blob: a1acddc6f4205adb06d5ec198d5e008e90801247 [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>
Radek Krejci47fab892020-11-05 17:02:41 +010021#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdarg.h>
23#include <stdint.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include <stdio.h>
25#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <string.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020027
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020029#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020030#include "context.h"
31#include "dict.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020032#include "diff.h"
Michal Vasko90932a92020-02-12 14:33:03 +010033#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020035#include "in_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020037#include "parser_data.h"
38#include "parser_internal.h"
Michal Vasko004d3152020-06-11 19:59:22 +020039#include "path.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020040#include "plugins_exts.h"
Michal Vasko90932a92020-02-12 14:33:03 +010041#include "plugins_exts_internal.h"
Michal Vasko69730152020-10-09 16:30:07 +020042#include "plugins_exts_metadata.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020043#include "plugins_types.h"
44#include "set.h"
45#include "tree.h"
46#include "tree_data_internal.h"
47#include "tree_schema.h"
48#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020049#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020050#include "xml.h"
51#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020052
Michal Vaskob104f112020-07-17 09:54:54 +020053static LY_ERR lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema,
Radek Krejci0f969882020-08-21 16:56:47 +020054 struct lyd_node **match);
Michal Vaskob104f112020-07-17 09:54:54 +020055
Radek Krejci084289f2019-07-09 17:35:30 +020056LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020057lyd_value_store(const struct ly_ctx *ctx, struct lyd_value *val, const struct lysc_type *type, const char *value,
58 size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints,
59 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 +020060{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020061 LY_ERR ret;
Radek Krejci084289f2019-07-09 17:35:30 +020062 struct ly_err_item *err = NULL;
Michal Vasko25d6ad02020-10-22 12:20:22 +020063 uint32_t options = (dynamic && *dynamic ? LY_TYPE_STORE_DYNAMIC : 0);
Radek Krejci084289f2019-07-09 17:35:30 +020064
Michal Vaskofeca4fb2020-10-05 08:58:40 +020065 if (incomplete) {
66 *incomplete = 0;
Radek Krejci084289f2019-07-09 17:35:30 +020067 }
68
Michal Vaskofeca4fb2020-10-05 08:58:40 +020069 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 +010070 if (ret == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +020071 if (incomplete) {
72 *incomplete = 1;
73 }
74 } else if (ret) {
75 if (err) {
76 LOGVAL(ctx, log_elem_type, log_elem, err->vecode, err->msg);
77 ly_err_free(err);
78 } else {
79 LOGVAL(ctx, log_elem_type, log_elem, LYVE_OTHER, "Storing value \"%.*s\" failed.", (int)value_len, value);
80 }
81 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +010082 }
83
Michal Vaskofeca4fb2020-10-05 08:58:40 +020084 if (dynamic) {
85 *dynamic = 0;
86 }
87 return LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +010088}
89
Radek Krejci38d85362019-09-05 16:26:38 +020090LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020091lyd_value_validate_incomplete(const struct ly_ctx *ctx, const struct lysc_type *type, struct lyd_value *val,
92 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 +020093{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020094 LY_ERR ret;
Radek Krejci38d85362019-09-05 16:26:38 +020095 struct ly_err_item *err = NULL;
Radek Krejci38d85362019-09-05 16:26:38 +020096
Michal Vaskofeca4fb2020-10-05 08:58:40 +020097 assert(type->plugin->validate);
Michal Vasko8d544252020-03-02 10:19:52 +010098
Michal Vaskofeca4fb2020-10-05 08:58:40 +020099 ret = type->plugin->validate(ctx, type, ctx_node, tree, val, &err);
100 if (ret) {
Radek Krejci38d85362019-09-05 16:26:38 +0200101 if (err) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200102 LOGVAL(ctx, log_elem_type, log_elem, err->vecode, err->msg);
Radek Krejci38d85362019-09-05 16:26:38 +0200103 ly_err_free(err);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200104 } else {
105 LOGVAL(ctx, log_elem_type, log_elem, LYVE_OTHER, "Resolving value \"%s\" failed.", val->canonical);
Radek Krejci38d85362019-09-05 16:26:38 +0200106 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200107 return ret;
Radek Krejci38d85362019-09-05 16:26:38 +0200108 }
109
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200110 return LY_SUCCESS;
Radek Krejci38d85362019-09-05 16:26:38 +0200111}
112
Michal Vaskof937cfe2020-08-03 16:07:12 +0200113LY_ERR
114_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 +0200115 LY_PREFIX_FORMAT format, void *prefix_data)
Radek Krejci084289f2019-07-09 17:35:30 +0200116{
117 LY_ERR rc = LY_SUCCESS;
118 struct ly_err_item *err = NULL;
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200119 struct lyd_value storage;
Radek Krejci084289f2019-07-09 17:35:30 +0200120 struct lysc_type *type;
Radek Krejci084289f2019-07-09 17:35:30 +0200121
122 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
123
124 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
125 LOGARG(ctx, node);
126 return LY_EINVAL;
127 }
128
Michal Vasko22df3f02020-08-24 13:29:22 +0200129 type = ((struct lysc_node_leaf *)node)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200130 rc = type->plugin->store(ctx ? ctx : node->module->ctx, type, value, value_len, 0, format, prefix_data,
131 LYD_HINT_SCHEMA, node, &storage, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200132 if (rc == LY_EINCOMPLETE) {
133 /* actually success since we do not provide the context tree and call validation with
134 * LY_TYPE_OPTS_INCOMPLETE_DATA */
135 rc = LY_SUCCESS;
136 } else if (rc && err) {
137 if (ctx) {
138 /* log only in case the ctx was provided as input parameter */
Radek Krejci73dead22019-07-11 16:46:16 +0200139 LOGVAL(ctx, LY_VLOG_STR, err->path, err->vecode, err->msg);
Radek Krejci084289f2019-07-09 17:35:30 +0200140 }
Radek Krejci73dead22019-07-11 16:46:16 +0200141 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200142 }
143
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200144 if (!rc) {
145 type->plugin->free(ctx ? ctx : node->module->ctx, &storage);
146 }
Radek Krejci084289f2019-07-09 17:35:30 +0200147 return rc;
148}
149
150API LY_ERR
Michal Vaskof937cfe2020-08-03 16:07:12 +0200151lys_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const char *value, size_t value_len)
152{
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200153 return _lys_value_validate(ctx, node, value, value_len, LY_PREF_JSON, NULL);
Michal Vaskof937cfe2020-08-03 16:07:12 +0200154}
155
156API LY_ERR
Michal Vasko44685da2020-03-17 15:38:06 +0100157lyd_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 +0200158 const struct lyd_node *tree, const struct lysc_type **realtype)
Radek Krejci084289f2019-07-09 17:35:30 +0200159{
160 LY_ERR rc;
161 struct ly_err_item *err = NULL;
162 struct lysc_type *type;
Michal Vasko3701af52020-08-03 14:29:38 +0200163 struct lyd_value val = {0};
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200164 ly_bool stored = 0;
Radek Krejci084289f2019-07-09 17:35:30 +0200165
166 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
167
Michal Vasko22df3f02020-08-24 13:29:22 +0200168 type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200169 /* store */
170 rc = type->plugin->store(ctx ? ctx : LYD_CTX(node), type, value, value_len, 0, LY_PREF_JSON, NULL,
171 LYD_HINT_DATA, node->schema, &val, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200172 if (rc == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200173 stored = 1;
174
175 /* resolve */
176 rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, (struct lyd_node *)node, tree, &val, &err);
177 }
178
179 if (rc) {
Radek Krejci73dead22019-07-11 16:46:16 +0200180 if (err) {
181 if (ctx) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200182 LOGVAL(ctx, LY_VLOG_LYD, node, err->vecode, err->msg);
Radek Krejci084289f2019-07-09 17:35:30 +0200183 }
Radek Krejci73dead22019-07-11 16:46:16 +0200184 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200185 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200186 if (stored) {
187 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
188 }
Radek Krejci73dead22019-07-11 16:46:16 +0200189 return rc;
Radek Krejci084289f2019-07-09 17:35:30 +0200190 }
191
Michal Vasko3701af52020-08-03 14:29:38 +0200192 if (realtype) {
Michal Vasko29134f82020-11-13 18:03:20 +0100193 if (val.realtype->basetype == LY_TYPE_UNION) {
194 *realtype = val.subvalue->value.realtype;
195 } else {
196 *realtype = val.realtype;
197 }
Michal Vasko3701af52020-08-03 14:29:38 +0200198 }
199
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200200 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200201 return LY_SUCCESS;
202}
203
204API LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200205lyd_value_compare(const struct lyd_node_term *node, const char *value, size_t value_len)
Radek Krejci084289f2019-07-09 17:35:30 +0200206{
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200207 LY_ERR ret = LY_SUCCESS;
Radek Krejci084289f2019-07-09 17:35:30 +0200208 struct ly_ctx *ctx;
209 struct lysc_type *type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200210 struct lyd_value val = {0};
Radek Krejci084289f2019-07-09 17:35:30 +0200211
212 LY_CHECK_ARG_RET(node ? node->schema->module->ctx : NULL, node, value, LY_EINVAL);
213
214 ctx = node->schema->module->ctx;
Michal Vasko22df3f02020-08-24 13:29:22 +0200215 type = ((struct lysc_node_leaf *)node->schema)->type;
Radek Krejci084289f2019-07-09 17:35:30 +0200216
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200217 /* store the value */
218 ret = lyd_value_store(ctx, &val, type, value, value_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, node->schema,
219 NULL, LY_VLOG_LYSC, node->schema);
220 LY_CHECK_RET(ret);
Radek Krejci084289f2019-07-09 17:35:30 +0200221
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200222 /* compare values */
223 ret = type->plugin->compare(&node->value, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200224
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200225 type->plugin->free(ctx, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200226 return ret;
227}
228
Radek Krejci19611252020-10-04 13:54:53 +0200229API ly_bool
230lyd_is_default(const struct lyd_node *node)
231{
232 const struct lysc_node_leaf *leaf;
233 const struct lysc_node_leaflist *llist;
234 const struct lyd_node_term *term;
235 LY_ARRAY_COUNT_TYPE u;
236
237 assert(node->schema->nodetype & LYD_NODE_TERM);
238 term = (const struct lyd_node_term *)node;
239
240 if (node->schema->nodetype == LYS_LEAF) {
241 leaf = (const struct lysc_node_leaf *)node->schema;
242 if (!leaf->dflt) {
243 return 0;
244 }
245
246 /* compare with the default value */
247 if (leaf->type->plugin->compare(&term->value, leaf->dflt)) {
248 return 0;
249 }
250 } else {
251 llist = (const struct lysc_node_leaflist *)node->schema;
252 if (!llist->dflts) {
253 return 0;
254 }
255
256 LY_ARRAY_FOR(llist->dflts, u) {
257 /* compare with each possible default value */
258 if (llist->type->plugin->compare(&term->value, llist->dflts[u])) {
259 return 0;
260 }
261 }
262 }
263
264 return 1;
265}
266
Radek Krejci7931b192020-06-25 17:05:03 +0200267static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +0200268lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +0200269{
Michal Vasko69730152020-10-09 16:30:07 +0200270 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200271 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +0200272 const char *path = in->method.fpath.filepath;
273 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +0200274
275 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +0200276 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +0200277
Michal Vasko69730152020-10-09 16:30:07 +0200278 if ((len >= 5) && !strncmp(&path[len - 4], ".xml", 4)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200279 format = LYD_XML;
Michal Vasko69730152020-10-09 16:30:07 +0200280 } else if ((len >= 6) && !strncmp(&path[len - 5], ".json", 5)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200281 format = LYD_JSON;
Michal Vasko69730152020-10-09 16:30:07 +0200282 } else if ((len >= 5) && !strncmp(&path[len - 4], ".lyb", 4)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200283 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +0200284 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +0200285 }
286
Radek Krejci7931b192020-06-25 17:05:03 +0200287 return format;
288}
Radek Krejcie7b95092019-05-15 11:03:07 +0200289
Radek Krejci7931b192020-06-25 17:05:03 +0200290API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200291lyd_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 +0200292 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200293{
Radek Krejci1798aae2020-07-14 13:26:06 +0200294 LY_ERR ret = LY_SUCCESS;
295 struct lyd_ctx *lydctx = NULL;
296
Radek Krejci7931b192020-06-25 17:05:03 +0200297 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
298 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
299 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
300
301 format = lyd_parse_get_format(in, format);
302 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
303
Radek Krejci1798aae2020-07-14 13:26:06 +0200304 /* init */
305 *tree = NULL;
306
Michal Vasko63f3d842020-07-08 10:10:14 +0200307 /* remember input position */
308 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200309
310 switch (format) {
311 case LYD_XML:
Radek Krejci1798aae2020-07-14 13:26:06 +0200312 LY_CHECK_RET(lyd_parse_xml_data(ctx, in, parse_options, validate_options, tree, &lydctx));
313 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200314 case LYD_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +0200315 LY_CHECK_RET(lyd_parse_json_data(ctx, in, parse_options, validate_options, tree, &lydctx));
316 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200317 case LYD_LYB:
Radek Krejci1798aae2020-07-14 13:26:06 +0200318 LY_CHECK_RET(lyd_parse_lyb_data(ctx, in, parse_options, validate_options, tree, &lydctx));
319 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200320 case LYD_UNKNOWN:
Radek Krejci7931b192020-06-25 17:05:03 +0200321 LOGINT_RET(ctx);
322 }
323
Radek Krejci1798aae2020-07-14 13:26:06 +0200324 if (!(parse_options & LYD_PARSE_ONLY)) {
325 uint32_t i = 0;
326 const struct lys_module *mod;
327 struct lyd_node *first, *next, **first2;
Radek Krejci7931b192020-06-25 17:05:03 +0200328
Radek Krejci1798aae2020-07-14 13:26:06 +0200329 next = *tree;
330 while (1) {
331 if (validate_options & LYD_VALIDATE_PRESENT) {
332 mod = lyd_data_next_module(&next, &first);
333 } else {
334 mod = lyd_mod_next_module(next, NULL, ctx, &i, &first);
335 }
336 if (!mod) {
337 break;
338 }
339 if (first == *tree) {
340 /* make sure first2 changes are carried to tree */
341 first2 = tree;
342 } else {
343 first2 = &first;
344 }
345
346 /* validate new top-level nodes, autodelete CANNOT occur, all nodes are new */
347 LY_CHECK_GOTO(ret = lyd_validate_new(first2, NULL, mod, NULL), cleanup);
348
349 /* add all top-level defaults for this module */
350 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, &lydctx->unres_node_type, &lydctx->when_check,
Michal Vasko69730152020-10-09 16:30:07 +0200351 (validate_options & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200352 LY_CHECK_GOTO(ret, cleanup);
353
354 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200355 ret = lyd_validate_unres(tree, &lydctx->when_check, &lydctx->unres_node_type, &lydctx->unres_meta_type, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200356 LY_CHECK_GOTO(ret, cleanup);
357
358 /* perform final validation that assumes the data tree is final */
359 LY_CHECK_GOTO(ret = lyd_validate_final_r(*first2, NULL, mod, validate_options, 0), cleanup);
360 }
361 }
362
363cleanup:
Michal Vaskoafac7822020-10-20 14:22:26 +0200364 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200365 if (ret) {
366 lyd_free_all(*tree);
367 *tree = NULL;
368 }
369 return ret;
Radek Krejci7931b192020-06-25 17:05:03 +0200370}
371
372API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200373lyd_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 +0200374 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200375{
376 LY_ERR ret;
377 struct ly_in *in;
378
379 LY_CHECK_RET(ly_in_new_memory(data, &in));
380 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
381
382 ly_in_free(in, 0);
383 return ret;
384}
385
386API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200387lyd_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 +0200388 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200389{
390 LY_ERR ret;
391 struct ly_in *in;
392
393 LY_CHECK_RET(ly_in_new_fd(fd, &in));
394 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
395
396 ly_in_free(in, 0);
397 return ret;
398}
399
400API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200401lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
402 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200403{
404 LY_ERR ret;
405 struct ly_in *in;
406
407 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
408 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
409
410 ly_in_free(in, 0);
411 return ret;
412}
413
Radek Krejci7931b192020-06-25 17:05:03 +0200414API LY_ERR
415lyd_parse_rpc(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **op)
416{
417 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
418
419 format = lyd_parse_get_format(in, format);
420 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
421
Radek Krejci1798aae2020-07-14 13:26:06 +0200422 /* init */
423 *tree = NULL;
424 if (op) {
425 *op = NULL;
426 }
427
Michal Vasko63f3d842020-07-08 10:10:14 +0200428 /* remember input position */
429 in->func_start = in->current;
430
Radek Krejci7931b192020-06-25 17:05:03 +0200431 switch (format) {
432 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200433 return lyd_parse_xml_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200434 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200435 return lyd_parse_json_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200436 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200437 return lyd_parse_lyb_rpc(ctx, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200438 case LYD_UNKNOWN:
439 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200440 }
441
442 LOGINT_RET(ctx);
443}
444
445API LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +0200446lyd_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 +0200447 struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200448{
449 LY_CHECK_ARG_RET(NULL, request, LY_EINVAL);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200450 LY_CHECK_ARG_RET(LYD_CTX(request), in, tree || op, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200451
452 format = lyd_parse_get_format(in, format);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200453 LY_CHECK_ARG_RET(LYD_CTX(request), format, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200454
Radek Krejci1798aae2020-07-14 13:26:06 +0200455 /* init */
456 if (tree) {
457 *tree = NULL;
458 }
459 if (op) {
460 *op = NULL;
461 }
462
Michal Vasko63f3d842020-07-08 10:10:14 +0200463 /* remember input position */
464 in->func_start = in->current;
465
Radek Krejci7931b192020-06-25 17:05:03 +0200466 switch (format) {
467 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200468 return lyd_parse_xml_reply(request, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200469 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200470 return lyd_parse_json_reply(request, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200471 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200472 return lyd_parse_lyb_reply(request, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200473 case LYD_UNKNOWN:
474 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200475 }
476
Michal Vaskob7be7a82020-08-20 09:09:04 +0200477 LOGINT_RET(LYD_CTX(request));
Radek Krejci7931b192020-06-25 17:05:03 +0200478}
479
480API LY_ERR
481lyd_parse_notif(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **ntf)
482{
Radek Krejci1798aae2020-07-14 13:26:06 +0200483 LY_CHECK_ARG_RET(ctx, ctx, in, tree || ntf, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200484
485 format = lyd_parse_get_format(in, format);
486 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
487
Radek Krejci1798aae2020-07-14 13:26:06 +0200488 /* init */
489 if (tree) {
490 *tree = NULL;
491 }
492 if (ntf) {
493 *ntf = NULL;
494 }
495
Michal Vasko63f3d842020-07-08 10:10:14 +0200496 /* remember input position */
497 in->func_start = in->current;
498
Radek Krejci7931b192020-06-25 17:05:03 +0200499 switch (format) {
500 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200501 return lyd_parse_xml_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200502 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200503 return lyd_parse_json_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200504 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200505 return lyd_parse_lyb_notif(ctx, in, tree, ntf);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200506 case LYD_UNKNOWN:
507 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200508 }
509
510 LOGINT_RET(ctx);
Radek Krejcie7b95092019-05-15 11:03:07 +0200511}
Radek Krejci084289f2019-07-09 17:35:30 +0200512
Michal Vasko90932a92020-02-12 14:33:03 +0100513LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200514lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
515 LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100516{
517 LY_ERR ret;
518 struct lyd_node_term *term;
519
Michal Vasko9b368d32020-02-14 13:53:31 +0100520 assert(schema->nodetype & LYD_NODE_TERM);
521
Michal Vasko90932a92020-02-12 14:33:03 +0100522 term = calloc(1, sizeof *term);
523 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
524
525 term->schema = schema;
526 term->prev = (struct lyd_node *)term;
Michal Vasko9b368d32020-02-14 13:53:31 +0100527 term->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100528
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200529 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
530 value_len, dynamic, format, prefix_data, hints, schema, incomplete, LY_VLOG_LYSC, schema);
531 LY_CHECK_ERR_RET(ret, free(term), ret);
Michal Vasko9b368d32020-02-14 13:53:31 +0100532 lyd_hash((struct lyd_node *)term);
533
534 *node = (struct lyd_node *)term;
535 return ret;
536}
537
538LY_ERR
539lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
540{
541 LY_ERR ret;
542 struct lyd_node_term *term;
543 struct lysc_type *type;
544
545 assert(schema->nodetype & LYD_NODE_TERM);
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200546 assert(val && val->canonical && val->realtype);
Michal Vasko9b368d32020-02-14 13:53:31 +0100547
548 term = calloc(1, sizeof *term);
549 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
550
551 term->schema = schema;
552 term->prev = (struct lyd_node *)term;
553 term->flags = LYD_NEW;
554
555 type = ((struct lysc_node_leaf *)schema)->type;
556 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
557 if (ret) {
558 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
559 free(term);
560 return ret;
561 }
562 lyd_hash((struct lyd_node *)term);
Michal Vasko90932a92020-02-12 14:33:03 +0100563
564 *node = (struct lyd_node *)term;
565 return ret;
566}
567
568LY_ERR
569lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
570{
571 struct lyd_node_inner *in;
572
Michal Vasko9b368d32020-02-14 13:53:31 +0100573 assert(schema->nodetype & LYD_NODE_INNER);
574
Michal Vasko90932a92020-02-12 14:33:03 +0100575 in = calloc(1, sizeof *in);
576 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
577
578 in->schema = schema;
579 in->prev = (struct lyd_node *)in;
Michal Vasko9b368d32020-02-14 13:53:31 +0100580 in->flags = LYD_NEW;
Michal Vasko3383be72020-11-03 17:15:31 +0100581 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
582 in->flags |= LYD_DEFAULT;
583 }
Michal Vasko90932a92020-02-12 14:33:03 +0100584
Michal Vasko9b368d32020-02-14 13:53:31 +0100585 /* do not hash list with keys, we need them for the hash */
586 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
587 lyd_hash((struct lyd_node *)in);
588 }
Michal Vasko90932a92020-02-12 14:33:03 +0100589
590 *node = (struct lyd_node *)in;
591 return LY_SUCCESS;
592}
593
Michal Vasko90932a92020-02-12 14:33:03 +0100594LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +0200595lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100596{
597 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100598 struct lyd_node *list = NULL, *key;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200599 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100600
Michal Vasko004d3152020-06-11 19:59:22 +0200601 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
Michal Vasko90932a92020-02-12 14:33:03 +0100602
603 /* create list */
604 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
605
Michal Vasko90932a92020-02-12 14:33:03 +0100606 /* create and insert all the keys */
Michal Vasko004d3152020-06-11 19:59:22 +0200607 LY_ARRAY_FOR(predicates, u) {
608 LY_CHECK_GOTO(ret = lyd_create_term2(predicates[u].key, &predicates[u].value, &key), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100609 lyd_insert_node(list, NULL, key);
610 }
611
Michal Vasko9b368d32020-02-14 13:53:31 +0100612 /* hash having all the keys */
613 lyd_hash(list);
614
Michal Vasko90932a92020-02-12 14:33:03 +0100615 /* success */
616 *node = list;
617 list = NULL;
618
619cleanup:
620 lyd_free_tree(list);
Michal Vasko004d3152020-06-11 19:59:22 +0200621 return ret;
622}
623
624static LY_ERR
625lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
626{
627 LY_ERR ret = LY_SUCCESS;
628 struct lyxp_expr *expr = NULL;
629 uint16_t exp_idx = 0;
630 enum ly_path_pred_type pred_type = 0;
631 struct ly_path_predicate *predicates = NULL;
632
633 /* parse keys */
Michal Vasko6b26e742020-07-17 15:02:10 +0200634 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 +0200635 LY_PATH_PRED_KEYS, &expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200636
637 /* compile them */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200638 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_PREF_JSON,
639 NULL, &predicates, &pred_type), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200640
641 /* create the list node */
642 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, node), cleanup);
643
644cleanup:
645 lyxp_expr_free(schema->module->ctx, expr);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200646 ly_path_predicates_free(schema->module->ctx, pred_type, predicates);
Michal Vasko90932a92020-02-12 14:33:03 +0100647 return ret;
648}
649
650LY_ERR
651lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, struct lyd_node **node)
652{
653 struct lyd_node_any *any;
654
Michal Vasko9b368d32020-02-14 13:53:31 +0100655 assert(schema->nodetype & LYD_NODE_ANY);
656
Michal Vasko90932a92020-02-12 14:33:03 +0100657 any = calloc(1, sizeof *any);
658 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
659
660 any->schema = schema;
661 any->prev = (struct lyd_node *)any;
Michal Vasko9b368d32020-02-14 13:53:31 +0100662 any->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100663
Radek Krejci1798aae2020-07-14 13:26:06 +0200664 /* TODO: convert XML/JSON strings into a opaq data tree */
665 any->value.str = value;
Michal Vasko90932a92020-02-12 14:33:03 +0100666 any->value_type = value_type;
Michal Vasko9b368d32020-02-14 13:53:31 +0100667 lyd_hash((struct lyd_node *)any);
Michal Vasko90932a92020-02-12 14:33:03 +0100668
669 *node = (struct lyd_node *)any;
670 return LY_SUCCESS;
671}
672
Michal Vasko52927e22020-03-16 17:26:14 +0100673LY_ERR
Michal Vasko501af032020-11-11 20:27:44 +0100674lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t pref_len,
675 const char *module_key, size_t module_key_len, const char *value, size_t value_len, ly_bool *dynamic,
676 LY_PREFIX_FORMAT format, void *val_prefix_data, uint32_t hints, struct lyd_node **node)
Michal Vasko52927e22020-03-16 17:26:14 +0100677{
Radek Krejci011e4aa2020-09-04 15:22:31 +0200678 LY_ERR ret = LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +0100679 struct lyd_node_opaq *opaq;
680
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200681 assert(ctx && name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +0100682
683 if (!value_len) {
684 value = "";
685 }
686
687 opaq = calloc(1, sizeof *opaq);
Michal Vasko501af032020-11-11 20:27:44 +0100688 LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100689
690 opaq->prev = (struct lyd_node *)opaq;
Michal Vaskoad92b672020-11-12 13:11:31 +0100691 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200692
Michal Vasko52927e22020-03-16 17:26:14 +0100693 if (pref_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100694 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->name.prefix), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100695 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200696 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100697 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->name.module_ns), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +0200698 }
Michal Vasko52927e22020-03-16 17:26:14 +0100699 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200700 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100701 *dynamic = 0;
702 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200703 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100704 }
Michal Vasko501af032020-11-11 20:27:44 +0100705
706 opaq->format = format;
707 opaq->val_prefix_data = val_prefix_data;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200708 opaq->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +0100709 opaq->ctx = ctx;
710
Radek Krejci011e4aa2020-09-04 15:22:31 +0200711finish:
712 if (ret) {
713 lyd_free_tree((struct lyd_node *)opaq);
Michal Vasko501af032020-11-11 20:27:44 +0100714 ly_free_prefix_data(format, val_prefix_data);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200715 } else {
716 *node = (struct lyd_node *)opaq;
717 }
718 return ret;
Michal Vasko52927e22020-03-16 17:26:14 +0100719}
720
Michal Vasko3a41dff2020-07-15 14:30:28 +0200721API LY_ERR
Radek Krejci41ac9942020-11-02 14:47:56 +0100722lyd_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 +0100723{
724 struct lyd_node *ret = NULL;
725 const struct lysc_node *schema;
726 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
727
Michal Vasko6027eb92020-07-15 16:37:30 +0200728 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100729
Michal Vaskof03ed032020-03-04 13:31:44 +0100730 if (!module) {
731 module = parent->schema->module;
732 }
733
Michal Vasko3a41dff2020-07-15 14:30:28 +0200734 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
Radek Krejci41ac9942020-11-02 14:47:56 +0100735 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200736 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 +0100737
Michal Vasko3a41dff2020-07-15 14:30:28 +0200738 LY_CHECK_RET(lyd_create_inner(schema, &ret));
739 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100740 lyd_insert_node(parent, NULL, ret);
741 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200742
743 if (node) {
744 *node = ret;
745 }
746 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100747}
748
Michal Vasko3a41dff2020-07-15 14:30:28 +0200749API LY_ERR
Radek Krejci41ac9942020-11-02 14:47:56 +0100750lyd_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 +0100751{
752 struct lyd_node *ret = NULL, *key;
753 const struct lysc_node *schema, *key_s;
754 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
755 va_list ap;
756 const char *key_val;
757 LY_ERR rc = LY_SUCCESS;
758
Michal Vasko6027eb92020-07-15 16:37:30 +0200759 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100760
Michal Vaskof03ed032020-03-04 13:31:44 +0100761 if (!module) {
762 module = parent->schema->module;
763 }
764
Radek Krejci41ac9942020-11-02 14:47:56 +0100765 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 +0200766 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100767
768 /* create list inner node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200769 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko013a8182020-03-03 10:46:53 +0100770
Michal Vasko3a41dff2020-07-15 14:30:28 +0200771 va_start(ap, node);
Michal Vasko013a8182020-03-03 10:46:53 +0100772
773 /* create and insert all the keys */
774 for (key_s = lysc_node_children(schema, 0); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
775 key_val = va_arg(ap, const char *);
776
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200777 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
778 NULL, &key);
779 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko013a8182020-03-03 10:46:53 +0100780 lyd_insert_node(ret, NULL, key);
781 }
782
Michal Vasko013a8182020-03-03 10:46:53 +0100783 if (parent) {
784 lyd_insert_node(parent, NULL, ret);
785 }
786
787cleanup:
Michal Vasko3a41dff2020-07-15 14:30:28 +0200788 va_end(ap);
Michal Vasko013a8182020-03-03 10:46:53 +0100789 if (rc) {
790 lyd_free_tree(ret);
791 ret = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200792 } else if (node) {
793 *node = ret;
Michal Vasko013a8182020-03-03 10:46:53 +0100794 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200795 return rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100796}
797
Michal Vasko3a41dff2020-07-15 14:30:28 +0200798API LY_ERR
799lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
Radek Krejci41ac9942020-11-02 14:47:56 +0100800 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100801{
802 struct lyd_node *ret = NULL;
803 const struct lysc_node *schema;
804 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
805
Michal Vasko6027eb92020-07-15 16:37:30 +0200806 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100807
Michal Vaskof03ed032020-03-04 13:31:44 +0100808 if (!module) {
809 module = parent->schema->module;
810 }
Michal Vasko004d3152020-06-11 19:59:22 +0200811 if (!keys) {
812 keys = "";
813 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100814
Michal Vasko004d3152020-06-11 19:59:22 +0200815 /* find schema node */
Radek Krejci41ac9942020-11-02 14:47:56 +0100816 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 +0200817 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100818
Michal Vasko004d3152020-06-11 19:59:22 +0200819 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
820 /* key-less list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200821 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200822 } else {
823 /* create the list node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200824 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200825 }
Michal Vasko004d3152020-06-11 19:59:22 +0200826 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100827 lyd_insert_node(parent, NULL, ret);
828 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200829
830 if (node) {
831 *node = ret;
832 }
833 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100834}
835
Michal Vasko3a41dff2020-07-15 14:30:28 +0200836API LY_ERR
837lyd_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 +0100838 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100839{
Michal Vaskocbff3e92020-05-27 12:56:41 +0200840 LY_ERR rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100841 struct lyd_node *ret = NULL;
842 const struct lysc_node *schema;
843 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
844
Michal Vasko6027eb92020-07-15 16:37:30 +0200845 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100846
Michal Vaskof03ed032020-03-04 13:31:44 +0100847 if (!module) {
848 module = parent->schema->module;
849 }
850
Radek Krejci41ac9942020-11-02 14:47:56 +0100851 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 +0200852 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100853
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200854 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL,
855 &ret);
856 LY_CHECK_RET(rc);
Michal Vaskocbff3e92020-05-27 12:56:41 +0200857 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100858 lyd_insert_node(parent, NULL, ret);
859 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200860
861 if (node) {
862 *node = ret;
863 }
864 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100865}
866
Michal Vasko3a41dff2020-07-15 14:30:28 +0200867API LY_ERR
Michal Vasko013a8182020-03-03 10:46:53 +0100868lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
Radek Krejci41ac9942020-11-02 14:47:56 +0100869 LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100870{
871 struct lyd_node *ret = NULL;
872 const struct lysc_node *schema;
873 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
874
Michal Vasko6027eb92020-07-15 16:37:30 +0200875 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100876
Michal Vaskof03ed032020-03-04 13:31:44 +0100877 if (!module) {
878 module = parent->schema->module;
879 }
880
Radek Krejci41ac9942020-11-02 14:47:56 +0100881 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 +0200882 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100883
Michal Vasko3a41dff2020-07-15 14:30:28 +0200884 LY_CHECK_RET(lyd_create_any(schema, value, value_type, &ret));
885 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100886 lyd_insert_node(parent, NULL, ret);
887 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200888
889 if (node) {
890 *node = ret;
891 }
892 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100893}
894
Michal Vasko4490d312020-06-16 13:08:55 +0200895/**
896 * @brief Update node value.
897 *
898 * @param[in] node Node to update.
899 * @param[in] value New value to set.
900 * @param[in] value_type Type of @p value for any node.
901 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
902 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
903 * @return LY_ERR value.
904 */
Michal Vasko00cbf532020-06-15 13:58:47 +0200905static LY_ERR
906lyd_new_path_update(struct lyd_node *node, const void *value, LYD_ANYDATA_VALUETYPE value_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200907 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +0200908{
909 LY_ERR ret = LY_SUCCESS;
910 struct lyd_node *new_any;
911
912 switch (node->schema->nodetype) {
913 case LYS_CONTAINER:
914 case LYS_NOTIF:
915 case LYS_RPC:
916 case LYS_ACTION:
917 case LYS_LIST:
918 case LYS_LEAFLIST:
919 /* if it exists, there is nothing to update */
920 *new_parent = NULL;
921 *new_node = NULL;
922 break;
923 case LYS_LEAF:
924 ret = lyd_change_term(node, value);
925 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
926 /* there was an actual change (at least of the default flag) */
927 *new_parent = node;
928 *new_node = node;
929 ret = LY_SUCCESS;
930 } else if (ret == LY_ENOT) {
931 /* no change */
932 *new_parent = NULL;
933 *new_node = NULL;
934 ret = LY_SUCCESS;
935 } /* else error */
936 break;
937 case LYS_ANYDATA:
938 case LYS_ANYXML:
939 /* create a new any node */
940 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, &new_any));
941
942 /* compare with the existing one */
Michal Vasko8f359bf2020-07-28 10:41:15 +0200943 if (lyd_compare_single(node, new_any, 0)) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200944 /* not equal, switch values (so that we can use generic node free) */
945 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
946 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
947 ((struct lyd_node_any *)node)->value.str = value;
948 ((struct lyd_node_any *)node)->value_type = value_type;
949
950 *new_parent = node;
951 *new_node = node;
952 } else {
953 /* they are equal */
954 *new_parent = NULL;
955 *new_node = NULL;
956 }
957 lyd_free_tree(new_any);
958 break;
959 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200960 LOGINT(LYD_CTX(node));
Michal Vasko00cbf532020-06-15 13:58:47 +0200961 ret = LY_EINT;
962 break;
963 }
964
965 return ret;
966}
967
Michal Vasko3a41dff2020-07-15 14:30:28 +0200968API LY_ERR
Michal Vasko871a0252020-11-11 18:35:24 +0100969lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module, const char *name,
970 const char *val_str, ly_bool clear_dflt, struct lyd_meta **meta)
Michal Vaskod86997b2020-05-26 15:19:54 +0200971{
Michal Vaskod86997b2020-05-26 15:19:54 +0200972 const char *prefix, *tmp;
Michal Vaskod86997b2020-05-26 15:19:54 +0200973 size_t pref_len, name_len;
974
Michal Vasko871a0252020-11-11 18:35:24 +0100975 LY_CHECK_ARG_RET(NULL, ctx, name, module || strchr(name, ':'), parent || meta, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +0200976
Michal Vasko871a0252020-11-11 18:35:24 +0100977 if (parent && !parent->schema) {
978 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
979 return LY_EINVAL;
980 }
Michal Vasko610553d2020-11-18 18:15:05 +0100981 if (meta) {
982 *meta = NULL;
983 }
Michal Vaskod86997b2020-05-26 15:19:54 +0200984
985 /* parse the name */
986 tmp = name;
987 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
988 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko871a0252020-11-11 18:35:24 +0100989 return LY_EINVAL;
Michal Vaskod86997b2020-05-26 15:19:54 +0200990 }
991
992 /* find the module */
993 if (prefix) {
Radek Krejci0ad51f12020-07-16 12:08:12 +0200994 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200995 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 +0200996 }
997
998 /* set value if none */
999 if (!val_str) {
1000 val_str = "";
1001 }
1002
Michal Vasko871a0252020-11-11 18:35:24 +01001003 return lyd_create_meta(parent, meta, module, name, name_len, val_str, strlen(val_str), NULL, LY_PREF_JSON,
1004 NULL, LYD_HINT_DATA, clear_dflt, NULL);
1005}
Michal Vasko3a41dff2020-07-15 14:30:28 +02001006
Michal Vaskoba696702020-11-11 19:12:45 +01001007API LY_ERR
1008lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, ly_bool clear_dflt, const struct lyd_attr *attr,
1009 struct lyd_meta **meta)
1010{
1011 const struct lys_module *mod;
1012
1013 LY_CHECK_ARG_RET(NULL, ctx, attr, parent || meta, LY_EINVAL);
1014
1015 if (parent && !parent->schema) {
1016 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1017 return LY_EINVAL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001018 }
Michal Vasko610553d2020-11-18 18:15:05 +01001019 if (meta) {
1020 *meta = NULL;
1021 }
Michal Vaskoba696702020-11-11 19:12:45 +01001022
1023 switch (attr->format) {
1024 case LY_PREF_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +01001025 mod = ly_ctx_get_module_implemented_ns(ctx, attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001026 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001027 LOGERR(ctx, LY_EINVAL, "Module with namespace \"%s\" not found.", attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001028 return LY_ENOTFOUND;
1029 }
1030 break;
1031 case LY_PREF_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +01001032 mod = ly_ctx_get_module_implemented(ctx, attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001033 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001034 LOGERR(ctx, LY_EINVAL, "Module \"%s\" not found.", attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001035 return LY_ENOTFOUND;
1036 }
1037 break;
1038 default:
1039 LOGINT_RET(ctx);
1040 }
1041
Michal Vaskoad92b672020-11-12 13:11:31 +01001042 return lyd_create_meta(parent, meta, mod, attr->name.name, strlen(attr->name.name), attr->value, strlen(attr->value),
Michal Vaskoba696702020-11-11 19:12:45 +01001043 NULL, attr->format, attr->val_prefix_data, attr->hints, clear_dflt, NULL);
Michal Vaskod86997b2020-05-26 15:19:54 +02001044}
1045
Michal Vasko3a41dff2020-07-15 14:30:28 +02001046API LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +02001047lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Radek Krejci0f969882020-08-21 16:56:47 +02001048 const char *module_name, struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001049{
1050 struct lyd_node *ret = NULL;
1051
Michal Vasko6027eb92020-07-15 16:37:30 +02001052 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001053
1054 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001055 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001056 }
1057 if (!value) {
1058 value = "";
1059 }
1060
Michal Vasko501af032020-11-11 20:27:44 +01001061 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), NULL, 0, module_name, strlen(module_name), value,
1062 strlen(value), NULL, LY_PREF_JSON, NULL, 0, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001063 if (parent) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001064 lyd_insert_node(parent, NULL, ret);
1065 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001066
1067 if (node) {
1068 *node = ret;
1069 }
1070 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001071}
1072
Michal Vasko3a41dff2020-07-15 14:30:28 +02001073API LY_ERR
1074lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *val_str,
Radek Krejci0f969882020-08-21 16:56:47 +02001075 struct lyd_attr **attr)
Michal Vasko00cbf532020-06-15 13:58:47 +02001076{
Radek Krejci1798aae2020-07-14 13:26:06 +02001077 struct lyd_attr *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02001078 const struct ly_ctx *ctx;
1079 const char *prefix, *tmp;
Michal Vasko51d21b82020-11-13 18:03:54 +01001080 size_t pref_len, name_len, mod_len;
Michal Vasko00cbf532020-06-15 13:58:47 +02001081
Michal Vasko3a41dff2020-07-15 14:30:28 +02001082 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001083
Michal Vaskob7be7a82020-08-20 09:09:04 +02001084 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001085
1086 /* parse the name */
1087 tmp = name;
1088 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1089 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001090 return LY_EVALID;
Michal Vasko00cbf532020-06-15 13:58:47 +02001091 }
1092
Michal Vasko51d21b82020-11-13 18:03:54 +01001093 /* get the module */
1094 if (module_name) {
1095 mod_len = strlen(module_name);
1096 } else {
1097 module_name = prefix;
1098 mod_len = pref_len;
1099 }
1100
Michal Vasko00cbf532020-06-15 13:58:47 +02001101 /* set value if none */
1102 if (!val_str) {
1103 val_str = "";
1104 }
1105
Michal Vasko51d21b82020-11-13 18:03:54 +01001106 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_name, mod_len, val_str,
1107 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001108
1109 if (attr) {
1110 *attr = ret;
1111 }
1112 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001113}
1114
1115API LY_ERR
1116lyd_change_term(struct lyd_node *term, const char *val_str)
1117{
1118 LY_ERR ret = LY_SUCCESS;
1119 struct lysc_type *type;
1120 struct lyd_node_term *t;
1121 struct lyd_node *parent;
1122 struct lyd_value val = {0};
Radek Krejci857189e2020-09-01 13:26:36 +02001123 ly_bool dflt_change, val_change;
Michal Vasko00cbf532020-06-15 13:58:47 +02001124
1125 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1126
1127 if (!val_str) {
1128 val_str = "";
1129 }
1130 t = (struct lyd_node_term *)term;
1131 type = ((struct lysc_node_leaf *)term->schema)->type;
1132
1133 /* parse the new value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001134 ret = lyd_value_store(LYD_CTX(term), &val, type, val_str, strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
1135 term->schema, NULL, LY_VLOG_LYD, term);
1136 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001137
1138 /* compare original and new value */
1139 if (type->plugin->compare(&t->value, &val)) {
1140 /* values differ, switch them */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001141 type->plugin->free(LYD_CTX(term), &t->value);
Michal Vasko00cbf532020-06-15 13:58:47 +02001142 t->value = val;
1143 memset(&val, 0, sizeof val);
1144 val_change = 1;
1145 } else {
1146 val_change = 0;
1147 }
1148
1149 /* always clear the default flag */
1150 if (term->flags & LYD_DEFAULT) {
1151 for (parent = term; parent; parent = (struct lyd_node *)parent->parent) {
1152 parent->flags &= ~LYD_DEFAULT;
1153 }
1154 dflt_change = 1;
1155 } else {
1156 dflt_change = 0;
1157 }
1158
1159 if (val_change || dflt_change) {
1160 /* make the node non-validated */
1161 term->flags &= LYD_NEW;
1162 }
1163
1164 if (val_change) {
1165 if (term->schema->nodetype == LYS_LEAFLIST) {
1166 /* leaf-list needs to be hashed again and re-inserted into parent */
1167 lyd_unlink_hash(term);
1168 lyd_hash(term);
1169 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1170 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1171 /* list needs to be updated if its key was changed */
1172 assert(term->parent->schema->nodetype == LYS_LIST);
1173 lyd_unlink_hash((struct lyd_node *)term->parent);
1174 lyd_hash((struct lyd_node *)term->parent);
1175 LY_CHECK_GOTO(ret = lyd_insert_hash((struct lyd_node *)term->parent), cleanup);
1176 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1177 }
1178
1179 /* retrun value */
1180 if (!val_change) {
1181 if (dflt_change) {
1182 /* only default flag change */
1183 ret = LY_EEXIST;
1184 } else {
1185 /* no change */
1186 ret = LY_ENOT;
1187 }
1188 } /* else value changed, LY_SUCCESS */
1189
1190cleanup:
Michal Vaskob7be7a82020-08-20 09:09:04 +02001191 type->plugin->free(LYD_CTX(term), &val);
Michal Vasko00cbf532020-06-15 13:58:47 +02001192 return ret;
1193}
1194
Michal Vasko41586352020-07-13 13:54:25 +02001195API LY_ERR
1196lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1197{
1198 LY_ERR ret = LY_SUCCESS;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001199 struct lyd_meta *m2 = NULL;
Michal Vasko41586352020-07-13 13:54:25 +02001200 struct lyd_value val;
Radek Krejci857189e2020-09-01 13:26:36 +02001201 ly_bool val_change;
Michal Vasko41586352020-07-13 13:54:25 +02001202
1203 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1204
1205 if (!val_str) {
1206 val_str = "";
1207 }
1208
1209 /* parse the new value into a new meta structure */
1210 LY_CHECK_GOTO(ret = lyd_create_meta(NULL, &m2, meta->annotation->module, meta->name, strlen(meta->name), val_str,
Michal Vasko871a0252020-11-11 18:35:24 +01001211 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, 0, NULL), cleanup);
Michal Vasko41586352020-07-13 13:54:25 +02001212
1213 /* compare original and new value */
1214 if (lyd_compare_meta(meta, m2)) {
1215 /* values differ, switch them */
1216 val = meta->value;
1217 meta->value = m2->value;
1218 m2->value = val;
1219 val_change = 1;
1220 } else {
1221 val_change = 0;
1222 }
1223
1224 /* retrun value */
1225 if (!val_change) {
1226 /* no change */
1227 ret = LY_ENOT;
1228 } /* else value changed, LY_SUCCESS */
1229
1230cleanup:
Michal Vasko1a66a5d2020-11-18 18:15:37 +01001231 lyd_free_meta_single(m2);
Michal Vasko41586352020-07-13 13:54:25 +02001232 return ret;
1233}
1234
Michal Vasko3a41dff2020-07-15 14:30:28 +02001235API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001236lyd_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 +02001237 struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001238{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001239 return lyd_new_path2(parent, ctx, path, value, 0, options, node, NULL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001240}
1241
1242API LY_ERR
1243lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001244 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 +02001245{
1246 LY_ERR ret = LY_SUCCESS, r;
1247 struct lyxp_expr *exp = NULL;
1248 struct ly_path *p = NULL;
1249 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1250 const struct lysc_node *schema;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001251 LY_ARRAY_COUNT_TYPE path_idx = 0;
Michal Vasko00cbf532020-06-15 13:58:47 +02001252 struct ly_path_predicate *pred;
1253
1254 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1255
1256 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001257 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001258 }
1259
1260 /* parse path */
Michal Vasko6b26e742020-07-17 15:02:10 +02001261 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 +02001262 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001263
1264 /* compile path */
1265 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 +02001266 options & LYD_NEW_PATH_OUTPUT ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, LY_PREF_JSON,
1267 NULL, &p), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001268
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001269 schema = p[LY_ARRAY_COUNT(p) - 1].node;
Michal Vasko69730152020-10-09 16:30:07 +02001270 if ((schema->nodetype == LYS_LIST) && (p[LY_ARRAY_COUNT(p) - 1].pred_type == LY_PATH_PREDTYPE_NONE) &&
Radek Krejci092e33c2020-10-12 15:33:10 +02001271 !(options & LYD_NEW_PATH_OPAQ)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001272 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +02001273 lys_nodetype2str(schema->nodetype), schema->name);
Michal Vasko00cbf532020-06-15 13:58:47 +02001274 ret = LY_EINVAL;
1275 goto cleanup;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001276 } 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 +02001277 /* parse leafref value into a predicate, if not defined in the path */
Michal Vasko00cbf532020-06-15 13:58:47 +02001278 if (!value) {
1279 value = "";
1280 }
1281
1282 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001283 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001284 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001285 }
1286 if (!r) {
Michal Vasko3af81bc2020-11-18 18:16:13 +01001287 /* store the new predicate */
1288 p[LY_ARRAY_COUNT(p) - 1].pred_type = LY_PATH_PREDTYPE_LEAFLIST;
1289 LY_ARRAY_NEW_GOTO(ctx, p[LY_ARRAY_COUNT(p) - 1].predicates, pred, ret, cleanup);
1290
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001291 ret = lyd_value_store(ctx, &pred->value, ((struct lysc_node_leaflist *)schema)->type, value, strlen(value),
1292 NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, schema, NULL, LY_VLOG_LYSC, schema);
1293 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoae875662020-10-21 10:33:17 +02001294 ++((struct lysc_type *)pred->value.realtype)->refcount;
Michal Vasko00cbf532020-06-15 13:58:47 +02001295 } /* else we have opaq flag and the value is not valid, leavne no predicate and then create an opaque node */
1296 }
1297
1298 /* try to find any existing nodes in the path */
1299 if (parent) {
1300 ret = ly_path_eval_partial(p, parent, &path_idx, &node);
1301 if (ret == LY_SUCCESS) {
1302 /* the node exists, are we supposed to update it or is it just a default? */
Radek Krejci092e33c2020-10-12 15:33:10 +02001303 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001304 LOGERR(ctx, LY_EEXIST, "Path \"%s\" already exists", path);
1305 ret = LY_EEXIST;
1306 goto cleanup;
1307 }
1308
1309 /* update the existing node */
1310 ret = lyd_new_path_update(node, value, value_type, &nparent, &nnode);
1311 goto cleanup;
1312 } else if (ret == LY_EINCOMPLETE) {
1313 /* some nodes were found, adjust the iterator to the next segment */
1314 ++path_idx;
1315 } else if (ret == LY_ENOTFOUND) {
1316 /* we will create the nodes from top-level, default behavior (absolute path), or from the parent (relative path) */
Michal Vasko45b0d202020-11-06 17:20:46 +01001317 if (lysc_data_parent(p[0].node)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001318 node = parent;
1319 }
1320 } else {
1321 /* error */
1322 goto cleanup;
1323 }
1324 }
1325
1326 /* create all the non-existing nodes in a loop */
Michal Vaskod989ba02020-08-24 10:59:24 +02001327 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001328 cur_parent = node;
1329 schema = p[path_idx].node;
1330
1331 switch (schema->nodetype) {
1332 case LYS_LIST:
1333 if (!(schema->flags & LYS_KEYLESS)) {
Radek Krejci092e33c2020-10-12 15:33:10 +02001334 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001335 /* creating opaque list without keys */
Michal Vasko501af032020-11-11 20:27:44 +01001336 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1337 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1338 LYD_NODEHINT_LIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001339 } else {
1340 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LIST);
1341 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, &node), cleanup);
1342 }
1343 break;
1344 }
Radek Krejci0f969882020-08-21 16:56:47 +02001345 /* fallthrough */
Michal Vasko00cbf532020-06-15 13:58:47 +02001346 case LYS_CONTAINER:
1347 case LYS_NOTIF:
1348 case LYS_RPC:
1349 case LYS_ACTION:
1350 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1351 break;
1352 case LYS_LEAFLIST:
Radek Krejci092e33c2020-10-12 15:33:10 +02001353 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001354 /* creating opaque leaf-list without value */
Michal Vasko501af032020-11-11 20:27:44 +01001355 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1356 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1357 LYD_NODEHINT_LEAFLIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001358 } else {
1359 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LEAFLIST);
1360 LY_CHECK_GOTO(ret = lyd_create_term2(schema, &p[path_idx].predicates[0].value, &node), cleanup);
1361 }
1362 break;
1363 case LYS_LEAF:
1364 /* make there is some value */
1365 if (!value) {
1366 value = "";
1367 }
1368
1369 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001370 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001371 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001372 }
1373 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001374 ret = lyd_create_term(schema, value, strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &node);
1375 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001376 } else {
1377 /* creating opaque leaf without value */
Michal Vasko501af032020-11-11 20:27:44 +01001378 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, schema->module->name,
1379 strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001380 }
1381 break;
1382 case LYS_ANYDATA:
1383 case LYS_ANYXML:
1384 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, &node), cleanup);
1385 break;
1386 default:
1387 LOGINT(ctx);
1388 ret = LY_EINT;
1389 goto cleanup;
1390 }
1391
1392 if (cur_parent) {
1393 /* connect to the parent */
1394 lyd_insert_node(cur_parent, NULL, node);
1395 } else if (parent) {
1396 /* connect to top-level siblings */
1397 lyd_insert_node(NULL, &parent, node);
1398 }
1399
1400 /* update remembered nodes */
1401 if (!nparent) {
1402 nparent = node;
1403 }
1404 nnode = node;
1405 }
1406
1407cleanup:
1408 lyxp_expr_free(ctx, exp);
1409 ly_path_free(ctx, p);
1410 if (!ret) {
1411 /* set out params only on success */
1412 if (new_parent) {
1413 *new_parent = nparent;
1414 }
1415 if (new_node) {
1416 *new_node = nnode;
1417 }
1418 }
1419 return ret;
1420}
1421
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001422LY_ERR
1423lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001424 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 +02001425 struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001426{
1427 LY_ERR ret;
1428 const struct lysc_node *iter = NULL;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001429 struct lyd_node *node = NULL;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001430 struct lyd_value **dflts;
1431 LY_ARRAY_COUNT_TYPE u;
1432
1433 assert(first && (parent || sparent || mod));
1434
1435 if (!sparent && parent) {
1436 sparent = parent->schema;
1437 }
1438
1439 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
1440 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1441 continue;
Michal Vasko44b19a12020-08-07 09:21:30 +02001442 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1443 continue;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001444 }
1445
1446 switch (iter->nodetype) {
1447 case LYS_CHOICE:
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001448 node = lys_getnext_data(NULL, *first, NULL, iter, NULL);
1449 if (!node && ((struct lysc_node_choice *)iter)->dflt) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001450 /* create default case data */
1451 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 +02001452 NULL, node_types, node_when, impl_opts, diff));
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001453 } else if (node) {
1454 /* create any default data in the existing case */
1455 assert(node->schema->parent->nodetype == LYS_CASE);
1456 LY_CHECK_RET(lyd_new_implicit_r(parent, first, node->schema->parent, NULL, node_types, node_when,
1457 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001458 }
1459 break;
1460 case LYS_CONTAINER:
1461 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1462 /* create default NP container */
1463 LY_CHECK_RET(lyd_create_inner(iter, &node));
Michal Vasko0cadfcb2020-11-04 17:17:05 +01001464 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001465 lyd_insert_node(parent, first, node);
1466
1467 /* cannot be a NP container with when */
1468 assert(!iter->when);
1469
Michal Vaskoe49b6322020-11-05 17:38:36 +01001470 if (diff) {
1471 /* add into diff */
1472 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1473 }
1474
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001475 /* create any default children */
1476 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 +02001477 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001478 }
1479 break;
1480 case LYS_LEAF:
Michal Vasko69730152020-10-09 16:30:07 +02001481 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1482 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001483 /* create default leaf */
1484 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1485 if (ret == LY_EINCOMPLETE) {
1486 if (node_types) {
1487 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001488 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001489 }
1490 } else if (ret) {
1491 return ret;
1492 }
Michal Vasko0cadfcb2020-11-04 17:17:05 +01001493 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001494 lyd_insert_node(parent, first, node);
1495
1496 if (iter->when && node_when) {
1497 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001498 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001499 }
1500 if (diff) {
1501 /* add into diff */
1502 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1503 }
1504 }
1505 break;
1506 case LYS_LEAFLIST:
Michal Vasko69730152020-10-09 16:30:07 +02001507 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1508 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001509 /* create all default leaf-lists */
1510 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1511 LY_ARRAY_FOR(dflts, u) {
1512 ret = lyd_create_term2(iter, dflts[u], &node);
1513 if (ret == LY_EINCOMPLETE) {
1514 if (node_types) {
1515 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001516 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001517 }
1518 } else if (ret) {
1519 return ret;
1520 }
Radek Krejcic5b54a02020-11-05 17:13:18 +01001521 node->flags = LYD_DEFAULT | (node->schema->when ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001522 lyd_insert_node(parent, first, node);
1523
1524 if (iter->when && node_when) {
1525 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001526 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001527 }
1528 if (diff) {
1529 /* add into diff */
1530 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1531 }
1532 }
1533 }
1534 break;
1535 default:
1536 /* without defaults */
1537 break;
1538 }
1539 }
1540
1541 return LY_SUCCESS;
1542}
1543
1544API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001545lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001546{
Michal Vasko56daf732020-08-10 10:57:18 +02001547 struct lyd_node *node;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001548 LY_ERR ret = LY_SUCCESS;
1549
1550 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1551 if (diff) {
1552 *diff = NULL;
1553 }
1554
Michal Vasko56daf732020-08-10 10:57:18 +02001555 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001556 /* skip added default nodes */
Michal Vasko69730152020-10-09 16:30:07 +02001557 if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
1558 (node->schema->nodetype & LYD_NODE_INNER)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001559 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 +02001560 NULL, implicit_options, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001561 }
1562
Michal Vasko56daf732020-08-10 10:57:18 +02001563 LYD_TREE_DFS_END(tree, node);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001564 }
1565
1566cleanup:
1567 if (ret && diff) {
1568 lyd_free_all(*diff);
1569 *diff = NULL;
1570 }
1571 return ret;
1572}
1573
1574API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001575lyd_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 +02001576{
1577 const struct lys_module *mod;
1578 struct lyd_node *d = NULL;
1579 uint32_t i = 0;
1580 LY_ERR ret = LY_SUCCESS;
1581
1582 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
1583 if (diff) {
1584 *diff = NULL;
1585 }
1586 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001587 ctx = LYD_CTX(*tree);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001588 }
1589
1590 /* add nodes for each module one-by-one */
1591 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
1592 if (!mod->implemented) {
1593 continue;
1594 }
1595
1596 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
1597 if (d) {
1598 /* merge into one diff */
1599 lyd_insert_sibling(*diff, d, diff);
1600
1601 d = NULL;
1602 }
1603 }
1604
1605cleanup:
1606 if (ret && diff) {
1607 lyd_free_all(*diff);
1608 *diff = NULL;
1609 }
1610 return ret;
1611}
1612
1613API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001614lyd_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 +02001615{
1616 struct lyd_node *root, *d = NULL;
1617 LY_ERR ret = LY_SUCCESS;
1618
1619 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
1620 if (diff) {
1621 *diff = NULL;
1622 }
1623
1624 /* add all top-level defaults for this module */
1625 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, NULL, NULL, implicit_options, diff), cleanup);
1626
1627 /* process nested nodes */
1628 LY_LIST_FOR(*tree, root) {
1629 /* skip added default nodes */
1630 if ((root->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
1631 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
1632
1633 if (d) {
1634 /* merge into one diff */
1635 lyd_insert_sibling(*diff, d, diff);
1636
1637 d = NULL;
1638 }
1639 }
1640 }
1641
1642cleanup:
1643 if (ret && diff) {
1644 lyd_free_all(*diff);
1645 *diff = NULL;
1646 }
1647 return ret;
1648}
1649
Michal Vasko90932a92020-02-12 14:33:03 +01001650struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +02001651lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +01001652{
Michal Vaskob104f112020-07-17 09:54:54 +02001653 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +01001654 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02001655 ly_bool found;
Michal Vasko90932a92020-02-12 14:33:03 +01001656
Michal Vaskob104f112020-07-17 09:54:54 +02001657 assert(new_node);
1658
1659 if (!first_sibling || !new_node->schema) {
1660 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +01001661 return NULL;
1662 }
1663
Michal Vaskob104f112020-07-17 09:54:54 +02001664 if (first_sibling->parent && first_sibling->parent->children_ht) {
1665 /* find the anchor using hashes */
1666 sparent = first_sibling->parent->schema;
1667 schema = lys_getnext(new_node->schema, sparent, NULL, 0);
1668 while (schema) {
1669 /* keep trying to find the first existing instance of the closest following schema sibling,
1670 * otherwise return NULL - inserting at the end */
1671 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
1672 break;
1673 }
1674
1675 schema = lys_getnext(schema, sparent, NULL, 0);
1676 }
1677 } else {
1678 /* find the anchor without hashes */
1679 match = (struct lyd_node *)first_sibling;
1680 if (!lysc_data_parent(new_node->schema)) {
1681 /* we are in top-level, skip all the data from preceding modules */
1682 LY_LIST_FOR(match, match) {
1683 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
1684 break;
1685 }
1686 }
1687 }
1688
1689 /* get the first schema sibling */
1690 sparent = lysc_data_parent(new_node->schema);
1691 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, 0);
1692
1693 found = 0;
1694 LY_LIST_FOR(match, match) {
1695 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
1696 /* we have found an opaque node, which must be at the end, so use it OR
1697 * modules do not match, so we must have traversed all the data from new_node module (if any),
1698 * we have found the first node of the next module, that is what we want */
1699 break;
1700 }
1701
1702 /* skip schema nodes until we find the instantiated one */
1703 while (!found) {
1704 if (new_node->schema == schema) {
1705 /* we have found the schema of the new node, continue search to find the first
1706 * data node with a different schema (after our schema) */
1707 found = 1;
1708 break;
1709 }
1710 if (match->schema == schema) {
1711 /* current node (match) is a data node still before the new node, continue search in data */
1712 break;
1713 }
1714 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, 0);
1715 assert(schema);
1716 }
1717
1718 if (found && (match->schema != new_node->schema)) {
1719 /* find the next node after we have found our node schema data instance */
1720 break;
1721 }
1722 }
Michal Vasko90932a92020-02-12 14:33:03 +01001723 }
1724
1725 return match;
1726}
1727
1728/**
1729 * @brief Insert node after a sibling.
1730 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001731 * Handles inserting into NP containers and key-less lists.
1732 *
Michal Vasko90932a92020-02-12 14:33:03 +01001733 * @param[in] sibling Sibling to insert after.
1734 * @param[in] node Node to insert.
1735 */
1736static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001737lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001738{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001739 struct lyd_node_inner *par;
1740
Michal Vasko90932a92020-02-12 14:33:03 +01001741 assert(!node->next && (node->prev == node));
1742
1743 node->next = sibling->next;
1744 node->prev = sibling;
1745 sibling->next = node;
1746 if (node->next) {
1747 /* sibling had a succeeding node */
1748 node->next->prev = node;
1749 } else {
1750 /* sibling was last, find first sibling and change its prev */
1751 if (sibling->parent) {
1752 sibling = sibling->parent->child;
1753 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +02001754 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +01001755 }
1756 sibling->prev = node;
1757 }
1758 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001759
Michal Vasko9f96a052020-03-10 09:41:45 +01001760 for (par = node->parent; par; par = par->parent) {
1761 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1762 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001763 par->flags &= ~LYD_DEFAULT;
1764 }
Michal Vaskob104f112020-07-17 09:54:54 +02001765 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001766 /* rehash key-less list */
1767 lyd_hash((struct lyd_node *)par);
1768 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001769 }
Michal Vasko90932a92020-02-12 14:33:03 +01001770}
1771
1772/**
1773 * @brief Insert node before a sibling.
1774 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001775 * Handles inserting into NP containers and key-less lists.
1776 *
Michal Vasko90932a92020-02-12 14:33:03 +01001777 * @param[in] sibling Sibling to insert before.
1778 * @param[in] node Node to insert.
1779 */
1780static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001781lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001782{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001783 struct lyd_node_inner *par;
1784
Michal Vasko90932a92020-02-12 14:33:03 +01001785 assert(!node->next && (node->prev == node));
1786
1787 node->next = sibling;
1788 /* covers situation of sibling being first */
1789 node->prev = sibling->prev;
1790 sibling->prev = node;
1791 if (node->prev->next) {
1792 /* sibling had a preceding node */
1793 node->prev->next = node;
1794 } else if (sibling->parent) {
1795 /* sibling was first and we must also change parent child pointer */
1796 sibling->parent->child = node;
1797 }
1798 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001799
Michal Vasko9f96a052020-03-10 09:41:45 +01001800 for (par = node->parent; par; par = par->parent) {
1801 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1802 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001803 par->flags &= ~LYD_DEFAULT;
1804 }
Michal Vaskob104f112020-07-17 09:54:54 +02001805 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001806 /* rehash key-less list */
1807 lyd_hash((struct lyd_node *)par);
1808 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001809 }
Michal Vasko90932a92020-02-12 14:33:03 +01001810}
1811
1812/**
Michal Vaskob104f112020-07-17 09:54:54 +02001813 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +01001814 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001815 * Handles inserting into NP containers and key-less lists.
1816 *
Michal Vasko90932a92020-02-12 14:33:03 +01001817 * @param[in] parent Parent to insert into.
1818 * @param[in] node Node to insert.
1819 */
1820static void
Michal Vaskob104f112020-07-17 09:54:54 +02001821lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001822{
1823 struct lyd_node_inner *par;
1824
Radek Krejcia1c1e542020-09-29 16:06:52 +02001825 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +01001826 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +01001827
1828 par = (struct lyd_node_inner *)parent;
1829
Michal Vaskob104f112020-07-17 09:54:54 +02001830 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +01001831 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001832
Michal Vaskod989ba02020-08-24 10:59:24 +02001833 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001834 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1835 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001836 par->flags &= ~LYD_DEFAULT;
1837 }
Michal Vasko52927e22020-03-16 17:26:14 +01001838 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001839 /* rehash key-less list */
1840 lyd_hash((struct lyd_node *)par);
1841 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001842 }
Michal Vasko751cb4d2020-07-14 12:25:28 +02001843}
Michal Vasko0249f7c2020-03-05 16:36:40 +01001844
Michal Vasko751cb4d2020-07-14 12:25:28 +02001845/**
1846 * @brief Learn whether a list instance has all the keys.
1847 *
1848 * @param[in] list List instance to check.
1849 * @return non-zero if all the keys were found,
1850 * @return 0 otherwise.
1851 */
1852static int
1853lyd_insert_has_keys(const struct lyd_node *list)
1854{
1855 const struct lyd_node *key;
1856 const struct lysc_node *skey = NULL;
1857
1858 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +02001859 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +02001860 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
1861 if (!key || (key->schema != skey)) {
1862 /* key missing */
1863 return 0;
1864 }
1865
1866 key = key->next;
1867 }
1868
1869 /* all keys found */
1870 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +01001871}
1872
1873void
Michal Vaskob104f112020-07-17 09:54:54 +02001874lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001875{
Michal Vaskob104f112020-07-17 09:54:54 +02001876 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +01001877
Michal Vaskob104f112020-07-17 09:54:54 +02001878 /* inserting list without its keys is not supported */
1879 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +01001880 assert(!parent || !parent->schema ||
1881 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +01001882
Michal Vaskob104f112020-07-17 09:54:54 +02001883 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
1884 parent = (struct lyd_node *)(*first_sibling_p)->parent;
Michal Vasko9b368d32020-02-14 13:53:31 +01001885 }
Michal Vasko90932a92020-02-12 14:33:03 +01001886
Michal Vaskob104f112020-07-17 09:54:54 +02001887 /* get first sibling */
1888 first_sibling = parent ? ((struct lyd_node_inner *)parent)->child : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +01001889
Michal Vaskob104f112020-07-17 09:54:54 +02001890 /* find the anchor, our next node, so we can insert before it */
1891 anchor = lyd_insert_get_next_anchor(first_sibling, node);
1892 if (anchor) {
1893 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +01001894 if (!parent && (*first_sibling_p == anchor)) {
1895 /* move first sibling */
1896 *first_sibling_p = node;
1897 }
Michal Vaskob104f112020-07-17 09:54:54 +02001898 } else if (first_sibling) {
1899 lyd_insert_after_node(first_sibling->prev, node);
1900 } else if (parent) {
1901 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +01001902 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02001903 *first_sibling_p = node;
1904 }
1905
1906 /* insert into parent HT */
1907 lyd_insert_hash(node);
1908
1909 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +02001910 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +02001911 lyd_hash(parent);
1912
1913 /* now we can insert even the list into its parent HT */
1914 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +01001915 }
Michal Vasko90932a92020-02-12 14:33:03 +01001916}
1917
Michal Vaskof03ed032020-03-04 13:31:44 +01001918static LY_ERR
1919lyd_insert_check_schema(const struct lysc_node *parent, const struct lysc_node *schema)
1920{
1921 const struct lysc_node *par2;
1922
1923 assert(schema);
Michal Vasko62ed12d2020-05-21 10:08:25 +02001924 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01001925
1926 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02001927 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01001928
1929 if (parent) {
1930 /* inner node */
1931 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02001932 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02001933 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001934 return LY_EINVAL;
1935 }
1936 } else {
1937 /* top-level node */
1938 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02001939 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001940 return LY_EINVAL;
1941 }
1942 }
1943
1944 return LY_SUCCESS;
1945}
1946
1947API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001948lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01001949{
1950 struct lyd_node *iter;
1951
Michal Vasko654bc852020-06-23 13:28:06 +02001952 LY_CHECK_ARG_RET(NULL, parent, node, parent->schema->nodetype & LYD_NODE_INNER, LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001953
1954 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, node->schema));
1955
1956 if (node->schema->flags & LYS_KEY) {
1957 LOGERR(parent->schema->module->ctx, LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
1958 return LY_EINVAL;
1959 }
1960
1961 if (node->parent || node->prev->next) {
1962 lyd_unlink_tree(node);
1963 }
1964
1965 while (node) {
1966 iter = node->next;
1967 lyd_unlink_tree(node);
1968 lyd_insert_node(parent, NULL, node);
1969 node = iter;
1970 }
1971 return LY_SUCCESS;
1972}
1973
1974API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001975lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01001976{
1977 struct lyd_node *iter;
1978
Michal Vaskob104f112020-07-17 09:54:54 +02001979 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001980
Michal Vaskob104f112020-07-17 09:54:54 +02001981 if (sibling) {
1982 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001983 }
1984
1985 if (node->parent || node->prev->next) {
1986 lyd_unlink_tree(node);
1987 }
1988
1989 while (node) {
Michal Vaskob104f112020-07-17 09:54:54 +02001990 if (node->schema->flags & LYS_KEY) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001991 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +02001992 return LY_EINVAL;
1993 }
1994
Michal Vaskob1b5c262020-03-05 14:29:47 +01001995 iter = node->next;
1996 lyd_unlink_tree(node);
1997 lyd_insert_node(NULL, &sibling, node);
1998 node = iter;
1999 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01002000
Michal Vaskob104f112020-07-17 09:54:54 +02002001 if (first) {
2002 /* find the first sibling */
2003 *first = sibling;
2004 while ((*first)->prev->next) {
2005 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002006 }
2007 }
2008
2009 return LY_SUCCESS;
2010}
2011
Michal Vaskob1b5c262020-03-05 14:29:47 +01002012API LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01002013lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
2014{
2015 struct lyd_node *iter;
2016
2017 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2018
Michal Vasko62ed12d2020-05-21 10:08:25 +02002019 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002020
Michal Vaskob104f112020-07-17 09:54:54 +02002021 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002022 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002023 return LY_EINVAL;
2024 }
2025
2026 if (node->parent || node->prev->next) {
2027 lyd_unlink_tree(node);
2028 }
2029
2030 /* insert in reverse order to get the original order */
2031 node = node->prev;
2032 while (node) {
2033 iter = node->prev;
2034 lyd_unlink_tree(node);
2035
2036 lyd_insert_before_node(sibling, node);
Michal Vasko751cb4d2020-07-14 12:25:28 +02002037 lyd_insert_hash(node);
2038
Michal Vaskof03ed032020-03-04 13:31:44 +01002039 /* move the anchor accordingly */
2040 sibling = node;
2041
2042 node = (iter == node) ? NULL : iter;
2043 }
2044 return LY_SUCCESS;
2045}
2046
2047API LY_ERR
2048lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
2049{
2050 struct lyd_node *iter;
2051
2052 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2053
Michal Vasko62ed12d2020-05-21 10:08:25 +02002054 LY_CHECK_RET(lyd_insert_check_schema(lysc_data_parent(sibling->schema), node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002055
Michal Vaskob104f112020-07-17 09:54:54 +02002056 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002057 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002058 return LY_EINVAL;
2059 }
2060
2061 if (node->parent || node->prev->next) {
2062 lyd_unlink_tree(node);
2063 }
2064
2065 while (node) {
2066 iter = node->next;
2067 lyd_unlink_tree(node);
2068
2069 lyd_insert_after_node(sibling, node);
Michal Vasko751cb4d2020-07-14 12:25:28 +02002070 lyd_insert_hash(node);
2071
Michal Vaskof03ed032020-03-04 13:31:44 +01002072 /* move the anchor accordingly */
2073 sibling = node;
2074
2075 node = iter;
2076 }
2077 return LY_SUCCESS;
2078}
2079
2080API void
2081lyd_unlink_tree(struct lyd_node *node)
2082{
2083 struct lyd_node *iter;
2084
2085 if (!node) {
2086 return;
2087 }
2088
Michal Vaskob104f112020-07-17 09:54:54 +02002089 /* update hashes while still linked into the tree */
2090 lyd_unlink_hash(node);
2091
Michal Vaskof03ed032020-03-04 13:31:44 +01002092 /* unlink from siblings */
2093 if (node->prev->next) {
2094 node->prev->next = node->next;
2095 }
2096 if (node->next) {
2097 node->next->prev = node->prev;
2098 } else {
2099 /* unlinking the last node */
2100 if (node->parent) {
2101 iter = node->parent->child;
2102 } else {
2103 iter = node->prev;
2104 while (iter->prev != node) {
2105 iter = iter->prev;
2106 }
2107 }
2108 /* update the "last" pointer from the first node */
2109 iter->prev = node->prev;
2110 }
2111
2112 /* unlink from parent */
2113 if (node->parent) {
2114 if (node->parent->child == node) {
2115 /* the node is the first child */
2116 node->parent->child = node->next;
2117 }
2118
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002119 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +02002120 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
2121 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002122 LY_LIST_FOR(node->parent->child, iter) {
2123 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
2124 break;
2125 }
2126 }
2127 if (!iter) {
2128 node->parent->flags |= LYD_DEFAULT;
2129 }
2130 }
2131
Michal Vaskof03ed032020-03-04 13:31:44 +01002132 /* check for keyless list and update its hash */
2133 for (iter = (struct lyd_node *)node->parent; iter; iter = (struct lyd_node *)iter->parent) {
Michal Vasko413c7f22020-05-05 12:34:06 +02002134 if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002135 lyd_hash(iter);
2136 }
2137 }
2138
2139 node->parent = NULL;
2140 }
2141
2142 node->next = NULL;
2143 node->prev = node;
2144}
2145
Michal Vaskoa5da3292020-08-12 13:10:50 +02002146void
Michal Vasko871a0252020-11-11 18:35:24 +01002147lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +02002148{
2149 struct lyd_meta *last, *iter;
2150
2151 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02002152
2153 if (!meta) {
2154 return;
2155 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002156
2157 for (iter = meta; iter; iter = iter->next) {
2158 iter->parent = parent;
2159 }
2160
2161 /* insert as the last attribute */
2162 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002163 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02002164 last->next = meta;
2165 } else {
2166 parent->meta = meta;
2167 }
2168
2169 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +01002170 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02002171 parent->flags &= ~LYD_DEFAULT;
2172 parent = (struct lyd_node *)parent->parent;
2173 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002174}
2175
2176LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01002177lyd_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 +02002178 size_t name_len, const char *value, size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format,
Michal Vasko871a0252020-11-11 18:35:24 +01002179 void *prefix_data, uint32_t hints, ly_bool clear_dflt, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01002180{
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002181 LY_ERR rc;
Michal Vasko90932a92020-02-12 14:33:03 +01002182 struct lysc_ext_instance *ant = NULL;
Michal Vasko9f96a052020-03-10 09:41:45 +01002183 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002184 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +01002185
Michal Vasko9f96a052020-03-10 09:41:45 +01002186 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002187
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002188 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko69730152020-10-09 16:30:07 +02002189 if ((mod->compiled->exts[u].def->plugin == lyext_plugins_internal[LYEXT_PLUGIN_INTERNAL_ANNOTATION].plugin) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002190 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +01002191 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002192 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +01002193 break;
2194 }
2195 }
2196 if (!ant) {
2197 /* attribute is not defined as a metadata annotation (RFC 7952) */
2198 LOGERR(mod->ctx, LY_EINVAL, "Annotation definition for attribute \"%s:%.*s\" not found.",
2199 mod->name, name_len, name);
2200 return LY_EINVAL;
2201 }
2202
Michal Vasko9f96a052020-03-10 09:41:45 +01002203 mt = calloc(1, sizeof *mt);
2204 LY_CHECK_ERR_RET(!mt, LOGMEM(mod->ctx), LY_EMEM);
2205 mt->parent = parent;
2206 mt->annotation = ant;
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002207 rc = lyd_value_store(mod->ctx, &mt->value, ((struct lyext_metadata *)ant->data)->type, value, value_len, dynamic,
2208 format, prefix_data, hints, parent ? parent->schema : NULL, incomplete, LY_VLOG_NONE, NULL);
2209 LY_CHECK_ERR_RET(rc, free(mt), rc);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002210 rc = lydict_insert(mod->ctx, name, name_len, &mt->name);
2211 LY_CHECK_ERR_RET(rc, free(mt), rc);
Michal Vasko90932a92020-02-12 14:33:03 +01002212
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002213 /* insert as the last attribute */
2214 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01002215 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01002216 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002217 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01002218 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002219 }
2220
Michal Vasko9f96a052020-03-10 09:41:45 +01002221 if (meta) {
2222 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002223 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002224 return LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01002225}
2226
Michal Vaskoa5da3292020-08-12 13:10:50 +02002227void
2228lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
2229{
2230 struct lyd_attr *last, *iter;
2231 struct lyd_node_opaq *opaq;
2232
2233 assert(parent && !parent->schema);
2234
2235 if (!attr) {
2236 return;
2237 }
2238
2239 opaq = (struct lyd_node_opaq *)parent;
2240 for (iter = attr; iter; iter = iter->next) {
2241 iter->parent = opaq;
2242 }
2243
2244 /* insert as the last attribute */
2245 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002246 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02002247 last->next = attr;
2248 } else {
2249 opaq->attr = attr;
2250 }
2251}
2252
Michal Vasko52927e22020-03-16 17:26:14 +01002253LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002254lyd_create_attr(struct lyd_node *parent, struct lyd_attr **attr, const struct ly_ctx *ctx, const char *name, size_t name_len,
Michal Vasko501af032020-11-11 20:27:44 +01002255 const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
2256 size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format, void *val_prefix_data, uint32_t hints)
Michal Vasko52927e22020-03-16 17:26:14 +01002257{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002258 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02002259 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01002260
2261 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002262 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01002263
2264 if (!value_len) {
2265 value = "";
2266 }
2267
2268 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002269 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02002270
Michal Vaskoad92b672020-11-12 13:11:31 +01002271 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002272 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002273 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002274 }
2275 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002276 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002277 }
2278
Michal Vasko52927e22020-03-16 17:26:14 +01002279 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002280 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
2281 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002282 *dynamic = 0;
2283 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002284 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002285 }
Michal Vasko501af032020-11-11 20:27:44 +01002286 at->format = format;
2287 at->val_prefix_data = val_prefix_data;
2288 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01002289
2290 /* insert as the last attribute */
2291 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002292 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01002293 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002294 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01002295 last->next = at;
2296 }
2297
Radek Krejci011e4aa2020-09-04 15:22:31 +02002298finish:
2299 if (ret) {
2300 lyd_free_attr_single(ctx, at);
2301 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01002302 *attr = at;
2303 }
2304 return LY_SUCCESS;
2305}
2306
Radek Krejci084289f2019-07-09 17:35:30 +02002307API const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02002308lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02002309{
Michal Vasko004d3152020-06-11 19:59:22 +02002310 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02002311
Michal Vasko004d3152020-06-11 19:59:22 +02002312 if (ly_path_eval(path, tree, &target)) {
2313 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02002314 }
2315
Michal Vasko004d3152020-06-11 19:59:22 +02002316 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02002317}
2318
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002319API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002320lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002321{
2322 const struct lyd_node *iter1, *iter2;
2323 struct lyd_node_term *term1, *term2;
2324 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01002325 struct lyd_node_opaq *opaq1, *opaq2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002326 size_t len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02002327
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002328 if (!node1 || !node2) {
2329 if (node1 == node2) {
2330 return LY_SUCCESS;
2331 } else {
2332 return LY_ENOT;
2333 }
2334 }
2335
Michal Vaskob7be7a82020-08-20 09:09:04 +02002336 if ((LYD_CTX(node1) != LYD_CTX(node2)) || (node1->schema != node2->schema)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002337 return LY_ENOT;
2338 }
2339
2340 if (node1->hash != node2->hash) {
2341 return LY_ENOT;
2342 }
Michal Vasko52927e22020-03-16 17:26:14 +01002343 /* 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 +02002344
Michal Vasko52927e22020-03-16 17:26:14 +01002345 if (!node1->schema) {
2346 opaq1 = (struct lyd_node_opaq *)node1;
2347 opaq2 = (struct lyd_node_opaq *)node2;
Michal Vaskoad92b672020-11-12 13:11:31 +01002348 if ((opaq1->name.name != opaq2->name.name) || (opaq1->format != opaq2->format) ||
2349 (opaq1->name.module_ns != opaq2->name.module_ns)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002350 return LY_ENOT;
2351 }
Michal Vasko52927e22020-03-16 17:26:14 +01002352 switch (opaq1->format) {
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002353 case LY_PREF_XML:
2354 if (lyxml_value_compare(LYD_CTX(node1), opaq1->value, opaq1->val_prefix_data, opaq2->value, opaq2->val_prefix_data)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002355 return LY_ENOT;
2356 }
2357 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002358 case LY_PREF_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +02002359 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
2360 if (strcmp(opaq1->value, opaq2->value)) {
2361 return LY_ENOT;
2362 }
2363 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002364 default:
Michal Vasko52927e22020-03-16 17:26:14 +01002365 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002366 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01002367 return LY_EINT;
2368 }
2369 if (options & LYD_COMPARE_FULL_RECURSION) {
2370 iter1 = opaq1->child;
2371 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002372 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01002373 }
2374 return LY_SUCCESS;
2375 } else {
2376 switch (node1->schema->nodetype) {
2377 case LYS_LEAF:
2378 case LYS_LEAFLIST:
2379 if (options & LYD_COMPARE_DEFAULTS) {
2380 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2381 return LY_ENOT;
2382 }
2383 }
2384
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002385 term1 = (struct lyd_node_term *)node1;
2386 term2 = (struct lyd_node_term *)node2;
2387 if (term1->value.realtype != term2->value.realtype) {
2388 return LY_ENOT;
2389 }
Michal Vasko52927e22020-03-16 17:26:14 +01002390
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002391 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
Michal Vasko52927e22020-03-16 17:26:14 +01002392 case LYS_CONTAINER:
2393 if (options & LYD_COMPARE_DEFAULTS) {
2394 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2395 return LY_ENOT;
2396 }
2397 }
2398 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko22df3f02020-08-24 13:29:22 +02002399 iter1 = ((struct lyd_node_inner *)node1)->child;
2400 iter2 = ((struct lyd_node_inner *)node2)->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002401 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002402 }
2403 return LY_SUCCESS;
Michal Vasko1bf09392020-03-27 12:38:10 +01002404 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002405 case LYS_ACTION:
2406 if (options & LYD_COMPARE_FULL_RECURSION) {
2407 /* TODO action/RPC
2408 goto all_children_compare;
2409 */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002410 }
2411 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002412 case LYS_NOTIF:
2413 if (options & LYD_COMPARE_FULL_RECURSION) {
2414 /* TODO Notification
2415 goto all_children_compare;
2416 */
2417 }
2418 return LY_SUCCESS;
2419 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02002420 iter1 = ((struct lyd_node_inner *)node1)->child;
2421 iter2 = ((struct lyd_node_inner *)node2)->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002422
2423 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
2424 /* lists with keys, their equivalence is based on their keys */
Michal Vasko22df3f02020-08-24 13:29:22 +02002425 for (struct lysc_node *key = ((struct lysc_node_list *)node1->schema)->child;
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002426 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01002427 key = key->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002428 if (lyd_compare_single(iter1, iter2, options)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002429 return LY_ENOT;
2430 }
2431 iter1 = iter1->next;
2432 iter2 = iter2->next;
2433 }
2434 } else {
2435 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
2436
Radek Krejci0f969882020-08-21 16:56:47 +02002437all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01002438 if (!iter1 && !iter2) {
2439 /* no children, nothing to compare */
2440 return LY_SUCCESS;
2441 }
2442
Michal Vaskod989ba02020-08-24 10:59:24 +02002443 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002444 if (lyd_compare_single(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002445 return LY_ENOT;
2446 }
2447 }
2448 if (iter1 || iter2) {
2449 return LY_ENOT;
2450 }
2451 }
2452 return LY_SUCCESS;
2453 case LYS_ANYXML:
2454 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02002455 any1 = (struct lyd_node_any *)node1;
2456 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01002457
2458 if (any1->value_type != any2->value_type) {
2459 return LY_ENOT;
2460 }
2461 switch (any1->value_type) {
2462 case LYD_ANYDATA_DATATREE:
2463 iter1 = any1->value.tree;
2464 iter2 = any2->value.tree;
2465 goto all_children_compare;
2466 case LYD_ANYDATA_STRING:
2467 case LYD_ANYDATA_XML:
2468 case LYD_ANYDATA_JSON:
2469 len1 = strlen(any1->value.str);
2470 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02002471 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002472 return LY_ENOT;
2473 }
2474 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002475 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02002476 len1 = lyd_lyb_data_length(any1->value.mem);
2477 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko69730152020-10-09 16:30:07 +02002478 if ((len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002479 return LY_ENOT;
2480 }
2481 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002482 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002483 }
2484 }
2485
Michal Vaskob7be7a82020-08-20 09:09:04 +02002486 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002487 return LY_EINT;
2488}
Radek Krejci22ebdba2019-07-25 13:59:43 +02002489
Michal Vasko21725742020-06-29 11:49:25 +02002490API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002491lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02002492{
Michal Vaskod989ba02020-08-24 10:59:24 +02002493 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002494 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
2495 }
2496
Michal Vasko11a81432020-07-28 16:31:29 +02002497 if (node1 == node2) {
2498 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002499 }
Michal Vasko11a81432020-07-28 16:31:29 +02002500 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002501}
2502
2503API LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02002504lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
2505{
2506 if (!meta1 || !meta2) {
2507 if (meta1 == meta2) {
2508 return LY_SUCCESS;
2509 } else {
2510 return LY_ENOT;
2511 }
2512 }
2513
Michal Vaskoa8083062020-11-06 17:22:10 +01002514 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02002515 return LY_ENOT;
2516 }
2517
2518 if (meta1->value.realtype != meta2->value.realtype) {
2519 return LY_ENOT;
2520 }
2521
2522 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
2523}
2524
Radek Krejci22ebdba2019-07-25 13:59:43 +02002525/**
Michal Vasko52927e22020-03-16 17:26:14 +01002526 * @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 +02002527 *
2528 * 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 +02002529 *
2530 * @param[in] node Original node to duplicate
2531 * @param[in] parent Parent to insert into, NULL for top-level sibling.
2532 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2533 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2534 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it int @p parent / @p first sibling).
2535 * @return LY_ERR value
Radek Krejci22ebdba2019-07-25 13:59:43 +02002536 */
Michal Vasko52927e22020-03-16 17:26:14 +01002537static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002538lyd_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 +02002539 struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002540{
Michal Vasko52927e22020-03-16 17:26:14 +01002541 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002542 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002543 struct lyd_meta *meta;
2544 struct lyd_node_any *any;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002545
Michal Vasko52927e22020-03-16 17:26:14 +01002546 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002547
Michal Vasko52927e22020-03-16 17:26:14 +01002548 if (!node->schema) {
2549 dup = calloc(1, sizeof(struct lyd_node_opaq));
2550 } else {
2551 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01002552 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002553 case LYS_ACTION:
2554 case LYS_NOTIF:
2555 case LYS_CONTAINER:
2556 case LYS_LIST:
2557 dup = calloc(1, sizeof(struct lyd_node_inner));
2558 break;
2559 case LYS_LEAF:
2560 case LYS_LEAFLIST:
2561 dup = calloc(1, sizeof(struct lyd_node_term));
2562 break;
2563 case LYS_ANYDATA:
2564 case LYS_ANYXML:
2565 dup = calloc(1, sizeof(struct lyd_node_any));
2566 break;
2567 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02002568 LOGINT(LYD_CTX(node));
Michal Vasko52927e22020-03-16 17:26:14 +01002569 ret = LY_EINT;
2570 goto error;
2571 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002572 }
Michal Vaskob7be7a82020-08-20 09:09:04 +02002573 LY_CHECK_ERR_GOTO(!dup, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002574
Michal Vaskof6df0a02020-06-16 13:08:34 +02002575 if (options & LYD_DUP_WITH_FLAGS) {
2576 dup->flags = node->flags;
2577 } else {
2578 dup->flags = (node->flags & LYD_DEFAULT) | LYD_NEW;
2579 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002580 dup->schema = node->schema;
Michal Vasko52927e22020-03-16 17:26:14 +01002581 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002582
Michal Vasko25a32822020-07-09 15:48:22 +02002583 /* duplicate metadata */
2584 if (!(options & LYD_DUP_NO_META)) {
2585 LY_LIST_FOR(node->meta, meta) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002586 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
Michal Vasko25a32822020-07-09 15:48:22 +02002587 }
2588 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002589
2590 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01002591 if (!dup->schema) {
2592 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
2593 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
2594 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002595
2596 if (options & LYD_DUP_RECURSIVE) {
2597 /* duplicate all the children */
2598 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002599 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002600 }
2601 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002602 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.name, 0, &opaq->name.name), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002603 opaq->format = orig->format;
Michal Vaskoad92b672020-11-12 13:11:31 +01002604 if (orig->name.prefix) {
2605 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.prefix, 0, &opaq->name.prefix), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002606 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002607 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.module_ns, 0, &opaq->name.module_ns), error);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002608 if (orig->val_prefix_data) {
2609 ret = ly_dup_prefix_data(LYD_CTX(node), opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
2610 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002611 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002612 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->value, 0, &opaq->value), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002613 opaq->ctx = orig->ctx;
2614 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
2615 struct lyd_node_term *term = (struct lyd_node_term *)dup;
2616 struct lyd_node_term *orig = (struct lyd_node_term *)node;
2617
2618 term->hash = orig->hash;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002619 LY_CHECK_ERR_GOTO(orig->value.realtype->plugin->duplicate(LYD_CTX(node), &orig->value, &term->value),
Michal Vasko69730152020-10-09 16:30:07 +02002620 LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."); ret = LY_EINT, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002621 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
2622 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
2623 struct lyd_node *child;
2624
2625 if (options & LYD_DUP_RECURSIVE) {
2626 /* duplicate all the children */
2627 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002628 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002629 }
Michal Vasko69730152020-10-09 16:30:07 +02002630 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002631 /* always duplicate keys of a list */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002632 child = orig->child;
Michal Vasko52927e22020-03-16 17:26:14 +01002633 for (struct lysc_node *key = ((struct lysc_node_list *)dup->schema)->child;
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002634 key && (key->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +02002635 key = key->next) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002636 if (!child) {
2637 /* possibly not keys are present in filtered tree */
2638 break;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002639 } else if (child->schema != key) {
2640 /* possibly not all keys are present in filtered tree,
2641 * but there can be also some non-key nodes */
2642 continue;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002643 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002644 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002645 child = child->next;
2646 }
2647 }
2648 lyd_hash(dup);
2649 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02002650 dup->hash = node->hash;
2651 any = (struct lyd_node_any *)node;
2652 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002653 }
2654
Michal Vasko52927e22020-03-16 17:26:14 +01002655 /* insert */
2656 lyd_insert_node(parent, first, dup);
Michal Vasko52927e22020-03-16 17:26:14 +01002657
2658 if (dup_p) {
2659 *dup_p = dup;
2660 }
2661 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002662
2663error:
Michal Vasko52927e22020-03-16 17:26:14 +01002664 lyd_free_tree(dup);
2665 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002666}
2667
Michal Vasko3a41dff2020-07-15 14:30:28 +02002668static LY_ERR
2669lyd_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 +02002670 struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002671{
Michal Vasko3a41dff2020-07-15 14:30:28 +02002672 const struct lyd_node_inner *orig_parent, *iter;
Radek Krejci857189e2020-09-01 13:26:36 +02002673 ly_bool repeat = 1;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002674
2675 *dup_parent = NULL;
2676 *local_parent = NULL;
2677
2678 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
2679 if (parent && (parent->schema == orig_parent->schema)) {
2680 /* stop creating parents, connect what we have into the provided parent */
2681 iter = parent;
2682 repeat = 0;
2683 } else {
2684 iter = NULL;
2685 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, NULL, (struct lyd_node **)&iter, 0,
Radek Krejci0f969882020-08-21 16:56:47 +02002686 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02002687 }
2688 if (!*local_parent) {
2689 *local_parent = (struct lyd_node_inner *)iter;
2690 }
2691 if (iter->child) {
2692 /* 1) list - add after keys
2693 * 2) provided parent with some children */
2694 iter->child->prev->next = *dup_parent;
2695 if (*dup_parent) {
2696 (*dup_parent)->prev = iter->child->prev;
2697 iter->child->prev = *dup_parent;
2698 }
2699 } else {
2700 ((struct lyd_node_inner *)iter)->child = *dup_parent;
2701 }
2702 if (*dup_parent) {
2703 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
2704 }
2705 *dup_parent = (struct lyd_node *)iter;
2706 }
2707
2708 if (repeat && parent) {
2709 /* given parent and created parents chain actually do not interconnect */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002710 LOGERR(LYD_CTX(node), LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02002711 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002712 return LY_EINVAL;
2713 }
2714
2715 return LY_SUCCESS;
2716}
2717
2718static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002719lyd_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 +02002720{
2721 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002722 const struct lyd_node *orig; /* original node to be duplicated */
2723 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002724 struct lyd_node *top = NULL; /* the most higher created node */
2725 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002726
Michal Vasko3a41dff2020-07-15 14:30:28 +02002727 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002728
2729 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002730 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, parent, &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002731 } else {
2732 local_parent = parent;
2733 }
2734
Radek Krejci22ebdba2019-07-25 13:59:43 +02002735 LY_LIST_FOR(node, orig) {
Michal Vasko52927e22020-03-16 17:26:14 +01002736 /* if there is no local parent, it will be inserted into first */
Michal Vasko3a41dff2020-07-15 14:30:28 +02002737 LY_CHECK_GOTO(rc = lyd_dup_r(orig, (struct lyd_node *)local_parent, &first, options, first ? NULL : &first), error);
2738 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002739 break;
2740 }
2741 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002742
2743 /* rehash if needed */
Michal Vaskod989ba02020-08-24 10:59:24 +02002744 for ( ; local_parent; local_parent = local_parent->parent) {
Michal Vasko69730152020-10-09 16:30:07 +02002745 if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002746 lyd_hash((struct lyd_node *)local_parent);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002747 }
2748 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002749
2750 if (dup) {
2751 *dup = first;
2752 }
2753 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002754
2755error:
2756 if (top) {
2757 lyd_free_tree(top);
2758 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01002759 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002760 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002761 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002762}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002763
Michal Vasko3a41dff2020-07-15 14:30:28 +02002764API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002765lyd_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 +02002766{
2767 return lyd_dup(node, parent, options, 1, dup);
2768}
2769
2770API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002771lyd_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 +02002772{
2773 return lyd_dup(node, parent, options, 0, dup);
2774}
2775
2776API LY_ERR
2777lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02002778{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002779 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002780 struct lyd_meta *mt, *last;
2781
Michal Vasko3a41dff2020-07-15 14:30:28 +02002782 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02002783
2784 /* create a copy */
2785 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02002786 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02002787 mt->annotation = meta->annotation;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002788 ret = meta->value.realtype->plugin->duplicate(LYD_CTX(node), &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002789 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
2790 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02002791
2792 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02002793 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02002794 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002795 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02002796 last->next = mt;
2797 } else {
2798 node->meta = mt;
2799 }
2800
Radek Krejci011e4aa2020-09-04 15:22:31 +02002801finish:
2802 if (ret) {
2803 lyd_free_meta_single(mt);
2804 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002805 *dup = mt;
2806 }
2807 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002808}
2809
Michal Vasko4490d312020-06-16 13:08:55 +02002810/**
2811 * @brief Merge a source sibling into target siblings.
2812 *
2813 * @param[in,out] first_trg First target sibling, is updated if top-level.
2814 * @param[in] parent_trg Target parent.
2815 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
2816 * @param[in] options Merge options.
2817 * @return LY_ERR value.
2818 */
2819static LY_ERR
2820lyd_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 +02002821 uint16_t options)
Michal Vasko4490d312020-06-16 13:08:55 +02002822{
2823 LY_ERR ret;
2824 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02002825 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vasko4490d312020-06-16 13:08:55 +02002826 struct lysc_type *type;
Michal Vasko4490d312020-06-16 13:08:55 +02002827
2828 sibling_src = *sibling_src_p;
2829 if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
2830 /* try to find the exact instance */
2831 ret = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
2832 } else {
2833 /* try to simply find the node, there cannot be more instances */
2834 ret = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
2835 }
2836
2837 if (!ret) {
2838 /* node found, make sure even value matches for all node types */
Michal Vasko8f359bf2020-07-28 10:41:15 +02002839 if ((match_trg->schema->nodetype == LYS_LEAF) && lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002840 /* since they are different, they cannot both be default */
2841 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
2842
Michal Vasko3a41dff2020-07-15 14:30:28 +02002843 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
2844 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002845 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002846 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
2847 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02002848 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02002849
2850 /* copy flags and add LYD_NEW */
2851 match_trg->flags = sibling_src->flags | LYD_NEW;
2852 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002853 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002854 /* update value */
2855 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002856 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002857
2858 /* copy flags and add LYD_NEW */
2859 match_trg->flags = sibling_src->flags | LYD_NEW;
Michal Vasko4490d312020-06-16 13:08:55 +02002860 } else {
2861 /* check descendants, recursively */
Radek Krejcia1c1e542020-09-29 16:06:52 +02002862 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
Michal Vasko4490d312020-06-16 13:08:55 +02002863 LY_CHECK_RET(lyd_merge_sibling_r(lyd_node_children_p(match_trg), match_trg, &child_src, options));
2864 }
2865 }
2866 } else {
2867 /* node not found, merge it */
2868 if (options & LYD_MERGE_DESTRUCT) {
2869 dup_src = (struct lyd_node *)sibling_src;
2870 lyd_unlink_tree(dup_src);
2871 /* spend it */
2872 *sibling_src_p = NULL;
2873 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002874 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 +02002875 }
2876
2877 /* set LYD_NEW for all the new nodes, required for validation */
Michal Vasko56daf732020-08-10 10:57:18 +02002878 LYD_TREE_DFS_BEGIN(dup_src, elem) {
Michal Vasko4490d312020-06-16 13:08:55 +02002879 elem->flags |= LYD_NEW;
Michal Vasko56daf732020-08-10 10:57:18 +02002880 LYD_TREE_DFS_END(dup_src, elem);
Michal Vasko4490d312020-06-16 13:08:55 +02002881 }
2882
2883 lyd_insert_node(parent_trg, first_trg, dup_src);
2884 }
2885
2886 return LY_SUCCESS;
2887}
2888
Michal Vasko3a41dff2020-07-15 14:30:28 +02002889static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002890lyd_merge(struct lyd_node **target, const struct lyd_node *source, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02002891{
2892 const struct lyd_node *sibling_src, *tmp;
Radek Krejci857189e2020-09-01 13:26:36 +02002893 ly_bool first;
Michal Vasko4490d312020-06-16 13:08:55 +02002894
2895 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
2896
2897 if (!source) {
2898 /* nothing to merge */
2899 return LY_SUCCESS;
2900 }
2901
2902 if (lysc_data_parent((*target)->schema) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002903 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02002904 return LY_EINVAL;
2905 }
2906
2907 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Radek Krejci857189e2020-09-01 13:26:36 +02002908 first = (sibling_src == source) ? 1 : 0;
Michal Vasko4490d312020-06-16 13:08:55 +02002909 LY_CHECK_RET(lyd_merge_sibling_r(target, NULL, &sibling_src, options));
2910 if (first && !sibling_src) {
2911 /* source was spent (unlinked), move to the next node */
2912 source = tmp;
2913 }
2914
Michal Vasko3a41dff2020-07-15 14:30:28 +02002915 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02002916 break;
2917 }
2918 }
2919
2920 if (options & LYD_MERGE_DESTRUCT) {
2921 /* free any leftover source data that were not merged */
2922 lyd_free_siblings((struct lyd_node *)source);
2923 }
2924
2925 return LY_SUCCESS;
2926}
2927
Michal Vasko3a41dff2020-07-15 14:30:28 +02002928API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002929lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002930{
2931 return lyd_merge(target, source, options, 1);
2932}
2933
2934API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002935lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002936{
2937 return lyd_merge(target, source, options, 0);
2938}
2939
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002940static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002941lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002942{
Michal Vasko14654712020-02-06 08:35:21 +01002943 /* ending \0 */
2944 ++reqlen;
2945
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002946 if (reqlen > *buflen) {
2947 if (is_static) {
2948 return LY_EINCOMPLETE;
2949 }
2950
2951 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
2952 if (!*buffer) {
2953 return LY_EMEM;
2954 }
2955
2956 *buflen = reqlen;
2957 }
2958
2959 return LY_SUCCESS;
2960}
2961
Michal Vaskod59035b2020-07-08 12:00:06 +02002962LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002963lyd_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 +02002964{
2965 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002966 size_t len;
2967 const char *val;
2968 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002969
Radek Krejcia1c1e542020-09-29 16:06:52 +02002970 for (key = lyd_child(node); key && (key->schema->flags & LYS_KEY); key = key->next) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002971 val = LYD_CANON_VALUE(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002972 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002973 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002974
2975 quot = '\'';
2976 if (strchr(val, '\'')) {
2977 quot = '"';
2978 }
2979 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002980 }
2981
2982 return LY_SUCCESS;
2983}
2984
2985/**
2986 * @brief Append leaf-list value predicate to path.
2987 *
2988 * @param[in] node Node to print.
2989 * @param[in,out] buffer Buffer to print to.
2990 * @param[in,out] buflen Current buffer length.
2991 * @param[in,out] bufused Current number of characters used in @p buffer.
2992 * @param[in] is_static Whether buffer is static or can be reallocated.
2993 * @return LY_ERR
2994 */
2995static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002996lyd_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 +02002997{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002998 size_t len;
2999 const char *val;
3000 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003001
Michal Vaskob7be7a82020-08-20 09:09:04 +02003002 val = LYD_CANON_VALUE(node);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003003 len = 4 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003004 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003005
3006 quot = '\'';
3007 if (strchr(val, '\'')) {
3008 quot = '"';
3009 }
3010 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
3011
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003012 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003013}
3014
3015/**
3016 * @brief Append node position (relative to its other instances) predicate to path.
3017 *
3018 * @param[in] node Node to print.
3019 * @param[in,out] buffer Buffer to print to.
3020 * @param[in,out] buflen Current buffer length.
3021 * @param[in,out] bufused Current number of characters used in @p buffer.
3022 * @param[in] is_static Whether buffer is static or can be reallocated.
3023 * @return LY_ERR
3024 */
3025static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003026lyd_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 +02003027{
3028 const struct lyd_node *first, *iter;
3029 size_t len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003030 uint64_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003031 char *val = NULL;
3032 LY_ERR rc;
3033
3034 if (node->parent) {
3035 first = node->parent->child;
3036 } else {
Michal Vaskoe070bfe2020-08-31 12:27:25 +02003037 for (first = node; first->prev->next; first = first->prev) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003038 }
3039 pos = 1;
3040 for (iter = first; iter != node; iter = iter->next) {
3041 if (iter->schema == node->schema) {
3042 ++pos;
3043 }
3044 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02003045 if (asprintf(&val, "%" PRIu64, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003046 return LY_EMEM;
3047 }
3048
3049 len = 1 + strlen(val) + 1;
3050 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
3051 if (rc != LY_SUCCESS) {
3052 goto cleanup;
3053 }
3054
3055 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
3056
3057cleanup:
3058 free(val);
3059 return rc;
3060}
3061
3062API char *
3063lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
3064{
Radek Krejci857189e2020-09-01 13:26:36 +02003065 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003066 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01003067 size_t bufused = 0, len;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003068 const struct lyd_node *iter;
3069 const struct lys_module *mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02003070 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003071
3072 LY_CHECK_ARG_RET(NULL, node, NULL);
3073 if (buffer) {
3074 LY_CHECK_ARG_RET(node->schema->module->ctx, buflen > 1, NULL);
3075 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01003076 } else {
3077 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003078 }
3079
3080 switch (pathtype) {
Michal Vasko14654712020-02-06 08:35:21 +01003081 case LYD_PATH_LOG:
Michal Vasko790b2bc2020-08-03 13:35:06 +02003082 case LYD_PATH_LOG_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01003083 depth = 1;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003084 for (iter = node; iter->parent; iter = (const struct lyd_node *)iter->parent) {
3085 ++depth;
3086 }
3087
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003088 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01003089 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003090 /* find the right node */
Radek Krejci1e008d22020-08-17 11:37:37 +02003091 for (iter = node, i = 1; i < depth; iter = (const struct lyd_node *)iter->parent, ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003092iter_print:
3093 /* print prefix and name */
3094 mod = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02003095 if (iter->schema && (!iter->parent || (iter->schema->module != iter->parent->schema->module))) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003096 mod = iter->schema->module;
3097 }
3098
3099 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01003100 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
3101 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003102 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
3103 if (rc != LY_SUCCESS) {
3104 break;
3105 }
3106
3107 /* print next node */
Radek Krejci1798aae2020-07-14 13:26:06 +02003108 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "",
Michal Vaskoad92b672020-11-12 13:11:31 +01003109 iter->schema ? iter->schema->name : ((struct lyd_node_opaq *)iter)->name.name);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003110
Michal Vasko790b2bc2020-08-03 13:35:06 +02003111 /* do not always print the last (first) predicate */
Michal Vasko552e1122020-11-06 17:22:44 +01003112 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_LOG))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02003113 switch (iter->schema->nodetype) {
3114 case LYS_LIST:
3115 if (iter->schema->flags & LYS_KEYLESS) {
3116 /* print its position */
3117 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3118 } else {
3119 /* print all list keys in predicates */
3120 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
3121 }
3122 break;
3123 case LYS_LEAFLIST:
3124 if (iter->schema->flags & LYS_CONFIG_W) {
3125 /* print leaf-list value */
3126 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
3127 } else {
3128 /* print its position */
3129 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3130 }
3131 break;
3132 default:
3133 /* nothing to print more */
3134 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003135 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003136 }
3137 if (rc != LY_SUCCESS) {
3138 break;
3139 }
3140
Michal Vasko14654712020-02-06 08:35:21 +01003141 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003142 }
3143 break;
3144 }
3145
3146 return buffer;
3147}
Michal Vaskoe444f752020-02-10 12:20:06 +01003148
Michal Vasko25a32822020-07-09 15:48:22 +02003149API struct lyd_meta *
3150lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
3151{
3152 struct lyd_meta *ret = NULL;
3153 const struct ly_ctx *ctx;
3154 const char *prefix, *tmp;
3155 char *str;
3156 size_t pref_len, name_len;
3157
3158 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
3159
3160 if (!first) {
3161 return NULL;
3162 }
3163
3164 ctx = first->annotation->module->ctx;
3165
3166 /* parse the name */
3167 tmp = name;
3168 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3169 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3170 return NULL;
3171 }
3172
3173 /* find the module */
3174 if (prefix) {
3175 str = strndup(prefix, pref_len);
3176 module = ly_ctx_get_module_latest(ctx, str);
3177 free(str);
3178 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", pref_len, prefix), NULL);
3179 }
3180
3181 /* find the metadata */
3182 LY_LIST_FOR(first, first) {
3183 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3184 ret = (struct lyd_meta *)first;
3185 break;
3186 }
3187 }
3188
3189 return ret;
3190}
3191
Michal Vasko9b368d32020-02-14 13:53:31 +01003192API LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003193lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3194{
3195 struct lyd_node **match_p;
3196 struct lyd_node_inner *parent;
3197
Michal Vaskof03ed032020-03-04 13:31:44 +01003198 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003199
Michal Vasko62ed12d2020-05-21 10:08:25 +02003200 if (!siblings || (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema))) {
3201 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003202 if (match) {
3203 *match = NULL;
3204 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003205 return LY_ENOTFOUND;
3206 }
3207
3208 /* find first sibling */
3209 if (siblings->parent) {
3210 siblings = siblings->parent->child;
3211 } else {
3212 while (siblings->prev->next) {
3213 siblings = siblings->prev;
3214 }
3215 }
3216
3217 parent = (struct lyd_node_inner *)siblings->parent;
3218 if (parent && parent->children_ht) {
3219 assert(target->hash);
3220
3221 /* find by hash */
3222 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003223 /* check even value when needed */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003224 if (!(target->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !lyd_compare_single(target, *match_p, 0)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003225 siblings = *match_p;
3226 } else {
3227 siblings = NULL;
3228 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003229 } else {
3230 /* not found */
3231 siblings = NULL;
3232 }
3233 } else {
3234 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02003235 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02003236 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003237 break;
3238 }
3239 }
3240 }
3241
3242 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003243 if (match) {
3244 *match = NULL;
3245 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003246 return LY_ENOTFOUND;
3247 }
3248
Michal Vasko9b368d32020-02-14 13:53:31 +01003249 if (match) {
3250 *match = (struct lyd_node *)siblings;
3251 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003252 return LY_SUCCESS;
3253}
3254
Radek Krejci857189e2020-09-01 13:26:36 +02003255/**
3256 * @brief Comparison callback to match schema node with a schema of a data node.
3257 *
3258 * @param[in] val1_p Pointer to the schema node
3259 * @param[in] val2_p Pointer to the data node
3260 * Implementation of ::values_equal_cb.
3261 */
3262static ly_bool
3263lyd_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 +01003264{
3265 struct lysc_node *val1;
3266 struct lyd_node *val2;
3267
3268 val1 = *((struct lysc_node **)val1_p);
3269 val2 = *((struct lyd_node **)val2_p);
3270
Michal Vasko90932a92020-02-12 14:33:03 +01003271 if (val1 == val2->schema) {
3272 /* schema match is enough */
3273 return 1;
3274 } else {
3275 return 0;
3276 }
3277}
3278
Michal Vasko92239c72020-11-18 18:17:25 +01003279/**
3280 * @brief Search in the given siblings (NOT recursively) for the first schema node data instance.
3281 * Uses hashes - should be used whenever possible for best performance.
3282 *
3283 * @param[in] siblings Siblings to search in including preceding and succeeding nodes.
3284 * @param[in] schema Target data node schema to find.
3285 * @param[out] match Can be NULL, otherwise the found data node.
3286 * @return LY_SUCCESS on success, @p match set.
3287 * @return LY_ENOTFOUND if not found, @p match set to NULL.
3288 * @return LY_ERR value if another error occurred.
3289 */
Michal Vasko90932a92020-02-12 14:33:03 +01003290static LY_ERR
3291lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema, struct lyd_node **match)
3292{
3293 struct lyd_node **match_p;
3294 struct lyd_node_inner *parent;
3295 uint32_t hash;
3296 values_equal_cb ht_cb;
3297
Michal Vaskob104f112020-07-17 09:54:54 +02003298 assert(siblings && schema);
Michal Vasko90932a92020-02-12 14:33:03 +01003299
3300 parent = (struct lyd_node_inner *)siblings->parent;
Michal Vasko08fd6132020-11-18 18:17:45 +01003301 if (parent && parent->schema && parent->children_ht) {
Michal Vasko90932a92020-02-12 14:33:03 +01003302 /* calculate our hash */
3303 hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
3304 hash = dict_hash_multi(hash, schema->name, strlen(schema->name));
3305 hash = dict_hash_multi(hash, NULL, 0);
3306
3307 /* use special hash table function */
3308 ht_cb = lyht_set_cb(parent->children_ht, lyd_hash_table_schema_val_equal);
3309
3310 /* find by hash */
3311 if (!lyht_find(parent->children_ht, &schema, hash, (void **)&match_p)) {
3312 siblings = *match_p;
3313 } else {
3314 /* not found */
3315 siblings = NULL;
3316 }
3317
3318 /* set the original hash table compare function back */
3319 lyht_set_cb(parent->children_ht, ht_cb);
3320 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02003321 /* find first sibling */
3322 if (siblings->parent) {
3323 siblings = siblings->parent->child;
3324 } else {
3325 while (siblings->prev->next) {
3326 siblings = siblings->prev;
3327 }
3328 }
3329
3330 /* search manually without hashes */
Michal Vaskod989ba02020-08-24 10:59:24 +02003331 for ( ; siblings; siblings = siblings->next) {
Michal Vasko90932a92020-02-12 14:33:03 +01003332 if (siblings->schema == schema) {
3333 /* schema match is enough */
3334 break;
3335 }
3336 }
3337 }
3338
3339 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003340 if (match) {
3341 *match = NULL;
3342 }
Michal Vasko90932a92020-02-12 14:33:03 +01003343 return LY_ENOTFOUND;
3344 }
3345
Michal Vasko9b368d32020-02-14 13:53:31 +01003346 if (match) {
3347 *match = (struct lyd_node *)siblings;
3348 }
Michal Vasko90932a92020-02-12 14:33:03 +01003349 return LY_SUCCESS;
3350}
3351
Michal Vaskoe444f752020-02-10 12:20:06 +01003352API LY_ERR
3353lyd_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 +02003354 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003355{
3356 LY_ERR rc;
3357 struct lyd_node *target = NULL;
3358
Michal Vasko4c583e82020-07-17 12:16:14 +02003359 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003360
Michal Vasko08fd6132020-11-18 18:17:45 +01003361 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003362 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003363 if (match) {
3364 *match = NULL;
3365 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003366 return LY_ENOTFOUND;
3367 }
3368
Michal Vaskof03ed032020-03-04 13:31:44 +01003369 if (key_or_value && !val_len) {
3370 val_len = strlen(key_or_value);
3371 }
3372
Michal Vaskob104f112020-07-17 09:54:54 +02003373 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3374 /* create a data node and find the instance */
3375 if (schema->nodetype == LYS_LEAFLIST) {
3376 /* target used attributes: schema, hash, value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003377 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &target);
3378 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003379 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003380 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02003381 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003382 }
3383
3384 /* find it */
3385 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003386 } else {
3387 /* find the first schema node instance */
3388 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003389 }
3390
Michal Vaskoe444f752020-02-10 12:20:06 +01003391 lyd_free_tree(target);
3392 return rc;
3393}
Michal Vaskoccc02342020-05-21 10:09:21 +02003394
3395API LY_ERR
3396lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
3397{
3398 LY_ERR ret = LY_SUCCESS;
3399 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003400 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02003401 uint32_t i;
3402
3403 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
3404
3405 memset(&xp_set, 0, sizeof xp_set);
3406
3407 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003408 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
3409 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003410
3411 /* evaluate expression */
Michal Vaskocdad7122020-11-09 21:04:44 +01003412 ret = lyxp_eval(exp, NULL, LY_PREF_JSON, NULL, ctx_node, ctx_node, &xp_set, LYXP_IGNORE_WHEN);
Michal Vaskoccc02342020-05-21 10:09:21 +02003413 LY_CHECK_GOTO(ret, cleanup);
3414
3415 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02003416 ret = ly_set_new(set);
3417 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003418
3419 /* transform into ly_set */
3420 if (xp_set.type == LYXP_SET_NODE_SET) {
3421 /* allocate memory for all the elements once (even though not all items must be elements but most likely will be) */
3422 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003423 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(ctx_node)); ret = LY_EMEM, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003424 (*set)->size = xp_set.used;
3425
3426 for (i = 0; i < xp_set.used; ++i) {
3427 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +02003428 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +02003429 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003430 }
3431 }
3432 }
3433
3434cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02003435 lyxp_set_free_content(&xp_set);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003436 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
Michal Vaskoccc02342020-05-21 10:09:21 +02003437 return ret;
3438}
Radek Krejcica989142020-11-05 11:32:22 +01003439
3440API uint32_t
3441lyd_list_pos(const struct lyd_node *instance)
3442{
3443 const struct lyd_node *iter = NULL;
3444 uint32_t pos = 0;
3445
3446 if (!instance || !(instance->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
3447 return 0;
3448 }
3449
3450 /* data instances are ordered, so we can stop when we found instance of other schema node */
3451 for (iter = instance; iter->schema == instance->schema; iter = iter->prev) {
Radek Krejcibb27df32020-11-13 15:39:16 +01003452 if (pos && (iter->next == NULL)) {
Radek Krejcica989142020-11-05 11:32:22 +01003453 /* overrun to the end of the siblings list */
3454 break;
3455 }
3456 ++pos;
3457 }
3458
3459 return pos;
3460}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003461
3462API struct lyd_node *
3463lyd_first_sibling(const struct lyd_node *node)
3464{
3465 struct lyd_node *start;
3466
3467 if (!node) {
3468 return NULL;
3469 }
3470
3471 /* get the first sibling */
3472 if (node->parent) {
3473 start = node->parent->child;
3474 } else {
Radek Krejcibb27df32020-11-13 15:39:16 +01003475 for (start = (struct lyd_node *)node; start->prev->next; start = start->prev) {}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003476 }
3477
3478 return start;
3479}