blob: 931e07048e17260f20c022c06ef84e37ed4c0a47 [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,
Radek Krejci2efc45b2020-12-22 16:25:44 +010059 const struct lysc_node *ctx_node, ly_bool *incomplete)
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 Vasko405cc9e2020-12-01 12:01:27 +010069 ret = type->plugin->store(ctx, type, value, value_len, options, format, prefix_data, hints, ctx_node, val, NULL, &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) {
Radek Krejci2efc45b2020-12-22 16:25:44 +010076 LOGVAL(ctx, err->vecode, err->msg);
Michal Vaskofeca4fb2020-10-05 08:58:40 +020077 ly_err_free(err);
78 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +010079 LOGVAL(ctx, LYVE_OTHER, "Storing value \"%.*s\" failed.", (int)value_len, value);
Michal Vaskofeca4fb2020-10-05 08:58:40 +020080 }
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,
Radek Krejci2efc45b2020-12-22 16:25:44 +010092 const struct lyd_node *ctx_node, const struct lyd_node *tree)
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) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100102 LOGVAL(ctx, 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 {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100105 LOGVAL(ctx, 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,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100131 LYD_HINT_SCHEMA, node, &storage, NULL, &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 Krejciddace2c2021-01-08 11:30:56 +0100139 LOG_LOCSET(NULL, NULL, err->path, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100140 LOGVAL(ctx, err->vecode, err->msg);
Radek Krejciddace2c2021-01-08 11:30:56 +0100141 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci084289f2019-07-09 17:35:30 +0200142 }
Radek Krejci73dead22019-07-11 16:46:16 +0200143 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200144 }
145
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200146 if (!rc) {
147 type->plugin->free(ctx ? ctx : node->module->ctx, &storage);
148 }
Radek Krejci084289f2019-07-09 17:35:30 +0200149 return rc;
150}
151
152API LY_ERR
Michal Vaskof937cfe2020-08-03 16:07:12 +0200153lys_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const char *value, size_t value_len)
154{
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200155 return _lys_value_validate(ctx, node, value, value_len, LY_PREF_JSON, NULL);
Michal Vaskof937cfe2020-08-03 16:07:12 +0200156}
157
158API LY_ERR
Michal Vasko44685da2020-03-17 15:38:06 +0100159lyd_value_validate(const struct ly_ctx *ctx, const struct lyd_node_term *node, const char *value, size_t value_len,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200160 const struct lyd_node *tree, const struct lysc_type **realtype)
Radek Krejci084289f2019-07-09 17:35:30 +0200161{
162 LY_ERR rc;
163 struct ly_err_item *err = NULL;
164 struct lysc_type *type;
Michal Vasko3701af52020-08-03 14:29:38 +0200165 struct lyd_value val = {0};
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200166 ly_bool stored = 0;
Radek Krejci084289f2019-07-09 17:35:30 +0200167
168 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
169
Michal Vasko22df3f02020-08-24 13:29:22 +0200170 type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200171 /* store */
172 rc = type->plugin->store(ctx ? ctx : LYD_CTX(node), type, value, value_len, 0, LY_PREF_JSON, NULL,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100173 LYD_HINT_DATA, node->schema, &val, NULL, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200174 if (rc == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200175 stored = 1;
176
177 /* resolve */
Michal Vasko9e685082021-01-29 14:49:09 +0100178 rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, &node->node, tree, &val, &err);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200179 }
180
181 if (rc) {
Radek Krejci73dead22019-07-11 16:46:16 +0200182 if (err) {
183 if (ctx) {
Michal Vasko9e685082021-01-29 14:49:09 +0100184 LOG_LOCSET(NULL, &node->node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100185 LOGVAL(ctx, err->vecode, err->msg);
Radek Krejciddace2c2021-01-08 11:30:56 +0100186 LOG_LOCBACK(0, 1, 0, 0);
Radek Krejci084289f2019-07-09 17:35:30 +0200187 }
Radek Krejci73dead22019-07-11 16:46:16 +0200188 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200189 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200190 if (stored) {
191 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
192 }
Radek Krejci73dead22019-07-11 16:46:16 +0200193 return rc;
Radek Krejci084289f2019-07-09 17:35:30 +0200194 }
195
Michal Vasko3701af52020-08-03 14:29:38 +0200196 if (realtype) {
Michal Vasko29134f82020-11-13 18:03:20 +0100197 if (val.realtype->basetype == LY_TYPE_UNION) {
198 *realtype = val.subvalue->value.realtype;
199 } else {
200 *realtype = val.realtype;
201 }
Michal Vasko3701af52020-08-03 14:29:38 +0200202 }
203
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200204 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200205 return LY_SUCCESS;
206}
207
208API LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200209lyd_value_compare(const struct lyd_node_term *node, const char *value, size_t value_len)
Radek Krejci084289f2019-07-09 17:35:30 +0200210{
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200211 LY_ERR ret = LY_SUCCESS;
Radek Krejci084289f2019-07-09 17:35:30 +0200212 struct ly_ctx *ctx;
213 struct lysc_type *type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200214 struct lyd_value val = {0};
Radek Krejci084289f2019-07-09 17:35:30 +0200215
216 LY_CHECK_ARG_RET(node ? node->schema->module->ctx : NULL, node, value, LY_EINVAL);
217
218 ctx = node->schema->module->ctx;
Michal Vasko22df3f02020-08-24 13:29:22 +0200219 type = ((struct lysc_node_leaf *)node->schema)->type;
Radek Krejci084289f2019-07-09 17:35:30 +0200220
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200221 /* store the value */
Michal Vasko9e685082021-01-29 14:49:09 +0100222 LOG_LOCSET(node->schema, &node->node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100223 ret = lyd_value_store(ctx, &val, type, value, value_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, node->schema, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100224 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200225 LY_CHECK_RET(ret);
Radek Krejci084289f2019-07-09 17:35:30 +0200226
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200227 /* compare values */
228 ret = type->plugin->compare(&node->value, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200229
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200230 type->plugin->free(ctx, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200231 return ret;
232}
233
Radek Krejci19611252020-10-04 13:54:53 +0200234API ly_bool
235lyd_is_default(const struct lyd_node *node)
236{
237 const struct lysc_node_leaf *leaf;
238 const struct lysc_node_leaflist *llist;
239 const struct lyd_node_term *term;
240 LY_ARRAY_COUNT_TYPE u;
241
242 assert(node->schema->nodetype & LYD_NODE_TERM);
243 term = (const struct lyd_node_term *)node;
244
245 if (node->schema->nodetype == LYS_LEAF) {
246 leaf = (const struct lysc_node_leaf *)node->schema;
247 if (!leaf->dflt) {
248 return 0;
249 }
250
251 /* compare with the default value */
252 if (leaf->type->plugin->compare(&term->value, leaf->dflt)) {
253 return 0;
254 }
255 } else {
256 llist = (const struct lysc_node_leaflist *)node->schema;
257 if (!llist->dflts) {
258 return 0;
259 }
260
261 LY_ARRAY_FOR(llist->dflts, u) {
262 /* compare with each possible default value */
263 if (llist->type->plugin->compare(&term->value, llist->dflts[u])) {
264 return 0;
265 }
266 }
267 }
268
269 return 1;
270}
271
Radek Krejci7931b192020-06-25 17:05:03 +0200272static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +0200273lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +0200274{
Michal Vasko69730152020-10-09 16:30:07 +0200275 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200276 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +0200277 const char *path = in->method.fpath.filepath;
278 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +0200279
280 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +0200281 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +0200282
Radek Krejcif13b87b2020-12-01 22:02:17 +0100283 if ((len >= LY_XML_SUFFIX_LEN + 1) &&
284 !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200285 format = LYD_XML;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100286 } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
287 !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200288 format = LYD_JSON;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100289 } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
290 !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200291 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +0200292 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +0200293 }
294
Radek Krejci7931b192020-06-25 17:05:03 +0200295 return format;
296}
Radek Krejcie7b95092019-05-15 11:03:07 +0200297
Radek Krejci7931b192020-06-25 17:05:03 +0200298API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200299lyd_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 +0200300 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200301{
Radek Krejci1798aae2020-07-14 13:26:06 +0200302 LY_ERR ret = LY_SUCCESS;
303 struct lyd_ctx *lydctx = NULL;
304
Radek Krejci7931b192020-06-25 17:05:03 +0200305 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
306 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
307 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
308
309 format = lyd_parse_get_format(in, format);
310 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
311
Radek Krejci1798aae2020-07-14 13:26:06 +0200312 /* init */
313 *tree = NULL;
314
Michal Vasko63f3d842020-07-08 10:10:14 +0200315 /* remember input position */
316 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200317
318 switch (format) {
319 case LYD_XML:
Radek Krejci1798aae2020-07-14 13:26:06 +0200320 LY_CHECK_RET(lyd_parse_xml_data(ctx, in, parse_options, validate_options, tree, &lydctx));
321 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200322 case LYD_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +0200323 LY_CHECK_RET(lyd_parse_json_data(ctx, in, parse_options, validate_options, tree, &lydctx));
324 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200325 case LYD_LYB:
Radek Krejci1798aae2020-07-14 13:26:06 +0200326 LY_CHECK_RET(lyd_parse_lyb_data(ctx, in, parse_options, validate_options, tree, &lydctx));
327 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200328 case LYD_UNKNOWN:
Radek Krejci7931b192020-06-25 17:05:03 +0200329 LOGINT_RET(ctx);
330 }
331
Radek Krejci1798aae2020-07-14 13:26:06 +0200332 if (!(parse_options & LYD_PARSE_ONLY)) {
333 uint32_t i = 0;
334 const struct lys_module *mod;
335 struct lyd_node *first, *next, **first2;
Radek Krejci7931b192020-06-25 17:05:03 +0200336
Radek Krejci1798aae2020-07-14 13:26:06 +0200337 next = *tree;
338 while (1) {
339 if (validate_options & LYD_VALIDATE_PRESENT) {
340 mod = lyd_data_next_module(&next, &first);
341 } else {
342 mod = lyd_mod_next_module(next, NULL, ctx, &i, &first);
343 }
344 if (!mod) {
345 break;
346 }
Radek Krejcicc551802020-12-05 11:57:20 +0100347 if (!first || (first == *tree)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200348 /* make sure first2 changes are carried to tree */
349 first2 = tree;
350 } else {
351 first2 = &first;
352 }
353
354 /* validate new top-level nodes, autodelete CANNOT occur, all nodes are new */
355 LY_CHECK_GOTO(ret = lyd_validate_new(first2, NULL, mod, NULL), cleanup);
356
357 /* add all top-level defaults for this module */
Michal Vasko32711382020-12-03 14:14:31 +0100358 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, &lydctx->node_types, &lydctx->node_when,
Michal Vasko69730152020-10-09 16:30:07 +0200359 (validate_options & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200360 LY_CHECK_GOTO(ret, cleanup);
361
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100362 /* our first module node pointer may no longer be the first */
363 while (*first2 && (*first2)->prev->next && (lyd_owner_module(*first2) == lyd_owner_module((*first2)->prev))) {
364 *first2 = (*first2)->prev;
365 }
366
Radek Krejci1798aae2020-07-14 13:26:06 +0200367 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100368 ret = lyd_validate_unres(first2, mod, &lydctx->node_when, &lydctx->node_types, &lydctx->meta_types, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200369 LY_CHECK_GOTO(ret, cleanup);
370
371 /* perform final validation that assumes the data tree is final */
Michal Vaskobd4db892020-11-23 16:58:20 +0100372 LY_CHECK_GOTO(ret = lyd_validate_final_r(*first2, NULL, NULL, mod, validate_options, 0), cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +0200373 }
374 }
375
376cleanup:
Michal Vaskoafac7822020-10-20 14:22:26 +0200377 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200378 if (ret) {
379 lyd_free_all(*tree);
380 *tree = NULL;
381 }
382 return ret;
Radek Krejci7931b192020-06-25 17:05:03 +0200383}
384
385API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200386lyd_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 +0200387 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200388{
389 LY_ERR ret;
390 struct ly_in *in;
391
392 LY_CHECK_RET(ly_in_new_memory(data, &in));
393 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
394
395 ly_in_free(in, 0);
396 return ret;
397}
398
399API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200400lyd_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 +0200401 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200402{
403 LY_ERR ret;
404 struct ly_in *in;
405
406 LY_CHECK_RET(ly_in_new_fd(fd, &in));
407 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
408
409 ly_in_free(in, 0);
410 return ret;
411}
412
413API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200414lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
415 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200416{
417 LY_ERR ret;
418 struct ly_in *in;
419
420 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
421 ret = lyd_parse_data(ctx, in, format, parse_options, validate_options, tree);
422
423 ly_in_free(in, 0);
424 return ret;
425}
426
Radek Krejci7931b192020-06-25 17:05:03 +0200427API LY_ERR
428lyd_parse_rpc(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **op)
429{
430 LY_CHECK_ARG_RET(ctx, ctx, in, tree, LY_EINVAL);
431
432 format = lyd_parse_get_format(in, format);
433 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
434
Radek Krejci1798aae2020-07-14 13:26:06 +0200435 /* init */
436 *tree = NULL;
437 if (op) {
438 *op = NULL;
439 }
440
Michal Vasko63f3d842020-07-08 10:10:14 +0200441 /* remember input position */
442 in->func_start = in->current;
443
Radek Krejci7931b192020-06-25 17:05:03 +0200444 switch (format) {
445 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200446 return lyd_parse_xml_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200447 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200448 return lyd_parse_json_rpc(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200449 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200450 return lyd_parse_lyb_rpc(ctx, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200451 case LYD_UNKNOWN:
452 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200453 }
454
455 LOGINT_RET(ctx);
456}
457
458API LY_ERR
Michal Vasko2552ea32020-12-08 15:32:34 +0100459lyd_parse_reply(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree,
Radek Krejci0f969882020-08-21 16:56:47 +0200460 struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200461{
Michal Vasko2552ea32020-12-08 15:32:34 +0100462 LY_CHECK_ARG_RET(ctx, ctx, in, tree || op, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200463
464 format = lyd_parse_get_format(in, format);
Michal Vasko2552ea32020-12-08 15:32:34 +0100465 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200466
Radek Krejci1798aae2020-07-14 13:26:06 +0200467 /* init */
468 if (tree) {
469 *tree = NULL;
470 }
471 if (op) {
472 *op = NULL;
473 }
474
Michal Vasko63f3d842020-07-08 10:10:14 +0200475 /* remember input position */
476 in->func_start = in->current;
477
Radek Krejci7931b192020-06-25 17:05:03 +0200478 switch (format) {
479 case LYD_XML:
Michal Vasko2552ea32020-12-08 15:32:34 +0100480 return lyd_parse_xml_reply(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200481 case LYD_JSON:
Michal Vasko2552ea32020-12-08 15:32:34 +0100482 return lyd_parse_json_reply(ctx, in, tree, op);
Radek Krejci7931b192020-06-25 17:05:03 +0200483 case LYD_LYB:
Michal Vasko2552ea32020-12-08 15:32:34 +0100484 return lyd_parse_lyb_reply(ctx, in, tree, op);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200485 case LYD_UNKNOWN:
486 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200487 }
488
Michal Vasko2552ea32020-12-08 15:32:34 +0100489 LOGINT_RET(ctx);
Radek Krejci7931b192020-06-25 17:05:03 +0200490}
491
492API LY_ERR
493lyd_parse_notif(const struct ly_ctx *ctx, struct ly_in *in, LYD_FORMAT format, struct lyd_node **tree, struct lyd_node **ntf)
494{
Radek Krejci1798aae2020-07-14 13:26:06 +0200495 LY_CHECK_ARG_RET(ctx, ctx, in, tree || ntf, LY_EINVAL);
Radek Krejci7931b192020-06-25 17:05:03 +0200496
497 format = lyd_parse_get_format(in, format);
498 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
499
Radek Krejci1798aae2020-07-14 13:26:06 +0200500 /* init */
501 if (tree) {
502 *tree = NULL;
503 }
504 if (ntf) {
505 *ntf = NULL;
506 }
507
Michal Vasko63f3d842020-07-08 10:10:14 +0200508 /* remember input position */
509 in->func_start = in->current;
510
Radek Krejci7931b192020-06-25 17:05:03 +0200511 switch (format) {
512 case LYD_XML:
Michal Vasko63f3d842020-07-08 10:10:14 +0200513 return lyd_parse_xml_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200514 case LYD_JSON:
Michal Vasko63f3d842020-07-08 10:10:14 +0200515 return lyd_parse_json_notif(ctx, in, tree, ntf);
Radek Krejci7931b192020-06-25 17:05:03 +0200516 case LYD_LYB:
Michal Vasko63f3d842020-07-08 10:10:14 +0200517 return lyd_parse_lyb_notif(ctx, in, tree, ntf);
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200518 case LYD_UNKNOWN:
519 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200520 }
521
522 LOGINT_RET(ctx);
Radek Krejcie7b95092019-05-15 11:03:07 +0200523}
Radek Krejci084289f2019-07-09 17:35:30 +0200524
Michal Vasko90932a92020-02-12 14:33:03 +0100525LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200526lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
527 LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100528{
529 LY_ERR ret;
530 struct lyd_node_term *term;
531
Michal Vasko9b368d32020-02-14 13:53:31 +0100532 assert(schema->nodetype & LYD_NODE_TERM);
533
Michal Vasko90932a92020-02-12 14:33:03 +0100534 term = calloc(1, sizeof *term);
535 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
536
537 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100538 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100539 term->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100540
Radek Krejciddace2c2021-01-08 11:30:56 +0100541 LOG_LOCSET(schema, NULL, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200542 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
Radek Krejci2efc45b2020-12-22 16:25:44 +0100543 value_len, dynamic, format, prefix_data, hints, schema, incomplete);
Radek Krejciddace2c2021-01-08 11:30:56 +0100544 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200545 LY_CHECK_ERR_RET(ret, free(term), ret);
Michal Vasko9e685082021-01-29 14:49:09 +0100546 lyd_hash(&term->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100547
Michal Vasko9e685082021-01-29 14:49:09 +0100548 *node = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100549 return ret;
550}
551
552LY_ERR
553lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
554{
555 LY_ERR ret;
556 struct lyd_node_term *term;
557 struct lysc_type *type;
558
559 assert(schema->nodetype & LYD_NODE_TERM);
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200560 assert(val && val->canonical && val->realtype);
Michal Vasko9b368d32020-02-14 13:53:31 +0100561
562 term = calloc(1, sizeof *term);
563 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
564
565 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100566 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100567 term->flags = LYD_NEW;
568
569 type = ((struct lysc_node_leaf *)schema)->type;
570 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
571 if (ret) {
572 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
573 free(term);
574 return ret;
575 }
Michal Vasko9e685082021-01-29 14:49:09 +0100576 lyd_hash(&term->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100577
Michal Vasko9e685082021-01-29 14:49:09 +0100578 *node = &term->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100579 return ret;
580}
581
582LY_ERR
583lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
584{
585 struct lyd_node_inner *in;
586
Michal Vasko9b368d32020-02-14 13:53:31 +0100587 assert(schema->nodetype & LYD_NODE_INNER);
588
Michal Vasko90932a92020-02-12 14:33:03 +0100589 in = calloc(1, sizeof *in);
590 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
591
592 in->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100593 in->prev = &in->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100594 in->flags = LYD_NEW;
Michal Vasko3383be72020-11-03 17:15:31 +0100595 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
596 in->flags |= LYD_DEFAULT;
597 }
Michal Vasko90932a92020-02-12 14:33:03 +0100598
Michal Vasko9b368d32020-02-14 13:53:31 +0100599 /* do not hash list with keys, we need them for the hash */
600 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100601 lyd_hash(&in->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100602 }
Michal Vasko90932a92020-02-12 14:33:03 +0100603
Michal Vasko9e685082021-01-29 14:49:09 +0100604 *node = &in->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100605 return LY_SUCCESS;
606}
607
Michal Vasko90932a92020-02-12 14:33:03 +0100608LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +0200609lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100610{
611 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100612 struct lyd_node *list = NULL, *key;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200613 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100614
Michal Vasko004d3152020-06-11 19:59:22 +0200615 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
Michal Vasko90932a92020-02-12 14:33:03 +0100616
617 /* create list */
618 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
619
Radek Krejciddace2c2021-01-08 11:30:56 +0100620 LOG_LOCSET(NULL, list, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100621
Michal Vasko90932a92020-02-12 14:33:03 +0100622 /* create and insert all the keys */
Michal Vasko004d3152020-06-11 19:59:22 +0200623 LY_ARRAY_FOR(predicates, u) {
624 LY_CHECK_GOTO(ret = lyd_create_term2(predicates[u].key, &predicates[u].value, &key), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100625 lyd_insert_node(list, NULL, key);
626 }
627
Michal Vasko9b368d32020-02-14 13:53:31 +0100628 /* hash having all the keys */
629 lyd_hash(list);
630
Michal Vasko90932a92020-02-12 14:33:03 +0100631 /* success */
632 *node = list;
633 list = NULL;
634
635cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100636 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko90932a92020-02-12 14:33:03 +0100637 lyd_free_tree(list);
Michal Vasko004d3152020-06-11 19:59:22 +0200638 return ret;
639}
640
641static LY_ERR
642lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
643{
644 LY_ERR ret = LY_SUCCESS;
645 struct lyxp_expr *expr = NULL;
646 uint16_t exp_idx = 0;
647 enum ly_path_pred_type pred_type = 0;
648 struct ly_path_predicate *predicates = NULL;
649
Radek Krejciddace2c2021-01-08 11:30:56 +0100650 LOG_LOCSET(schema, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100651
Michal Vasko004d3152020-06-11 19:59:22 +0200652 /* parse keys */
Michal Vasko6b26e742020-07-17 15:02:10 +0200653 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 +0200654 LY_PATH_PRED_KEYS, &expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200655
656 /* compile them */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200657 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_PREF_JSON,
658 NULL, &predicates, &pred_type), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200659
660 /* create the list node */
661 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, node), cleanup);
662
663cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100664 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200665 lyxp_expr_free(schema->module->ctx, expr);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200666 ly_path_predicates_free(schema->module->ctx, pred_type, predicates);
Michal Vasko90932a92020-02-12 14:33:03 +0100667 return ret;
668}
669
670LY_ERR
Michal Vasko366a4a12020-12-04 16:23:57 +0100671lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, ly_bool use_value,
672 struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100673{
Michal Vasko366a4a12020-12-04 16:23:57 +0100674 LY_ERR ret;
Michal Vasko90932a92020-02-12 14:33:03 +0100675 struct lyd_node_any *any;
Michal Vasko366a4a12020-12-04 16:23:57 +0100676 union lyd_any_value any_val;
Michal Vasko90932a92020-02-12 14:33:03 +0100677
Michal Vasko9b368d32020-02-14 13:53:31 +0100678 assert(schema->nodetype & LYD_NODE_ANY);
679
Michal Vasko90932a92020-02-12 14:33:03 +0100680 any = calloc(1, sizeof *any);
681 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
682
683 any->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100684 any->prev = &any->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100685 any->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100686
Radek Krejci1798aae2020-07-14 13:26:06 +0200687 /* TODO: convert XML/JSON strings into a opaq data tree */
Michal Vasko366a4a12020-12-04 16:23:57 +0100688
689 if (use_value) {
690 any->value.str = value;
691 any->value_type = value_type;
692 } else {
693 any_val.str = value;
Michal Vasko9e685082021-01-29 14:49:09 +0100694 ret = lyd_any_copy_value(&any->node, &any_val, value_type);
Michal Vasko366a4a12020-12-04 16:23:57 +0100695 LY_CHECK_ERR_RET(ret, free(any), ret);
696 }
Michal Vasko9e685082021-01-29 14:49:09 +0100697 lyd_hash(&any->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100698
Michal Vasko9e685082021-01-29 14:49:09 +0100699 *node = &any->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100700 return LY_SUCCESS;
701}
702
Michal Vasko52927e22020-03-16 17:26:14 +0100703LY_ERR
Michal Vasko501af032020-11-11 20:27:44 +0100704lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t pref_len,
705 const char *module_key, size_t module_key_len, const char *value, size_t value_len, ly_bool *dynamic,
706 LY_PREFIX_FORMAT format, void *val_prefix_data, uint32_t hints, struct lyd_node **node)
Michal Vasko52927e22020-03-16 17:26:14 +0100707{
Radek Krejci011e4aa2020-09-04 15:22:31 +0200708 LY_ERR ret = LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +0100709 struct lyd_node_opaq *opaq;
710
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200711 assert(ctx && name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +0100712
713 if (!value_len) {
714 value = "";
715 }
716
717 opaq = calloc(1, sizeof *opaq);
Michal Vasko501af032020-11-11 20:27:44 +0100718 LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100719
Michal Vasko9e685082021-01-29 14:49:09 +0100720 opaq->prev = &opaq->node;
Michal Vaskoad92b672020-11-12 13:11:31 +0100721 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200722
Michal Vasko52927e22020-03-16 17:26:14 +0100723 if (pref_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100724 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->name.prefix), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100725 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200726 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100727 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->name.module_ns), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +0200728 }
Michal Vasko52927e22020-03-16 17:26:14 +0100729 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200730 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100731 *dynamic = 0;
732 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200733 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100734 }
Michal Vasko501af032020-11-11 20:27:44 +0100735
736 opaq->format = format;
737 opaq->val_prefix_data = val_prefix_data;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200738 opaq->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +0100739 opaq->ctx = ctx;
740
Radek Krejci011e4aa2020-09-04 15:22:31 +0200741finish:
742 if (ret) {
Michal Vasko9e685082021-01-29 14:49:09 +0100743 lyd_free_tree(&opaq->node);
Michal Vasko501af032020-11-11 20:27:44 +0100744 ly_free_prefix_data(format, val_prefix_data);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200745 } else {
Michal Vasko9e685082021-01-29 14:49:09 +0100746 *node = &opaq->node;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200747 }
748 return ret;
Michal Vasko52927e22020-03-16 17:26:14 +0100749}
750
Michal Vasko3a41dff2020-07-15 14:30:28 +0200751API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100752lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
753 struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100754{
755 struct lyd_node *ret = NULL;
756 const struct lysc_node *schema;
757 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
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
Michal Vasko3a41dff2020-07-15 14:30:28 +0200765 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
Radek Krejci41ac9942020-11-02 14:47:56 +0100766 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200767 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 +0100768
Michal Vasko3a41dff2020-07-15 14:30:28 +0200769 LY_CHECK_RET(lyd_create_inner(schema, &ret));
770 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100771 lyd_insert_node(parent, NULL, ret);
772 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200773
774 if (node) {
775 *node = ret;
776 }
777 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100778}
779
Michal Vasko3a41dff2020-07-15 14:30:28 +0200780API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100781lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
782 struct lyd_node **node, ...)
Michal Vasko013a8182020-03-03 10:46:53 +0100783{
784 struct lyd_node *ret = NULL, *key;
785 const struct lysc_node *schema, *key_s;
786 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
787 va_list ap;
788 const char *key_val;
789 LY_ERR rc = LY_SUCCESS;
790
Michal Vasko6027eb92020-07-15 16:37:30 +0200791 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100792
Michal Vaskof03ed032020-03-04 13:31:44 +0100793 if (!module) {
794 module = parent->schema->module;
795 }
796
Radek Krejci41ac9942020-11-02 14:47:56 +0100797 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 +0200798 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100799
800 /* create list inner node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200801 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko013a8182020-03-03 10:46:53 +0100802
Michal Vasko3a41dff2020-07-15 14:30:28 +0200803 va_start(ap, node);
Michal Vasko013a8182020-03-03 10:46:53 +0100804
805 /* create and insert all the keys */
Michal Vasko544e58a2021-01-28 14:33:41 +0100806 for (key_s = lysc_node_child(schema); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
Michal Vasko013a8182020-03-03 10:46:53 +0100807 key_val = va_arg(ap, const char *);
808
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200809 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
810 NULL, &key);
811 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko013a8182020-03-03 10:46:53 +0100812 lyd_insert_node(ret, NULL, key);
813 }
814
Michal Vasko013a8182020-03-03 10:46:53 +0100815 if (parent) {
816 lyd_insert_node(parent, NULL, ret);
817 }
818
819cleanup:
Michal Vasko3a41dff2020-07-15 14:30:28 +0200820 va_end(ap);
Michal Vasko013a8182020-03-03 10:46:53 +0100821 if (rc) {
822 lyd_free_tree(ret);
823 ret = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200824 } else if (node) {
825 *node = ret;
Michal Vasko013a8182020-03-03 10:46:53 +0100826 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200827 return rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100828}
829
Michal Vasko3a41dff2020-07-15 14:30:28 +0200830API LY_ERR
831lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
Radek Krejci41ac9942020-11-02 14:47:56 +0100832 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100833{
834 struct lyd_node *ret = NULL;
835 const struct lysc_node *schema;
836 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
837
Michal Vasko6027eb92020-07-15 16:37:30 +0200838 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100839
Michal Vaskof03ed032020-03-04 13:31:44 +0100840 if (!module) {
841 module = parent->schema->module;
842 }
Michal Vasko004d3152020-06-11 19:59:22 +0200843 if (!keys) {
844 keys = "";
845 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100846
Michal Vasko004d3152020-06-11 19:59:22 +0200847 /* find schema node */
Radek Krejci41ac9942020-11-02 14:47:56 +0100848 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 +0200849 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100850
Michal Vasko004d3152020-06-11 19:59:22 +0200851 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
852 /* key-less list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200853 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200854 } else {
855 /* create the list node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200856 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200857 }
Michal Vasko004d3152020-06-11 19:59:22 +0200858 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100859 lyd_insert_node(parent, NULL, ret);
860 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200861
862 if (node) {
863 *node = ret;
864 }
865 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100866}
867
Michal Vasko3a41dff2020-07-15 14:30:28 +0200868API LY_ERR
869lyd_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 +0100870 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100871{
Michal Vaskocbff3e92020-05-27 12:56:41 +0200872 LY_ERR rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100873 struct lyd_node *ret = NULL;
874 const struct lysc_node *schema;
875 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
876
Michal Vasko6027eb92020-07-15 16:37:30 +0200877 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100878
Michal Vaskof03ed032020-03-04 13:31:44 +0100879 if (!module) {
880 module = parent->schema->module;
881 }
882
Radek Krejci41ac9942020-11-02 14:47:56 +0100883 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 +0200884 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100885
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200886 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL,
887 &ret);
888 LY_CHECK_RET(rc);
Michal Vaskocbff3e92020-05-27 12:56:41 +0200889 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100890 lyd_insert_node(parent, NULL, ret);
891 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200892
893 if (node) {
894 *node = ret;
895 }
896 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100897}
898
Michal Vasko3a41dff2020-07-15 14:30:28 +0200899API LY_ERR
Michal Vasko219006c2020-12-04 16:26:52 +0100900lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, void *value,
Radek Krejci41ac9942020-11-02 14:47:56 +0100901 LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100902{
903 struct lyd_node *ret = NULL;
904 const struct lysc_node *schema;
905 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
906
Michal Vasko6027eb92020-07-15 16:37:30 +0200907 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100908
Michal Vaskof03ed032020-03-04 13:31:44 +0100909 if (!module) {
910 module = parent->schema->module;
911 }
912
Radek Krejci41ac9942020-11-02 14:47:56 +0100913 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 +0200914 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100915
Michal Vasko366a4a12020-12-04 16:23:57 +0100916 LY_CHECK_RET(lyd_create_any(schema, value, value_type, 1, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200917 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100918 lyd_insert_node(parent, NULL, ret);
919 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200920
921 if (node) {
922 *node = ret;
923 }
924 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100925}
926
Michal Vasko4490d312020-06-16 13:08:55 +0200927/**
928 * @brief Update node value.
929 *
930 * @param[in] node Node to update.
931 * @param[in] value New value to set.
932 * @param[in] value_type Type of @p value for any node.
933 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
934 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
935 * @return LY_ERR value.
936 */
Michal Vasko00cbf532020-06-15 13:58:47 +0200937static LY_ERR
938lyd_new_path_update(struct lyd_node *node, const void *value, LYD_ANYDATA_VALUETYPE value_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200939 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +0200940{
941 LY_ERR ret = LY_SUCCESS;
942 struct lyd_node *new_any;
943
944 switch (node->schema->nodetype) {
945 case LYS_CONTAINER:
946 case LYS_NOTIF:
947 case LYS_RPC:
948 case LYS_ACTION:
949 case LYS_LIST:
950 case LYS_LEAFLIST:
951 /* if it exists, there is nothing to update */
952 *new_parent = NULL;
953 *new_node = NULL;
954 break;
955 case LYS_LEAF:
956 ret = lyd_change_term(node, value);
957 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
958 /* there was an actual change (at least of the default flag) */
959 *new_parent = node;
960 *new_node = node;
961 ret = LY_SUCCESS;
962 } else if (ret == LY_ENOT) {
963 /* no change */
964 *new_parent = NULL;
965 *new_node = NULL;
966 ret = LY_SUCCESS;
967 } /* else error */
968 break;
969 case LYS_ANYDATA:
970 case LYS_ANYXML:
971 /* create a new any node */
Michal Vasko366a4a12020-12-04 16:23:57 +0100972 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, 0, &new_any));
Michal Vasko00cbf532020-06-15 13:58:47 +0200973
974 /* compare with the existing one */
Michal Vasko8f359bf2020-07-28 10:41:15 +0200975 if (lyd_compare_single(node, new_any, 0)) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200976 /* not equal, switch values (so that we can use generic node free) */
977 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
978 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
979 ((struct lyd_node_any *)node)->value.str = value;
980 ((struct lyd_node_any *)node)->value_type = value_type;
981
982 *new_parent = node;
983 *new_node = node;
984 } else {
985 /* they are equal */
986 *new_parent = NULL;
987 *new_node = NULL;
988 }
989 lyd_free_tree(new_any);
990 break;
991 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +0200992 LOGINT(LYD_CTX(node));
Michal Vasko00cbf532020-06-15 13:58:47 +0200993 ret = LY_EINT;
994 break;
995 }
996
997 return ret;
998}
999
Michal Vasko3a41dff2020-07-15 14:30:28 +02001000API LY_ERR
Michal Vasko871a0252020-11-11 18:35:24 +01001001lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module, const char *name,
1002 const char *val_str, ly_bool clear_dflt, struct lyd_meta **meta)
Michal Vaskod86997b2020-05-26 15:19:54 +02001003{
Michal Vaskod86997b2020-05-26 15:19:54 +02001004 const char *prefix, *tmp;
Michal Vaskod86997b2020-05-26 15:19:54 +02001005 size_t pref_len, name_len;
1006
Michal Vasko871a0252020-11-11 18:35:24 +01001007 LY_CHECK_ARG_RET(NULL, ctx, name, module || strchr(name, ':'), parent || meta, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001008
Michal Vasko871a0252020-11-11 18:35:24 +01001009 if (parent && !parent->schema) {
1010 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1011 return LY_EINVAL;
1012 }
Michal Vasko610553d2020-11-18 18:15:05 +01001013 if (meta) {
1014 *meta = NULL;
1015 }
Michal Vaskod86997b2020-05-26 15:19:54 +02001016
1017 /* parse the name */
1018 tmp = name;
1019 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1020 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko871a0252020-11-11 18:35:24 +01001021 return LY_EINVAL;
Michal Vaskod86997b2020-05-26 15:19:54 +02001022 }
1023
1024 /* find the module */
1025 if (prefix) {
Radek Krejci0ad51f12020-07-16 12:08:12 +02001026 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001027 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 +02001028 }
1029
1030 /* set value if none */
1031 if (!val_str) {
1032 val_str = "";
1033 }
1034
Michal Vasko871a0252020-11-11 18:35:24 +01001035 return lyd_create_meta(parent, meta, module, name, name_len, val_str, strlen(val_str), NULL, LY_PREF_JSON,
1036 NULL, LYD_HINT_DATA, clear_dflt, NULL);
1037}
Michal Vasko3a41dff2020-07-15 14:30:28 +02001038
Michal Vaskoba696702020-11-11 19:12:45 +01001039API LY_ERR
1040lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, ly_bool clear_dflt, const struct lyd_attr *attr,
1041 struct lyd_meta **meta)
1042{
1043 const struct lys_module *mod;
1044
1045 LY_CHECK_ARG_RET(NULL, ctx, attr, parent || meta, LY_EINVAL);
1046
1047 if (parent && !parent->schema) {
1048 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1049 return LY_EINVAL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001050 }
Michal Vasko610553d2020-11-18 18:15:05 +01001051 if (meta) {
1052 *meta = NULL;
1053 }
Michal Vaskoba696702020-11-11 19:12:45 +01001054
1055 switch (attr->format) {
1056 case LY_PREF_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +01001057 mod = ly_ctx_get_module_implemented_ns(ctx, attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001058 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001059 LOGERR(ctx, LY_EINVAL, "Module with namespace \"%s\" not found.", attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001060 return LY_ENOTFOUND;
1061 }
1062 break;
1063 case LY_PREF_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +01001064 mod = ly_ctx_get_module_implemented(ctx, attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001065 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001066 LOGERR(ctx, LY_EINVAL, "Module \"%s\" not found.", attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001067 return LY_ENOTFOUND;
1068 }
1069 break;
1070 default:
1071 LOGINT_RET(ctx);
1072 }
1073
Michal Vaskoad92b672020-11-12 13:11:31 +01001074 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 +01001075 NULL, attr->format, attr->val_prefix_data, attr->hints, clear_dflt, NULL);
Michal Vaskod86997b2020-05-26 15:19:54 +02001076}
1077
Michal Vasko3a41dff2020-07-15 14:30:28 +02001078API LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +02001079lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Radek Krejci0f969882020-08-21 16:56:47 +02001080 const char *module_name, struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001081{
1082 struct lyd_node *ret = NULL;
1083
Michal Vasko6027eb92020-07-15 16:37:30 +02001084 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001085
1086 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001087 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001088 }
1089 if (!value) {
1090 value = "";
1091 }
1092
Michal Vasko501af032020-11-11 20:27:44 +01001093 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), NULL, 0, module_name, strlen(module_name), value,
1094 strlen(value), NULL, LY_PREF_JSON, NULL, 0, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001095 if (parent) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001096 lyd_insert_node(parent, NULL, ret);
1097 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001098
1099 if (node) {
1100 *node = ret;
1101 }
1102 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001103}
1104
Michal Vasko3a41dff2020-07-15 14:30:28 +02001105API LY_ERR
1106lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *val_str,
Radek Krejci0f969882020-08-21 16:56:47 +02001107 struct lyd_attr **attr)
Michal Vasko00cbf532020-06-15 13:58:47 +02001108{
Radek Krejci1798aae2020-07-14 13:26:06 +02001109 struct lyd_attr *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02001110 const struct ly_ctx *ctx;
1111 const char *prefix, *tmp;
Michal Vasko51d21b82020-11-13 18:03:54 +01001112 size_t pref_len, name_len, mod_len;
Michal Vasko00cbf532020-06-15 13:58:47 +02001113
Michal Vasko3a41dff2020-07-15 14:30:28 +02001114 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001115
Michal Vaskob7be7a82020-08-20 09:09:04 +02001116 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001117
1118 /* parse the name */
1119 tmp = name;
1120 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1121 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001122 return LY_EVALID;
Michal Vasko00cbf532020-06-15 13:58:47 +02001123 }
1124
Michal Vasko51d21b82020-11-13 18:03:54 +01001125 /* get the module */
1126 if (module_name) {
1127 mod_len = strlen(module_name);
1128 } else {
1129 module_name = prefix;
1130 mod_len = pref_len;
1131 }
1132
Michal Vasko00cbf532020-06-15 13:58:47 +02001133 /* set value if none */
1134 if (!val_str) {
1135 val_str = "";
1136 }
1137
Michal Vasko51d21b82020-11-13 18:03:54 +01001138 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_name, mod_len, val_str,
1139 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001140
1141 if (attr) {
1142 *attr = ret;
1143 }
1144 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001145}
1146
1147API LY_ERR
1148lyd_change_term(struct lyd_node *term, const char *val_str)
1149{
1150 LY_ERR ret = LY_SUCCESS;
1151 struct lysc_type *type;
1152 struct lyd_node_term *t;
1153 struct lyd_node *parent;
1154 struct lyd_value val = {0};
Radek Krejci857189e2020-09-01 13:26:36 +02001155 ly_bool dflt_change, val_change;
Michal Vasko00cbf532020-06-15 13:58:47 +02001156
1157 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1158
1159 if (!val_str) {
1160 val_str = "";
1161 }
1162 t = (struct lyd_node_term *)term;
1163 type = ((struct lysc_node_leaf *)term->schema)->type;
1164
1165 /* parse the new value */
Radek Krejciddace2c2021-01-08 11:30:56 +01001166 LOG_LOCSET(term->schema, term, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001167 ret = lyd_value_store(LYD_CTX(term), &val, type, val_str, strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
Radek Krejci2efc45b2020-12-22 16:25:44 +01001168 term->schema, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001169 LOG_LOCBACK(term->schema ? 1 : 0, 1, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001170 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001171
1172 /* compare original and new value */
1173 if (type->plugin->compare(&t->value, &val)) {
1174 /* values differ, switch them */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001175 type->plugin->free(LYD_CTX(term), &t->value);
Michal Vasko00cbf532020-06-15 13:58:47 +02001176 t->value = val;
1177 memset(&val, 0, sizeof val);
1178 val_change = 1;
1179 } else {
1180 val_change = 0;
1181 }
1182
1183 /* always clear the default flag */
1184 if (term->flags & LYD_DEFAULT) {
Michal Vasko9e685082021-01-29 14:49:09 +01001185 for (parent = term; parent; parent = lyd_parent(parent)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001186 parent->flags &= ~LYD_DEFAULT;
1187 }
1188 dflt_change = 1;
1189 } else {
1190 dflt_change = 0;
1191 }
1192
1193 if (val_change || dflt_change) {
1194 /* make the node non-validated */
1195 term->flags &= LYD_NEW;
1196 }
1197
1198 if (val_change) {
1199 if (term->schema->nodetype == LYS_LEAFLIST) {
1200 /* leaf-list needs to be hashed again and re-inserted into parent */
1201 lyd_unlink_hash(term);
1202 lyd_hash(term);
1203 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1204 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1205 /* list needs to be updated if its key was changed */
1206 assert(term->parent->schema->nodetype == LYS_LIST);
Michal Vasko9e685082021-01-29 14:49:09 +01001207 lyd_unlink_hash(lyd_parent(term));
1208 lyd_hash(lyd_parent(term));
1209 LY_CHECK_GOTO(ret = lyd_insert_hash(lyd_parent(term)), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001210 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1211 }
1212
1213 /* retrun value */
1214 if (!val_change) {
1215 if (dflt_change) {
1216 /* only default flag change */
1217 ret = LY_EEXIST;
1218 } else {
1219 /* no change */
1220 ret = LY_ENOT;
1221 }
1222 } /* else value changed, LY_SUCCESS */
1223
1224cleanup:
Michal Vasko59512fc2020-12-09 18:13:29 +01001225 if (val.realtype) {
1226 type->plugin->free(LYD_CTX(term), &val);
1227 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001228 return ret;
1229}
1230
Michal Vasko41586352020-07-13 13:54:25 +02001231API LY_ERR
1232lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1233{
1234 LY_ERR ret = LY_SUCCESS;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001235 struct lyd_meta *m2 = NULL;
Michal Vasko41586352020-07-13 13:54:25 +02001236 struct lyd_value val;
Radek Krejci857189e2020-09-01 13:26:36 +02001237 ly_bool val_change;
Michal Vasko41586352020-07-13 13:54:25 +02001238
1239 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1240
1241 if (!val_str) {
1242 val_str = "";
1243 }
1244
1245 /* parse the new value into a new meta structure */
1246 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 +01001247 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, 0, NULL), cleanup);
Michal Vasko41586352020-07-13 13:54:25 +02001248
1249 /* compare original and new value */
1250 if (lyd_compare_meta(meta, m2)) {
1251 /* values differ, switch them */
1252 val = meta->value;
1253 meta->value = m2->value;
1254 m2->value = val;
1255 val_change = 1;
1256 } else {
1257 val_change = 0;
1258 }
1259
1260 /* retrun value */
1261 if (!val_change) {
1262 /* no change */
1263 ret = LY_ENOT;
1264 } /* else value changed, LY_SUCCESS */
1265
1266cleanup:
Michal Vasko1a66a5d2020-11-18 18:15:37 +01001267 lyd_free_meta_single(m2);
Michal Vasko41586352020-07-13 13:54:25 +02001268 return ret;
1269}
1270
Michal Vasko3a41dff2020-07-15 14:30:28 +02001271API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001272lyd_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 +02001273 struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001274{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001275 return lyd_new_path2(parent, ctx, path, value, 0, options, node, NULL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001276}
1277
Michal Vasko6741dc62021-02-04 09:27:45 +01001278static LY_ERR
1279lyd_new_path_check_find_lypath(struct ly_path *path, const char *str_path, const char *value, uint32_t options)
1280{
1281 LY_ERR ret = LY_SUCCESS, r;
1282 const struct lysc_node *schema;
1283 struct ly_path_predicate *pred;
1284 LY_ARRAY_COUNT_TYPE u, last_u;
1285
1286 assert(path);
1287
1288 /* go through all the compiled nodes */
1289 LY_ARRAY_FOR(path, u) {
1290 schema = path[u].node;
1291 last_u = u;
1292 if ((schema->nodetype == LYS_LIST) && (path[u].pred_type == LY_PATH_PREDTYPE_NONE)) {
1293 if (schema->flags & LYS_KEYLESS) {
1294 /* creating a new keyless list instance */
1295 break;
1296 } else if ((u < LY_ARRAY_COUNT(path) - 1) || !(options & LYD_NEW_PATH_OPAQ)) {
1297 LOG_LOCSET(schema, NULL, NULL, NULL);
1298 LOGVAL(schema->module->ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1299 lys_nodetype2str(schema->nodetype), schema->name, str_path);
1300 LOG_LOCBACK(1, 0, 0, 0);
1301 return LY_EINVAL;
1302 } /* else creating an opaque list without keys */
1303 }
1304 }
1305
1306 if ((schema->nodetype == LYS_LEAFLIST) && (path[last_u].pred_type == LY_PATH_PREDTYPE_NONE)) {
1307 /* parse leafref value into a predicate, if not defined in the path */
1308 if (!value) {
1309 value = "";
1310 }
1311
1312 r = LY_SUCCESS;
1313 if (options & LYD_NEW_PATH_OPAQ) {
1314 r = lys_value_validate(NULL, schema, value, strlen(value));
1315 }
1316 if (!r) {
1317 /* store the new predicate */
1318 path[last_u].pred_type = LY_PATH_PREDTYPE_LEAFLIST;
1319 LY_ARRAY_NEW_GOTO(schema->module->ctx, path[last_u].predicates, pred, ret, cleanup);
1320
1321 ret = lyd_value_store(schema->module->ctx, &pred->value, ((struct lysc_node_leaflist *)schema)->type, value,
1322 strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, schema, NULL);
1323 LY_CHECK_GOTO(ret, cleanup);
1324 ++((struct lysc_type *)pred->value.realtype)->refcount;
1325
1326 if (schema->flags & LYS_CONFIG_R) {
1327 /* creating a new state leaf-list instance */
1328 --last_u;
1329 }
1330 } /* else we have opaq flag and the value is not valid, leave no predicate and then create an opaque node */
1331 }
1332
1333 /* hide the nodes that should always be created so they are not found */
1334 while (last_u + 1 < LY_ARRAY_COUNT(path)) {
1335 LY_ARRAY_DECREMENT(path);
1336 }
1337
1338cleanup:
1339 return ret;
1340}
1341
Michal Vasko00cbf532020-06-15 13:58:47 +02001342API LY_ERR
1343lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001344 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 +02001345{
1346 LY_ERR ret = LY_SUCCESS, r;
1347 struct lyxp_expr *exp = NULL;
1348 struct ly_path *p = NULL;
1349 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1350 const struct lysc_node *schema;
Michal Vasko6741dc62021-02-04 09:27:45 +01001351 LY_ARRAY_COUNT_TYPE path_idx = 0, orig_count;
Michal Vasko00cbf532020-06-15 13:58:47 +02001352
1353 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1354
1355 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001356 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001357 }
1358
1359 /* parse path */
Michal Vasko6b26e742020-07-17 15:02:10 +02001360 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 +02001361 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001362
1363 /* compile path */
1364 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 +02001365 options & LYD_NEW_PATH_OUTPUT ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY, LY_PREF_JSON,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001366 NULL, NULL, &p), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001367
Michal Vasko6741dc62021-02-04 09:27:45 +01001368 /* check the compiled path before searching existing nodes, it may be shortened */
1369 orig_count = LY_ARRAY_COUNT(p);
1370 LY_CHECK_GOTO(ret = lyd_new_path_check_find_lypath(p, path, value, options), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001371
1372 /* try to find any existing nodes in the path */
1373 if (parent) {
1374 ret = ly_path_eval_partial(p, parent, &path_idx, &node);
1375 if (ret == LY_SUCCESS) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001376 if (orig_count == LY_ARRAY_COUNT(p)) {
1377 /* the node exists, are we supposed to update it or is it just a default? */
1378 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
1379 LOG_LOCSET(NULL, node, NULL, NULL);
1380 LOGVAL(ctx, LYVE_REFERENCE, "Path \"%s\" already exists", path);
1381 LOG_LOCBACK(0, 1, 0, 0);
1382 ret = LY_EEXIST;
1383 goto cleanup;
1384 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001385
Michal Vasko6741dc62021-02-04 09:27:45 +01001386 /* update the existing node */
1387 ret = lyd_new_path_update(node, value, value_type, &nparent, &nnode);
1388 goto cleanup;
1389 } /* else we were not searching for the whole path */
Michal Vasko00cbf532020-06-15 13:58:47 +02001390 } else if (ret == LY_EINCOMPLETE) {
1391 /* some nodes were found, adjust the iterator to the next segment */
1392 ++path_idx;
1393 } else if (ret == LY_ENOTFOUND) {
1394 /* 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 +01001395 if (lysc_data_parent(p[0].node)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001396 node = parent;
1397 }
1398 } else {
1399 /* error */
1400 goto cleanup;
1401 }
1402 }
1403
Michal Vasko6741dc62021-02-04 09:27:45 +01001404 /* restore the full path for creating new nodes */
1405 while (orig_count > LY_ARRAY_COUNT(p)) {
1406 LY_ARRAY_INCREMENT(p);
1407 }
1408
Michal Vasko00cbf532020-06-15 13:58:47 +02001409 /* create all the non-existing nodes in a loop */
Michal Vaskod989ba02020-08-24 10:59:24 +02001410 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001411 cur_parent = node;
1412 schema = p[path_idx].node;
1413
1414 switch (schema->nodetype) {
1415 case LYS_LIST:
1416 if (!(schema->flags & LYS_KEYLESS)) {
Radek Krejci092e33c2020-10-12 15:33:10 +02001417 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001418 /* creating opaque list without keys */
Michal Vasko501af032020-11-11 20:27:44 +01001419 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1420 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1421 LYD_NODEHINT_LIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001422 } else {
Michal Vasko8b776962021-01-12 12:21:49 +01001423 if (p[path_idx].pred_type != LY_PATH_PREDTYPE_LIST) {
1424 LOG_LOCSET(schema, NULL, NULL, NULL);
1425 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1426 lys_nodetype2str(schema->nodetype), schema->name, path);
1427 LOG_LOCBACK(1, 0, 0, 0);
1428 ret = LY_EINVAL;
1429 goto cleanup;
1430 }
1431
Michal Vasko00cbf532020-06-15 13:58:47 +02001432 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, &node), cleanup);
1433 }
1434 break;
1435 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001436 /* fall through */
Michal Vasko00cbf532020-06-15 13:58:47 +02001437 case LYS_CONTAINER:
1438 case LYS_NOTIF:
1439 case LYS_RPC:
1440 case LYS_ACTION:
1441 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1442 break;
1443 case LYS_LEAFLIST:
Radek Krejci092e33c2020-10-12 15:33:10 +02001444 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001445 /* creating opaque leaf-list without value */
Michal Vasko501af032020-11-11 20:27:44 +01001446 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1447 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1448 LYD_NODEHINT_LEAFLIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001449 } else {
1450 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LEAFLIST);
1451 LY_CHECK_GOTO(ret = lyd_create_term2(schema, &p[path_idx].predicates[0].value, &node), cleanup);
1452 }
1453 break;
1454 case LYS_LEAF:
Michal Vasko35880332020-12-08 13:08:12 +01001455 if (lysc_is_key(schema)) {
1456 /* it must have been already created or some error will occur later */
1457 assert(cur_parent);
1458 node = lyd_child(cur_parent);
1459 assert(node && (node->schema == schema));
1460 goto next_iter;
1461 }
1462
1463 /* make sure there is some value */
Michal Vasko00cbf532020-06-15 13:58:47 +02001464 if (!value) {
1465 value = "";
1466 }
1467
1468 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001469 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001470 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001471 }
1472 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001473 ret = lyd_create_term(schema, value, strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &node);
1474 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001475 } else {
1476 /* creating opaque leaf without value */
Michal Vasko501af032020-11-11 20:27:44 +01001477 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, schema->module->name,
1478 strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001479 }
1480 break;
1481 case LYS_ANYDATA:
1482 case LYS_ANYXML:
Michal Vasko366a4a12020-12-04 16:23:57 +01001483 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001484 break;
1485 default:
1486 LOGINT(ctx);
1487 ret = LY_EINT;
1488 goto cleanup;
1489 }
1490
1491 if (cur_parent) {
1492 /* connect to the parent */
1493 lyd_insert_node(cur_parent, NULL, node);
1494 } else if (parent) {
1495 /* connect to top-level siblings */
1496 lyd_insert_node(NULL, &parent, node);
1497 }
1498
Michal Vasko35880332020-12-08 13:08:12 +01001499next_iter:
Michal Vasko00cbf532020-06-15 13:58:47 +02001500 /* update remembered nodes */
1501 if (!nparent) {
1502 nparent = node;
1503 }
1504 nnode = node;
1505 }
1506
1507cleanup:
1508 lyxp_expr_free(ctx, exp);
Michal Vasko6741dc62021-02-04 09:27:45 +01001509 if (p) {
1510 while (orig_count > LY_ARRAY_COUNT(p)) {
1511 LY_ARRAY_INCREMENT(p);
1512 }
1513 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001514 ly_path_free(ctx, p);
1515 if (!ret) {
1516 /* set out params only on success */
1517 if (new_parent) {
1518 *new_parent = nparent;
1519 }
1520 if (new_node) {
1521 *new_node = nnode;
1522 }
Michal Vaskof4b95ba2020-12-11 08:42:33 +01001523 } else {
1524 lyd_free_tree(nparent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001525 }
1526 return ret;
1527}
1528
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001529LY_ERR
1530lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001531 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 +02001532 struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001533{
1534 LY_ERR ret;
Michal Vaskod1e53b92021-01-28 13:11:06 +01001535 const struct lysc_node *iter = NULL;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001536 struct lyd_node *node = NULL;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001537 struct lyd_value **dflts;
1538 LY_ARRAY_COUNT_TYPE u;
Michal Vasko630d9892020-12-08 17:11:08 +01001539 uint32_t getnext_opts;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001540
1541 assert(first && (parent || sparent || mod));
1542
1543 if (!sparent && parent) {
1544 sparent = parent->schema;
1545 }
1546
Michal Vasko630d9892020-12-08 17:11:08 +01001547 getnext_opts = LYS_GETNEXT_WITHCHOICE;
1548 if (impl_opts & LYD_IMPLICIT_OUTPUT) {
1549 getnext_opts |= LYS_GETNEXT_OUTPUT;
1550 }
1551
1552 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, getnext_opts))) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001553 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1554 continue;
Michal Vasko44b19a12020-08-07 09:21:30 +02001555 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1556 continue;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001557 }
1558
1559 switch (iter->nodetype) {
1560 case LYS_CHOICE:
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001561 node = lys_getnext_data(NULL, *first, NULL, iter, NULL);
1562 if (!node && ((struct lysc_node_choice *)iter)->dflt) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001563 /* create default case data */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001564 LY_CHECK_RET(lyd_new_implicit_r(parent, first, &((struct lysc_node_choice *)iter)->dflt->node,
Michal Vasko69730152020-10-09 16:30:07 +02001565 NULL, node_types, node_when, impl_opts, diff));
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001566 } else if (node) {
1567 /* create any default data in the existing case */
1568 assert(node->schema->parent->nodetype == LYS_CASE);
1569 LY_CHECK_RET(lyd_new_implicit_r(parent, first, node->schema->parent, NULL, node_types, node_when,
1570 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001571 }
1572 break;
1573 case LYS_CONTAINER:
1574 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1575 /* create default NP container */
1576 LY_CHECK_RET(lyd_create_inner(iter, &node));
Radek Krejci9a3823e2021-01-27 20:26:46 +01001577 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001578 lyd_insert_node(parent, first, node);
1579
1580 /* cannot be a NP container with when */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001581 assert(!lysc_node_when(iter));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001582
Michal Vaskoe49b6322020-11-05 17:38:36 +01001583 if (diff) {
1584 /* add into diff */
1585 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1586 }
1587
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001588 /* create any default children */
1589 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 +02001590 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001591 }
1592 break;
1593 case LYS_LEAF:
Michal Vasko69730152020-10-09 16:30:07 +02001594 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1595 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001596 /* create default leaf */
1597 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1598 if (ret == LY_EINCOMPLETE) {
1599 if (node_types) {
1600 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001601 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001602 }
1603 } else if (ret) {
1604 return ret;
1605 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001606 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001607 lyd_insert_node(parent, first, node);
1608
Radek Krejci9a3823e2021-01-27 20:26:46 +01001609 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001610 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001611 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001612 }
1613 if (diff) {
1614 /* add into diff */
1615 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1616 }
1617 }
1618 break;
1619 case LYS_LEAFLIST:
Michal Vasko69730152020-10-09 16:30:07 +02001620 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1621 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001622 /* create all default leaf-lists */
1623 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1624 LY_ARRAY_FOR(dflts, u) {
1625 ret = lyd_create_term2(iter, dflts[u], &node);
1626 if (ret == LY_EINCOMPLETE) {
1627 if (node_types) {
1628 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001629 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001630 }
1631 } else if (ret) {
1632 return ret;
1633 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001634 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001635 lyd_insert_node(parent, first, node);
1636
Radek Krejci9a3823e2021-01-27 20:26:46 +01001637 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001638 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001639 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001640 }
1641 if (diff) {
1642 /* add into diff */
1643 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1644 }
1645 }
1646 }
1647 break;
1648 default:
1649 /* without defaults */
1650 break;
1651 }
1652 }
1653
1654 return LY_SUCCESS;
1655}
1656
1657API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001658lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001659{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001660 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01001661 struct lyd_node *node;
1662 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001663
1664 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1665 if (diff) {
1666 *diff = NULL;
1667 }
1668
Michal Vasko56daf732020-08-10 10:57:18 +02001669 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001670 /* skip added default nodes */
Michal Vasko69730152020-10-09 16:30:07 +02001671 if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
1672 (node->schema->nodetype & LYD_NODE_INNER)) {
Michal Vasko9e685082021-01-29 14:49:09 +01001673 LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_children_p(node), NULL, NULL, NULL,
Michal Vasko3488ada2020-12-03 14:18:19 +01001674 &node_when, implicit_options, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001675 }
1676
Michal Vasko56daf732020-08-10 10:57:18 +02001677 LYD_TREE_DFS_END(tree, node);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001678 }
1679
Michal Vasko3488ada2020-12-03 14:18:19 +01001680 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001681 LY_CHECK_GOTO(ret = lyd_validate_unres(&tree, NULL, &node_when, NULL, NULL, diff), cleanup);
Michal Vasko3488ada2020-12-03 14:18:19 +01001682
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001683cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01001684 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001685 if (ret && diff) {
1686 lyd_free_all(*diff);
1687 *diff = NULL;
1688 }
1689 return ret;
1690}
1691
1692API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001693lyd_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 +02001694{
1695 const struct lys_module *mod;
1696 struct lyd_node *d = NULL;
1697 uint32_t i = 0;
1698 LY_ERR ret = LY_SUCCESS;
1699
1700 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
1701 if (diff) {
1702 *diff = NULL;
1703 }
1704 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001705 ctx = LYD_CTX(*tree);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001706 }
1707
1708 /* add nodes for each module one-by-one */
1709 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
1710 if (!mod->implemented) {
1711 continue;
1712 }
1713
1714 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
1715 if (d) {
1716 /* merge into one diff */
1717 lyd_insert_sibling(*diff, d, diff);
1718
1719 d = NULL;
1720 }
1721 }
1722
1723cleanup:
1724 if (ret && diff) {
1725 lyd_free_all(*diff);
1726 *diff = NULL;
1727 }
1728 return ret;
1729}
1730
1731API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001732lyd_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 +02001733{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001734 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01001735 struct lyd_node *root, *d = NULL;
1736 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001737
1738 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
1739 if (diff) {
1740 *diff = NULL;
1741 }
1742
1743 /* add all top-level defaults for this module */
Michal Vasko3488ada2020-12-03 14:18:19 +01001744 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, NULL, &node_when, implicit_options, diff), cleanup);
1745
1746 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001747 LY_CHECK_GOTO(ret = lyd_validate_unres(tree, module, &node_when, NULL, NULL, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001748
1749 /* process nested nodes */
1750 LY_LIST_FOR(*tree, root) {
1751 /* skip added default nodes */
1752 if ((root->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
1753 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
1754
1755 if (d) {
1756 /* merge into one diff */
1757 lyd_insert_sibling(*diff, d, diff);
1758
1759 d = NULL;
1760 }
1761 }
1762 }
1763
1764cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01001765 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001766 if (ret && diff) {
1767 lyd_free_all(*diff);
1768 *diff = NULL;
1769 }
1770 return ret;
1771}
1772
Michal Vasko90932a92020-02-12 14:33:03 +01001773struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +02001774lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +01001775{
Michal Vaskob104f112020-07-17 09:54:54 +02001776 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +01001777 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02001778 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +01001779 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +01001780
Michal Vaskob104f112020-07-17 09:54:54 +02001781 assert(new_node);
1782
1783 if (!first_sibling || !new_node->schema) {
1784 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +01001785 return NULL;
1786 }
1787
Michal Vasko93b16062020-12-09 18:14:18 +01001788 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +01001789 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +01001790 getnext_opts = LYS_GETNEXT_OUTPUT;
1791 }
1792
Michal Vaskob104f112020-07-17 09:54:54 +02001793 if (first_sibling->parent && first_sibling->parent->children_ht) {
1794 /* find the anchor using hashes */
1795 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +01001796 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001797 while (schema) {
1798 /* keep trying to find the first existing instance of the closest following schema sibling,
1799 * otherwise return NULL - inserting at the end */
1800 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
1801 break;
1802 }
1803
Michal Vasko93b16062020-12-09 18:14:18 +01001804 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001805 }
1806 } else {
1807 /* find the anchor without hashes */
1808 match = (struct lyd_node *)first_sibling;
1809 if (!lysc_data_parent(new_node->schema)) {
1810 /* we are in top-level, skip all the data from preceding modules */
1811 LY_LIST_FOR(match, match) {
1812 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
1813 break;
1814 }
1815 }
1816 }
1817
1818 /* get the first schema sibling */
1819 sparent = lysc_data_parent(new_node->schema);
Michal Vasko93b16062020-12-09 18:14:18 +01001820 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001821
1822 found = 0;
1823 LY_LIST_FOR(match, match) {
1824 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
1825 /* we have found an opaque node, which must be at the end, so use it OR
1826 * modules do not match, so we must have traversed all the data from new_node module (if any),
1827 * we have found the first node of the next module, that is what we want */
1828 break;
1829 }
1830
1831 /* skip schema nodes until we find the instantiated one */
1832 while (!found) {
1833 if (new_node->schema == schema) {
1834 /* we have found the schema of the new node, continue search to find the first
1835 * data node with a different schema (after our schema) */
1836 found = 1;
1837 break;
1838 }
1839 if (match->schema == schema) {
1840 /* current node (match) is a data node still before the new node, continue search in data */
1841 break;
1842 }
Michal Vasko93b16062020-12-09 18:14:18 +01001843 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001844 assert(schema);
1845 }
1846
1847 if (found && (match->schema != new_node->schema)) {
1848 /* find the next node after we have found our node schema data instance */
1849 break;
1850 }
1851 }
Michal Vasko90932a92020-02-12 14:33:03 +01001852 }
1853
1854 return match;
1855}
1856
1857/**
1858 * @brief Insert node after a sibling.
1859 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001860 * Handles inserting into NP containers and key-less lists.
1861 *
Michal Vasko90932a92020-02-12 14:33:03 +01001862 * @param[in] sibling Sibling to insert after.
1863 * @param[in] node Node to insert.
1864 */
1865static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001866lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001867{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001868 struct lyd_node_inner *par;
1869
Michal Vasko90932a92020-02-12 14:33:03 +01001870 assert(!node->next && (node->prev == node));
1871
1872 node->next = sibling->next;
1873 node->prev = sibling;
1874 sibling->next = node;
1875 if (node->next) {
1876 /* sibling had a succeeding node */
1877 node->next->prev = node;
1878 } else {
1879 /* sibling was last, find first sibling and change its prev */
1880 if (sibling->parent) {
1881 sibling = sibling->parent->child;
1882 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +02001883 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +01001884 }
1885 sibling->prev = node;
1886 }
1887 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001888
Michal Vasko9f96a052020-03-10 09:41:45 +01001889 for (par = node->parent; par; par = par->parent) {
1890 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1891 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001892 par->flags &= ~LYD_DEFAULT;
1893 }
Michal Vaskob104f112020-07-17 09:54:54 +02001894 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001895 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01001896 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01001897 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001898 }
Michal Vasko90932a92020-02-12 14:33:03 +01001899}
1900
1901/**
1902 * @brief Insert node before a sibling.
1903 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001904 * Handles inserting into NP containers and key-less lists.
1905 *
Michal Vasko90932a92020-02-12 14:33:03 +01001906 * @param[in] sibling Sibling to insert before.
1907 * @param[in] node Node to insert.
1908 */
1909static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001910lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001911{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001912 struct lyd_node_inner *par;
1913
Michal Vasko90932a92020-02-12 14:33:03 +01001914 assert(!node->next && (node->prev == node));
1915
1916 node->next = sibling;
1917 /* covers situation of sibling being first */
1918 node->prev = sibling->prev;
1919 sibling->prev = node;
1920 if (node->prev->next) {
1921 /* sibling had a preceding node */
1922 node->prev->next = node;
1923 } else if (sibling->parent) {
1924 /* sibling was first and we must also change parent child pointer */
1925 sibling->parent->child = node;
1926 }
1927 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001928
Michal Vasko9f96a052020-03-10 09:41:45 +01001929 for (par = node->parent; par; par = par->parent) {
1930 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1931 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001932 par->flags &= ~LYD_DEFAULT;
1933 }
Michal Vaskob104f112020-07-17 09:54:54 +02001934 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001935 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01001936 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01001937 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001938 }
Michal Vasko90932a92020-02-12 14:33:03 +01001939}
1940
1941/**
Michal Vaskob104f112020-07-17 09:54:54 +02001942 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +01001943 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001944 * Handles inserting into NP containers and key-less lists.
1945 *
Michal Vasko90932a92020-02-12 14:33:03 +01001946 * @param[in] parent Parent to insert into.
1947 * @param[in] node Node to insert.
1948 */
1949static void
Michal Vaskob104f112020-07-17 09:54:54 +02001950lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001951{
1952 struct lyd_node_inner *par;
1953
Radek Krejcia1c1e542020-09-29 16:06:52 +02001954 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +01001955 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +01001956
1957 par = (struct lyd_node_inner *)parent;
1958
Michal Vaskob104f112020-07-17 09:54:54 +02001959 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +01001960 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001961
Michal Vaskod989ba02020-08-24 10:59:24 +02001962 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001963 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1964 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001965 par->flags &= ~LYD_DEFAULT;
1966 }
Michal Vasko52927e22020-03-16 17:26:14 +01001967 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001968 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01001969 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01001970 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001971 }
Michal Vasko751cb4d2020-07-14 12:25:28 +02001972}
Michal Vasko0249f7c2020-03-05 16:36:40 +01001973
Michal Vasko751cb4d2020-07-14 12:25:28 +02001974/**
1975 * @brief Learn whether a list instance has all the keys.
1976 *
1977 * @param[in] list List instance to check.
1978 * @return non-zero if all the keys were found,
1979 * @return 0 otherwise.
1980 */
1981static int
1982lyd_insert_has_keys(const struct lyd_node *list)
1983{
1984 const struct lyd_node *key;
1985 const struct lysc_node *skey = NULL;
1986
1987 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +02001988 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +02001989 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
1990 if (!key || (key->schema != skey)) {
1991 /* key missing */
1992 return 0;
1993 }
1994
1995 key = key->next;
1996 }
1997
1998 /* all keys found */
1999 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +01002000}
2001
2002void
Michal Vaskob104f112020-07-17 09:54:54 +02002003lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002004{
Michal Vaskob104f112020-07-17 09:54:54 +02002005 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +01002006
Michal Vaskob104f112020-07-17 09:54:54 +02002007 /* inserting list without its keys is not supported */
2008 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +01002009 assert(!parent || !parent->schema ||
2010 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +01002011
Michal Vaskob104f112020-07-17 09:54:54 +02002012 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +01002013 parent = lyd_parent(*first_sibling_p);
Michal Vasko9b368d32020-02-14 13:53:31 +01002014 }
Michal Vasko90932a92020-02-12 14:33:03 +01002015
Michal Vaskob104f112020-07-17 09:54:54 +02002016 /* get first sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01002017 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +01002018
Michal Vaskob104f112020-07-17 09:54:54 +02002019 /* find the anchor, our next node, so we can insert before it */
2020 anchor = lyd_insert_get_next_anchor(first_sibling, node);
2021 if (anchor) {
2022 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +01002023 if (!parent && (*first_sibling_p == anchor)) {
2024 /* move first sibling */
2025 *first_sibling_p = node;
2026 }
Michal Vaskob104f112020-07-17 09:54:54 +02002027 } else if (first_sibling) {
2028 lyd_insert_after_node(first_sibling->prev, node);
2029 } else if (parent) {
2030 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +01002031 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02002032 *first_sibling_p = node;
2033 }
2034
2035 /* insert into parent HT */
2036 lyd_insert_hash(node);
2037
2038 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +02002039 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +02002040 lyd_hash(parent);
2041
2042 /* now we can insert even the list into its parent HT */
2043 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +01002044 }
Michal Vasko90932a92020-02-12 14:33:03 +01002045}
2046
Michal Vasko717a4c32020-12-07 09:40:10 +01002047/**
2048 * @brief Check schema place of a node to be inserted.
2049 *
2050 * @param[in] parent Schema node of the parent data node.
2051 * @param[in] sibling Schema node of a sibling data node.
2052 * @param[in] schema Schema node if the data node to be inserted.
2053 * @return LY_SUCCESS on success.
2054 * @return LY_EINVAL if the place is invalid.
2055 */
Michal Vaskof03ed032020-03-04 13:31:44 +01002056static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +01002057lyd_insert_check_schema(const struct lysc_node *parent, const struct lysc_node *sibling, const struct lysc_node *schema)
Michal Vaskof03ed032020-03-04 13:31:44 +01002058{
2059 const struct lysc_node *par2;
2060
Michal Vasko62ed12d2020-05-21 10:08:25 +02002061 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +01002062 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
2063 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01002064
Michal Vasko717a4c32020-12-07 09:40:10 +01002065 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002066 /* opaque nodes can be inserted wherever */
2067 return LY_SUCCESS;
2068 }
2069
Michal Vasko717a4c32020-12-07 09:40:10 +01002070 if (!parent) {
2071 parent = lysc_data_parent(sibling);
2072 }
2073
Michal Vaskof03ed032020-03-04 13:31:44 +01002074 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02002075 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01002076
2077 if (parent) {
2078 /* inner node */
2079 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02002080 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02002081 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002082 return LY_EINVAL;
2083 }
2084 } else {
2085 /* top-level node */
2086 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02002087 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002088 return LY_EINVAL;
2089 }
2090 }
2091
2092 return LY_SUCCESS;
2093}
2094
2095API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002096lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01002097{
2098 struct lyd_node *iter;
2099
Michal Vasko654bc852020-06-23 13:28:06 +02002100 LY_CHECK_ARG_RET(NULL, parent, node, parent->schema->nodetype & LYD_NODE_INNER, LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01002101
Michal Vasko717a4c32020-12-07 09:40:10 +01002102 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002103
2104 if (node->schema->flags & LYS_KEY) {
2105 LOGERR(parent->schema->module->ctx, LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
2106 return LY_EINVAL;
2107 }
2108
2109 if (node->parent || node->prev->next) {
2110 lyd_unlink_tree(node);
2111 }
2112
2113 while (node) {
2114 iter = node->next;
2115 lyd_unlink_tree(node);
2116 lyd_insert_node(parent, NULL, node);
2117 node = iter;
2118 }
2119 return LY_SUCCESS;
2120}
2121
2122API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002123lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01002124{
2125 struct lyd_node *iter;
2126
Michal Vaskob104f112020-07-17 09:54:54 +02002127 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01002128
Michal Vaskob104f112020-07-17 09:54:54 +02002129 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +01002130 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01002131 }
2132
Michal Vasko553d0b52020-12-04 16:27:52 +01002133 if (sibling == node) {
2134 /* we need to keep the connection to siblings so we can insert into them */
2135 sibling = sibling->prev;
2136 }
2137
Michal Vaskob1b5c262020-03-05 14:29:47 +01002138 if (node->parent || node->prev->next) {
2139 lyd_unlink_tree(node);
2140 }
2141
2142 while (node) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002143 if (lysc_is_key(node->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002144 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +02002145 return LY_EINVAL;
2146 }
2147
Michal Vaskob1b5c262020-03-05 14:29:47 +01002148 iter = node->next;
2149 lyd_unlink_tree(node);
2150 lyd_insert_node(NULL, &sibling, node);
2151 node = iter;
2152 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01002153
Michal Vaskob104f112020-07-17 09:54:54 +02002154 if (first) {
2155 /* find the first sibling */
2156 *first = sibling;
2157 while ((*first)->prev->next) {
2158 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002159 }
2160 }
2161
2162 return LY_SUCCESS;
2163}
2164
Michal Vaskob1b5c262020-03-05 14:29:47 +01002165API LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01002166lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
2167{
Michal Vaskof03ed032020-03-04 13:31:44 +01002168 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2169
Michal Vasko717a4c32020-12-07 09:40:10 +01002170 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002171
Michal Vaskob104f112020-07-17 09:54:54 +02002172 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002173 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002174 return LY_EINVAL;
2175 }
2176
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002177 lyd_unlink_tree(node);
2178 lyd_insert_before_node(sibling, node);
2179 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002180
Michal Vaskof03ed032020-03-04 13:31:44 +01002181 return LY_SUCCESS;
2182}
2183
2184API LY_ERR
2185lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
2186{
Michal Vaskof03ed032020-03-04 13:31:44 +01002187 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2188
Michal Vasko717a4c32020-12-07 09:40:10 +01002189 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002190
Michal Vaskob104f112020-07-17 09:54:54 +02002191 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002192 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002193 return LY_EINVAL;
2194 }
2195
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002196 lyd_unlink_tree(node);
2197 lyd_insert_after_node(sibling, node);
2198 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002199
Michal Vaskof03ed032020-03-04 13:31:44 +01002200 return LY_SUCCESS;
2201}
2202
2203API void
2204lyd_unlink_tree(struct lyd_node *node)
2205{
2206 struct lyd_node *iter;
2207
2208 if (!node) {
2209 return;
2210 }
2211
Michal Vaskob104f112020-07-17 09:54:54 +02002212 /* update hashes while still linked into the tree */
2213 lyd_unlink_hash(node);
2214
Michal Vaskof03ed032020-03-04 13:31:44 +01002215 /* unlink from siblings */
2216 if (node->prev->next) {
2217 node->prev->next = node->next;
2218 }
2219 if (node->next) {
2220 node->next->prev = node->prev;
2221 } else {
2222 /* unlinking the last node */
2223 if (node->parent) {
2224 iter = node->parent->child;
2225 } else {
2226 iter = node->prev;
2227 while (iter->prev != node) {
2228 iter = iter->prev;
2229 }
2230 }
2231 /* update the "last" pointer from the first node */
2232 iter->prev = node->prev;
2233 }
2234
2235 /* unlink from parent */
2236 if (node->parent) {
2237 if (node->parent->child == node) {
2238 /* the node is the first child */
2239 node->parent->child = node->next;
2240 }
2241
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002242 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +02002243 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
2244 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002245 LY_LIST_FOR(node->parent->child, iter) {
2246 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
2247 break;
2248 }
2249 }
2250 if (!iter) {
2251 node->parent->flags |= LYD_DEFAULT;
2252 }
2253 }
2254
Michal Vaskof03ed032020-03-04 13:31:44 +01002255 /* check for keyless list and update its hash */
Michal Vasko9e685082021-01-29 14:49:09 +01002256 for (iter = lyd_parent(node); iter; iter = lyd_parent(iter)) {
Michal Vasko413c7f22020-05-05 12:34:06 +02002257 if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002258 lyd_hash(iter);
2259 }
2260 }
2261
2262 node->parent = NULL;
2263 }
2264
2265 node->next = NULL;
2266 node->prev = node;
2267}
2268
Michal Vaskoa5da3292020-08-12 13:10:50 +02002269void
Michal Vasko871a0252020-11-11 18:35:24 +01002270lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +02002271{
2272 struct lyd_meta *last, *iter;
2273
2274 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02002275
2276 if (!meta) {
2277 return;
2278 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002279
2280 for (iter = meta; iter; iter = iter->next) {
2281 iter->parent = parent;
2282 }
2283
2284 /* insert as the last attribute */
2285 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002286 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02002287 last->next = meta;
2288 } else {
2289 parent->meta = meta;
2290 }
2291
2292 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +01002293 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02002294 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +01002295 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +02002296 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002297}
2298
2299LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01002300lyd_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 +02002301 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 +01002302 void *prefix_data, uint32_t hints, ly_bool clear_dflt, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01002303{
Radek Krejci2efc45b2020-12-22 16:25:44 +01002304 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01002305 struct lysc_ext_instance *ant = NULL;
Michal Vasko9f96a052020-03-10 09:41:45 +01002306 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002307 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +01002308
Michal Vasko9f96a052020-03-10 09:41:45 +01002309 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002310
Radek Krejciddace2c2021-01-08 11:30:56 +01002311 LOG_LOCSET(parent ? parent->schema : NULL, parent, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002312
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002313 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko69730152020-10-09 16:30:07 +02002314 if ((mod->compiled->exts[u].def->plugin == lyext_plugins_internal[LYEXT_PLUGIN_INTERNAL_ANNOTATION].plugin) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002315 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +01002316 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002317 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +01002318 break;
2319 }
2320 }
2321 if (!ant) {
2322 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +01002323 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Michal Vasko90932a92020-02-12 14:33:03 +01002324 mod->name, name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002325 ret = LY_EINVAL;
2326 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +01002327 }
2328
Michal Vasko9f96a052020-03-10 09:41:45 +01002329 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002330 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +01002331 mt->parent = parent;
2332 mt->annotation = ant;
Radek Krejci2efc45b2020-12-22 16:25:44 +01002333 ret = lyd_value_store(mod->ctx, &mt->value, ((struct lyext_metadata *)ant->data)->type, value, value_len, dynamic,
2334 format, prefix_data, hints, parent ? parent->schema : NULL, incomplete);
2335 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
2336 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
2337 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +01002338
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002339 /* insert as the last attribute */
2340 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01002341 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01002342 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002343 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01002344 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002345 }
2346
Michal Vasko9f96a052020-03-10 09:41:45 +01002347 if (meta) {
2348 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002349 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01002350
2351cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01002352 LOG_LOCBACK((parent && parent->schema) ? 1 : 0, parent ? 1 : 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002353 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01002354}
2355
Michal Vaskoa5da3292020-08-12 13:10:50 +02002356void
2357lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
2358{
2359 struct lyd_attr *last, *iter;
2360 struct lyd_node_opaq *opaq;
2361
2362 assert(parent && !parent->schema);
2363
2364 if (!attr) {
2365 return;
2366 }
2367
2368 opaq = (struct lyd_node_opaq *)parent;
2369 for (iter = attr; iter; iter = iter->next) {
2370 iter->parent = opaq;
2371 }
2372
2373 /* insert as the last attribute */
2374 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002375 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02002376 last->next = attr;
2377 } else {
2378 opaq->attr = attr;
2379 }
2380}
2381
Michal Vasko52927e22020-03-16 17:26:14 +01002382LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002383lyd_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 +01002384 const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
2385 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 +01002386{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002387 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02002388 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01002389
2390 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002391 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01002392
2393 if (!value_len) {
2394 value = "";
2395 }
2396
2397 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002398 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02002399
Michal Vaskoad92b672020-11-12 13:11:31 +01002400 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002401 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002402 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002403 }
2404 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002405 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002406 }
2407
Michal Vasko52927e22020-03-16 17:26:14 +01002408 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002409 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
2410 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002411 *dynamic = 0;
2412 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002413 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002414 }
Michal Vasko501af032020-11-11 20:27:44 +01002415 at->format = format;
2416 at->val_prefix_data = val_prefix_data;
2417 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01002418
2419 /* insert as the last attribute */
2420 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002421 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01002422 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002423 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01002424 last->next = at;
2425 }
2426
Radek Krejci011e4aa2020-09-04 15:22:31 +02002427finish:
2428 if (ret) {
2429 lyd_free_attr_single(ctx, at);
2430 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01002431 *attr = at;
2432 }
2433 return LY_SUCCESS;
2434}
2435
Radek Krejci084289f2019-07-09 17:35:30 +02002436API const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02002437lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02002438{
Michal Vasko004d3152020-06-11 19:59:22 +02002439 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02002440
Michal Vasko004d3152020-06-11 19:59:22 +02002441 if (ly_path_eval(path, tree, &target)) {
2442 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02002443 }
2444
Michal Vasko004d3152020-06-11 19:59:22 +02002445 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02002446}
2447
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002448API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002449lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002450{
2451 const struct lyd_node *iter1, *iter2;
2452 struct lyd_node_term *term1, *term2;
2453 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01002454 struct lyd_node_opaq *opaq1, *opaq2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002455 size_t len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02002456
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002457 if (!node1 || !node2) {
2458 if (node1 == node2) {
2459 return LY_SUCCESS;
2460 } else {
2461 return LY_ENOT;
2462 }
2463 }
2464
Michal Vaskob7be7a82020-08-20 09:09:04 +02002465 if ((LYD_CTX(node1) != LYD_CTX(node2)) || (node1->schema != node2->schema)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002466 return LY_ENOT;
2467 }
2468
2469 if (node1->hash != node2->hash) {
2470 return LY_ENOT;
2471 }
Michal Vasko52927e22020-03-16 17:26:14 +01002472 /* 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 +02002473
Michal Vasko52927e22020-03-16 17:26:14 +01002474 if (!node1->schema) {
2475 opaq1 = (struct lyd_node_opaq *)node1;
2476 opaq2 = (struct lyd_node_opaq *)node2;
Michal Vaskoad92b672020-11-12 13:11:31 +01002477 if ((opaq1->name.name != opaq2->name.name) || (opaq1->format != opaq2->format) ||
2478 (opaq1->name.module_ns != opaq2->name.module_ns)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002479 return LY_ENOT;
2480 }
Michal Vasko52927e22020-03-16 17:26:14 +01002481 switch (opaq1->format) {
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002482 case LY_PREF_XML:
2483 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 +01002484 return LY_ENOT;
2485 }
2486 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002487 case LY_PREF_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +02002488 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
2489 if (strcmp(opaq1->value, opaq2->value)) {
2490 return LY_ENOT;
2491 }
2492 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002493 default:
Michal Vasko52927e22020-03-16 17:26:14 +01002494 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002495 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01002496 return LY_EINT;
2497 }
2498 if (options & LYD_COMPARE_FULL_RECURSION) {
2499 iter1 = opaq1->child;
2500 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002501 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01002502 }
2503 return LY_SUCCESS;
2504 } else {
2505 switch (node1->schema->nodetype) {
2506 case LYS_LEAF:
2507 case LYS_LEAFLIST:
2508 if (options & LYD_COMPARE_DEFAULTS) {
2509 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2510 return LY_ENOT;
2511 }
2512 }
2513
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002514 term1 = (struct lyd_node_term *)node1;
2515 term2 = (struct lyd_node_term *)node2;
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002516 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
Michal Vasko52927e22020-03-16 17:26:14 +01002517 case LYS_CONTAINER:
2518 if (options & LYD_COMPARE_DEFAULTS) {
2519 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2520 return LY_ENOT;
2521 }
2522 }
2523 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko9e685082021-01-29 14:49:09 +01002524 iter1 = lyd_child(node1);
2525 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002526 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002527 }
2528 return LY_SUCCESS;
Michal Vasko1bf09392020-03-27 12:38:10 +01002529 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002530 case LYS_ACTION:
2531 if (options & LYD_COMPARE_FULL_RECURSION) {
2532 /* TODO action/RPC
2533 goto all_children_compare;
2534 */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002535 }
2536 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002537 case LYS_NOTIF:
2538 if (options & LYD_COMPARE_FULL_RECURSION) {
2539 /* TODO Notification
2540 goto all_children_compare;
2541 */
2542 }
2543 return LY_SUCCESS;
2544 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01002545 iter1 = lyd_child(node1);
2546 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002547
2548 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
2549 /* lists with keys, their equivalence is based on their keys */
Michal Vasko544e58a2021-01-28 14:33:41 +01002550 for (const struct lysc_node *key = lysc_node_child(node1->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002551 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01002552 key = key->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002553 if (lyd_compare_single(iter1, iter2, options)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002554 return LY_ENOT;
2555 }
2556 iter1 = iter1->next;
2557 iter2 = iter2->next;
2558 }
2559 } else {
2560 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
2561
Radek Krejci0f969882020-08-21 16:56:47 +02002562all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01002563 if (!iter1 && !iter2) {
2564 /* no children, nothing to compare */
2565 return LY_SUCCESS;
2566 }
2567
Michal Vaskod989ba02020-08-24 10:59:24 +02002568 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002569 if (lyd_compare_single(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002570 return LY_ENOT;
2571 }
2572 }
2573 if (iter1 || iter2) {
2574 return LY_ENOT;
2575 }
2576 }
2577 return LY_SUCCESS;
2578 case LYS_ANYXML:
2579 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02002580 any1 = (struct lyd_node_any *)node1;
2581 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01002582
2583 if (any1->value_type != any2->value_type) {
2584 return LY_ENOT;
2585 }
2586 switch (any1->value_type) {
2587 case LYD_ANYDATA_DATATREE:
2588 iter1 = any1->value.tree;
2589 iter2 = any2->value.tree;
2590 goto all_children_compare;
2591 case LYD_ANYDATA_STRING:
2592 case LYD_ANYDATA_XML:
2593 case LYD_ANYDATA_JSON:
2594 len1 = strlen(any1->value.str);
2595 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02002596 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002597 return LY_ENOT;
2598 }
2599 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002600 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02002601 len1 = lyd_lyb_data_length(any1->value.mem);
2602 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko69730152020-10-09 16:30:07 +02002603 if ((len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002604 return LY_ENOT;
2605 }
2606 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002607 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002608 }
2609 }
2610
Michal Vaskob7be7a82020-08-20 09:09:04 +02002611 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002612 return LY_EINT;
2613}
Radek Krejci22ebdba2019-07-25 13:59:43 +02002614
Michal Vasko21725742020-06-29 11:49:25 +02002615API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002616lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02002617{
Michal Vaskod989ba02020-08-24 10:59:24 +02002618 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002619 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
2620 }
2621
Michal Vasko11a81432020-07-28 16:31:29 +02002622 if (node1 == node2) {
2623 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002624 }
Michal Vasko11a81432020-07-28 16:31:29 +02002625 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002626}
2627
2628API LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02002629lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
2630{
2631 if (!meta1 || !meta2) {
2632 if (meta1 == meta2) {
2633 return LY_SUCCESS;
2634 } else {
2635 return LY_ENOT;
2636 }
2637 }
2638
Michal Vaskoa8083062020-11-06 17:22:10 +01002639 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02002640 return LY_ENOT;
2641 }
2642
Michal Vasko21725742020-06-29 11:49:25 +02002643 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
2644}
2645
Radek Krejci22ebdba2019-07-25 13:59:43 +02002646/**
Michal Vasko52927e22020-03-16 17:26:14 +01002647 * @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 +02002648 *
2649 * 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 +02002650 *
2651 * @param[in] node Original node to duplicate
2652 * @param[in] parent Parent to insert into, NULL for top-level sibling.
2653 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2654 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2655 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it int @p parent / @p first sibling).
2656 * @return LY_ERR value
Radek Krejci22ebdba2019-07-25 13:59:43 +02002657 */
Michal Vasko52927e22020-03-16 17:26:14 +01002658static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002659lyd_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 +02002660 struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002661{
Michal Vasko52927e22020-03-16 17:26:14 +01002662 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002663 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002664 struct lyd_meta *meta;
2665 struct lyd_node_any *any;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002666
Michal Vasko52927e22020-03-16 17:26:14 +01002667 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002668
Michal Vasko52927e22020-03-16 17:26:14 +01002669 if (!node->schema) {
2670 dup = calloc(1, sizeof(struct lyd_node_opaq));
2671 } else {
2672 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01002673 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002674 case LYS_ACTION:
2675 case LYS_NOTIF:
2676 case LYS_CONTAINER:
2677 case LYS_LIST:
2678 dup = calloc(1, sizeof(struct lyd_node_inner));
2679 break;
2680 case LYS_LEAF:
2681 case LYS_LEAFLIST:
2682 dup = calloc(1, sizeof(struct lyd_node_term));
2683 break;
2684 case LYS_ANYDATA:
2685 case LYS_ANYXML:
2686 dup = calloc(1, sizeof(struct lyd_node_any));
2687 break;
2688 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02002689 LOGINT(LYD_CTX(node));
Michal Vasko52927e22020-03-16 17:26:14 +01002690 ret = LY_EINT;
2691 goto error;
2692 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002693 }
Michal Vaskob7be7a82020-08-20 09:09:04 +02002694 LY_CHECK_ERR_GOTO(!dup, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002695
Michal Vaskof6df0a02020-06-16 13:08:34 +02002696 if (options & LYD_DUP_WITH_FLAGS) {
2697 dup->flags = node->flags;
2698 } else {
2699 dup->flags = (node->flags & LYD_DEFAULT) | LYD_NEW;
2700 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002701 dup->schema = node->schema;
Michal Vasko52927e22020-03-16 17:26:14 +01002702 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002703
Michal Vasko25a32822020-07-09 15:48:22 +02002704 /* duplicate metadata */
2705 if (!(options & LYD_DUP_NO_META)) {
2706 LY_LIST_FOR(node->meta, meta) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002707 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
Michal Vasko25a32822020-07-09 15:48:22 +02002708 }
2709 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002710
2711 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01002712 if (!dup->schema) {
2713 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
2714 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
2715 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002716
2717 if (options & LYD_DUP_RECURSIVE) {
2718 /* duplicate all the children */
2719 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002720 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002721 }
2722 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002723 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.name, 0, &opaq->name.name), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002724 opaq->format = orig->format;
Michal Vaskoad92b672020-11-12 13:11:31 +01002725 if (orig->name.prefix) {
2726 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.prefix, 0, &opaq->name.prefix), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002727 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002728 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 +01002729 if (orig->val_prefix_data) {
2730 ret = ly_dup_prefix_data(LYD_CTX(node), opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
2731 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002732 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002733 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->value, 0, &opaq->value), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002734 opaq->ctx = orig->ctx;
2735 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
2736 struct lyd_node_term *term = (struct lyd_node_term *)dup;
2737 struct lyd_node_term *orig = (struct lyd_node_term *)node;
2738
2739 term->hash = orig->hash;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002740 LY_CHECK_ERR_GOTO(orig->value.realtype->plugin->duplicate(LYD_CTX(node), &orig->value, &term->value),
Michal Vasko69730152020-10-09 16:30:07 +02002741 LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."); ret = LY_EINT, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002742 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
2743 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
2744 struct lyd_node *child;
2745
2746 if (options & LYD_DUP_RECURSIVE) {
2747 /* duplicate all the children */
2748 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002749 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002750 }
Michal Vasko69730152020-10-09 16:30:07 +02002751 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002752 /* always duplicate keys of a list */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002753 child = orig->child;
Michal Vasko544e58a2021-01-28 14:33:41 +01002754 for (const struct lysc_node *key = lysc_node_child(dup->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002755 key && (key->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +02002756 key = key->next) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002757 if (!child) {
2758 /* possibly not keys are present in filtered tree */
2759 break;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002760 } else if (child->schema != key) {
2761 /* possibly not all keys are present in filtered tree,
2762 * but there can be also some non-key nodes */
2763 continue;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002764 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002765 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002766 child = child->next;
2767 }
2768 }
2769 lyd_hash(dup);
2770 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02002771 dup->hash = node->hash;
2772 any = (struct lyd_node_any *)node;
2773 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002774 }
2775
Michal Vasko52927e22020-03-16 17:26:14 +01002776 /* insert */
2777 lyd_insert_node(parent, first, dup);
Michal Vasko52927e22020-03-16 17:26:14 +01002778
2779 if (dup_p) {
2780 *dup_p = dup;
2781 }
2782 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002783
2784error:
Michal Vasko52927e22020-03-16 17:26:14 +01002785 lyd_free_tree(dup);
2786 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002787}
2788
Michal Vasko3a41dff2020-07-15 14:30:28 +02002789static LY_ERR
2790lyd_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 +02002791 struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002792{
Michal Vasko3a41dff2020-07-15 14:30:28 +02002793 const struct lyd_node_inner *orig_parent, *iter;
Radek Krejci857189e2020-09-01 13:26:36 +02002794 ly_bool repeat = 1;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002795
2796 *dup_parent = NULL;
2797 *local_parent = NULL;
2798
2799 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
2800 if (parent && (parent->schema == orig_parent->schema)) {
2801 /* stop creating parents, connect what we have into the provided parent */
2802 iter = parent;
2803 repeat = 0;
2804 } else {
2805 iter = NULL;
2806 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, NULL, (struct lyd_node **)&iter, 0,
Radek Krejci0f969882020-08-21 16:56:47 +02002807 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02002808 }
2809 if (!*local_parent) {
2810 *local_parent = (struct lyd_node_inner *)iter;
2811 }
2812 if (iter->child) {
2813 /* 1) list - add after keys
2814 * 2) provided parent with some children */
2815 iter->child->prev->next = *dup_parent;
2816 if (*dup_parent) {
2817 (*dup_parent)->prev = iter->child->prev;
2818 iter->child->prev = *dup_parent;
2819 }
2820 } else {
2821 ((struct lyd_node_inner *)iter)->child = *dup_parent;
2822 }
2823 if (*dup_parent) {
2824 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
2825 }
2826 *dup_parent = (struct lyd_node *)iter;
2827 }
2828
2829 if (repeat && parent) {
2830 /* given parent and created parents chain actually do not interconnect */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002831 LOGERR(LYD_CTX(node), LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02002832 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002833 return LY_EINVAL;
2834 }
2835
2836 return LY_SUCCESS;
2837}
2838
2839static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002840lyd_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 +02002841{
2842 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002843 const struct lyd_node *orig; /* original node to be duplicated */
2844 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002845 struct lyd_node *top = NULL; /* the most higher created node */
2846 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002847
Michal Vasko3a41dff2020-07-15 14:30:28 +02002848 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002849
2850 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002851 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, parent, &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002852 } else {
2853 local_parent = parent;
2854 }
2855
Radek Krejci22ebdba2019-07-25 13:59:43 +02002856 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01002857 if (lysc_is_key(orig->schema)) {
2858 if (local_parent) {
2859 /* the key must already exist in the parent */
2860 rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
2861 LY_CHECK_ERR_GOTO(rc, LOGINT(LYD_CTX(node)), error);
2862 } else {
2863 assert(!(options & LYD_DUP_WITH_PARENTS));
2864 /* duplicating a single key, okay, I suppose... */
2865 rc = lyd_dup_r(orig, NULL, &first, options, first ? NULL : &first);
2866 LY_CHECK_GOTO(rc, error);
2867 }
2868 } else {
2869 /* if there is no local parent, it will be inserted into first */
Michal Vasko9e685082021-01-29 14:49:09 +01002870 rc = lyd_dup_r(orig, &local_parent->node, &first, options, first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01002871 LY_CHECK_GOTO(rc, error);
2872 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002873 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002874 break;
2875 }
2876 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002877
2878 /* rehash if needed */
Michal Vaskod989ba02020-08-24 10:59:24 +02002879 for ( ; local_parent; local_parent = local_parent->parent) {
Michal Vasko69730152020-10-09 16:30:07 +02002880 if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +01002881 lyd_hash(&local_parent->node);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002882 }
2883 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002884
2885 if (dup) {
2886 *dup = first;
2887 }
2888 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002889
2890error:
2891 if (top) {
2892 lyd_free_tree(top);
2893 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01002894 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002895 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002896 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002897}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002898
Michal Vasko3a41dff2020-07-15 14:30:28 +02002899API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002900lyd_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 +02002901{
2902 return lyd_dup(node, parent, options, 1, dup);
2903}
2904
2905API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002906lyd_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 +02002907{
2908 return lyd_dup(node, parent, options, 0, dup);
2909}
2910
2911API LY_ERR
2912lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02002913{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002914 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002915 struct lyd_meta *mt, *last;
2916
Michal Vasko3a41dff2020-07-15 14:30:28 +02002917 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02002918
2919 /* create a copy */
2920 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02002921 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02002922 mt->annotation = meta->annotation;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002923 ret = meta->value.realtype->plugin->duplicate(LYD_CTX(node), &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02002924 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
2925 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02002926
2927 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02002928 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02002929 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002930 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02002931 last->next = mt;
2932 } else {
2933 node->meta = mt;
2934 }
2935
Radek Krejci011e4aa2020-09-04 15:22:31 +02002936finish:
2937 if (ret) {
2938 lyd_free_meta_single(mt);
2939 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002940 *dup = mt;
2941 }
2942 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002943}
2944
Michal Vasko4490d312020-06-16 13:08:55 +02002945/**
2946 * @brief Merge a source sibling into target siblings.
2947 *
2948 * @param[in,out] first_trg First target sibling, is updated if top-level.
2949 * @param[in] parent_trg Target parent.
2950 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
2951 * @param[in] options Merge options.
2952 * @return LY_ERR value.
2953 */
2954static LY_ERR
2955lyd_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 +02002956 uint16_t options)
Michal Vasko4490d312020-06-16 13:08:55 +02002957{
2958 LY_ERR ret;
2959 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02002960 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vasko4490d312020-06-16 13:08:55 +02002961 struct lysc_type *type;
Michal Vasko4490d312020-06-16 13:08:55 +02002962
2963 sibling_src = *sibling_src_p;
2964 if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
2965 /* try to find the exact instance */
2966 ret = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
2967 } else {
2968 /* try to simply find the node, there cannot be more instances */
2969 ret = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
2970 }
2971
2972 if (!ret) {
2973 /* node found, make sure even value matches for all node types */
Michal Vasko8f359bf2020-07-28 10:41:15 +02002974 if ((match_trg->schema->nodetype == LYS_LEAF) && lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002975 /* since they are different, they cannot both be default */
2976 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
2977
Michal Vasko3a41dff2020-07-15 14:30:28 +02002978 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
2979 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002980 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002981 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
2982 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02002983 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02002984
2985 /* copy flags and add LYD_NEW */
2986 match_trg->flags = sibling_src->flags | LYD_NEW;
2987 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002988 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002989 /* update value */
2990 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002991 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002992
2993 /* copy flags and add LYD_NEW */
2994 match_trg->flags = sibling_src->flags | LYD_NEW;
Michal Vasko4490d312020-06-16 13:08:55 +02002995 } else {
2996 /* check descendants, recursively */
Radek Krejcia1c1e542020-09-29 16:06:52 +02002997 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
Michal Vasko4490d312020-06-16 13:08:55 +02002998 LY_CHECK_RET(lyd_merge_sibling_r(lyd_node_children_p(match_trg), match_trg, &child_src, options));
2999 }
3000 }
3001 } else {
3002 /* node not found, merge it */
3003 if (options & LYD_MERGE_DESTRUCT) {
3004 dup_src = (struct lyd_node *)sibling_src;
3005 lyd_unlink_tree(dup_src);
3006 /* spend it */
3007 *sibling_src_p = NULL;
3008 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003009 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 +02003010 }
3011
3012 /* set LYD_NEW for all the new nodes, required for validation */
Michal Vasko56daf732020-08-10 10:57:18 +02003013 LYD_TREE_DFS_BEGIN(dup_src, elem) {
Michal Vasko4490d312020-06-16 13:08:55 +02003014 elem->flags |= LYD_NEW;
Michal Vasko56daf732020-08-10 10:57:18 +02003015 LYD_TREE_DFS_END(dup_src, elem);
Michal Vasko4490d312020-06-16 13:08:55 +02003016 }
3017
3018 lyd_insert_node(parent_trg, first_trg, dup_src);
3019 }
3020
3021 return LY_SUCCESS;
3022}
3023
Michal Vasko3a41dff2020-07-15 14:30:28 +02003024static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003025lyd_merge(struct lyd_node **target, const struct lyd_node *source, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02003026{
3027 const struct lyd_node *sibling_src, *tmp;
Radek Krejci857189e2020-09-01 13:26:36 +02003028 ly_bool first;
Michal Vasko4490d312020-06-16 13:08:55 +02003029
3030 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
3031
3032 if (!source) {
3033 /* nothing to merge */
3034 return LY_SUCCESS;
3035 }
3036
Michal Vasko831422b2020-11-24 11:20:51 +01003037 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003038 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02003039 return LY_EINVAL;
3040 }
3041
3042 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Radek Krejci857189e2020-09-01 13:26:36 +02003043 first = (sibling_src == source) ? 1 : 0;
Michal Vasko4490d312020-06-16 13:08:55 +02003044 LY_CHECK_RET(lyd_merge_sibling_r(target, NULL, &sibling_src, options));
3045 if (first && !sibling_src) {
3046 /* source was spent (unlinked), move to the next node */
3047 source = tmp;
3048 }
3049
Michal Vasko3a41dff2020-07-15 14:30:28 +02003050 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02003051 break;
3052 }
3053 }
3054
3055 if (options & LYD_MERGE_DESTRUCT) {
3056 /* free any leftover source data that were not merged */
3057 lyd_free_siblings((struct lyd_node *)source);
3058 }
3059
3060 return LY_SUCCESS;
3061}
3062
Michal Vasko3a41dff2020-07-15 14:30:28 +02003063API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003064lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003065{
3066 return lyd_merge(target, source, options, 1);
3067}
3068
3069API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003070lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003071{
3072 return lyd_merge(target, source, options, 0);
3073}
3074
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003075static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003076lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003077{
Michal Vasko14654712020-02-06 08:35:21 +01003078 /* ending \0 */
3079 ++reqlen;
3080
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003081 if (reqlen > *buflen) {
3082 if (is_static) {
3083 return LY_EINCOMPLETE;
3084 }
3085
3086 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
3087 if (!*buffer) {
3088 return LY_EMEM;
3089 }
3090
3091 *buflen = reqlen;
3092 }
3093
3094 return LY_SUCCESS;
3095}
3096
Michal Vaskod59035b2020-07-08 12:00:06 +02003097LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003098lyd_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 +02003099{
3100 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003101 size_t len;
3102 const char *val;
3103 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003104
Radek Krejcia1c1e542020-09-29 16:06:52 +02003105 for (key = lyd_child(node); key && (key->schema->flags & LYS_KEY); key = key->next) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003106 val = LYD_CANON_VALUE(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003107 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003108 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003109
3110 quot = '\'';
3111 if (strchr(val, '\'')) {
3112 quot = '"';
3113 }
3114 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003115 }
3116
3117 return LY_SUCCESS;
3118}
3119
3120/**
3121 * @brief Append leaf-list value predicate to path.
3122 *
3123 * @param[in] node Node to print.
3124 * @param[in,out] buffer Buffer to print to.
3125 * @param[in,out] buflen Current buffer length.
3126 * @param[in,out] bufused Current number of characters used in @p buffer.
3127 * @param[in] is_static Whether buffer is static or can be reallocated.
3128 * @return LY_ERR
3129 */
3130static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003131lyd_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 +02003132{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003133 size_t len;
3134 const char *val;
3135 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003136
Michal Vaskob7be7a82020-08-20 09:09:04 +02003137 val = LYD_CANON_VALUE(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01003138 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003139 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003140
3141 quot = '\'';
3142 if (strchr(val, '\'')) {
3143 quot = '"';
3144 }
3145 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
3146
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003147 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003148}
3149
3150/**
3151 * @brief Append node position (relative to its other instances) predicate to path.
3152 *
3153 * @param[in] node Node to print.
3154 * @param[in,out] buffer Buffer to print to.
3155 * @param[in,out] buflen Current buffer length.
3156 * @param[in,out] bufused Current number of characters used in @p buffer.
3157 * @param[in] is_static Whether buffer is static or can be reallocated.
3158 * @return LY_ERR
3159 */
3160static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003161lyd_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 +02003162{
3163 const struct lyd_node *first, *iter;
3164 size_t len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003165 uint64_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003166 char *val = NULL;
3167 LY_ERR rc;
3168
3169 if (node->parent) {
3170 first = node->parent->child;
3171 } else {
Michal Vaskoe070bfe2020-08-31 12:27:25 +02003172 for (first = node; first->prev->next; first = first->prev) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003173 }
3174 pos = 1;
3175 for (iter = first; iter != node; iter = iter->next) {
3176 if (iter->schema == node->schema) {
3177 ++pos;
3178 }
3179 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02003180 if (asprintf(&val, "%" PRIu64, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003181 return LY_EMEM;
3182 }
3183
3184 len = 1 + strlen(val) + 1;
3185 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
3186 if (rc != LY_SUCCESS) {
3187 goto cleanup;
3188 }
3189
3190 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
3191
3192cleanup:
3193 free(val);
3194 return rc;
3195}
3196
3197API char *
3198lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
3199{
Radek Krejci857189e2020-09-01 13:26:36 +02003200 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003201 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01003202 size_t bufused = 0, len;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003203 const struct lyd_node *iter;
3204 const struct lys_module *mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02003205 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003206
3207 LY_CHECK_ARG_RET(NULL, node, NULL);
3208 if (buffer) {
3209 LY_CHECK_ARG_RET(node->schema->module->ctx, buflen > 1, NULL);
3210 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01003211 } else {
3212 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003213 }
3214
3215 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01003216 case LYD_PATH_STD:
3217 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01003218 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01003219 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003220 ++depth;
3221 }
3222
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003223 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01003224 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003225 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01003226 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003227iter_print:
3228 /* print prefix and name */
3229 mod = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02003230 if (iter->schema && (!iter->parent || (iter->schema->module != iter->parent->schema->module))) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003231 mod = iter->schema->module;
3232 }
3233
3234 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01003235 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
3236 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003237 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
3238 if (rc != LY_SUCCESS) {
3239 break;
3240 }
3241
3242 /* print next node */
Radek Krejci1798aae2020-07-14 13:26:06 +02003243 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "",
Michal Vaskoad92b672020-11-12 13:11:31 +01003244 iter->schema ? iter->schema->name : ((struct lyd_node_opaq *)iter)->name.name);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003245
Michal Vasko790b2bc2020-08-03 13:35:06 +02003246 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01003247 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02003248 switch (iter->schema->nodetype) {
3249 case LYS_LIST:
3250 if (iter->schema->flags & LYS_KEYLESS) {
3251 /* print its position */
3252 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3253 } else {
3254 /* print all list keys in predicates */
3255 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
3256 }
3257 break;
3258 case LYS_LEAFLIST:
3259 if (iter->schema->flags & LYS_CONFIG_W) {
3260 /* print leaf-list value */
3261 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
3262 } else {
3263 /* print its position */
3264 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3265 }
3266 break;
3267 default:
3268 /* nothing to print more */
3269 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003270 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003271 }
3272 if (rc != LY_SUCCESS) {
3273 break;
3274 }
3275
Michal Vasko14654712020-02-06 08:35:21 +01003276 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003277 }
3278 break;
3279 }
3280
3281 return buffer;
3282}
Michal Vaskoe444f752020-02-10 12:20:06 +01003283
Michal Vasko25a32822020-07-09 15:48:22 +02003284API struct lyd_meta *
3285lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
3286{
3287 struct lyd_meta *ret = NULL;
3288 const struct ly_ctx *ctx;
3289 const char *prefix, *tmp;
3290 char *str;
3291 size_t pref_len, name_len;
3292
3293 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
3294
3295 if (!first) {
3296 return NULL;
3297 }
3298
3299 ctx = first->annotation->module->ctx;
3300
3301 /* parse the name */
3302 tmp = name;
3303 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3304 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3305 return NULL;
3306 }
3307
3308 /* find the module */
3309 if (prefix) {
3310 str = strndup(prefix, pref_len);
3311 module = ly_ctx_get_module_latest(ctx, str);
3312 free(str);
3313 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", pref_len, prefix), NULL);
3314 }
3315
3316 /* find the metadata */
3317 LY_LIST_FOR(first, first) {
3318 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3319 ret = (struct lyd_meta *)first;
3320 break;
3321 }
3322 }
3323
3324 return ret;
3325}
3326
Michal Vasko9b368d32020-02-14 13:53:31 +01003327API LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003328lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3329{
3330 struct lyd_node **match_p;
3331 struct lyd_node_inner *parent;
3332
Michal Vaskof03ed032020-03-04 13:31:44 +01003333 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003334
Michal Vasko6da1e952020-12-09 18:14:38 +01003335 if (!siblings || (siblings->schema && target->schema &&
3336 (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003337 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003338 if (match) {
3339 *match = NULL;
3340 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003341 return LY_ENOTFOUND;
3342 }
3343
3344 /* find first sibling */
3345 if (siblings->parent) {
3346 siblings = siblings->parent->child;
3347 } else {
3348 while (siblings->prev->next) {
3349 siblings = siblings->prev;
3350 }
3351 }
3352
Michal Vasko9e685082021-01-29 14:49:09 +01003353 parent = siblings->parent;
Michal Vasko6da1e952020-12-09 18:14:38 +01003354 if (parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003355 assert(target->hash);
3356
3357 /* find by hash */
3358 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003359 /* check even value when needed */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003360 if (!(target->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !lyd_compare_single(target, *match_p, 0)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003361 siblings = *match_p;
3362 } else {
3363 siblings = NULL;
3364 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003365 } else {
3366 /* not found */
3367 siblings = NULL;
3368 }
3369 } else {
3370 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02003371 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02003372 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003373 break;
3374 }
3375 }
3376 }
3377
3378 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003379 if (match) {
3380 *match = NULL;
3381 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003382 return LY_ENOTFOUND;
3383 }
3384
Michal Vasko9b368d32020-02-14 13:53:31 +01003385 if (match) {
3386 *match = (struct lyd_node *)siblings;
3387 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003388 return LY_SUCCESS;
3389}
3390
Radek Krejci857189e2020-09-01 13:26:36 +02003391/**
3392 * @brief Comparison callback to match schema node with a schema of a data node.
3393 *
3394 * @param[in] val1_p Pointer to the schema node
3395 * @param[in] val2_p Pointer to the data node
3396 * Implementation of ::values_equal_cb.
3397 */
3398static ly_bool
3399lyd_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 +01003400{
3401 struct lysc_node *val1;
3402 struct lyd_node *val2;
3403
3404 val1 = *((struct lysc_node **)val1_p);
3405 val2 = *((struct lyd_node **)val2_p);
3406
Michal Vasko90932a92020-02-12 14:33:03 +01003407 if (val1 == val2->schema) {
3408 /* schema match is enough */
3409 return 1;
3410 } else {
3411 return 0;
3412 }
3413}
3414
Michal Vasko92239c72020-11-18 18:17:25 +01003415/**
3416 * @brief Search in the given siblings (NOT recursively) for the first schema node data instance.
3417 * Uses hashes - should be used whenever possible for best performance.
3418 *
3419 * @param[in] siblings Siblings to search in including preceding and succeeding nodes.
3420 * @param[in] schema Target data node schema to find.
3421 * @param[out] match Can be NULL, otherwise the found data node.
3422 * @return LY_SUCCESS on success, @p match set.
3423 * @return LY_ENOTFOUND if not found, @p match set to NULL.
3424 * @return LY_ERR value if another error occurred.
3425 */
Michal Vasko90932a92020-02-12 14:33:03 +01003426static LY_ERR
3427lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema, struct lyd_node **match)
3428{
3429 struct lyd_node **match_p;
3430 struct lyd_node_inner *parent;
3431 uint32_t hash;
3432 values_equal_cb ht_cb;
3433
Michal Vaskob104f112020-07-17 09:54:54 +02003434 assert(siblings && schema);
Michal Vasko90932a92020-02-12 14:33:03 +01003435
Michal Vasko9e685082021-01-29 14:49:09 +01003436 parent = siblings->parent;
Michal Vasko08fd6132020-11-18 18:17:45 +01003437 if (parent && parent->schema && parent->children_ht) {
Michal Vasko90932a92020-02-12 14:33:03 +01003438 /* calculate our hash */
3439 hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
3440 hash = dict_hash_multi(hash, schema->name, strlen(schema->name));
3441 hash = dict_hash_multi(hash, NULL, 0);
3442
3443 /* use special hash table function */
3444 ht_cb = lyht_set_cb(parent->children_ht, lyd_hash_table_schema_val_equal);
3445
3446 /* find by hash */
3447 if (!lyht_find(parent->children_ht, &schema, hash, (void **)&match_p)) {
3448 siblings = *match_p;
3449 } else {
3450 /* not found */
3451 siblings = NULL;
3452 }
3453
3454 /* set the original hash table compare function back */
3455 lyht_set_cb(parent->children_ht, ht_cb);
3456 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02003457 /* find first sibling */
3458 if (siblings->parent) {
3459 siblings = siblings->parent->child;
3460 } else {
3461 while (siblings->prev->next) {
3462 siblings = siblings->prev;
3463 }
3464 }
3465
3466 /* search manually without hashes */
Michal Vaskod989ba02020-08-24 10:59:24 +02003467 for ( ; siblings; siblings = siblings->next) {
Michal Vasko90932a92020-02-12 14:33:03 +01003468 if (siblings->schema == schema) {
3469 /* schema match is enough */
3470 break;
3471 }
3472 }
3473 }
3474
3475 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003476 if (match) {
3477 *match = NULL;
3478 }
Michal Vasko90932a92020-02-12 14:33:03 +01003479 return LY_ENOTFOUND;
3480 }
3481
Michal Vasko9b368d32020-02-14 13:53:31 +01003482 if (match) {
3483 *match = (struct lyd_node *)siblings;
3484 }
Michal Vasko90932a92020-02-12 14:33:03 +01003485 return LY_SUCCESS;
3486}
3487
Michal Vaskoe444f752020-02-10 12:20:06 +01003488API LY_ERR
3489lyd_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 +02003490 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003491{
3492 LY_ERR rc;
3493 struct lyd_node *target = NULL;
3494
Michal Vasko4c583e82020-07-17 12:16:14 +02003495 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003496
Michal Vasko08fd6132020-11-18 18:17:45 +01003497 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003498 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003499 if (match) {
3500 *match = NULL;
3501 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003502 return LY_ENOTFOUND;
3503 }
3504
Michal Vaskof03ed032020-03-04 13:31:44 +01003505 if (key_or_value && !val_len) {
3506 val_len = strlen(key_or_value);
3507 }
3508
Michal Vaskob104f112020-07-17 09:54:54 +02003509 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3510 /* create a data node and find the instance */
3511 if (schema->nodetype == LYS_LEAFLIST) {
3512 /* target used attributes: schema, hash, value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003513 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &target);
3514 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003515 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003516 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02003517 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003518 }
3519
3520 /* find it */
3521 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003522 } else {
3523 /* find the first schema node instance */
3524 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003525 }
3526
Michal Vaskoe444f752020-02-10 12:20:06 +01003527 lyd_free_tree(target);
3528 return rc;
3529}
Michal Vaskoccc02342020-05-21 10:09:21 +02003530
3531API LY_ERR
3532lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
3533{
3534 LY_ERR ret = LY_SUCCESS;
3535 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003536 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02003537 uint32_t i;
3538
3539 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
3540
3541 memset(&xp_set, 0, sizeof xp_set);
3542
3543 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003544 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
3545 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003546
3547 /* evaluate expression */
Michal Vasko400e9672021-01-11 13:39:17 +01003548 ret = lyxp_eval(LYD_CTX(ctx_node), exp, NULL, LY_PREF_JSON, NULL, ctx_node, ctx_node, &xp_set, LYXP_IGNORE_WHEN);
Michal Vaskoccc02342020-05-21 10:09:21 +02003549 LY_CHECK_GOTO(ret, cleanup);
3550
3551 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02003552 ret = ly_set_new(set);
3553 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003554
3555 /* transform into ly_set */
3556 if (xp_set.type == LYXP_SET_NODE_SET) {
3557 /* allocate memory for all the elements once (even though not all items must be elements but most likely will be) */
3558 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003559 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(ctx_node)); ret = LY_EMEM, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003560 (*set)->size = xp_set.used;
3561
3562 for (i = 0; i < xp_set.used; ++i) {
3563 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +02003564 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +02003565 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003566 }
3567 }
3568 }
3569
3570cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02003571 lyxp_set_free_content(&xp_set);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003572 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
Radek Krejci8f45abc2020-11-26 12:15:13 +01003573 if (ret) {
3574 ly_set_free(*set, NULL);
3575 *set = NULL;
3576 }
Michal Vaskoccc02342020-05-21 10:09:21 +02003577 return ret;
3578}
Radek Krejcica989142020-11-05 11:32:22 +01003579
Michal Vasko3e1f6552021-01-14 09:27:55 +01003580API LY_ERR
3581lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
3582{
3583 LY_ERR ret = LY_SUCCESS;
3584 struct lyxp_expr *expr = NULL;
3585 struct ly_path *lypath = NULL;
3586
3587 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
3588
3589 /* parse the path */
3590 ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
3591 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
3592 LY_CHECK_GOTO(ret, cleanup);
3593
3594 /* compile the path */
3595 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, expr, LY_PATH_LREF_FALSE,
3596 output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_SINGLE, LY_PREF_JSON,
3597 (void *)LYD_CTX(ctx_node), NULL, &lypath);
3598 LY_CHECK_GOTO(ret, cleanup);
3599
3600 /* evaluate the path */
3601 ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
3602
3603cleanup:
3604 lyxp_expr_free(LYD_CTX(ctx_node), expr);
3605 ly_path_free(LYD_CTX(ctx_node), lypath);
3606 return ret;
3607}
3608
Radek Krejcica989142020-11-05 11:32:22 +01003609API uint32_t
3610lyd_list_pos(const struct lyd_node *instance)
3611{
3612 const struct lyd_node *iter = NULL;
3613 uint32_t pos = 0;
3614
3615 if (!instance || !(instance->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
3616 return 0;
3617 }
3618
3619 /* data instances are ordered, so we can stop when we found instance of other schema node */
3620 for (iter = instance; iter->schema == instance->schema; iter = iter->prev) {
Radek Krejcibb27df32020-11-13 15:39:16 +01003621 if (pos && (iter->next == NULL)) {
Radek Krejcica989142020-11-05 11:32:22 +01003622 /* overrun to the end of the siblings list */
3623 break;
3624 }
3625 ++pos;
3626 }
3627
3628 return pos;
3629}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003630
3631API struct lyd_node *
3632lyd_first_sibling(const struct lyd_node *node)
3633{
3634 struct lyd_node *start;
3635
3636 if (!node) {
3637 return NULL;
3638 }
3639
3640 /* get the first sibling */
3641 if (node->parent) {
3642 start = node->parent->child;
3643 } else {
Radek Krejcibb27df32020-11-13 15:39:16 +01003644 for (start = (struct lyd_node *)node; start->prev->next; start = start->prev) {}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003645 }
3646
3647 return start;
3648}