blob: f9f9abffa62c50ee7bff1b665c2ed2de4f585feb [file] [log] [blame]
Michal Vasko59892dd2022-05-13 11:02:30 +02001/**
2 * @file tree_data_new.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @author Michal Vasko <mvasko@cesnet.cz>
5 * @brief Data tree new functions
6 *
7 * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
8 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
16#define _GNU_SOURCE
17
18#include <assert.h>
19#include <ctype.h>
20#include <inttypes.h>
21#include <stdarg.h>
22#include <stdint.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include "common.h"
28#include "compat.h"
29#include "context.h"
30#include "dict.h"
31#include "diff.h"
32#include "hash_table.h"
33#include "in.h"
34#include "in_internal.h"
35#include "log.h"
36#include "parser_data.h"
37#include "parser_internal.h"
38#include "path.h"
39#include "plugins.h"
40#include "plugins_exts/metadata.h"
41#include "plugins_internal.h"
42#include "plugins_types.h"
43#include "set.h"
44#include "tree.h"
45#include "tree_data_internal.h"
46#include "tree_edit.h"
47#include "tree_schema.h"
48#include "tree_schema_internal.h"
49#include "validation.h"
50#include "xml.h"
51#include "xpath.h"
52
53LY_ERR
54lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
55 LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
56{
57 LY_ERR ret;
58 struct lyd_node_term *term;
59
60 assert(schema->nodetype & LYD_NODE_TERM);
61
62 term = calloc(1, sizeof *term);
63 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
64
65 term->schema = schema;
66 term->prev = &term->node;
67 term->flags = LYD_NEW;
68
69 LOG_LOCSET(schema, NULL, NULL, NULL);
70 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
71 value_len, dynamic, format, prefix_data, hints, schema, incomplete);
72 LOG_LOCBACK(1, 0, 0, 0);
73 LY_CHECK_ERR_RET(ret, free(term), ret);
74 lyd_hash(&term->node);
75
76 *node = &term->node;
77 return ret;
78}
79
80LY_ERR
81lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
82{
83 LY_ERR ret;
84 struct lyd_node_term *term;
85 struct lysc_type *type;
86
87 assert(schema->nodetype & LYD_NODE_TERM);
88 assert(val && val->realtype);
89
90 term = calloc(1, sizeof *term);
91 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
92
93 term->schema = schema;
94 term->prev = &term->node;
95 term->flags = LYD_NEW;
96
97 type = ((struct lysc_node_leaf *)schema)->type;
98 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
99 if (ret) {
100 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
101 free(term);
102 return ret;
103 }
104 lyd_hash(&term->node);
105
106 *node = &term->node;
107 return ret;
108}
109
110LY_ERR
111lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
112{
113 struct lyd_node_inner *in;
114
115 assert(schema->nodetype & LYD_NODE_INNER);
116
117 in = calloc(1, sizeof *in);
118 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
119
120 in->schema = schema;
121 in->prev = &in->node;
122 in->flags = LYD_NEW;
123 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
124 in->flags |= LYD_DEFAULT;
125 }
126
127 /* do not hash list with keys, we need them for the hash */
128 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
129 lyd_hash(&in->node);
130 }
131
132 *node = &in->node;
133 return LY_SUCCESS;
134}
135
136LY_ERR
Michal Vasko90189962023-02-28 12:10:34 +0100137lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, const struct lyxp_var *vars,
138 struct lyd_node **node)
Michal Vasko59892dd2022-05-13 11:02:30 +0200139{
140 LY_ERR ret = LY_SUCCESS;
141 struct lyd_node *list = NULL, *key;
Michal Vasko90189962023-02-28 12:10:34 +0100142 const struct lyd_value *value;
143 struct lyd_value val = {0};
144 struct lyxp_var *var;
Michal Vasko59892dd2022-05-13 11:02:30 +0200145 LY_ARRAY_COUNT_TYPE u;
146
147 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
148
149 /* create list */
150 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
151
Michal Vasko6e075ab2022-12-21 15:48:14 +0100152 LOG_LOCSET(schema, NULL, NULL, NULL);
Michal Vasko59892dd2022-05-13 11:02:30 +0200153
154 /* create and insert all the keys */
155 LY_ARRAY_FOR(predicates, u) {
Michal Vasko90189962023-02-28 12:10:34 +0100156 if (predicates[u].type == LY_PATH_PREDTYPE_LIST_VAR) {
157 /* find the var */
158 if ((ret = lyxp_vars_find(schema->module->ctx, vars, predicates[u].variable, 0, &var))) {
159 goto cleanup;
160 }
161
162 /* store the value */
163 LOG_LOCSET(predicates[u].key, NULL, NULL, NULL);
164 ret = lyd_value_store(schema->module->ctx, &val, ((struct lysc_node_leaf *)predicates[u].key)->type,
165 var->value, strlen(var->value), NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, predicates[u].key, NULL);
166 LOG_LOCBACK(1, 0, 0, 0);
167 LY_CHECK_GOTO(ret, cleanup);
168
169 value = &val;
170 } else {
171 assert(predicates[u].type == LY_PATH_PREDTYPE_LIST);
172 value = &predicates[u].value;
173 }
174
175 ret = lyd_create_term2(predicates[u].key, value, &key);
176 if (val.realtype) {
177 val.realtype->plugin->free(schema->module->ctx, &val);
178 memset(&val, 0, sizeof val);
179 }
180 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +0200181 lyd_insert_node(list, NULL, key, 0);
182 }
183
184 /* hash having all the keys */
185 lyd_hash(list);
186
187 /* success */
188 *node = list;
189 list = NULL;
190
191cleanup:
Michal Vasko6e075ab2022-12-21 15:48:14 +0100192 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko59892dd2022-05-13 11:02:30 +0200193 lyd_free_tree(list);
194 return ret;
195}
196
197LY_ERR
198lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
199{
200 LY_ERR ret = LY_SUCCESS;
201 struct lyxp_expr *expr = NULL;
Michal Vaskodd528af2022-08-08 14:35:07 +0200202 uint32_t exp_idx = 0;
Michal Vasko59892dd2022-05-13 11:02:30 +0200203 struct ly_path_predicate *predicates = NULL;
204
205 LOG_LOCSET(schema, NULL, NULL, NULL);
206
207 /* parse keys */
208 LY_CHECK_GOTO(ret = ly_path_parse_predicate(schema->module->ctx, NULL, keys, keys_len, LY_PATH_PREFIX_OPTIONAL,
209 LY_PATH_PRED_KEYS, &expr), cleanup);
210
211 /* compile them */
212 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_VALUE_JSON,
Michal Vasko90189962023-02-28 12:10:34 +0100213 NULL, &predicates), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +0200214
215 /* create the list node */
Michal Vasko90189962023-02-28 12:10:34 +0100216 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, NULL, node), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +0200217
218cleanup:
219 LOG_LOCBACK(1, 0, 0, 0);
220 lyxp_expr_free(schema->module->ctx, expr);
Michal Vasko90189962023-02-28 12:10:34 +0100221 ly_path_predicates_free(schema->module->ctx, predicates);
Michal Vasko59892dd2022-05-13 11:02:30 +0200222 return ret;
223}
224
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100225/**
Michal Vasko5b414dd2023-04-13 10:29:58 +0200226 * @brief Learn actual any value type in case it is currently ::LYD_ANYDATA_STRING.
227 *
228 * @param[in] value Any value.
229 * @param[out] value_type Detected value type.
230 */
231static void
232lyd_create_any_string_valtype(const void *value, LYD_ANYDATA_VALUETYPE *value_type)
233{
234 /* detect format */
235 if (!value) {
236 /* interpret it as an empty data tree */
237 *value_type = LYD_ANYDATA_DATATREE;
238 } else if (((char *)value)[0] == '<') {
239 *value_type = LYD_ANYDATA_XML;
240 } else if (((char *)value)[0] == '{') {
241 *value_type = LYD_ANYDATA_JSON;
242 } else if (!strncmp(value, "lyb", 3)) {
243 *value_type = LYD_ANYDATA_LYB;
244 } else {
245 /* really just some string */
246 *value_type = LYD_ANYDATA_STRING;
247 }
248}
249
250/**
251 * @brief Convert an any value into a datatree.
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100252 *
253 * @param[in] ctx libyang context.
Michal Vasko5b414dd2023-04-13 10:29:58 +0200254 * @param[in] value_in Any value as an input.
255 * @param[in] value_type Any @p value type.
256 * @param[in] log Whether parsing errors should be logged.
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100257 * @param[out] tree Parsed data tree.
258 * @return LY_ERR value.
259 */
260static LY_ERR
Michal Vasko5b414dd2023-04-13 10:29:58 +0200261lyd_create_any_datatree(const struct ly_ctx *ctx, struct ly_in *value_in, LYD_ANYDATA_VALUETYPE value_type, ly_bool log,
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100262 struct lyd_node **tree)
263{
Michal Vasko5b414dd2023-04-13 10:29:58 +0200264 LY_ERR rc = LY_SUCCESS;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100265 struct lyd_ctx *lydctx = NULL;
Michal Vasko5b414dd2023-04-13 10:29:58 +0200266 uint32_t parse_opts, int_opts, log_opts = 0;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100267
268 *tree = NULL;
269
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100270 /* set options */
271 parse_opts = LYD_PARSE_ONLY | LYD_PARSE_OPAQ;
272 int_opts = LYD_INTOPT_ANY | LYD_INTOPT_WITH_SIBLINGS;
273
Michal Vasko5b414dd2023-04-13 10:29:58 +0200274 if (!log) {
275 /* no logging */
276 ly_temp_log_options(&log_opts);
277 }
278
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100279 switch (value_type) {
280 case LYD_ANYDATA_DATATREE:
281 case LYD_ANYDATA_STRING:
282 /* unreachable */
283 LOGINT_RET(ctx);
284 case LYD_ANYDATA_XML:
Michal Vasko5b414dd2023-04-13 10:29:58 +0200285 rc = lyd_parse_xml(ctx, NULL, NULL, tree, value_in, parse_opts, 0, int_opts, NULL, NULL, &lydctx);
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100286 break;
287 case LYD_ANYDATA_JSON:
Michal Vasko5b414dd2023-04-13 10:29:58 +0200288 rc = lyd_parse_json(ctx, NULL, NULL, tree, value_in, parse_opts, 0, int_opts, NULL, NULL, &lydctx);
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100289 break;
290 case LYD_ANYDATA_LYB:
Michal Vasko5b414dd2023-04-13 10:29:58 +0200291 rc = lyd_parse_lyb(ctx, NULL, NULL, tree, value_in, parse_opts | LYD_PARSE_STRICT, 0, int_opts, NULL, NULL, &lydctx);
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100292 break;
293 }
294 if (lydctx) {
295 lydctx->free(lydctx);
296 }
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100297
Michal Vasko5b414dd2023-04-13 10:29:58 +0200298 if (!log) {
299 /* restore logging */
300 ly_temp_log_options(NULL);
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100301 }
Michal Vasko90fc1ae2023-04-27 12:22:19 +0200302 if (rc && *tree) {
303 lyd_free_siblings(*tree);
304 *tree = NULL;
305 }
Michal Vasko5b414dd2023-04-13 10:29:58 +0200306 return rc;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100307}
308
Michal Vasko59892dd2022-05-13 11:02:30 +0200309LY_ERR
310lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, ly_bool use_value,
311 struct lyd_node **node)
312{
Michal Vasko5b414dd2023-04-13 10:29:58 +0200313 LY_ERR rc = LY_SUCCESS, r;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100314 struct lyd_node *tree;
Michal Vaskobdeee992022-12-01 16:17:56 +0100315 struct lyd_node_any *any = NULL;
Michal Vasko59892dd2022-05-13 11:02:30 +0200316 union lyd_any_value any_val;
Michal Vasko5b414dd2023-04-13 10:29:58 +0200317 struct ly_in *in = NULL;
Michal Vasko59892dd2022-05-13 11:02:30 +0200318
319 assert(schema->nodetype & LYD_NODE_ANY);
320
321 any = calloc(1, sizeof *any);
322 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
323
324 any->schema = schema;
325 any->prev = &any->node;
326 any->flags = LYD_NEW;
327
Michal Vasko5b414dd2023-04-13 10:29:58 +0200328 if (schema->nodetype == LYS_ANYDATA) {
329 /* anydata */
330 if (value_type == LYD_ANYDATA_STRING) {
331 /* detect value type */
332 lyd_create_any_string_valtype(value, &value_type);
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100333 }
Michal Vasko5b414dd2023-04-13 10:29:58 +0200334
335 if (value_type != LYD_ANYDATA_DATATREE) {
336 /* create input */
337 assert(value);
338 LY_CHECK_GOTO(rc = ly_in_new_memory(value, &in), cleanup);
339
340 /* parse as a data tree */
341 if ((r = lyd_create_any_datatree(schema->module->ctx, in, value_type, 1, &tree))) {
342 LOGERR(schema->module->ctx, rc, "Failed to parse any content into a data tree.");
343 rc = r;
344 goto cleanup;
345 }
346
347 /* use the parsed data tree */
348 if (use_value) {
349 free((void *)value);
350 }
351 use_value = 1;
352 value = tree;
353 value_type = LYD_ANYDATA_DATATREE;
354 }
355 } else {
356 /* anyxml */
357 switch (value_type) {
358 case LYD_ANYDATA_DATATREE:
359 /* fine, just use the value */
360 break;
361 case LYD_ANYDATA_STRING:
362 /* detect value type */
363 lyd_create_any_string_valtype(value, &value_type);
364 if ((value_type == LYD_ANYDATA_DATATREE) || (value_type == LYD_ANYDATA_STRING)) {
365 break;
366 }
367 /* fallthrough */
368 case LYD_ANYDATA_XML:
369 case LYD_ANYDATA_JSON:
370 case LYD_ANYDATA_LYB:
371 if (!value) {
372 /* nothing to parse */
373 break;
374 }
375
376 /* create input */
377 LY_CHECK_GOTO(rc = ly_in_new_memory(value, &in), cleanup);
378
379 /* try to parse as a data tree */
380 r = lyd_create_any_datatree(schema->module->ctx, in, value_type, 0, &tree);
381 if (!r) {
382 /* use the parsed data tree */
383 if (use_value) {
384 free((void *)value);
385 }
386 use_value = 1;
387 value = tree;
388 value_type = LYD_ANYDATA_DATATREE;
389 }
390 break;
391 }
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100392 }
393
Michal Vasko59892dd2022-05-13 11:02:30 +0200394 if (use_value) {
395 switch (value_type) {
396 case LYD_ANYDATA_DATATREE:
397 any->value.tree = (void *)value;
398 break;
399 case LYD_ANYDATA_STRING:
400 case LYD_ANYDATA_XML:
401 case LYD_ANYDATA_JSON:
Michal Vasko5b414dd2023-04-13 10:29:58 +0200402 LY_CHECK_GOTO(rc = lydict_insert_zc(schema->module->ctx, (void *)value, &any->value.str), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +0200403 break;
404 case LYD_ANYDATA_LYB:
405 any->value.mem = (void *)value;
406 break;
407 }
408 any->value_type = value_type;
409 } else {
410 any_val.str = value;
Michal Vasko5b414dd2023-04-13 10:29:58 +0200411 LY_CHECK_GOTO(rc = lyd_any_copy_value(&any->node, &any_val, value_type), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +0200412 }
413 lyd_hash(&any->node);
414
Michal Vasko5b414dd2023-04-13 10:29:58 +0200415cleanup:
416 if (rc) {
417 lyd_free_tree(&any->node);
418 } else {
419 *node = &any->node;
420 }
421 ly_in_free(in, 0);
422 return rc;
Michal Vasko59892dd2022-05-13 11:02:30 +0200423}
424
425LY_ERR
426lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t pref_len,
427 const char *module_key, size_t module_key_len, const char *value, size_t value_len, ly_bool *dynamic,
428 LY_VALUE_FORMAT format, void *val_prefix_data, uint32_t hints, struct lyd_node **node)
429{
430 LY_ERR ret = LY_SUCCESS;
431 struct lyd_node_opaq *opaq;
432
433 assert(ctx && name && name_len && format);
434
435 if (!value_len && (!dynamic || !*dynamic)) {
436 value = "";
437 }
438
439 opaq = calloc(1, sizeof *opaq);
440 LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
441
442 opaq->prev = &opaq->node;
443 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
444
445 if (pref_len) {
446 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->name.prefix), finish);
447 }
448 if (module_key_len) {
449 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->name.module_ns), finish);
450 }
451 if (dynamic && *dynamic) {
452 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
453 *dynamic = 0;
454 } else {
455 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
456 }
457
458 opaq->format = format;
459 opaq->val_prefix_data = val_prefix_data;
460 opaq->hints = hints;
461 opaq->ctx = ctx;
462
463finish:
464 if (ret) {
465 lyd_free_tree(&opaq->node);
466 ly_free_prefix_data(format, val_prefix_data);
467 } else {
468 *node = &opaq->node;
469 }
470 return ret;
471}
472
473LIBYANG_API_DEF LY_ERR
474lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
475 struct lyd_node **node)
476{
477 LY_ERR r;
478 struct lyd_node *ret = NULL;
479 const struct lysc_node *schema;
480 struct lysc_ext_instance *ext = NULL;
481 const struct ly_ctx *ctx = parent ? LYD_CTX(parent) : (module ? module->ctx : NULL);
482
483 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
484 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
485
486 if (!module) {
487 module = parent->schema->module;
488 }
489
490 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
491 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
492 if (!schema && parent) {
493 r = ly_nested_ext_schema(parent, NULL, module->name, strlen(module->name), LY_VALUE_JSON, NULL, name,
494 strlen(name), &schema, &ext);
495 LY_CHECK_RET(r && (r != LY_ENOT), r);
496 }
497 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Inner node (container, notif, RPC, or action) \"%s\" not found.",
498 name), LY_ENOTFOUND);
499
500 LY_CHECK_RET(lyd_create_inner(schema, &ret));
501 if (ext) {
502 ret->flags |= LYD_EXT;
503 }
504 if (parent) {
505 lyd_insert_node(parent, NULL, ret, 0);
506 }
507
508 if (node) {
509 *node = ret;
510 }
511 return LY_SUCCESS;
512}
513
514LIBYANG_API_DEF LY_ERR
515lyd_new_ext_inner(const struct lysc_ext_instance *ext, const char *name, struct lyd_node **node)
516{
517 struct lyd_node *ret = NULL;
518 const struct lysc_node *schema;
519 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
520
521 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
522
523 schema = lysc_ext_find_node(ext, NULL, name, 0, LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, 0);
524 if (!schema) {
525 if (ext->argument) {
526 LOGERR(ctx, LY_EINVAL, "Inner node (not a list) \"%s\" not found in instance \"%s\" of extension %s.",
527 name, ext->argument, ext->def->name);
528 } else {
529 LOGERR(ctx, LY_EINVAL, "Inner node (not a list) \"%s\" not found in instance of extension %s.",
530 name, ext->def->name);
531 }
532 return LY_ENOTFOUND;
533 }
534 LY_CHECK_RET(lyd_create_inner(schema, &ret));
535
536 *node = ret;
537
538 return LY_SUCCESS;
539}
540
541/**
542 * @brief Create a new list node in the data tree.
543 *
544 * @param[in] parent Parent node for the node being created. NULL in case of creating a top level element.
545 * @param[in] module Module of the node being created. If NULL, @p parent module will be used.
546 * @param[in] name Schema node name of the new data node. The node must be #LYS_LIST.
547 * @param[in] format Format of key values.
548 * @param[in] output Flag in case the @p parent is RPC/Action. If value is 0, the input's data nodes of the RPC/Action are
549 * taken into consideration. Otherwise, the output's data node is going to be created.
550 * @param[out] node Optional created node.
551 * @param[in] ap Ordered key values of the new list instance, all must be set. For ::LY_VALUE_LYB, every value must
552 * be followed by the value length.
553 * @return LY_ERR value.
554 */
555static LY_ERR
556_lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, LY_VALUE_FORMAT format,
557 ly_bool output, struct lyd_node **node, va_list ap)
558{
559 struct lyd_node *ret = NULL, *key;
560 const struct lysc_node *schema, *key_s;
561 struct lysc_ext_instance *ext = NULL;
562 const struct ly_ctx *ctx = parent ? LYD_CTX(parent) : (module ? module->ctx : NULL);
563 const void *key_val;
564 uint32_t key_len;
565 LY_ERR r, rc = LY_SUCCESS;
566
567 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
568 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
569
570 if (!module) {
571 module = parent->schema->module;
572 }
573
574 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYS_LIST, output ? LYS_GETNEXT_OUTPUT : 0);
575 if (!schema && parent) {
576 r = ly_nested_ext_schema(parent, NULL, module->name, strlen(module->name), LY_VALUE_JSON, NULL, name,
577 strlen(name), &schema, &ext);
578 LY_CHECK_RET(r && (r != LY_ENOT), r);
579 }
580 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
581
582 /* create list inner node */
583 LY_CHECK_RET(lyd_create_inner(schema, &ret));
584
585 /* create and insert all the keys */
586 for (key_s = lysc_node_child(schema); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
587 if (format == LY_VALUE_LYB) {
588 key_val = va_arg(ap, const void *);
589 key_len = va_arg(ap, uint32_t);
590 } else {
591 key_val = va_arg(ap, const char *);
592 key_len = key_val ? strlen((char *)key_val) : 0;
593 }
594
595 rc = lyd_create_term(key_s, key_val, key_len, NULL, format, NULL, LYD_HINT_DATA, NULL, &key);
596 LY_CHECK_GOTO(rc, cleanup);
597 lyd_insert_node(ret, NULL, key, 1);
598 }
599
600 if (ext) {
601 ret->flags |= LYD_EXT;
602 }
603 if (parent) {
604 lyd_insert_node(parent, NULL, ret, 0);
605 }
606
607cleanup:
608 if (rc) {
609 lyd_free_tree(ret);
610 ret = NULL;
611 } else if (node) {
612 *node = ret;
613 }
614 return rc;
615}
616
617LIBYANG_API_DEF LY_ERR
618lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
619 struct lyd_node **node, ...)
620{
621 LY_ERR rc;
622 va_list ap;
623
624 va_start(ap, node);
625
626 rc = _lyd_new_list(parent, module, name, LY_VALUE_JSON, output, node, ap);
627
628 va_end(ap);
629 return rc;
630}
631
632LIBYANG_API_DEF LY_ERR
633lyd_new_list_bin(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
634 struct lyd_node **node, ...)
635{
636 LY_ERR rc;
637 va_list ap;
638
639 va_start(ap, node);
640
641 rc = _lyd_new_list(parent, module, name, LY_VALUE_LYB, output, node, ap);
642
643 va_end(ap);
644 return rc;
645}
646
647LIBYANG_API_DEF LY_ERR
648lyd_new_list_canon(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
649 struct lyd_node **node, ...)
650{
651 LY_ERR rc;
652 va_list ap;
653
654 va_start(ap, node);
655
656 rc = _lyd_new_list(parent, module, name, LY_VALUE_CANON, output, node, ap);
657
658 va_end(ap);
659 return rc;
660}
661
662LIBYANG_API_DEF LY_ERR
663lyd_new_ext_list(const struct lysc_ext_instance *ext, const char *name, struct lyd_node **node, ...)
664{
665 struct lyd_node *ret = NULL, *key;
666 const struct lysc_node *schema, *key_s;
667 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
668 va_list ap;
669 const char *key_val;
670 LY_ERR rc = LY_SUCCESS;
671
672 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
673
674 schema = lysc_ext_find_node(ext, NULL, name, 0, LYS_LIST, 0);
675 if (!schema) {
676 if (ext->argument) {
677 LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found in instance \"%s\" of extension %s.",
678 name, ext->argument, ext->def->name);
679 } else {
680 LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found in instance of extension %s.", name, ext->def->name);
681 }
682 return LY_ENOTFOUND;
683 }
684 /* create list inner node */
685 LY_CHECK_RET(lyd_create_inner(schema, &ret));
686
687 va_start(ap, node);
688
689 /* create and insert all the keys */
690 for (key_s = lysc_node_child(schema); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
691 key_val = va_arg(ap, const char *);
692
693 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA,
694 NULL, &key);
695 LY_CHECK_GOTO(rc, cleanup);
696 lyd_insert_node(ret, NULL, key, 1);
697 }
698
699cleanup:
700 va_end(ap);
701 if (rc) {
702 lyd_free_tree(ret);
703 ret = NULL;
704 }
705 *node = ret;
706 return rc;
707}
708
709LIBYANG_API_DEF LY_ERR
710lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
711 ly_bool output, struct lyd_node **node)
712{
713 LY_ERR r;
714 struct lyd_node *ret = NULL;
715 const struct lysc_node *schema;
716 struct lysc_ext_instance *ext = NULL;
717 const struct ly_ctx *ctx = parent ? LYD_CTX(parent) : (module ? module->ctx : NULL);
718
719 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
720 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
721
722 if (!module) {
723 module = parent->schema->module;
724 }
725 if (!keys) {
726 keys = "";
727 }
728
729 /* find schema node */
730 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYS_LIST, output ? LYS_GETNEXT_OUTPUT : 0);
731 if (!schema && parent) {
732 r = ly_nested_ext_schema(parent, NULL, module->name, strlen(module->name), LY_VALUE_JSON, NULL, name, strlen(name),
733 &schema, &ext);
734 LY_CHECK_RET(r && (r != LY_ENOT), r);
735 }
736 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
737
738 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
739 /* key-less list */
740 LY_CHECK_RET(lyd_create_inner(schema, &ret));
741 } else {
742 /* create the list node */
743 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
744 }
745 if (ext) {
746 ret->flags |= LYD_EXT;
747 }
748 if (parent) {
749 lyd_insert_node(parent, NULL, ret, 0);
750 }
751
752 if (node) {
753 *node = ret;
754 }
755 return LY_SUCCESS;
756}
757
758/**
759 * @brief Create a new term node in the data tree.
760 *
761 * @param[in] parent Parent node for the node being created. NULL in case of creating a top level element.
762 * @param[in] module Module of the node being created. If NULL, @p parent module will be used.
763 * @param[in] name Schema node name of the new data node. The node can be ::LYS_LEAF or ::LYS_LEAFLIST.
764 * @param[in] value Value of the node being created.
765 * @param[in] value_len Length of @p value.
766 * @param[in] format Format of @p value.
767 * @param[in] output Flag in case the @p parent is RPC/Action. If value is 0, the input's data nodes of the RPC/Action are
768 * taken into consideration. Otherwise, the output's data node is going to be created.
769 * @param[out] node Optional created node.
770 * @return LY_ERR value.
771 */
772static LY_ERR
773_lyd_new_term(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
774 size_t value_len, LY_VALUE_FORMAT format, ly_bool output, struct lyd_node **node)
775{
776 LY_ERR r;
777 struct lyd_node *ret = NULL;
778 const struct lysc_node *schema;
779 struct lysc_ext_instance *ext = NULL;
780 const struct ly_ctx *ctx = parent ? LYD_CTX(parent) : (module ? module->ctx : NULL);
781
782 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
783 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
784
785 if (!module) {
786 module = parent->schema->module;
787 }
788
789 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYD_NODE_TERM, output ? LYS_GETNEXT_OUTPUT : 0);
790 if (!schema && parent) {
791 r = ly_nested_ext_schema(parent, NULL, module->name, strlen(module->name), LY_VALUE_JSON, NULL, name,
792 strlen(name), &schema, &ext);
793 LY_CHECK_RET(r && (r != LY_ENOT), r);
794 }
795 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
796
797 LY_CHECK_RET(lyd_create_term(schema, value, value_len, NULL, format, NULL, LYD_HINT_DATA, NULL, &ret));
798 if (ext) {
799 ret->flags |= LYD_EXT;
800 }
801 if (parent) {
802 lyd_insert_node(parent, NULL, ret, 0);
803 }
804
805 if (node) {
806 *node = ret;
807 }
808 return LY_SUCCESS;
809}
810
811LIBYANG_API_DEF LY_ERR
812lyd_new_term(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *val_str,
813 ly_bool output, struct lyd_node **node)
814{
815 return _lyd_new_term(parent, module, name, val_str, val_str ? strlen(val_str) : 0, LY_VALUE_JSON, output, node);
816}
817
818LIBYANG_API_DEF LY_ERR
819lyd_new_term_bin(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
820 size_t value_len, ly_bool output, struct lyd_node **node)
821{
822 return _lyd_new_term(parent, module, name, value, value_len, LY_VALUE_LYB, output, node);
823}
824
825LIBYANG_API_DEF LY_ERR
826lyd_new_term_canon(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *val_str,
827 ly_bool output, struct lyd_node **node)
828{
829 return _lyd_new_term(parent, module, name, val_str, val_str ? strlen(val_str) : 0, LY_VALUE_CANON, output, node);
830}
831
832LIBYANG_API_DEF LY_ERR
833lyd_new_ext_term(const struct lysc_ext_instance *ext, const char *name, const char *val_str, struct lyd_node **node)
834{
835 LY_ERR rc;
836 struct lyd_node *ret = NULL;
837 const struct lysc_node *schema;
838 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
839
840 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
841
842 schema = lysc_ext_find_node(ext, NULL, name, 0, LYD_NODE_TERM, 0);
843 if (!schema) {
844 if (ext->argument) {
845 LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found in instance \"%s\" of extension %s.",
846 name, ext->argument, ext->def->name);
847 } else {
848 LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found in instance of extension %s.", name, ext->def->name);
849 }
850 return LY_ENOTFOUND;
851 }
852 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, NULL, &ret);
853 LY_CHECK_RET(rc);
854
855 *node = ret;
856
857 return LY_SUCCESS;
858}
859
860LIBYANG_API_DEF LY_ERR
861lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
862 ly_bool use_value, LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
863{
864 LY_ERR r;
865 struct lyd_node *ret = NULL;
866 const struct lysc_node *schema;
867 struct lysc_ext_instance *ext = NULL;
868 const struct ly_ctx *ctx = parent ? LYD_CTX(parent) : (module ? module->ctx : NULL);
869
870 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
871 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
872
873 if (!module) {
874 module = parent->schema->module;
875 }
876
877 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYD_NODE_ANY, output ? LYS_GETNEXT_OUTPUT : 0);
878 if (!schema && parent) {
879 r = ly_nested_ext_schema(parent, NULL, module->name, strlen(module->name), LY_VALUE_JSON, NULL, name,
880 strlen(name), &schema, &ext);
881 LY_CHECK_RET(r && (r != LY_ENOT), r);
882 }
883 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
884
885 LY_CHECK_RET(lyd_create_any(schema, value, value_type, use_value, &ret));
886 if (ext) {
887 ret->flags |= LYD_EXT;
888 }
889 if (parent) {
890 lyd_insert_node(parent, NULL, ret, 0);
891 }
892
893 if (node) {
894 *node = ret;
895 }
896 return LY_SUCCESS;
897}
898
899LIBYANG_API_DEF LY_ERR
900lyd_new_ext_any(const struct lysc_ext_instance *ext, const char *name, const void *value, ly_bool use_value,
901 LYD_ANYDATA_VALUETYPE value_type, struct lyd_node **node)
902{
903 struct lyd_node *ret = NULL;
904 const struct lysc_node *schema;
905 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
906
907 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
908
909 schema = lysc_ext_find_node(ext, NULL, name, 0, LYD_NODE_ANY, 0);
910 if (!schema) {
911 if (ext->argument) {
912 LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found in instance \"%s\" of extension %s.",
913 name, ext->argument, ext->def->name);
914 } else {
915 LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found in instance of extension %s.", name, ext->def->name);
916 }
917 return LY_ENOTFOUND;
918 }
919 LY_CHECK_RET(lyd_create_any(schema, value, value_type, use_value, &ret));
920
921 *node = ret;
922
923 return LY_SUCCESS;
924}
925
926LIBYANG_API_DEF LY_ERR
927lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module, const char *name,
928 const char *val_str, ly_bool clear_dflt, struct lyd_meta **meta)
929{
930 const char *prefix, *tmp;
931 size_t pref_len, name_len;
932
933 LY_CHECK_ARG_RET(ctx, ctx || parent, name, module || strchr(name, ':'), parent || meta, LY_EINVAL);
934 LY_CHECK_CTX_EQUAL_RET(ctx, parent ? LYD_CTX(parent) : NULL, module ? module->ctx : NULL, LY_EINVAL);
935 if (!ctx) {
Michal Vasko33c48972022-07-20 10:28:07 +0200936 ctx = module ? module->ctx : LYD_CTX(parent);
Michal Vasko59892dd2022-05-13 11:02:30 +0200937 }
938
939 if (parent && !parent->schema) {
940 LOGERR(ctx, LY_EINVAL, "Cannot add metadata \"%s\" to an opaque node \"%s\".", name, LYD_NAME(parent));
941 return LY_EINVAL;
942 }
943 if (meta) {
944 *meta = NULL;
945 }
946
947 /* parse the name */
948 tmp = name;
949 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
950 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
951 return LY_EINVAL;
952 }
953
954 /* find the module */
955 if (prefix) {
956 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
957 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", (int)pref_len, prefix), LY_ENOTFOUND);
958 }
959
960 /* set value if none */
961 if (!val_str) {
962 val_str = "";
963 }
964
965 return lyd_create_meta(parent, meta, module, name, name_len, val_str, strlen(val_str), NULL, LY_VALUE_JSON,
966 NULL, LYD_HINT_DATA, parent ? parent->schema : NULL, clear_dflt, NULL);
967}
968
969LIBYANG_API_DEF LY_ERR
970lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, ly_bool clear_dflt, const struct lyd_attr *attr,
971 struct lyd_meta **meta)
972{
973 const struct lys_module *mod;
974
975 LY_CHECK_ARG_RET(NULL, ctx, attr, parent || meta, LY_EINVAL);
976 LY_CHECK_CTX_EQUAL_RET(ctx, parent ? LYD_CTX(parent) : NULL, LY_EINVAL);
977
978 if (parent && !parent->schema) {
Michal Vasko7b3a00e2023-08-09 11:58:03 +0200979 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".",
980 ((struct lyd_node_opaq *)parent)->name.name);
Michal Vasko59892dd2022-05-13 11:02:30 +0200981 return LY_EINVAL;
982 }
983 if (meta) {
984 *meta = NULL;
985 }
986
987 switch (attr->format) {
988 case LY_VALUE_XML:
989 mod = ly_ctx_get_module_implemented_ns(ctx, attr->name.module_ns);
990 if (!mod) {
991 LOGERR(ctx, LY_EINVAL, "Module with namespace \"%s\" not found.", attr->name.module_ns);
992 return LY_ENOTFOUND;
993 }
994 break;
995 case LY_VALUE_JSON:
996 mod = ly_ctx_get_module_implemented(ctx, attr->name.module_name);
997 if (!mod) {
998 LOGERR(ctx, LY_EINVAL, "Module \"%s\" not found.", attr->name.module_name);
999 return LY_ENOTFOUND;
1000 }
1001 break;
1002 default:
1003 LOGINT_RET(ctx);
1004 }
1005
1006 return lyd_create_meta(parent, meta, mod, attr->name.name, strlen(attr->name.name), attr->value, strlen(attr->value),
1007 NULL, attr->format, attr->val_prefix_data, attr->hints, parent ? parent->schema : NULL, clear_dflt, NULL);
1008}
1009
1010LIBYANG_API_DEF LY_ERR
1011lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
1012 const char *prefix, const char *module_name, struct lyd_node **node)
1013{
1014 struct lyd_node *ret = NULL;
1015
1016 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_name, !prefix || !strcmp(prefix, module_name), LY_EINVAL);
1017 LY_CHECK_CTX_EQUAL_RET(ctx, parent ? LYD_CTX(parent) : NULL, LY_EINVAL);
1018
1019 if (!ctx) {
1020 ctx = LYD_CTX(parent);
1021 }
1022 if (!value) {
1023 value = "";
1024 }
1025
1026 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_name,
1027 strlen(module_name), value, strlen(value), NULL, LY_VALUE_JSON, NULL, 0, &ret));
1028 if (parent) {
1029 lyd_insert_node(parent, NULL, ret, 1);
1030 }
1031
1032 if (node) {
1033 *node = ret;
1034 }
1035 return LY_SUCCESS;
1036}
1037
1038LIBYANG_API_DEF LY_ERR
1039lyd_new_opaq2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
1040 const char *prefix, const char *module_ns, struct lyd_node **node)
1041{
1042 struct lyd_node *ret = NULL;
1043
1044 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_ns, LY_EINVAL);
1045 LY_CHECK_CTX_EQUAL_RET(ctx, parent ? LYD_CTX(parent) : NULL, LY_EINVAL);
1046
1047 if (!ctx) {
1048 ctx = LYD_CTX(parent);
1049 }
1050 if (!value) {
1051 value = "";
1052 }
1053
1054 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_ns,
1055 strlen(module_ns), value, strlen(value), NULL, LY_VALUE_XML, NULL, 0, &ret));
1056 if (parent) {
1057 lyd_insert_node(parent, NULL, ret, 1);
1058 }
1059
1060 if (node) {
1061 *node = ret;
1062 }
1063 return LY_SUCCESS;
1064}
1065
1066LIBYANG_API_DEF LY_ERR
1067lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *value,
1068 struct lyd_attr **attr)
1069{
1070 struct lyd_attr *ret = NULL;
1071 const struct ly_ctx *ctx;
1072 const char *prefix, *tmp;
1073 size_t pref_len, name_len, mod_len;
1074
1075 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
1076
1077 ctx = LYD_CTX(parent);
1078
1079 /* parse the name */
1080 tmp = name;
1081 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1082 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
1083 return LY_EVALID;
1084 }
1085
1086 if ((pref_len == 3) && !strncmp(prefix, "xml", 3)) {
1087 /* not a prefix but special name */
1088 name = prefix;
1089 name_len += 1 + pref_len;
1090 prefix = NULL;
1091 pref_len = 0;
1092 }
1093
1094 /* get the module */
1095 if (module_name) {
1096 mod_len = strlen(module_name);
1097 } else {
1098 module_name = prefix;
1099 mod_len = pref_len;
1100 }
1101
1102 /* set value if none */
1103 if (!value) {
1104 value = "";
1105 }
1106
1107 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_name, mod_len, value,
1108 strlen(value), NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA));
1109
1110 if (attr) {
1111 *attr = ret;
1112 }
1113 return LY_SUCCESS;
1114}
1115
1116LIBYANG_API_DEF LY_ERR
1117lyd_new_attr2(struct lyd_node *parent, const char *module_ns, const char *name, const char *value,
1118 struct lyd_attr **attr)
1119{
1120 struct lyd_attr *ret = NULL;
1121 const struct ly_ctx *ctx;
1122 const char *prefix, *tmp;
1123 size_t pref_len, name_len;
1124
1125 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
1126
1127 ctx = LYD_CTX(parent);
1128
1129 /* parse the name */
1130 tmp = name;
1131 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1132 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
1133 return LY_EVALID;
1134 }
1135
1136 if ((pref_len == 3) && !strncmp(prefix, "xml", 3)) {
1137 /* not a prefix but special name */
1138 name = prefix;
1139 name_len += 1 + pref_len;
1140 prefix = NULL;
1141 pref_len = 0;
1142 }
1143
1144 /* set value if none */
1145 if (!value) {
1146 value = "";
1147 }
Michal Vasko825718f2022-11-10 10:33:51 +01001148 if (strchr(value, ':')) {
1149 LOGWRN(ctx, "Value \"%s\" prefix will never be interpreted as an XML prefix.", value);
1150 }
Michal Vasko59892dd2022-05-13 11:02:30 +02001151
1152 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_ns,
1153 module_ns ? strlen(module_ns) : 0, value, strlen(value), NULL, LY_VALUE_XML, NULL, LYD_HINT_DATA));
1154
1155 if (attr) {
1156 *attr = ret;
1157 }
1158 return LY_SUCCESS;
1159}
1160
1161/**
1162 * @brief Change the value of a term (leaf or leaf-list) node.
1163 *
1164 * Node changed this way is always considered explicitly set, meaning its default flag
1165 * is always cleared.
1166 *
1167 * @param[in] term Term node to change.
1168 * @param[in] value New value to set.
1169 * @param[in] value_len Length of @p value.
1170 * @param[in] format Format of @p value.
1171 * @return LY_SUCCESS if value was changed,
1172 * @return LY_EEXIST if value was the same and only the default flag was cleared,
1173 * @return LY_ENOT if the values were equal and no change occured,
1174 * @return LY_ERR value on other errors.
1175 */
1176static LY_ERR
1177_lyd_change_term(struct lyd_node *term, const void *value, size_t value_len, LY_VALUE_FORMAT format)
1178{
1179 LY_ERR ret = LY_SUCCESS;
1180 struct lysc_type *type;
1181 struct lyd_node_term *t;
1182 struct lyd_node *parent;
1183 struct lyd_value val;
1184 ly_bool dflt_change, val_change;
1185
1186 assert(term && term->schema && (term->schema->nodetype & LYD_NODE_TERM));
1187
1188 t = (struct lyd_node_term *)term;
1189 type = ((struct lysc_node_leaf *)term->schema)->type;
1190
1191 /* parse the new value */
1192 LOG_LOCSET(term->schema, term, NULL, NULL);
1193 ret = lyd_value_store(LYD_CTX(term), &val, type, value, value_len, NULL, format, NULL, LYD_HINT_DATA, term->schema, NULL);
1194 LOG_LOCBACK(term->schema ? 1 : 0, 1, 0, 0);
1195 LY_CHECK_GOTO(ret, cleanup);
1196
1197 /* compare original and new value */
1198 if (type->plugin->compare(&t->value, &val)) {
1199 /* values differ, switch them */
1200 type->plugin->free(LYD_CTX(term), &t->value);
1201 t->value = val;
1202 val_change = 1;
1203 } else {
1204 /* same values, free the new stored one */
1205 type->plugin->free(LYD_CTX(term), &val);
1206 val_change = 0;
1207 }
1208
1209 /* always clear the default flag */
1210 if (term->flags & LYD_DEFAULT) {
1211 for (parent = term; parent; parent = lyd_parent(parent)) {
1212 parent->flags &= ~LYD_DEFAULT;
1213 }
1214 dflt_change = 1;
1215 } else {
1216 dflt_change = 0;
1217 }
1218
1219 if (val_change || dflt_change) {
1220 /* make the node non-validated */
1221 term->flags &= LYD_NEW;
1222 }
1223
1224 if (val_change) {
1225 if (term->schema->nodetype == LYS_LEAFLIST) {
1226 /* leaf-list needs to be hashed again and re-inserted into parent */
1227 lyd_unlink_hash(term);
1228 lyd_hash(term);
1229 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1230 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1231 /* list needs to be updated if its key was changed */
1232 assert(term->parent->schema->nodetype == LYS_LIST);
1233 lyd_unlink_hash(lyd_parent(term));
1234 lyd_hash(lyd_parent(term));
1235 LY_CHECK_GOTO(ret = lyd_insert_hash(lyd_parent(term)), cleanup);
1236 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1237 }
1238
1239 /* retrun value */
1240 if (!val_change) {
1241 if (dflt_change) {
1242 /* only default flag change */
1243 ret = LY_EEXIST;
1244 } else {
1245 /* no change */
1246 ret = LY_ENOT;
1247 }
1248 } /* else value changed, LY_SUCCESS */
1249
1250cleanup:
1251 return ret;
1252}
1253
1254LIBYANG_API_DEF LY_ERR
1255lyd_change_term(struct lyd_node *term, const char *val_str)
1256{
1257 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1258
1259 return _lyd_change_term(term, val_str, val_str ? strlen(val_str) : 0, LY_VALUE_JSON);
1260}
1261
1262LIBYANG_API_DEF LY_ERR
1263lyd_change_term_bin(struct lyd_node *term, const void *value, size_t value_len)
1264{
1265 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1266
1267 return _lyd_change_term(term, value, value_len, LY_VALUE_LYB);
1268}
1269
1270LIBYANG_API_DEF LY_ERR
1271lyd_change_term_canon(struct lyd_node *term, const char *val_str)
1272{
1273 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1274
1275 return _lyd_change_term(term, val_str, val_str ? strlen(val_str) : 0, LY_VALUE_CANON);
1276}
1277
1278LIBYANG_API_DEF LY_ERR
1279lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1280{
1281 LY_ERR ret = LY_SUCCESS;
1282 struct lyd_meta *m2 = NULL;
1283 struct lyd_value val;
1284 ly_bool val_change;
1285
1286 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1287
1288 if (!val_str) {
1289 val_str = "";
1290 }
1291
1292 /* parse the new value into a new meta structure */
1293 ret = lyd_create_meta(NULL, &m2, meta->annotation->module, meta->name, strlen(meta->name), val_str, strlen(val_str),
1294 NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, meta->parent ? meta->parent->schema : NULL, 0, NULL);
1295 LY_CHECK_GOTO(ret, cleanup);
1296
1297 /* compare original and new value */
1298 if (lyd_compare_meta(meta, m2)) {
1299 /* values differ, switch them */
1300 val = meta->value;
1301 meta->value = m2->value;
1302 m2->value = val;
1303 val_change = 1;
1304 } else {
1305 val_change = 0;
1306 }
1307
1308 /* retrun value */
1309 if (!val_change) {
1310 /* no change */
1311 ret = LY_ENOT;
1312 } /* else value changed, LY_SUCCESS */
1313
1314cleanup:
1315 lyd_free_meta_single(m2);
1316 return ret;
1317}
1318
1319/**
1320 * @brief Update node value.
1321 *
1322 * @param[in] node Node to update.
1323 * @param[in] value New value to set.
1324 * @param[in] value_len Length of @p value.
1325 * @param[in] value_type Type of @p value for anydata/anyxml node.
1326 * @param[in] format Format of @p value.
1327 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
1328 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
1329 * @return LY_ERR value.
1330 */
1331static LY_ERR
1332lyd_new_path_update(struct lyd_node *node, const void *value, size_t value_len, LYD_ANYDATA_VALUETYPE value_type,
1333 LY_VALUE_FORMAT format, struct lyd_node **new_parent, struct lyd_node **new_node)
1334{
1335 LY_ERR ret = LY_SUCCESS;
1336 struct lyd_node *new_any;
1337
1338 switch (node->schema->nodetype) {
1339 case LYS_CONTAINER:
1340 case LYS_NOTIF:
1341 case LYS_RPC:
1342 case LYS_ACTION:
1343 case LYS_LIST:
1344 /* if it exists, there is nothing to update */
1345 *new_parent = NULL;
1346 *new_node = NULL;
1347 break;
1348 case LYS_LEAFLIST:
1349 if (!lysc_is_dup_inst_list(node->schema)) {
1350 /* if it exists, there is nothing to update */
1351 *new_parent = NULL;
1352 *new_node = NULL;
1353 break;
1354 }
1355 /* fallthrough */
1356 case LYS_LEAF:
1357 ret = _lyd_change_term(node, value, value_len, format);
1358 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
1359 /* there was an actual change (at least of the default flag) */
1360 *new_parent = node;
1361 *new_node = node;
1362 ret = LY_SUCCESS;
1363 } else if (ret == LY_ENOT) {
1364 /* no change */
1365 *new_parent = NULL;
1366 *new_node = NULL;
1367 ret = LY_SUCCESS;
1368 } /* else error */
1369 break;
1370 case LYS_ANYDATA:
1371 case LYS_ANYXML:
1372 /* create a new any node */
1373 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, 0, &new_any));
1374
1375 /* compare with the existing one */
1376 if (lyd_compare_single(node, new_any, 0)) {
1377 /* not equal, switch values (so that we can use generic node free) */
1378 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
1379 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
1380 ((struct lyd_node_any *)node)->value.str = value;
1381 ((struct lyd_node_any *)node)->value_type = value_type;
1382
1383 *new_parent = node;
1384 *new_node = node;
1385 } else {
1386 /* they are equal */
1387 *new_parent = NULL;
1388 *new_node = NULL;
1389 }
1390 lyd_free_tree(new_any);
1391 break;
1392 default:
1393 LOGINT(LYD_CTX(node));
1394 ret = LY_EINT;
1395 break;
1396 }
1397
1398 return ret;
1399}
1400
1401static LY_ERR
1402lyd_new_path_check_find_lypath(struct ly_path *path, const char *str_path, const char *value, size_t value_len,
1403 LY_VALUE_FORMAT format, uint32_t options)
1404{
1405 LY_ERR r;
1406 struct ly_path_predicate *pred;
1407 struct lyd_value val;
1408 const struct lysc_node *schema = NULL;
1409 LY_ARRAY_COUNT_TYPE u, new_count;
1410 int create = 0;
1411
1412 assert(path);
1413
1414 /* go through all the compiled nodes */
1415 LY_ARRAY_FOR(path, u) {
1416 schema = path[u].node;
1417
1418 if (lysc_is_dup_inst_list(schema)) {
Michal Vasko5de21542023-03-20 10:00:05 +01001419 if (!path[u].predicates ||
1420 ((schema->nodetype == LYS_LEAFLIST) && (path[u].predicates[0].type == LY_PATH_PREDTYPE_LEAFLIST))) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001421 /* creating a new key-less list or state leaf-list instance */
1422 create = 1;
1423 new_count = u;
Michal Vasko90189962023-02-28 12:10:34 +01001424 } else if (path[u].predicates[0].type != LY_PATH_PREDTYPE_POSITION) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001425 LOG_LOCSET(schema, NULL, NULL, NULL);
Michal Vasko5de21542023-03-20 10:00:05 +01001426 LOGVAL(schema->module->ctx, LYVE_XPATH, "Invalid predicate for state %s \"%s\" in path \"%s\".",
Michal Vasko59892dd2022-05-13 11:02:30 +02001427 lys_nodetype2str(schema->nodetype), schema->name, str_path);
1428 LOG_LOCBACK(1, 0, 0, 0);
1429 return LY_EINVAL;
1430 }
Michal Vasko90189962023-02-28 12:10:34 +01001431 } else if ((schema->nodetype == LYS_LIST) &&
1432 (!path[u].predicates || (path[u].predicates[0].type != LY_PATH_PREDTYPE_LIST))) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001433 if ((u < LY_ARRAY_COUNT(path) - 1) || !(options & LYD_NEW_PATH_OPAQ)) {
1434 LOG_LOCSET(schema, NULL, NULL, NULL);
1435 LOGVAL(schema->module->ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1436 lys_nodetype2str(schema->nodetype), schema->name, str_path);
1437 LOG_LOCBACK(1, 0, 0, 0);
1438 return LY_EINVAL;
1439 } /* else creating an opaque list */
Michal Vasko90189962023-02-28 12:10:34 +01001440 } else if ((schema->nodetype == LYS_LEAFLIST) &&
1441 (!path[u].predicates || (path[u].predicates[0].type != LY_PATH_PREDTYPE_LEAFLIST))) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001442 r = LY_SUCCESS;
1443 if (options & LYD_NEW_PATH_OPAQ) {
1444 r = lyd_value_validate(NULL, schema, value, value_len, NULL, NULL, NULL);
1445 }
1446 if (!r) {
1447 /* try to store the value */
1448 LY_CHECK_RET(lyd_value_store(schema->module->ctx, &val, ((struct lysc_node_leaflist *)schema)->type,
1449 value, value_len, NULL, format, NULL, LYD_HINT_DATA, schema, NULL));
1450 ++((struct lysc_type *)val.realtype)->refcount;
1451
1452 /* store the new predicate so that it is used when searching for this instance */
Michal Vasko59892dd2022-05-13 11:02:30 +02001453 LY_ARRAY_NEW_RET(schema->module->ctx, path[u].predicates, pred, LY_EMEM);
Michal Vasko90189962023-02-28 12:10:34 +01001454 pred->type = LY_PATH_PREDTYPE_LEAFLIST;
Michal Vasko59892dd2022-05-13 11:02:30 +02001455 pred->value = val;
1456 } /* else we have opaq flag and the value is not valid, leave no predicate and then create an opaque node */
1457 }
1458 }
1459
1460 if (create) {
1461 /* hide the nodes that should always be created so they are not found */
1462 while (new_count < LY_ARRAY_COUNT(path)) {
1463 LY_ARRAY_DECREMENT(path);
1464 }
1465 }
1466
1467 return LY_SUCCESS;
1468}
1469
1470/**
1471 * @brief Create a new node in the data tree based on a path. All node types can be created.
1472 *
1473 * If @p path points to a list key, the key value from the predicate is used and @p value is ignored.
1474 * Also, if a leaf-list is being created and both a predicate is defined in @p path
1475 * and @p value is set, the predicate is preferred.
1476 *
1477 * For key-less lists and state leaf-lists, positional predicates can be used. If no preciate is used for these
1478 * nodes, they are always created.
1479 *
1480 * @param[in] parent Data parent to add to/modify, can be NULL. Note that in case a first top-level sibling is used,
1481 * it may no longer be first if @p path is absolute and starts with a non-existing top-level node inserted
1482 * before @p parent. Use ::lyd_first_sibling() to adjust @p parent in these cases.
1483 * @param[in] ctx libyang context, must be set if @p parent is NULL.
1484 * @param[in] ext Extension instance where the node being created is defined. This argument takes effect only for absolute
1485 * path or when the relative paths touches document root (top-level). In such cases the present extension instance replaces
1486 * searching for the appropriate module.
1487 * @param[in] path [Path](@ref howtoXPath) to create.
1488 * @param[in] value Value of the new leaf/leaf-list (const char *) in ::LY_VALUE_JSON format. If creating an
1489 * anyxml/anydata node, the expected type depends on @p value_type. For other node types, it should be NULL.
1490 * @param[in] value_len Length of @p value in bytes. May be 0 if @p value is a zero-terminated string. Ignored when
1491 * creating anyxml/anydata nodes.
1492 * @param[in] value_type Anyxml/anydata node @p value type.
1493 * @param[in] options Bitmask of options, see @ref pathoptions.
1494 * @param[out] new_parent Optional first parent node created. If only one node was created, equals to @p new_node.
1495 * @param[out] new_node Optional last node created.
1496 * @return LY_ERR value.
1497 */
1498static LY_ERR
1499lyd_new_path_(struct lyd_node *parent, const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, const char *path,
1500 const void *value, size_t value_len, LYD_ANYDATA_VALUETYPE value_type, uint32_t options,
1501 struct lyd_node **new_parent, struct lyd_node **new_node)
1502{
1503 LY_ERR ret = LY_SUCCESS, r;
1504 struct lyxp_expr *exp = NULL;
1505 struct ly_path *p = NULL;
1506 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1507 const struct lysc_node *schema;
1508 const struct lyd_value *val = NULL;
1509 LY_ARRAY_COUNT_TYPE path_idx = 0, orig_count = 0;
1510 LY_VALUE_FORMAT format;
1511
1512 assert(parent || ctx);
1513 assert(path && ((path[0] == '/') || parent));
1514 assert(!(options & LYD_NEW_PATH_BIN_VALUE) || !(options & LYD_NEW_PATH_CANON_VALUE));
1515
1516 if (!ctx) {
1517 ctx = LYD_CTX(parent);
1518 }
1519 if (value && !value_len) {
1520 value_len = strlen(value);
1521 }
1522 if (options & LYD_NEW_PATH_BIN_VALUE) {
1523 format = LY_VALUE_LYB;
1524 } else if (options & LYD_NEW_PATH_CANON_VALUE) {
1525 format = LY_VALUE_CANON;
1526 } else {
1527 format = LY_VALUE_JSON;
1528 }
1529
1530 /* parse path */
Michal Vasko074d9a12023-06-22 08:23:41 +02001531 LY_CHECK_GOTO(ret = ly_path_parse(ctx, NULL, path, strlen(path), 0, LY_PATH_BEGIN_EITHER, LY_PATH_PREFIX_FIRST,
Michal Vasko59892dd2022-05-13 11:02:30 +02001532 LY_PATH_PRED_SIMPLE, &exp), cleanup);
1533
1534 /* compile path */
1535 LY_CHECK_GOTO(ret = ly_path_compile(ctx, NULL, lyd_node_schema(parent), ext, exp, options & LYD_NEW_PATH_OUTPUT ?
1536 LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p), cleanup);
1537
1538 /* check the compiled path before searching existing nodes, it may be shortened */
1539 orig_count = LY_ARRAY_COUNT(p);
1540 LY_CHECK_GOTO(ret = lyd_new_path_check_find_lypath(p, path, value, value_len, format, options), cleanup);
1541
1542 /* try to find any existing nodes in the path */
1543 if (parent) {
Michal Vaskof2560512023-03-03 09:54:47 +01001544 r = ly_path_eval_partial(p, parent, NULL, &path_idx, &node);
1545 if (r == LY_SUCCESS) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001546 if (orig_count == LY_ARRAY_COUNT(p)) {
1547 /* the node exists, are we supposed to update it or is it just a default? */
1548 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
1549 LOG_LOCSET(NULL, node, NULL, NULL);
Michal Vaskoa9764922023-02-09 13:59:07 +01001550 LOGVAL(ctx, LYVE_REFERENCE, "Path \"%s\" already exists.", path);
Michal Vasko59892dd2022-05-13 11:02:30 +02001551 LOG_LOCBACK(0, 1, 0, 0);
1552 ret = LY_EEXIST;
1553 goto cleanup;
1554 }
1555
1556 /* update the existing node */
1557 ret = lyd_new_path_update(node, value, value_len, value_type, format, &nparent, &nnode);
1558 goto cleanup;
1559 } /* else we were not searching for the whole path */
Michal Vaskof2560512023-03-03 09:54:47 +01001560 } else if (r == LY_EINCOMPLETE) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001561 /* some nodes were found, adjust the iterator to the next segment */
1562 ++path_idx;
Michal Vaskof2560512023-03-03 09:54:47 +01001563 } else if (r == LY_ENOTFOUND) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001564 /* we will create the nodes from top-level, default behavior (absolute path), or from the parent (relative path) */
1565 if (lysc_data_parent(p[0].node)) {
1566 node = parent;
1567 }
1568 } else {
1569 /* error */
Michal Vaskof2560512023-03-03 09:54:47 +01001570 ret = r;
Michal Vasko59892dd2022-05-13 11:02:30 +02001571 goto cleanup;
1572 }
1573 }
1574
1575 /* restore the full path for creating new nodes */
1576 while (orig_count > LY_ARRAY_COUNT(p)) {
1577 LY_ARRAY_INCREMENT(p);
1578 }
1579
1580 /* create all the non-existing nodes in a loop */
1581 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
1582 cur_parent = node;
1583 schema = p[path_idx].node;
1584
1585 switch (schema->nodetype) {
1586 case LYS_LIST:
1587 if (lysc_is_dup_inst_list(schema)) {
1588 /* create key-less list instance */
1589 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
Michal Vasko90189962023-02-28 12:10:34 +01001590 } else if ((options & LYD_NEW_PATH_OPAQ) && !p[path_idx].predicates) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001591 /* creating opaque list without keys */
1592 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1593 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_VALUE_JSON, NULL,
1594 LYD_NODEHINT_LIST, &node), cleanup);
1595 } else {
1596 /* create standard list instance */
Michal Vasko90189962023-02-28 12:10:34 +01001597 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, NULL, &node), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001598 }
1599 break;
1600 case LYS_CONTAINER:
1601 case LYS_NOTIF:
1602 case LYS_RPC:
1603 case LYS_ACTION:
1604 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1605 break;
1606 case LYS_LEAFLIST:
Michal Vasko90189962023-02-28 12:10:34 +01001607 if ((options & LYD_NEW_PATH_OPAQ) &&
1608 (!p[path_idx].predicates || (p[path_idx].predicates[0].type != LY_PATH_PREDTYPE_LEAFLIST))) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001609 /* we have not checked this only for dup-inst lists, otherwise it must be opaque */
1610 r = LY_EVALID;
1611 if (lysc_is_dup_inst_list(schema)) {
1612 /* validate value */
1613 r = lyd_value_validate(NULL, schema, value ? value : "", value_len, NULL, NULL, NULL);
1614 }
1615 if (r && (r != LY_EINCOMPLETE)) {
1616 /* creating opaque leaf-list */
1617 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), value, value_len,
1618 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, format, NULL,
1619 LYD_NODEHINT_LEAFLIST, &node), cleanup);
1620 break;
1621 }
1622 }
1623
1624 /* get value to set */
Michal Vasko90189962023-02-28 12:10:34 +01001625 if (p[path_idx].predicates && (p[path_idx].predicates[0].type == LY_PATH_PREDTYPE_LEAFLIST)) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001626 val = &p[path_idx].predicates[0].value;
1627 }
1628
1629 /* create a leaf-list instance */
1630 if (val) {
Michal Vasko90189962023-02-28 12:10:34 +01001631 LY_CHECK_GOTO(ret = lyd_create_term2(schema, val, &node), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001632 } else {
1633 LY_CHECK_GOTO(ret = lyd_create_term(schema, value, value_len, NULL, format, NULL, LYD_HINT_DATA,
1634 NULL, &node), cleanup);
1635 }
1636 break;
1637 case LYS_LEAF:
1638 if (lysc_is_key(schema) && cur_parent->schema) {
1639 /* it must have been already created or some error will occur later */
1640 lyd_find_sibling_schema(lyd_child(cur_parent), schema, &node);
1641 assert(node);
1642 goto next_iter;
1643 }
1644
1645 if (options & LYD_NEW_PATH_OPAQ) {
1646 if (cur_parent && !cur_parent->schema) {
1647 /* always create opaque nodes for opaque parents */
1648 r = LY_ENOT;
1649 } else {
1650 /* validate value */
1651 r = lyd_value_validate(NULL, schema, value ? value : "", value_len, NULL, NULL, NULL);
1652 }
1653 if (r && (r != LY_EINCOMPLETE)) {
1654 /* creating opaque leaf */
1655 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), value, value_len,
1656 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, format, NULL, 0, &node),
1657 cleanup);
1658 break;
1659 }
1660 }
1661
1662 /* create a leaf instance */
1663 LY_CHECK_GOTO(ret = lyd_create_term(schema, value, value_len, NULL, format, NULL, LYD_HINT_DATA, NULL,
1664 &node), cleanup);
1665 break;
1666 case LYS_ANYDATA:
1667 case LYS_ANYXML:
1668 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, 0, &node), cleanup);
1669 break;
1670 default:
1671 LOGINT(ctx);
1672 ret = LY_EINT;
1673 goto cleanup;
1674 }
1675
1676 if (p[path_idx].ext) {
1677 node->flags |= LYD_EXT;
1678 }
1679 if (cur_parent) {
1680 /* connect to the parent */
1681 lyd_insert_node(cur_parent, NULL, node, 0);
1682 } else if (parent) {
1683 /* connect to top-level siblings */
1684 lyd_insert_node(NULL, &parent, node, 0);
1685 }
1686
1687next_iter:
1688 /* update remembered nodes */
1689 if (!nparent) {
1690 nparent = node;
1691 }
1692 nnode = node;
1693 }
1694
1695cleanup:
1696 lyxp_expr_free(ctx, exp);
1697 if (p) {
1698 while (orig_count > LY_ARRAY_COUNT(p)) {
1699 LY_ARRAY_INCREMENT(p);
1700 }
1701 }
1702 ly_path_free(ctx, p);
1703 if (!ret) {
1704 /* set out params only on success */
1705 if (new_parent) {
1706 *new_parent = nparent;
1707 }
1708 if (new_node) {
1709 *new_node = nnode;
1710 }
1711 } else {
1712 lyd_free_tree(nparent);
1713 }
1714 return ret;
1715}
1716
1717LIBYANG_API_DEF LY_ERR
1718lyd_new_path(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const char *value, uint32_t options,
1719 struct lyd_node **node)
1720{
1721 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent,
1722 !(options & LYD_NEW_PATH_BIN_VALUE) || !(options & LYD_NEW_PATH_CANON_VALUE), LY_EINVAL);
1723 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, ctx, LY_EINVAL);
1724
1725 return lyd_new_path_(parent, ctx, NULL, path, value, 0, LYD_ANYDATA_STRING, options, node, NULL);
1726}
1727
1728LIBYANG_API_DEF LY_ERR
1729lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
1730 size_t value_len, LYD_ANYDATA_VALUETYPE value_type, uint32_t options, struct lyd_node **new_parent,
1731 struct lyd_node **new_node)
1732{
1733 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent,
1734 !(options & LYD_NEW_PATH_BIN_VALUE) || !(options & LYD_NEW_PATH_CANON_VALUE), LY_EINVAL);
1735 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, ctx, LY_EINVAL);
1736
1737 return lyd_new_path_(parent, ctx, NULL, path, value, value_len, value_type, options, new_parent, new_node);
1738}
1739
1740LIBYANG_API_DEF LY_ERR
1741lyd_new_ext_path(struct lyd_node *parent, const struct lysc_ext_instance *ext, const char *path, const void *value,
1742 uint32_t options, struct lyd_node **node)
1743{
1744 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
1745
1746 LY_CHECK_ARG_RET(ctx, ext, path, (path[0] == '/') || parent,
1747 !(options & LYD_NEW_PATH_BIN_VALUE) || !(options & LYD_NEW_PATH_CANON_VALUE), LY_EINVAL);
1748 LY_CHECK_CTX_EQUAL_RET(parent ? LYD_CTX(parent) : NULL, ctx, LY_EINVAL);
1749
1750 return lyd_new_path_(parent, ctx, ext, path, value, 0, LYD_ANYDATA_STRING, options, node, NULL);
1751}
1752
1753LY_ERR
1754lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001755 const struct lys_module *mod, struct ly_set *node_when, struct ly_set *node_types, struct ly_set *ext_node,
1756 uint32_t impl_opts, struct lyd_node **diff)
Michal Vasko59892dd2022-05-13 11:02:30 +02001757{
1758 LY_ERR ret;
1759 const struct lysc_node *iter = NULL;
1760 struct lyd_node *node = NULL;
1761 struct lyd_value **dflts;
1762 LY_ARRAY_COUNT_TYPE u;
1763 uint32_t getnext_opts;
1764
1765 assert(first && (parent || sparent || mod));
1766
1767 if (!sparent && parent) {
1768 sparent = parent->schema;
1769 }
1770
1771 getnext_opts = LYS_GETNEXT_WITHCHOICE;
1772 if (impl_opts & LYD_IMPLICIT_OUTPUT) {
1773 getnext_opts |= LYS_GETNEXT_OUTPUT;
1774 }
1775
1776 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, getnext_opts))) {
1777 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1778 continue;
1779 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1780 continue;
1781 }
1782
1783 switch (iter->nodetype) {
1784 case LYS_CHOICE:
1785 node = lys_getnext_data(NULL, *first, NULL, iter, NULL);
1786 if (!node && ((struct lysc_node_choice *)iter)->dflt) {
1787 /* create default case data */
1788 LY_CHECK_RET(lyd_new_implicit_r(parent, first, &((struct lysc_node_choice *)iter)->dflt->node,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001789 NULL, node_when, node_types, ext_node, impl_opts, diff));
Michal Vasko59892dd2022-05-13 11:02:30 +02001790 } else if (node) {
1791 /* create any default data in the existing case */
1792 assert(node->schema->parent->nodetype == LYS_CASE);
1793 LY_CHECK_RET(lyd_new_implicit_r(parent, first, node->schema->parent, NULL, node_when, node_types,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001794 ext_node, impl_opts, diff));
Michal Vasko59892dd2022-05-13 11:02:30 +02001795 }
1796 break;
1797 case LYS_CONTAINER:
1798 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1799 /* create default NP container */
1800 LY_CHECK_RET(lyd_create_inner(iter, &node));
1801 node->flags = LYD_DEFAULT | (lysc_has_when(iter) ? LYD_WHEN_TRUE : 0);
1802 lyd_insert_node(parent, first, node, 0);
1803
1804 if (lysc_has_when(iter) && node_when) {
1805 /* remember to resolve when */
1806 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
1807 }
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001808 if (ext_node) {
1809 /* store for ext instance node validation, if needed */
1810 LY_CHECK_RET(lyd_validate_node_ext(node, ext_node));
1811 }
Michal Vasko59892dd2022-05-13 11:02:30 +02001812 if (diff) {
1813 /* add into diff */
1814 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1815 }
1816
1817 /* create any default children */
1818 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, node_when, node_types,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001819 ext_node, impl_opts, diff));
Michal Vasko59892dd2022-05-13 11:02:30 +02001820 }
1821 break;
1822 case LYS_LEAF:
1823 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1824 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1825 /* create default leaf */
1826 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1827 if (ret == LY_EINCOMPLETE) {
1828 if (node_types) {
1829 /* remember to resolve type */
1830 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
1831 }
1832 } else if (ret) {
1833 return ret;
1834 }
1835 node->flags = LYD_DEFAULT | (lysc_has_when(iter) ? LYD_WHEN_TRUE : 0);
1836 lyd_insert_node(parent, first, node, 0);
1837
1838 if (lysc_has_when(iter) && node_when) {
1839 /* remember to resolve when */
1840 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
1841 }
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001842 if (ext_node) {
1843 /* store for ext instance node validation, if needed */
1844 LY_CHECK_RET(lyd_validate_node_ext(node, ext_node));
1845 }
Michal Vasko59892dd2022-05-13 11:02:30 +02001846 if (diff) {
1847 /* add into diff */
1848 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1849 }
1850 }
1851 break;
1852 case LYS_LEAFLIST:
1853 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1854 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1855 /* create all default leaf-lists */
1856 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1857 LY_ARRAY_FOR(dflts, u) {
1858 ret = lyd_create_term2(iter, dflts[u], &node);
1859 if (ret == LY_EINCOMPLETE) {
1860 if (node_types) {
1861 /* remember to resolve type */
1862 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
1863 }
1864 } else if (ret) {
1865 return ret;
1866 }
1867 node->flags = LYD_DEFAULT | (lysc_has_when(iter) ? LYD_WHEN_TRUE : 0);
1868 lyd_insert_node(parent, first, node, 0);
1869
1870 if (lysc_has_when(iter) && node_when) {
1871 /* remember to resolve when */
1872 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
1873 }
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001874 if (ext_node) {
1875 /* store for ext instance node validation, if needed */
1876 LY_CHECK_RET(lyd_validate_node_ext(node, ext_node));
1877 }
Michal Vasko59892dd2022-05-13 11:02:30 +02001878 if (diff) {
1879 /* add into diff */
1880 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1881 }
1882 }
1883 }
1884 break;
1885 default:
1886 /* without defaults */
1887 break;
1888 }
1889 }
1890
1891 return LY_SUCCESS;
1892}
1893
1894LIBYANG_API_DEF LY_ERR
1895lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
1896{
1897 LY_ERR ret = LY_SUCCESS;
1898 struct lyd_node *node;
1899 struct ly_set node_when = {0};
1900
1901 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1902 if (diff) {
1903 *diff = NULL;
1904 }
1905
1906 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskof87fbdf2023-07-11 10:20:02 +02001907 if (node->schema->nodetype & LYD_NODE_INNER) {
Michal Vasko59892dd2022-05-13 11:02:30 +02001908 LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, &node_when, NULL,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001909 NULL, implicit_options, diff), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001910 }
1911
1912 LYD_TREE_DFS_END(tree, node);
1913 }
1914
1915 /* resolve when and remove any invalid defaults */
Michal Vasko135719f2022-08-25 12:18:17 +02001916 ret = lyd_validate_unres(&tree, NULL, 0, &node_when, LYXP_IGNORE_WHEN, NULL, NULL, NULL, NULL, 0, diff);
Michal Vaskofbbea932022-06-07 11:00:55 +02001917 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001918
1919cleanup:
1920 ly_set_erase(&node_when, NULL);
1921 if (ret && diff) {
1922 lyd_free_all(*diff);
1923 *diff = NULL;
1924 }
1925 return ret;
1926}
1927
1928LIBYANG_API_DEF LY_ERR
1929lyd_new_implicit_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t implicit_options, struct lyd_node **diff)
1930{
1931 const struct lys_module *mod;
1932 struct lyd_node *d = NULL;
1933 uint32_t i = 0;
1934 LY_ERR ret = LY_SUCCESS;
1935
1936 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
1937 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL);
1938 if (diff) {
1939 *diff = NULL;
1940 }
1941 if (!ctx) {
1942 ctx = LYD_CTX(*tree);
1943 }
1944
1945 /* add nodes for each module one-by-one */
1946 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
1947 if (!mod->implemented) {
1948 continue;
1949 }
1950
1951 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
1952 if (d) {
1953 /* merge into one diff */
1954 lyd_insert_sibling(*diff, d, diff);
1955
1956 d = NULL;
1957 }
1958 }
1959
1960cleanup:
1961 if (ret && diff) {
1962 lyd_free_all(*diff);
1963 *diff = NULL;
1964 }
1965 return ret;
1966}
1967
1968LIBYANG_API_DEF LY_ERR
1969lyd_new_implicit_module(struct lyd_node **tree, const struct lys_module *module, uint32_t implicit_options,
1970 struct lyd_node **diff)
1971{
1972 LY_ERR ret = LY_SUCCESS;
1973 struct lyd_node *root, *d = NULL;
1974 struct ly_set node_when = {0};
1975
1976 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
1977 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module ? module->ctx : NULL, LY_EINVAL);
1978 if (diff) {
1979 *diff = NULL;
1980 }
1981
1982 /* add all top-level defaults for this module */
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001983 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, &node_when, NULL, NULL, implicit_options, diff),
1984 cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001985
1986 /* resolve when and remove any invalid defaults */
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001987 LY_CHECK_GOTO(ret = lyd_validate_unres(tree, module, 0, &node_when, LYXP_IGNORE_WHEN, NULL, NULL, NULL, NULL,
1988 0, diff), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001989
1990 /* process nested nodes */
1991 LY_LIST_FOR(*tree, root) {
Michal Vaskof87fbdf2023-07-11 10:20:02 +02001992 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
Michal Vasko59892dd2022-05-13 11:02:30 +02001993
Michal Vaskof87fbdf2023-07-11 10:20:02 +02001994 if (d) {
1995 /* merge into one diff */
1996 lyd_insert_sibling(*diff, d, diff);
1997 d = NULL;
Michal Vasko59892dd2022-05-13 11:02:30 +02001998 }
1999 }
2000
2001cleanup:
2002 ly_set_erase(&node_when, NULL);
2003 if (ret && diff) {
2004 lyd_free_all(*diff);
2005 *diff = NULL;
2006 }
2007 return ret;
2008}