validation UPDATE means for proper per-module(s) validation

Author: michalvasko

src/parser_data.h

@@ -203,11 +203,14 @@ struct ly_in;
                                                  Also, no implicit state data are added. */
 #define LYD_VALIDATE_PRESENT    0x0002      /**< Validate only modules whose data actually exist. */
 #define LYD_VALIDATE_MULTI_ERROR 0x0004     /**< Do not stop validation on the first error but generate all the detected errors. */
-#define LYD_VALIDATE_OPERATIONAL 0x0008     /**< Semantic constraint violations are reported only as warnings instead
-                                                 of errors (see [RFC 8342 sec. 5.3](https://datatracker.ietf.org/doc/html/rfc8342#section-5.3)). */
+#define LYD_VALIDATE_OPERATIONAL 0x0008     /**< Semantic constraint violations are reported only as warnings instead of
+                                                 errors (see [RFC 8342 sec. 5.3](https://datatracker.ietf.org/doc/html/rfc8342#section-5.3)). */
 #define LYD_VALIDATE_NO_DEFAULTS 0x0010     /**< Do not add any default nodes during validation, other implicit nodes
                                                  (such as NP containers) are still added. Validation will fail if a
                                                  default node is required for it to pass. */
+#define LYD_VALIDATE_NOT_FINAL 0x0020       /**< Skip final validation tasks that require for all the data nodes to
+                                                 either exist or not, based on the YANG constraints. Once the data
+                                                 satisfy this requirement, the final validation should be performed. */
 
 #define LYD_VALIDATE_OPTS_MASK  0x0000FFFF  /**< Mask for all the LYD_VALIDATE_* options. */
 
@@ -476,6 +479,10 @@ LIBYANG_API_DECL LY_ERR lyd_validate_all(struct lyd_node **tree, const struct ly
  * The data tree is modified in-place. As a result of the validation, some data might be removed
  * from the tree. In that case, the removed items are freed, not just unlinked.
  *
+ * If several modules need to be validated, the flag ::LYD_VALIDATE_NOT_FINAL should be used first for validation
+ * of each module and then ::lyd_validate_module_final() should be called also for each module. Otherwise,
+ * false-positive validation errors for foreign dependencies may occur.
+ *
  * @param[in,out] tree Data tree to recursively validate. May be changed by validation, might become NULL.
  * @param[in] module Module whose data (and schema restrictions) to validate.
  * @param[in] val_opts Validation options (@ref datavalidationoptions).
@@ -486,6 +493,20 @@ LIBYANG_API_DECL LY_ERR lyd_validate_all(struct lyd_node **tree, const struct ly
 LIBYANG_API_DECL LY_ERR lyd_validate_module(struct lyd_node **tree, const struct lys_module *module, uint32_t val_opts,
         struct lyd_node **diff);
 
+/**
+ * @brief Finish validation of a module data that have previously been validated with ::LYD_VALIDATE_NOT_FINAL flag.
+ *
+ * This final validation will not add or remove any nodes.
+ *
+ * @param[in] tree Data tree to recursively validate.
+ * @param[in] module Module whose data (and schema restrictions) to validate.
+ * @param[in] val_opts Validation options (@ref datavalidationoptions).
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR error on error.
+ */
+LIBYANG_API_DECL LY_ERR lyd_validate_module_final(struct lyd_node *tree, const struct lys_module *module,
+        uint32_t val_opts);
+
 /**
  * @brief Validate an RPC/action request, reply, or notification. Only the operation data tree (input/output/notif)
  * is validate, any parents are ignored.

src/validation.c

@@ -1877,9 +1877,11 @@ lyd_validate(struct lyd_node **tree, const struct lys_module *module, const stru
                 ext_node_p, ext_val_p, val_opts, diff);
         LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
 
-        /* perform final validation that assumes the data tree is final */
-        r = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0);
-        LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
+        if (!(val_opts & LYD_VALIDATE_NOT_FINAL)) {
+            /* perform final validation that assumes the data tree is final */
+            r = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0);
+            LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
+        }
     }
 
 cleanup:
@@ -1909,14 +1911,36 @@ lyd_validate_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t val_
 LIBYANG_API_DEF LY_ERR
 lyd_validate_module(struct lyd_node **tree, const struct lys_module *module, uint32_t val_opts, struct lyd_node **diff)
 {
-    LY_CHECK_ARG_RET(NULL, tree, *tree || module, LY_EINVAL);
-    LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module ? module->ctx : NULL, LY_EINVAL);
+    LY_CHECK_ARG_RET(NULL, tree, module, !(val_opts & LYD_VALIDATE_PRESENT), LY_EINVAL);
+    LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module->ctx, LY_EINVAL);
     if (diff) {
         *diff = NULL;
     }
 
-    return lyd_validate(tree, module, (*tree) ? LYD_CTX(*tree) : module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL,
-            diff);
+    return lyd_validate(tree, module, module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_validate_module_final(struct lyd_node *tree, const struct lys_module *module, uint32_t val_opts)
+{
+    LY_ERR r, rc = LY_SUCCESS;
+    struct lyd_node *first;
+    const struct lys_module *mod;
+    uint32_t i = 0;
+
+    LY_CHECK_ARG_RET(NULL, module, !(val_opts & (LYD_VALIDATE_PRESENT | LYD_VALIDATE_NOT_FINAL)), LY_EINVAL);
+    LY_CHECK_CTX_EQUAL_RET(LYD_CTX(tree), module->ctx, LY_EINVAL);
+
+    /* module is unchanged but we need to get the first module data node */
+    mod = lyd_mod_next_module(tree, module, module->ctx, &i, &first);
+    assert(mod);
+
+    /* perform final validation that assumes the data tree is final */
+    r = lyd_validate_final_r(first, NULL, NULL, mod, val_opts, 0, 0);
+    LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
+
+cleanup:
+    return rc;
 }
 
 /**