plugins ext UPDATE custom XPath root ext plugin API

Required for the 'structure' extension. Major
ext plugin API refactoring included.

Author: michalvasko

src/parser_common.c

@@ -64,7 +64,6 @@ lyd_ctx_free(struct lyd_ctx *lydctx)
     ly_set_erase(&lydctx->node_types, NULL);
     ly_set_erase(&lydctx->meta_types, NULL);
     ly_set_erase(&lydctx->node_when, NULL);
-    ly_set_erase(&lydctx->ext_node, free);
     ly_set_erase(&lydctx->ext_val, free);
     lyd_val_getnext_ht_free(lydctx->val_getnext_ht);
 }
@@ -304,8 +303,8 @@ lyd_parser_create_term(struct lyd_ctx *lydctx, const struct lysc_node *schema, c
     ly_bool incomplete;
     ly_bool store_only = (lydctx->parse_opts & LYD_PARSE_STORE_ONLY) == LYD_PARSE_STORE_ONLY ? 1 : 0;
 
-    if ((r = lyd_create_term(schema, value, value_bits_len, 1, store_only, dynamic, format, prefix_data,
-            hints, &incomplete, node))) {
+    if ((r = lyd_create_term(schema, value, value_bits_len, 1, store_only, dynamic, format, prefix_data, hints,
+            lydctx->ext, &incomplete, node))) {
         if (lydctx->data_ctx->ctx != schema->module->ctx) {
             /* move errors to the main context */
             ly_err_move(schema->module->ctx, (struct ly_ctx *)lydctx->data_ctx->ctx);
@@ -344,7 +343,7 @@ lyd_parser_create_meta(struct lyd_ctx *lydctx, struct lyd_node *parent, struct l
     ly_log_location(NULL, NULL, path, NULL);
 
     LY_CHECK_GOTO(rc = lyd_create_meta(parent, meta, mod, name, name_len, value, value_size_bits, 1, store_only,
-            dynamic, format, prefix_data, hints, ctx_node, 0, &incomplete), cleanup);
+            dynamic, format, prefix_data, hints, ctx_node, lydctx->ext, 0, &incomplete), cleanup);
 
     if (incomplete && !(lydctx->parse_opts & LYD_PARSE_ONLY)) {
         LY_CHECK_GOTO(rc = ly_set_add(&lydctx->meta_types, *meta, 1, NULL), cleanup);
@@ -468,9 +467,8 @@ lyd_parser_validate_new_implicit(struct lyd_ctx *lydctx, struct lyd_node *node)
     LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
 
     /* add any missing default children */
-    r = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, &lydctx->node_when, &lydctx->node_types,
-            &lydctx->ext_node, (lydctx->val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0,
-            lydctx->val_getnext_ht, NULL);
+    r = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, lydctx->ext, &lydctx->node_when, &lydctx->node_types,
+            (lydctx->val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, lydctx->val_getnext_ht, NULL);
     LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
 
 cleanup:

src/parser_data.h

@@ -478,6 +478,21 @@ LIBYANG_API_DECL LY_ERR lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *
 LIBYANG_API_DECL LY_ERR lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in,
         LYD_FORMAT format, enum lyd_type data_type, uint32_t parse_options, struct lyd_node **tree, struct lyd_node **op);
 
+/**
+ * @brief Validate a data subtree of an extension instance, which is assumed to be a separate data tree independent of
+ * normal YANG data.
+ *
+ * @param[in,out] subtree Data subtree to validate. May be changed by validation, might become NULL.
+ * @param[in] ext Extension instance whose data to validate.
+ * @param[in] val_opts Validation options (@ref datavalidationoptions).
+ * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
+ * @param[out] diff Optional diff with any changes made by the validation.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR error on error.
+ */
+LIBYANG_API_DECL LY_ERR lyd_validate_ext(struct lyd_node **ext_tree, const struct lysc_ext_instance *ext,
+        uint32_t val_opts, const struct lyd_node *dep_tree, struct lyd_node **diff);
+
 /**
  * @brief Fully validate a data tree.
  *

src/parser_internal.h

@@ -62,8 +62,9 @@ typedef void (*lyd_ctx_free_clb)(struct lyd_ctx *ctx);
 #define LYD_INTOPT_NOTIF            0x08    /**< Notification is being parsed. */
 #define LYD_INTOPT_ANY              0x10    /**< Anydata/anyxml content is being parsed, there can be anything. */
 #define LYD_INTOPT_WITH_SIBLINGS    0x20    /**< Parse the whole input with any siblings. */
-#define LYD_INTOPT_NO_SIBLINGS      0x40    /**< If there are any siblings, return an error. */
-#define LYD_INTOPT_EVENTTIME        0x80    /**< Parse notification eventTime node. */
+#define LYD_INTOPT_SKIP_SIBLINGS    0x40    /**< Perform the validation task only for the specfic subtree, skip other siblings. */
+#define LYD_INTOPT_NO_SIBLINGS      0x80    /**< If there are any siblings, return an error. */
+#define LYD_INTOPT_EVENTTIME        0x0100  /**< Parse notification eventTime node. */
 
 /**
  * @brief Internal (common) context for YANG data parsers.
@@ -82,7 +83,6 @@ struct lyd_ctx {
     struct ly_set node_when;       /**< set of nodes with "when" conditions */
     struct ly_set node_types;      /**< set of nodes validated with LY_EINCOMPLETE result */
     struct ly_set meta_types;      /**< set of metadata validated with LY_EINCOMPLETE result */
-    struct ly_set ext_node;        /**< set of nodes with extension instances to validate */
     struct ly_set ext_val;         /**< set of nested subtrees parsed by extensions to validate */
     struct lyd_node *op_node;      /**< if an RPC/action/notification is being parsed, store the pointer to it */
     const struct lys_module *val_getnext_ht_mod;    /**< module of the cached schema nodes in getnext HT */
@@ -111,7 +111,6 @@ struct lyd_xml_ctx {
     struct ly_set node_when;
     struct ly_set node_types;
     struct ly_set meta_types;
-    struct ly_set ext_node;
     struct ly_set ext_val;
     struct lyd_node *op_node;
     const struct lys_module *val_getnext_ht_mod;
@@ -136,7 +135,6 @@ struct lyd_json_ctx {
     struct ly_set node_when;
     struct ly_set node_types;
     struct ly_set meta_types;
-    struct ly_set ext_node;
     struct ly_set ext_val;
     struct lyd_node *op_node;
     const struct lys_module *val_getnext_ht_mod;
@@ -168,7 +166,6 @@ struct lyd_lyb_ctx {
     struct ly_set node_when;
     struct ly_set node_types;
     struct ly_set meta_types;
-    struct ly_set ext_node;
     struct ly_set ext_val;
     struct lyd_node *op_node;
     const struct lys_module *val_getnext_ht_mod;
@@ -191,14 +188,6 @@ struct lyd_ctx_ext_val {
     struct lyd_node *sibling;
 };
 
-/**
- * @brief Parsed data node with extension instance to validate.
- */
-struct lyd_ctx_ext_node {
-    struct lysc_ext_instance *ext;
-    struct lyd_node *node;
-};
-
 /**
  * @brief Common part to supplement the specific ::lyd_ctx_free_clb callbacks.
  */

src/parser_json.c

@@ -460,7 +460,8 @@ lydjson_check_list(struct lyd_json_ctx *lydctx, const struct lysc_node *list)
 
                     rc = lydjson_value_type_hint(lydctx, &status, &hints);
                     LY_CHECK_GOTO(rc, cleanup);
-                    rc = ly_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len * 8, LY_VALUE_JSON, NULL, hints);
+                    rc = ly_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len * 8, LY_VALUE_JSON, NULL,
+                            hints, lydctx->ext);
                     LY_CHECK_GOTO(rc, cleanup);
 
                     /* key with a valid value, remove from the set */
@@ -533,7 +534,8 @@ lydjson_data_check_opaq(struct lyd_json_ctx *lydctx, const struct lysc_node *sno
             }
 
             prev_lo = ly_temp_log_options(&temp_lo);
-            if (ly_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len * 8, LY_VALUE_JSON, NULL, *type_hint_p)) {
+            if (ly_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len * 8, LY_VALUE_JSON, NULL,
+                    *type_hint_p, lydctx->ext)) {
                 ret = LY_ENOT;
             }
             ly_temp_log_options(prev_lo);
@@ -1538,12 +1540,6 @@ lydjson_parse_instance(struct lyd_json_ctx *lydctx, struct lyd_node *parent, str
         /* add/correct flags */
         r = lyd_parser_set_data_flags(*node, &(*node)->meta, (struct lyd_ctx *)lydctx, ext);
         LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
-
-        if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) {
-            /* store for ext instance node validation, if needed */
-            r = lyd_validate_node_ext(*node, &lydctx->ext_node);
-            LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
-        }
     } else if (r == LY_ENOT) {
         /* parse it again as an opaq node */
         r = lydjson_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status, status, first_p, node);

src/parser_lyb.c

@@ -936,11 +936,6 @@ lyb_finish_node(struct lyd_lyb_ctx *lybctx, struct lyd_node *parent, uint32_t fl
     /* insert into parent */
     lyb_insert_node(lybctx, parent, *node, first_p, parsed);
 
-    if (!(lybctx->parse_opts & LYD_PARSE_ONLY)) {
-        /* store for ext instance node validation, if needed */
-        (void)lyd_validate_node_ext(*node, &lybctx->ext_node);
-    }
-
     *node = NULL;
 }
 

src/parser_xml.c

@@ -274,9 +274,10 @@ lydxml_attrs(struct lyxml_ctx *xmlctx, struct lyd_attr **attr)
 }
 
 static LY_ERR
-lydxml_check_list(struct lyxml_ctx *xmlctx, const struct lysc_node *list)
+lydxml_check_list(struct lyd_xml_ctx *lydctx, const struct lysc_node *list)
 {
     LY_ERR ret = LY_SUCCESS, r;
+    struct lyxml_ctx *xmlctx = lydctx->xmlctx;
     enum LYXML_PARSER_STATUS next;
     struct ly_set key_set = {0};
     const struct lysc_node *snode;
@@ -314,7 +315,8 @@ lydxml_check_list(struct lyxml_ctx *xmlctx, const struct lysc_node *list)
         assert(xmlctx->status == LYXML_ELEM_CONTENT);
         if (i < key_set.count) {
             /* validate the value */
-            r = ly_value_validate(NULL, snode, xmlctx->value, xmlctx->value_len * 8, LY_VALUE_XML, &xmlctx->ns, LYD_HINT_DATA);
+            r = ly_value_validate(NULL, snode, xmlctx->value, xmlctx->value_len * 8, LY_VALUE_XML, &xmlctx->ns,
+                    LYD_HINT_DATA, lydctx->ext);
             if (!r) {
                 /* key with a valid value, remove from the set */
                 ly_set_rm_index(&key_set, i, NULL);
@@ -422,7 +424,8 @@ lydxml_data_check_opaq(struct lyd_xml_ctx *lydctx, const struct lysc_node **snod
     if ((*snode)->nodetype & LYD_NODE_TERM) {
         /* value may not be valid in which case we parse it as an opaque node */
         prev_lo = ly_temp_log_options(&temp_lo);
-        r = ly_value_validate(NULL, *snode, xmlctx->value, xmlctx->value_len * 8, LY_VALUE_XML, &xmlctx->ns, LYD_HINT_DATA);
+        r = ly_value_validate(NULL, *snode, xmlctx->value, xmlctx->value_len * 8, LY_VALUE_XML, &xmlctx->ns,
+                LYD_HINT_DATA, lydctx->ext);
         ly_temp_log_options(prev_lo);
         if (r) {
             LOGVRB("Parsing opaque term node \"%s\" with invalid value \"%.*s\".", (*snode)->name, (int)xmlctx->value_len,
@@ -433,7 +436,7 @@ lydxml_data_check_opaq(struct lyd_xml_ctx *lydctx, const struct lysc_node **snod
         /* skip content */
         LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), restore);
 
-        if (lydxml_check_list(xmlctx, *snode)) {
+        if (lydxml_check_list(lydctx, *snode)) {
             /* invalid list, parse as opaque if it missing/has invalid some keys */
             LOGVRB("Parsing opaque list node \"%s\" with missing/invalid keys.", (*snode)->name);
             *snode = NULL;
@@ -1108,12 +1111,6 @@ lydxml_subtree_r(struct lyd_xml_ctx *lydctx, struct lyd_node *parent, struct lyd
         /* add/correct flags */
         r = lyd_parser_set_data_flags(node, &meta, (struct lyd_ctx *)lydctx, ext);
         LY_CHECK_ERR_GOTO(r, rc = r; lyd_free_tree(node), cleanup);
-
-        if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) {
-            /* store for ext instance node validation, if needed */
-            r = lyd_validate_node_ext(node, &lydctx->ext_node);
-            LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
-        }
     }
 
     /* parser next */

src/path.c

@@ -643,8 +643,8 @@ ly_path_compile_snode(const struct ly_ctx *ctx, const struct lysc_node *cur_node
 
 LY_ERR
 ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
-        const struct lysc_node *ctx_node, const struct lyxp_expr *expr, uint32_t *tok_idx, LY_VALUE_FORMAT format,
-        void *prefix_data, struct ly_path_predicate **predicates)
+        const struct lysc_node *ctx_node, const struct lysc_ext_instance *top_ext, const struct lyxp_expr *expr,
+        uint32_t *tok_idx, LY_VALUE_FORMAT format, void *prefix_data, struct ly_path_predicate **predicates)
 {
     LY_ERR rc = LY_SUCCESS, r;
     struct ly_path_predicate *p;
@@ -716,7 +716,8 @@ ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_
 
                 /* do not store the canonical value, only validate */
                 LOG_LOCSET(key, NULL);
-                r = lyd_value_validate2(ctx_node->module->ctx, key, val, val_len, format, prefix_data, NULL, NULL, &p->value);
+                r = lyd_value_validate2(ctx_node->module->ctx, key, val, val_len, format, prefix_data, NULL, top_ext,
+                        NULL, &p->value);
                 LOG_LOCBACK(1, 0);
                 LY_CHECK_ERR_GOTO(r && (r != LY_EINCOMPLETE), rc = r, cleanup);
 
@@ -774,7 +775,8 @@ ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_
 
         /* do not store the value, only validate */
         LOG_LOCSET(ctx_node, NULL);
-        r = lyd_value_validate2(ctx_node->module->ctx, ctx_node, val, val_len, format, prefix_data, NULL, NULL, &p->value);
+        r = lyd_value_validate2(ctx_node->module->ctx, ctx_node, val, val_len, format, prefix_data, NULL, top_ext, NULL,
+                &p->value);
         LOG_LOCBACK(1, 0);
         LY_CHECK_ERR_GOTO(r && (r != LY_EINCOMPLETE), rc = r, cleanup);
 
@@ -1187,6 +1189,8 @@ _ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, con
 
     if (oper == LY_PATH_OPER_OUTPUT) {
         getnext_opts = LYS_GETNEXT_OUTPUT;
+    } else if (top_ext) {
+        getnext_opts = LYS_GETNEXT_EXT_XPATH;
     } else {
         getnext_opts = 0;
     }
@@ -1263,7 +1267,7 @@ _ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, con
         if (lref) {
             rc = ly_path_compile_predicate_leafref(ctx_node, cur_node, expr, &tok_idx, format, prefix_data);
         } else {
-            rc = ly_path_compile_predicate(ctx, cur_node, cur_mod, ctx_node, expr, &tok_idx, format, prefix_data,
+            rc = ly_path_compile_predicate(ctx, cur_node, cur_mod, ctx_node, top_ext, expr, &tok_idx, format, prefix_data,
                     &p->predicates);
         }
         LY_CHECK_GOTO(rc, cleanup);
@@ -1314,7 +1318,7 @@ ly_path_compile_leafref(const struct ly_ctx *ctx, const struct lysc_node *ctx_no
 
 LY_ERR
 ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, const struct lyxp_var *vars,
-        ly_bool with_opaq, LY_ARRAY_COUNT_TYPE *path_idx, struct lyd_node **match)
+        const struct lysc_ext_instance *top_ext, ly_bool with_opaq, LY_ARRAY_COUNT_TYPE *path_idx, struct lyd_node **match)
 {
     LY_ARRAY_COUNT_TYPE u;
     struct lyd_node *prev_node = NULL, *elem, *node = NULL, *target;
@@ -1352,14 +1356,16 @@ ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, c
                 break;
             case LY_PATH_PREDTYPE_LEAFLIST:
                 /* we will use hashes to find one leaf-list instance */
-                LY_CHECK_RET(lyd_create_term_canon(path[u].node, path[u].predicates[0].value, &target));
+                LY_CHECK_RET(lyd_create_term(path[u].node, path[u].predicates[0].value,
+                        strlen(path[u].predicates[0].value) * 8, 1, 1, NULL, LY_VALUE_CANON, NULL, LYD_HINT_DATA,
+                        top_ext, NULL, &target));
                 lyd_find_sibling_first(start, target, &node);
                 lyd_free_tree(target);
                 break;
             case LY_PATH_PREDTYPE_LIST_VAR:
             case LY_PATH_PREDTYPE_LIST:
                 /* we will use hashes to find one list instance */
-                LY_CHECK_RET(lyd_create_list(path[u].node, path[u].predicates, vars, 1, &target));
+                LY_CHECK_RET(lyd_create_list(path[u].node, path[u].predicates, vars, 1, top_ext, &target));
                 lyd_find_sibling_first(start, target, &node);
                 lyd_free_tree(target);
                 break;
@@ -1419,12 +1425,13 @@ ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, c
 }
 
 LY_ERR
-ly_path_eval(const struct ly_path *path, const struct lyd_node *start, const struct lyxp_var *vars, struct lyd_node **match)
+ly_path_eval(const struct ly_path *path, const struct lyd_node *start, const struct lyxp_var *vars,
+        const struct lysc_ext_instance *top_ext, struct lyd_node **match)
 {
     LY_ERR ret;
     struct lyd_node *m;
 
-    ret = ly_path_eval_partial(path, start, vars, 0, NULL, &m);
+    ret = ly_path_eval_partial(path, start, vars, top_ext, 0, NULL, &m);
 
     if (ret == LY_SUCCESS) {
         /* last node was found */

src/path.h

@@ -213,6 +213,7 @@ LY_ERR ly_path_compile_leafref(const struct ly_ctx *ctx, const struct lysc_node
  * @param[in] cur_mod Current module of the path (where it was "instantiated"). Used for nodes without a prefix
  * for ::LY_VALUE_SCHEMA and ::LY_VALUE_SCHEMA_RESOLVED format.
  * @param[in] ctx_node Context node, node for which the predicate is defined.
+ * @param[in] top_ext Extension instance containing the definition of the data being created.
  * @param[in] expr Parsed path.
  * @param[in,out] tok_idx Index in @p expr, is adjusted for parsed tokens.
  * @param[in] format Format of the path.
@@ -221,15 +222,16 @@ LY_ERR ly_path_compile_leafref(const struct ly_ctx *ctx, const struct lysc_node
  * @return LY_ERR value.
  */
 LY_ERR ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
-        const struct lysc_node *ctx_node, const struct lyxp_expr *expr, uint32_t *tok_idx, LY_VALUE_FORMAT format,
-        void *prefix_data, struct ly_path_predicate **predicates);
+        const struct lysc_node *ctx_node, const struct lysc_ext_instance *top_ext, const struct lyxp_expr *expr,
+        uint32_t *tok_idx, LY_VALUE_FORMAT format, void *prefix_data, struct ly_path_predicate **predicates);
 
 /**
  * @brief Resolve at least partially the target defined by ly_path structure. Not supported for leafref!
  *
  * @param[in] path Path structure specifying the target.
  * @param[in] start Starting node for relative paths, can be any for absolute paths.
  * @param[in] vars Array of defined variables to use in predicates, may be NULL.
+ * @param[in] top_ext Extension instance containing the definition of the data being created.
  * @param[in] with_opaq Whether to consider opaque nodes or not.
  * @param[out] path_idx Last found path segment index, can be NULL, set to 0 if not found.
  * @param[out] match Last found matching node, can be NULL, set to NULL if not found.
@@ -239,21 +241,22 @@ LY_ERR ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_nod
  * @return LY_ERR on another error.
  */
 LY_ERR ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, const struct lyxp_var *vars,
-        ly_bool with_opaq, LY_ARRAY_COUNT_TYPE *path_idx, struct lyd_node **match);
+        const struct lysc_ext_instance *top_ext, ly_bool with_opaq, LY_ARRAY_COUNT_TYPE *path_idx, struct lyd_node **match);
 
 /**
  * @brief Resolve the target defined by ly_path structure. Not supported for leafref!
  *
  * @param[in] path Path structure specifying the target.
  * @param[in] start Starting node for relative paths, can be any for absolute paths.
  * @param[in] vars Array of defined variables to use in predicates, may be NULL.
+ * @param[in] top_ext Extension instance containing the definition of the data being created.
  * @param[out] match Found matching node, can be NULL, set to NULL if not found.
  * @return LY_ENOTFOUND if no nodes were found,
  * @return LY_SUCCESS when the last node in the path was found,
  * @return LY_ERR on another error.
  */
 LY_ERR ly_path_eval(const struct ly_path *path, const struct lyd_node *start, const struct lyxp_var *vars,
-        struct lyd_node **match);
+        const struct lysc_ext_instance *top_ext, struct lyd_node **match);
 
 /**
  * @brief Duplicate ly_path structure.