tree data UPDATE function with hints for canonizing values

Needed for default values.

Author: michalvasko

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

src/tree_data.h

@@ -1868,6 +1868,30 @@ LIBYANG_API_DECL void lyd_free_attr_siblings(const struct ly_ctx *ctx, struct ly
 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);
 
+/**
+ * @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] 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.
+ * @param[out] canonical Optional canonical value of @p value in the dictionary, needs to be freed using ::lydict_remove().
+ * @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.
+ */
+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,
+        const char **canonical);
+
 /**
  * @brief Compare the node's value with the given string value. The string value is first validated according to
  * the (current) node's type.

src/tree_data_common.c

@@ -625,12 +625,23 @@ lyd_value_validate(const struct ly_ctx *ctx, const struct lysc_node *schema, con
 {
     LY_CHECK_ARG_RET(ctx, schema, !value_len || value, LY_EINVAL);
 
-    return lyd_value_validate2(ctx, schema, value, value_len, LY_VALUE_JSON, NULL, ctx_node, NULL, realtype, canonical);
+    return lyd_value_validate3(ctx, schema, value, value_len, LY_VALUE_JSON, NULL, LYD_HINT_DATA, ctx_node, NULL,
+            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)
+{
+    LY_CHECK_ARG_RET(ctx, schema, !value_len || value, LY_EINVAL);
+
+    return lyd_value_validate3(ctx, schema, value, value_len, LY_VALUE_JSON, NULL, hints, ctx_node, NULL,
+            realtype, canonical);
 }
 
 LY_ERR
-lyd_value_validate2(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, size_t value_len,
-        LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *ctx_node,
+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)
 {
     LY_ERR rc;
@@ -652,8 +663,7 @@ lyd_value_validate2(const struct ly_ctx *ctx, const struct lysc_node *schema, co
     type_plg = LYSC_GET_TYPE_PLG(type->plugin_ref);
 
     /* store */
-    rc = type_plg->store(ctx, type, value, value_len * 8, 0, format, prefix_data, LYD_HINT_DATA, schema, top_ext, &val,
-            NULL, &err);
+    rc = type_plg->store(ctx, type, value, value_len * 8, 0, format, prefix_data, hints, schema, top_ext, &val, NULL, &err);
     if (!rc || (rc == LY_EINCOMPLETE)) {
         stored = 1;
     }

src/tree_data_internal.h

@@ -647,6 +647,7 @@ LY_ERR ly_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node,
  * @param[in] value_len Length of the given @p value (mandatory).
  * @param[in] format Value prefix format.
  * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
+ * @param[in] hints Value hints, bitmap of LYD_VALHINT_* values.
  * @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.
@@ -657,8 +658,8 @@ LY_ERR ly_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node,
  * (e.g. due to require-instance).
  * @return LY_ERR value if an error occurred.
  */
-LY_ERR lyd_value_validate2(const struct ly_ctx *ctx, const struct lysc_node *schema, const char *value, size_t value_len,
-        LY_VALUE_FORMAT format, void *prefix_data, const struct lyd_node *ctx_node,
+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);
 
 /**

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_validate2(NULL, schema, value, LYPLG_BITS2BYTES(value_size_bits), format, NULL, NULL, ext,
-                        NULL, &canon);
+                r = lyd_value_validate3(NULL, schema, value, LYPLG_BITS2BYTES(value_size_bits), format, NULL,
+                        LYD_HINT_DATA, NULL, ext, 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_validate2(schema->module->ctx, schema, val->str, strlen(val->str), LY_VALUE_SCHEMA_RESOLVED,
-            val->prefixes, ctx_node, NULL, NULL, &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);
     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_validate2(ctx, first->schema, slist->uniques[u][v]->dflt.str,
+                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, NULL, NULL, NULL, &canon2);
+                        slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, 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_validate2(ctx, first->schema, slist->uniques[u][v]->dflt.str,
+                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, NULL, NULL, NULL, &canon2);
+                        slist->uniques[u][v]->dflt.prefixes, LYD_HINT_SCHEMA, NULL, NULL, NULL, &canon2);
                 val2 = canon2;
             }
 
@@ -1480,8 +1480,9 @@ 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_validate2(ctx, snode, uniques[u][v]->dflt.str, strlen(uniques[u][v]->dflt.str),
-                                LY_VALUE_SCHEMA_RESOLVED, uniques[u][v]->dflt.prefixes, NULL, NULL, NULL, &val);
+                        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,
+                                NULL, &val);
                         LY_CHECK_GOTO(ret, cleanup);
                     }
                     if (!val) {

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_validate2(NULL, xp_node->node->schema, set->val.str, strlen(set->val.str), set->format,
-            set->prefix_data, NULL, set->ext, NULL, &canon);
+    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);
     if (r && (r != LY_EINCOMPLETE)) {
         /* invalid value, fine */
         return LY_SUCCESS;