tree data UPDATE refactor validating values

Dedicated function for default value validation.
Refs #2433

Author: michalvasko

doc/transition_3_4.dox

@@ -14,8 +14,9 @@
  * and the other for YANG data that can be written to normally. The main consequence of this is that comparing
  * directly (the addresses) of strings from these 2 dictionaries will not work. Next, all plugin references were
  * replaced by an `uintptr_t` value but there are functions ::lysc_get_type_plugin() and ::lysc_get_ext_plugin() for
- * getting the actual plugin structures. Finally, some new callbacks were required for extension-instance plugins
- * so that they can be printed with the context as well.
+ * getting the actual plugin structures. Then, default values are stored as strings in the schema nodes. To learn their
+ * real type or get their canonical value, use ::lyd_value_validate_dflt(). Finally, some new callbacks were required
+ * for extension-instance plugins so that they can be printed with the context as well.
  *
  * Other notable changes include major LYB binary data format optimizations. The effect in API is that wherever a size
  * of a value is required, it is now expected in bits instead of bytes. Next, there are extension plugin API

src/parser_common.c

@@ -94,7 +94,7 @@ lyd_parser_notif_eventtime_validate(const struct lyd_node *node)
 
         /* validate the value, in JSON format */
         value = lyd_get_value(node);
-        LY_CHECK_RET(lyd_value_validate(LYD_CTX(node), schema, value, strlen(value), NULL, NULL, NULL));
+        LY_CHECK_RET(lyd_value_validate(schema, value, strlen(value), NULL, NULL, NULL));
     } else {
         LYSC_CTX_INIT_CTX(cctx, ctx);
 

src/path.c

@@ -716,8 +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_validate3(ctx_node->module->ctx, key, val, val_len, format, prefix_data, LYD_HINT_DATA,
-                        NULL, top_ext, NULL, &p->value);
+                r = lyd_value_validate3(key, val, val_len, format, prefix_data, LYD_HINT_DATA, NULL, top_ext, 1, NULL,
+                        &p->value);
                 LOG_LOCBACK(1, 0);
                 LY_CHECK_ERR_GOTO(r && (r != LY_EINCOMPLETE), rc = r, cleanup);
 
@@ -775,8 +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_validate3(ctx_node->module->ctx, ctx_node, val, val_len, format, prefix_data, LYD_HINT_DATA, NULL,
-                top_ext, NULL, &p->value);
+        r = lyd_value_validate3(ctx_node, val, val_len, format, prefix_data, LYD_HINT_DATA, NULL, top_ext, 1, NULL,
+                &p->value);
         LOG_LOCBACK(1, 0);
         LY_CHECK_ERR_GOTO(r && (r != LY_EINCOMPLETE), rc = r, cleanup);
 

src/tree_data.h

@@ -1852,7 +1852,6 @@ LIBYANG_API_DECL void lyd_free_attr_siblings(const struct ly_ctx *ctx, struct ly
  *
  * The given node is not modified in any way - it is just checked if the @p value can be set to the node.
  *
- * @param[in] ctx libyang context for logging (function does not log errors when @p ctx is NULL)
  * @param[in] schema Schema node of the @p value.
  * @param[in] value String value to be checked, it is expected to be in JSON format.
  * @param[in] value_len Length of the given @p value (mandatory).
@@ -1865,20 +1864,17 @@ LIBYANG_API_DECL void lyd_free_attr_siblings(const struct ly_ctx *ctx, struct ly
  * (e.g. due to require-instance).
  * @return LY_ERR value if an error occurred.
  */
-LIBYANG_API_DECL LY_ERR lyd_value_validate(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value,
-        uint32_t value_len, const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical);
+LIBYANG_API_DECL LY_ERR lyd_value_validate(const struct lysc_node *schema, const char *value, uint32_t value_len,
+        const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical);
 
 /**
  * @brief Check type restrictions applicable to the particular leaf/leaf-list with the given string @p value.
  *
  * The given node is not modified in any way - it is just checked if the @p value can be set to the node.
  *
- * @param[in] ctx libyang context for logging (function does not log errors when @p ctx is NULL)
  * @param[in] schema Schema node of the @p value.
- * @param[in] value String value to be checked, it is expected to be in JSON format.
- * @param[in] value_len Length of the given @p value (mandatory).
- * @param[in] hints Value hints, bitmap of @ref lydvalhints. Use ::LYD_HINT_DATA for generic data value and
- * ::LYD_HINT_SCHEMA for a schema value (default value, for example).
+ * @param[in] value String default value to be checked, in a ::lysc_value.
+ * @param[in] prefixes Stored prefixes of @p value, in a ::lysc_value.
  * @param[in] ctx_node Optional data tree context node for the value (leafref target, instance-identifier).
  * If not set and is required for the validation to complete, ::LY_EINCOMPLETE is be returned.
  * @param[out] realtype Optional real type of @p value.
@@ -1888,8 +1884,8 @@ LIBYANG_API_DECL LY_ERR lyd_value_validate(const struct ly_ctx *ctx, const struc
  * (e.g. due to require-instance).
  * @return LY_ERR value if an error occurred.
  */
-LIBYANG_API_DECL LY_ERR lyd_value_validate2(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value,
-        uint32_t value_len, uint32_t hints, const struct lyd_node *ctx_node, const struct lysc_type **realtype,
+LIBYANG_API_DECL LY_ERR lyd_value_validate_dflt(const struct lysc_node *schema, const char *value,
+        struct lysc_prefix *prefixes, const struct lyd_node *ctx_node, const struct lysc_type **realtype,
         const char **canonical);
 
 /**

src/tree_data_common.c

@@ -620,41 +620,39 @@ ly_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const
 }
 
 LIBYANG_API_DEF LY_ERR
-lyd_value_validate(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, uint32_t value_len,
+lyd_value_validate(const struct lysc_node *schema, const char *value, uint32_t value_len,
         const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical)
 {
-    LY_CHECK_ARG_RET(ctx, schema, !value_len || value, LY_EINVAL);
+    LY_CHECK_ARG_RET(NULL, schema, !value_len || value, LY_EINVAL);
 
-    return lyd_value_validate3(ctx, schema, value, value_len, LY_VALUE_JSON, NULL, LYD_HINT_DATA, ctx_node, NULL,
-            realtype, canonical);
+    return lyd_value_validate3(schema, value, value_len, LY_VALUE_JSON, NULL, LYD_HINT_DATA, ctx_node, NULL,
+            1, realtype, canonical);
 }
 
 LIBYANG_API_DEF LY_ERR
-lyd_value_validate2(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, uint32_t value_len,
-        uint32_t hints, const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical)
+lyd_value_validate_dflt(const struct lysc_node *schema, const char *value, struct lysc_prefix *prefixes,
+        const struct lyd_node *ctx_node, const struct lysc_type **realtype, const char **canonical)
 {
-    LY_CHECK_ARG_RET(ctx, schema, !value_len || value, LY_EINVAL);
+    LY_CHECK_ARG_RET(NULL, schema, LY_EINVAL);
 
-    return lyd_value_validate3(ctx, schema, value, value_len, LY_VALUE_JSON, NULL, hints, ctx_node, NULL,
-            realtype, canonical);
+    return lyd_value_validate3(schema, value, value ? strlen(value) : 0, LY_VALUE_SCHEMA_RESOLVED, prefixes,
+            LYD_HINT_SCHEMA, ctx_node, NULL, 1, realtype, canonical);
 }
 
 LY_ERR
-lyd_value_validate3(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, size_t value_len,
-        LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lyd_node *ctx_node,
-        const struct lysc_ext_instance *top_ext, const struct lysc_type **realtype, const char **canonical)
+lyd_value_validate3(const struct lysc_node *schema, const char *value, size_t value_len, LY_VALUE_FORMAT format,
+        void *prefix_data, uint32_t hints, const struct lyd_node *ctx_node, const struct lysc_ext_instance *top_ext,
+        int log, const struct lysc_type **realtype, const char **canonical)
 {
     LY_ERR rc;
+    const struct ly_ctx *ctx;
     struct ly_err_item *err = NULL;
     struct lysc_type *type;
     struct lyd_value val = {0};
-    ly_bool stored = 0, log = 1;
+    ly_bool stored = 0;
     struct lyplg_type *type_plg;
 
-    if (!ctx) {
-        ctx = schema->module->ctx;
-        log = 0;
-    }
+    ctx = schema->module->ctx;
     if (!value_len) {
         value = "";
     }

src/tree_data_internal.h

@@ -641,7 +641,6 @@ LY_ERR ly_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node,
  *
  * The given node is not modified in any way - it is just checked if the @p value can be set to the node.
  *
- * @param[in] ctx libyang context for logging (function does not log errors when @p ctx is NULL)
  * @param[in] schema Schema node of the @p value.
  * @param[in] value String value to be checked, it is expected to be in JSON format.
  * @param[in] value_len Length of the given @p value (mandatory).
@@ -651,16 +650,17 @@ LY_ERR ly_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node,
  * @param[in] ctx_node Optional data tree context node for the value (leafref target, instance-identifier).
  * If not set and is required for the validation to complete, ::LY_EINCOMPLETE is be returned.
  * @param[in] top_ext Extension instance containing the definition of the data being validated.
+ * @param[in] log Whether to log errors or not.
  * @param[out] realtype Optional real type of @p value.
  * @param[out] canonical Optional canonical value of @p value (in the dictionary).
  * @return LY_SUCCESS on success
  * @return LY_EINCOMPLETE in case the @p ctx_node is not provided and it was needed to finish the validation
  * (e.g. due to require-instance).
  * @return LY_ERR value if an error occurred.
  */
-LY_ERR lyd_value_validate3(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, size_t value_len,
+LY_ERR lyd_value_validate3(const struct lysc_node *schema, const char *value, size_t value_len,
         LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lyd_node *ctx_node,
-        const struct lysc_ext_instance *top_ext, const struct lysc_type **realtype, const char **canonical);
+        const struct lysc_ext_instance *top_ext, int log, const struct lysc_type **realtype, const char **canonical);
 
 /**
  * @defgroup datahash Data nodes hash manipulation

src/tree_data_new.c

@@ -1579,8 +1579,8 @@ lyd_new_path_check_find_lypath(struct ly_path *path, const struct lysc_ext_insta
             }
             if (!r) {
                 /* validate the value and store the canonical value */
-                r = lyd_value_validate3(NULL, schema, value, LYPLG_BITS2BYTES(value_size_bits), format, NULL,
-                        LYD_HINT_DATA, NULL, ext, NULL, &canon);
+                r = lyd_value_validate3(schema, value, LYPLG_BITS2BYTES(value_size_bits), format, NULL, LYD_HINT_DATA,
+                        NULL, ext, 0, NULL, &canon);
                 LY_CHECK_RET(r && r != LY_EINCOMPLETE, r);
 
                 /* store the new predicate so that it is used when searching for this instance */

src/tree_schema_common.c

@@ -2861,8 +2861,8 @@ lysc_value_cmp(const struct lysc_node *schema, const struct lyd_node *ctx_node,
     int cmp;
     const char *canon;
 
-    r = lyd_value_validate3(schema->module->ctx, schema, val->str, strlen(val->str), LY_VALUE_SCHEMA_RESOLVED,
-            val->prefixes, LYD_HINT_SCHEMA, ctx_node, NULL, NULL, &canon);
+    r = lyd_value_validate3(schema, val->str, strlen(val->str), LY_VALUE_SCHEMA_RESOLVED, val->prefixes,
+            LYD_HINT_SCHEMA, ctx_node, NULL, 1, NULL, &canon);
     if (r && (r != LY_EINCOMPLETE)) {
         return -1;
     }

src/validation.c

@@ -1336,9 +1336,9 @@ lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *c
                 val1 = lyd_get_value(diter);
             } else if (slist->uniques[u][v]->dflt.str) {
                 /* use canonical default value */
-                lyd_value_validate3(ctx, first->schema, slist->uniques[u][v]->dflt.str,
-                        strlen(slist->uniques[u][v]->dflt.str), LY_VALUE_SCHEMA_RESOLVED,
-                        slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, NULL, &canon2);
+                lyd_value_validate3(first->schema, slist->uniques[u][v]->dflt.str, strlen(slist->uniques[u][v]->dflt.str),
+                        LY_VALUE_SCHEMA_RESOLVED, slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, 1,
+                        NULL, &canon2);
                 val1 = canon1;
             }
 
@@ -1350,9 +1350,9 @@ lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *c
                 val2 = lyd_get_value(diter);
             } else if (slist->uniques[u][v]->dflt.str) {
                 /* use canonical default value */
-                lyd_value_validate3(ctx, first->schema, slist->uniques[u][v]->dflt.str,
-                        strlen(slist->uniques[u][v]->dflt.str), LY_VALUE_SCHEMA_RESOLVED,
-                        slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, NULL, &canon2);
+                lyd_value_validate3(first->schema, slist->uniques[u][v]->dflt.str, strlen(slist->uniques[u][v]->dflt.str),
+                        LY_VALUE_SCHEMA_RESOLVED, slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, 1,
+                        NULL, &canon2);
                 val2 = canon2;
             }
 
@@ -1480,8 +1480,8 @@ lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode,
                         val = lyd_get_value(diter);
                     } else if (uniques[u][v]->dflt.str) {
                         /* use canonical default value */
-                        ret = lyd_value_validate3(ctx, snode, uniques[u][v]->dflt.str, strlen(uniques[u][v]->dflt.str),
-                                LY_VALUE_SCHEMA_RESOLVED, uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL,
+                        ret = lyd_value_validate3(snode, uniques[u][v]->dflt.str, strlen(uniques[u][v]->dflt.str),
+                                LY_VALUE_SCHEMA_RESOLVED, uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, 1,
                                 NULL, &val);
                         LY_CHECK_GOTO(ret, cleanup);
                     }

src/xpath.c

@@ -1709,8 +1709,8 @@ set_comp_canonize(struct lyxp_set *set, const struct lyxp_set_node *xp_node)
     }
 
     /* print canonized string, ignore errors, the value may not satisfy schema constraints */
-    r = lyd_value_validate3(NULL, xp_node->node->schema, set->val.str, strlen(set->val.str), set->format,
-            set->prefix_data, LYD_HINT_DATA, NULL, set->ext, NULL, &canon);
+    r = lyd_value_validate3(xp_node->node->schema, set->val.str, strlen(set->val.str), set->format, set->prefix_data,
+            LYD_HINT_DATA, NULL, set->ext, 0, NULL, &canon);
     if (r && (r != LY_EINCOMPLETE)) {
         /* invalid value, fine */
         return LY_SUCCESS;