blob: 2a29a605a5797b560069e6234e0ea47f918faef2 [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
Michal Vaskoe0665742021-02-11 11:08:44 +0100298/**
299 * @brief Parse YANG data into a data tree.
300 *
301 * @param[in] ctx libyang context.
302 * @param[in] parent Parent to connect the parsed nodes to, if any.
303 * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
304 * @param[in] in Input handle to read the input from.
305 * @param[in] format Expected format of the data in @p in.
306 * @param[in] parse_opts Options for parser.
307 * @param[in] val_opts Options for validation.
308 * @param[out] op Optional pointer to the parsed operation, if any.
309 * @return LY_ERR value.
310 */
311static LY_ERR
312lyd_parse(const struct ly_ctx *ctx, struct lyd_node *parent, struct lyd_node **first_p, struct ly_in *in,
313 LYD_FORMAT format, uint32_t parse_opts, uint32_t val_opts, struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200314{
Michal Vaskoe0665742021-02-11 11:08:44 +0100315 LY_ERR rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200316 struct lyd_ctx *lydctx = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100317 struct ly_set parsed = {0};
318 struct lyd_node *first;
319 uint32_t i;
Radek Krejci1798aae2020-07-14 13:26:06 +0200320
Michal Vaskoe0665742021-02-11 11:08:44 +0100321 assert(ctx && (parent || first_p));
Radek Krejci7931b192020-06-25 17:05:03 +0200322
323 format = lyd_parse_get_format(in, format);
Michal Vaskoe0665742021-02-11 11:08:44 +0100324 if (first_p) {
325 *first_p = NULL;
326 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200327
Michal Vasko63f3d842020-07-08 10:10:14 +0200328 /* remember input position */
329 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200330
Michal Vaskoe0665742021-02-11 11:08:44 +0100331 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200332 switch (format) {
333 case LYD_XML:
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100334 rc = lyd_parse_xml(ctx, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, NULL, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200335 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200336 case LYD_JSON:
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100337 rc = lyd_parse_json(ctx, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200338 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200339 case LYD_LYB:
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100340 rc = lyd_parse_lyb(ctx, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200341 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200342 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100343 LOGARG(ctx, format);
344 rc = LY_EINVAL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100345 break;
346 }
347 LY_CHECK_GOTO(rc, cleanup);
348
349 if (parent) {
350 /* get first top-level sibling */
351 for (first = parent; first->parent; first = lyd_parent(first)) {}
352 first = lyd_first_sibling(first);
353 first_p = &first;
Radek Krejci7931b192020-06-25 17:05:03 +0200354 }
355
Michal Vaskoe0665742021-02-11 11:08:44 +0100356 if (!(parse_opts & LYD_PARSE_ONLY)) {
357 /* validate data */
358 rc = lyd_validate(first_p, NULL, ctx, val_opts, 0, &lydctx->node_when, &lydctx->node_types,
359 &lydctx->meta_types, NULL);
360 LY_CHECK_GOTO(rc, cleanup);
361 }
Radek Krejci7931b192020-06-25 17:05:03 +0200362
Michal Vaskoe0665742021-02-11 11:08:44 +0100363 /* set the operation node */
364 if (op) {
365 *op = lydctx->op_node;
Radek Krejci1798aae2020-07-14 13:26:06 +0200366 }
367
368cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +0100369 if (lydctx) {
370 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200371 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100372 if (rc) {
373 if (parent) {
374 /* free all the parsed subtrees */
375 for (i = 0; i < parsed.count; ++i) {
376 lyd_free_tree(parsed.dnodes[i]);
377 }
378 } else {
379 /* free everything */
380 lyd_free_all(*first_p);
381 *first_p = NULL;
382 }
383 }
384 ly_set_erase(&parsed, NULL);
385 return rc;
Radek Krejci7931b192020-06-25 17:05:03 +0200386}
387
388API LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100389lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
390 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
391{
392 LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
393 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
394 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
395
396 return lyd_parse(ctx, parent, tree, in, format, parse_options, validate_options, NULL);
397}
398
399API LY_ERR
400lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
401 uint32_t validate_options, 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_memory(data, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100407 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200408
409 ly_in_free(in, 0);
410 return ret;
411}
412
413API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200414lyd_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 +0200415 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_fd(fd, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100421 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200422
423 ly_in_free(in, 0);
424 return ret;
425}
426
427API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200428lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
429 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200430{
431 LY_ERR ret;
432 struct ly_in *in;
433
434 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100435 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200436
437 ly_in_free(in, 0);
438 return ret;
439}
440
Radek Krejci7931b192020-06-25 17:05:03 +0200441API LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100442lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
443 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200444{
Michal Vaskoe0665742021-02-11 11:08:44 +0100445 LY_ERR rc = LY_SUCCESS;
446 struct lyd_ctx *lydctx = NULL;
447 struct ly_set parsed = {0};
448 struct lyd_node *first = NULL, *envp = NULL;
449 uint32_t i, parse_opts, val_opts;
Radek Krejci7931b192020-06-25 17:05:03 +0200450
Michal Vaskoe0665742021-02-11 11:08:44 +0100451 LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
Michal Vasko27fb0262021-02-23 09:42:01 +0100452 if (!ctx) {
453 ctx = LYD_CTX(parent);
454 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200455 if (tree) {
456 *tree = NULL;
457 }
458 if (op) {
459 *op = NULL;
460 }
461
Radek Krejci7931b192020-06-25 17:05:03 +0200462 format = lyd_parse_get_format(in, format);
Radek Krejci7931b192020-06-25 17:05:03 +0200463
Michal Vasko63f3d842020-07-08 10:10:14 +0200464 /* remember input position */
465 in->func_start = in->current;
466
Michal Vaskoe0665742021-02-11 11:08:44 +0100467 /* check params based on the data type */
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100468 if ((data_type == LYD_TYPE_RPC_NETCONF) || (data_type == LYD_TYPE_NOTIF_NETCONF)) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100469 LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100470 } else if (data_type == LYD_TYPE_REPLY_NETCONF) {
471 LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op,
472 LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100473 }
474 parse_opts = LYD_PARSE_ONLY | LYD_PARSE_STRICT;
475 val_opts = 0;
476
477 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200478 switch (format) {
479 case LYD_XML:
Michal Vaskoe0665742021-02-11 11:08:44 +0100480 rc = lyd_parse_xml(ctx, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
Michal Vasko299d5d12021-02-16 16:36:37 +0100481 if (rc && envp) {
482 /* special situation when the envelopes were parsed successfully */
483 if (tree) {
484 *tree = envp;
485 }
486 ly_set_erase(&parsed, NULL);
487 return rc;
488 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100489 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200490 case LYD_JSON:
Michal Vaskoe0665742021-02-11 11:08:44 +0100491 rc = lyd_parse_json(ctx, parent, &first, in, parse_opts, val_opts, data_type, &parsed, &lydctx);
492 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200493 case LYD_LYB:
Michal Vaskoe0665742021-02-11 11:08:44 +0100494 rc = lyd_parse_lyb(ctx, parent, &first, in, parse_opts, val_opts, data_type, &parsed, &lydctx);
495 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200496 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100497 LOGARG(ctx, format);
498 rc = LY_EINVAL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200499 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200500 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100501 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci7931b192020-06-25 17:05:03 +0200502
Michal Vaskoe0665742021-02-11 11:08:44 +0100503 /* set out params correctly */
504 if (tree) {
505 if (envp) {
506 /* special out param meaning */
507 *tree = envp;
508 } else {
509 *tree = parent ? NULL : first;
510 }
511 }
512 if (op) {
513 *op = lydctx->op_node;
514 }
515
516cleanup:
517 if (lydctx) {
518 lydctx->free(lydctx);
519 }
520 if (rc) {
521 if (parent) {
522 /* free all the parsed subtrees */
523 for (i = 0; i < parsed.count; ++i) {
524 lyd_free_tree(parsed.dnodes[i]);
525 }
526 } else {
527 /* free everything (cannot occur in the current code, a safety) */
528 lyd_free_all(first);
529 if (tree) {
530 *tree = NULL;
531 }
532 if (op) {
533 *op = NULL;
534 }
535 }
536 }
537 ly_set_erase(&parsed, NULL);
538 return rc;
Radek Krejcie7b95092019-05-15 11:03:07 +0200539}
Radek Krejci084289f2019-07-09 17:35:30 +0200540
Michal Vasko90932a92020-02-12 14:33:03 +0100541LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200542lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
543 LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100544{
545 LY_ERR ret;
546 struct lyd_node_term *term;
547
Michal Vasko9b368d32020-02-14 13:53:31 +0100548 assert(schema->nodetype & LYD_NODE_TERM);
549
Michal Vasko90932a92020-02-12 14:33:03 +0100550 term = calloc(1, sizeof *term);
551 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
552
553 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100554 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100555 term->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100556
Radek Krejciddace2c2021-01-08 11:30:56 +0100557 LOG_LOCSET(schema, NULL, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200558 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
Radek Krejci2efc45b2020-12-22 16:25:44 +0100559 value_len, dynamic, format, prefix_data, hints, schema, incomplete);
Radek Krejciddace2c2021-01-08 11:30:56 +0100560 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200561 LY_CHECK_ERR_RET(ret, free(term), ret);
Michal Vasko9e685082021-01-29 14:49:09 +0100562 lyd_hash(&term->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100563
Michal Vasko9e685082021-01-29 14:49:09 +0100564 *node = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100565 return ret;
566}
567
568LY_ERR
569lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
570{
571 LY_ERR ret;
572 struct lyd_node_term *term;
573 struct lysc_type *type;
574
575 assert(schema->nodetype & LYD_NODE_TERM);
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200576 assert(val && val->canonical && val->realtype);
Michal Vasko9b368d32020-02-14 13:53:31 +0100577
578 term = calloc(1, sizeof *term);
579 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
580
581 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100582 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100583 term->flags = LYD_NEW;
584
585 type = ((struct lysc_node_leaf *)schema)->type;
586 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
587 if (ret) {
588 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
589 free(term);
590 return ret;
591 }
Michal Vasko9e685082021-01-29 14:49:09 +0100592 lyd_hash(&term->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100593
Michal Vasko9e685082021-01-29 14:49:09 +0100594 *node = &term->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100595 return ret;
596}
597
598LY_ERR
599lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
600{
601 struct lyd_node_inner *in;
602
Michal Vasko9b368d32020-02-14 13:53:31 +0100603 assert(schema->nodetype & LYD_NODE_INNER);
604
Michal Vasko90932a92020-02-12 14:33:03 +0100605 in = calloc(1, sizeof *in);
606 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
607
608 in->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100609 in->prev = &in->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100610 in->flags = LYD_NEW;
Michal Vasko3383be72020-11-03 17:15:31 +0100611 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
612 in->flags |= LYD_DEFAULT;
613 }
Michal Vasko90932a92020-02-12 14:33:03 +0100614
Michal Vasko9b368d32020-02-14 13:53:31 +0100615 /* do not hash list with keys, we need them for the hash */
616 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100617 lyd_hash(&in->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100618 }
Michal Vasko90932a92020-02-12 14:33:03 +0100619
Michal Vasko9e685082021-01-29 14:49:09 +0100620 *node = &in->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100621 return LY_SUCCESS;
622}
623
Michal Vasko90932a92020-02-12 14:33:03 +0100624LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +0200625lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100626{
627 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100628 struct lyd_node *list = NULL, *key;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200629 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100630
Michal Vasko004d3152020-06-11 19:59:22 +0200631 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
Michal Vasko90932a92020-02-12 14:33:03 +0100632
633 /* create list */
634 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
635
Radek Krejciddace2c2021-01-08 11:30:56 +0100636 LOG_LOCSET(NULL, list, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100637
Michal Vasko90932a92020-02-12 14:33:03 +0100638 /* create and insert all the keys */
Michal Vasko004d3152020-06-11 19:59:22 +0200639 LY_ARRAY_FOR(predicates, u) {
640 LY_CHECK_GOTO(ret = lyd_create_term2(predicates[u].key, &predicates[u].value, &key), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100641 lyd_insert_node(list, NULL, key);
642 }
643
Michal Vasko9b368d32020-02-14 13:53:31 +0100644 /* hash having all the keys */
645 lyd_hash(list);
646
Michal Vasko90932a92020-02-12 14:33:03 +0100647 /* success */
648 *node = list;
649 list = NULL;
650
651cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100652 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko90932a92020-02-12 14:33:03 +0100653 lyd_free_tree(list);
Michal Vasko004d3152020-06-11 19:59:22 +0200654 return ret;
655}
656
657static LY_ERR
658lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
659{
660 LY_ERR ret = LY_SUCCESS;
661 struct lyxp_expr *expr = NULL;
662 uint16_t exp_idx = 0;
663 enum ly_path_pred_type pred_type = 0;
664 struct ly_path_predicate *predicates = NULL;
665
Radek Krejciddace2c2021-01-08 11:30:56 +0100666 LOG_LOCSET(schema, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100667
Michal Vasko004d3152020-06-11 19:59:22 +0200668 /* parse keys */
Michal Vasko6b26e742020-07-17 15:02:10 +0200669 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 +0200670 LY_PATH_PRED_KEYS, &expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200671
672 /* compile them */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200673 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_PREF_JSON,
674 NULL, &predicates, &pred_type), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200675
676 /* create the list node */
677 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, node), cleanup);
678
679cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100680 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200681 lyxp_expr_free(schema->module->ctx, expr);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200682 ly_path_predicates_free(schema->module->ctx, pred_type, predicates);
Michal Vasko90932a92020-02-12 14:33:03 +0100683 return ret;
684}
685
686LY_ERR
Michal Vasko366a4a12020-12-04 16:23:57 +0100687lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, ly_bool use_value,
688 struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100689{
Michal Vasko366a4a12020-12-04 16:23:57 +0100690 LY_ERR ret;
Michal Vasko90932a92020-02-12 14:33:03 +0100691 struct lyd_node_any *any;
Michal Vasko366a4a12020-12-04 16:23:57 +0100692 union lyd_any_value any_val;
Michal Vasko90932a92020-02-12 14:33:03 +0100693
Michal Vasko9b368d32020-02-14 13:53:31 +0100694 assert(schema->nodetype & LYD_NODE_ANY);
695
Michal Vasko90932a92020-02-12 14:33:03 +0100696 any = calloc(1, sizeof *any);
697 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
698
699 any->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100700 any->prev = &any->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100701 any->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100702
Radek Krejci1798aae2020-07-14 13:26:06 +0200703 /* TODO: convert XML/JSON strings into a opaq data tree */
Michal Vasko366a4a12020-12-04 16:23:57 +0100704
705 if (use_value) {
706 any->value.str = value;
707 any->value_type = value_type;
708 } else {
709 any_val.str = value;
Michal Vasko9e685082021-01-29 14:49:09 +0100710 ret = lyd_any_copy_value(&any->node, &any_val, value_type);
Michal Vasko366a4a12020-12-04 16:23:57 +0100711 LY_CHECK_ERR_RET(ret, free(any), ret);
712 }
Michal Vasko9e685082021-01-29 14:49:09 +0100713 lyd_hash(&any->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100714
Michal Vasko9e685082021-01-29 14:49:09 +0100715 *node = &any->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100716 return LY_SUCCESS;
717}
718
Michal Vasko52927e22020-03-16 17:26:14 +0100719LY_ERR
Michal Vasko501af032020-11-11 20:27:44 +0100720lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t pref_len,
721 const char *module_key, size_t module_key_len, const char *value, size_t value_len, ly_bool *dynamic,
722 LY_PREFIX_FORMAT format, void *val_prefix_data, uint32_t hints, struct lyd_node **node)
Michal Vasko52927e22020-03-16 17:26:14 +0100723{
Radek Krejci011e4aa2020-09-04 15:22:31 +0200724 LY_ERR ret = LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +0100725 struct lyd_node_opaq *opaq;
726
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200727 assert(ctx && name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +0100728
729 if (!value_len) {
730 value = "";
731 }
732
733 opaq = calloc(1, sizeof *opaq);
Michal Vasko501af032020-11-11 20:27:44 +0100734 LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100735
Michal Vasko9e685082021-01-29 14:49:09 +0100736 opaq->prev = &opaq->node;
Michal Vaskoad92b672020-11-12 13:11:31 +0100737 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200738
Michal Vasko52927e22020-03-16 17:26:14 +0100739 if (pref_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100740 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->name.prefix), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100741 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200742 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100743 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->name.module_ns), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +0200744 }
Michal Vasko52927e22020-03-16 17:26:14 +0100745 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200746 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100747 *dynamic = 0;
748 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200749 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100750 }
Michal Vasko501af032020-11-11 20:27:44 +0100751
752 opaq->format = format;
753 opaq->val_prefix_data = val_prefix_data;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200754 opaq->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +0100755 opaq->ctx = ctx;
756
Radek Krejci011e4aa2020-09-04 15:22:31 +0200757finish:
758 if (ret) {
Michal Vasko9e685082021-01-29 14:49:09 +0100759 lyd_free_tree(&opaq->node);
Michal Vasko501af032020-11-11 20:27:44 +0100760 ly_free_prefix_data(format, val_prefix_data);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200761 } else {
Michal Vasko9e685082021-01-29 14:49:09 +0100762 *node = &opaq->node;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200763 }
764 return ret;
Michal Vasko52927e22020-03-16 17:26:14 +0100765}
766
Michal Vasko3a41dff2020-07-15 14:30:28 +0200767API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100768lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
769 struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100770{
771 struct lyd_node *ret = NULL;
772 const struct lysc_node *schema;
773 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
774
Michal Vasko6027eb92020-07-15 16:37:30 +0200775 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100776
Michal Vaskof03ed032020-03-04 13:31:44 +0100777 if (!module) {
778 module = parent->schema->module;
779 }
780
Michal Vasko3a41dff2020-07-15 14:30:28 +0200781 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
Radek Krejci41ac9942020-11-02 14:47:56 +0100782 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200783 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 +0100784
Michal Vasko3a41dff2020-07-15 14:30:28 +0200785 LY_CHECK_RET(lyd_create_inner(schema, &ret));
786 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100787 lyd_insert_node(parent, NULL, ret);
788 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200789
790 if (node) {
791 *node = ret;
792 }
793 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100794}
795
Michal Vasko3a41dff2020-07-15 14:30:28 +0200796API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100797lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
798 struct lyd_node **node, ...)
Michal Vasko013a8182020-03-03 10:46:53 +0100799{
800 struct lyd_node *ret = NULL, *key;
801 const struct lysc_node *schema, *key_s;
802 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
803 va_list ap;
804 const char *key_val;
805 LY_ERR rc = LY_SUCCESS;
806
Michal Vasko6027eb92020-07-15 16:37:30 +0200807 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100808
Michal Vaskof03ed032020-03-04 13:31:44 +0100809 if (!module) {
810 module = parent->schema->module;
811 }
812
Radek Krejci41ac9942020-11-02 14:47:56 +0100813 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0, LYS_LIST, output ? LYS_GETNEXT_OUTPUT : 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200814 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100815
816 /* create list inner node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200817 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko013a8182020-03-03 10:46:53 +0100818
Michal Vasko3a41dff2020-07-15 14:30:28 +0200819 va_start(ap, node);
Michal Vasko013a8182020-03-03 10:46:53 +0100820
821 /* create and insert all the keys */
Michal Vasko544e58a2021-01-28 14:33:41 +0100822 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 +0100823 key_val = va_arg(ap, const char *);
824
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200825 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
826 NULL, &key);
827 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko013a8182020-03-03 10:46:53 +0100828 lyd_insert_node(ret, NULL, key);
829 }
830
Michal Vasko013a8182020-03-03 10:46:53 +0100831 if (parent) {
832 lyd_insert_node(parent, NULL, ret);
833 }
834
835cleanup:
Michal Vasko3a41dff2020-07-15 14:30:28 +0200836 va_end(ap);
Michal Vasko013a8182020-03-03 10:46:53 +0100837 if (rc) {
838 lyd_free_tree(ret);
839 ret = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200840 } else if (node) {
841 *node = ret;
Michal Vasko013a8182020-03-03 10:46:53 +0100842 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200843 return rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100844}
845
Michal Vasko3a41dff2020-07-15 14:30:28 +0200846API LY_ERR
847lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
Radek Krejci41ac9942020-11-02 14:47:56 +0100848 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100849{
850 struct lyd_node *ret = NULL;
851 const struct lysc_node *schema;
852 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
853
Michal Vasko6027eb92020-07-15 16:37:30 +0200854 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100855
Michal Vaskof03ed032020-03-04 13:31:44 +0100856 if (!module) {
857 module = parent->schema->module;
858 }
Michal Vasko004d3152020-06-11 19:59:22 +0200859 if (!keys) {
860 keys = "";
861 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100862
Michal Vasko004d3152020-06-11 19:59:22 +0200863 /* find schema node */
Radek Krejci41ac9942020-11-02 14:47:56 +0100864 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 +0200865 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100866
Michal Vasko004d3152020-06-11 19:59:22 +0200867 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
868 /* key-less list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200869 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200870 } else {
871 /* create the list node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200872 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
Michal Vasko004d3152020-06-11 19:59:22 +0200873 }
Michal Vasko004d3152020-06-11 19:59:22 +0200874 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100875 lyd_insert_node(parent, NULL, ret);
876 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200877
878 if (node) {
879 *node = ret;
880 }
881 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100882}
883
Michal Vasko3a41dff2020-07-15 14:30:28 +0200884API LY_ERR
885lyd_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 +0100886 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100887{
Michal Vaskocbff3e92020-05-27 12:56:41 +0200888 LY_ERR rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100889 struct lyd_node *ret = NULL;
890 const struct lysc_node *schema;
891 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
892
Michal Vasko6027eb92020-07-15 16:37:30 +0200893 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100894
Michal Vaskof03ed032020-03-04 13:31:44 +0100895 if (!module) {
896 module = parent->schema->module;
897 }
898
Radek Krejci41ac9942020-11-02 14:47:56 +0100899 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 +0200900 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100901
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200902 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL,
903 &ret);
904 LY_CHECK_RET(rc);
Michal Vaskocbff3e92020-05-27 12:56:41 +0200905 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100906 lyd_insert_node(parent, NULL, ret);
907 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200908
909 if (node) {
910 *node = ret;
911 }
912 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100913}
914
Michal Vasko3a41dff2020-07-15 14:30:28 +0200915API LY_ERR
Michal Vasko219006c2020-12-04 16:26:52 +0100916lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, void *value,
Radek Krejci41ac9942020-11-02 14:47:56 +0100917 LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100918{
919 struct lyd_node *ret = NULL;
920 const struct lysc_node *schema;
921 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
922
Michal Vasko6027eb92020-07-15 16:37:30 +0200923 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100924
Michal Vaskof03ed032020-03-04 13:31:44 +0100925 if (!module) {
926 module = parent->schema->module;
927 }
928
Radek Krejci41ac9942020-11-02 14:47:56 +0100929 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 +0200930 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100931
Michal Vasko366a4a12020-12-04 16:23:57 +0100932 LY_CHECK_RET(lyd_create_any(schema, value, value_type, 1, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200933 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100934 lyd_insert_node(parent, NULL, ret);
935 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200936
937 if (node) {
938 *node = ret;
939 }
940 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100941}
942
Michal Vasko4490d312020-06-16 13:08:55 +0200943/**
944 * @brief Update node value.
945 *
946 * @param[in] node Node to update.
947 * @param[in] value New value to set.
948 * @param[in] value_type Type of @p value for any node.
949 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
950 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
951 * @return LY_ERR value.
952 */
Michal Vasko00cbf532020-06-15 13:58:47 +0200953static LY_ERR
954lyd_new_path_update(struct lyd_node *node, const void *value, LYD_ANYDATA_VALUETYPE value_type,
Radek Krejci0f969882020-08-21 16:56:47 +0200955 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +0200956{
957 LY_ERR ret = LY_SUCCESS;
958 struct lyd_node *new_any;
959
960 switch (node->schema->nodetype) {
961 case LYS_CONTAINER:
962 case LYS_NOTIF:
963 case LYS_RPC:
964 case LYS_ACTION:
965 case LYS_LIST:
966 case LYS_LEAFLIST:
967 /* if it exists, there is nothing to update */
968 *new_parent = NULL;
969 *new_node = NULL;
970 break;
971 case LYS_LEAF:
972 ret = lyd_change_term(node, value);
973 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
974 /* there was an actual change (at least of the default flag) */
975 *new_parent = node;
976 *new_node = node;
977 ret = LY_SUCCESS;
978 } else if (ret == LY_ENOT) {
979 /* no change */
980 *new_parent = NULL;
981 *new_node = NULL;
982 ret = LY_SUCCESS;
983 } /* else error */
984 break;
985 case LYS_ANYDATA:
986 case LYS_ANYXML:
987 /* create a new any node */
Michal Vasko366a4a12020-12-04 16:23:57 +0100988 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, 0, &new_any));
Michal Vasko00cbf532020-06-15 13:58:47 +0200989
990 /* compare with the existing one */
Michal Vasko8f359bf2020-07-28 10:41:15 +0200991 if (lyd_compare_single(node, new_any, 0)) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200992 /* not equal, switch values (so that we can use generic node free) */
993 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
994 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
995 ((struct lyd_node_any *)node)->value.str = value;
996 ((struct lyd_node_any *)node)->value_type = value_type;
997
998 *new_parent = node;
999 *new_node = node;
1000 } else {
1001 /* they are equal */
1002 *new_parent = NULL;
1003 *new_node = NULL;
1004 }
1005 lyd_free_tree(new_any);
1006 break;
1007 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02001008 LOGINT(LYD_CTX(node));
Michal Vasko00cbf532020-06-15 13:58:47 +02001009 ret = LY_EINT;
1010 break;
1011 }
1012
1013 return ret;
1014}
1015
Michal Vasko3a41dff2020-07-15 14:30:28 +02001016API LY_ERR
Michal Vasko871a0252020-11-11 18:35:24 +01001017lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module, const char *name,
1018 const char *val_str, ly_bool clear_dflt, struct lyd_meta **meta)
Michal Vaskod86997b2020-05-26 15:19:54 +02001019{
Michal Vaskod86997b2020-05-26 15:19:54 +02001020 const char *prefix, *tmp;
Michal Vaskod86997b2020-05-26 15:19:54 +02001021 size_t pref_len, name_len;
1022
Michal Vasko871a0252020-11-11 18:35:24 +01001023 LY_CHECK_ARG_RET(NULL, ctx, name, module || strchr(name, ':'), parent || meta, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001024
Michal Vasko871a0252020-11-11 18:35:24 +01001025 if (parent && !parent->schema) {
1026 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1027 return LY_EINVAL;
1028 }
Michal Vasko610553d2020-11-18 18:15:05 +01001029 if (meta) {
1030 *meta = NULL;
1031 }
Michal Vaskod86997b2020-05-26 15:19:54 +02001032
1033 /* parse the name */
1034 tmp = name;
1035 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1036 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko871a0252020-11-11 18:35:24 +01001037 return LY_EINVAL;
Michal Vaskod86997b2020-05-26 15:19:54 +02001038 }
1039
1040 /* find the module */
1041 if (prefix) {
Radek Krejci0ad51f12020-07-16 12:08:12 +02001042 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001043 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 +02001044 }
1045
1046 /* set value if none */
1047 if (!val_str) {
1048 val_str = "";
1049 }
1050
Michal Vasko871a0252020-11-11 18:35:24 +01001051 return lyd_create_meta(parent, meta, module, name, name_len, val_str, strlen(val_str), NULL, LY_PREF_JSON,
1052 NULL, LYD_HINT_DATA, clear_dflt, NULL);
1053}
Michal Vasko3a41dff2020-07-15 14:30:28 +02001054
Michal Vaskoba696702020-11-11 19:12:45 +01001055API LY_ERR
1056lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, ly_bool clear_dflt, const struct lyd_attr *attr,
1057 struct lyd_meta **meta)
1058{
1059 const struct lys_module *mod;
1060
1061 LY_CHECK_ARG_RET(NULL, ctx, attr, parent || meta, LY_EINVAL);
1062
1063 if (parent && !parent->schema) {
1064 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1065 return LY_EINVAL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001066 }
Michal Vasko610553d2020-11-18 18:15:05 +01001067 if (meta) {
1068 *meta = NULL;
1069 }
Michal Vaskoba696702020-11-11 19:12:45 +01001070
1071 switch (attr->format) {
1072 case LY_PREF_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +01001073 mod = ly_ctx_get_module_implemented_ns(ctx, attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001074 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001075 LOGERR(ctx, LY_EINVAL, "Module with namespace \"%s\" not found.", attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001076 return LY_ENOTFOUND;
1077 }
1078 break;
1079 case LY_PREF_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +01001080 mod = ly_ctx_get_module_implemented(ctx, attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001081 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001082 LOGERR(ctx, LY_EINVAL, "Module \"%s\" not found.", attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001083 return LY_ENOTFOUND;
1084 }
1085 break;
1086 default:
1087 LOGINT_RET(ctx);
1088 }
1089
Michal Vaskoad92b672020-11-12 13:11:31 +01001090 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 +01001091 NULL, attr->format, attr->val_prefix_data, attr->hints, clear_dflt, NULL);
Michal Vaskod86997b2020-05-26 15:19:54 +02001092}
1093
Michal Vasko3a41dff2020-07-15 14:30:28 +02001094API LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +02001095lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Michal Vasko0ab974d2021-02-24 13:18:26 +01001096 const char *prefix, const char *module_name, struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001097{
1098 struct lyd_node *ret = NULL;
Michal Vasko0ab974d2021-02-24 13:18:26 +01001099 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_name, !prefix || !strcmp(prefix, module_name), LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001100
1101 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001102 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001103 }
1104 if (!value) {
1105 value = "";
1106 }
1107
Michal Vasko0ab974d2021-02-24 13:18:26 +01001108 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_name,
1109 strlen(module_name), value, strlen(value), NULL, LY_PREF_JSON, NULL, 0, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001110 if (parent) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001111 lyd_insert_node(parent, NULL, ret);
1112 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001113
1114 if (node) {
1115 *node = ret;
1116 }
1117 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001118}
1119
Michal Vasko3a41dff2020-07-15 14:30:28 +02001120API LY_ERR
Michal Vasko8d65f852021-02-17 11:28:13 +01001121lyd_new_opaq2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Michal Vasko0ab974d2021-02-24 13:18:26 +01001122 const char *prefix, const char *module_ns, struct lyd_node **node)
Michal Vasko8d65f852021-02-17 11:28:13 +01001123{
1124 struct lyd_node *ret = NULL;
1125
1126 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_ns, LY_EINVAL);
1127
1128 if (!ctx) {
1129 ctx = LYD_CTX(parent);
1130 }
1131 if (!value) {
1132 value = "";
1133 }
1134
Michal Vasko0ab974d2021-02-24 13:18:26 +01001135 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_ns,
1136 strlen(module_ns), value, strlen(value), NULL, LY_PREF_XML, NULL, 0, &ret));
Michal Vasko8d65f852021-02-17 11:28:13 +01001137 if (parent) {
1138 lyd_insert_node(parent, NULL, ret);
1139 }
1140
1141 if (node) {
1142 *node = ret;
1143 }
1144 return LY_SUCCESS;
1145}
1146
1147API LY_ERR
1148lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *value,
Radek Krejci0f969882020-08-21 16:56:47 +02001149 struct lyd_attr **attr)
Michal Vasko00cbf532020-06-15 13:58:47 +02001150{
Radek Krejci1798aae2020-07-14 13:26:06 +02001151 struct lyd_attr *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02001152 const struct ly_ctx *ctx;
1153 const char *prefix, *tmp;
Michal Vasko51d21b82020-11-13 18:03:54 +01001154 size_t pref_len, name_len, mod_len;
Michal Vasko00cbf532020-06-15 13:58:47 +02001155
Michal Vasko3a41dff2020-07-15 14:30:28 +02001156 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001157
Michal Vaskob7be7a82020-08-20 09:09:04 +02001158 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001159
1160 /* parse the name */
1161 tmp = name;
1162 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
Michal Vaskob69b68c2021-02-17 11:18:16 +01001163 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001164 return LY_EVALID;
Michal Vasko00cbf532020-06-15 13:58:47 +02001165 }
1166
Michal Vasko51d21b82020-11-13 18:03:54 +01001167 /* get the module */
1168 if (module_name) {
1169 mod_len = strlen(module_name);
1170 } else {
1171 module_name = prefix;
1172 mod_len = pref_len;
1173 }
1174
Michal Vasko00cbf532020-06-15 13:58:47 +02001175 /* set value if none */
Michal Vasko8d65f852021-02-17 11:28:13 +01001176 if (!value) {
1177 value = "";
Michal Vasko00cbf532020-06-15 13:58:47 +02001178 }
1179
Michal Vasko8d65f852021-02-17 11:28:13 +01001180 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_name, mod_len, value,
1181 strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA));
1182
1183 if (attr) {
1184 *attr = ret;
1185 }
1186 return LY_SUCCESS;
1187}
1188
1189API LY_ERR
1190lyd_new_attr2(struct lyd_node *parent, const char *module_ns, const char *name, const char *value,
1191 struct lyd_attr **attr)
1192{
1193 struct lyd_attr *ret = NULL;
1194 const struct ly_ctx *ctx;
1195 const char *prefix, *tmp;
1196 size_t pref_len, name_len;
1197
1198 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
1199
1200 ctx = LYD_CTX(parent);
1201
1202 /* parse the name */
1203 tmp = name;
1204 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1205 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
1206 return LY_EVALID;
1207 }
1208
1209 /* set value if none */
1210 if (!value) {
1211 value = "";
1212 }
1213
1214 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_ns,
1215 module_ns ? strlen(module_ns) : 0, value, strlen(value), NULL, LY_PREF_XML, NULL, LYD_HINT_DATA));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001216
1217 if (attr) {
1218 *attr = ret;
1219 }
1220 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001221}
1222
1223API LY_ERR
1224lyd_change_term(struct lyd_node *term, const char *val_str)
1225{
1226 LY_ERR ret = LY_SUCCESS;
1227 struct lysc_type *type;
1228 struct lyd_node_term *t;
1229 struct lyd_node *parent;
1230 struct lyd_value val = {0};
Radek Krejci857189e2020-09-01 13:26:36 +02001231 ly_bool dflt_change, val_change;
Michal Vasko00cbf532020-06-15 13:58:47 +02001232
1233 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1234
1235 if (!val_str) {
1236 val_str = "";
1237 }
1238 t = (struct lyd_node_term *)term;
1239 type = ((struct lysc_node_leaf *)term->schema)->type;
1240
1241 /* parse the new value */
Radek Krejciddace2c2021-01-08 11:30:56 +01001242 LOG_LOCSET(term->schema, term, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001243 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 +01001244 term->schema, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001245 LOG_LOCBACK(term->schema ? 1 : 0, 1, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001246 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001247
1248 /* compare original and new value */
1249 if (type->plugin->compare(&t->value, &val)) {
1250 /* values differ, switch them */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001251 type->plugin->free(LYD_CTX(term), &t->value);
Michal Vasko00cbf532020-06-15 13:58:47 +02001252 t->value = val;
1253 memset(&val, 0, sizeof val);
1254 val_change = 1;
1255 } else {
1256 val_change = 0;
1257 }
1258
1259 /* always clear the default flag */
1260 if (term->flags & LYD_DEFAULT) {
Michal Vasko9e685082021-01-29 14:49:09 +01001261 for (parent = term; parent; parent = lyd_parent(parent)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001262 parent->flags &= ~LYD_DEFAULT;
1263 }
1264 dflt_change = 1;
1265 } else {
1266 dflt_change = 0;
1267 }
1268
1269 if (val_change || dflt_change) {
1270 /* make the node non-validated */
1271 term->flags &= LYD_NEW;
1272 }
1273
1274 if (val_change) {
1275 if (term->schema->nodetype == LYS_LEAFLIST) {
1276 /* leaf-list needs to be hashed again and re-inserted into parent */
1277 lyd_unlink_hash(term);
1278 lyd_hash(term);
1279 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1280 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1281 /* list needs to be updated if its key was changed */
1282 assert(term->parent->schema->nodetype == LYS_LIST);
Michal Vasko9e685082021-01-29 14:49:09 +01001283 lyd_unlink_hash(lyd_parent(term));
1284 lyd_hash(lyd_parent(term));
1285 LY_CHECK_GOTO(ret = lyd_insert_hash(lyd_parent(term)), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001286 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1287 }
1288
1289 /* retrun value */
1290 if (!val_change) {
1291 if (dflt_change) {
1292 /* only default flag change */
1293 ret = LY_EEXIST;
1294 } else {
1295 /* no change */
1296 ret = LY_ENOT;
1297 }
1298 } /* else value changed, LY_SUCCESS */
1299
1300cleanup:
Michal Vasko59512fc2020-12-09 18:13:29 +01001301 if (val.realtype) {
1302 type->plugin->free(LYD_CTX(term), &val);
1303 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001304 return ret;
1305}
1306
Michal Vasko41586352020-07-13 13:54:25 +02001307API LY_ERR
1308lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1309{
1310 LY_ERR ret = LY_SUCCESS;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001311 struct lyd_meta *m2 = NULL;
Michal Vasko41586352020-07-13 13:54:25 +02001312 struct lyd_value val;
Radek Krejci857189e2020-09-01 13:26:36 +02001313 ly_bool val_change;
Michal Vasko41586352020-07-13 13:54:25 +02001314
1315 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1316
1317 if (!val_str) {
1318 val_str = "";
1319 }
1320
1321 /* parse the new value into a new meta structure */
1322 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 +01001323 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, 0, NULL), cleanup);
Michal Vasko41586352020-07-13 13:54:25 +02001324
1325 /* compare original and new value */
1326 if (lyd_compare_meta(meta, m2)) {
1327 /* values differ, switch them */
1328 val = meta->value;
1329 meta->value = m2->value;
1330 m2->value = val;
1331 val_change = 1;
1332 } else {
1333 val_change = 0;
1334 }
1335
1336 /* retrun value */
1337 if (!val_change) {
1338 /* no change */
1339 ret = LY_ENOT;
1340 } /* else value changed, LY_SUCCESS */
1341
1342cleanup:
Michal Vasko1a66a5d2020-11-18 18:15:37 +01001343 lyd_free_meta_single(m2);
Michal Vasko41586352020-07-13 13:54:25 +02001344 return ret;
1345}
1346
Michal Vasko3a41dff2020-07-15 14:30:28 +02001347API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001348lyd_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 +02001349 struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001350{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001351 return lyd_new_path2(parent, ctx, path, value, 0, options, node, NULL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001352}
1353
Michal Vasko6741dc62021-02-04 09:27:45 +01001354static LY_ERR
1355lyd_new_path_check_find_lypath(struct ly_path *path, const char *str_path, const char *value, uint32_t options)
1356{
1357 LY_ERR ret = LY_SUCCESS, r;
1358 const struct lysc_node *schema;
1359 struct ly_path_predicate *pred;
Michal Vasko6f9b4262021-02-04 12:09:56 +01001360 LY_ARRAY_COUNT_TYPE u, new_count;
Michal Vasko6741dc62021-02-04 09:27:45 +01001361
1362 assert(path);
1363
1364 /* go through all the compiled nodes */
1365 LY_ARRAY_FOR(path, u) {
1366 schema = path[u].node;
Michal Vasko6f9b4262021-02-04 12:09:56 +01001367 new_count = u + 1;
Michal Vasko6741dc62021-02-04 09:27:45 +01001368 if ((schema->nodetype == LYS_LIST) && (path[u].pred_type == LY_PATH_PREDTYPE_NONE)) {
1369 if (schema->flags & LYS_KEYLESS) {
1370 /* creating a new keyless list instance */
1371 break;
1372 } else if ((u < LY_ARRAY_COUNT(path) - 1) || !(options & LYD_NEW_PATH_OPAQ)) {
1373 LOG_LOCSET(schema, NULL, NULL, NULL);
1374 LOGVAL(schema->module->ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1375 lys_nodetype2str(schema->nodetype), schema->name, str_path);
1376 LOG_LOCBACK(1, 0, 0, 0);
1377 return LY_EINVAL;
1378 } /* else creating an opaque list without keys */
1379 }
1380 }
1381
Michal Vasko6f9b4262021-02-04 12:09:56 +01001382 if ((schema->nodetype == LYS_LEAFLIST) && (path[new_count - 1].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001383 /* parse leafref value into a predicate, if not defined in the path */
1384 if (!value) {
1385 value = "";
1386 }
1387
1388 r = LY_SUCCESS;
1389 if (options & LYD_NEW_PATH_OPAQ) {
1390 r = lys_value_validate(NULL, schema, value, strlen(value));
1391 }
1392 if (!r) {
1393 /* store the new predicate */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001394 path[new_count - 1].pred_type = LY_PATH_PREDTYPE_LEAFLIST;
1395 LY_ARRAY_NEW_GOTO(schema->module->ctx, path[new_count - 1].predicates, pred, ret, cleanup);
Michal Vasko6741dc62021-02-04 09:27:45 +01001396
1397 ret = lyd_value_store(schema->module->ctx, &pred->value, ((struct lysc_node_leaflist *)schema)->type, value,
1398 strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, schema, NULL);
1399 LY_CHECK_GOTO(ret, cleanup);
1400 ++((struct lysc_type *)pred->value.realtype)->refcount;
1401
1402 if (schema->flags & LYS_CONFIG_R) {
1403 /* creating a new state leaf-list instance */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001404 --new_count;
Michal Vasko6741dc62021-02-04 09:27:45 +01001405 }
1406 } /* else we have opaq flag and the value is not valid, leave no predicate and then create an opaque node */
1407 }
1408
1409 /* hide the nodes that should always be created so they are not found */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001410 while (new_count < LY_ARRAY_COUNT(path)) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001411 LY_ARRAY_DECREMENT(path);
1412 }
1413
1414cleanup:
1415 return ret;
1416}
1417
Michal Vasko00cbf532020-06-15 13:58:47 +02001418API LY_ERR
1419lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001420 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 +02001421{
1422 LY_ERR ret = LY_SUCCESS, r;
1423 struct lyxp_expr *exp = NULL;
1424 struct ly_path *p = NULL;
1425 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1426 const struct lysc_node *schema;
Michal Vasko6741dc62021-02-04 09:27:45 +01001427 LY_ARRAY_COUNT_TYPE path_idx = 0, orig_count;
Michal Vasko00cbf532020-06-15 13:58:47 +02001428
1429 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1430
1431 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001432 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001433 }
1434
1435 /* parse path */
Michal Vasko6b26e742020-07-17 15:02:10 +02001436 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 +02001437 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001438
1439 /* compile path */
1440 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 +02001441 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 +01001442 NULL, NULL, &p), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001443
Michal Vasko6741dc62021-02-04 09:27:45 +01001444 /* check the compiled path before searching existing nodes, it may be shortened */
1445 orig_count = LY_ARRAY_COUNT(p);
1446 LY_CHECK_GOTO(ret = lyd_new_path_check_find_lypath(p, path, value, options), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001447
1448 /* try to find any existing nodes in the path */
1449 if (parent) {
1450 ret = ly_path_eval_partial(p, parent, &path_idx, &node);
1451 if (ret == LY_SUCCESS) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001452 if (orig_count == LY_ARRAY_COUNT(p)) {
1453 /* the node exists, are we supposed to update it or is it just a default? */
1454 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
1455 LOG_LOCSET(NULL, node, NULL, NULL);
1456 LOGVAL(ctx, LYVE_REFERENCE, "Path \"%s\" already exists", path);
1457 LOG_LOCBACK(0, 1, 0, 0);
1458 ret = LY_EEXIST;
1459 goto cleanup;
1460 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001461
Michal Vasko6741dc62021-02-04 09:27:45 +01001462 /* update the existing node */
1463 ret = lyd_new_path_update(node, value, value_type, &nparent, &nnode);
1464 goto cleanup;
1465 } /* else we were not searching for the whole path */
Michal Vasko00cbf532020-06-15 13:58:47 +02001466 } else if (ret == LY_EINCOMPLETE) {
1467 /* some nodes were found, adjust the iterator to the next segment */
1468 ++path_idx;
1469 } else if (ret == LY_ENOTFOUND) {
1470 /* 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 +01001471 if (lysc_data_parent(p[0].node)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001472 node = parent;
1473 }
1474 } else {
1475 /* error */
1476 goto cleanup;
1477 }
1478 }
1479
Michal Vasko6741dc62021-02-04 09:27:45 +01001480 /* restore the full path for creating new nodes */
1481 while (orig_count > LY_ARRAY_COUNT(p)) {
1482 LY_ARRAY_INCREMENT(p);
1483 }
1484
Michal Vasko00cbf532020-06-15 13:58:47 +02001485 /* create all the non-existing nodes in a loop */
Michal Vaskod989ba02020-08-24 10:59:24 +02001486 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001487 cur_parent = node;
1488 schema = p[path_idx].node;
1489
1490 switch (schema->nodetype) {
1491 case LYS_LIST:
1492 if (!(schema->flags & LYS_KEYLESS)) {
Radek Krejci092e33c2020-10-12 15:33:10 +02001493 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001494 /* creating opaque list without keys */
Michal Vasko501af032020-11-11 20:27:44 +01001495 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1496 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1497 LYD_NODEHINT_LIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001498 } else {
Michal Vasko8b776962021-01-12 12:21:49 +01001499 if (p[path_idx].pred_type != LY_PATH_PREDTYPE_LIST) {
1500 LOG_LOCSET(schema, NULL, NULL, NULL);
1501 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1502 lys_nodetype2str(schema->nodetype), schema->name, path);
1503 LOG_LOCBACK(1, 0, 0, 0);
1504 ret = LY_EINVAL;
1505 goto cleanup;
1506 }
1507
Michal Vasko00cbf532020-06-15 13:58:47 +02001508 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, &node), cleanup);
1509 }
1510 break;
1511 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001512 /* fall through */
Michal Vasko00cbf532020-06-15 13:58:47 +02001513 case LYS_CONTAINER:
1514 case LYS_NOTIF:
1515 case LYS_RPC:
1516 case LYS_ACTION:
1517 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1518 break;
1519 case LYS_LEAFLIST:
Radek Krejci092e33c2020-10-12 15:33:10 +02001520 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001521 /* creating opaque leaf-list without value */
Michal Vasko501af032020-11-11 20:27:44 +01001522 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1523 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1524 LYD_NODEHINT_LEAFLIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001525 } else {
1526 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LEAFLIST);
1527 LY_CHECK_GOTO(ret = lyd_create_term2(schema, &p[path_idx].predicates[0].value, &node), cleanup);
1528 }
1529 break;
1530 case LYS_LEAF:
Michal Vasko35880332020-12-08 13:08:12 +01001531 if (lysc_is_key(schema)) {
1532 /* it must have been already created or some error will occur later */
1533 assert(cur_parent);
1534 node = lyd_child(cur_parent);
1535 assert(node && (node->schema == schema));
1536 goto next_iter;
1537 }
1538
1539 /* make sure there is some value */
Michal Vasko00cbf532020-06-15 13:58:47 +02001540 if (!value) {
1541 value = "";
1542 }
1543
1544 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001545 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001546 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001547 }
1548 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001549 ret = lyd_create_term(schema, value, strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &node);
1550 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001551 } else {
1552 /* creating opaque leaf without value */
Michal Vasko501af032020-11-11 20:27:44 +01001553 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, schema->module->name,
1554 strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001555 }
1556 break;
1557 case LYS_ANYDATA:
1558 case LYS_ANYXML:
Michal Vasko366a4a12020-12-04 16:23:57 +01001559 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001560 break;
1561 default:
1562 LOGINT(ctx);
1563 ret = LY_EINT;
1564 goto cleanup;
1565 }
1566
1567 if (cur_parent) {
1568 /* connect to the parent */
1569 lyd_insert_node(cur_parent, NULL, node);
1570 } else if (parent) {
1571 /* connect to top-level siblings */
1572 lyd_insert_node(NULL, &parent, node);
1573 }
1574
Michal Vasko35880332020-12-08 13:08:12 +01001575next_iter:
Michal Vasko00cbf532020-06-15 13:58:47 +02001576 /* update remembered nodes */
1577 if (!nparent) {
1578 nparent = node;
1579 }
1580 nnode = node;
1581 }
1582
1583cleanup:
1584 lyxp_expr_free(ctx, exp);
Michal Vasko6741dc62021-02-04 09:27:45 +01001585 if (p) {
1586 while (orig_count > LY_ARRAY_COUNT(p)) {
1587 LY_ARRAY_INCREMENT(p);
1588 }
1589 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001590 ly_path_free(ctx, p);
1591 if (!ret) {
1592 /* set out params only on success */
1593 if (new_parent) {
1594 *new_parent = nparent;
1595 }
1596 if (new_node) {
1597 *new_node = nnode;
1598 }
Michal Vaskof4b95ba2020-12-11 08:42:33 +01001599 } else {
1600 lyd_free_tree(nparent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001601 }
1602 return ret;
1603}
1604
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001605LY_ERR
1606lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001607 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 +02001608 struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001609{
1610 LY_ERR ret;
Michal Vaskod1e53b92021-01-28 13:11:06 +01001611 const struct lysc_node *iter = NULL;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001612 struct lyd_node *node = NULL;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001613 struct lyd_value **dflts;
1614 LY_ARRAY_COUNT_TYPE u;
Michal Vasko630d9892020-12-08 17:11:08 +01001615 uint32_t getnext_opts;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001616
1617 assert(first && (parent || sparent || mod));
1618
1619 if (!sparent && parent) {
1620 sparent = parent->schema;
1621 }
1622
Michal Vasko630d9892020-12-08 17:11:08 +01001623 getnext_opts = LYS_GETNEXT_WITHCHOICE;
1624 if (impl_opts & LYD_IMPLICIT_OUTPUT) {
1625 getnext_opts |= LYS_GETNEXT_OUTPUT;
1626 }
1627
1628 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, getnext_opts))) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001629 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1630 continue;
Michal Vasko44b19a12020-08-07 09:21:30 +02001631 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1632 continue;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001633 }
1634
1635 switch (iter->nodetype) {
1636 case LYS_CHOICE:
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001637 node = lys_getnext_data(NULL, *first, NULL, iter, NULL);
1638 if (!node && ((struct lysc_node_choice *)iter)->dflt) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001639 /* create default case data */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001640 LY_CHECK_RET(lyd_new_implicit_r(parent, first, &((struct lysc_node_choice *)iter)->dflt->node,
Michal Vasko69730152020-10-09 16:30:07 +02001641 NULL, node_types, node_when, impl_opts, diff));
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001642 } else if (node) {
1643 /* create any default data in the existing case */
1644 assert(node->schema->parent->nodetype == LYS_CASE);
1645 LY_CHECK_RET(lyd_new_implicit_r(parent, first, node->schema->parent, NULL, node_types, node_when,
1646 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001647 }
1648 break;
1649 case LYS_CONTAINER:
1650 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1651 /* create default NP container */
1652 LY_CHECK_RET(lyd_create_inner(iter, &node));
Radek Krejci9a3823e2021-01-27 20:26:46 +01001653 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001654 lyd_insert_node(parent, first, node);
1655
1656 /* cannot be a NP container with when */
Radek Krejci9a3823e2021-01-27 20:26:46 +01001657 assert(!lysc_node_when(iter));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001658
Michal Vaskoe49b6322020-11-05 17:38:36 +01001659 if (diff) {
1660 /* add into diff */
1661 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1662 }
1663
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001664 /* create any default children */
Michal Vaskoe0665742021-02-11 11:08:44 +01001665 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, node_types, node_when,
Michal Vasko69730152020-10-09 16:30:07 +02001666 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001667 }
1668 break;
1669 case LYS_LEAF:
Michal Vasko69730152020-10-09 16:30:07 +02001670 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1671 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001672 /* create default leaf */
1673 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1674 if (ret == LY_EINCOMPLETE) {
1675 if (node_types) {
1676 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001677 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001678 }
1679 } else if (ret) {
1680 return ret;
1681 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001682 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001683 lyd_insert_node(parent, first, node);
1684
Radek Krejci9a3823e2021-01-27 20:26:46 +01001685 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001686 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001687 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001688 }
1689 if (diff) {
1690 /* add into diff */
1691 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1692 }
1693 }
1694 break;
1695 case LYS_LEAFLIST:
Michal Vasko69730152020-10-09 16:30:07 +02001696 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1697 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001698 /* create all default leaf-lists */
1699 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1700 LY_ARRAY_FOR(dflts, u) {
1701 ret = lyd_create_term2(iter, dflts[u], &node);
1702 if (ret == LY_EINCOMPLETE) {
1703 if (node_types) {
1704 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001705 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001706 }
1707 } else if (ret) {
1708 return ret;
1709 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001710 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001711 lyd_insert_node(parent, first, node);
1712
Radek Krejci9a3823e2021-01-27 20:26:46 +01001713 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001714 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001715 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001716 }
1717 if (diff) {
1718 /* add into diff */
1719 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1720 }
1721 }
1722 }
1723 break;
1724 default:
1725 /* without defaults */
1726 break;
1727 }
1728 }
1729
1730 return LY_SUCCESS;
1731}
1732
1733API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001734lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001735{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001736 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01001737 struct lyd_node *node;
1738 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001739
1740 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1741 if (diff) {
1742 *diff = NULL;
1743 }
1744
Michal Vasko56daf732020-08-10 10:57:18 +02001745 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001746 /* skip added default nodes */
Michal Vasko69730152020-10-09 16:30:07 +02001747 if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
1748 (node->schema->nodetype & LYD_NODE_INNER)) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001749 LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, NULL,
Michal Vasko3488ada2020-12-03 14:18:19 +01001750 &node_when, implicit_options, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001751 }
1752
Michal Vasko56daf732020-08-10 10:57:18 +02001753 LYD_TREE_DFS_END(tree, node);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001754 }
1755
Michal Vasko3488ada2020-12-03 14:18:19 +01001756 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001757 LY_CHECK_GOTO(ret = lyd_validate_unres(&tree, NULL, &node_when, NULL, NULL, diff), cleanup);
Michal Vasko3488ada2020-12-03 14:18:19 +01001758
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001759cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01001760 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001761 if (ret && diff) {
1762 lyd_free_all(*diff);
1763 *diff = NULL;
1764 }
1765 return ret;
1766}
1767
1768API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001769lyd_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 +02001770{
1771 const struct lys_module *mod;
1772 struct lyd_node *d = NULL;
1773 uint32_t i = 0;
1774 LY_ERR ret = LY_SUCCESS;
1775
1776 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
1777 if (diff) {
1778 *diff = NULL;
1779 }
1780 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001781 ctx = LYD_CTX(*tree);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001782 }
1783
1784 /* add nodes for each module one-by-one */
1785 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
1786 if (!mod->implemented) {
1787 continue;
1788 }
1789
1790 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
1791 if (d) {
1792 /* merge into one diff */
1793 lyd_insert_sibling(*diff, d, diff);
1794
1795 d = NULL;
1796 }
1797 }
1798
1799cleanup:
1800 if (ret && diff) {
1801 lyd_free_all(*diff);
1802 *diff = NULL;
1803 }
1804 return ret;
1805}
1806
1807API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001808lyd_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 +02001809{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001810 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01001811 struct lyd_node *root, *d = NULL;
1812 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001813
1814 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
1815 if (diff) {
1816 *diff = NULL;
1817 }
1818
1819 /* add all top-level defaults for this module */
Michal Vasko3488ada2020-12-03 14:18:19 +01001820 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, NULL, &node_when, implicit_options, diff), cleanup);
1821
1822 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001823 LY_CHECK_GOTO(ret = lyd_validate_unres(tree, module, &node_when, NULL, NULL, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001824
1825 /* process nested nodes */
1826 LY_LIST_FOR(*tree, root) {
1827 /* skip added default nodes */
1828 if ((root->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
1829 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
1830
1831 if (d) {
1832 /* merge into one diff */
1833 lyd_insert_sibling(*diff, d, diff);
1834
1835 d = NULL;
1836 }
1837 }
1838 }
1839
1840cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01001841 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001842 if (ret && diff) {
1843 lyd_free_all(*diff);
1844 *diff = NULL;
1845 }
1846 return ret;
1847}
1848
Michal Vasko90932a92020-02-12 14:33:03 +01001849struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +02001850lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +01001851{
Michal Vaskob104f112020-07-17 09:54:54 +02001852 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +01001853 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02001854 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +01001855 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +01001856
Michal Vaskob104f112020-07-17 09:54:54 +02001857 assert(new_node);
1858
1859 if (!first_sibling || !new_node->schema) {
1860 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +01001861 return NULL;
1862 }
1863
Michal Vasko93b16062020-12-09 18:14:18 +01001864 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +01001865 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +01001866 getnext_opts = LYS_GETNEXT_OUTPUT;
1867 }
1868
Michal Vaskob104f112020-07-17 09:54:54 +02001869 if (first_sibling->parent && first_sibling->parent->children_ht) {
1870 /* find the anchor using hashes */
1871 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +01001872 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001873 while (schema) {
1874 /* keep trying to find the first existing instance of the closest following schema sibling,
1875 * otherwise return NULL - inserting at the end */
1876 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
1877 break;
1878 }
1879
Michal Vasko93b16062020-12-09 18:14:18 +01001880 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001881 }
1882 } else {
1883 /* find the anchor without hashes */
1884 match = (struct lyd_node *)first_sibling;
1885 if (!lysc_data_parent(new_node->schema)) {
1886 /* we are in top-level, skip all the data from preceding modules */
1887 LY_LIST_FOR(match, match) {
1888 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
1889 break;
1890 }
1891 }
1892 }
1893
1894 /* get the first schema sibling */
1895 sparent = lysc_data_parent(new_node->schema);
Michal Vasko93b16062020-12-09 18:14:18 +01001896 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001897
1898 found = 0;
1899 LY_LIST_FOR(match, match) {
1900 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
1901 /* we have found an opaque node, which must be at the end, so use it OR
1902 * modules do not match, so we must have traversed all the data from new_node module (if any),
1903 * we have found the first node of the next module, that is what we want */
1904 break;
1905 }
1906
1907 /* skip schema nodes until we find the instantiated one */
1908 while (!found) {
1909 if (new_node->schema == schema) {
1910 /* we have found the schema of the new node, continue search to find the first
1911 * data node with a different schema (after our schema) */
1912 found = 1;
1913 break;
1914 }
1915 if (match->schema == schema) {
1916 /* current node (match) is a data node still before the new node, continue search in data */
1917 break;
1918 }
Michal Vasko93b16062020-12-09 18:14:18 +01001919 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02001920 assert(schema);
1921 }
1922
1923 if (found && (match->schema != new_node->schema)) {
1924 /* find the next node after we have found our node schema data instance */
1925 break;
1926 }
1927 }
Michal Vasko90932a92020-02-12 14:33:03 +01001928 }
1929
1930 return match;
1931}
1932
1933/**
1934 * @brief Insert node after a sibling.
1935 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001936 * Handles inserting into NP containers and key-less lists.
1937 *
Michal Vasko90932a92020-02-12 14:33:03 +01001938 * @param[in] sibling Sibling to insert after.
1939 * @param[in] node Node to insert.
1940 */
1941static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001942lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001943{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001944 struct lyd_node_inner *par;
1945
Michal Vasko90932a92020-02-12 14:33:03 +01001946 assert(!node->next && (node->prev == node));
1947
1948 node->next = sibling->next;
1949 node->prev = sibling;
1950 sibling->next = node;
1951 if (node->next) {
1952 /* sibling had a succeeding node */
1953 node->next->prev = node;
1954 } else {
1955 /* sibling was last, find first sibling and change its prev */
1956 if (sibling->parent) {
1957 sibling = sibling->parent->child;
1958 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +02001959 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +01001960 }
1961 sibling->prev = node;
1962 }
1963 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001964
Michal Vasko9f96a052020-03-10 09:41:45 +01001965 for (par = node->parent; par; par = par->parent) {
1966 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
1967 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01001968 par->flags &= ~LYD_DEFAULT;
1969 }
Michal Vaskob104f112020-07-17 09:54:54 +02001970 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01001971 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01001972 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01001973 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01001974 }
Michal Vasko90932a92020-02-12 14:33:03 +01001975}
1976
1977/**
1978 * @brief Insert node before a sibling.
1979 *
Michal Vasko9f96a052020-03-10 09:41:45 +01001980 * Handles inserting into NP containers and key-less lists.
1981 *
Michal Vasko90932a92020-02-12 14:33:03 +01001982 * @param[in] sibling Sibling to insert before.
1983 * @param[in] node Node to insert.
1984 */
1985static void
Michal Vaskof03ed032020-03-04 13:31:44 +01001986lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01001987{
Michal Vasko0249f7c2020-03-05 16:36:40 +01001988 struct lyd_node_inner *par;
1989
Michal Vasko90932a92020-02-12 14:33:03 +01001990 assert(!node->next && (node->prev == node));
1991
1992 node->next = sibling;
1993 /* covers situation of sibling being first */
1994 node->prev = sibling->prev;
1995 sibling->prev = node;
1996 if (node->prev->next) {
1997 /* sibling had a preceding node */
1998 node->prev->next = node;
1999 } else if (sibling->parent) {
2000 /* sibling was first and we must also change parent child pointer */
2001 sibling->parent->child = node;
2002 }
2003 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002004
Michal Vasko9f96a052020-03-10 09:41:45 +01002005 for (par = node->parent; par; par = par->parent) {
2006 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
2007 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01002008 par->flags &= ~LYD_DEFAULT;
2009 }
Michal Vaskob104f112020-07-17 09:54:54 +02002010 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002011 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01002012 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01002013 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01002014 }
Michal Vasko90932a92020-02-12 14:33:03 +01002015}
2016
2017/**
Michal Vaskob104f112020-07-17 09:54:54 +02002018 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +01002019 *
Michal Vasko9f96a052020-03-10 09:41:45 +01002020 * Handles inserting into NP containers and key-less lists.
2021 *
Michal Vasko90932a92020-02-12 14:33:03 +01002022 * @param[in] parent Parent to insert into.
2023 * @param[in] node Node to insert.
2024 */
2025static void
Michal Vaskob104f112020-07-17 09:54:54 +02002026lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002027{
2028 struct lyd_node_inner *par;
2029
Radek Krejcia1c1e542020-09-29 16:06:52 +02002030 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +01002031 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +01002032
2033 par = (struct lyd_node_inner *)parent;
2034
Michal Vaskob104f112020-07-17 09:54:54 +02002035 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +01002036 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002037
Michal Vaskod989ba02020-08-24 10:59:24 +02002038 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002039 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
2040 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01002041 par->flags &= ~LYD_DEFAULT;
2042 }
Michal Vasko52927e22020-03-16 17:26:14 +01002043 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002044 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01002045 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01002046 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01002047 }
Michal Vasko751cb4d2020-07-14 12:25:28 +02002048}
Michal Vasko0249f7c2020-03-05 16:36:40 +01002049
Michal Vasko751cb4d2020-07-14 12:25:28 +02002050/**
2051 * @brief Learn whether a list instance has all the keys.
2052 *
2053 * @param[in] list List instance to check.
2054 * @return non-zero if all the keys were found,
2055 * @return 0 otherwise.
2056 */
2057static int
2058lyd_insert_has_keys(const struct lyd_node *list)
2059{
2060 const struct lyd_node *key;
2061 const struct lysc_node *skey = NULL;
2062
2063 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +02002064 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +02002065 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
2066 if (!key || (key->schema != skey)) {
2067 /* key missing */
2068 return 0;
2069 }
2070
2071 key = key->next;
2072 }
2073
2074 /* all keys found */
2075 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +01002076}
2077
2078void
Michal Vaskob104f112020-07-17 09:54:54 +02002079lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002080{
Michal Vaskob104f112020-07-17 09:54:54 +02002081 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +01002082
Michal Vaskob104f112020-07-17 09:54:54 +02002083 /* inserting list without its keys is not supported */
2084 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +01002085 assert(!parent || !parent->schema ||
2086 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +01002087
Michal Vaskob104f112020-07-17 09:54:54 +02002088 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +01002089 parent = lyd_parent(*first_sibling_p);
Michal Vasko9b368d32020-02-14 13:53:31 +01002090 }
Michal Vasko90932a92020-02-12 14:33:03 +01002091
Michal Vaskob104f112020-07-17 09:54:54 +02002092 /* get first sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01002093 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +01002094
Michal Vaskob104f112020-07-17 09:54:54 +02002095 /* find the anchor, our next node, so we can insert before it */
2096 anchor = lyd_insert_get_next_anchor(first_sibling, node);
2097 if (anchor) {
2098 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +01002099 if (!parent && (*first_sibling_p == anchor)) {
2100 /* move first sibling */
2101 *first_sibling_p = node;
2102 }
Michal Vaskob104f112020-07-17 09:54:54 +02002103 } else if (first_sibling) {
2104 lyd_insert_after_node(first_sibling->prev, node);
2105 } else if (parent) {
2106 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +01002107 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02002108 *first_sibling_p = node;
2109 }
2110
2111 /* insert into parent HT */
2112 lyd_insert_hash(node);
2113
2114 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +02002115 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +02002116 lyd_hash(parent);
2117
2118 /* now we can insert even the list into its parent HT */
2119 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +01002120 }
Michal Vasko90932a92020-02-12 14:33:03 +01002121}
2122
Michal Vasko717a4c32020-12-07 09:40:10 +01002123/**
2124 * @brief Check schema place of a node to be inserted.
2125 *
2126 * @param[in] parent Schema node of the parent data node.
2127 * @param[in] sibling Schema node of a sibling data node.
2128 * @param[in] schema Schema node if the data node to be inserted.
2129 * @return LY_SUCCESS on success.
2130 * @return LY_EINVAL if the place is invalid.
2131 */
Michal Vaskof03ed032020-03-04 13:31:44 +01002132static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +01002133lyd_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 +01002134{
2135 const struct lysc_node *par2;
2136
Michal Vasko62ed12d2020-05-21 10:08:25 +02002137 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +01002138 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
2139 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01002140
Michal Vasko717a4c32020-12-07 09:40:10 +01002141 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002142 /* opaque nodes can be inserted wherever */
2143 return LY_SUCCESS;
2144 }
2145
Michal Vasko717a4c32020-12-07 09:40:10 +01002146 if (!parent) {
2147 parent = lysc_data_parent(sibling);
2148 }
2149
Michal Vaskof03ed032020-03-04 13:31:44 +01002150 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02002151 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01002152
2153 if (parent) {
2154 /* inner node */
2155 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02002156 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02002157 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002158 return LY_EINVAL;
2159 }
2160 } else {
2161 /* top-level node */
2162 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02002163 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002164 return LY_EINVAL;
2165 }
2166 }
2167
2168 return LY_SUCCESS;
2169}
2170
2171API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002172lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01002173{
2174 struct lyd_node *iter;
2175
Michal Vasko0ab974d2021-02-24 13:18:26 +01002176 LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01002177
Michal Vasko717a4c32020-12-07 09:40:10 +01002178 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002179
Michal Vasko0ab974d2021-02-24 13:18:26 +01002180 if (node->schema && (node->schema->flags & LYS_KEY)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002181 LOGERR(parent->schema->module->ctx, LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
2182 return LY_EINVAL;
2183 }
2184
2185 if (node->parent || node->prev->next) {
2186 lyd_unlink_tree(node);
2187 }
2188
2189 while (node) {
2190 iter = node->next;
2191 lyd_unlink_tree(node);
2192 lyd_insert_node(parent, NULL, node);
2193 node = iter;
2194 }
2195 return LY_SUCCESS;
2196}
2197
2198API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002199lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01002200{
2201 struct lyd_node *iter;
2202
Michal Vaskob104f112020-07-17 09:54:54 +02002203 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01002204
Michal Vaskob104f112020-07-17 09:54:54 +02002205 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +01002206 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01002207 }
2208
Michal Vasko553d0b52020-12-04 16:27:52 +01002209 if (sibling == node) {
2210 /* we need to keep the connection to siblings so we can insert into them */
2211 sibling = sibling->prev;
2212 }
2213
Michal Vaskob1b5c262020-03-05 14:29:47 +01002214 if (node->parent || node->prev->next) {
2215 lyd_unlink_tree(node);
2216 }
2217
2218 while (node) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002219 if (lysc_is_key(node->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002220 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +02002221 return LY_EINVAL;
2222 }
2223
Michal Vaskob1b5c262020-03-05 14:29:47 +01002224 iter = node->next;
2225 lyd_unlink_tree(node);
2226 lyd_insert_node(NULL, &sibling, node);
2227 node = iter;
2228 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01002229
Michal Vaskob104f112020-07-17 09:54:54 +02002230 if (first) {
2231 /* find the first sibling */
2232 *first = sibling;
2233 while ((*first)->prev->next) {
2234 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002235 }
2236 }
2237
2238 return LY_SUCCESS;
2239}
2240
Michal Vaskob1b5c262020-03-05 14:29:47 +01002241API LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01002242lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
2243{
Michal Vaskof03ed032020-03-04 13:31:44 +01002244 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2245
Michal Vasko717a4c32020-12-07 09:40:10 +01002246 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002247
Michal Vaskob104f112020-07-17 09:54:54 +02002248 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002249 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002250 return LY_EINVAL;
2251 }
2252
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002253 lyd_unlink_tree(node);
2254 lyd_insert_before_node(sibling, node);
2255 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002256
Michal Vaskof03ed032020-03-04 13:31:44 +01002257 return LY_SUCCESS;
2258}
2259
2260API LY_ERR
2261lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
2262{
Michal Vaskof03ed032020-03-04 13:31:44 +01002263 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2264
Michal Vasko717a4c32020-12-07 09:40:10 +01002265 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002266
Michal Vaskob104f112020-07-17 09:54:54 +02002267 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002268 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002269 return LY_EINVAL;
2270 }
2271
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002272 lyd_unlink_tree(node);
2273 lyd_insert_after_node(sibling, node);
2274 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002275
Michal Vaskof03ed032020-03-04 13:31:44 +01002276 return LY_SUCCESS;
2277}
2278
2279API void
2280lyd_unlink_tree(struct lyd_node *node)
2281{
2282 struct lyd_node *iter;
2283
2284 if (!node) {
2285 return;
2286 }
2287
Michal Vaskob104f112020-07-17 09:54:54 +02002288 /* update hashes while still linked into the tree */
2289 lyd_unlink_hash(node);
2290
Michal Vaskof03ed032020-03-04 13:31:44 +01002291 /* unlink from siblings */
2292 if (node->prev->next) {
2293 node->prev->next = node->next;
2294 }
2295 if (node->next) {
2296 node->next->prev = node->prev;
2297 } else {
2298 /* unlinking the last node */
2299 if (node->parent) {
2300 iter = node->parent->child;
2301 } else {
2302 iter = node->prev;
2303 while (iter->prev != node) {
2304 iter = iter->prev;
2305 }
2306 }
2307 /* update the "last" pointer from the first node */
2308 iter->prev = node->prev;
2309 }
2310
2311 /* unlink from parent */
2312 if (node->parent) {
2313 if (node->parent->child == node) {
2314 /* the node is the first child */
2315 node->parent->child = node->next;
2316 }
2317
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002318 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +02002319 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
2320 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002321 LY_LIST_FOR(node->parent->child, iter) {
2322 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
2323 break;
2324 }
2325 }
2326 if (!iter) {
2327 node->parent->flags |= LYD_DEFAULT;
2328 }
2329 }
2330
Michal Vaskof03ed032020-03-04 13:31:44 +01002331 /* check for keyless list and update its hash */
Michal Vasko9e685082021-01-29 14:49:09 +01002332 for (iter = lyd_parent(node); iter; iter = lyd_parent(iter)) {
Michal Vasko413c7f22020-05-05 12:34:06 +02002333 if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002334 lyd_hash(iter);
2335 }
2336 }
2337
2338 node->parent = NULL;
2339 }
2340
2341 node->next = NULL;
2342 node->prev = node;
2343}
2344
Michal Vaskoa5da3292020-08-12 13:10:50 +02002345void
Michal Vasko871a0252020-11-11 18:35:24 +01002346lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +02002347{
2348 struct lyd_meta *last, *iter;
2349
2350 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02002351
2352 if (!meta) {
2353 return;
2354 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002355
2356 for (iter = meta; iter; iter = iter->next) {
2357 iter->parent = parent;
2358 }
2359
2360 /* insert as the last attribute */
2361 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002362 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02002363 last->next = meta;
2364 } else {
2365 parent->meta = meta;
2366 }
2367
2368 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +01002369 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02002370 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +01002371 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +02002372 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002373}
2374
2375LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01002376lyd_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 +02002377 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 +01002378 void *prefix_data, uint32_t hints, ly_bool clear_dflt, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01002379{
Radek Krejci2efc45b2020-12-22 16:25:44 +01002380 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01002381 struct lysc_ext_instance *ant = NULL;
Michal Vasko9f96a052020-03-10 09:41:45 +01002382 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002383 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +01002384
Michal Vasko9f96a052020-03-10 09:41:45 +01002385 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002386
Radek Krejciddace2c2021-01-08 11:30:56 +01002387 LOG_LOCSET(parent ? parent->schema : NULL, parent, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002388
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002389 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko69730152020-10-09 16:30:07 +02002390 if ((mod->compiled->exts[u].def->plugin == lyext_plugins_internal[LYEXT_PLUGIN_INTERNAL_ANNOTATION].plugin) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002391 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +01002392 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002393 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +01002394 break;
2395 }
2396 }
2397 if (!ant) {
2398 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +01002399 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Michal Vasko90932a92020-02-12 14:33:03 +01002400 mod->name, name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002401 ret = LY_EINVAL;
2402 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +01002403 }
2404
Michal Vasko9f96a052020-03-10 09:41:45 +01002405 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002406 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +01002407 mt->parent = parent;
2408 mt->annotation = ant;
Radek Krejci2efc45b2020-12-22 16:25:44 +01002409 ret = lyd_value_store(mod->ctx, &mt->value, ((struct lyext_metadata *)ant->data)->type, value, value_len, dynamic,
2410 format, prefix_data, hints, parent ? parent->schema : NULL, incomplete);
2411 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
2412 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
2413 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +01002414
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002415 /* insert as the last attribute */
2416 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01002417 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01002418 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002419 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01002420 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002421 }
2422
Michal Vasko9f96a052020-03-10 09:41:45 +01002423 if (meta) {
2424 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002425 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01002426
2427cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01002428 LOG_LOCBACK((parent && parent->schema) ? 1 : 0, parent ? 1 : 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002429 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01002430}
2431
Michal Vaskoa5da3292020-08-12 13:10:50 +02002432void
2433lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
2434{
2435 struct lyd_attr *last, *iter;
2436 struct lyd_node_opaq *opaq;
2437
2438 assert(parent && !parent->schema);
2439
2440 if (!attr) {
2441 return;
2442 }
2443
2444 opaq = (struct lyd_node_opaq *)parent;
2445 for (iter = attr; iter; iter = iter->next) {
2446 iter->parent = opaq;
2447 }
2448
2449 /* insert as the last attribute */
2450 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002451 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02002452 last->next = attr;
2453 } else {
2454 opaq->attr = attr;
2455 }
2456}
2457
Michal Vasko52927e22020-03-16 17:26:14 +01002458LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002459lyd_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 +01002460 const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
2461 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 +01002462{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002463 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02002464 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01002465
2466 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002467 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01002468
2469 if (!value_len) {
2470 value = "";
2471 }
2472
2473 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002474 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02002475
Michal Vaskoad92b672020-11-12 13:11:31 +01002476 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002477 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002478 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002479 }
2480 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002481 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002482 }
2483
Michal Vasko52927e22020-03-16 17:26:14 +01002484 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002485 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
2486 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002487 *dynamic = 0;
2488 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002489 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002490 }
Michal Vasko501af032020-11-11 20:27:44 +01002491 at->format = format;
2492 at->val_prefix_data = val_prefix_data;
2493 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01002494
2495 /* insert as the last attribute */
2496 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002497 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01002498 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002499 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01002500 last->next = at;
2501 }
2502
Radek Krejci011e4aa2020-09-04 15:22:31 +02002503finish:
2504 if (ret) {
2505 lyd_free_attr_single(ctx, at);
2506 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01002507 *attr = at;
2508 }
2509 return LY_SUCCESS;
2510}
2511
Radek Krejci084289f2019-07-09 17:35:30 +02002512API const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02002513lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02002514{
Michal Vasko004d3152020-06-11 19:59:22 +02002515 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02002516
Michal Vasko004d3152020-06-11 19:59:22 +02002517 if (ly_path_eval(path, tree, &target)) {
2518 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02002519 }
2520
Michal Vasko004d3152020-06-11 19:59:22 +02002521 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02002522}
2523
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002524API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002525lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002526{
2527 const struct lyd_node *iter1, *iter2;
2528 struct lyd_node_term *term1, *term2;
2529 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01002530 struct lyd_node_opaq *opaq1, *opaq2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002531 size_t len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02002532
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002533 if (!node1 || !node2) {
2534 if (node1 == node2) {
2535 return LY_SUCCESS;
2536 } else {
2537 return LY_ENOT;
2538 }
2539 }
2540
Michal Vaskob7be7a82020-08-20 09:09:04 +02002541 if ((LYD_CTX(node1) != LYD_CTX(node2)) || (node1->schema != node2->schema)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002542 return LY_ENOT;
2543 }
2544
2545 if (node1->hash != node2->hash) {
2546 return LY_ENOT;
2547 }
Michal Vasko52927e22020-03-16 17:26:14 +01002548 /* 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 +02002549
Michal Vasko52927e22020-03-16 17:26:14 +01002550 if (!node1->schema) {
2551 opaq1 = (struct lyd_node_opaq *)node1;
2552 opaq2 = (struct lyd_node_opaq *)node2;
Michal Vaskoad92b672020-11-12 13:11:31 +01002553 if ((opaq1->name.name != opaq2->name.name) || (opaq1->format != opaq2->format) ||
2554 (opaq1->name.module_ns != opaq2->name.module_ns)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002555 return LY_ENOT;
2556 }
Michal Vasko52927e22020-03-16 17:26:14 +01002557 switch (opaq1->format) {
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002558 case LY_PREF_XML:
2559 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 +01002560 return LY_ENOT;
2561 }
2562 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002563 case LY_PREF_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +02002564 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
2565 if (strcmp(opaq1->value, opaq2->value)) {
2566 return LY_ENOT;
2567 }
2568 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002569 default:
Michal Vasko52927e22020-03-16 17:26:14 +01002570 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002571 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01002572 return LY_EINT;
2573 }
2574 if (options & LYD_COMPARE_FULL_RECURSION) {
2575 iter1 = opaq1->child;
2576 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002577 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01002578 }
2579 return LY_SUCCESS;
2580 } else {
2581 switch (node1->schema->nodetype) {
2582 case LYS_LEAF:
2583 case LYS_LEAFLIST:
2584 if (options & LYD_COMPARE_DEFAULTS) {
2585 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2586 return LY_ENOT;
2587 }
2588 }
2589
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002590 term1 = (struct lyd_node_term *)node1;
2591 term2 = (struct lyd_node_term *)node2;
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002592 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
Michal Vasko52927e22020-03-16 17:26:14 +01002593 case LYS_CONTAINER:
2594 if (options & LYD_COMPARE_DEFAULTS) {
2595 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2596 return LY_ENOT;
2597 }
2598 }
2599 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko9e685082021-01-29 14:49:09 +01002600 iter1 = lyd_child(node1);
2601 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002602 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002603 }
2604 return LY_SUCCESS;
Michal Vasko1bf09392020-03-27 12:38:10 +01002605 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002606 case LYS_ACTION:
2607 if (options & LYD_COMPARE_FULL_RECURSION) {
2608 /* TODO action/RPC
2609 goto all_children_compare;
2610 */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002611 }
2612 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002613 case LYS_NOTIF:
2614 if (options & LYD_COMPARE_FULL_RECURSION) {
2615 /* TODO Notification
2616 goto all_children_compare;
2617 */
2618 }
2619 return LY_SUCCESS;
2620 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01002621 iter1 = lyd_child(node1);
2622 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002623
2624 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
2625 /* lists with keys, their equivalence is based on their keys */
Michal Vasko544e58a2021-01-28 14:33:41 +01002626 for (const struct lysc_node *key = lysc_node_child(node1->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002627 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01002628 key = key->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002629 if (lyd_compare_single(iter1, iter2, options)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002630 return LY_ENOT;
2631 }
2632 iter1 = iter1->next;
2633 iter2 = iter2->next;
2634 }
2635 } else {
2636 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
2637
Radek Krejci0f969882020-08-21 16:56:47 +02002638all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01002639 if (!iter1 && !iter2) {
2640 /* no children, nothing to compare */
2641 return LY_SUCCESS;
2642 }
2643
Michal Vaskod989ba02020-08-24 10:59:24 +02002644 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002645 if (lyd_compare_single(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002646 return LY_ENOT;
2647 }
2648 }
2649 if (iter1 || iter2) {
2650 return LY_ENOT;
2651 }
2652 }
2653 return LY_SUCCESS;
2654 case LYS_ANYXML:
2655 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02002656 any1 = (struct lyd_node_any *)node1;
2657 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01002658
2659 if (any1->value_type != any2->value_type) {
2660 return LY_ENOT;
2661 }
2662 switch (any1->value_type) {
2663 case LYD_ANYDATA_DATATREE:
2664 iter1 = any1->value.tree;
2665 iter2 = any2->value.tree;
2666 goto all_children_compare;
2667 case LYD_ANYDATA_STRING:
2668 case LYD_ANYDATA_XML:
2669 case LYD_ANYDATA_JSON:
2670 len1 = strlen(any1->value.str);
2671 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02002672 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002673 return LY_ENOT;
2674 }
2675 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002676 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02002677 len1 = lyd_lyb_data_length(any1->value.mem);
2678 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko69730152020-10-09 16:30:07 +02002679 if ((len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002680 return LY_ENOT;
2681 }
2682 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002683 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002684 }
2685 }
2686
Michal Vaskob7be7a82020-08-20 09:09:04 +02002687 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002688 return LY_EINT;
2689}
Radek Krejci22ebdba2019-07-25 13:59:43 +02002690
Michal Vasko21725742020-06-29 11:49:25 +02002691API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002692lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02002693{
Michal Vaskod989ba02020-08-24 10:59:24 +02002694 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002695 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
2696 }
2697
Michal Vasko11a81432020-07-28 16:31:29 +02002698 if (node1 == node2) {
2699 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002700 }
Michal Vasko11a81432020-07-28 16:31:29 +02002701 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002702}
2703
2704API LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02002705lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
2706{
2707 if (!meta1 || !meta2) {
2708 if (meta1 == meta2) {
2709 return LY_SUCCESS;
2710 } else {
2711 return LY_ENOT;
2712 }
2713 }
2714
Michal Vaskoa8083062020-11-06 17:22:10 +01002715 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02002716 return LY_ENOT;
2717 }
2718
Michal Vasko21725742020-06-29 11:49:25 +02002719 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
2720}
2721
Radek Krejci22ebdba2019-07-25 13:59:43 +02002722/**
Michal Vasko52927e22020-03-16 17:26:14 +01002723 * @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 +02002724 *
2725 * 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 +02002726 *
2727 * @param[in] node Original node to duplicate
2728 * @param[in] parent Parent to insert into, NULL for top-level sibling.
2729 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2730 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2731 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it int @p parent / @p first sibling).
2732 * @return LY_ERR value
Radek Krejci22ebdba2019-07-25 13:59:43 +02002733 */
Michal Vasko52927e22020-03-16 17:26:14 +01002734static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002735lyd_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 +02002736 struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002737{
Michal Vasko52927e22020-03-16 17:26:14 +01002738 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002739 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002740 struct lyd_meta *meta;
2741 struct lyd_node_any *any;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002742
Michal Vasko52927e22020-03-16 17:26:14 +01002743 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002744
Michal Vasko52927e22020-03-16 17:26:14 +01002745 if (!node->schema) {
2746 dup = calloc(1, sizeof(struct lyd_node_opaq));
2747 } else {
2748 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01002749 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002750 case LYS_ACTION:
2751 case LYS_NOTIF:
2752 case LYS_CONTAINER:
2753 case LYS_LIST:
2754 dup = calloc(1, sizeof(struct lyd_node_inner));
2755 break;
2756 case LYS_LEAF:
2757 case LYS_LEAFLIST:
2758 dup = calloc(1, sizeof(struct lyd_node_term));
2759 break;
2760 case LYS_ANYDATA:
2761 case LYS_ANYXML:
2762 dup = calloc(1, sizeof(struct lyd_node_any));
2763 break;
2764 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02002765 LOGINT(LYD_CTX(node));
Michal Vasko52927e22020-03-16 17:26:14 +01002766 ret = LY_EINT;
2767 goto error;
2768 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002769 }
Michal Vaskob7be7a82020-08-20 09:09:04 +02002770 LY_CHECK_ERR_GOTO(!dup, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002771
Michal Vaskof6df0a02020-06-16 13:08:34 +02002772 if (options & LYD_DUP_WITH_FLAGS) {
2773 dup->flags = node->flags;
2774 } else {
2775 dup->flags = (node->flags & LYD_DEFAULT) | LYD_NEW;
2776 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002777 dup->schema = node->schema;
Michal Vasko52927e22020-03-16 17:26:14 +01002778 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002779
Michal Vasko25a32822020-07-09 15:48:22 +02002780 /* duplicate metadata */
2781 if (!(options & LYD_DUP_NO_META)) {
2782 LY_LIST_FOR(node->meta, meta) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002783 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
Michal Vasko25a32822020-07-09 15:48:22 +02002784 }
2785 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002786
2787 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01002788 if (!dup->schema) {
2789 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
2790 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
2791 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002792
2793 if (options & LYD_DUP_RECURSIVE) {
2794 /* duplicate all the children */
2795 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002796 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002797 }
2798 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002799 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.name, 0, &opaq->name.name), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002800 opaq->format = orig->format;
Michal Vaskoad92b672020-11-12 13:11:31 +01002801 if (orig->name.prefix) {
2802 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.prefix, 0, &opaq->name.prefix), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002803 }
Michal Vaskoad92b672020-11-12 13:11:31 +01002804 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 +01002805 if (orig->val_prefix_data) {
2806 ret = ly_dup_prefix_data(LYD_CTX(node), opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
2807 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002808 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02002809 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->value, 0, &opaq->value), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002810 opaq->ctx = orig->ctx;
2811 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
2812 struct lyd_node_term *term = (struct lyd_node_term *)dup;
2813 struct lyd_node_term *orig = (struct lyd_node_term *)node;
2814
2815 term->hash = orig->hash;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002816 LY_CHECK_ERR_GOTO(orig->value.realtype->plugin->duplicate(LYD_CTX(node), &orig->value, &term->value),
Michal Vasko69730152020-10-09 16:30:07 +02002817 LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."); ret = LY_EINT, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002818 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
2819 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
2820 struct lyd_node *child;
2821
2822 if (options & LYD_DUP_RECURSIVE) {
2823 /* duplicate all the children */
2824 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002825 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002826 }
Michal Vasko69730152020-10-09 16:30:07 +02002827 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002828 /* always duplicate keys of a list */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002829 child = orig->child;
Michal Vasko544e58a2021-01-28 14:33:41 +01002830 for (const struct lysc_node *key = lysc_node_child(dup->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002831 key && (key->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +02002832 key = key->next) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002833 if (!child) {
2834 /* possibly not keys are present in filtered tree */
2835 break;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002836 } else if (child->schema != key) {
2837 /* possibly not all keys are present in filtered tree,
2838 * but there can be also some non-key nodes */
2839 continue;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002840 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002841 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002842 child = child->next;
2843 }
2844 }
2845 lyd_hash(dup);
2846 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02002847 dup->hash = node->hash;
2848 any = (struct lyd_node_any *)node;
2849 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002850 }
2851
Michal Vasko52927e22020-03-16 17:26:14 +01002852 /* insert */
2853 lyd_insert_node(parent, first, dup);
Michal Vasko52927e22020-03-16 17:26:14 +01002854
2855 if (dup_p) {
2856 *dup_p = dup;
2857 }
2858 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002859
2860error:
Michal Vasko52927e22020-03-16 17:26:14 +01002861 lyd_free_tree(dup);
2862 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002863}
2864
Michal Vasko3a41dff2020-07-15 14:30:28 +02002865static LY_ERR
2866lyd_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 +02002867 struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002868{
Michal Vasko3a41dff2020-07-15 14:30:28 +02002869 const struct lyd_node_inner *orig_parent, *iter;
Radek Krejci857189e2020-09-01 13:26:36 +02002870 ly_bool repeat = 1;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002871
2872 *dup_parent = NULL;
2873 *local_parent = NULL;
2874
2875 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
2876 if (parent && (parent->schema == orig_parent->schema)) {
2877 /* stop creating parents, connect what we have into the provided parent */
2878 iter = parent;
2879 repeat = 0;
2880 } else {
2881 iter = NULL;
2882 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, NULL, (struct lyd_node **)&iter, 0,
Radek Krejci0f969882020-08-21 16:56:47 +02002883 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02002884 }
2885 if (!*local_parent) {
2886 *local_parent = (struct lyd_node_inner *)iter;
2887 }
2888 if (iter->child) {
2889 /* 1) list - add after keys
2890 * 2) provided parent with some children */
2891 iter->child->prev->next = *dup_parent;
2892 if (*dup_parent) {
2893 (*dup_parent)->prev = iter->child->prev;
2894 iter->child->prev = *dup_parent;
2895 }
2896 } else {
2897 ((struct lyd_node_inner *)iter)->child = *dup_parent;
2898 }
2899 if (*dup_parent) {
2900 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
2901 }
2902 *dup_parent = (struct lyd_node *)iter;
2903 }
2904
2905 if (repeat && parent) {
2906 /* given parent and created parents chain actually do not interconnect */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002907 LOGERR(LYD_CTX(node), LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02002908 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002909 return LY_EINVAL;
2910 }
2911
2912 return LY_SUCCESS;
2913}
2914
2915static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002916lyd_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 +02002917{
2918 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002919 const struct lyd_node *orig; /* original node to be duplicated */
2920 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002921 struct lyd_node *top = NULL; /* the most higher created node */
2922 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02002923
Michal Vasko3a41dff2020-07-15 14:30:28 +02002924 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002925
2926 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002927 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, parent, &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002928 } else {
2929 local_parent = parent;
2930 }
2931
Radek Krejci22ebdba2019-07-25 13:59:43 +02002932 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01002933 if (lysc_is_key(orig->schema)) {
2934 if (local_parent) {
2935 /* the key must already exist in the parent */
2936 rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
2937 LY_CHECK_ERR_GOTO(rc, LOGINT(LYD_CTX(node)), error);
2938 } else {
2939 assert(!(options & LYD_DUP_WITH_PARENTS));
2940 /* duplicating a single key, okay, I suppose... */
2941 rc = lyd_dup_r(orig, NULL, &first, options, first ? NULL : &first);
2942 LY_CHECK_GOTO(rc, error);
2943 }
2944 } else {
2945 /* if there is no local parent, it will be inserted into first */
Michal Vasko9e685082021-01-29 14:49:09 +01002946 rc = lyd_dup_r(orig, &local_parent->node, &first, options, first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01002947 LY_CHECK_GOTO(rc, error);
2948 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002949 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002950 break;
2951 }
2952 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002953
2954 /* rehash if needed */
Michal Vaskod989ba02020-08-24 10:59:24 +02002955 for ( ; local_parent; local_parent = local_parent->parent) {
Michal Vasko69730152020-10-09 16:30:07 +02002956 if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +01002957 lyd_hash(&local_parent->node);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002958 }
2959 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002960
2961 if (dup) {
2962 *dup = first;
2963 }
2964 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002965
2966error:
2967 if (top) {
2968 lyd_free_tree(top);
2969 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01002970 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002971 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002972 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002973}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002974
Michal Vasko3a41dff2020-07-15 14:30:28 +02002975API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002976lyd_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 +02002977{
2978 return lyd_dup(node, parent, options, 1, dup);
2979}
2980
2981API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002982lyd_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 +02002983{
2984 return lyd_dup(node, parent, options, 0, dup);
2985}
2986
2987API LY_ERR
2988lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02002989{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002990 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002991 struct lyd_meta *mt, *last;
2992
Michal Vasko3a41dff2020-07-15 14:30:28 +02002993 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02002994
2995 /* create a copy */
2996 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02002997 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02002998 mt->annotation = meta->annotation;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002999 ret = meta->value.realtype->plugin->duplicate(LYD_CTX(node), &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02003000 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
3001 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02003002
3003 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02003004 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02003005 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02003006 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02003007 last->next = mt;
3008 } else {
3009 node->meta = mt;
3010 }
3011
Radek Krejci011e4aa2020-09-04 15:22:31 +02003012finish:
3013 if (ret) {
3014 lyd_free_meta_single(mt);
3015 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003016 *dup = mt;
3017 }
3018 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02003019}
3020
Michal Vasko4490d312020-06-16 13:08:55 +02003021/**
3022 * @brief Merge a source sibling into target siblings.
3023 *
3024 * @param[in,out] first_trg First target sibling, is updated if top-level.
3025 * @param[in] parent_trg Target parent.
3026 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
3027 * @param[in] options Merge options.
3028 * @return LY_ERR value.
3029 */
3030static LY_ERR
3031lyd_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 +02003032 uint16_t options)
Michal Vasko4490d312020-06-16 13:08:55 +02003033{
3034 LY_ERR ret;
3035 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02003036 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vasko4490d312020-06-16 13:08:55 +02003037 struct lysc_type *type;
Michal Vasko4490d312020-06-16 13:08:55 +02003038
3039 sibling_src = *sibling_src_p;
3040 if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
3041 /* try to find the exact instance */
3042 ret = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
3043 } else {
3044 /* try to simply find the node, there cannot be more instances */
3045 ret = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
3046 }
3047
3048 if (!ret) {
3049 /* node found, make sure even value matches for all node types */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003050 if ((match_trg->schema->nodetype == LYS_LEAF) && lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02003051 /* since they are different, they cannot both be default */
3052 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
3053
Michal Vasko3a41dff2020-07-15 14:30:28 +02003054 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
3055 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02003056 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02003057 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
3058 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02003059 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02003060
3061 /* copy flags and add LYD_NEW */
3062 match_trg->flags = sibling_src->flags | LYD_NEW;
3063 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02003064 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02003065 /* update value */
3066 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02003067 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02003068
3069 /* copy flags and add LYD_NEW */
3070 match_trg->flags = sibling_src->flags | LYD_NEW;
Michal Vasko4490d312020-06-16 13:08:55 +02003071 } else {
3072 /* check descendants, recursively */
Radek Krejcia1c1e542020-09-29 16:06:52 +02003073 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
Michal Vaskoe0665742021-02-11 11:08:44 +01003074 LY_CHECK_RET(lyd_merge_sibling_r(lyd_node_child_p(match_trg), match_trg, &child_src, options));
Michal Vasko4490d312020-06-16 13:08:55 +02003075 }
3076 }
3077 } else {
3078 /* node not found, merge it */
3079 if (options & LYD_MERGE_DESTRUCT) {
3080 dup_src = (struct lyd_node *)sibling_src;
3081 lyd_unlink_tree(dup_src);
3082 /* spend it */
3083 *sibling_src_p = NULL;
3084 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003085 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 +02003086 }
3087
3088 /* set LYD_NEW for all the new nodes, required for validation */
Michal Vasko56daf732020-08-10 10:57:18 +02003089 LYD_TREE_DFS_BEGIN(dup_src, elem) {
Michal Vasko4490d312020-06-16 13:08:55 +02003090 elem->flags |= LYD_NEW;
Michal Vasko56daf732020-08-10 10:57:18 +02003091 LYD_TREE_DFS_END(dup_src, elem);
Michal Vasko4490d312020-06-16 13:08:55 +02003092 }
3093
3094 lyd_insert_node(parent_trg, first_trg, dup_src);
3095 }
3096
3097 return LY_SUCCESS;
3098}
3099
Michal Vasko3a41dff2020-07-15 14:30:28 +02003100static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003101lyd_merge(struct lyd_node **target, const struct lyd_node *source, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02003102{
3103 const struct lyd_node *sibling_src, *tmp;
Radek Krejci857189e2020-09-01 13:26:36 +02003104 ly_bool first;
Michal Vasko4490d312020-06-16 13:08:55 +02003105
3106 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
3107
3108 if (!source) {
3109 /* nothing to merge */
3110 return LY_SUCCESS;
3111 }
3112
Michal Vasko831422b2020-11-24 11:20:51 +01003113 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003114 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02003115 return LY_EINVAL;
3116 }
3117
3118 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Radek Krejci857189e2020-09-01 13:26:36 +02003119 first = (sibling_src == source) ? 1 : 0;
Michal Vasko4490d312020-06-16 13:08:55 +02003120 LY_CHECK_RET(lyd_merge_sibling_r(target, NULL, &sibling_src, options));
3121 if (first && !sibling_src) {
3122 /* source was spent (unlinked), move to the next node */
3123 source = tmp;
3124 }
3125
Michal Vasko3a41dff2020-07-15 14:30:28 +02003126 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02003127 break;
3128 }
3129 }
3130
3131 if (options & LYD_MERGE_DESTRUCT) {
3132 /* free any leftover source data that were not merged */
3133 lyd_free_siblings((struct lyd_node *)source);
3134 }
3135
3136 return LY_SUCCESS;
3137}
3138
Michal Vasko3a41dff2020-07-15 14:30:28 +02003139API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003140lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003141{
3142 return lyd_merge(target, source, options, 1);
3143}
3144
3145API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003146lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003147{
3148 return lyd_merge(target, source, options, 0);
3149}
3150
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003151static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003152lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003153{
Michal Vasko14654712020-02-06 08:35:21 +01003154 /* ending \0 */
3155 ++reqlen;
3156
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003157 if (reqlen > *buflen) {
3158 if (is_static) {
3159 return LY_EINCOMPLETE;
3160 }
3161
3162 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
3163 if (!*buffer) {
3164 return LY_EMEM;
3165 }
3166
3167 *buflen = reqlen;
3168 }
3169
3170 return LY_SUCCESS;
3171}
3172
Michal Vaskod59035b2020-07-08 12:00:06 +02003173LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003174lyd_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 +02003175{
3176 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003177 size_t len;
3178 const char *val;
3179 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003180
Radek Krejcia1c1e542020-09-29 16:06:52 +02003181 for (key = lyd_child(node); key && (key->schema->flags & LYS_KEY); key = key->next) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003182 val = LYD_CANON_VALUE(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003183 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003184 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003185
3186 quot = '\'';
3187 if (strchr(val, '\'')) {
3188 quot = '"';
3189 }
3190 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003191 }
3192
3193 return LY_SUCCESS;
3194}
3195
3196/**
3197 * @brief Append leaf-list value predicate to path.
3198 *
3199 * @param[in] node Node to print.
3200 * @param[in,out] buffer Buffer to print to.
3201 * @param[in,out] buflen Current buffer length.
3202 * @param[in,out] bufused Current number of characters used in @p buffer.
3203 * @param[in] is_static Whether buffer is static or can be reallocated.
3204 * @return LY_ERR
3205 */
3206static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003207lyd_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 +02003208{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003209 size_t len;
3210 const char *val;
3211 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003212
Michal Vaskob7be7a82020-08-20 09:09:04 +02003213 val = LYD_CANON_VALUE(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01003214 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003215 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003216
3217 quot = '\'';
3218 if (strchr(val, '\'')) {
3219 quot = '"';
3220 }
3221 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
3222
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003223 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003224}
3225
3226/**
3227 * @brief Append node position (relative to its other instances) predicate to path.
3228 *
3229 * @param[in] node Node to print.
3230 * @param[in,out] buffer Buffer to print to.
3231 * @param[in,out] buflen Current buffer length.
3232 * @param[in,out] bufused Current number of characters used in @p buffer.
3233 * @param[in] is_static Whether buffer is static or can be reallocated.
3234 * @return LY_ERR
3235 */
3236static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003237lyd_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 +02003238{
3239 const struct lyd_node *first, *iter;
3240 size_t len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003241 uint64_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003242 char *val = NULL;
3243 LY_ERR rc;
3244
3245 if (node->parent) {
3246 first = node->parent->child;
3247 } else {
Michal Vaskoe070bfe2020-08-31 12:27:25 +02003248 for (first = node; first->prev->next; first = first->prev) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003249 }
3250 pos = 1;
3251 for (iter = first; iter != node; iter = iter->next) {
3252 if (iter->schema == node->schema) {
3253 ++pos;
3254 }
3255 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02003256 if (asprintf(&val, "%" PRIu64, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003257 return LY_EMEM;
3258 }
3259
3260 len = 1 + strlen(val) + 1;
3261 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
3262 if (rc != LY_SUCCESS) {
3263 goto cleanup;
3264 }
3265
3266 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
3267
3268cleanup:
3269 free(val);
3270 return rc;
3271}
3272
3273API char *
3274lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
3275{
Radek Krejci857189e2020-09-01 13:26:36 +02003276 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003277 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01003278 size_t bufused = 0, len;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003279 const struct lyd_node *iter;
3280 const struct lys_module *mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02003281 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003282
3283 LY_CHECK_ARG_RET(NULL, node, NULL);
3284 if (buffer) {
3285 LY_CHECK_ARG_RET(node->schema->module->ctx, buflen > 1, NULL);
3286 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01003287 } else {
3288 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003289 }
3290
3291 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01003292 case LYD_PATH_STD:
3293 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01003294 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01003295 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003296 ++depth;
3297 }
3298
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003299 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01003300 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003301 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01003302 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003303iter_print:
3304 /* print prefix and name */
3305 mod = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02003306 if (iter->schema && (!iter->parent || (iter->schema->module != iter->parent->schema->module))) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003307 mod = iter->schema->module;
3308 }
3309
3310 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01003311 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
3312 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003313 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
3314 if (rc != LY_SUCCESS) {
3315 break;
3316 }
3317
3318 /* print next node */
Radek Krejci1798aae2020-07-14 13:26:06 +02003319 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "",
Michal Vaskoad92b672020-11-12 13:11:31 +01003320 iter->schema ? iter->schema->name : ((struct lyd_node_opaq *)iter)->name.name);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003321
Michal Vasko790b2bc2020-08-03 13:35:06 +02003322 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01003323 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02003324 switch (iter->schema->nodetype) {
3325 case LYS_LIST:
3326 if (iter->schema->flags & LYS_KEYLESS) {
3327 /* print its position */
3328 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3329 } else {
3330 /* print all list keys in predicates */
3331 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
3332 }
3333 break;
3334 case LYS_LEAFLIST:
3335 if (iter->schema->flags & LYS_CONFIG_W) {
3336 /* print leaf-list value */
3337 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
3338 } else {
3339 /* print its position */
3340 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3341 }
3342 break;
3343 default:
3344 /* nothing to print more */
3345 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003346 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003347 }
3348 if (rc != LY_SUCCESS) {
3349 break;
3350 }
3351
Michal Vasko14654712020-02-06 08:35:21 +01003352 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003353 }
3354 break;
3355 }
3356
3357 return buffer;
3358}
Michal Vaskoe444f752020-02-10 12:20:06 +01003359
Michal Vasko25a32822020-07-09 15:48:22 +02003360API struct lyd_meta *
3361lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
3362{
3363 struct lyd_meta *ret = NULL;
3364 const struct ly_ctx *ctx;
3365 const char *prefix, *tmp;
3366 char *str;
3367 size_t pref_len, name_len;
3368
3369 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
3370
3371 if (!first) {
3372 return NULL;
3373 }
3374
3375 ctx = first->annotation->module->ctx;
3376
3377 /* parse the name */
3378 tmp = name;
3379 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3380 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3381 return NULL;
3382 }
3383
3384 /* find the module */
3385 if (prefix) {
3386 str = strndup(prefix, pref_len);
3387 module = ly_ctx_get_module_latest(ctx, str);
3388 free(str);
3389 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", pref_len, prefix), NULL);
3390 }
3391
3392 /* find the metadata */
3393 LY_LIST_FOR(first, first) {
3394 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3395 ret = (struct lyd_meta *)first;
3396 break;
3397 }
3398 }
3399
3400 return ret;
3401}
3402
Michal Vasko9b368d32020-02-14 13:53:31 +01003403API LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003404lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3405{
3406 struct lyd_node **match_p;
3407 struct lyd_node_inner *parent;
3408
Michal Vaskof03ed032020-03-04 13:31:44 +01003409 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003410
Michal Vasko6da1e952020-12-09 18:14:38 +01003411 if (!siblings || (siblings->schema && target->schema &&
3412 (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003413 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003414 if (match) {
3415 *match = NULL;
3416 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003417 return LY_ENOTFOUND;
3418 }
3419
3420 /* find first sibling */
3421 if (siblings->parent) {
3422 siblings = siblings->parent->child;
3423 } else {
3424 while (siblings->prev->next) {
3425 siblings = siblings->prev;
3426 }
3427 }
3428
Michal Vasko9e685082021-01-29 14:49:09 +01003429 parent = siblings->parent;
Michal Vasko6da1e952020-12-09 18:14:38 +01003430 if (parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003431 assert(target->hash);
3432
3433 /* find by hash */
3434 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003435 /* check even value when needed */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003436 if (!(target->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !lyd_compare_single(target, *match_p, 0)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003437 siblings = *match_p;
3438 } else {
3439 siblings = NULL;
3440 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003441 } else {
3442 /* not found */
3443 siblings = NULL;
3444 }
3445 } else {
3446 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02003447 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02003448 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003449 break;
3450 }
3451 }
3452 }
3453
3454 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003455 if (match) {
3456 *match = NULL;
3457 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003458 return LY_ENOTFOUND;
3459 }
3460
Michal Vasko9b368d32020-02-14 13:53:31 +01003461 if (match) {
3462 *match = (struct lyd_node *)siblings;
3463 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003464 return LY_SUCCESS;
3465}
3466
Radek Krejci857189e2020-09-01 13:26:36 +02003467/**
3468 * @brief Comparison callback to match schema node with a schema of a data node.
3469 *
3470 * @param[in] val1_p Pointer to the schema node
3471 * @param[in] val2_p Pointer to the data node
3472 * Implementation of ::values_equal_cb.
3473 */
3474static ly_bool
3475lyd_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 +01003476{
3477 struct lysc_node *val1;
3478 struct lyd_node *val2;
3479
3480 val1 = *((struct lysc_node **)val1_p);
3481 val2 = *((struct lyd_node **)val2_p);
3482
Michal Vasko90932a92020-02-12 14:33:03 +01003483 if (val1 == val2->schema) {
3484 /* schema match is enough */
3485 return 1;
3486 } else {
3487 return 0;
3488 }
3489}
3490
Michal Vasko92239c72020-11-18 18:17:25 +01003491/**
3492 * @brief Search in the given siblings (NOT recursively) for the first schema node data instance.
3493 * Uses hashes - should be used whenever possible for best performance.
3494 *
3495 * @param[in] siblings Siblings to search in including preceding and succeeding nodes.
3496 * @param[in] schema Target data node schema to find.
3497 * @param[out] match Can be NULL, otherwise the found data node.
3498 * @return LY_SUCCESS on success, @p match set.
3499 * @return LY_ENOTFOUND if not found, @p match set to NULL.
3500 * @return LY_ERR value if another error occurred.
3501 */
Michal Vasko90932a92020-02-12 14:33:03 +01003502static LY_ERR
3503lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema, struct lyd_node **match)
3504{
3505 struct lyd_node **match_p;
3506 struct lyd_node_inner *parent;
3507 uint32_t hash;
3508 values_equal_cb ht_cb;
3509
Michal Vaskob104f112020-07-17 09:54:54 +02003510 assert(siblings && schema);
Michal Vasko90932a92020-02-12 14:33:03 +01003511
Michal Vasko9e685082021-01-29 14:49:09 +01003512 parent = siblings->parent;
Michal Vasko08fd6132020-11-18 18:17:45 +01003513 if (parent && parent->schema && parent->children_ht) {
Michal Vasko90932a92020-02-12 14:33:03 +01003514 /* calculate our hash */
3515 hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
3516 hash = dict_hash_multi(hash, schema->name, strlen(schema->name));
3517 hash = dict_hash_multi(hash, NULL, 0);
3518
3519 /* use special hash table function */
3520 ht_cb = lyht_set_cb(parent->children_ht, lyd_hash_table_schema_val_equal);
3521
3522 /* find by hash */
3523 if (!lyht_find(parent->children_ht, &schema, hash, (void **)&match_p)) {
3524 siblings = *match_p;
3525 } else {
3526 /* not found */
3527 siblings = NULL;
3528 }
3529
3530 /* set the original hash table compare function back */
3531 lyht_set_cb(parent->children_ht, ht_cb);
3532 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02003533 /* find first sibling */
3534 if (siblings->parent) {
3535 siblings = siblings->parent->child;
3536 } else {
3537 while (siblings->prev->next) {
3538 siblings = siblings->prev;
3539 }
3540 }
3541
3542 /* search manually without hashes */
Michal Vaskod989ba02020-08-24 10:59:24 +02003543 for ( ; siblings; siblings = siblings->next) {
Michal Vasko90932a92020-02-12 14:33:03 +01003544 if (siblings->schema == schema) {
3545 /* schema match is enough */
3546 break;
3547 }
3548 }
3549 }
3550
3551 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003552 if (match) {
3553 *match = NULL;
3554 }
Michal Vasko90932a92020-02-12 14:33:03 +01003555 return LY_ENOTFOUND;
3556 }
3557
Michal Vasko9b368d32020-02-14 13:53:31 +01003558 if (match) {
3559 *match = (struct lyd_node *)siblings;
3560 }
Michal Vasko90932a92020-02-12 14:33:03 +01003561 return LY_SUCCESS;
3562}
3563
Michal Vaskoe444f752020-02-10 12:20:06 +01003564API LY_ERR
3565lyd_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 +02003566 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003567{
3568 LY_ERR rc;
3569 struct lyd_node *target = NULL;
3570
Michal Vasko4c583e82020-07-17 12:16:14 +02003571 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003572
Michal Vasko08fd6132020-11-18 18:17:45 +01003573 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003574 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003575 if (match) {
3576 *match = NULL;
3577 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003578 return LY_ENOTFOUND;
3579 }
3580
Michal Vaskof03ed032020-03-04 13:31:44 +01003581 if (key_or_value && !val_len) {
3582 val_len = strlen(key_or_value);
3583 }
3584
Michal Vaskob104f112020-07-17 09:54:54 +02003585 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3586 /* create a data node and find the instance */
3587 if (schema->nodetype == LYS_LEAFLIST) {
3588 /* target used attributes: schema, hash, value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003589 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &target);
3590 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003591 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003592 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02003593 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003594 }
3595
3596 /* find it */
3597 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003598 } else {
3599 /* find the first schema node instance */
3600 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003601 }
3602
Michal Vaskoe444f752020-02-10 12:20:06 +01003603 lyd_free_tree(target);
3604 return rc;
3605}
Michal Vaskoccc02342020-05-21 10:09:21 +02003606
3607API LY_ERR
Michal Vasko1d4af6c2021-02-22 13:31:26 +01003608lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
3609{
3610 LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
3611
3612 for ( ; first; first = first->next) {
3613 if (!first->schema && !strcmp(LYD_NAME(first), name)) {
3614 break;
3615 }
3616 }
3617
3618 if (match) {
3619 *match = (struct lyd_node *)first;
3620 }
3621 return first ? LY_SUCCESS : LY_ENOTFOUND;
3622}
3623
3624API LY_ERR
Michal Vaskoccc02342020-05-21 10:09:21 +02003625lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
3626{
3627 LY_ERR ret = LY_SUCCESS;
3628 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003629 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02003630 uint32_t i;
3631
3632 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
3633
3634 memset(&xp_set, 0, sizeof xp_set);
3635
3636 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003637 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
3638 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003639
3640 /* evaluate expression */
Michal Vasko400e9672021-01-11 13:39:17 +01003641 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 +02003642 LY_CHECK_GOTO(ret, cleanup);
3643
3644 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02003645 ret = ly_set_new(set);
3646 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003647
3648 /* transform into ly_set */
3649 if (xp_set.type == LYXP_SET_NODE_SET) {
3650 /* allocate memory for all the elements once (even though not all items must be elements but most likely will be) */
3651 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003652 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(ctx_node)); ret = LY_EMEM, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003653 (*set)->size = xp_set.used;
3654
3655 for (i = 0; i < xp_set.used; ++i) {
3656 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +02003657 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +02003658 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003659 }
3660 }
3661 }
3662
3663cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02003664 lyxp_set_free_content(&xp_set);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003665 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
Radek Krejci8f45abc2020-11-26 12:15:13 +01003666 if (ret) {
3667 ly_set_free(*set, NULL);
3668 *set = NULL;
3669 }
Michal Vaskoccc02342020-05-21 10:09:21 +02003670 return ret;
3671}
Radek Krejcica989142020-11-05 11:32:22 +01003672
Michal Vasko3e1f6552021-01-14 09:27:55 +01003673API LY_ERR
3674lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
3675{
3676 LY_ERR ret = LY_SUCCESS;
3677 struct lyxp_expr *expr = NULL;
3678 struct ly_path *lypath = NULL;
3679
3680 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
3681
3682 /* parse the path */
3683 ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
3684 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
3685 LY_CHECK_GOTO(ret, cleanup);
3686
3687 /* compile the path */
3688 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, expr, LY_PATH_LREF_FALSE,
3689 output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_SINGLE, LY_PREF_JSON,
3690 (void *)LYD_CTX(ctx_node), NULL, &lypath);
3691 LY_CHECK_GOTO(ret, cleanup);
3692
3693 /* evaluate the path */
3694 ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
3695
3696cleanup:
3697 lyxp_expr_free(LYD_CTX(ctx_node), expr);
3698 ly_path_free(LYD_CTX(ctx_node), lypath);
3699 return ret;
3700}
3701
Radek Krejcica989142020-11-05 11:32:22 +01003702API uint32_t
3703lyd_list_pos(const struct lyd_node *instance)
3704{
3705 const struct lyd_node *iter = NULL;
3706 uint32_t pos = 0;
3707
3708 if (!instance || !(instance->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
3709 return 0;
3710 }
3711
3712 /* data instances are ordered, so we can stop when we found instance of other schema node */
3713 for (iter = instance; iter->schema == instance->schema; iter = iter->prev) {
Radek Krejcibb27df32020-11-13 15:39:16 +01003714 if (pos && (iter->next == NULL)) {
Radek Krejcica989142020-11-05 11:32:22 +01003715 /* overrun to the end of the siblings list */
3716 break;
3717 }
3718 ++pos;
3719 }
3720
3721 return pos;
3722}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003723
3724API struct lyd_node *
3725lyd_first_sibling(const struct lyd_node *node)
3726{
3727 struct lyd_node *start;
3728
3729 if (!node) {
3730 return NULL;
3731 }
3732
3733 /* get the first sibling */
3734 if (node->parent) {
3735 start = node->parent->child;
3736 } else {
Radek Krejcibb27df32020-11-13 15:39:16 +01003737 for (start = (struct lyd_node *)node; start->prev->next; start = start->prev) {}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003738 }
3739
3740 return start;
3741}