schema tree CHANGE add xpath_dep flags for specific msut and when also

michalvasko · michalvasko · commit 0b963116be72 · 2017-08-11T12:45:36.000+02:00
In addition to the flag being present on the node itself.
diff --git a/src/resolve.c b/src/resolve.c
@@ -4052,9 +4052,8 @@ resolve_instid_predicate(const struct lys_module *prev_mod, const char *pred, st
 int
 lys_check_xpath(struct lys_node *node, int check_place, int warn_on_fwd_ref)
 {
-    struct lys_node *parent, *elem;
+    struct lys_node *parent;
     struct lyxp_set set;
-    uint32_t i;
     int ret;
 
     if (check_place) {
@@ -4077,33 +4076,11 @@ lys_check_xpath(struct lys_node *node, int check_place, int warn_on_fwd_ref)
         }
     }
 
-    ret = lyxp_node_atomize(node, &set, warn_on_fwd_ref);
+    ret = lyxp_node_atomize(node, &set, warn_on_fwd_ref, 1);
     if (ret == -1) {
         return -1;
     }
 
-    for (parent = node; parent && !(parent->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); parent = lys_parent(parent));
-
-    for (i = 0; i < set.used; ++i) {
-        /* skip roots'n'stuff */
-        if (set.val.snodes[i].type == LYXP_NODE_ELEM) {
-            /* XPath expression cannot reference "lower" status than the node that has the definition */
-            if (lyp_check_status(node->flags, lys_node_module(node), node->name, set.val.snodes[i].snode->flags,
-                    lys_node_module(set.val.snodes[i].snode), set.val.snodes[i].snode->name, node)) {
-                return -1;
-            }
-
-            if (parent) {
-                for (elem = set.val.snodes[i].snode; elem && (elem != parent); elem = lys_parent(elem));
-                if (!elem) {
-                    /* not in node's RPC or notification subtree, set the flag */
-                    node->flags |= LYS_XPATH_DEP;
-                    break;
-                }
-            }
-        }
-    }
-
     free(set.val.snodes);
     return ret;
 }
@@ -5554,7 +5531,6 @@ resolve_list_keys(struct lys_node_list *list, const char *keys_str)
 static int
 resolve_must(struct lyd_node *node, int inout_parent, int ignore_fail)
 {
-    int node_flags;
     uint8_t i, must_size;
     struct lys_node *schema;
     struct lys_restr *must;
@@ -5574,8 +5550,6 @@ resolve_must(struct lyd_node *node, int inout_parent, int ignore_fail)
         must_size = ((struct lys_node_inout *)schema)->must_size;
         must = ((struct lys_node_inout *)schema)->must;
 
-        node_flags = schema->flags;
-
         /* context node is the RPC/action */
         node = node->parent;
         if (!(node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
@@ -5613,8 +5587,6 @@ resolve_must(struct lyd_node *node, int inout_parent, int ignore_fail)
             must_size = 0;
             break;
         }
-
-        node_flags = node->schema->flags;
     }
 
     for (i = 0; i < must_size; ++i) {
@@ -5625,7 +5597,7 @@ resolve_must(struct lyd_node *node, int inout_parent, int ignore_fail)
         lyxp_set_cast(&set, LYXP_SET_BOOLEAN, node, lyd_node_module(node), LYXP_MUST);
 
         if (!set.val.bool) {
-            if ((ignore_fail == 1) || ((node_flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
+            if ((ignore_fail == 1) || ((must[i].flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
                 LOGVRB("Must condition \"%s\" not satisfied, but it is not required.", must[i].expr);
             } else {
                 LOGVAL(LYE_NOMUST, LY_VLOG_LYD, node, must[i].expr);
@@ -5979,12 +5951,12 @@ resolve_applies_when(const struct lys_node *schema, int mode, const struct lys_n
  *
  * @return
  *  -1 - error, ly_errno is set
- *   0 - true "when" statement
- *   0, ly_vecode = LYVE_NOWHEN - false "when" statement
+ *   0 - all "when" statements true
+ *   0, ly_vecode = LYVE_NOWHEN - some "when" statement false, returned in failed_when
  *   1, ly_vecode = LYVE_INWHEN - nodes needed to resolve are conditional and not yet resolved (under another "when")
  */
 int
-resolve_when(struct lyd_node *node, int ignore_fail)
+resolve_when(struct lyd_node *node, int ignore_fail, struct lys_when **failed_when)
 {
     struct lyd_node *ctx_node = NULL, *unlinked_nodes, *tmp_node;
     struct lys_node *sparent;
@@ -6012,11 +5984,15 @@ resolve_when(struct lyd_node *node, int ignore_fail)
         lyxp_set_cast(&set, LYXP_SET_BOOLEAN, node, lyd_node_module(node), LYXP_WHEN);
         if (!set.val.bool) {
             node->when_status |= LYD_WHEN_FALSE;
-            if ((ignore_fail == 1) || ((node->schema->flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
+            if ((ignore_fail == 1)
+                    || ((((struct lys_node_container *)node->schema)->when->flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
                 LOGVRB("When condition \"%s\" is not satisfied, but it is not required.",
                        ((struct lys_node_container *)node->schema)->when->cond);
             } else {
                 LOGVAL(LYE_NOWHEN, LY_VLOG_LYD, node, ((struct lys_node_container *)node->schema)->when->cond);
+                if (failed_when) {
+                    *failed_when = ((struct lys_node_container *)node->schema)->when;
+                }
                 goto cleanup;
             }
         }
@@ -6066,12 +6042,16 @@ resolve_when(struct lyd_node *node, int ignore_fail)
 
             lyxp_set_cast(&set, LYXP_SET_BOOLEAN, ctx_node, lys_node_module(sparent), LYXP_WHEN);
             if (!set.val.bool) {
-                if ((ignore_fail == 1) || ((sparent->flags & LYS_XPATH_DEP) || (ignore_fail == 2))) {
+                if ((ignore_fail == 1)
+                        || ((((struct lys_node_uses *)sparent)->when->flags & LYS_XPATH_DEP) || (ignore_fail == 2))) {
                     LOGVRB("When condition \"%s\" is not satisfied, but it is not required.",
                         ((struct lys_node_uses *)sparent)->when->cond);
                 } else {
                     node->when_status |= LYD_WHEN_FALSE;
                     LOGVAL(LYE_NOWHEN, LY_VLOG_LYD, node, ((struct lys_node_uses *)sparent)->when->cond);
+                    if (failed_when) {
+                        *failed_when = ((struct lys_node_uses *)sparent)->when;
+                    }
                     goto cleanup;
                 }
             }
@@ -6120,11 +6100,15 @@ resolve_when(struct lyd_node *node, int ignore_fail)
             lyxp_set_cast(&set, LYXP_SET_BOOLEAN, ctx_node, lys_node_module(sparent->parent), LYXP_WHEN);
             if (!set.val.bool) {
                 node->when_status |= LYD_WHEN_FALSE;
-                if ((ignore_fail == 1) || ((sparent->parent->flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
+                if ((ignore_fail == 1)
+                        || ((((struct lys_node_augment *)sparent->parent)->when->flags & LYS_XPATH_DEP) && (ignore_fail == 2))) {
                     LOGVRB("When condition \"%s\" is not satisfied, but it is not required.",
                            ((struct lys_node_augment *)sparent->parent)->when->cond);
                 } else {
                     LOGVAL(LYE_NOWHEN, LY_VLOG_LYD, node, ((struct lys_node_augment *)sparent->parent)->when->cond);
+                    if (failed_when) {
+                        *failed_when = ((struct lys_node_augment *)sparent->parent)->when;
+                    }
                     goto cleanup;
                 }
             }
@@ -7586,7 +7570,7 @@ resolve_union(struct lyd_node_leaf_list *leaf, struct lys_type *type, int store,
  * @return EXIT_SUCCESS on success, EXIT_FAILURE on forward reference, -1 on error.
  */
 int
-resolve_unres_data_item(struct lyd_node *node, enum UNRES_ITEM type, int ignore_fail)
+resolve_unres_data_item(struct lyd_node *node, enum UNRES_ITEM type, int ignore_fail, struct lys_when **failed_when)
 {
     int rc, req_inst, ext_dep;
     struct lyd_node_leaf_list *leaf;
@@ -7661,7 +7645,7 @@ resolve_unres_data_item(struct lyd_node *node, enum UNRES_ITEM type, int ignore_
         return resolve_union(leaf, &sleaf->type, 1, ignore_fail, NULL);
 
     case UNRES_WHEN:
-        if ((rc = resolve_when(node, ignore_fail))) {
+        if ((rc = resolve_when(node, ignore_fail, failed_when))) {
             return rc;
         }
         break;
@@ -7737,6 +7721,7 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
     uint32_t i, j, first, resolved, del_items, stmt_count;
     int rc, progress, ignore_fail;
     struct lyd_node *parent;
+    struct lys_when *when;
 
     assert(root);
     assert(unres);
@@ -7791,12 +7776,12 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
                 continue;
             }
 
-            rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail);
+            rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail, &when);
             if (!rc) {
-                /* finish with error/delete the node only if when was false, an external dependency was required,
-                 * and it was not provided (the flag would not be passed down otherwise, checked in upper fucntions) */
+                /* finish with error/delete the node only if when was false, an external dependency was not required,
+                 * or it was not provided (the flag would not be passed down otherwise, checked in upper functions) */
                 if ((unres->node[i]->when_status & LYD_WHEN_FALSE)
-                        && (!(unres->node[i]->schema->flags & LYS_XPATH_DEP) || !(options & LYD_OPT_NOEXTDEPS))) {
+                        && (!(when->flags & LYS_XPATH_DEP) || !(options & LYD_OPT_NOEXTDEPS))) {
                     if ((options & LYD_OPT_NOAUTODEL) && !unres->node[i]->dflt) {
                         /* false when condition */
                         ly_vlog_hide(0);
@@ -7859,7 +7844,7 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
             } else if (rc == -1) {
                 ly_vlog_hide(0);
                 /* print only this last error */
-                resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail);
+                resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail, NULL);
                 return -1;
             } /* else forward reference */
         }
@@ -7905,7 +7890,7 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
                 stmt_count++;
             }
 
-            rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail);
+            rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail, NULL);
             if (!rc) {
                 unres->type[i] = UNRES_RESOLVED;
                 ly_err_clean(1);
@@ -7914,7 +7899,7 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
             } else if (rc == -1) {
                 ly_vlog_hide(0);
                 /* print only this last error */
-                resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail);
+                resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail, NULL);
                 return -1;
             } /* else forward reference */
         }
@@ -7937,7 +7922,7 @@ resolve_unres_data(struct unres_data *unres, struct lyd_node **root, int options
         }
         assert(!(options & LYD_OPT_TRUSTED) || ((unres->type[i] != UNRES_MUST) && (unres->type[i] != UNRES_MUST_INOUT)));
 
-        rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail);
+        rc = resolve_unres_data_item(unres->node[i], unres->type[i], ignore_fail, NULL);
         if (rc) {
             /* since when was already resolved, a forward reference is an error */
             return -1;
diff --git a/src/resolve.h b/src/resolve.h
@@ -208,7 +208,7 @@ struct lys_ident *resolve_identref(struct lys_type *type, const char *ident_name
 
 int resolve_unres_schema(struct lys_module *mod, struct unres_schema *unres);
 
-int resolve_when(struct lyd_node *node, int ignore_fail);
+int resolve_when(struct lyd_node *node, int ignore_fail, struct lys_when **failed_when);
 
 int unres_schema_add_str(struct lys_module *mod, struct unres_schema *unres, void *item, enum UNRES_ITEM type,
                          const char *str);
@@ -230,7 +230,7 @@ void unres_schema_free(struct lys_module *module, struct unres_schema **unres, i
 int resolve_union(struct lyd_node_leaf_list *leaf, struct lys_type *type, int store, int ignore_fail,
                   struct lys_type **resolved_type);
 
-int resolve_unres_data_item(struct lyd_node *dnode, enum UNRES_ITEM type, int ignore_fail);
+int resolve_unres_data_item(struct lyd_node *dnode, enum UNRES_ITEM type, int ignore_fail, struct lys_when **failed_when);
 
 int unres_data_addonly(struct unres_data *unres, struct lyd_node *node, enum UNRES_ITEM type);
 int unres_data_add(struct unres_data *unres, struct lyd_node *node, enum UNRES_ITEM type);
diff --git a/src/tree_data.c b/src/tree_data.c
@@ -103,7 +103,7 @@ lyd_check_mandatory_data(struct lyd_node *root, struct lyd_node *last_parent,
                 }
                 for (current = dummy; current; current = current->child) {
                     ly_vlog_hide(1);
-                    resolve_when(current, 0);
+                    resolve_when(current, 0, NULL);
                     ly_vlog_hide(0);
                     if (current->when_status & LYD_WHEN_FALSE) {
                         /* when evaluates to false */
diff --git a/src/tree_schema.c b/src/tree_schema.c
@@ -3932,7 +3932,7 @@ lys_node_xpath_atomize(const struct lys_node *node, int options)
             goto next_iter;
         }
 
-        if (lyxp_node_atomize(elem, &set, 0)) {
+        if (lyxp_node_atomize(elem, &set, 0, 0)) {
             ly_set_free(ret_set);
             free(set.val.snodes);
             return NULL;
diff --git a/src/tree_schema.h b/src/tree_schema.h
@@ -1933,6 +1933,7 @@ struct lys_restr {
     const char *emsg;                /**< error-message (optional) */
     struct lys_ext_instance **ext;   /**< array of pointers to the extension instances */
     uint8_t ext_size;                /**< number of elements in #ext array */
+    uint8_t flags;                   /**< only one flag can be specified, #LYS_XPATH_DEP */
 };
 
 /**
@@ -1944,6 +1945,7 @@ struct lys_when {
     const char *ref;                 /**< reference (optional) */
     struct lys_ext_instance **ext;   /**< array of pointers to the extension instances */
     uint8_t ext_size;                /**< number of elements in #ext array */
+    uint8_t flags;                   /**< only one flag can be specified, #LYS_XPATH_DEP */
 };
 
 /**
diff --git a/src/xpath.c b/src/xpath.c
@@ -7670,13 +7670,13 @@ lyxp_atomize(const char *expr, const struct lys_node *cur_snode, enum lyxp_node_
 }
 
 int
-lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on_fwd_ref)
+lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on_fwd_ref, int set_ext_dep_flags)
 {
-    struct lys_node *parent;
+    struct lys_node *parent, *elem;
     const struct lys_node *ctx_snode;
     struct lyxp_set tmp_set;
     uint8_t must_size = 0;
-    uint32_t i;
+    uint32_t i, j;
     int opts, ret = EXIT_SUCCESS;
     struct lys_when *when = NULL;
     struct lys_restr *must = NULL;
@@ -7752,6 +7752,13 @@ lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on
         ly_vlog_hide(1);
     }
 
+    if (set_ext_dep_flags) {
+        /* find operation if in one, used later */
+        for (parent = (struct lys_node *)node;
+             parent && !(parent->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF));
+             parent = lys_parent(parent));
+    }
+
     /* check "when" */
     if (when) {
         if (lyxp_atomize(when->cond, node, LYXP_NODE_ELEM, &tmp_set, LYXP_SNODE_WHEN | opts, &ctx_snode)) {
@@ -7776,6 +7783,28 @@ lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on
             ret = EXIT_FAILURE;
             memset(&tmp_set, 0, sizeof tmp_set);
         } else {
+            if (set_ext_dep_flags) {
+                for (j = 0; j < tmp_set.used; ++j) {
+                    /* skip roots'n'stuff */
+                    if (tmp_set.val.snodes[j].type == LYXP_NODE_ELEM) {
+                        /* XPath expression cannot reference "lower" status than the node that has the definition */
+                        if (lyp_check_status(node->flags, lys_node_module(node), node->name, tmp_set.val.snodes[j].snode->flags,
+                                lys_node_module(tmp_set.val.snodes[j].snode), tmp_set.val.snodes[j].snode->name, node)) {
+                            return -1;
+                        }
+
+                        if (parent) {
+                            for (elem = tmp_set.val.snodes[j].snode; elem && (elem != parent); elem = lys_parent(elem));
+                            if (!elem) {
+                                /* not in node's RPC or notification subtree, set the flag */
+                                when->flags |= LYS_XPATH_DEP;
+                                ((struct lys_node *)node)->flags |= LYS_XPATH_DEP;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
             set_snode_merge(set, &tmp_set);
             memset(&tmp_set, 0, sizeof tmp_set);
         }
@@ -7805,6 +7834,28 @@ lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on
             ret = EXIT_FAILURE;
             memset(&tmp_set, 0, sizeof tmp_set);
         } else {
+            if (set_ext_dep_flags) {
+                for (j = 0; j < tmp_set.used; ++j) {
+                    /* skip roots'n'stuff */
+                    if (tmp_set.val.snodes[j].type == LYXP_NODE_ELEM) {
+                        /* XPath expression cannot reference "lower" status than the node that has the definition */
+                        if (lyp_check_status(node->flags, lys_node_module(node), node->name, tmp_set.val.snodes[j].snode->flags,
+                                lys_node_module(tmp_set.val.snodes[j].snode), tmp_set.val.snodes[j].snode->name, node)) {
+                            return -1;
+                        }
+
+                        if (parent) {
+                            for (elem = tmp_set.val.snodes[j].snode; elem && (elem != parent); elem = lys_parent(elem));
+                            if (!elem) {
+                                /* not in node's RPC or notification subtree, set the flag */
+                                must[i].flags |= LYS_XPATH_DEP;
+                                ((struct lys_node *)node)->flags |= LYS_XPATH_DEP;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
             set_snode_merge(set, &tmp_set);
             memset(&tmp_set, 0, sizeof tmp_set);
         }
diff --git a/src/xpath.h b/src/xpath.h
@@ -256,10 +256,12 @@ int lyxp_atomize(const char *expr, const struct lys_node *cur_snode, enum lyxp_n
  * Will be cleared before use.
  * @param[in] warn_on_fwd_ref Setting this flag causes no errors to be printed and
  * only warning is printed on forward reference paths (addressing a non-existing node).
+ * @param[in] set_ext_dep_flags Set #LYS_XPATH_DEP for conditions that require foreign subtree and
+ * also for the node itself, if it has any such condition.
  *
  * @return EXIT_SUCCESS on success, EXIT_FAILURE on forward reference, -1 on error.
  */
-int lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on_fwd_ref);
+int lyxp_node_atomize(const struct lys_node *node, struct lyxp_set *set, int warn_on_fwd_ref, int set_ext_dep_flags);
 
 /**
  * @brief Check syntax of all the XPath expressions of the node.

Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ lyd_check_mandatory_data(struct lyd_node root, struct lyd_node last_parent,`
`103`	`103`	`}`
`104`	`104`	`for (current = dummy; current; current = current->child) {`
`105`	`105`	`ly_vlog_hide(1);`
`106`		`- resolve_when(current, 0);`
	`106`	`+ resolve_when(current, 0, NULL);`
`107`	`107`	`ly_vlog_hide(0);`
`108`	`108`	`if (current->when_status & LYD_WHEN_FALSE) {`
`109`	`109`	`/* when evaluates to false */`
Original file line number	Diff line number	Diff line change
`@@ -3932,7 +3932,7 @@ lys_node_xpath_atomize(const struct lys_node *node, int options)`
`3932`	`3932`	`goto next_iter;`
`3933`	`3933`	`}`
`3934`	`3934`
`3935`		`- if (lyxp_node_atomize(elem, &set, 0)) {`
	`3935`	`+ if (lyxp_node_atomize(elem, &set, 0, 0)) {`
`3936`	`3936`	`ly_set_free(ret_set);`
`3937`	`3937`	`free(set.val.snodes);`
`3938`	`3938`	`return NULL;`