JSON parser ADD parse JSON value fragment

New functionality allowing parsing only JSON values and adding them to
the nodes specified by path.

Author: Humblesaw

src/parser_data.h

@@ -336,6 +336,24 @@ LIBYANG_API_DECL LY_ERR lyd_parse_data_path(const struct ly_ctx *ctx, const char
 LIBYANG_API_DECL LY_ERR lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in,
         LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree);
 
+/**
+ * @brief Parse data from the input handler as a bare JSON value and connect it to the node parsed from the path.
+ *
+ * @param[in] ctx Context to connect with the tree being built here.
+ * @param[in] path Path to the node so the value in the input handler can be connected to it.
+ * @param[in] in Input handler with the value in the JSON format.
+ * @param[in] format Currently only LYD_JSON is supported.
+ * @param[in] new_val_options Options for new values, see @ref newvaloptions.
+ * @param[in] parse_options Options for parser, see @ref dataparseroptions.
+ * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
+ * @param[out] tree Full parsed data tree, note that NULL can be a valid tree.
+ * @return LY_SUCCESS in case of successful parsing.
+ * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
+ */
+LIBYANG_API_DECL LY_ERR lyd_parse_value_fragment(const struct ly_ctx *ctx, const char *path, struct ly_in *in,
+        LYD_FORMAT format, uint32_t new_val_options, uint32_t parse_options, uint32_t validate_options,
+        struct lyd_node **tree);
+
 /**
  * @ingroup datatree
  * @defgroup datatype Data operation type

src/parser_internal.h

@@ -286,19 +286,21 @@ LY_ERR lyd_parse_xml_netconf(const struct ly_ctx *ctx, const struct lysc_ext_ins
  * @param[in] ctx libyang context.
  * @param[in] ext Optional extension instance to parse data following the schema tree specified in the extension instance
  * @param[in] parent Parent to connect the parsed nodes to, if any.
+ * @param[in] schema Optional schema node of the parsed node (mandatory when parsing JSON value fragment).
  * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
  * @param[in] in Input structure.
  * @param[in] parse_opts Options for parser, see @ref dataparseroptions.
  * @param[in] val_opts Options for the validation phase, see @ref datavalidationoptions.
  * @param[in] int_opts Internal data parser options.
  * @param[out] parsed Set to add all the parsed siblings into.
  * @param[out] subtree_sibling Set if ::LYD_PARSE_SUBTREE is used and another subtree is following in @p in.
- * @param[out] lydctx_p Data parser context to finish validation.
+ * @param[out] lydctx_p Optional data parser context to finish validation.
  * @return LY_ERR value.
  */
 LY_ERR lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
-        struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, uint32_t int_opts,
-        struct ly_set *parsed, ly_bool *subtree_sibling, struct lyd_ctx **lydctx_p);
+        const struct lysc_node *schema, struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts,
+        uint32_t val_opts, uint32_t int_opts, struct ly_set *parsed, ly_bool *subtree_sibling,
+        struct lyd_ctx **lydctx_p);
 
 /**
  * @brief Parse JSON string as a RESTCONF message.

src/parser_json.c

@@ -935,7 +935,7 @@ lydjson_meta_attr(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, st
  */
 static void
 lydjson_maintain_children(struct lyd_node *parent, struct lyd_node **first_p, struct lyd_node **node_p, ly_bool last,
-        struct lysc_ext_instance *ext)
+        const struct lysc_ext_instance *ext)
 {
     if (!*node_p) {
         return;
@@ -1822,15 +1822,17 @@ lydjson_subtree_r(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct l
  * @brief Common start of JSON parser processing different types of the input data.
  *
  * @param[in] ctx libyang context
+ * @param[in] schema Schema node of the potential bare value to check.
  * @param[in] in Input structure.
  * @param[in] parse_opts Options for parser, see @ref dataparseroptions.
  * @param[in] val_opts Options for the validation phase, see @ref datavalidationoptions.
+ * @param[out] status_p Initial status of the input structure.
  * @param[out] lydctx_p Data parser context to finish validation.
  * @return LY_ERR value.
  */
 static LY_ERR
-lyd_parse_json_init(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts,
-        struct lyd_json_ctx **lydctx_p)
+lyd_parse_json_init(const struct ly_ctx *ctx, const struct lysc_node *schema, struct ly_in *in, uint32_t parse_opts,
+        uint32_t val_opts, enum LYJSON_PARSER_STATUS *status_p, struct lyd_json_ctx **lydctx_p)
 {
     LY_ERR ret = LY_SUCCESS;
     struct lyd_json_ctx *lydctx;
@@ -1849,28 +1851,44 @@ lyd_parse_json_init(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_o
     status = lyjson_ctx_status(lydctx->jsonctx);
 
     /* parse_opts & LYD_PARSE_SUBTREE not implemented */
-    if (status != LYJSON_OBJECT) {
-        /* expecting top-level object */
-        LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expected top-level JSON object, but %s found.", lyjson_token2str(status));
+    /* there are two options: either we want to parse a bare JSON value or a JSON object
+     * node of the bare JSON value has to have a schema, otherwise we do not know where to put the value
+     * the only types of nodes that can take on a value are a leaf (number, string or bool) and a leaf-list (array) */
+    if (schema &&
+            (((status == LYJSON_ARRAY) && (schema->nodetype & LYS_LEAFLIST)) ||
+            (((status == LYJSON_NUMBER) || (status == LYJSON_STRING) || (status == LYJSON_FALSE) ||
+            (status == LYJSON_TRUE) || (status == LYJSON_NULL) || (status == LYJSON_ARRAY)) && (schema->nodetype & LYS_LEAF)))) {
+        /* bare value (bare anydata 'value = object' is not supported) */
+    } else if (status == LYJSON_OBJECT) {
+        /* JSON object */
+    } else {
+        /* expecting top-level object or bare value */
+        LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expected top-level JSON object or correct bare value, but %s found.", lyjson_token2str(status));
         *lydctx_p = NULL;
         lyd_json_ctx_free((struct lyd_ctx *)lydctx);
         return LY_EVALID;
     }
 
     *lydctx_p = lydctx;
+    if (status_p) {
+        *status_p = status;
+    }
     return LY_SUCCESS;
 }
 
 LY_ERR
 lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
-        struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, uint32_t int_opts,
-        struct ly_set *parsed, ly_bool *subtree_sibling, struct lyd_ctx **lydctx_p)
+        const struct lysc_node *schema, struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts,
+        uint32_t val_opts, uint32_t int_opts, struct ly_set *parsed, ly_bool *subtree_sibling,
+        struct lyd_ctx **lydctx_p)
 {
     LY_ERR r, rc = LY_SUCCESS;
     struct lyd_json_ctx *lydctx = NULL;
-    enum LYJSON_PARSER_STATUS status;
+    enum LYJSON_PARSER_STATUS status = LYJSON_ERROR;
+    struct lyd_node *node = NULL;
+    const char *expected = NULL;
 
-    rc = lyd_parse_json_init(ctx, in, parse_opts, val_opts, &lydctx);
+    rc = lyd_parse_json_init(ctx, schema, in, parse_opts, val_opts, &status, &lydctx);
     LY_CHECK_GOTO(rc, cleanup);
 
     lydctx->int_opts = int_opts;
@@ -1879,17 +1897,88 @@ lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, st
     /* find the operation node if it exists already */
     LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup);
 
-    /* read subtree(s) */
-    do {
-        r = lydjson_subtree_r(lydctx, parent, first_p, parsed);
-        LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
+    if (status != LYJSON_OBJECT) {
+        /* parse bare JSON value */
+        assert(schema);
 
-        status = lyjson_ctx_status(lydctx->jsonctx);
+        /* this branch partly copies the behavior of lydjson_subtree_r() */
 
-        if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) {
+        /* set expected representation */
+        switch (schema->nodetype) {
+        case LYS_LEAFLIST:
+            expected = "array of values";
+            break;
+        case LYS_LEAF:
+            if (status == LYJSON_ARRAY) {
+                expected = "[null]";
+            } else {
+                expected = "value";
+            }
             break;
         }
-    } while (status == LYJSON_OBJECT_NEXT);
+
+        /* check the representation according to the nodetype and then continue with the content */
+        /* for now object values are not supported (anydata) */
+        /* for now extensions not supported */
+        switch (schema->nodetype) {
+        case LYS_LEAFLIST:
+            LY_CHECK_GOTO(status != LYJSON_ARRAY, representation_error);
+
+            /* process all the values/objects */
+            do {
+                /* move into array/next value */
+                r = lyjson_ctx_next(lydctx->jsonctx, &status);
+                LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
+                if (status == LYJSON_ARRAY_CLOSED) {
+                    /* empty array, fine... */
+                    break;
+                }
+
+                r = lydjson_parse_instance(lydctx, parent, first_p, schema, NULL, schema->name, strlen(schema->name),
+                        NULL, 0, &status, &node);
+                if (r == LY_ENOT) {
+                    goto representation_error;
+                }
+                LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
+
+                lydjson_maintain_children(parent, first_p, &node,
+                        lydctx->parse_opts & LYD_PARSE_ORDERED ? LYD_INSERT_NODE_LAST : LYD_INSERT_NODE_DEFAULT, NULL);
+
+                /* move after the item(s) */
+                r = lyjson_ctx_next(lydctx->jsonctx, &status);
+                LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
+            } while (status == LYJSON_ARRAY_NEXT);
+
+            break;
+        case LYS_LEAF:
+            /* process the value/object */
+            r = lydjson_parse_instance(lydctx, parent, first_p, schema, NULL, schema->name, strlen(schema->name),
+                    NULL, 0, &status, &node);
+            if (r == LY_ENOT) {
+                goto representation_error;
+            }
+            LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
+
+            /* finally connect the parsed node, is zeroed */
+            lydjson_maintain_children(parent, first_p, &node,
+                    lydctx->parse_opts & LYD_PARSE_ORDERED ? LYD_INSERT_NODE_LAST : LYD_INSERT_NODE_DEFAULT, NULL);
+            break;
+        }
+    } else {
+        /* parse JSON object */
+
+        /* read subtree(s) */
+        do {
+            r = lydjson_subtree_r(lydctx, parent, first_p, parsed);
+            LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
+
+            status = lyjson_ctx_status(lydctx->jsonctx);
+
+            if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) {
+                break;
+            }
+        } while (status == LYJSON_OBJECT_NEXT);
+    }
 
     if ((int_opts & LYD_INTOPT_NO_SIBLINGS) && lydctx->jsonctx->in->current[0] && (status != LYJSON_OBJECT_CLOSED)) {
         LOGVAL(ctx, LYVE_SYNTAX, "Unexpected sibling node.");
@@ -1919,6 +2008,13 @@ lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, st
         }
     }
 
+    goto cleanup;
+
+representation_error:
+    LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expecting JSON %s but %s \"%s\" is represented in input data as %s.",
+            expected, lys_nodetype2str(schema->nodetype), schema->name, lyjson_token2str(status));
+    rc = LY_EVALID;
+
 cleanup:
     /* there should be no unresolved types stored */
     assert(!(parse_opts & LYD_PARSE_ONLY) || !lydctx || (!lydctx->node_types.count && !lydctx->meta_types.count &&
@@ -1927,12 +2023,19 @@ lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, st
     if (rc && (!lydctx || !(lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR) || (rc != LY_EVALID))) {
         lyd_json_ctx_free((struct lyd_ctx *)lydctx);
     } else {
-        *lydctx_p = (struct lyd_ctx *)lydctx;
-
         /* the JSON context is no more needed, freeing it also stops logging line numbers which would be confusing now */
         lyjson_ctx_free(lydctx->jsonctx);
         lydctx->jsonctx = NULL;
+
+        /* set optional lydctx pointer, otherwise free */
+        if (lydctx_p) {
+            *lydctx_p = (struct lyd_ctx *)lydctx;
+        } else {
+            lyd_json_ctx_free((struct lyd_ctx *)lydctx);
+        }
     }
+
+    lyd_free_tree(node);
     return rc;
 }
 
@@ -2020,7 +2123,7 @@ lyd_parse_json_restconf(const struct ly_ctx *ctx, const struct lysc_ext_instance
     assert(!(parse_opts & LYD_PARSE_SUBTREE));
 
     /* init context */
-    rc = lyd_parse_json_init(ctx, in, parse_opts, val_opts, &lydctx);
+    rc = lyd_parse_json_init(ctx, NULL, in, parse_opts, val_opts, NULL, &lydctx);
     LY_CHECK_GOTO(rc, cleanup);
     lydctx->ext = ext;
 

src/tree_data.c

@@ -130,7 +130,7 @@ lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct
                 &subtree_sibling, &lydctx);
         break;
     case LYD_JSON:
-        r = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
+        r = lyd_parse_json(ctx, ext, parent, NULL, first_p, in, parse_opts, val_opts, int_opts, &parsed,
                 &subtree_sibling, &lydctx);
         break;
     case LYD_LYB:
@@ -279,6 +279,75 @@ lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT forma
     return ret;
 }
 
+LIBYANG_API_DEF LY_ERR
+lyd_parse_value_fragment(const struct ly_ctx *ctx, const char *path, struct ly_in *in, LYD_FORMAT format,
+        uint32_t new_val_options, uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
+{
+    LY_ERR ret = LY_SUCCESS;
+    struct lyxp_expr *exp = NULL;
+    struct ly_path *p = NULL;
+    struct lyd_node *new_parent = NULL, *top_level = NULL;
+    const struct lysc_node *new_node_schema = NULL;
+    struct ly_set parsed = {0};
+    ly_bool p_decremented = 0;
+
+    assert(ctx);
+    assert(path && (path[0] == '/'));
+
+    /* other formats are not supported for now */
+    assert(format == LYD_JSON);
+
+    /* parse path */
+    LY_CHECK_GOTO(ret = ly_path_parse(ctx, NULL, path, 0, 0, LY_PATH_BEGIN_EITHER, LY_PATH_PREFIX_FIRST,
+            LY_PATH_PRED_SIMPLE, &exp), cleanup);
+
+    /* compile path */
+    LY_CHECK_GOTO(ret = ly_path_compile(ctx, NULL, NULL, NULL, exp, new_val_options & LYD_NEW_VAL_OUTPUT ?
+            LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p), cleanup);
+
+    /* has to have a schema */
+    new_node_schema = p[LY_ARRAY_COUNT(p) - 1].node;
+
+    /* you cannot set a key */
+    if (lysc_is_key(new_node_schema)) {
+        LOGERR(ctx, LY_EINVAL, "Invalid argument: path: %s ends with a key (%s())", path, __func__);
+        goto cleanup;
+    }
+
+    /* only the term nodes get their path shortened */
+    if (new_node_schema->nodetype & LYD_NODE_TERM) {
+        /* shorten the ly_path by one element (to avoid a leaflist without predicate at the end) */
+        LY_ARRAY_DECREMENT(p);
+        p_decremented = 1;
+    }
+
+    if (LY_ARRAY_COUNT(p)) {
+        /* create nodes */
+        LY_CHECK_GOTO(ret = lyd_new_path_create(NULL, ctx, NULL, p, path, NULL, 0, 0, new_val_options, &top_level,
+                &new_parent), cleanup);
+    }
+
+    /* parse the json value */
+    LY_CHECK_GOTO(ret = lyd_parse_json(ctx, NULL, new_parent, new_node_schema, new_parent ? NULL : &top_level, in,
+            parse_options, validate_options, 0, &parsed, NULL, NULL), cleanup);
+
+    /* set output tree */
+    if (tree) {
+        *tree = top_level;
+    }
+
+cleanup:
+    lyxp_expr_free(exp);
+    if (p_decremented) {
+        LY_ARRAY_INCREMENT(p);
+    }
+    ly_path_free(p);
+    if (ret) {
+        lyd_free_all(top_level);
+    }
+    return ret;
+}
+
 /**
  * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
  * for schema nodes locked inside the extension instance.
@@ -401,7 +470,7 @@ lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, str
         rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
         break;
     case LYD_JSON:
-        rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
+        rc = lyd_parse_json(ctx, ext, parent, NULL, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
         break;
     case LYD_LYB:
         rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);