blob: 4e0e18b32676980216f291000382c20c60e07064 [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
Michal Vaskob1b5c262020-03-05 14:29:47 +01002 * @file tree_data.c
Radek Krejcie7b95092019-05-15 11:03:07 +02003 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02004 * @brief Data tree functions
Radek Krejcie7b95092019-05-15 11:03:07 +02005 *
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02006 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
Radek Krejcie7b95092019-05-15 11:03:07 +02007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
16
17#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020018
Radek Krejci084289f2019-07-09 17:35:30 +020019#include <assert.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <ctype.h>
21#include <errno.h>
22#include <fcntl.h>
23#include <stdarg.h>
24#include <stdint.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include <stdio.h>
26#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include <string.h>
28#include <unistd.h>
29
Radek Krejci535ea9f2020-05-29 16:01:05 +020030#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020031#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020032#include "context.h"
33#include "dict.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020034#include "diff.h"
Michal Vasko90932a92020-02-12 14:33:03 +010035#include "hash_table.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020036#include "in_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020037#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020038#include "parser_data.h"
39#include "parser_internal.h"
Michal Vasko004d3152020-06-11 19:59:22 +020040#include "path.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020041#include "plugins_exts.h"
Michal Vasko90932a92020-02-12 14:33:03 +010042#include "plugins_exts_internal.h"
Michal Vasko69730152020-10-09 16:30:07 +020043#include "plugins_exts_metadata.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020044#include "plugins_types.h"
45#include "set.h"
46#include "tree.h"
47#include "tree_data_internal.h"
48#include "tree_schema.h"
49#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020050#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020051#include "xml.h"
52#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020053
Michal Vaskob104f112020-07-17 09:54:54 +020054static LY_ERR lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema,
Radek Krejci0f969882020-08-21 16:56:47 +020055 struct lyd_node **match);
Michal Vaskob104f112020-07-17 09:54:54 +020056
Radek Krejci084289f2019-07-09 17:35:30 +020057LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020058lyd_value_store(const struct ly_ctx *ctx, struct lyd_value *val, const struct lysc_type *type, const char *value,
59 size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints,
60 const struct lysc_node *ctx_node, ly_bool *incomplete, enum LY_VLOG_ELEM log_elem_type, const void *log_elem)
Radek Krejci084289f2019-07-09 17:35:30 +020061{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020062 LY_ERR ret;
Radek Krejci084289f2019-07-09 17:35:30 +020063 struct ly_err_item *err = NULL;
Michal Vasko25d6ad02020-10-22 12:20:22 +020064 uint32_t options = (dynamic && *dynamic ? LY_TYPE_STORE_DYNAMIC : 0);
Radek Krejci084289f2019-07-09 17:35:30 +020065
Michal Vaskofeca4fb2020-10-05 08:58:40 +020066 if (incomplete) {
67 *incomplete = 0;
Radek Krejci084289f2019-07-09 17:35:30 +020068 }
69
Michal Vaskofeca4fb2020-10-05 08:58:40 +020070 ret = type->plugin->store(ctx, type, value, value_len, options, format, prefix_data, hints, ctx_node, val, &err);
Michal Vasko90932a92020-02-12 14:33:03 +010071 if (ret == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +020072 if (incomplete) {
73 *incomplete = 1;
74 }
75 } else if (ret) {
76 if (err) {
77 LOGVAL(ctx, log_elem_type, log_elem, err->vecode, err->msg);
78 ly_err_free(err);
79 } else {
80 LOGVAL(ctx, log_elem_type, log_elem, LYVE_OTHER, "Storing value \"%.*s\" failed.", (int)value_len, value);
81 }
82 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +010083 }
84
Michal Vaskofeca4fb2020-10-05 08:58:40 +020085 if (dynamic) {
86 *dynamic = 0;
87 }
88 return LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +010089}
90
Radek Krejci38d85362019-09-05 16:26:38 +020091LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020092lyd_value_validate_incomplete(const struct ly_ctx *ctx, const struct lysc_type *type, struct lyd_value *val,
93 const struct lyd_node *ctx_node, const struct lyd_node *tree, enum LY_VLOG_ELEM log_elem_type, const void *log_elem)
Radek Krejci38d85362019-09-05 16:26:38 +020094{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020095 LY_ERR ret;
Radek Krejci38d85362019-09-05 16:26:38 +020096 struct ly_err_item *err = NULL;
Radek Krejci38d85362019-09-05 16:26:38 +020097
Michal Vaskofeca4fb2020-10-05 08:58:40 +020098 assert(type->plugin->validate);
Michal Vasko8d544252020-03-02 10:19:52 +010099
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200100 ret = type->plugin->validate(ctx, type, ctx_node, tree, val, &err);
101 if (ret) {
Radek Krejci38d85362019-09-05 16:26:38 +0200102 if (err) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200103 LOGVAL(ctx, log_elem_type, log_elem, err->vecode, err->msg);
Radek Krejci38d85362019-09-05 16:26:38 +0200104 ly_err_free(err);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200105 } else {
106 LOGVAL(ctx, log_elem_type, log_elem, LYVE_OTHER, "Resolving value \"%s\" failed.", val->canonical);
Radek Krejci38d85362019-09-05 16:26:38 +0200107 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200108 return ret;
Radek Krejci38d85362019-09-05 16:26:38 +0200109 }
110
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200111 return LY_SUCCESS;
Radek Krejci38d85362019-09-05 16:26:38 +0200112}
113
Michal Vaskof937cfe2020-08-03 16:07:12 +0200114LY_ERR
115_lys_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const char *value, size_t value_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200116 LY_PREFIX_FORMAT format, void *prefix_data)
Radek Krejci084289f2019-07-09 17:35:30 +0200117{
118 LY_ERR rc = LY_SUCCESS;
119 struct ly_err_item *err = NULL;
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200120 struct lyd_value storage;
Radek Krejci084289f2019-07-09 17:35:30 +0200121 struct lysc_type *type;
Radek Krejci084289f2019-07-09 17:35:30 +0200122
123 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
124
125 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
126 LOGARG(ctx, node);
127 return LY_EINVAL;
128 }
129
Michal Vasko22df3f02020-08-24 13:29:22 +0200130 type = ((struct lysc_node_leaf *)node)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200131 rc = type->plugin->store(ctx ? ctx : node->module->ctx, type, value, value_len, 0, format, prefix_data,
132 LYD_HINT_SCHEMA, node, &storage, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200133 if (rc == LY_EINCOMPLETE) {
134 /* actually success since we do not provide the context tree and call validation with
135 * LY_TYPE_OPTS_INCOMPLETE_DATA */
136 rc = LY_SUCCESS;
137 } else if (rc && err) {
138 if (ctx) {
139 /* log only in case the ctx was provided as input parameter */
140 ly_err_print(err);
141 LOGVAL(ctx, LY_VLOG_STR, err->path, err->vecode, err->msg);
Radek Krejci084289f2019-07-09 17:35:30 +0200142 }
Radek Krejci73dead22019-07-11 16:46:16 +0200143 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200144 }
145
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200146 if (!rc) {
147 type->plugin->free(ctx ? ctx : node->module->ctx, &storage);
148 }
Radek Krejci084289f2019-07-09 17:35:30 +0200149 return rc;
150}
151
152API LY_ERR
Michal Vaskof937cfe2020-08-03 16:07:12 +0200153lys_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const char *value, size_t value_len)
154{
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200155 return _lys_value_validate(ctx, node, value, value_len, LY_PREF_JSON, NULL);
Michal Vaskof937cfe2020-08-03 16:07:12 +0200156}
157
158API LY_ERR
Michal Vasko44685da2020-03-17 15:38:06 +0100159lyd_value_validate(const struct ly_ctx *ctx, const struct lyd_node_term *node, const char *value, size_t value_len,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200160 const struct lyd_node *tree, const struct lysc_type **realtype)
Radek Krejci084289f2019-07-09 17:35:30 +0200161{
162 LY_ERR rc;
163 struct ly_err_item *err = NULL;
164 struct lysc_type *type;
Michal Vasko3701af52020-08-03 14:29:38 +0200165 struct lyd_value val = {0};
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200166 ly_bool stored = 0;
Radek Krejci084289f2019-07-09 17:35:30 +0200167
168 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
169
Michal Vasko22df3f02020-08-24 13:29:22 +0200170 type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200171 /* store */
172 rc = type->plugin->store(ctx ? ctx : LYD_CTX(node), type, value, value_len, 0, LY_PREF_JSON, NULL,
173 LYD_HINT_DATA, node->schema, &val, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200174 if (rc == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200175 stored = 1;
176
177 /* resolve */
178 rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, (struct lyd_node *)node, tree, &val, &err);
179 }
180
181 if (rc) {
Radek Krejci73dead22019-07-11 16:46:16 +0200182 if (err) {
183 if (ctx) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200184 LOGVAL(ctx, LY_VLOG_LYD, node, err->vecode, err->msg);
Radek Krejci084289f2019-07-09 17:35:30 +0200185 }
Radek Krejci73dead22019-07-11 16:46:16 +0200186 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200187 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200188 if (stored) {
189 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
190 }
Radek Krejci73dead22019-07-11 16:46:16 +0200191 return rc;
Radek Krejci084289f2019-07-09 17:35:30 +0200192 }
193
Michal Vasko3701af52020-08-03 14:29:38 +0200194 if (realtype) {
195 *realtype = val.realtype;
196 }
197
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200198 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200199 return LY_SUCCESS;
200}
201
202API LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200203lyd_value_compare(const struct lyd_node_term *node, const char *value, size_t value_len)
Radek Krejci084289f2019-07-09 17:35:30 +0200204{
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200205 LY_ERR ret = LY_SUCCESS;
Radek Krejci084289f2019-07-09 17:35:30 +0200206 struct ly_ctx *ctx;
207 struct lysc_type *type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200208 struct lyd_value val = {0};
Radek Krejci084289f2019-07-09 17:35:30 +0200209
210 LY_CHECK_ARG_RET(node ? node->schema->module->ctx : NULL, node, value, LY_EINVAL);
211
212 ctx = node->schema->module->ctx;
Michal Vasko22df3f02020-08-24 13:29:22 +0200213 type = ((struct lysc_node_leaf *)node->schema)->type;
Radek Krejci084289f2019-07-09 17:35:30 +0200214
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200215 /* store the value */
216 ret = lyd_value_store(ctx, &val, type, value, value_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, node->schema,
217 NULL, LY_VLOG_LYSC, node->schema);
218 LY_CHECK_RET(ret);
Radek Krejci084289f2019-07-09 17:35:30 +0200219
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200220 /* compare values */
221 ret = type->plugin->compare(&node->value, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200222
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200223 type->plugin->free(ctx, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200224 return ret;
225}
226
Radek Krejci19611252020-10-04 13:54:53 +0200227API ly_bool
228lyd_is_default(const struct lyd_node *node)
229{
230 const struct lysc_node_leaf *leaf;
231 const struct lysc_node_leaflist *llist;
232 const struct lyd_node_term *term;
233 LY_ARRAY_COUNT_TYPE u;
234
235 assert(node->schema->nodetype & LYD_NODE_TERM);
236 term = (const struct lyd_node_term *)node;
237
238 if (node->schema->nodetype == LYS_LEAF) {
239 leaf = (const struct lysc_node_leaf *)node->schema;
240 if (!leaf->dflt) {
241 return 0;
242 }
243
244 /* compare with the default value */
245 if (leaf->type->plugin->compare(&term->value, leaf->dflt)) {
246 return 0;
247 }
248 } else {
249 llist = (const struct lysc_node_leaflist *)node->schema;
250 if (!llist->dflts) {
251 return 0;
252 }
253
254 LY_ARRAY_FOR(llist->dflts, u) {
255 /* compare with each possible default value */
256 if (llist->type->plugin->compare(&term->value, llist->dflts[u])) {
257 return 0;
258 }
259 }
260 }
261
262 return 1;
263}
264
Radek Krejci7931b192020-06-25 17:05:03 +0200265static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +0200266lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +0200267{
Michal Vasko69730152020-10-09 16:30:07 +0200268 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200269 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +0200270 const char *path = in->method.fpath.filepath;
271 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +0200272
273 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +0200274 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +0200275
Michal Vasko69730152020-10-09 16:30:07 +0200276 if ((len >= 5) && !strncmp(&path[len - 4], ".xml", 4)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200277 format = LYD_XML;
Michal Vasko69730152020-10-09 16:30:07 +0200278 } else if ((len >= 6) && !strncmp(&path[len - 5], ".json", 5)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200279 format = LYD_JSON;
Michal Vasko69730152020-10-09 16:30:07 +0200280 } else if ((len >= 5) && !strncmp(&path[len - 4], ".lyb", 4)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200281 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +0200282 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +0200283 }
284
Radek Krejci7931b192020-06-25 17:05:03 +0200285 return format;
286}
Radek Krejcie7b95092019-05-15 11:03:07 +0200287
Radek Krejci7931b192020-06-25 17:05:03 +0200288API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200289lyd_parse_data(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options,
Radek Krejci0f969882020-08-21 16:56:47 +0200290 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200291{
Radek Krejci1798aae2020-07-14 13:26:06 +0200292 LY_ERR ret = LY_SUCCESS;
293 struct lyd_ctx *lydctx = NULL;
294
Radek Krejci7931b192020-06-25 17:05:03 +0200295 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
296 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
297 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
298
299 format = lyd_parse_get_format(in, format);
300 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
301
Radek Krejci1798aae2020-07-14 13:26:06 +0200302 /* init */
303 *tree = NULL;
304
Michal Vasko63f3d842020-07-08 10:10:14 +0200305 /* remember input position */
306 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200307
308 switch (format) {
309 case LYD_XML:
Radek Krejci1798aae2020-07-14 13:26:06 +0200310 LY_CHECK_RET(lyd_parse_xml_data(ctx, in, parse_options, validate_options, tree, &lydctx));
311 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200312 case LYD_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +0200313 LY_CHECK_RET(lyd_parse_json_data(ctx, in, parse_options, validate_options, tree, &lydctx));
314 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200315 case LYD_LYB:
Radek Krejci1798aae2020-07-14 13:26:06 +0200316 LY_CHECK_RET(lyd_parse_lyb_data(ctx, in, parse_options, validate_options, tree, &lydctx));
317 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200318 case LYD_UNKNOWN:
Radek Krejci7931b192020-06-25 17:05:03 +0200319 LOGINT_RET(ctx);
320 }
321
Radek Krejci1798aae2020-07-14 13:26:06 +0200322 if (!(parse_options & LYD_PARSE_ONLY)) {
323 uint32_t i = 0;
324 const struct lys_module *mod;
325 struct lyd_node *first, *next, **first2;
Radek Krejci7931b192020-06-25 17:05:03 +0200326
Radek Krejci1798aae2020-07-14 13:26:06 +0200327 next = *tree;
328 while (1) {
329 if (validate_options & LYD_VALIDATE_PRESENT) {
330 mod = lyd_data_next_module(&next, &first);
331 } else {
332 mod = lyd_mod_next_module(next, NULL, ctx, &i, &first);
333 }
334 if (!mod) {
335 break;
336 }
337 if (first == *tree) {
338 /* make sure first2 changes are carried to tree */
339 first2 = tree;
340 } else {
341 first2 = &first;
342 }
343
344 /* validate new top-level nodes, autodelete CANNOT occur, all nodes are new */
345 LY_CHECK_GOTO(ret = lyd_validate_new(first2, NULL, mod, NULL), cleanup);
346
347 /* add all top-level defaults for this module */
348 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, &lydctx->unres_node_type, &lydctx->when_check,
Michal Vasko69730152020-10-09 16:30:07 +0200349 (validate_options & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200350 LY_CHECK_GOTO(ret, cleanup);
351
352 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200353 ret = lyd_validate_unres(tree, &lydctx->when_check, &lydctx->unres_node_type, &lydctx->unres_meta_type, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200354 LY_CHECK_GOTO(ret, cleanup);
355
356 /* perform final validation that assumes the data tree is final */
357 LY_CHECK_GOTO(ret = lyd_validate_final_r(*first2, NULL, mod, validate_options, 0), cleanup);
358 }
359 }
360
361cleanup:
Michal Vaskoafac7822020-10-20 14:22:26 +0200362 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200363 if (ret) {
364 lyd_free_all(*tree);
365 *tree = NULL;
366 }
367 return ret;
Radek Krejci7931b192020-06-25 17:05:03 +0200368}
369
370API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200371lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options,
Radek Krejci0f969882020-08-21 16:56:47 +0200372 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200373{
374 LY_ERR ret;
375 struct ly_in *in;
376
377 LY_CHECK_RET(ly_in_new_memory(data, &in));
378 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
379
380 ly_in_free(in, 0);
381 return ret;
382}
383
384API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200385lyd_parse_data_fd(const struct ly_ctx *ctx, int fd, LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options,
Radek Krejci0f969882020-08-21 16:56:47 +0200386 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200387{
388 LY_ERR ret;
389 struct ly_in *in;
390
391 LY_CHECK_RET(ly_in_new_fd(fd, &in));
392 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
393
394 ly_in_free(in, 0);
395 return ret;
396}
397
398API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200399lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
400 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200401{
402 LY_ERR ret;
403 struct ly_in *in;
404
405 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
406 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
407
408 ly_in_free(in, 0);
409 return ret;
410}
411
Radek Krejci7931b192020-06-25 17:05:03 +0200412API LY_ERR
413lyd_parse_rpc(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **op)
414{
415 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
416
417 format = lyd_parse_get_format(in, format);
418 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
419
Radek Krejci1798aae2020-07-14 13:26:06 +0200420 /* init */
421 *tree = NULL;
422 if (op) {
423 *op = NULL;
424 }
425
Michal Vasko63f3d842020-07-08 10:10:14 +0200426 /* remember input position */
427 in->func_start = in->current;
428
Radek Krejci7931b192020-06-25 17:05:03 +0200429 switch (format) {
430 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200431 return lyd_parse_xml_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200432 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200433 return lyd_parse_json_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200434 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200435 return lyd_parse_lyb_rpc(ctx, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200436 case LYD_UNKNOWN:
437 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200438 }
439
440 LOGINT_RET(ctx);
441}
442
443API LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +0200444lyd_parse_reply(const struct lyd_node *request, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree,
Radek Krejci0f969882020-08-21 16:56:47 +0200445 struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200446{
447 LY_CHECK_ARG_RET(NULL, request, LY_EINVAL);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200448 LY_CHECK_ARG_RET(LYD_CTX(request), in, tree || op, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200449
450 format = lyd_parse_get_format(in, format);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200451 LY_CHECK_ARG_RET(LYD_CTX(request), format, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200452
Radek Krejci1798aae2020-07-14 13:26:06 +0200453 /* init */
454 if (tree) {
455 *tree = NULL;
456 }
457 if (op) {
458 *op = NULL;
459 }
460
Michal Vasko63f3d842020-07-08 10:10:14 +0200461 /* remember input position */
462 in->func_start = in->current;
463
Radek Krejci7931b192020-06-25 17:05:03 +0200464 switch (format) {
465 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200466 return lyd_parse_xml_reply(request, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200467 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200468 return lyd_parse_json_reply(request, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200469 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200470 return lyd_parse_lyb_reply(request, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200471 case LYD_UNKNOWN:
472 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200473 }
474
Michal Vaskob7be7a82020-08-20 09:09:04 +0200475 LOGINT_RET(LYD_CTX(request));
Radek Krejci7931b192020-06-25 17:05:03 +0200476}
477
478API LY_ERR
479lyd_parse_notif(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **ntf)
480{
Radek Krejci1798aae2020-07-14 13:26:06 +0200481 LY_CHECK_ARG_RET(ctx, ctx, in, tree || ntf, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200482
483 format = lyd_parse_get_format(in, format);
484 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
485
Radek Krejci1798aae2020-07-14 13:26:06 +0200486 /* init */
487 if (tree) {
488 *tree = NULL;
489 }
490 if (ntf) {
491 *ntf = NULL;
492 }
493
Michal Vasko63f3d842020-07-08 10:10:14 +0200494 /* remember input position */
495 in->func_start = in->current;
496
Radek Krejci7931b192020-06-25 17:05:03 +0200497 switch (format) {
498 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200499 return lyd_parse_xml_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200500 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200501 return lyd_parse_json_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200502 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200503 return lyd_parse_lyb_notif(ctx, in, tree, ntf);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200504 case LYD_UNKNOWN:
505 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200506 }
507
508 LOGINT_RET(ctx);
Radek Krejcie7b95092019-05-15 11:03:07 +0200509}
Radek Krejci084289f2019-07-09 17:35:30 +0200510
Michal Vasko90932a92020-02-12 14:33:03 +0100511LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200512lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
513 LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100514{
515 LY_ERR ret;
516 struct lyd_node_term *term;
517
Michal Vasko9b368d32020-02-14 13:53:31 +0100518 assert(schema->nodetype & LYD_NODE_TERM);
519
Michal Vasko90932a92020-02-12 14:33:03 +0100520 term = calloc(1, sizeof *term);
521 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
522
523 term->schema = schema;
524 term->prev = (struct lyd_node *)term;
Michal Vasko9b368d32020-02-14 13:53:31 +0100525 term->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100526
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200527 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
528 value_len, dynamic, format, prefix_data, hints, schema, incomplete, LY_VLOG_LYSC, schema);
529 LY_CHECK_ERR_RET(ret, free(term), ret);
Michal Vasko9b368d32020-02-14 13:53:31 +0100530 lyd_hash((struct lyd_node *)term);
531
532 *node = (struct lyd_node *)term;
533 return ret;
534}
535
536LY_ERR
537lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
538{
539 LY_ERR ret;
540 struct lyd_node_term *term;
541 struct lysc_type *type;
542
543 assert(schema->nodetype & LYD_NODE_TERM);
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200544 assert(val && val->canonical && val->realtype);
Michal Vasko9b368d32020-02-14 13:53:31 +0100545
546 term = calloc(1, sizeof *term);
547 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
548
549 term->schema = schema;
550 term->prev = (struct lyd_node *)term;
551 term->flags = LYD_NEW;
552
553 type = ((struct lysc_node_leaf *)schema)->type;
554 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
555 if (ret) {
556 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
557 free(term);
558 return ret;
559 }
560 lyd_hash((struct lyd_node *)term);
Michal Vasko90932a92020-02-12 14:33:03 +0100561
562 *node = (struct lyd_node *)term;
563 return ret;
564}
565
566LY_ERR
567lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
568{
569 struct lyd_node_inner *in;
570
Michal Vasko9b368d32020-02-14 13:53:31 +0100571 assert(schema->nodetype & LYD_NODE_INNER);
572
Michal Vasko90932a92020-02-12 14:33:03 +0100573 in = calloc(1, sizeof *in);
574 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
575
576 in->schema = schema;
577 in->prev = (struct lyd_node *)in;
Michal Vasko9b368d32020-02-14 13:53:31 +0100578 in->flags = LYD_NEW;
Michal Vasko3383be72020-11-03 17:15:31 +0100579 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
580 in->flags |= LYD_DEFAULT;
581 }
Michal Vasko90932a92020-02-12 14:33:03 +0100582
Michal Vasko9b368d32020-02-14 13:53:31 +0100583 /* do not hash list with keys, we need them for the hash */
584 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
585 lyd_hash((struct lyd_node *)in);
586 }
Michal Vasko90932a92020-02-12 14:33:03 +0100587
588 *node = (struct lyd_node *)in;
589 return LY_SUCCESS;
590}
591
Michal Vasko90932a92020-02-12 14:33:03 +0100592LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +0200593lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100594{
595 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100596 struct lyd_node *list = NULL, *key;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200597 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100598
Michal Vasko004d3152020-06-11 19:59:22 +0200599 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
Michal Vasko90932a92020-02-12 14:33:03 +0100600
601 /* create list */
602 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
603
Michal Vasko90932a92020-02-12 14:33:03 +0100604 /* create and insert all the keys */
Michal Vasko004d3152020-06-11 19:59:22 +0200605 LY_ARRAY_FOR(predicates, u) {
606 LY_CHECK_GOTO(ret = lyd_create_term2(predicates[u].key, &predicates[u].value, &key), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100607 lyd_insert_node(list, NULL, key);
608 }
609
Michal Vasko9b368d32020-02-14 13:53:31 +0100610 /* hash having all the keys */
611 lyd_hash(list);
612
Michal Vasko90932a92020-02-12 14:33:03 +0100613 /* success */
614 *node = list;
615 list = NULL;
616
617cleanup:
618 lyd_free_tree(list);
Michal Vasko004d3152020-06-11 19:59:22 +0200619 return ret;
620}
621
622static LY_ERR
623lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
624{
625 LY_ERR ret = LY_SUCCESS;
626 struct lyxp_expr *expr = NULL;
627 uint16_t exp_idx = 0;
628 enum ly_path_pred_type pred_type = 0;
629 struct ly_path_predicate *predicates = NULL;
630
631 /* parse keys */
Michal Vasko6b26e742020-07-17 15:02:10 +0200632 LY_CHECK_GOTO(ret = ly_path_parse_predicate(schema->module->ctx, NULL, keys, keys_len, LY_PATH_PREFIX_OPTIONAL,
Michal Vasko69730152020-10-09 16:30:07 +0200633 LY_PATH_PRED_KEYS, &expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200634
635 /* compile them */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200636 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_PREF_JSON,
637 NULL, &predicates, &pred_type), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200638
639 /* create the list node */
640 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, node), cleanup);
641
642cleanup:
643 lyxp_expr_free(schema->module->ctx, expr);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200644 ly_path_predicates_free(schema->module->ctx, pred_type, predicates);
Michal Vasko90932a92020-02-12 14:33:03 +0100645 return ret;
646}
647
648LY_ERR
649lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, struct lyd_node **node)
650{
651 struct lyd_node_any *any;
652
Michal Vasko9b368d32020-02-14 13:53:31 +0100653 assert(schema->nodetype & LYD_NODE_ANY);
654
Michal Vasko90932a92020-02-12 14:33:03 +0100655 any = calloc(1, sizeof *any);
656 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
657
658 any->schema = schema;
659 any->prev = (struct lyd_node *)any;
Michal Vasko9b368d32020-02-14 13:53:31 +0100660 any->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100661
Radek Krejci1798aae2020-07-14 13:26:06 +0200662 /* TODO: convert XML/JSON strings into a opaq data tree */
663 any->value.str = value;
Michal Vasko90932a92020-02-12 14:33:03 +0100664 any->value_type = value_type;
Michal Vasko9b368d32020-02-14 13:53:31 +0100665 lyd_hash((struct lyd_node *)any);
Michal Vasko90932a92020-02-12 14:33:03 +0100666
667 *node = (struct lyd_node *)any;
668 return LY_SUCCESS;
669}
670
Michal Vasko52927e22020-03-16 17:26:14 +0100671LY_ERR
672lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *value, size_t value_len,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200673 ly_bool *dynamic, LYD_FORMAT format, uint32_t hints, struct ly_prefix *val_prefs, const char *prefix, size_t pref_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200674 const char *module_key, size_t module_key_len, struct lyd_node **node)
Michal Vasko52927e22020-03-16 17:26:14 +0100675{
Radek Krejci011e4aa2020-09-04 15:22:31 +0200676 LY_ERR ret = LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +0100677 struct lyd_node_opaq *opaq;
678
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200679 assert(ctx && name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +0100680
681 if (!value_len) {
682 value = "";
683 }
684
685 opaq = calloc(1, sizeof *opaq);
Radek Krejcid46e46a2020-09-15 14:22:42 +0200686 LY_CHECK_ERR_RET(!opaq, LOGMEM(ctx); ly_free_val_prefs(ctx, val_prefs), LY_EMEM);
Michal Vasko52927e22020-03-16 17:26:14 +0100687
688 opaq->prev = (struct lyd_node *)opaq;
Radek Krejcid46e46a2020-09-15 14:22:42 +0200689 opaq->val_prefs = val_prefs;
690 opaq->format = format;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200691 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name), finish);
692
Michal Vasko52927e22020-03-16 17:26:14 +0100693 if (pref_len) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200694 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->prefix.id), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100695 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200696 if (module_key_len) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200697 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->prefix.module_ns), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +0200698 }
699
Michal Vasko52927e22020-03-16 17:26:14 +0100700 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200701 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100702 *dynamic = 0;
703 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200704 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100705 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200706 opaq->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +0100707 opaq->ctx = ctx;
708
Radek Krejci011e4aa2020-09-04 15:22:31 +0200709finish:
710 if (ret) {
711 lyd_free_tree((struct lyd_node *)opaq);
712 } else {
713 *node = (struct lyd_node *)opaq;
714 }
715 return ret;
Michal Vasko52927e22020-03-16 17:26:14 +0100716}
717
Michal Vasko3a41dff2020-07-15 14:30:28 +0200718API LY_ERR
Radek Krejci41ac9942020-11-02 14:47:56 +0100719lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100720{
721 struct lyd_node *ret = NULL;
722 const struct lysc_node *schema;
723 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
724
Michal Vasko6027eb92020-07-15 16:37:30 +0200725 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100726
Michal Vaskof03ed032020-03-04 13:31:44 +0100727 if (!module) {
728 module = parent->schema->module;
729 }
730
Michal Vasko3a41dff2020-07-15 14:30:28 +0200731 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
Radek Krejci41ac9942020-11-02 14:47:56 +0100732 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200733 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Inner node (and not a list) \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100734
Michal Vasko3a41dff2020-07-15 14:30:28 +0200735 LY_CHECK_RET(lyd_create_inner(schema, &ret));
736 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100737 lyd_insert_node(parent, NULL, ret);
738 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200739
740 if (node) {
741 *node = ret;
742 }
743 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100744}
745
Michal Vasko3a41dff2020-07-15 14:30:28 +0200746API LY_ERR
Radek Krejci41ac9942020-11-02 14:47:56 +0100747lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output, struct lyd_node **node, ...)
Michal Vasko013a8182020-03-03 10:46:53 +0100748{
749 struct lyd_node *ret = NULL, *key;
750 const struct lysc_node *schema, *key_s;
751 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
752 va_list ap;
753 const char *key_val;
754 LY_ERR rc = LY_SUCCESS;
755
Michal Vasko6027eb92020-07-15 16:37:30 +0200756 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100757
Michal Vaskof03ed032020-03-04 13:31:44 +0100758 if (!module) {
759 module = parent->schema->module;
760 }
761
Radek Krejci41ac9942020-11-02 14:47:56 +0100762 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYS_LIST, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200763 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100764
765 /* create list inner node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200766 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko013a8182020-03-03 10:46:53 +0100767
Michal Vasko3a41dff2020-07-15 14:30:28 +0200768 va_start(ap, node);
Michal Vasko013a8182020-03-03 10:46:53 +0100769
770 /* create and insert all the keys */
771 for (key_s = lysc_node_children(schema, 0); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
772 key_val = va_arg(ap, const char *);
773
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200774 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
775 NULL, &key);
776 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko013a8182020-03-03 10:46:53 +0100777 lyd_insert_node(ret, NULL, key);
778 }
779
Michal Vasko013a8182020-03-03 10:46:53 +0100780 if (parent) {
781 lyd_insert_node(parent, NULL, ret);
782 }
783
784cleanup:
Michal Vasko3a41dff2020-07-15 14:30:28 +0200785 va_end(ap);
Michal Vasko013a8182020-03-03 10:46:53 +0100786 if (rc) {
787 lyd_free_tree(ret);
788 ret = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200789 } else if (node) {
790 *node = ret;
Michal Vasko013a8182020-03-03 10:46:53 +0100791 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200792 return rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100793}
794
Michal Vasko3a41dff2020-07-15 14:30:28 +0200795API LY_ERR
796lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
Radek Krejci41ac9942020-11-02 14:47:56 +0100797 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100798{
799 struct lyd_node *ret = NULL;
800 const struct lysc_node *schema;
801 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
802
Michal Vasko6027eb92020-07-15 16:37:30 +0200803 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100804
Michal Vaskof03ed032020-03-04 13:31:44 +0100805 if (!module) {
806 module = parent->schema->module;
807 }
Michal Vasko004d3152020-06-11 19:59:22 +0200808 if (!keys) {
809 keys = "";
810 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100811
Michal Vasko004d3152020-06-11 19:59:22 +0200812 /* find schema node */
Radek Krejci41ac9942020-11-02 14:47:56 +0100813 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYS_LIST, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200814 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100815
Michal Vasko004d3152020-06-11 19:59:22 +0200816 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
817 /* key-less list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200818 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200819 } else {
820 /* create the list node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200821 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200822 }
Michal Vasko004d3152020-06-11 19:59:22 +0200823 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100824 lyd_insert_node(parent, NULL, ret);
825 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200826
827 if (node) {
828 *node = ret;
829 }
830 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100831}
832
Michal Vasko3a41dff2020-07-15 14:30:28 +0200833API LY_ERR
834lyd_new_term(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *val_str,
Radek Krejci41ac9942020-11-02 14:47:56 +0100835 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100836{
Michal Vaskocbff3e92020-05-27 12:56:41 +0200837 LY_ERR rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100838 struct lyd_node *ret = NULL;
839 const struct lysc_node *schema;
840 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
841
Michal Vasko6027eb92020-07-15 16:37:30 +0200842 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100843
Michal Vaskof03ed032020-03-04 13:31:44 +0100844 if (!module) {
845 module = parent->schema->module;
846 }
847
Radek Krejci41ac9942020-11-02 14:47:56 +0100848 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYD_NODE_TERM, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200849 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100850
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200851 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL,
852 &ret);
853 LY_CHECK_RET(rc);
Michal Vaskocbff3e92020-05-27 12:56:41 +0200854 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100855 lyd_insert_node(parent, NULL, ret);
856 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200857
858 if (node) {
859 *node = ret;
860 }
861 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100862}
863
Michal Vasko3a41dff2020-07-15 14:30:28 +0200864API LY_ERR
Michal Vasko013a8182020-03-03 10:46:53 +0100865lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
Radek Krejci41ac9942020-11-02 14:47:56 +0100866 LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100867{
868 struct lyd_node *ret = NULL;
869 const struct lysc_node *schema;
870 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
871
Michal Vasko6027eb92020-07-15 16:37:30 +0200872 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100873
Michal Vaskof03ed032020-03-04 13:31:44 +0100874 if (!module) {
875 module = parent->schema->module;
876 }
877
Radek Krejci41ac9942020-11-02 14:47:56 +0100878 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYD_NODE_ANY, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200879 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100880
Michal Vasko3a41dff2020-07-15 14:30:28 +0200881 LY_CHECK_RET(lyd_create_any(schema, value, value_type, &ret));
882 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100883 lyd_insert_node(parent, NULL, ret);
884 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200885
886 if (node) {
887 *node = ret;
888 }
889 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100890}
891
Michal Vasko4490d312020-06-16 13:08:55 +0200892/**
893 * @brief Update node value.
894 *
895 * @param[in] node Node to update.
896 * @param[in] value New value to set.
897 * @param[in] value_type Type of @p value for any node.
898 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
899 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
900 * @return LY_ERR value.
901 */
Michal Vasko00cbf532020-06-15 13:58:47 +0200902static LY_ERR
903lyd_new_path_update(struct lyd_node *node, const void *value, LYD_ANYDATA_VALUETYPE value_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200904 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +0200905{
906 LY_ERR ret = LY_SUCCESS;
907 struct lyd_node *new_any;
908
909 switch (node->schema->nodetype) {
910 case LYS_CONTAINER:
911 case LYS_NOTIF:
912 case LYS_RPC:
913 case LYS_ACTION:
914 case LYS_LIST:
915 case LYS_LEAFLIST:
916 /* if it exists, there is nothing to update */
917 *new_parent = NULL;
918 *new_node = NULL;
919 break;
920 case LYS_LEAF:
921 ret = lyd_change_term(node, value);
922 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
923 /* there was an actual change (at least of the default flag) */
924 *new_parent = node;
925 *new_node = node;
926 ret = LY_SUCCESS;
927 } else if (ret == LY_ENOT) {
928 /* no change */
929 *new_parent = NULL;
930 *new_node = NULL;
931 ret = LY_SUCCESS;
932 } /* else error */
933 break;
934 case LYS_ANYDATA:
935 case LYS_ANYXML:
936 /* create a new any node */
937 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, &new_any));
938
939 /* compare with the existing one */
Michal Vasko8f359bf2020-07-28 10:41:15 +0200940 if (lyd_compare_single(node, new_any, 0)) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200941 /* not equal, switch values (so that we can use generic node free) */
942 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
943 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
944 ((struct lyd_node_any *)node)->value.str = value;
945 ((struct lyd_node_any *)node)->value_type = value_type;
946
947 *new_parent = node;
948 *new_node = node;
949 } else {
950 /* they are equal */
951 *new_parent = NULL;
952 *new_node = NULL;
953 }
954 lyd_free_tree(new_any);
955 break;
956 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200957 LOGINT(LYD_CTX(node));
Michal Vasko00cbf532020-06-15 13:58:47 +0200958 ret = LY_EINT;
959 break;
960 }
961
962 return ret;
963}
964
Michal Vasko3a41dff2020-07-15 14:30:28 +0200965API LY_ERR
966lyd_new_meta(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *val_str,
Radek Krejci0f969882020-08-21 16:56:47 +0200967 struct lyd_meta **meta)
Michal Vaskod86997b2020-05-26 15:19:54 +0200968{
969 struct lyd_meta *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +0200970 const struct ly_ctx *ctx;
Michal Vaskod86997b2020-05-26 15:19:54 +0200971 const char *prefix, *tmp;
Michal Vaskod86997b2020-05-26 15:19:54 +0200972 size_t pref_len, name_len;
973
Michal Vasko3a41dff2020-07-15 14:30:28 +0200974 LY_CHECK_ARG_RET(NULL, parent, name, module || strchr(name, ':'), LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +0200975
Michal Vaskob7be7a82020-08-20 09:09:04 +0200976 ctx = LYD_CTX(parent);
Michal Vaskod86997b2020-05-26 15:19:54 +0200977
978 /* parse the name */
979 tmp = name;
980 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
981 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200982 return LY_EVALID;
Michal Vaskod86997b2020-05-26 15:19:54 +0200983 }
984
985 /* find the module */
986 if (prefix) {
Radek Krejci0ad51f12020-07-16 12:08:12 +0200987 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200988 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", pref_len, prefix), LY_ENOTFOUND);
Michal Vaskod86997b2020-05-26 15:19:54 +0200989 }
990
991 /* set value if none */
992 if (!val_str) {
993 val_str = "";
994 }
995
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200996 LY_CHECK_RET(lyd_create_meta(parent, &ret, module, name, name_len, val_str, strlen(val_str), NULL, LY_PREF_JSON,
997 NULL, LYD_HINT_DATA, NULL));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200998
999 if (meta) {
1000 *meta = ret;
1001 }
1002 return LY_SUCCESS;
Michal Vaskod86997b2020-05-26 15:19:54 +02001003}
1004
Michal Vasko3a41dff2020-07-15 14:30:28 +02001005API LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +02001006lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Radek Krejci0f969882020-08-21 16:56:47 +02001007 const char *module_name, struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001008{
1009 struct lyd_node *ret = NULL;
1010
Michal Vasko6027eb92020-07-15 16:37:30 +02001011 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001012
1013 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001014 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001015 }
1016 if (!value) {
1017 value = "";
1018 }
1019
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001020 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), value, strlen(value), NULL, LYD_JSON, 0, NULL, NULL, 0,
1021 module_name, strlen(module_name), &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001022 if (parent) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001023 lyd_insert_node(parent, NULL, ret);
1024 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001025
1026 if (node) {
1027 *node = ret;
1028 }
1029 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001030}
1031
Michal Vasko3a41dff2020-07-15 14:30:28 +02001032API LY_ERR
1033lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *val_str,
Radek Krejci0f969882020-08-21 16:56:47 +02001034 struct lyd_attr **attr)
Michal Vasko00cbf532020-06-15 13:58:47 +02001035{
Radek Krejci1798aae2020-07-14 13:26:06 +02001036 struct lyd_attr *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02001037 const struct ly_ctx *ctx;
1038 const char *prefix, *tmp;
1039 size_t pref_len, name_len;
1040
Michal Vasko3a41dff2020-07-15 14:30:28 +02001041 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001042
Michal Vaskob7be7a82020-08-20 09:09:04 +02001043 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001044
1045 /* parse the name */
1046 tmp = name;
1047 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1048 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001049 return LY_EVALID;
Michal Vasko00cbf532020-06-15 13:58:47 +02001050 }
1051
1052 /* set value if none */
1053 if (!val_str) {
1054 val_str = "";
1055 }
1056
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001057 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, val_str, strlen(val_str), NULL, LYD_JSON, 0, NULL,
Michal Vasko69730152020-10-09 16:30:07 +02001058 prefix, pref_len, module_name, module_name ? strlen(module_name) : 0));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001059
1060 if (attr) {
1061 *attr = ret;
1062 }
1063 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001064}
1065
1066API LY_ERR
1067lyd_change_term(struct lyd_node *term, const char *val_str)
1068{
1069 LY_ERR ret = LY_SUCCESS;
1070 struct lysc_type *type;
1071 struct lyd_node_term *t;
1072 struct lyd_node *parent;
1073 struct lyd_value val = {0};
Radek Krejci857189e2020-09-01 13:26:36 +02001074 ly_bool dflt_change, val_change;
Michal Vasko00cbf532020-06-15 13:58:47 +02001075
1076 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1077
1078 if (!val_str) {
1079 val_str = "";
1080 }
1081 t = (struct lyd_node_term *)term;
1082 type = ((struct lysc_node_leaf *)term->schema)->type;
1083
1084 /* parse the new value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001085 ret = lyd_value_store(LYD_CTX(term), &val, type, val_str, strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
1086 term->schema, NULL, LY_VLOG_LYD, term);
1087 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001088
1089 /* compare original and new value */
1090 if (type->plugin->compare(&t->value, &val)) {
1091 /* values differ, switch them */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001092 type->plugin->free(LYD_CTX(term), &t->value);
Michal Vasko00cbf532020-06-15 13:58:47 +02001093 t->value = val;
1094 memset(&val, 0, sizeof val);
1095 val_change = 1;
1096 } else {
1097 val_change = 0;
1098 }
1099
1100 /* always clear the default flag */
1101 if (term->flags & LYD_DEFAULT) {
1102 for (parent = term; parent; parent = (struct lyd_node *)parent->parent) {
1103 parent->flags &= ~LYD_DEFAULT;
1104 }
1105 dflt_change = 1;
1106 } else {
1107 dflt_change = 0;
1108 }
1109
1110 if (val_change || dflt_change) {
1111 /* make the node non-validated */
1112 term->flags &= LYD_NEW;
1113 }
1114
1115 if (val_change) {
1116 if (term->schema->nodetype == LYS_LEAFLIST) {
1117 /* leaf-list needs to be hashed again and re-inserted into parent */
1118 lyd_unlink_hash(term);
1119 lyd_hash(term);
1120 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1121 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1122 /* list needs to be updated if its key was changed */
1123 assert(term->parent->schema->nodetype == LYS_LIST);
1124 lyd_unlink_hash((struct lyd_node *)term->parent);
1125 lyd_hash((struct lyd_node *)term->parent);
1126 LY_CHECK_GOTO(ret = lyd_insert_hash((struct lyd_node *)term->parent), cleanup);
1127 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1128 }
1129
1130 /* retrun value */
1131 if (!val_change) {
1132 if (dflt_change) {
1133 /* only default flag change */
1134 ret = LY_EEXIST;
1135 } else {
1136 /* no change */
1137 ret = LY_ENOT;
1138 }
1139 } /* else value changed, LY_SUCCESS */
1140
1141cleanup:
Michal Vaskob7be7a82020-08-20 09:09:04 +02001142 type->plugin->free(LYD_CTX(term), &val);
Michal Vasko00cbf532020-06-15 13:58:47 +02001143 return ret;
1144}
1145
Michal Vasko41586352020-07-13 13:54:25 +02001146API LY_ERR
1147lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1148{
1149 LY_ERR ret = LY_SUCCESS;
1150 struct lyd_meta *m2;
1151 struct lyd_value val;
Radek Krejci857189e2020-09-01 13:26:36 +02001152 ly_bool val_change;
Michal Vasko41586352020-07-13 13:54:25 +02001153
1154 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1155
1156 if (!val_str) {
1157 val_str = "";
1158 }
1159
1160 /* parse the new value into a new meta structure */
1161 LY_CHECK_GOTO(ret = lyd_create_meta(NULL, &m2, meta->annotation->module, meta->name, strlen(meta->name), val_str,
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001162 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL), cleanup);
Michal Vasko41586352020-07-13 13:54:25 +02001163
1164 /* compare original and new value */
1165 if (lyd_compare_meta(meta, m2)) {
1166 /* values differ, switch them */
1167 val = meta->value;
1168 meta->value = m2->value;
1169 m2->value = val;
1170 val_change = 1;
1171 } else {
1172 val_change = 0;
1173 }
1174
1175 /* retrun value */
1176 if (!val_change) {
1177 /* no change */
1178 ret = LY_ENOT;
1179 } /* else value changed, LY_SUCCESS */
1180
1181cleanup:
1182 return ret;
1183}
1184
Michal Vasko3a41dff2020-07-15 14:30:28 +02001185API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001186lyd_new_path(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const char *value, uint32_t options,
Radek Krejci0f969882020-08-21 16:56:47 +02001187 struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001188{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001189 return lyd_new_path2(parent, ctx, path, value, 0, options, node, NULL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001190}
1191
1192API LY_ERR
1193lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001194 LYD_ANYDATA_VALUETYPE value_type, uint32_t options, struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001195{
1196 LY_ERR ret = LY_SUCCESS, r;
1197 struct lyxp_expr *exp = NULL;
1198 struct ly_path *p = NULL;
1199 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1200 const struct lysc_node *schema;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001201 LY_ARRAY_COUNT_TYPE path_idx = 0;
Michal Vasko00cbf532020-06-15 13:58:47 +02001202 struct ly_path_predicate *pred;
1203
1204 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1205
1206 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001207 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001208 }
1209
1210 /* parse path */
Michal Vasko6b26e742020-07-17 15:02:10 +02001211 LY_CHECK_GOTO(ret = ly_path_parse(ctx, NULL, path, strlen(path), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
Michal Vasko69730152020-10-09 16:30:07 +02001212 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001213
1214 /* compile path */
1215 LY_CHECK_GOTO(ret = ly_path_compile(ctx, NULL, parent ? parent->schema : NULL, exp, LY_PATH_LREF_FALSE,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001216 options & LYD_NEW_PATH_OUTPUT ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, LY_PREF_JSON,
1217 NULL, &p), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001218
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001219 schema = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko69730152020-10-09 16:30:07 +02001220 if ((schema->nodetype == LYS_LIST) && (p[LY_ARRAY_COUNT(p) - 1].pred_type == LY_PATH_PREDTYPE_NONE) &&
Radek Krejci092e33c2020-10-12 15:33:10 +02001221 !(options & LYD_NEW_PATH_OPAQ)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001222 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +02001223 lys_nodetype2str(schema->nodetype), schema->name);
Michal Vasko00cbf532020-06-15 13:58:47 +02001224 ret = LY_EINVAL;
1225 goto cleanup;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001226 } else if ((schema->nodetype == LYS_LEAFLIST) && (p[LY_ARRAY_COUNT(p) - 1].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001227 /* parse leafref value into a predicate, if not defined in the path */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001228 p[LY_ARRAY_COUNT(p) - 1].pred_type = LY_PATH_PREDTYPE_LEAFLIST;
1229 LY_ARRAY_NEW_GOTO(ctx, p[LY_ARRAY_COUNT(p) - 1].predicates, pred, ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001230
1231 if (!value) {
1232 value = "";
1233 }
1234
1235 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001236 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001237 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001238 }
1239 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001240 ret = lyd_value_store(ctx, &pred->value, ((struct lysc_node_leaflist *)schema)->type, value, strlen(value),
1241 NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, schema, NULL, LY_VLOG_LYSC, schema);
1242 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoae875662020-10-21 10:33:17 +02001243 ++((struct lysc_type *)pred->value.realtype)->refcount;
Michal Vasko00cbf532020-06-15 13:58:47 +02001244 } /* else we have opaq flag and the value is not valid, leavne no predicate and then create an opaque node */
1245 }
1246
1247 /* try to find any existing nodes in the path */
1248 if (parent) {
1249 ret = ly_path_eval_partial(p, parent, &path_idx, &node);
1250 if (ret == LY_SUCCESS) {
1251 /* the node exists, are we supposed to update it or is it just a default? */
Radek Krejci092e33c2020-10-12 15:33:10 +02001252 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001253 LOGERR(ctx, LY_EEXIST, "Path \"%s\" already exists", path);
1254 ret = LY_EEXIST;
1255 goto cleanup;
1256 }
1257
1258 /* update the existing node */
1259 ret = lyd_new_path_update(node, value, value_type, &nparent, &nnode);
1260 goto cleanup;
1261 } else if (ret == LY_EINCOMPLETE) {
1262 /* some nodes were found, adjust the iterator to the next segment */
1263 ++path_idx;
1264 } else if (ret == LY_ENOTFOUND) {
1265 /* we will create the nodes from top-level, default behavior (absolute path), or from the parent (relative path) */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001266 if (lysc_data_parent(p[LY_ARRAY_COUNT(p) - 1].node)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001267 node = parent;
1268 }
1269 } else {
1270 /* error */
1271 goto cleanup;
1272 }
1273 }
1274
1275 /* create all the non-existing nodes in a loop */
Michal Vaskod989ba02020-08-24 10:59:24 +02001276 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001277 cur_parent = node;
1278 schema = p[path_idx].node;
1279
1280 switch (schema->nodetype) {
1281 case LYS_LIST:
1282 if (!(schema->flags & LYS_KEYLESS)) {
Radek Krejci092e33c2020-10-12 15:33:10 +02001283 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001284 /* creating opaque list without keys */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001285 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, NULL, LYD_JSON,
1286 LYD_NODEHINT_LIST, NULL, NULL, 0, schema->module->name, strlen(schema->module->name), &node),
Michal Vasko69730152020-10-09 16:30:07 +02001287 cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001288 } else {
1289 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LIST);
1290 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, &node), cleanup);
1291 }
1292 break;
1293 }
Radek Krejci0f969882020-08-21 16:56:47 +02001294 /* fallthrough */
Michal Vasko00cbf532020-06-15 13:58:47 +02001295 case LYS_CONTAINER:
1296 case LYS_NOTIF:
1297 case LYS_RPC:
1298 case LYS_ACTION:
1299 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1300 break;
1301 case LYS_LEAFLIST:
Radek Krejci092e33c2020-10-12 15:33:10 +02001302 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001303 /* creating opaque leaf-list without value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001304 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, NULL, LYD_JSON,
1305 LYD_NODEHINT_LEAFLIST, NULL, NULL, 0, schema->module->name, strlen(schema->module->name), &node),
1306 cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001307 } else {
1308 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LEAFLIST);
1309 LY_CHECK_GOTO(ret = lyd_create_term2(schema, &p[path_idx].predicates[0].value, &node), cleanup);
1310 }
1311 break;
1312 case LYS_LEAF:
1313 /* make there is some value */
1314 if (!value) {
1315 value = "";
1316 }
1317
1318 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001319 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001320 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001321 }
1322 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001323 ret = lyd_create_term(schema, value, strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &node);
1324 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001325 } else {
1326 /* creating opaque leaf without value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001327 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, NULL, LYD_JSON,
Michal Vasko69730152020-10-09 16:30:07 +02001328 0, NULL, NULL, 0, schema->module->name,
1329 strlen(schema->module->name), &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001330 }
1331 break;
1332 case LYS_ANYDATA:
1333 case LYS_ANYXML:
1334 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, &node), cleanup);
1335 break;
1336 default:
1337 LOGINT(ctx);
1338 ret = LY_EINT;
1339 goto cleanup;
1340 }
1341
1342 if (cur_parent) {
1343 /* connect to the parent */
1344 lyd_insert_node(cur_parent, NULL, node);
1345 } else if (parent) {
1346 /* connect to top-level siblings */
1347 lyd_insert_node(NULL, &parent, node);
1348 }
1349
1350 /* update remembered nodes */
1351 if (!nparent) {
1352 nparent = node;
1353 }
1354 nnode = node;
1355 }
1356
1357cleanup:
1358 lyxp_expr_free(ctx, exp);
1359 ly_path_free(ctx, p);
1360 if (!ret) {
1361 /* set out params only on success */
1362 if (new_parent) {
1363 *new_parent = nparent;
1364 }
1365 if (new_node) {
1366 *new_node = nnode;
1367 }
1368 }
1369 return ret;
1370}
1371
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001372LY_ERR
1373lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001374 const struct lys_module *mod, struct ly_set *node_types, struct ly_set *node_when, uint32_t impl_opts,
Radek Krejci0f969882020-08-21 16:56:47 +02001375 struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001376{
1377 LY_ERR ret;
1378 const struct lysc_node *iter = NULL;
1379 struct lyd_node *node;
1380 struct lyd_value **dflts;
1381 LY_ARRAY_COUNT_TYPE u;
1382
1383 assert(first && (parent || sparent || mod));
1384
1385 if (!sparent && parent) {
1386 sparent = parent->schema;
1387 }
1388
1389 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
1390 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1391 continue;
Michal Vasko44b19a12020-08-07 09:21:30 +02001392 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1393 continue;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001394 }
1395
1396 switch (iter->nodetype) {
1397 case LYS_CHOICE:
1398 if (((struct lysc_node_choice *)iter)->dflt && !lys_getnext_data(NULL, *first, NULL, iter, NULL)) {
1399 /* create default case data */
1400 LY_CHECK_RET(lyd_new_implicit_r(parent, first, (struct lysc_node *)((struct lysc_node_choice *)iter)->dflt,
Michal Vasko69730152020-10-09 16:30:07 +02001401 NULL, node_types, node_when, impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001402 }
1403 break;
1404 case LYS_CONTAINER:
1405 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1406 /* create default NP container */
1407 LY_CHECK_RET(lyd_create_inner(iter, &node));
Michal Vasko0cadfcb2020-11-04 17:17:05 +01001408 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001409 lyd_insert_node(parent, first, node);
1410
1411 /* cannot be a NP container with when */
1412 assert(!iter->when);
1413
Michal Vaskoe49b6322020-11-05 17:38:36 +01001414 if (diff) {
1415 /* add into diff */
1416 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1417 }
1418
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001419 /* create any default children */
1420 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_children_p(node), NULL, NULL, node_types, node_when,
Michal Vasko69730152020-10-09 16:30:07 +02001421 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001422 }
1423 break;
1424 case LYS_LEAF:
Michal Vasko69730152020-10-09 16:30:07 +02001425 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1426 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001427 /* create default leaf */
1428 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1429 if (ret == LY_EINCOMPLETE) {
1430 if (node_types) {
1431 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001432 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001433 }
1434 } else if (ret) {
1435 return ret;
1436 }
Michal Vasko0cadfcb2020-11-04 17:17:05 +01001437 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001438 lyd_insert_node(parent, first, node);
1439
1440 if (iter->when && node_when) {
1441 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001442 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001443 }
1444 if (diff) {
1445 /* add into diff */
1446 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1447 }
1448 }
1449 break;
1450 case LYS_LEAFLIST:
Michal Vasko69730152020-10-09 16:30:07 +02001451 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1452 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001453 /* create all default leaf-lists */
1454 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1455 LY_ARRAY_FOR(dflts, u) {
1456 ret = lyd_create_term2(iter, dflts[u], &node);
1457 if (ret == LY_EINCOMPLETE) {
1458 if (node_types) {
1459 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001460 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001461 }
1462 } else if (ret) {
1463 return ret;
1464 }
Michal Vasko0cadfcb2020-11-04 17:17:05 +01001465 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001466 lyd_insert_node(parent, first, node);
1467
1468 if (iter->when && node_when) {
1469 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001470 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001471 }
1472 if (diff) {
1473 /* add into diff */
1474 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1475 }
1476 }
1477 }
1478 break;
1479 default:
1480 /* without defaults */
1481 break;
1482 }
1483 }
1484
1485 return LY_SUCCESS;
1486}
1487
1488API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001489lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001490{
Michal Vasko56daf732020-08-10 10:57:18 +02001491 struct lyd_node *node;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001492 LY_ERR ret = LY_SUCCESS;
1493
1494 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1495 if (diff) {
1496 *diff = NULL;
1497 }
1498
Michal Vasko56daf732020-08-10 10:57:18 +02001499 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001500 /* skip added default nodes */
Michal Vasko69730152020-10-09 16:30:07 +02001501 if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
1502 (node->schema->nodetype & LYD_NODE_INNER)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001503 LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_children_p((struct lyd_node *)node), NULL, NULL, NULL,
Michal Vasko69730152020-10-09 16:30:07 +02001504 NULL, implicit_options, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001505 }
1506
Michal Vasko56daf732020-08-10 10:57:18 +02001507 LYD_TREE_DFS_END(tree, node);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001508 }
1509
1510cleanup:
1511 if (ret && diff) {
1512 lyd_free_all(*diff);
1513 *diff = NULL;
1514 }
1515 return ret;
1516}
1517
1518API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001519lyd_new_implicit_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001520{
1521 const struct lys_module *mod;
1522 struct lyd_node *d = NULL;
1523 uint32_t i = 0;
1524 LY_ERR ret = LY_SUCCESS;
1525
1526 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
1527 if (diff) {
1528 *diff = NULL;
1529 }
1530 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001531 ctx = LYD_CTX(*tree);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001532 }
1533
1534 /* add nodes for each module one-by-one */
1535 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
1536 if (!mod->implemented) {
1537 continue;
1538 }
1539
1540 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
1541 if (d) {
1542 /* merge into one diff */
1543 lyd_insert_sibling(*diff, d, diff);
1544
1545 d = NULL;
1546 }
1547 }
1548
1549cleanup:
1550 if (ret && diff) {
1551 lyd_free_all(*diff);
1552 *diff = NULL;
1553 }
1554 return ret;
1555}
1556
1557API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001558lyd_new_implicit_module(struct lyd_node **tree, const struct lys_module *module, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001559{
1560 struct lyd_node *root, *d = NULL;
1561 LY_ERR ret = LY_SUCCESS;
1562
1563 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
1564 if (diff) {
1565 *diff = NULL;
1566 }
1567
1568 /* add all top-level defaults for this module */
1569 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, NULL, NULL, implicit_options, diff), cleanup);
1570
1571 /* process nested nodes */
1572 LY_LIST_FOR(*tree, root) {
1573 /* skip added default nodes */
1574 if ((root->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
1575 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
1576
1577 if (d) {
1578 /* merge into one diff */
1579 lyd_insert_sibling(*diff, d, diff);
1580
1581 d = NULL;
1582 }
1583 }
1584 }
1585
1586cleanup:
1587 if (ret && diff) {
1588 lyd_free_all(*diff);
1589 *diff = NULL;
1590 }
1591 return ret;
1592}
1593
Michal Vasko90932a92020-02-12 14:33:03 +01001594struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +02001595lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +01001596{
Michal Vaskob104f112020-07-17 09:54:54 +02001597 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +01001598 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02001599 ly_bool found;
Michal Vasko90932a92020-02-12 14:33:03 +01001600
Michal Vaskob104f112020-07-17 09:54:54 +02001601 assert(new_node);
1602
1603 if (!first_sibling || !new_node->schema) {
1604 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +01001605 return NULL;
1606 }
1607
Michal Vaskob104f112020-07-17 09:54:54 +02001608 if (first_sibling->parent && first_sibling->parent->children_ht) {
1609 /* find the anchor using hashes */
1610 sparent = first_sibling->parent->schema;
1611 schema = lys_getnext(new_node->schema, sparent, NULL, 0);
1612 while (schema) {
1613 /* keep trying to find the first existing instance of the closest following schema sibling,
1614 * otherwise return NULL - inserting at the end */
1615 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
1616 break;
1617 }
1618
1619 schema = lys_getnext(schema, sparent, NULL, 0);
1620 }
1621 } else {
1622 /* find the anchor without hashes */
1623 match = (struct lyd_node *)first_sibling;
1624 if (!lysc_data_parent(new_node->schema)) {
1625 /* we are in top-level, skip all the data from preceding modules */
1626 LY_LIST_FOR(match, match) {
1627 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
1628 break;
1629 }
1630 }
1631 }
1632
1633 /* get the first schema sibling */
1634 sparent = lysc_data_parent(new_node->schema);
1635 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, 0);
1636
1637 found = 0;
1638 LY_LIST_FOR(match, match) {
1639 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
1640 /* we have found an opaque node, which must be at the end, so use it OR
1641 * modules do not match, so we must have traversed all the data from new_node module (if any),
1642 * we have found the first node of the next module, that is what we want */
1643 break;
1644 }
1645
1646 /* skip schema nodes until we find the instantiated one */
1647 while (!found) {
1648 if (new_node->schema == schema) {
1649 /* we have found the schema of the new node, continue search to find the first
1650 * data node with a different schema (after our schema) */
1651 found = 1;
1652 break;
1653 }
1654 if (match->schema == schema) {
1655 /* current node (match) is a data node still before the new node, continue search in data */
1656 break;
1657 }
1658 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, 0);
1659 assert(schema);
1660 }
1661
1662 if (found && (match->schema != new_node->schema)) {
1663 /* find the next node after we have found our node schema data instance */
1664 break;
1665 }
1666 }
Michal Vasko90932a92020-02-12 14:33:03 +01001667 }
1668
1669 return match;
1670}
1671
1672/**
1673 * @brief Insert node after a sibling.
1674 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001675 * Handles inserting into NP containers and key-less lists.
1676 *
Michal Vasko90932a92020-02-12 14:33:03 +01001677 * @param[in] sibling Sibling to insert after.
1678 * @param[in] node Node to insert.
1679 */
1680static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001681lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001682{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001683 struct lyd_node_inner *par;
1684
Michal Vasko90932a92020-02-12 14:33:03 +01001685 assert(!node->next && (node->prev == node));
1686
1687 node->next = sibling->next;
1688 node->prev = sibling;
1689 sibling->next = node;
1690 if (node->next) {
1691 /* sibling had a succeeding node */
1692 node->next->prev = node;
1693 } else {
1694 /* sibling was last, find first sibling and change its prev */
1695 if (sibling->parent) {
1696 sibling = sibling->parent->child;
1697 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +02001698 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +01001699 }
1700 sibling->prev = node;
1701 }
1702 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001703
Michal Vasko9f96a052020-03-10 09:41:45 +01001704 for (par = node->parent; par; par = par->parent) {
1705 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1706 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001707 par->flags &= ~LYD_DEFAULT;
1708 }
Michal Vaskob104f112020-07-17 09:54:54 +02001709 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001710 /* rehash key-less list */
1711 lyd_hash((struct lyd_node *)par);
1712 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001713 }
Michal Vasko90932a92020-02-12 14:33:03 +01001714}
1715
1716/**
1717 * @brief Insert node before a sibling.
1718 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001719 * Handles inserting into NP containers and key-less lists.
1720 *
Michal Vasko90932a92020-02-12 14:33:03 +01001721 * @param[in] sibling Sibling to insert before.
1722 * @param[in] node Node to insert.
1723 */
1724static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001725lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001726{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001727 struct lyd_node_inner *par;
1728
Michal Vasko90932a92020-02-12 14:33:03 +01001729 assert(!node->next && (node->prev == node));
1730
1731 node->next = sibling;
1732 /* covers situation of sibling being first */
1733 node->prev = sibling->prev;
1734 sibling->prev = node;
1735 if (node->prev->next) {
1736 /* sibling had a preceding node */
1737 node->prev->next = node;
1738 } else if (sibling->parent) {
1739 /* sibling was first and we must also change parent child pointer */
1740 sibling->parent->child = node;
1741 }
1742 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001743
Michal Vasko9f96a052020-03-10 09:41:45 +01001744 for (par = node->parent; par; par = par->parent) {
1745 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1746 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001747 par->flags &= ~LYD_DEFAULT;
1748 }
Michal Vaskob104f112020-07-17 09:54:54 +02001749 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001750 /* rehash key-less list */
1751 lyd_hash((struct lyd_node *)par);
1752 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001753 }
Michal Vasko90932a92020-02-12 14:33:03 +01001754}
1755
1756/**
Michal Vaskob104f112020-07-17 09:54:54 +02001757 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +01001758 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001759 * Handles inserting into NP containers and key-less lists.
1760 *
Michal Vasko90932a92020-02-12 14:33:03 +01001761 * @param[in] parent Parent to insert into.
1762 * @param[in] node Node to insert.
1763 */
1764static void
Michal Vaskob104f112020-07-17 09:54:54 +02001765lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001766{
1767 struct lyd_node_inner *par;
1768
Radek Krejcia1c1e542020-09-29 16:06:52 +02001769 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +01001770 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +01001771
1772 par = (struct lyd_node_inner *)parent;
1773
Michal Vaskob104f112020-07-17 09:54:54 +02001774 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +01001775 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001776
Michal Vaskod989ba02020-08-24 10:59:24 +02001777 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001778 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1779 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001780 par->flags &= ~LYD_DEFAULT;
1781 }
Michal Vasko52927e22020-03-16 17:26:14 +01001782 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001783 /* rehash key-less list */
1784 lyd_hash((struct lyd_node *)par);
1785 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001786 }
Michal Vasko751cb4d2020-07-14 12:25:28 +02001787}
Michal Vasko0249f7c2020-03-05 16:36:40 +01001788
Michal Vasko751cb4d2020-07-14 12:25:28 +02001789/**
1790 * @brief Learn whether a list instance has all the keys.
1791 *
1792 * @param[in] list List instance to check.
1793 * @return non-zero if all the keys were found,
1794 * @return 0 otherwise.
1795 */
1796static int
1797lyd_insert_has_keys(const struct lyd_node *list)
1798{
1799 const struct lyd_node *key;
1800 const struct lysc_node *skey = NULL;
1801
1802 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +02001803 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +02001804 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
1805 if (!key || (key->schema != skey)) {
1806 /* key missing */
1807 return 0;
1808 }
1809
1810 key = key->next;
1811 }
1812
1813 /* all keys found */
1814 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +01001815}
1816
1817void
Michal Vaskob104f112020-07-17 09:54:54 +02001818lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001819{
Michal Vaskob104f112020-07-17 09:54:54 +02001820 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +01001821
Michal Vaskob104f112020-07-17 09:54:54 +02001822 /* inserting list without its keys is not supported */
1823 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vasko9b368d32020-02-14 13:53:31 +01001824
Michal Vaskob104f112020-07-17 09:54:54 +02001825 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
1826 parent = (struct lyd_node *)(*first_sibling_p)->parent;
Michal Vasko9b368d32020-02-14 13:53:31 +01001827 }
Michal Vasko90932a92020-02-12 14:33:03 +01001828
Michal Vaskob104f112020-07-17 09:54:54 +02001829 /* get first sibling */
1830 first_sibling = parent ? ((struct lyd_node_inner *)parent)->child : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +01001831
Michal Vaskob104f112020-07-17 09:54:54 +02001832 /* find the anchor, our next node, so we can insert before it */
1833 anchor = lyd_insert_get_next_anchor(first_sibling, node);
1834 if (anchor) {
1835 lyd_insert_before_node(anchor, node);
1836 } else if (first_sibling) {
1837 lyd_insert_after_node(first_sibling->prev, node);
1838 } else if (parent) {
1839 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +01001840 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02001841 *first_sibling_p = node;
1842 }
1843
1844 /* insert into parent HT */
1845 lyd_insert_hash(node);
1846
1847 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +02001848 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +02001849 lyd_hash(parent);
1850
1851 /* now we can insert even the list into its parent HT */
1852 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +01001853 }
Michal Vasko90932a92020-02-12 14:33:03 +01001854}
1855
Michal Vaskof03ed032020-03-04 13:31:44 +01001856static LY_ERR
1857lyd_insert_check_schema(const struct lysc_node *parent, const struct lysc_node *schema)
1858{
1859 const struct lysc_node *par2;
1860
1861 assert(schema);
Michal Vasko62ed12d2020-05-21 10:08:25 +02001862 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01001863
1864 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02001865 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01001866
1867 if (parent) {
1868 /* inner node */
1869 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02001870 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02001871 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001872 return LY_EINVAL;
1873 }
1874 } else {
1875 /* top-level node */
1876 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02001877 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001878 return LY_EINVAL;
1879 }
1880 }
1881
1882 return LY_SUCCESS;
1883}
1884
1885API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001886lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01001887{
1888 struct lyd_node *iter;
1889
Michal Vasko654bc852020-06-23 13:28:06 +02001890 LY_CHECK_ARG_RET(NULL, parent, node, parent->schema->nodetype & LYD_NODE_INNER, LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001891
1892 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, node->schema));
1893
1894 if (node->schema->flags & LYS_KEY) {
1895 LOGERR(parent->schema->module->ctx, LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
1896 return LY_EINVAL;
1897 }
1898
1899 if (node->parent || node->prev->next) {
1900 lyd_unlink_tree(node);
1901 }
1902
1903 while (node) {
1904 iter = node->next;
1905 lyd_unlink_tree(node);
1906 lyd_insert_node(parent, NULL, node);
1907 node = iter;
1908 }
1909 return LY_SUCCESS;
1910}
1911
1912API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001913lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01001914{
1915 struct lyd_node *iter;
1916
Michal Vaskob104f112020-07-17 09:54:54 +02001917 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001918
Michal Vaskob104f112020-07-17 09:54:54 +02001919 if (sibling) {
1920 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001921 }
1922
1923 if (node->parent || node->prev->next) {
1924 lyd_unlink_tree(node);
1925 }
1926
1927 while (node) {
Michal Vaskob104f112020-07-17 09:54:54 +02001928 if (node->schema->flags & LYS_KEY) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001929 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +02001930 return LY_EINVAL;
1931 }
1932
Michal Vaskob1b5c262020-03-05 14:29:47 +01001933 iter = node->next;
1934 lyd_unlink_tree(node);
1935 lyd_insert_node(NULL, &sibling, node);
1936 node = iter;
1937 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001938
Michal Vaskob104f112020-07-17 09:54:54 +02001939 if (first) {
1940 /* find the first sibling */
1941 *first = sibling;
1942 while ((*first)->prev->next) {
1943 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001944 }
1945 }
1946
1947 return LY_SUCCESS;
1948}
1949
Michal Vaskob1b5c262020-03-05 14:29:47 +01001950API LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01001951lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
1952{
1953 struct lyd_node *iter;
1954
1955 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
1956
Michal Vasko62ed12d2020-05-21 10:08:25 +02001957 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01001958
Michal Vaskob104f112020-07-17 09:54:54 +02001959 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001960 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01001961 return LY_EINVAL;
1962 }
1963
1964 if (node->parent || node->prev->next) {
1965 lyd_unlink_tree(node);
1966 }
1967
1968 /* insert in reverse order to get the original order */
1969 node = node->prev;
1970 while (node) {
1971 iter = node->prev;
1972 lyd_unlink_tree(node);
1973
1974 lyd_insert_before_node(sibling, node);
Michal Vasko751cb4d2020-07-14 12:25:28 +02001975 lyd_insert_hash(node);
1976
Michal Vaskof03ed032020-03-04 13:31:44 +01001977 /* move the anchor accordingly */
1978 sibling = node;
1979
1980 node = (iter == node) ? NULL : iter;
1981 }
1982 return LY_SUCCESS;
1983}
1984
1985API LY_ERR
1986lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
1987{
1988 struct lyd_node *iter;
1989
1990 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
1991
Michal Vasko62ed12d2020-05-21 10:08:25 +02001992 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01001993
Michal Vaskob104f112020-07-17 09:54:54 +02001994 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001995 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01001996 return LY_EINVAL;
1997 }
1998
1999 if (node->parent || node->prev->next) {
2000 lyd_unlink_tree(node);
2001 }
2002
2003 while (node) {
2004 iter = node->next;
2005 lyd_unlink_tree(node);
2006
2007 lyd_insert_after_node(sibling, node);
Michal Vasko751cb4d2020-07-14 12:25:28 +02002008 lyd_insert_hash(node);
2009
Michal Vaskof03ed032020-03-04 13:31:44 +01002010 /* move the anchor accordingly */
2011 sibling = node;
2012
2013 node = iter;
2014 }
2015 return LY_SUCCESS;
2016}
2017
2018API void
2019lyd_unlink_tree(struct lyd_node *node)
2020{
2021 struct lyd_node *iter;
2022
2023 if (!node) {
2024 return;
2025 }
2026
Michal Vaskob104f112020-07-17 09:54:54 +02002027 /* update hashes while still linked into the tree */
2028 lyd_unlink_hash(node);
2029
Michal Vaskof03ed032020-03-04 13:31:44 +01002030 /* unlink from siblings */
2031 if (node->prev->next) {
2032 node->prev->next = node->next;
2033 }
2034 if (node->next) {
2035 node->next->prev = node->prev;
2036 } else {
2037 /* unlinking the last node */
2038 if (node->parent) {
2039 iter = node->parent->child;
2040 } else {
2041 iter = node->prev;
2042 while (iter->prev != node) {
2043 iter = iter->prev;
2044 }
2045 }
2046 /* update the "last" pointer from the first node */
2047 iter->prev = node->prev;
2048 }
2049
2050 /* unlink from parent */
2051 if (node->parent) {
2052 if (node->parent->child == node) {
2053 /* the node is the first child */
2054 node->parent->child = node->next;
2055 }
2056
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002057 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +02002058 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
2059 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002060 LY_LIST_FOR(node->parent->child, iter) {
2061 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
2062 break;
2063 }
2064 }
2065 if (!iter) {
2066 node->parent->flags |= LYD_DEFAULT;
2067 }
2068 }
2069
Michal Vaskof03ed032020-03-04 13:31:44 +01002070 /* check for keyless list and update its hash */
2071 for (iter = (struct lyd_node *)node->parent; iter; iter = (struct lyd_node *)iter->parent) {
Michal Vasko413c7f22020-05-05 12:34:06 +02002072 if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002073 lyd_hash(iter);
2074 }
2075 }
2076
2077 node->parent = NULL;
2078 }
2079
2080 node->next = NULL;
2081 node->prev = node;
2082}
2083
Michal Vaskoa5da3292020-08-12 13:10:50 +02002084void
Radek Krejci1798aae2020-07-14 13:26:06 +02002085lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta)
2086{
2087 struct lyd_meta *last, *iter;
2088
2089 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02002090
2091 if (!meta) {
2092 return;
2093 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002094
2095 for (iter = meta; iter; iter = iter->next) {
2096 iter->parent = parent;
2097 }
2098
2099 /* insert as the last attribute */
2100 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002101 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02002102 last->next = meta;
2103 } else {
2104 parent->meta = meta;
2105 }
2106
2107 /* remove default flags from NP containers */
2108 while (parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
2109 parent->flags &= ~LYD_DEFAULT;
2110 parent = (struct lyd_node *)parent->parent;
2111 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002112}
2113
2114LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01002115lyd_create_meta(struct lyd_node *parent, struct lyd_meta **meta, const struct lys_module *mod, const char *name,
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002116 size_t name_len, const char *value, size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format,
2117 void *prefix_data, uint32_t hints, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01002118{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002119 LY_ERR rc;
Michal Vasko90932a92020-02-12 14:33:03 +01002120 struct lysc_ext_instance *ant = NULL;
Michal Vasko9f96a052020-03-10 09:41:45 +01002121 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002122 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +01002123
Michal Vasko9f96a052020-03-10 09:41:45 +01002124 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002125
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002126 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko69730152020-10-09 16:30:07 +02002127 if ((mod->compiled->exts[u].def->plugin == lyext_plugins_internal[LYEXT_PLUGIN_INTERNAL_ANNOTATION].plugin) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002128 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +01002129 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002130 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +01002131 break;
2132 }
2133 }
2134 if (!ant) {
2135 /* attribute is not defined as a metadata annotation (RFC 7952) */
2136 LOGERR(mod->ctx, LY_EINVAL, "Annotation definition for attribute \"%s:%.*s\" not found.",
2137 mod->name, name_len, name);
2138 return LY_EINVAL;
2139 }
2140
Michal Vasko9f96a052020-03-10 09:41:45 +01002141 mt = calloc(1, sizeof *mt);
2142 LY_CHECK_ERR_RET(!mt, LOGMEM(mod->ctx), LY_EMEM);
2143 mt->parent = parent;
2144 mt->annotation = ant;
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002145 rc = lyd_value_store(mod->ctx, &mt->value, ((struct lyext_metadata *)ant->data)->type, value, value_len, dynamic,
2146 format, prefix_data, hints, parent ? parent->schema : NULL, incomplete, LY_VLOG_NONE, NULL);
2147 LY_CHECK_ERR_RET(rc, free(mt), rc);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002148 rc = lydict_insert(mod->ctx, name, name_len, &mt->name);
2149 LY_CHECK_ERR_RET(rc, free(mt), rc);
Michal Vasko90932a92020-02-12 14:33:03 +01002150
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002151 /* insert as the last attribute */
2152 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002153 lyd_insert_meta(parent, mt);
Michal Vasko9f96a052020-03-10 09:41:45 +01002154 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002155 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01002156 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002157 }
2158
Michal Vasko9f96a052020-03-10 09:41:45 +01002159 if (meta) {
2160 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002161 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002162 return LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01002163}
2164
Michal Vaskoa5da3292020-08-12 13:10:50 +02002165void
2166lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
2167{
2168 struct lyd_attr *last, *iter;
2169 struct lyd_node_opaq *opaq;
2170
2171 assert(parent && !parent->schema);
2172
2173 if (!attr) {
2174 return;
2175 }
2176
2177 opaq = (struct lyd_node_opaq *)parent;
2178 for (iter = attr; iter; iter = iter->next) {
2179 iter->parent = opaq;
2180 }
2181
2182 /* insert as the last attribute */
2183 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002184 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02002185 last->next = attr;
2186 } else {
2187 opaq->attr = attr;
2188 }
2189}
2190
Michal Vasko52927e22020-03-16 17:26:14 +01002191LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002192lyd_create_attr(struct lyd_node *parent, struct lyd_attr **attr, const struct ly_ctx *ctx, const char *name, size_t name_len,
2193 const char *value, size_t value_len, ly_bool *dynamic, LYD_FORMAT format, uint32_t hints,
Radek Krejci0f969882020-08-21 16:56:47 +02002194 struct ly_prefix *val_prefs, const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len)
Michal Vasko52927e22020-03-16 17:26:14 +01002195{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002196 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02002197 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01002198
2199 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002200 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01002201
2202 if (!value_len) {
2203 value = "";
2204 }
2205
2206 at = calloc(1, sizeof *at);
Radek Krejcid46e46a2020-09-15 14:22:42 +02002207 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_val_prefs(ctx, val_prefs), LY_EMEM);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002208 at->hints = hints;
Radek Krejcid46e46a2020-09-15 14:22:42 +02002209 at->format = format;
2210 at->val_prefs = val_prefs;
2211
Radek Krejci011e4aa2020-09-04 15:22:31 +02002212 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002213 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002214 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
2215 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002216 *dynamic = 0;
2217 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002218 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002219 }
2220
Radek Krejci1798aae2020-07-14 13:26:06 +02002221 if (prefix_len) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002222 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->prefix.id), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +02002223 }
2224 if (module_key_len) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002225 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->prefix.module_ns), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002226 }
2227
2228 /* insert as the last attribute */
2229 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002230 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01002231 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002232 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01002233 last->next = at;
2234 }
2235
Radek Krejci011e4aa2020-09-04 15:22:31 +02002236finish:
2237 if (ret) {
2238 lyd_free_attr_single(ctx, at);
2239 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01002240 *attr = at;
2241 }
2242 return LY_SUCCESS;
2243}
2244
Radek Krejci084289f2019-07-09 17:35:30 +02002245API const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02002246lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02002247{
Michal Vasko004d3152020-06-11 19:59:22 +02002248 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02002249
Michal Vasko004d3152020-06-11 19:59:22 +02002250 if (ly_path_eval(path, tree, &target)) {
2251 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02002252 }
2253
Michal Vasko004d3152020-06-11 19:59:22 +02002254 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02002255}
2256
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002257API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002258lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002259{
2260 const struct lyd_node *iter1, *iter2;
2261 struct lyd_node_term *term1, *term2;
2262 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01002263 struct lyd_node_opaq *opaq1, *opaq2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002264 size_t len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02002265
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002266 if (!node1 || !node2) {
2267 if (node1 == node2) {
2268 return LY_SUCCESS;
2269 } else {
2270 return LY_ENOT;
2271 }
2272 }
2273
Michal Vaskob7be7a82020-08-20 09:09:04 +02002274 if ((LYD_CTX(node1) != LYD_CTX(node2)) || (node1->schema != node2->schema)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002275 return LY_ENOT;
2276 }
2277
2278 if (node1->hash != node2->hash) {
2279 return LY_ENOT;
2280 }
Michal Vasko52927e22020-03-16 17:26:14 +01002281 /* equal hashes do not mean equal nodes, they can be just in collision (or both be 0) so the nodes must be checked explicitly */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002282
Michal Vasko52927e22020-03-16 17:26:14 +01002283 if (!node1->schema) {
2284 opaq1 = (struct lyd_node_opaq *)node1;
2285 opaq2 = (struct lyd_node_opaq *)node2;
Radek Krejci1798aae2020-07-14 13:26:06 +02002286 if ((opaq1->name != opaq2->name) || (opaq1->format != opaq2->format) || (opaq1->prefix.module_ns != opaq2->prefix.module_ns)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002287 return LY_ENOT;
2288 }
Michal Vasko52927e22020-03-16 17:26:14 +01002289 switch (opaq1->format) {
2290 case LYD_XML:
2291 if (lyxml_value_compare(opaq1->value, opaq1->val_prefs, opaq2->value, opaq2->val_prefs)) {
2292 return LY_ENOT;
2293 }
2294 break;
Radek Krejci1798aae2020-07-14 13:26:06 +02002295 case LYD_JSON:
2296 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
2297 if (strcmp(opaq1->value, opaq2->value)) {
2298 return LY_ENOT;
2299 }
2300 break;
Michal Vasko60ea6352020-06-29 13:39:39 +02002301 case LYD_LYB:
Michal Vaskoc8a230d2020-08-14 12:17:10 +02002302 case LYD_UNKNOWN:
Michal Vasko52927e22020-03-16 17:26:14 +01002303 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002304 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01002305 return LY_EINT;
2306 }
2307 if (options & LYD_COMPARE_FULL_RECURSION) {
2308 iter1 = opaq1->child;
2309 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002310 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01002311 }
2312 return LY_SUCCESS;
2313 } else {
2314 switch (node1->schema->nodetype) {
2315 case LYS_LEAF:
2316 case LYS_LEAFLIST:
2317 if (options & LYD_COMPARE_DEFAULTS) {
2318 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2319 return LY_ENOT;
2320 }
2321 }
2322
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002323 term1 = (struct lyd_node_term *)node1;
2324 term2 = (struct lyd_node_term *)node2;
2325 if (term1->value.realtype != term2->value.realtype) {
2326 return LY_ENOT;
2327 }
Michal Vasko52927e22020-03-16 17:26:14 +01002328
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002329 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
Michal Vasko52927e22020-03-16 17:26:14 +01002330 case LYS_CONTAINER:
2331 if (options & LYD_COMPARE_DEFAULTS) {
2332 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2333 return LY_ENOT;
2334 }
2335 }
2336 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko22df3f02020-08-24 13:29:22 +02002337 iter1 = ((struct lyd_node_inner *)node1)->child;
2338 iter2 = ((struct lyd_node_inner *)node2)->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002339 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002340 }
2341 return LY_SUCCESS;
Michal Vasko1bf09392020-03-27 12:38:10 +01002342 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002343 case LYS_ACTION:
2344 if (options & LYD_COMPARE_FULL_RECURSION) {
2345 /* TODO action/RPC
2346 goto all_children_compare;
2347 */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002348 }
2349 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002350 case LYS_NOTIF:
2351 if (options & LYD_COMPARE_FULL_RECURSION) {
2352 /* TODO Notification
2353 goto all_children_compare;
2354 */
2355 }
2356 return LY_SUCCESS;
2357 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02002358 iter1 = ((struct lyd_node_inner *)node1)->child;
2359 iter2 = ((struct lyd_node_inner *)node2)->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002360
2361 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
2362 /* lists with keys, their equivalence is based on their keys */
Michal Vasko22df3f02020-08-24 13:29:22 +02002363 for (struct lysc_node *key = ((struct lysc_node_list *)node1->schema)->child;
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002364 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01002365 key = key->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002366 if (lyd_compare_single(iter1, iter2, options)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002367 return LY_ENOT;
2368 }
2369 iter1 = iter1->next;
2370 iter2 = iter2->next;
2371 }
2372 } else {
2373 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
2374
Radek Krejci0f969882020-08-21 16:56:47 +02002375all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01002376 if (!iter1 && !iter2) {
2377 /* no children, nothing to compare */
2378 return LY_SUCCESS;
2379 }
2380
Michal Vaskod989ba02020-08-24 10:59:24 +02002381 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002382 if (lyd_compare_single(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002383 return LY_ENOT;
2384 }
2385 }
2386 if (iter1 || iter2) {
2387 return LY_ENOT;
2388 }
2389 }
2390 return LY_SUCCESS;
2391 case LYS_ANYXML:
2392 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02002393 any1 = (struct lyd_node_any *)node1;
2394 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01002395
2396 if (any1->value_type != any2->value_type) {
2397 return LY_ENOT;
2398 }
2399 switch (any1->value_type) {
2400 case LYD_ANYDATA_DATATREE:
2401 iter1 = any1->value.tree;
2402 iter2 = any2->value.tree;
2403 goto all_children_compare;
2404 case LYD_ANYDATA_STRING:
2405 case LYD_ANYDATA_XML:
2406 case LYD_ANYDATA_JSON:
2407 len1 = strlen(any1->value.str);
2408 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02002409 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002410 return LY_ENOT;
2411 }
2412 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002413 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02002414 len1 = lyd_lyb_data_length(any1->value.mem);
2415 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko69730152020-10-09 16:30:07 +02002416 if ((len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002417 return LY_ENOT;
2418 }
2419 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002420 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002421 }
2422 }
2423
Michal Vaskob7be7a82020-08-20 09:09:04 +02002424 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002425 return LY_EINT;
2426}
Radek Krejci22ebdba2019-07-25 13:59:43 +02002427
Michal Vasko21725742020-06-29 11:49:25 +02002428API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002429lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02002430{
Michal Vaskod989ba02020-08-24 10:59:24 +02002431 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002432 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
2433 }
2434
Michal Vasko11a81432020-07-28 16:31:29 +02002435 if (node1 == node2) {
2436 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002437 }
Michal Vasko11a81432020-07-28 16:31:29 +02002438 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002439}
2440
2441API LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02002442lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
2443{
2444 if (!meta1 || !meta2) {
2445 if (meta1 == meta2) {
2446 return LY_SUCCESS;
2447 } else {
2448 return LY_ENOT;
2449 }
2450 }
2451
Michal Vaskob7be7a82020-08-20 09:09:04 +02002452 if ((LYD_CTX(meta1->parent) != LYD_CTX(meta2->parent)) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02002453 return LY_ENOT;
2454 }
2455
2456 if (meta1->value.realtype != meta2->value.realtype) {
2457 return LY_ENOT;
2458 }
2459
2460 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
2461}
2462
Radek Krejci22ebdba2019-07-25 13:59:43 +02002463/**
Michal Vasko52927e22020-03-16 17:26:14 +01002464 * @brief Duplicate a single node and connect it into @p parent (if present) or last of @p first siblings.
Radek Krejci22ebdba2019-07-25 13:59:43 +02002465 *
2466 * Ignores LYD_DUP_WITH_PARENTS and LYD_DUP_WITH_SIBLINGS which are supposed to be handled by lyd_dup().
Radek Krejcif8b95172020-05-15 14:51:06 +02002467 *
2468 * @param[in] node Original node to duplicate
2469 * @param[in] parent Parent to insert into, NULL for top-level sibling.
2470 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2471 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2472 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it int @p parent / @p first sibling).
2473 * @return LY_ERR value
Radek Krejci22ebdba2019-07-25 13:59:43 +02002474 */
Michal Vasko52927e22020-03-16 17:26:14 +01002475static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002476lyd_dup_r(const struct lyd_node *node, struct lyd_node *parent, struct lyd_node **first, uint32_t options,
Radek Krejci0f969882020-08-21 16:56:47 +02002477 struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002478{
Michal Vasko52927e22020-03-16 17:26:14 +01002479 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002480 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002481 struct lyd_meta *meta;
2482 struct lyd_node_any *any;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002483 LY_ARRAY_COUNT_TYPE u;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002484
Michal Vasko52927e22020-03-16 17:26:14 +01002485 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002486
Michal Vasko52927e22020-03-16 17:26:14 +01002487 if (!node->schema) {
2488 dup = calloc(1, sizeof(struct lyd_node_opaq));
2489 } else {
2490 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01002491 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002492 case LYS_ACTION:
2493 case LYS_NOTIF:
2494 case LYS_CONTAINER:
2495 case LYS_LIST:
2496 dup = calloc(1, sizeof(struct lyd_node_inner));
2497 break;
2498 case LYS_LEAF:
2499 case LYS_LEAFLIST:
2500 dup = calloc(1, sizeof(struct lyd_node_term));
2501 break;
2502 case LYS_ANYDATA:
2503 case LYS_ANYXML:
2504 dup = calloc(1, sizeof(struct lyd_node_any));
2505 break;
2506 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02002507 LOGINT(LYD_CTX(node));
Michal Vasko52927e22020-03-16 17:26:14 +01002508 ret = LY_EINT;
2509 goto error;
2510 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002511 }
Michal Vaskob7be7a82020-08-20 09:09:04 +02002512 LY_CHECK_ERR_GOTO(!dup, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002513
Michal Vaskof6df0a02020-06-16 13:08:34 +02002514 if (options & LYD_DUP_WITH_FLAGS) {
2515 dup->flags = node->flags;
2516 } else {
2517 dup->flags = (node->flags & LYD_DEFAULT) | LYD_NEW;
2518 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002519 dup->schema = node->schema;
Michal Vasko52927e22020-03-16 17:26:14 +01002520 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002521
Michal Vasko25a32822020-07-09 15:48:22 +02002522 /* duplicate metadata */
2523 if (!(options & LYD_DUP_NO_META)) {
2524 LY_LIST_FOR(node->meta, meta) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002525 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
Michal Vasko25a32822020-07-09 15:48:22 +02002526 }
2527 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002528
2529 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01002530 if (!dup->schema) {
2531 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
2532 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
2533 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002534
2535 if (options & LYD_DUP_RECURSIVE) {
2536 /* duplicate all the children */
2537 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002538 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002539 }
2540 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002541 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name, 0, &opaq->name), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002542 opaq->format = orig->format;
Radek Krejci1798aae2020-07-14 13:26:06 +02002543 if (orig->prefix.id) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002544 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->prefix.id, 0, &opaq->prefix.id), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002545 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002546 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->prefix.module_ns, 0, &opaq->prefix.module_ns), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002547 if (orig->val_prefs) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002548 LY_ARRAY_CREATE_GOTO(LYD_CTX(node), opaq->val_prefs, LY_ARRAY_COUNT(orig->val_prefs), ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002549 LY_ARRAY_FOR(orig->val_prefs, u) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002550 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->val_prefs[u].id, 0, &opaq->val_prefs[u].id), error);
2551 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->val_prefs[u].module_ns, 0, &opaq->val_prefs[u].module_ns), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002552 LY_ARRAY_INCREMENT(opaq->val_prefs);
2553 }
2554 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002555 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->value, 0, &opaq->value), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002556 opaq->ctx = orig->ctx;
2557 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
2558 struct lyd_node_term *term = (struct lyd_node_term *)dup;
2559 struct lyd_node_term *orig = (struct lyd_node_term *)node;
2560
2561 term->hash = orig->hash;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002562 LY_CHECK_ERR_GOTO(orig->value.realtype->plugin->duplicate(LYD_CTX(node), &orig->value, &term->value),
Michal Vasko69730152020-10-09 16:30:07 +02002563 LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."); ret = LY_EINT, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002564 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
2565 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
2566 struct lyd_node *child;
2567
2568 if (options & LYD_DUP_RECURSIVE) {
2569 /* duplicate all the children */
2570 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002571 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002572 }
Michal Vasko69730152020-10-09 16:30:07 +02002573 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002574 /* always duplicate keys of a list */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002575 child = orig->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002576 for (struct lysc_node *key = ((struct lysc_node_list *)dup->schema)->child;
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002577 key && (key->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +02002578 key = key->next) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002579 if (!child) {
2580 /* possibly not keys are present in filtered tree */
2581 break;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002582 } else if (child->schema != key) {
2583 /* possibly not all keys are present in filtered tree,
2584 * but there can be also some non-key nodes */
2585 continue;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002586 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002587 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002588 child = child->next;
2589 }
2590 }
2591 lyd_hash(dup);
2592 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02002593 dup->hash = node->hash;
2594 any = (struct lyd_node_any *)node;
2595 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002596 }
2597
Michal Vasko52927e22020-03-16 17:26:14 +01002598 /* insert */
2599 lyd_insert_node(parent, first, dup);
Michal Vasko52927e22020-03-16 17:26:14 +01002600
2601 if (dup_p) {
2602 *dup_p = dup;
2603 }
2604 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002605
2606error:
Michal Vasko52927e22020-03-16 17:26:14 +01002607 lyd_free_tree(dup);
2608 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002609}
2610
Michal Vasko3a41dff2020-07-15 14:30:28 +02002611static LY_ERR
2612lyd_dup_get_local_parent(const struct lyd_node *node, const struct lyd_node_inner *parent, struct lyd_node **dup_parent,
Radek Krejci0f969882020-08-21 16:56:47 +02002613 struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002614{
Michal Vasko3a41dff2020-07-15 14:30:28 +02002615 const struct lyd_node_inner *orig_parent, *iter;
Radek Krejci857189e2020-09-01 13:26:36 +02002616 ly_bool repeat = 1;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002617
2618 *dup_parent = NULL;
2619 *local_parent = NULL;
2620
2621 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
2622 if (parent && (parent->schema == orig_parent->schema)) {
2623 /* stop creating parents, connect what we have into the provided parent */
2624 iter = parent;
2625 repeat = 0;
2626 } else {
2627 iter = NULL;
2628 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, NULL, (struct lyd_node **)&iter, 0,
Radek Krejci0f969882020-08-21 16:56:47 +02002629 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02002630 }
2631 if (!*local_parent) {
2632 *local_parent = (struct lyd_node_inner *)iter;
2633 }
2634 if (iter->child) {
2635 /* 1) list - add after keys
2636 * 2) provided parent with some children */
2637 iter->child->prev->next = *dup_parent;
2638 if (*dup_parent) {
2639 (*dup_parent)->prev = iter->child->prev;
2640 iter->child->prev = *dup_parent;
2641 }
2642 } else {
2643 ((struct lyd_node_inner *)iter)->child = *dup_parent;
2644 }
2645 if (*dup_parent) {
2646 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
2647 }
2648 *dup_parent = (struct lyd_node *)iter;
2649 }
2650
2651 if (repeat && parent) {
2652 /* given parent and created parents chain actually do not interconnect */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002653 LOGERR(LYD_CTX(node), LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02002654 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002655 return LY_EINVAL;
2656 }
2657
2658 return LY_SUCCESS;
2659}
2660
2661static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002662lyd_dup(const struct lyd_node *node, struct lyd_node_inner *parent, uint32_t options, ly_bool nosiblings, struct lyd_node **dup)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002663{
2664 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002665 const struct lyd_node *orig; /* original node to be duplicated */
2666 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002667 struct lyd_node *top = NULL; /* the most higher created node */
2668 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002669
Michal Vasko3a41dff2020-07-15 14:30:28 +02002670 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002671
2672 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002673 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, parent, &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002674 } else {
2675 local_parent = parent;
2676 }
2677
Radek Krejci22ebdba2019-07-25 13:59:43 +02002678 LY_LIST_FOR(node, orig) {
Michal Vasko52927e22020-03-16 17:26:14 +01002679 /* if there is no local parent, it will be inserted into first */
Michal Vasko3a41dff2020-07-15 14:30:28 +02002680 LY_CHECK_GOTO(rc = lyd_dup_r(orig, (struct lyd_node *)local_parent, &first, options, first ? NULL : &first), error);
2681 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002682 break;
2683 }
2684 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002685
2686 /* rehash if needed */
Michal Vaskod989ba02020-08-24 10:59:24 +02002687 for ( ; local_parent; local_parent = local_parent->parent) {
Michal Vasko69730152020-10-09 16:30:07 +02002688 if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002689 lyd_hash((struct lyd_node *)local_parent);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002690 }
2691 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002692
2693 if (dup) {
2694 *dup = first;
2695 }
2696 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002697
2698error:
2699 if (top) {
2700 lyd_free_tree(top);
2701 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01002702 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002703 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002704 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002705}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002706
Michal Vasko3a41dff2020-07-15 14:30:28 +02002707API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002708lyd_dup_single(const struct lyd_node *node, struct lyd_node_inner *parent, uint32_t options, struct lyd_node **dup)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002709{
2710 return lyd_dup(node, parent, options, 1, dup);
2711}
2712
2713API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002714lyd_dup_siblings(const struct lyd_node *node, struct lyd_node_inner *parent, uint32_t options, struct lyd_node **dup)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002715{
2716 return lyd_dup(node, parent, options, 0, dup);
2717}
2718
2719API LY_ERR
2720lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02002721{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002722 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002723 struct lyd_meta *mt, *last;
2724
Michal Vasko3a41dff2020-07-15 14:30:28 +02002725 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02002726
2727 /* create a copy */
2728 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02002729 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02002730 mt->annotation = meta->annotation;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002731 ret = meta->value.realtype->plugin->duplicate(LYD_CTX(node), &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002732 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
2733 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02002734
2735 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02002736 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02002737 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002738 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02002739 last->next = mt;
2740 } else {
2741 node->meta = mt;
2742 }
2743
Radek Krejci011e4aa2020-09-04 15:22:31 +02002744finish:
2745 if (ret) {
2746 lyd_free_meta_single(mt);
2747 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002748 *dup = mt;
2749 }
2750 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002751}
2752
Michal Vasko4490d312020-06-16 13:08:55 +02002753/**
2754 * @brief Merge a source sibling into target siblings.
2755 *
2756 * @param[in,out] first_trg First target sibling, is updated if top-level.
2757 * @param[in] parent_trg Target parent.
2758 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
2759 * @param[in] options Merge options.
2760 * @return LY_ERR value.
2761 */
2762static LY_ERR
2763lyd_merge_sibling_r(struct lyd_node **first_trg, struct lyd_node *parent_trg, const struct lyd_node **sibling_src_p,
Radek Krejci1deb5be2020-08-26 16:43:36 +02002764 uint16_t options)
Michal Vasko4490d312020-06-16 13:08:55 +02002765{
2766 LY_ERR ret;
2767 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02002768 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vasko4490d312020-06-16 13:08:55 +02002769 struct lysc_type *type;
Michal Vasko4490d312020-06-16 13:08:55 +02002770
2771 sibling_src = *sibling_src_p;
2772 if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
2773 /* try to find the exact instance */
2774 ret = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
2775 } else {
2776 /* try to simply find the node, there cannot be more instances */
2777 ret = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
2778 }
2779
2780 if (!ret) {
2781 /* node found, make sure even value matches for all node types */
Michal Vasko8f359bf2020-07-28 10:41:15 +02002782 if ((match_trg->schema->nodetype == LYS_LEAF) && lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002783 /* since they are different, they cannot both be default */
2784 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
2785
Michal Vasko3a41dff2020-07-15 14:30:28 +02002786 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
2787 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002788 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002789 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
2790 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02002791 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02002792
2793 /* copy flags and add LYD_NEW */
2794 match_trg->flags = sibling_src->flags | LYD_NEW;
2795 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002796 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002797 /* update value */
2798 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002799 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002800
2801 /* copy flags and add LYD_NEW */
2802 match_trg->flags = sibling_src->flags | LYD_NEW;
Michal Vasko4490d312020-06-16 13:08:55 +02002803 } else {
2804 /* check descendants, recursively */
Radek Krejcia1c1e542020-09-29 16:06:52 +02002805 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
Michal Vasko4490d312020-06-16 13:08:55 +02002806 LY_CHECK_RET(lyd_merge_sibling_r(lyd_node_children_p(match_trg), match_trg, &child_src, options));
2807 }
2808 }
2809 } else {
2810 /* node not found, merge it */
2811 if (options & LYD_MERGE_DESTRUCT) {
2812 dup_src = (struct lyd_node *)sibling_src;
2813 lyd_unlink_tree(dup_src);
2814 /* spend it */
2815 *sibling_src_p = NULL;
2816 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002817 LY_CHECK_RET(lyd_dup_single(sibling_src, NULL, LYD_DUP_RECURSIVE | LYD_DUP_WITH_FLAGS, &dup_src));
Michal Vasko4490d312020-06-16 13:08:55 +02002818 }
2819
2820 /* set LYD_NEW for all the new nodes, required for validation */
Michal Vasko56daf732020-08-10 10:57:18 +02002821 LYD_TREE_DFS_BEGIN(dup_src, elem) {
Michal Vasko4490d312020-06-16 13:08:55 +02002822 elem->flags |= LYD_NEW;
Michal Vasko56daf732020-08-10 10:57:18 +02002823 LYD_TREE_DFS_END(dup_src, elem);
Michal Vasko4490d312020-06-16 13:08:55 +02002824 }
2825
2826 lyd_insert_node(parent_trg, first_trg, dup_src);
2827 }
2828
2829 return LY_SUCCESS;
2830}
2831
Michal Vasko3a41dff2020-07-15 14:30:28 +02002832static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002833lyd_merge(struct lyd_node **target, const struct lyd_node *source, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02002834{
2835 const struct lyd_node *sibling_src, *tmp;
Radek Krejci857189e2020-09-01 13:26:36 +02002836 ly_bool first;
Michal Vasko4490d312020-06-16 13:08:55 +02002837
2838 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
2839
2840 if (!source) {
2841 /* nothing to merge */
2842 return LY_SUCCESS;
2843 }
2844
2845 if (lysc_data_parent((*target)->schema) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002846 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02002847 return LY_EINVAL;
2848 }
2849
2850 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Radek Krejci857189e2020-09-01 13:26:36 +02002851 first = (sibling_src == source) ? 1 : 0;
Michal Vasko4490d312020-06-16 13:08:55 +02002852 LY_CHECK_RET(lyd_merge_sibling_r(target, NULL, &sibling_src, options));
2853 if (first && !sibling_src) {
2854 /* source was spent (unlinked), move to the next node */
2855 source = tmp;
2856 }
2857
Michal Vasko3a41dff2020-07-15 14:30:28 +02002858 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02002859 break;
2860 }
2861 }
2862
2863 if (options & LYD_MERGE_DESTRUCT) {
2864 /* free any leftover source data that were not merged */
2865 lyd_free_siblings((struct lyd_node *)source);
2866 }
2867
2868 return LY_SUCCESS;
2869}
2870
Michal Vasko3a41dff2020-07-15 14:30:28 +02002871API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002872lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002873{
2874 return lyd_merge(target, source, options, 1);
2875}
2876
2877API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002878lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002879{
2880 return lyd_merge(target, source, options, 0);
2881}
2882
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002883static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002884lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002885{
Michal Vasko14654712020-02-06 08:35:21 +01002886 /* ending \0 */
2887 ++reqlen;
2888
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002889 if (reqlen > *buflen) {
2890 if (is_static) {
2891 return LY_EINCOMPLETE;
2892 }
2893
2894 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
2895 if (!*buffer) {
2896 return LY_EMEM;
2897 }
2898
2899 *buflen = reqlen;
2900 }
2901
2902 return LY_SUCCESS;
2903}
2904
Michal Vaskod59035b2020-07-08 12:00:06 +02002905LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002906lyd_path_list_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002907{
2908 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002909 size_t len;
2910 const char *val;
2911 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002912
Radek Krejcia1c1e542020-09-29 16:06:52 +02002913 for (key = lyd_child(node); key && (key->schema->flags & LYS_KEY); key = key->next) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002914 val = LYD_CANON_VALUE(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002915 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002916 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002917
2918 quot = '\'';
2919 if (strchr(val, '\'')) {
2920 quot = '"';
2921 }
2922 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002923 }
2924
2925 return LY_SUCCESS;
2926}
2927
2928/**
2929 * @brief Append leaf-list value predicate to path.
2930 *
2931 * @param[in] node Node to print.
2932 * @param[in,out] buffer Buffer to print to.
2933 * @param[in,out] buflen Current buffer length.
2934 * @param[in,out] bufused Current number of characters used in @p buffer.
2935 * @param[in] is_static Whether buffer is static or can be reallocated.
2936 * @return LY_ERR
2937 */
2938static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002939lyd_path_leaflist_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002940{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002941 size_t len;
2942 const char *val;
2943 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002944
Michal Vaskob7be7a82020-08-20 09:09:04 +02002945 val = LYD_CANON_VALUE(node);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002946 len = 4 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002947 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002948
2949 quot = '\'';
2950 if (strchr(val, '\'')) {
2951 quot = '"';
2952 }
2953 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
2954
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002955 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002956}
2957
2958/**
2959 * @brief Append node position (relative to its other instances) predicate to path.
2960 *
2961 * @param[in] node Node to print.
2962 * @param[in,out] buffer Buffer to print to.
2963 * @param[in,out] buflen Current buffer length.
2964 * @param[in,out] bufused Current number of characters used in @p buffer.
2965 * @param[in] is_static Whether buffer is static or can be reallocated.
2966 * @return LY_ERR
2967 */
2968static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002969lyd_path_position_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002970{
2971 const struct lyd_node *first, *iter;
2972 size_t len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002973 uint64_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002974 char *val = NULL;
2975 LY_ERR rc;
2976
2977 if (node->parent) {
2978 first = node->parent->child;
2979 } else {
Michal Vaskoe070bfe2020-08-31 12:27:25 +02002980 for (first = node; first->prev->next; first = first->prev) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002981 }
2982 pos = 1;
2983 for (iter = first; iter != node; iter = iter->next) {
2984 if (iter->schema == node->schema) {
2985 ++pos;
2986 }
2987 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002988 if (asprintf(&val, "%" PRIu64, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002989 return LY_EMEM;
2990 }
2991
2992 len = 1 + strlen(val) + 1;
2993 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
2994 if (rc != LY_SUCCESS) {
2995 goto cleanup;
2996 }
2997
2998 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
2999
3000cleanup:
3001 free(val);
3002 return rc;
3003}
3004
3005API char *
3006lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
3007{
Radek Krejci857189e2020-09-01 13:26:36 +02003008 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003009 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01003010 size_t bufused = 0, len;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003011 const struct lyd_node *iter;
3012 const struct lys_module *mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02003013 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003014
3015 LY_CHECK_ARG_RET(NULL, node, NULL);
3016 if (buffer) {
3017 LY_CHECK_ARG_RET(node->schema->module->ctx, buflen > 1, NULL);
3018 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01003019 } else {
3020 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003021 }
3022
3023 switch (pathtype) {
Michal Vasko14654712020-02-06 08:35:21 +01003024 case LYD_PATH_LOG:
Michal Vasko790b2bc2020-08-03 13:35:06 +02003025 case LYD_PATH_LOG_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01003026 depth = 1;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003027 for (iter = node; iter->parent; iter = (const struct lyd_node *)iter->parent) {
3028 ++depth;
3029 }
3030
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003031 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01003032 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003033 /* find the right node */
Radek Krejci1e008d22020-08-17 11:37:37 +02003034 for (iter = node, i = 1; i < depth; iter = (const struct lyd_node *)iter->parent, ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003035iter_print:
3036 /* print prefix and name */
3037 mod = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02003038 if (iter->schema && (!iter->parent || (iter->schema->module != iter->parent->schema->module))) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003039 mod = iter->schema->module;
3040 }
3041
3042 /* realloc string */
Michal Vasko22df3f02020-08-24 13:29:22 +02003043 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) : strlen(((struct lyd_node_opaq *)iter)->name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003044 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
3045 if (rc != LY_SUCCESS) {
3046 break;
3047 }
3048
3049 /* print next node */
Radek Krejci1798aae2020-07-14 13:26:06 +02003050 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "",
Michal Vasko69730152020-10-09 16:30:07 +02003051 iter->schema ? iter->schema->name : ((struct lyd_node_opaq *)iter)->name);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003052
Michal Vasko790b2bc2020-08-03 13:35:06 +02003053 /* do not always print the last (first) predicate */
Radek Krejci1798aae2020-07-14 13:26:06 +02003054 if (iter->schema && (bufused || (pathtype == LYD_PATH_LOG))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02003055 switch (iter->schema->nodetype) {
3056 case LYS_LIST:
3057 if (iter->schema->flags & LYS_KEYLESS) {
3058 /* print its position */
3059 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3060 } else {
3061 /* print all list keys in predicates */
3062 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
3063 }
3064 break;
3065 case LYS_LEAFLIST:
3066 if (iter->schema->flags & LYS_CONFIG_W) {
3067 /* print leaf-list value */
3068 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
3069 } else {
3070 /* print its position */
3071 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3072 }
3073 break;
3074 default:
3075 /* nothing to print more */
3076 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003077 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003078 }
3079 if (rc != LY_SUCCESS) {
3080 break;
3081 }
3082
Michal Vasko14654712020-02-06 08:35:21 +01003083 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003084 }
3085 break;
3086 }
3087
3088 return buffer;
3089}
Michal Vaskoe444f752020-02-10 12:20:06 +01003090
Michal Vasko25a32822020-07-09 15:48:22 +02003091API struct lyd_meta *
3092lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
3093{
3094 struct lyd_meta *ret = NULL;
3095 const struct ly_ctx *ctx;
3096 const char *prefix, *tmp;
3097 char *str;
3098 size_t pref_len, name_len;
3099
3100 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
3101
3102 if (!first) {
3103 return NULL;
3104 }
3105
3106 ctx = first->annotation->module->ctx;
3107
3108 /* parse the name */
3109 tmp = name;
3110 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3111 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3112 return NULL;
3113 }
3114
3115 /* find the module */
3116 if (prefix) {
3117 str = strndup(prefix, pref_len);
3118 module = ly_ctx_get_module_latest(ctx, str);
3119 free(str);
3120 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", pref_len, prefix), NULL);
3121 }
3122
3123 /* find the metadata */
3124 LY_LIST_FOR(first, first) {
3125 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3126 ret = (struct lyd_meta *)first;
3127 break;
3128 }
3129 }
3130
3131 return ret;
3132}
3133
Michal Vasko9b368d32020-02-14 13:53:31 +01003134API LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003135lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3136{
3137 struct lyd_node **match_p;
3138 struct lyd_node_inner *parent;
3139
Michal Vaskof03ed032020-03-04 13:31:44 +01003140 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003141
Michal Vasko62ed12d2020-05-21 10:08:25 +02003142 if (!siblings || (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema))) {
3143 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003144 if (match) {
3145 *match = NULL;
3146 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003147 return LY_ENOTFOUND;
3148 }
3149
3150 /* find first sibling */
3151 if (siblings->parent) {
3152 siblings = siblings->parent->child;
3153 } else {
3154 while (siblings->prev->next) {
3155 siblings = siblings->prev;
3156 }
3157 }
3158
3159 parent = (struct lyd_node_inner *)siblings->parent;
3160 if (parent && parent->children_ht) {
3161 assert(target->hash);
3162
3163 /* find by hash */
3164 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003165 /* check even value when needed */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003166 if (!(target->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !lyd_compare_single(target, *match_p, 0)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003167 siblings = *match_p;
3168 } else {
3169 siblings = NULL;
3170 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003171 } else {
3172 /* not found */
3173 siblings = NULL;
3174 }
3175 } else {
3176 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02003177 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02003178 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003179 break;
3180 }
3181 }
3182 }
3183
3184 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003185 if (match) {
3186 *match = NULL;
3187 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003188 return LY_ENOTFOUND;
3189 }
3190
Michal Vasko9b368d32020-02-14 13:53:31 +01003191 if (match) {
3192 *match = (struct lyd_node *)siblings;
3193 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003194 return LY_SUCCESS;
3195}
3196
Radek Krejci857189e2020-09-01 13:26:36 +02003197/**
3198 * @brief Comparison callback to match schema node with a schema of a data node.
3199 *
3200 * @param[in] val1_p Pointer to the schema node
3201 * @param[in] val2_p Pointer to the data node
3202 * Implementation of ::values_equal_cb.
3203 */
3204static ly_bool
3205lyd_hash_table_schema_val_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Michal Vasko90932a92020-02-12 14:33:03 +01003206{
3207 struct lysc_node *val1;
3208 struct lyd_node *val2;
3209
3210 val1 = *((struct lysc_node **)val1_p);
3211 val2 = *((struct lyd_node **)val2_p);
3212
Michal Vasko90932a92020-02-12 14:33:03 +01003213 if (val1 == val2->schema) {
3214 /* schema match is enough */
3215 return 1;
3216 } else {
3217 return 0;
3218 }
3219}
3220
3221static LY_ERR
3222lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema, struct lyd_node **match)
3223{
3224 struct lyd_node **match_p;
3225 struct lyd_node_inner *parent;
3226 uint32_t hash;
3227 values_equal_cb ht_cb;
3228
Michal Vaskob104f112020-07-17 09:54:54 +02003229 assert(siblings && schema);
Michal Vasko90932a92020-02-12 14:33:03 +01003230
3231 parent = (struct lyd_node_inner *)siblings->parent;
3232 if (parent && parent->children_ht) {
3233 /* calculate our hash */
3234 hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
3235 hash = dict_hash_multi(hash, schema->name, strlen(schema->name));
3236 hash = dict_hash_multi(hash, NULL, 0);
3237
3238 /* use special hash table function */
3239 ht_cb = lyht_set_cb(parent->children_ht, lyd_hash_table_schema_val_equal);
3240
3241 /* find by hash */
3242 if (!lyht_find(parent->children_ht, &schema, hash, (void **)&match_p)) {
3243 siblings = *match_p;
3244 } else {
3245 /* not found */
3246 siblings = NULL;
3247 }
3248
3249 /* set the original hash table compare function back */
3250 lyht_set_cb(parent->children_ht, ht_cb);
3251 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02003252 /* find first sibling */
3253 if (siblings->parent) {
3254 siblings = siblings->parent->child;
3255 } else {
3256 while (siblings->prev->next) {
3257 siblings = siblings->prev;
3258 }
3259 }
3260
3261 /* search manually without hashes */
Michal Vaskod989ba02020-08-24 10:59:24 +02003262 for ( ; siblings; siblings = siblings->next) {
Michal Vasko90932a92020-02-12 14:33:03 +01003263 if (siblings->schema == schema) {
3264 /* schema match is enough */
3265 break;
3266 }
3267 }
3268 }
3269
3270 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003271 if (match) {
3272 *match = NULL;
3273 }
Michal Vasko90932a92020-02-12 14:33:03 +01003274 return LY_ENOTFOUND;
3275 }
3276
Michal Vasko9b368d32020-02-14 13:53:31 +01003277 if (match) {
3278 *match = (struct lyd_node *)siblings;
3279 }
Michal Vasko90932a92020-02-12 14:33:03 +01003280 return LY_SUCCESS;
3281}
3282
Michal Vaskoe444f752020-02-10 12:20:06 +01003283API LY_ERR
3284lyd_find_sibling_val(const struct lyd_node *siblings, const struct lysc_node *schema, const char *key_or_value,
Radek Krejci0f969882020-08-21 16:56:47 +02003285 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003286{
3287 LY_ERR rc;
3288 struct lyd_node *target = NULL;
3289
Michal Vasko4c583e82020-07-17 12:16:14 +02003290 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003291
Michal Vasko62ed12d2020-05-21 10:08:25 +02003292 if (!siblings || (lysc_data_parent(siblings->schema) != lysc_data_parent(schema))) {
3293 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003294 if (match) {
3295 *match = NULL;
3296 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003297 return LY_ENOTFOUND;
3298 }
3299
Michal Vaskof03ed032020-03-04 13:31:44 +01003300 if (key_or_value && !val_len) {
3301 val_len = strlen(key_or_value);
3302 }
3303
Michal Vaskob104f112020-07-17 09:54:54 +02003304 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3305 /* create a data node and find the instance */
3306 if (schema->nodetype == LYS_LEAFLIST) {
3307 /* target used attributes: schema, hash, value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003308 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &target);
3309 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003310 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003311 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02003312 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003313 }
3314
3315 /* find it */
3316 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003317 } else {
3318 /* find the first schema node instance */
3319 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003320 }
3321
Michal Vaskoe444f752020-02-10 12:20:06 +01003322 lyd_free_tree(target);
3323 return rc;
3324}
Michal Vaskoccc02342020-05-21 10:09:21 +02003325
3326API LY_ERR
3327lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
3328{
3329 LY_ERR ret = LY_SUCCESS;
3330 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003331 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02003332 uint32_t i;
3333
3334 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
3335
3336 memset(&xp_set, 0, sizeof xp_set);
3337
3338 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003339 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
3340 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003341
3342 /* evaluate expression */
Michal Vasko5d24f6c2020-10-13 13:49:06 +02003343 ret = lyxp_eval(exp, NULL, LY_PREF_JSON, NULL, ctx_node, ctx_node, &xp_set, 0);
Michal Vaskoccc02342020-05-21 10:09:21 +02003344 LY_CHECK_GOTO(ret, cleanup);
3345
3346 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02003347 ret = ly_set_new(set);
3348 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003349
3350 /* transform into ly_set */
3351 if (xp_set.type == LYXP_SET_NODE_SET) {
3352 /* allocate memory for all the elements once (even though not all items must be elements but most likely will be) */
3353 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003354 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(ctx_node)); ret = LY_EMEM, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003355 (*set)->size = xp_set.used;
3356
3357 for (i = 0; i < xp_set.used; ++i) {
3358 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +02003359 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +02003360 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003361 }
3362 }
3363 }
3364
3365cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02003366 lyxp_set_free_content(&xp_set);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003367 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
Michal Vaskoccc02342020-05-21 10:09:21 +02003368 return ret;
3369}
Radek Krejcica989142020-11-05 11:32:22 +01003370
3371API uint32_t
3372lyd_list_pos(const struct lyd_node *instance)
3373{
3374 const struct lyd_node *iter = NULL;
3375 uint32_t pos = 0;
3376
3377 if (!instance || !(instance->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
3378 return 0;
3379 }
3380
3381 /* data instances are ordered, so we can stop when we found instance of other schema node */
3382 for (iter = instance; iter->schema == instance->schema; iter = iter->prev) {
3383 if (pos && iter->next == NULL) {
3384 /* overrun to the end of the siblings list */
3385 break;
3386 }
3387 ++pos;
3388 }
3389
3390 return pos;
3391}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003392
3393API struct lyd_node *
3394lyd_first_sibling(const struct lyd_node *node)
3395{
3396 struct lyd_node *start;
3397
3398 if (!node) {
3399 return NULL;
3400 }
3401
3402 /* get the first sibling */
3403 if (node->parent) {
3404 start = node->parent->child;
3405 } else {
3406 for (start = (struct lyd_node *)node; start->prev->next; start = start->prev);
3407 }
3408
3409 return start;
3410}