blob: 4a8d5e98b7111a88f029e0782e28da02cd9ee3e9 [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"
Radek Krejci859a15a2021-03-05 20:56:59 +010047#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020048#include "tree_schema.h"
49#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020050#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020051#include "xml.h"
52#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020053
Michal Vaskob104f112020-07-17 09:54:54 +020054static LY_ERR lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema,
Radek Krejci0f969882020-08-21 16:56:47 +020055 struct lyd_node **match);
Michal Vaskob104f112020-07-17 09:54:54 +020056
Radek Krejci084289f2019-07-09 17:35:30 +020057LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020058lyd_value_store(const struct ly_ctx *ctx, struct lyd_value *val, const struct lysc_type *type, const char *value,
59 size_t value_len, ly_bool *dynamic, LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints,
Radek Krejci2efc45b2020-12-22 16:25:44 +010060 const struct lysc_node *ctx_node, ly_bool *incomplete)
Radek Krejci084289f2019-07-09 17:35:30 +020061{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020062 LY_ERR ret;
Radek Krejci084289f2019-07-09 17:35:30 +020063 struct ly_err_item *err = NULL;
Michal Vasko25d6ad02020-10-22 12:20:22 +020064 uint32_t options = (dynamic && *dynamic ? LY_TYPE_STORE_DYNAMIC : 0);
Radek Krejci084289f2019-07-09 17:35:30 +020065
Michal Vaskofeca4fb2020-10-05 08:58:40 +020066 if (incomplete) {
67 *incomplete = 0;
Radek Krejci084289f2019-07-09 17:35:30 +020068 }
69
Michal Vasko405cc9e2020-12-01 12:01:27 +010070 ret = type->plugin->store(ctx, type, value, value_len, options, format, prefix_data, hints, ctx_node, val, NULL, &err);
Radek Iša96b2de12021-02-16 10:32:57 +010071 if (dynamic) {
72 *dynamic = 0;
73 }
74
Michal Vasko90932a92020-02-12 14:33:03 +010075 if (ret == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +020076 if (incomplete) {
77 *incomplete = 1;
78 }
79 } else if (ret) {
80 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +010081 LOGVAL(ctx, err->vecode, err->msg);
Michal Vaskofeca4fb2020-10-05 08:58:40 +020082 ly_err_free(err);
83 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +010084 LOGVAL(ctx, LYVE_OTHER, "Storing value \"%.*s\" failed.", (int)value_len, value);
Michal Vaskofeca4fb2020-10-05 08:58:40 +020085 }
86 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +010087 }
88
Michal Vaskofeca4fb2020-10-05 08:58:40 +020089 return LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +010090}
91
Radek Krejci38d85362019-09-05 16:26:38 +020092LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +020093lyd_value_validate_incomplete(const struct ly_ctx *ctx, const struct lysc_type *type, struct lyd_value *val,
Radek Krejci2efc45b2020-12-22 16:25:44 +010094 const struct lyd_node *ctx_node, const struct lyd_node *tree)
Radek Krejci38d85362019-09-05 16:26:38 +020095{
Michal Vaskofeca4fb2020-10-05 08:58:40 +020096 LY_ERR ret;
Radek Krejci38d85362019-09-05 16:26:38 +020097 struct ly_err_item *err = NULL;
Radek Krejci38d85362019-09-05 16:26:38 +020098
Michal Vaskofeca4fb2020-10-05 08:58:40 +020099 assert(type->plugin->validate);
Michal Vasko8d544252020-03-02 10:19:52 +0100100
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200101 ret = type->plugin->validate(ctx, type, ctx_node, tree, val, &err);
102 if (ret) {
Radek Krejci38d85362019-09-05 16:26:38 +0200103 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100104 LOGVAL(ctx, err->vecode, err->msg);
Radek Krejci38d85362019-09-05 16:26:38 +0200105 ly_err_free(err);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200106 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100107 LOGVAL(ctx, LYVE_OTHER, "Resolving value \"%s\" failed.", val->canonical);
Radek Krejci38d85362019-09-05 16:26:38 +0200108 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200109 return ret;
Radek Krejci38d85362019-09-05 16:26:38 +0200110 }
111
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200112 return LY_SUCCESS;
Radek Krejci38d85362019-09-05 16:26:38 +0200113}
114
Michal Vaskof937cfe2020-08-03 16:07:12 +0200115LY_ERR
116_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 +0200117 LY_PREFIX_FORMAT format, void *prefix_data)
Radek Krejci084289f2019-07-09 17:35:30 +0200118{
119 LY_ERR rc = LY_SUCCESS;
120 struct ly_err_item *err = NULL;
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200121 struct lyd_value storage;
Radek Krejci084289f2019-07-09 17:35:30 +0200122 struct lysc_type *type;
Radek Krejci084289f2019-07-09 17:35:30 +0200123
124 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
125
126 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
127 LOGARG(ctx, node);
128 return LY_EINVAL;
129 }
130
Michal Vasko22df3f02020-08-24 13:29:22 +0200131 type = ((struct lysc_node_leaf *)node)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200132 rc = type->plugin->store(ctx ? ctx : node->module->ctx, type, value, value_len, 0, format, prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100133 LYD_HINT_SCHEMA, node, &storage, NULL, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200134 if (rc == LY_EINCOMPLETE) {
135 /* actually success since we do not provide the context tree and call validation with
136 * LY_TYPE_OPTS_INCOMPLETE_DATA */
137 rc = LY_SUCCESS;
138 } else if (rc && err) {
139 if (ctx) {
140 /* log only in case the ctx was provided as input parameter */
Radek Krejciddace2c2021-01-08 11:30:56 +0100141 LOG_LOCSET(NULL, NULL, err->path, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100142 LOGVAL(ctx, err->vecode, err->msg);
Radek Krejciddace2c2021-01-08 11:30:56 +0100143 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci084289f2019-07-09 17:35:30 +0200144 }
Radek Krejci73dead22019-07-11 16:46:16 +0200145 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200146 }
147
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200148 if (!rc) {
149 type->plugin->free(ctx ? ctx : node->module->ctx, &storage);
150 }
Radek Krejci084289f2019-07-09 17:35:30 +0200151 return rc;
152}
153
154API LY_ERR
Michal Vaskof937cfe2020-08-03 16:07:12 +0200155lys_value_validate(const struct ly_ctx *ctx, const struct lysc_node *node, const char *value, size_t value_len)
156{
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200157 return _lys_value_validate(ctx, node, value, value_len, LY_PREF_JSON, NULL);
Michal Vaskof937cfe2020-08-03 16:07:12 +0200158}
159
160API LY_ERR
Michal Vasko44685da2020-03-17 15:38:06 +0100161lyd_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 +0200162 const struct lyd_node *tree, const struct lysc_type **realtype)
Radek Krejci084289f2019-07-09 17:35:30 +0200163{
164 LY_ERR rc;
165 struct ly_err_item *err = NULL;
166 struct lysc_type *type;
Michal Vasko3701af52020-08-03 14:29:38 +0200167 struct lyd_value val = {0};
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200168 ly_bool stored = 0;
Radek Krejci084289f2019-07-09 17:35:30 +0200169
170 LY_CHECK_ARG_RET(ctx, node, value, LY_EINVAL);
171
Michal Vasko22df3f02020-08-24 13:29:22 +0200172 type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200173 /* store */
174 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 +0100175 LYD_HINT_DATA, node->schema, &val, NULL, &err);
Radek Krejci73dead22019-07-11 16:46:16 +0200176 if (rc == LY_EINCOMPLETE) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200177 stored = 1;
178
179 /* resolve */
Michal Vasko9e685082021-01-29 14:49:09 +0100180 rc = type->plugin->validate(ctx ? ctx : LYD_CTX(node), type, &node->node, tree, &val, &err);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200181 }
182
183 if (rc) {
Radek Krejci73dead22019-07-11 16:46:16 +0200184 if (err) {
185 if (ctx) {
Michal Vasko9e685082021-01-29 14:49:09 +0100186 LOG_LOCSET(NULL, &node->node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100187 LOGVAL(ctx, err->vecode, err->msg);
Radek Krejciddace2c2021-01-08 11:30:56 +0100188 LOG_LOCBACK(0, 1, 0, 0);
Radek Krejci084289f2019-07-09 17:35:30 +0200189 }
Radek Krejci73dead22019-07-11 16:46:16 +0200190 ly_err_free(err);
Radek Krejci084289f2019-07-09 17:35:30 +0200191 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200192 if (stored) {
193 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
194 }
Radek Krejci73dead22019-07-11 16:46:16 +0200195 return rc;
Radek Krejci084289f2019-07-09 17:35:30 +0200196 }
197
Michal Vasko3701af52020-08-03 14:29:38 +0200198 if (realtype) {
Michal Vasko29134f82020-11-13 18:03:20 +0100199 if (val.realtype->basetype == LY_TYPE_UNION) {
200 *realtype = val.subvalue->value.realtype;
201 } else {
202 *realtype = val.realtype;
203 }
Michal Vasko3701af52020-08-03 14:29:38 +0200204 }
205
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200206 type->plugin->free(ctx ? ctx : LYD_CTX(node), &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200207 return LY_SUCCESS;
208}
209
210API LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200211lyd_value_compare(const struct lyd_node_term *node, const char *value, size_t value_len)
Radek Krejci084289f2019-07-09 17:35:30 +0200212{
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200213 LY_ERR ret = LY_SUCCESS;
Radek Krejci084289f2019-07-09 17:35:30 +0200214 struct ly_ctx *ctx;
215 struct lysc_type *type;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200216 struct lyd_value val = {0};
Radek Krejci084289f2019-07-09 17:35:30 +0200217
218 LY_CHECK_ARG_RET(node ? node->schema->module->ctx : NULL, node, value, LY_EINVAL);
219
220 ctx = node->schema->module->ctx;
Michal Vasko22df3f02020-08-24 13:29:22 +0200221 type = ((struct lysc_node_leaf *)node->schema)->type;
Radek Krejci084289f2019-07-09 17:35:30 +0200222
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200223 /* store the value */
Michal Vasko9e685082021-01-29 14:49:09 +0100224 LOG_LOCSET(node->schema, &node->node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100225 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 +0100226 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200227 LY_CHECK_RET(ret);
Radek Krejci084289f2019-07-09 17:35:30 +0200228
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200229 /* compare values */
230 ret = type->plugin->compare(&node->value, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200231
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200232 type->plugin->free(ctx, &val);
Radek Krejci084289f2019-07-09 17:35:30 +0200233 return ret;
234}
235
Radek Krejci19611252020-10-04 13:54:53 +0200236API ly_bool
237lyd_is_default(const struct lyd_node *node)
238{
239 const struct lysc_node_leaf *leaf;
240 const struct lysc_node_leaflist *llist;
241 const struct lyd_node_term *term;
242 LY_ARRAY_COUNT_TYPE u;
243
244 assert(node->schema->nodetype & LYD_NODE_TERM);
245 term = (const struct lyd_node_term *)node;
246
247 if (node->schema->nodetype == LYS_LEAF) {
248 leaf = (const struct lysc_node_leaf *)node->schema;
249 if (!leaf->dflt) {
250 return 0;
251 }
252
253 /* compare with the default value */
254 if (leaf->type->plugin->compare(&term->value, leaf->dflt)) {
255 return 0;
256 }
257 } else {
258 llist = (const struct lysc_node_leaflist *)node->schema;
259 if (!llist->dflts) {
260 return 0;
261 }
262
263 LY_ARRAY_FOR(llist->dflts, u) {
264 /* compare with each possible default value */
265 if (llist->type->plugin->compare(&term->value, llist->dflts[u])) {
266 return 0;
267 }
268 }
269 }
270
271 return 1;
272}
273
Radek Krejci7931b192020-06-25 17:05:03 +0200274static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +0200275lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +0200276{
Michal Vasko69730152020-10-09 16:30:07 +0200277 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200278 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +0200279 const char *path = in->method.fpath.filepath;
280 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +0200281
282 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +0200283 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +0200284
Radek Krejcif13b87b2020-12-01 22:02:17 +0100285 if ((len >= LY_XML_SUFFIX_LEN + 1) &&
286 !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200287 format = LYD_XML;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100288 } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
289 !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200290 format = LYD_JSON;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100291 } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
292 !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200293 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +0200294 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +0200295 }
296
Radek Krejci7931b192020-06-25 17:05:03 +0200297 return format;
298}
Radek Krejcie7b95092019-05-15 11:03:07 +0200299
Michal Vaskoe0665742021-02-11 11:08:44 +0100300/**
301 * @brief Parse YANG data into a data tree.
302 *
303 * @param[in] ctx libyang context.
Radek Krejcif16e2542021-02-17 15:39:23 +0100304 * @param[in] ext Optional extenion instance to parse data following the schema tree specified in the extension instance
Michal Vaskoe0665742021-02-11 11:08:44 +0100305 * @param[in] parent Parent to connect the parsed nodes to, if any.
306 * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
307 * @param[in] in Input handle to read the input from.
308 * @param[in] format Expected format of the data in @p in.
309 * @param[in] parse_opts Options for parser.
310 * @param[in] val_opts Options for validation.
311 * @param[out] op Optional pointer to the parsed operation, if any.
312 * @return LY_ERR value.
313 */
314static LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100315lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, struct lyd_node **first_p,
316 struct ly_in *in, LYD_FORMAT format, uint32_t parse_opts, uint32_t val_opts, struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200317{
Michal Vaskoe0665742021-02-11 11:08:44 +0100318 LY_ERR rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200319 struct lyd_ctx *lydctx = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100320 struct ly_set parsed = {0};
321 struct lyd_node *first;
322 uint32_t i;
Radek Krejci1798aae2020-07-14 13:26:06 +0200323
Michal Vaskoe0665742021-02-11 11:08:44 +0100324 assert(ctx && (parent || first_p));
Radek Krejci7931b192020-06-25 17:05:03 +0200325
326 format = lyd_parse_get_format(in, format);
Michal Vaskoe0665742021-02-11 11:08:44 +0100327 if (first_p) {
328 *first_p = NULL;
329 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200330
Michal Vasko63f3d842020-07-08 10:10:14 +0200331 /* remember input position */
332 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200333
Michal Vaskoe0665742021-02-11 11:08:44 +0100334 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200335 switch (format) {
336 case LYD_XML:
Radek Krejcif16e2542021-02-17 15:39:23 +0100337 rc = lyd_parse_xml(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, NULL, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200338 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200339 case LYD_JSON:
Radek Krejcif16e2542021-02-17 15:39:23 +0100340 rc = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200341 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200342 case LYD_LYB:
Radek Krejcif16e2542021-02-17 15:39:23 +0100343 rc = lyd_parse_lyb(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200344 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200345 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100346 LOGARG(ctx, format);
347 rc = LY_EINVAL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100348 break;
349 }
350 LY_CHECK_GOTO(rc, cleanup);
351
352 if (parent) {
353 /* get first top-level sibling */
354 for (first = parent; first->parent; first = lyd_parent(first)) {}
355 first = lyd_first_sibling(first);
356 first_p = &first;
Radek Krejci7931b192020-06-25 17:05:03 +0200357 }
358
Michal Vaskoe0665742021-02-11 11:08:44 +0100359 if (!(parse_opts & LYD_PARSE_ONLY)) {
360 /* validate data */
361 rc = lyd_validate(first_p, NULL, ctx, val_opts, 0, &lydctx->node_when, &lydctx->node_types,
362 &lydctx->meta_types, NULL);
363 LY_CHECK_GOTO(rc, cleanup);
364 }
Radek Krejci7931b192020-06-25 17:05:03 +0200365
Michal Vaskoe0665742021-02-11 11:08:44 +0100366 /* set the operation node */
367 if (op) {
368 *op = lydctx->op_node;
Radek Krejci1798aae2020-07-14 13:26:06 +0200369 }
370
371cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +0100372 if (lydctx) {
373 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200374 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100375 if (rc) {
376 if (parent) {
377 /* free all the parsed subtrees */
378 for (i = 0; i < parsed.count; ++i) {
379 lyd_free_tree(parsed.dnodes[i]);
380 }
381 } else {
382 /* free everything */
383 lyd_free_all(*first_p);
384 *first_p = NULL;
385 }
386 }
387 ly_set_erase(&parsed, NULL);
388 return rc;
Radek Krejci7931b192020-06-25 17:05:03 +0200389}
390
391API LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100392lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
393 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
394{
395 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
396
397 LY_CHECK_ARG_RET(ctx, ext, in, parent || tree, LY_EINVAL);
398 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
399 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
400
401 return lyd_parse(ctx, ext, parent, tree, in, format, parse_options, validate_options, NULL);
402}
403
404API LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100405lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
406 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
407{
408 LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
409 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
410 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
411
Radek Krejcif16e2542021-02-17 15:39:23 +0100412 return lyd_parse(ctx, NULL, parent, tree, in, format, parse_options, validate_options, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100413}
414
415API LY_ERR
416lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
417 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200418{
419 LY_ERR ret;
420 struct ly_in *in;
421
422 LY_CHECK_RET(ly_in_new_memory(data, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100423 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200424
425 ly_in_free(in, 0);
426 return ret;
427}
428
429API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200430lyd_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 +0200431 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200432{
433 LY_ERR ret;
434 struct ly_in *in;
435
436 LY_CHECK_RET(ly_in_new_fd(fd, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100437 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200438
439 ly_in_free(in, 0);
440 return ret;
441}
442
443API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200444lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
445 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200446{
447 LY_ERR ret;
448 struct ly_in *in;
449
450 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100451 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200452
453 ly_in_free(in, 0);
454 return ret;
455}
456
Radek Krejcif16e2542021-02-17 15:39:23 +0100457/**
458 * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
459 * for schema nodes locked inside the extension instance.
460 *
461 * At least one of @p parent, @p tree, or @p op must always be set.
462 *
463 * Specific @p data_type values have different parameter meaning as follows:
464 * - ::LYD_TYPE_RPC_NETCONF:
465 * - @p parent - must be NULL, the whole RPC is expected;
466 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
467 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
468 * a separate opaque data tree, even if the function fails, this may be returned;
469 * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
470 *
471 * - ::LYD_TYPE_NOTIF_NETCONF:
472 * - @p parent - must be NULL, the whole notification is expected;
473 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
474 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
475 * a separate opaque data tree, even if the function fails, this may be returned;
476 * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
477 *
478 * - ::LYD_TYPE_REPLY_NETCONF:
479 * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
480 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
481 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
482 * a separate opaque data tree, even if the function fails, this may be returned;
483 * - @p op - must be NULL, the reply is appended to the RPC;
484 * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
485 *
486 * @param[in] ctx libyang context.
487 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
488 * @param[in] parent Optional parent to connect the parsed nodes to.
489 * @param[in] in Input handle to read the input from.
490 * @param[in] format Expected format of the data in @p in.
491 * @param[in] data_type Expected operation to parse (@ref datatype).
492 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
493 * @param[out] op Optional parsed operation node.
494 * @return LY_ERR value.
495 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
496 */
497static LY_ERR
498lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
499 struct ly_in *in, LYD_FORMAT format, enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
Radek Krejci7931b192020-06-25 17:05:03 +0200500{
Michal Vaskoe0665742021-02-11 11:08:44 +0100501 LY_ERR rc = LY_SUCCESS;
502 struct lyd_ctx *lydctx = NULL;
503 struct ly_set parsed = {0};
504 struct lyd_node *first = NULL, *envp = NULL;
505 uint32_t i, parse_opts, val_opts;
Radek Krejci7931b192020-06-25 17:05:03 +0200506
Michal Vasko27fb0262021-02-23 09:42:01 +0100507 if (!ctx) {
508 ctx = LYD_CTX(parent);
509 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200510 if (tree) {
511 *tree = NULL;
512 }
513 if (op) {
514 *op = NULL;
515 }
516
Radek Krejci7931b192020-06-25 17:05:03 +0200517 format = lyd_parse_get_format(in, format);
Radek Krejci7931b192020-06-25 17:05:03 +0200518
Michal Vasko63f3d842020-07-08 10:10:14 +0200519 /* remember input position */
520 in->func_start = in->current;
521
Michal Vaskoe0665742021-02-11 11:08:44 +0100522 /* check params based on the data type */
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100523 if ((data_type == LYD_TYPE_RPC_NETCONF) || (data_type == LYD_TYPE_NOTIF_NETCONF)) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100524 LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100525 } else if (data_type == LYD_TYPE_REPLY_NETCONF) {
526 LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op,
527 LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100528 }
529 parse_opts = LYD_PARSE_ONLY | LYD_PARSE_STRICT;
530 val_opts = 0;
531
532 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200533 switch (format) {
534 case LYD_XML:
Radek Krejcif16e2542021-02-17 15:39:23 +0100535 rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
Michal Vasko299d5d12021-02-16 16:36:37 +0100536 if (rc && envp) {
537 /* special situation when the envelopes were parsed successfully */
538 if (tree) {
539 *tree = envp;
540 }
541 ly_set_erase(&parsed, NULL);
542 return rc;
543 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100544 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200545 case LYD_JSON:
Radek Krejcif16e2542021-02-17 15:39:23 +0100546 rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &parsed, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100547 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200548 case LYD_LYB:
Radek Krejcif16e2542021-02-17 15:39:23 +0100549 rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &parsed, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100550 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200551 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100552 LOGARG(ctx, format);
553 rc = LY_EINVAL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200554 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200555 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100556 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci7931b192020-06-25 17:05:03 +0200557
Michal Vaskoe0665742021-02-11 11:08:44 +0100558 /* set out params correctly */
559 if (tree) {
560 if (envp) {
561 /* special out param meaning */
562 *tree = envp;
563 } else {
564 *tree = parent ? NULL : first;
565 }
566 }
567 if (op) {
568 *op = lydctx->op_node;
569 }
570
571cleanup:
572 if (lydctx) {
573 lydctx->free(lydctx);
574 }
575 if (rc) {
576 if (parent) {
577 /* free all the parsed subtrees */
578 for (i = 0; i < parsed.count; ++i) {
579 lyd_free_tree(parsed.dnodes[i]);
580 }
581 } else {
582 /* free everything (cannot occur in the current code, a safety) */
583 lyd_free_all(first);
584 if (tree) {
585 *tree = NULL;
586 }
587 if (op) {
588 *op = NULL;
589 }
590 }
591 }
592 ly_set_erase(&parsed, NULL);
593 return rc;
Radek Krejcie7b95092019-05-15 11:03:07 +0200594}
Radek Krejci084289f2019-07-09 17:35:30 +0200595
Radek Krejcif16e2542021-02-17 15:39:23 +0100596API LY_ERR
597lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
598 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
599{
600 LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
601
602 return lyd_parse_op_(ctx, NULL, parent, in, format, data_type, tree, op);
603}
604
605API LY_ERR
606lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
607 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
608{
609 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
610
611 LY_CHECK_ARG_RET(ctx, ext, in, data_type, parent || tree || op, LY_EINVAL);
612
613 return lyd_parse_op_(ctx, ext, parent, in, format, data_type, tree, op);
614}
615
Michal Vasko90932a92020-02-12 14:33:03 +0100616LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200617lyd_create_term(const struct lysc_node *schema, const char *value, size_t value_len, ly_bool *dynamic,
618 LY_PREFIX_FORMAT format, void *prefix_data, uint32_t hints, ly_bool *incomplete, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100619{
620 LY_ERR ret;
621 struct lyd_node_term *term;
622
Michal Vasko9b368d32020-02-14 13:53:31 +0100623 assert(schema->nodetype & LYD_NODE_TERM);
624
Michal Vasko90932a92020-02-12 14:33:03 +0100625 term = calloc(1, sizeof *term);
626 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
627
628 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100629 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100630 term->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100631
Radek Krejciddace2c2021-01-08 11:30:56 +0100632 LOG_LOCSET(schema, NULL, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200633 ret = lyd_value_store(schema->module->ctx, &term->value, ((struct lysc_node_leaf *)term->schema)->type, value,
Radek Krejci2efc45b2020-12-22 16:25:44 +0100634 value_len, dynamic, format, prefix_data, hints, schema, incomplete);
Radek Krejciddace2c2021-01-08 11:30:56 +0100635 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200636 LY_CHECK_ERR_RET(ret, free(term), ret);
Michal Vasko9e685082021-01-29 14:49:09 +0100637 lyd_hash(&term->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100638
Michal Vasko9e685082021-01-29 14:49:09 +0100639 *node = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100640 return ret;
641}
642
643LY_ERR
644lyd_create_term2(const struct lysc_node *schema, const struct lyd_value *val, struct lyd_node **node)
645{
646 LY_ERR ret;
647 struct lyd_node_term *term;
648 struct lysc_type *type;
649
650 assert(schema->nodetype & LYD_NODE_TERM);
Michal Vaskoba99a3e2020-08-18 15:50:05 +0200651 assert(val && val->canonical && val->realtype);
Michal Vasko9b368d32020-02-14 13:53:31 +0100652
653 term = calloc(1, sizeof *term);
654 LY_CHECK_ERR_RET(!term, LOGMEM(schema->module->ctx), LY_EMEM);
655
656 term->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100657 term->prev = &term->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100658 term->flags = LYD_NEW;
659
660 type = ((struct lysc_node_leaf *)schema)->type;
661 ret = type->plugin->duplicate(schema->module->ctx, val, &term->value);
662 if (ret) {
663 LOGERR(schema->module->ctx, ret, "Value duplication failed.");
664 free(term);
665 return ret;
666 }
Michal Vasko9e685082021-01-29 14:49:09 +0100667 lyd_hash(&term->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100668
Michal Vasko9e685082021-01-29 14:49:09 +0100669 *node = &term->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100670 return ret;
671}
672
673LY_ERR
674lyd_create_inner(const struct lysc_node *schema, struct lyd_node **node)
675{
676 struct lyd_node_inner *in;
677
Michal Vasko9b368d32020-02-14 13:53:31 +0100678 assert(schema->nodetype & LYD_NODE_INNER);
679
Michal Vasko90932a92020-02-12 14:33:03 +0100680 in = calloc(1, sizeof *in);
681 LY_CHECK_ERR_RET(!in, LOGMEM(schema->module->ctx), LY_EMEM);
682
683 in->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100684 in->prev = &in->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100685 in->flags = LYD_NEW;
Michal Vasko3383be72020-11-03 17:15:31 +0100686 if ((schema->nodetype == LYS_CONTAINER) && !(schema->flags & LYS_PRESENCE)) {
687 in->flags |= LYD_DEFAULT;
688 }
Michal Vasko90932a92020-02-12 14:33:03 +0100689
Michal Vasko9b368d32020-02-14 13:53:31 +0100690 /* do not hash list with keys, we need them for the hash */
691 if ((schema->nodetype != LYS_LIST) || (schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100692 lyd_hash(&in->node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100693 }
Michal Vasko90932a92020-02-12 14:33:03 +0100694
Michal Vasko9e685082021-01-29 14:49:09 +0100695 *node = &in->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100696 return LY_SUCCESS;
697}
698
Michal Vasko90932a92020-02-12 14:33:03 +0100699LY_ERR
Michal Vasko004d3152020-06-11 19:59:22 +0200700lyd_create_list(const struct lysc_node *schema, const struct ly_path_predicate *predicates, struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100701{
702 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100703 struct lyd_node *list = NULL, *key;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200704 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100705
Michal Vasko004d3152020-06-11 19:59:22 +0200706 assert((schema->nodetype == LYS_LIST) && !(schema->flags & LYS_KEYLESS));
Michal Vasko90932a92020-02-12 14:33:03 +0100707
708 /* create list */
709 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &list), cleanup);
710
Radek Krejciddace2c2021-01-08 11:30:56 +0100711 LOG_LOCSET(NULL, list, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100712
Michal Vasko90932a92020-02-12 14:33:03 +0100713 /* create and insert all the keys */
Michal Vasko004d3152020-06-11 19:59:22 +0200714 LY_ARRAY_FOR(predicates, u) {
715 LY_CHECK_GOTO(ret = lyd_create_term2(predicates[u].key, &predicates[u].value, &key), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100716 lyd_insert_node(list, NULL, key);
717 }
718
Michal Vasko9b368d32020-02-14 13:53:31 +0100719 /* hash having all the keys */
720 lyd_hash(list);
721
Michal Vasko90932a92020-02-12 14:33:03 +0100722 /* success */
723 *node = list;
724 list = NULL;
725
726cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100727 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko90932a92020-02-12 14:33:03 +0100728 lyd_free_tree(list);
Michal Vasko004d3152020-06-11 19:59:22 +0200729 return ret;
730}
731
732static LY_ERR
733lyd_create_list2(const struct lysc_node *schema, const char *keys, size_t keys_len, struct lyd_node **node)
734{
735 LY_ERR ret = LY_SUCCESS;
736 struct lyxp_expr *expr = NULL;
737 uint16_t exp_idx = 0;
738 enum ly_path_pred_type pred_type = 0;
739 struct ly_path_predicate *predicates = NULL;
740
Radek Krejciddace2c2021-01-08 11:30:56 +0100741 LOG_LOCSET(schema, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100742
Michal Vasko004d3152020-06-11 19:59:22 +0200743 /* parse keys */
Michal Vasko6b26e742020-07-17 15:02:10 +0200744 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 +0200745 LY_PATH_PRED_KEYS, &expr), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200746
747 /* compile them */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200748 LY_CHECK_GOTO(ret = ly_path_compile_predicate(schema->module->ctx, NULL, NULL, schema, expr, &exp_idx, LY_PREF_JSON,
749 NULL, &predicates, &pred_type), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200750
751 /* create the list node */
752 LY_CHECK_GOTO(ret = lyd_create_list(schema, predicates, node), cleanup);
753
754cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100755 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200756 lyxp_expr_free(schema->module->ctx, expr);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200757 ly_path_predicates_free(schema->module->ctx, pred_type, predicates);
Michal Vasko90932a92020-02-12 14:33:03 +0100758 return ret;
759}
760
761LY_ERR
Michal Vasko366a4a12020-12-04 16:23:57 +0100762lyd_create_any(const struct lysc_node *schema, const void *value, LYD_ANYDATA_VALUETYPE value_type, ly_bool use_value,
763 struct lyd_node **node)
Michal Vasko90932a92020-02-12 14:33:03 +0100764{
Michal Vasko366a4a12020-12-04 16:23:57 +0100765 LY_ERR ret;
Michal Vasko90932a92020-02-12 14:33:03 +0100766 struct lyd_node_any *any;
Michal Vasko366a4a12020-12-04 16:23:57 +0100767 union lyd_any_value any_val;
Michal Vasko90932a92020-02-12 14:33:03 +0100768
Michal Vasko9b368d32020-02-14 13:53:31 +0100769 assert(schema->nodetype & LYD_NODE_ANY);
770
Michal Vasko90932a92020-02-12 14:33:03 +0100771 any = calloc(1, sizeof *any);
772 LY_CHECK_ERR_RET(!any, LOGMEM(schema->module->ctx), LY_EMEM);
773
774 any->schema = schema;
Michal Vasko9e685082021-01-29 14:49:09 +0100775 any->prev = &any->node;
Michal Vasko9b368d32020-02-14 13:53:31 +0100776 any->flags = LYD_NEW;
Michal Vasko90932a92020-02-12 14:33:03 +0100777
Radek Krejci1798aae2020-07-14 13:26:06 +0200778 /* TODO: convert XML/JSON strings into a opaq data tree */
Michal Vasko366a4a12020-12-04 16:23:57 +0100779
780 if (use_value) {
781 any->value.str = value;
782 any->value_type = value_type;
783 } else {
784 any_val.str = value;
Michal Vasko9e685082021-01-29 14:49:09 +0100785 ret = lyd_any_copy_value(&any->node, &any_val, value_type);
Michal Vasko366a4a12020-12-04 16:23:57 +0100786 LY_CHECK_ERR_RET(ret, free(any), ret);
787 }
Michal Vasko9e685082021-01-29 14:49:09 +0100788 lyd_hash(&any->node);
Michal Vasko90932a92020-02-12 14:33:03 +0100789
Michal Vasko9e685082021-01-29 14:49:09 +0100790 *node = &any->node;
Michal Vasko90932a92020-02-12 14:33:03 +0100791 return LY_SUCCESS;
792}
793
Michal Vasko52927e22020-03-16 17:26:14 +0100794LY_ERR
Michal Vasko501af032020-11-11 20:27:44 +0100795lyd_create_opaq(const struct ly_ctx *ctx, const char *name, size_t name_len, const char *prefix, size_t pref_len,
796 const char *module_key, size_t module_key_len, const char *value, size_t value_len, ly_bool *dynamic,
797 LY_PREFIX_FORMAT format, void *val_prefix_data, uint32_t hints, struct lyd_node **node)
Michal Vasko52927e22020-03-16 17:26:14 +0100798{
Radek Krejci011e4aa2020-09-04 15:22:31 +0200799 LY_ERR ret = LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +0100800 struct lyd_node_opaq *opaq;
801
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200802 assert(ctx && name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +0100803
804 if (!value_len) {
805 value = "";
806 }
807
808 opaq = calloc(1, sizeof *opaq);
Michal Vasko501af032020-11-11 20:27:44 +0100809 LY_CHECK_ERR_GOTO(!opaq, LOGMEM(ctx); ret = LY_EMEM, finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100810
Michal Vasko9e685082021-01-29 14:49:09 +0100811 opaq->prev = &opaq->node;
Michal Vaskoad92b672020-11-12 13:11:31 +0100812 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &opaq->name.name), finish);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200813
Michal Vasko52927e22020-03-16 17:26:14 +0100814 if (pref_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100815 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, pref_len, &opaq->name.prefix), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100816 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200817 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100818 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &opaq->name.module_ns), finish);
Radek Krejci1798aae2020-07-14 13:26:06 +0200819 }
Michal Vasko52927e22020-03-16 17:26:14 +0100820 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200821 LY_CHECK_GOTO(ret = lydict_insert_zc(ctx, (char *)value, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100822 *dynamic = 0;
823 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200824 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &opaq->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +0100825 }
Michal Vasko501af032020-11-11 20:27:44 +0100826
827 opaq->format = format;
828 opaq->val_prefix_data = val_prefix_data;
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200829 opaq->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +0100830 opaq->ctx = ctx;
831
Radek Krejci011e4aa2020-09-04 15:22:31 +0200832finish:
833 if (ret) {
Michal Vasko9e685082021-01-29 14:49:09 +0100834 lyd_free_tree(&opaq->node);
Michal Vasko501af032020-11-11 20:27:44 +0100835 ly_free_prefix_data(format, val_prefix_data);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200836 } else {
Michal Vasko9e685082021-01-29 14:49:09 +0100837 *node = &opaq->node;
Radek Krejci011e4aa2020-09-04 15:22:31 +0200838 }
839 return ret;
Michal Vasko52927e22020-03-16 17:26:14 +0100840}
841
Michal Vasko3a41dff2020-07-15 14:30:28 +0200842API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100843lyd_new_inner(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
844 struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100845{
846 struct lyd_node *ret = NULL;
847 const struct lysc_node *schema;
848 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
849
Michal Vasko6027eb92020-07-15 16:37:30 +0200850 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100851
Michal Vaskof03ed032020-03-04 13:31:44 +0100852 if (!module) {
853 module = parent->schema->module;
854 }
855
Michal Vasko3a41dff2020-07-15 14:30:28 +0200856 schema = lys_find_child(parent ? parent->schema : NULL, module, name, 0,
Radek Krejci41ac9942020-11-02 14:47:56 +0100857 LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, output ? LYS_GETNEXT_OUTPUT : 0);
Radek Krejcidd2a7662021-03-12 11:26:34 +0100858 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Inner node (not a list) \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100859
Michal Vasko3a41dff2020-07-15 14:30:28 +0200860 LY_CHECK_RET(lyd_create_inner(schema, &ret));
861 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +0100862 lyd_insert_node(parent, NULL, ret);
863 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200864
865 if (node) {
866 *node = ret;
867 }
868 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +0100869}
870
Michal Vasko3a41dff2020-07-15 14:30:28 +0200871API LY_ERR
Radek Krejcidd2a7662021-03-12 11:26:34 +0100872lyd_new_ext_inner(const struct lysc_ext_instance *ext, const char *name, struct lyd_node **node)
873{
874 struct lyd_node *ret = NULL;
875 const struct lysc_node *schema;
876 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
877
878 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
879
880 schema = lysc_ext_find_node(ext, NULL, name, 0, LYS_CONTAINER | LYS_NOTIF | LYS_RPC | LYS_ACTION, 0);
881 if (!schema) {
882 if (ext->argument) {
883 LOGERR(ctx, LY_EINVAL, "Inner node (not a list) \"%s\" not found in instance \"%s\" of extension %s.",
884 name, ext->argument, ext->def->name);
885 } else {
886 LOGERR(ctx, LY_EINVAL, "Inner node (not a list) \"%s\" not found in instance of extension %s.",
887 name, ext->def->name);
888 }
889 return LY_ENOTFOUND;
890 }
891 LY_CHECK_RET(lyd_create_inner(schema, &ret));
892
893 *node = ret;
894
895 return LY_SUCCESS;
896}
897
898API LY_ERR
Michal Vasko65243892020-12-04 16:26:21 +0100899lyd_new_list(struct lyd_node *parent, const struct lys_module *module, const char *name, ly_bool output,
900 struct lyd_node **node, ...)
Michal Vasko013a8182020-03-03 10:46:53 +0100901{
902 struct lyd_node *ret = NULL, *key;
903 const struct lysc_node *schema, *key_s;
904 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
905 va_list ap;
906 const char *key_val;
907 LY_ERR rc = LY_SUCCESS;
908
Michal Vasko6027eb92020-07-15 16:37:30 +0200909 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +0100910
Michal Vaskof03ed032020-03-04 13:31:44 +0100911 if (!module) {
912 module = parent->schema->module;
913 }
914
Radek Krejci41ac9942020-11-02 14:47:56 +0100915 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 +0200916 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +0100917
918 /* create list inner node */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200919 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko013a8182020-03-03 10:46:53 +0100920
Michal Vasko3a41dff2020-07-15 14:30:28 +0200921 va_start(ap, node);
Michal Vasko013a8182020-03-03 10:46:53 +0100922
923 /* create and insert all the keys */
Michal Vasko544e58a2021-01-28 14:33:41 +0100924 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 +0100925 key_val = va_arg(ap, const char *);
926
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200927 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
928 NULL, &key);
929 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko013a8182020-03-03 10:46:53 +0100930 lyd_insert_node(ret, NULL, key);
931 }
932
Michal Vasko013a8182020-03-03 10:46:53 +0100933 if (parent) {
934 lyd_insert_node(parent, NULL, ret);
935 }
936
937cleanup:
Michal Vasko3a41dff2020-07-15 14:30:28 +0200938 va_end(ap);
Michal Vasko013a8182020-03-03 10:46:53 +0100939 if (rc) {
940 lyd_free_tree(ret);
941 ret = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200942 } else if (node) {
943 *node = ret;
Michal Vasko013a8182020-03-03 10:46:53 +0100944 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200945 return rc;
Michal Vasko013a8182020-03-03 10:46:53 +0100946}
947
Michal Vasko3a41dff2020-07-15 14:30:28 +0200948API LY_ERR
Radek Krejci8247bae2021-03-12 11:47:02 +0100949lyd_new_ext_list(const struct lysc_ext_instance *ext, const char *name, struct lyd_node **node, ...)
950{
951 struct lyd_node *ret = NULL, *key;
952 const struct lysc_node *schema, *key_s;
953 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
954 va_list ap;
955 const char *key_val;
956 LY_ERR rc = LY_SUCCESS;
957
958 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
959
960 schema = lysc_ext_find_node(ext, NULL, name, 0, LYS_LIST, 0);
961 if (!schema) {
962 if (ext->argument) {
963 LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found in instance \"%s\" of extension %s.",
964 name, ext->argument, ext->def->name);
965 } else {
966 LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found in instance of extension %s.", name, ext->def->name);
967 }
968 return LY_ENOTFOUND;
969 }
970 /* create list inner node */
971 LY_CHECK_RET(lyd_create_inner(schema, &ret));
972
973 va_start(ap, node);
974
975 /* create and insert all the keys */
976 for (key_s = lysc_node_child(schema); key_s && (key_s->flags & LYS_KEY); key_s = key_s->next) {
977 key_val = va_arg(ap, const char *);
978
979 rc = lyd_create_term(key_s, key_val, key_val ? strlen(key_val) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA,
980 NULL, &key);
981 LY_CHECK_GOTO(rc, cleanup);
982 lyd_insert_node(ret, NULL, key);
983 }
984
985cleanup:
986 va_end(ap);
987 if (rc) {
988 lyd_free_tree(ret);
989 ret = NULL;
Radek Krejci8247bae2021-03-12 11:47:02 +0100990 }
Radek Krejci8919fbd2021-03-15 09:35:25 +0100991 *node = ret;
Radek Krejci8247bae2021-03-12 11:47:02 +0100992 return rc;
993}
994
995API LY_ERR
Michal Vasko3a41dff2020-07-15 14:30:28 +0200996lyd_new_list2(struct lyd_node *parent, const struct lys_module *module, const char *name, const char *keys,
Radek Krejci41ac9942020-11-02 14:47:56 +0100997 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +0100998{
999 struct lyd_node *ret = NULL;
1000 const struct lysc_node *schema;
1001 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
1002
Michal Vasko6027eb92020-07-15 16:37:30 +02001003 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +01001004
Michal Vaskof03ed032020-03-04 13:31:44 +01001005 if (!module) {
1006 module = parent->schema->module;
1007 }
Michal Vasko004d3152020-06-11 19:59:22 +02001008 if (!keys) {
1009 keys = "";
1010 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001011
Michal Vasko004d3152020-06-11 19:59:22 +02001012 /* find schema node */
Radek Krejci41ac9942020-11-02 14:47:56 +01001013 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 +02001014 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "List node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +01001015
Michal Vasko004d3152020-06-11 19:59:22 +02001016 if ((schema->flags & LYS_KEYLESS) && !keys[0]) {
1017 /* key-less list */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001018 LY_CHECK_RET(lyd_create_inner(schema, &ret));
Michal Vasko004d3152020-06-11 19:59:22 +02001019 } else {
1020 /* create the list node */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001021 LY_CHECK_RET(lyd_create_list2(schema, keys, strlen(keys), &ret));
Michal Vasko004d3152020-06-11 19:59:22 +02001022 }
Michal Vasko004d3152020-06-11 19:59:22 +02001023 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +01001024 lyd_insert_node(parent, NULL, ret);
1025 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001026
1027 if (node) {
1028 *node = ret;
1029 }
1030 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +01001031}
1032
Michal Vasko3a41dff2020-07-15 14:30:28 +02001033API LY_ERR
1034lyd_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 +01001035 ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +01001036{
Michal Vaskocbff3e92020-05-27 12:56:41 +02001037 LY_ERR rc;
Michal Vasko013a8182020-03-03 10:46:53 +01001038 struct lyd_node *ret = NULL;
1039 const struct lysc_node *schema;
1040 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
1041
Michal Vasko6027eb92020-07-15 16:37:30 +02001042 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +01001043
Michal Vaskof03ed032020-03-04 13:31:44 +01001044 if (!module) {
1045 module = parent->schema->module;
1046 }
1047
Radek Krejci41ac9942020-11-02 14:47:56 +01001048 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 +02001049 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +01001050
Radek Krejci8a5afc22021-03-12 11:10:47 +01001051 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &ret);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001052 LY_CHECK_RET(rc);
Michal Vaskocbff3e92020-05-27 12:56:41 +02001053 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +01001054 lyd_insert_node(parent, NULL, ret);
1055 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001056
1057 if (node) {
1058 *node = ret;
1059 }
1060 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +01001061}
1062
Michal Vasko3a41dff2020-07-15 14:30:28 +02001063API LY_ERR
Radek Krejci8a5afc22021-03-12 11:10:47 +01001064lyd_new_ext_term(const struct lysc_ext_instance *ext, const char *name, const char *val_str, struct lyd_node **node)
1065{
1066 LY_ERR rc;
1067 struct lyd_node *ret = NULL;
1068 const struct lysc_node *schema;
1069 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
1070
1071 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
1072
1073 schema = lysc_ext_find_node(ext, NULL, name, 0, LYD_NODE_TERM, 0);
1074 if (!schema) {
1075 if (ext->argument) {
1076 LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found in instance \"%s\" of extension %s.",
1077 name, ext->argument, ext->def->name);
1078 } else {
1079 LOGERR(ctx, LY_EINVAL, "Term node \"%s\" not found in instance of extension %s.", name, ext->def->name);
1080 }
1081 return LY_ENOTFOUND;
1082 }
1083 rc = lyd_create_term(schema, val_str, val_str ? strlen(val_str) : 0, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &ret);
1084 LY_CHECK_RET(rc);
1085
1086 *node = ret;
1087
1088 return LY_SUCCESS;
1089}
1090
1091API LY_ERR
Michal Vasko2a4ab2b2021-03-04 15:52:40 +01001092lyd_new_any(struct lyd_node *parent, const struct lys_module *module, const char *name, const void *value,
1093 ly_bool use_value, LYD_ANYDATA_VALUETYPE value_type, ly_bool output, struct lyd_node **node)
Michal Vasko013a8182020-03-03 10:46:53 +01001094{
1095 struct lyd_node *ret = NULL;
1096 const struct lysc_node *schema;
1097 struct ly_ctx *ctx = parent ? parent->schema->module->ctx : (module ? module->ctx : NULL);
1098
Michal Vasko6027eb92020-07-15 16:37:30 +02001099 LY_CHECK_ARG_RET(ctx, parent || module, parent || node, name, LY_EINVAL);
Michal Vasko013a8182020-03-03 10:46:53 +01001100
Michal Vaskof03ed032020-03-04 13:31:44 +01001101 if (!module) {
1102 module = parent->schema->module;
1103 }
1104
Radek Krejci41ac9942020-11-02 14:47:56 +01001105 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 +02001106 LY_CHECK_ERR_RET(!schema, LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found.", name), LY_ENOTFOUND);
Michal Vasko013a8182020-03-03 10:46:53 +01001107
Michal Vasko2a4ab2b2021-03-04 15:52:40 +01001108 LY_CHECK_RET(lyd_create_any(schema, value, value_type, use_value, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001109 if (parent) {
Michal Vasko013a8182020-03-03 10:46:53 +01001110 lyd_insert_node(parent, NULL, ret);
1111 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001112
1113 if (node) {
1114 *node = ret;
1115 }
1116 return LY_SUCCESS;
Michal Vasko013a8182020-03-03 10:46:53 +01001117}
1118
Radek Krejci0b963da2021-03-12 13:23:44 +01001119API LY_ERR
1120lyd_new_ext_any(const struct lysc_ext_instance *ext, const char *name, const void *value, ly_bool use_value,
1121 LYD_ANYDATA_VALUETYPE value_type, struct lyd_node **node)
1122{
1123 struct lyd_node *ret = NULL;
1124 const struct lysc_node *schema;
1125 struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
1126
1127 LY_CHECK_ARG_RET(ctx, ext, node, name, LY_EINVAL);
1128
1129 schema = lysc_ext_find_node(ext, NULL, name, 0, LYD_NODE_ANY, 0);
1130 if (!schema) {
1131 if (ext->argument) {
1132 LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found in instance \"%s\" of extension %s.",
1133 name, ext->argument, ext->def->name);
1134 } else {
1135 LOGERR(ctx, LY_EINVAL, "Any node \"%s\" not found in instance of extension %s.", name, ext->def->name);
1136 }
1137 return LY_ENOTFOUND;
1138 }
1139 LY_CHECK_RET(lyd_create_any(schema, value, value_type, use_value, &ret));
1140
1141 *node = ret;
1142
1143 return LY_SUCCESS;
1144}
1145
Michal Vasko4490d312020-06-16 13:08:55 +02001146/**
1147 * @brief Update node value.
1148 *
1149 * @param[in] node Node to update.
1150 * @param[in] value New value to set.
1151 * @param[in] value_type Type of @p value for any node.
1152 * @param[out] new_parent Set to @p node if the value was updated, otherwise set to NULL.
1153 * @param[out] new_node Set to @p node if the value was updated, otherwise set to NULL.
1154 * @return LY_ERR value.
1155 */
Michal Vasko00cbf532020-06-15 13:58:47 +02001156static LY_ERR
1157lyd_new_path_update(struct lyd_node *node, const void *value, LYD_ANYDATA_VALUETYPE value_type,
Radek Krejci0f969882020-08-21 16:56:47 +02001158 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001159{
1160 LY_ERR ret = LY_SUCCESS;
1161 struct lyd_node *new_any;
1162
1163 switch (node->schema->nodetype) {
1164 case LYS_CONTAINER:
1165 case LYS_NOTIF:
1166 case LYS_RPC:
1167 case LYS_ACTION:
1168 case LYS_LIST:
1169 case LYS_LEAFLIST:
1170 /* if it exists, there is nothing to update */
1171 *new_parent = NULL;
1172 *new_node = NULL;
1173 break;
1174 case LYS_LEAF:
1175 ret = lyd_change_term(node, value);
1176 if ((ret == LY_SUCCESS) || (ret == LY_EEXIST)) {
1177 /* there was an actual change (at least of the default flag) */
1178 *new_parent = node;
1179 *new_node = node;
1180 ret = LY_SUCCESS;
1181 } else if (ret == LY_ENOT) {
1182 /* no change */
1183 *new_parent = NULL;
1184 *new_node = NULL;
1185 ret = LY_SUCCESS;
1186 } /* else error */
1187 break;
1188 case LYS_ANYDATA:
1189 case LYS_ANYXML:
1190 /* create a new any node */
Michal Vasko366a4a12020-12-04 16:23:57 +01001191 LY_CHECK_RET(lyd_create_any(node->schema, value, value_type, 0, &new_any));
Michal Vasko00cbf532020-06-15 13:58:47 +02001192
1193 /* compare with the existing one */
Michal Vasko8f359bf2020-07-28 10:41:15 +02001194 if (lyd_compare_single(node, new_any, 0)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001195 /* not equal, switch values (so that we can use generic node free) */
1196 ((struct lyd_node_any *)new_any)->value = ((struct lyd_node_any *)node)->value;
1197 ((struct lyd_node_any *)new_any)->value_type = ((struct lyd_node_any *)node)->value_type;
1198 ((struct lyd_node_any *)node)->value.str = value;
1199 ((struct lyd_node_any *)node)->value_type = value_type;
1200
1201 *new_parent = node;
1202 *new_node = node;
1203 } else {
1204 /* they are equal */
1205 *new_parent = NULL;
1206 *new_node = NULL;
1207 }
1208 lyd_free_tree(new_any);
1209 break;
1210 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02001211 LOGINT(LYD_CTX(node));
Michal Vasko00cbf532020-06-15 13:58:47 +02001212 ret = LY_EINT;
1213 break;
1214 }
1215
1216 return ret;
1217}
1218
Michal Vasko3a41dff2020-07-15 14:30:28 +02001219API LY_ERR
Michal Vasko871a0252020-11-11 18:35:24 +01001220lyd_new_meta(const struct ly_ctx *ctx, struct lyd_node *parent, const struct lys_module *module, const char *name,
1221 const char *val_str, ly_bool clear_dflt, struct lyd_meta **meta)
Michal Vaskod86997b2020-05-26 15:19:54 +02001222{
Michal Vaskod86997b2020-05-26 15:19:54 +02001223 const char *prefix, *tmp;
Michal Vaskod86997b2020-05-26 15:19:54 +02001224 size_t pref_len, name_len;
1225
Michal Vasko2b5344c2021-02-26 10:12:05 +01001226 LY_CHECK_ARG_RET(ctx, ctx || parent, name, module || strchr(name, ':'), parent || meta, LY_EINVAL);
1227 if (!ctx) {
1228 ctx = LYD_CTX(parent);
1229 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001230
Michal Vasko871a0252020-11-11 18:35:24 +01001231 if (parent && !parent->schema) {
Michal Vasko33b4fab2021-03-04 15:56:12 +01001232 LOGERR(ctx, LY_EINVAL, "Cannot add metadata \"%s\" to an opaque node \"%s\".", name, LYD_NAME(parent));
Michal Vasko871a0252020-11-11 18:35:24 +01001233 return LY_EINVAL;
1234 }
Michal Vasko610553d2020-11-18 18:15:05 +01001235 if (meta) {
1236 *meta = NULL;
1237 }
Michal Vaskod86997b2020-05-26 15:19:54 +02001238
1239 /* parse the name */
1240 tmp = name;
1241 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1242 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
Michal Vasko871a0252020-11-11 18:35:24 +01001243 return LY_EINVAL;
Michal Vaskod86997b2020-05-26 15:19:54 +02001244 }
1245
1246 /* find the module */
1247 if (prefix) {
Radek Krejci0ad51f12020-07-16 12:08:12 +02001248 module = ly_ctx_get_module_implemented2(ctx, prefix, pref_len);
Radek Krejci422afb12021-03-04 16:38:16 +01001249 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", (int)pref_len, prefix), LY_ENOTFOUND);
Michal Vaskod86997b2020-05-26 15:19:54 +02001250 }
1251
1252 /* set value if none */
1253 if (!val_str) {
1254 val_str = "";
1255 }
1256
Michal Vasko871a0252020-11-11 18:35:24 +01001257 return lyd_create_meta(parent, meta, module, name, name_len, val_str, strlen(val_str), NULL, LY_PREF_JSON,
1258 NULL, LYD_HINT_DATA, clear_dflt, NULL);
1259}
Michal Vasko3a41dff2020-07-15 14:30:28 +02001260
Michal Vaskoba696702020-11-11 19:12:45 +01001261API LY_ERR
1262lyd_new_meta2(const struct ly_ctx *ctx, struct lyd_node *parent, ly_bool clear_dflt, const struct lyd_attr *attr,
1263 struct lyd_meta **meta)
1264{
1265 const struct lys_module *mod;
1266
1267 LY_CHECK_ARG_RET(NULL, ctx, attr, parent || meta, LY_EINVAL);
1268
1269 if (parent && !parent->schema) {
1270 LOGERR(ctx, LY_EINVAL, "Cannot add metadata to an opaque node \"%s\".", ((struct lyd_node_opaq *)parent)->name);
1271 return LY_EINVAL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001272 }
Michal Vasko610553d2020-11-18 18:15:05 +01001273 if (meta) {
1274 *meta = NULL;
1275 }
Michal Vaskoba696702020-11-11 19:12:45 +01001276
1277 switch (attr->format) {
1278 case LY_PREF_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +01001279 mod = ly_ctx_get_module_implemented_ns(ctx, attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001280 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001281 LOGERR(ctx, LY_EINVAL, "Module with namespace \"%s\" not found.", attr->name.module_ns);
Michal Vaskoba696702020-11-11 19:12:45 +01001282 return LY_ENOTFOUND;
1283 }
1284 break;
1285 case LY_PREF_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +01001286 mod = ly_ctx_get_module_implemented(ctx, attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001287 if (!mod) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001288 LOGERR(ctx, LY_EINVAL, "Module \"%s\" not found.", attr->name.module_name);
Michal Vaskoba696702020-11-11 19:12:45 +01001289 return LY_ENOTFOUND;
1290 }
1291 break;
1292 default:
1293 LOGINT_RET(ctx);
1294 }
1295
Michal Vaskoad92b672020-11-12 13:11:31 +01001296 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 +01001297 NULL, attr->format, attr->val_prefix_data, attr->hints, clear_dflt, NULL);
Michal Vaskod86997b2020-05-26 15:19:54 +02001298}
1299
Michal Vasko3a41dff2020-07-15 14:30:28 +02001300API LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +02001301lyd_new_opaq(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Michal Vasko0ab974d2021-02-24 13:18:26 +01001302 const char *prefix, const char *module_name, struct lyd_node **node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001303{
1304 struct lyd_node *ret = NULL;
Radek Krejci07a55962021-03-02 20:16:43 +01001305
Michal Vasko0ab974d2021-02-24 13:18:26 +01001306 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 +02001307
1308 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001309 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001310 }
1311 if (!value) {
1312 value = "";
1313 }
1314
Michal Vasko0ab974d2021-02-24 13:18:26 +01001315 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_name,
1316 strlen(module_name), value, strlen(value), NULL, LY_PREF_JSON, NULL, 0, &ret));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001317 if (parent) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001318 lyd_insert_node(parent, NULL, ret);
1319 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001320
1321 if (node) {
1322 *node = ret;
1323 }
1324 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001325}
1326
Michal Vasko3a41dff2020-07-15 14:30:28 +02001327API LY_ERR
Michal Vasko8d65f852021-02-17 11:28:13 +01001328lyd_new_opaq2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *name, const char *value,
Michal Vasko0ab974d2021-02-24 13:18:26 +01001329 const char *prefix, const char *module_ns, struct lyd_node **node)
Michal Vasko8d65f852021-02-17 11:28:13 +01001330{
1331 struct lyd_node *ret = NULL;
1332
1333 LY_CHECK_ARG_RET(ctx, parent || ctx, parent || node, name, module_ns, LY_EINVAL);
1334
1335 if (!ctx) {
1336 ctx = LYD_CTX(parent);
1337 }
1338 if (!value) {
1339 value = "";
1340 }
1341
Michal Vasko0ab974d2021-02-24 13:18:26 +01001342 LY_CHECK_RET(lyd_create_opaq(ctx, name, strlen(name), prefix, prefix ? strlen(prefix) : 0, module_ns,
1343 strlen(module_ns), value, strlen(value), NULL, LY_PREF_XML, NULL, 0, &ret));
Michal Vasko8d65f852021-02-17 11:28:13 +01001344 if (parent) {
1345 lyd_insert_node(parent, NULL, ret);
1346 }
1347
1348 if (node) {
1349 *node = ret;
1350 }
1351 return LY_SUCCESS;
1352}
1353
1354API LY_ERR
1355lyd_new_attr(struct lyd_node *parent, const char *module_name, const char *name, const char *value,
Radek Krejci0f969882020-08-21 16:56:47 +02001356 struct lyd_attr **attr)
Michal Vasko00cbf532020-06-15 13:58:47 +02001357{
Radek Krejci1798aae2020-07-14 13:26:06 +02001358 struct lyd_attr *ret = NULL;
Michal Vasko00cbf532020-06-15 13:58:47 +02001359 const struct ly_ctx *ctx;
1360 const char *prefix, *tmp;
Michal Vasko51d21b82020-11-13 18:03:54 +01001361 size_t pref_len, name_len, mod_len;
Michal Vasko00cbf532020-06-15 13:58:47 +02001362
Michal Vasko3a41dff2020-07-15 14:30:28 +02001363 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
Michal Vasko00cbf532020-06-15 13:58:47 +02001364
Michal Vaskob7be7a82020-08-20 09:09:04 +02001365 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001366
1367 /* parse the name */
1368 tmp = name;
1369 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
Michal Vaskob69b68c2021-02-17 11:18:16 +01001370 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001371 return LY_EVALID;
Michal Vasko00cbf532020-06-15 13:58:47 +02001372 }
1373
Michal Vasko51d21b82020-11-13 18:03:54 +01001374 /* get the module */
1375 if (module_name) {
1376 mod_len = strlen(module_name);
1377 } else {
1378 module_name = prefix;
1379 mod_len = pref_len;
1380 }
1381
Michal Vasko00cbf532020-06-15 13:58:47 +02001382 /* set value if none */
Michal Vasko8d65f852021-02-17 11:28:13 +01001383 if (!value) {
1384 value = "";
Michal Vasko00cbf532020-06-15 13:58:47 +02001385 }
1386
Michal Vasko8d65f852021-02-17 11:28:13 +01001387 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_name, mod_len, value,
1388 strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA));
1389
1390 if (attr) {
1391 *attr = ret;
1392 }
1393 return LY_SUCCESS;
1394}
1395
1396API LY_ERR
1397lyd_new_attr2(struct lyd_node *parent, const char *module_ns, const char *name, const char *value,
1398 struct lyd_attr **attr)
1399{
1400 struct lyd_attr *ret = NULL;
1401 const struct ly_ctx *ctx;
1402 const char *prefix, *tmp;
1403 size_t pref_len, name_len;
1404
1405 LY_CHECK_ARG_RET(NULL, parent, !parent->schema, name, LY_EINVAL);
1406
1407 ctx = LYD_CTX(parent);
1408
1409 /* parse the name */
1410 tmp = name;
1411 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
1412 LOGERR(ctx, LY_EINVAL, "Attribute name \"%s\" is not valid.", name);
1413 return LY_EVALID;
1414 }
1415
1416 /* set value if none */
1417 if (!value) {
1418 value = "";
1419 }
1420
1421 LY_CHECK_RET(lyd_create_attr(parent, &ret, ctx, name, name_len, prefix, pref_len, module_ns,
1422 module_ns ? strlen(module_ns) : 0, value, strlen(value), NULL, LY_PREF_XML, NULL, LYD_HINT_DATA));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001423
1424 if (attr) {
1425 *attr = ret;
1426 }
1427 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +02001428}
1429
1430API LY_ERR
1431lyd_change_term(struct lyd_node *term, const char *val_str)
1432{
1433 LY_ERR ret = LY_SUCCESS;
1434 struct lysc_type *type;
1435 struct lyd_node_term *t;
1436 struct lyd_node *parent;
1437 struct lyd_value val = {0};
Radek Krejci857189e2020-09-01 13:26:36 +02001438 ly_bool dflt_change, val_change;
Michal Vasko00cbf532020-06-15 13:58:47 +02001439
1440 LY_CHECK_ARG_RET(NULL, term, term->schema, term->schema->nodetype & LYD_NODE_TERM, LY_EINVAL);
1441
1442 if (!val_str) {
1443 val_str = "";
1444 }
1445 t = (struct lyd_node_term *)term;
1446 type = ((struct lysc_node_leaf *)term->schema)->type;
1447
1448 /* parse the new value */
Radek Krejciddace2c2021-01-08 11:30:56 +01001449 LOG_LOCSET(term->schema, term, NULL, NULL);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001450 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 +01001451 term->schema, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001452 LOG_LOCBACK(term->schema ? 1 : 0, 1, 0, 0);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001453 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001454
1455 /* compare original and new value */
1456 if (type->plugin->compare(&t->value, &val)) {
1457 /* values differ, switch them */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001458 type->plugin->free(LYD_CTX(term), &t->value);
Michal Vasko00cbf532020-06-15 13:58:47 +02001459 t->value = val;
1460 memset(&val, 0, sizeof val);
1461 val_change = 1;
1462 } else {
1463 val_change = 0;
1464 }
1465
1466 /* always clear the default flag */
1467 if (term->flags & LYD_DEFAULT) {
Michal Vasko9e685082021-01-29 14:49:09 +01001468 for (parent = term; parent; parent = lyd_parent(parent)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001469 parent->flags &= ~LYD_DEFAULT;
1470 }
1471 dflt_change = 1;
1472 } else {
1473 dflt_change = 0;
1474 }
1475
1476 if (val_change || dflt_change) {
1477 /* make the node non-validated */
1478 term->flags &= LYD_NEW;
1479 }
1480
1481 if (val_change) {
1482 if (term->schema->nodetype == LYS_LEAFLIST) {
1483 /* leaf-list needs to be hashed again and re-inserted into parent */
1484 lyd_unlink_hash(term);
1485 lyd_hash(term);
1486 LY_CHECK_GOTO(ret = lyd_insert_hash(term), cleanup);
1487 } else if ((term->schema->flags & LYS_KEY) && term->parent) {
1488 /* list needs to be updated if its key was changed */
1489 assert(term->parent->schema->nodetype == LYS_LIST);
Michal Vasko9e685082021-01-29 14:49:09 +01001490 lyd_unlink_hash(lyd_parent(term));
1491 lyd_hash(lyd_parent(term));
1492 LY_CHECK_GOTO(ret = lyd_insert_hash(lyd_parent(term)), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001493 } /* else leaf that is not a key, its value is not used for its hash so it does not change */
1494 }
1495
1496 /* retrun value */
1497 if (!val_change) {
1498 if (dflt_change) {
1499 /* only default flag change */
1500 ret = LY_EEXIST;
1501 } else {
1502 /* no change */
1503 ret = LY_ENOT;
1504 }
1505 } /* else value changed, LY_SUCCESS */
1506
1507cleanup:
Michal Vasko59512fc2020-12-09 18:13:29 +01001508 if (val.realtype) {
1509 type->plugin->free(LYD_CTX(term), &val);
1510 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001511 return ret;
1512}
1513
Michal Vasko41586352020-07-13 13:54:25 +02001514API LY_ERR
1515lyd_change_meta(struct lyd_meta *meta, const char *val_str)
1516{
1517 LY_ERR ret = LY_SUCCESS;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001518 struct lyd_meta *m2 = NULL;
Michal Vasko41586352020-07-13 13:54:25 +02001519 struct lyd_value val;
Radek Krejci857189e2020-09-01 13:26:36 +02001520 ly_bool val_change;
Michal Vasko41586352020-07-13 13:54:25 +02001521
1522 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
1523
1524 if (!val_str) {
1525 val_str = "";
1526 }
1527
1528 /* parse the new value into a new meta structure */
1529 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 +01001530 strlen(val_str), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, 0, NULL), cleanup);
Michal Vasko41586352020-07-13 13:54:25 +02001531
1532 /* compare original and new value */
1533 if (lyd_compare_meta(meta, m2)) {
1534 /* values differ, switch them */
1535 val = meta->value;
1536 meta->value = m2->value;
1537 m2->value = val;
1538 val_change = 1;
1539 } else {
1540 val_change = 0;
1541 }
1542
1543 /* retrun value */
1544 if (!val_change) {
1545 /* no change */
1546 ret = LY_ENOT;
1547 } /* else value changed, LY_SUCCESS */
1548
1549cleanup:
Michal Vasko1a66a5d2020-11-18 18:15:37 +01001550 lyd_free_meta_single(m2);
Michal Vasko41586352020-07-13 13:54:25 +02001551 return ret;
1552}
1553
Michal Vasko6741dc62021-02-04 09:27:45 +01001554static LY_ERR
1555lyd_new_path_check_find_lypath(struct ly_path *path, const char *str_path, const char *value, uint32_t options)
1556{
1557 LY_ERR ret = LY_SUCCESS, r;
Radek Krejci910d0132021-03-05 14:19:31 +01001558 const struct lysc_node *schema = NULL;
Michal Vasko6741dc62021-02-04 09:27:45 +01001559 struct ly_path_predicate *pred;
Radek Krejci910d0132021-03-05 14:19:31 +01001560 LY_ARRAY_COUNT_TYPE u, new_count = 0;
Michal Vasko6741dc62021-02-04 09:27:45 +01001561
1562 assert(path);
1563
1564 /* go through all the compiled nodes */
1565 LY_ARRAY_FOR(path, u) {
1566 schema = path[u].node;
Michal Vasko6f9b4262021-02-04 12:09:56 +01001567 new_count = u + 1;
Michal Vasko6741dc62021-02-04 09:27:45 +01001568 if ((schema->nodetype == LYS_LIST) && (path[u].pred_type == LY_PATH_PREDTYPE_NONE)) {
1569 if (schema->flags & LYS_KEYLESS) {
1570 /* creating a new keyless list instance */
1571 break;
1572 } else if ((u < LY_ARRAY_COUNT(path) - 1) || !(options & LYD_NEW_PATH_OPAQ)) {
1573 LOG_LOCSET(schema, NULL, NULL, NULL);
1574 LOGVAL(schema->module->ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1575 lys_nodetype2str(schema->nodetype), schema->name, str_path);
1576 LOG_LOCBACK(1, 0, 0, 0);
1577 return LY_EINVAL;
1578 } /* else creating an opaque list without keys */
1579 }
1580 }
1581
Michal Vasko6f9b4262021-02-04 12:09:56 +01001582 if ((schema->nodetype == LYS_LEAFLIST) && (path[new_count - 1].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001583 /* parse leafref value into a predicate, if not defined in the path */
1584 if (!value) {
1585 value = "";
1586 }
1587
1588 r = LY_SUCCESS;
1589 if (options & LYD_NEW_PATH_OPAQ) {
1590 r = lys_value_validate(NULL, schema, value, strlen(value));
1591 }
1592 if (!r) {
1593 /* store the new predicate */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001594 path[new_count - 1].pred_type = LY_PATH_PREDTYPE_LEAFLIST;
1595 LY_ARRAY_NEW_GOTO(schema->module->ctx, path[new_count - 1].predicates, pred, ret, cleanup);
Michal Vasko6741dc62021-02-04 09:27:45 +01001596
1597 ret = lyd_value_store(schema->module->ctx, &pred->value, ((struct lysc_node_leaflist *)schema)->type, value,
1598 strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, schema, NULL);
1599 LY_CHECK_GOTO(ret, cleanup);
1600 ++((struct lysc_type *)pred->value.realtype)->refcount;
1601
1602 if (schema->flags & LYS_CONFIG_R) {
1603 /* creating a new state leaf-list instance */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001604 --new_count;
Michal Vasko6741dc62021-02-04 09:27:45 +01001605 }
1606 } /* else we have opaq flag and the value is not valid, leave no predicate and then create an opaque node */
1607 }
1608
1609 /* hide the nodes that should always be created so they are not found */
Michal Vasko6f9b4262021-02-04 12:09:56 +01001610 while (new_count < LY_ARRAY_COUNT(path)) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001611 LY_ARRAY_DECREMENT(path);
1612 }
1613
1614cleanup:
1615 return ret;
1616}
1617
Radek Krejci95ccd1b2021-03-12 14:57:22 +01001618/**
1619 * @brief Create a new node in the data tree based on a path. All node types can be created.
1620 *
1621 * If @p path points to a list key and the list instance does not exist, the key value from the predicate is used
1622 * and @p value is ignored. Also, if a leaf-list is being created and both a predicate is defined in @p path
1623 * and @p value is set, the predicate is preferred.
1624 *
1625 * For key-less lists and state leaf-lists, positional predicates can be used. If no preciate is used for these
1626 * nodes, they are always created.
1627 *
1628 * @param[in] parent Data parent to add to/modify, can be NULL. Note that in case a first top-level sibling is used,
1629 * it may no longer be first if @p path is absolute and starts with a non-existing top-level node inserted
1630 * before @p parent. Use ::lyd_first_sibling() to adjust @p parent in these cases.
1631 * @param[in] ctx libyang context, must be set if @p parent is NULL.
1632 * @param[in] ext Extension instance where the node being created is defined. This argument takes effect only for absolute
1633 * path or when the relative paths touches document root (top-level). In such cases the present extension instance replaces
1634 * searching for the appropriate module.
1635 * @param[in] path [Path](@ref howtoXPath) to create.
1636 * @param[in] value Value of the new leaf/leaf-list (const char *) or anyxml/anydata (expected type depends on @p value_type).
1637 * For other node types, it is ignored.
1638 * @param[in] value_type Anyxml/anydata node @p value type.
1639 * @param[in] options Bitmask of options, see @ref pathoptions.
1640 * @param[out] new_parent Optional first parent node created. If only one node was created, equals to @p new_node.
1641 * @param[out] new_node Optional last node created.
1642 * @return LY_ERR value.
1643 */
1644static LY_ERR
1645lyd_new_path_(struct lyd_node *parent, const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, const char *path,
1646 const void *value, LYD_ANYDATA_VALUETYPE value_type, uint32_t options,
1647 struct lyd_node **new_parent, struct lyd_node **new_node)
Michal Vasko00cbf532020-06-15 13:58:47 +02001648{
1649 LY_ERR ret = LY_SUCCESS, r;
1650 struct lyxp_expr *exp = NULL;
1651 struct ly_path *p = NULL;
1652 struct lyd_node *nparent = NULL, *nnode = NULL, *node = NULL, *cur_parent;
1653 const struct lysc_node *schema;
Radek Krejci910d0132021-03-05 14:19:31 +01001654 LY_ARRAY_COUNT_TYPE path_idx = 0, orig_count = 0;
Michal Vasko00cbf532020-06-15 13:58:47 +02001655
Radek Krejci95ccd1b2021-03-12 14:57:22 +01001656 assert(parent || ctx);
1657 assert(path);
1658 assert((path[0] == '/') || parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001659
1660 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001661 ctx = LYD_CTX(parent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001662 }
1663
1664 /* parse path */
Michal Vasko6b26e742020-07-17 15:02:10 +02001665 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 +02001666 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &exp), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001667
1668 /* compile path */
Radek Krejci95ccd1b2021-03-12 14:57:22 +01001669 LY_CHECK_GOTO(ret = ly_path_compile(ctx, NULL, parent ? parent->schema : NULL, ext, exp, LY_PATH_LREF_FALSE,
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001670 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 +01001671 NULL, NULL, &p), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001672
Michal Vasko6741dc62021-02-04 09:27:45 +01001673 /* check the compiled path before searching existing nodes, it may be shortened */
1674 orig_count = LY_ARRAY_COUNT(p);
1675 LY_CHECK_GOTO(ret = lyd_new_path_check_find_lypath(p, path, value, options), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001676
1677 /* try to find any existing nodes in the path */
1678 if (parent) {
1679 ret = ly_path_eval_partial(p, parent, &path_idx, &node);
1680 if (ret == LY_SUCCESS) {
Michal Vasko6741dc62021-02-04 09:27:45 +01001681 if (orig_count == LY_ARRAY_COUNT(p)) {
1682 /* the node exists, are we supposed to update it or is it just a default? */
1683 if (!(options & LYD_NEW_PATH_UPDATE) && !(node->flags & LYD_DEFAULT)) {
1684 LOG_LOCSET(NULL, node, NULL, NULL);
1685 LOGVAL(ctx, LYVE_REFERENCE, "Path \"%s\" already exists", path);
1686 LOG_LOCBACK(0, 1, 0, 0);
1687 ret = LY_EEXIST;
1688 goto cleanup;
1689 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001690
Michal Vasko6741dc62021-02-04 09:27:45 +01001691 /* update the existing node */
1692 ret = lyd_new_path_update(node, value, value_type, &nparent, &nnode);
1693 goto cleanup;
1694 } /* else we were not searching for the whole path */
Michal Vasko00cbf532020-06-15 13:58:47 +02001695 } else if (ret == LY_EINCOMPLETE) {
1696 /* some nodes were found, adjust the iterator to the next segment */
1697 ++path_idx;
1698 } else if (ret == LY_ENOTFOUND) {
1699 /* 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 +01001700 if (lysc_data_parent(p[0].node)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001701 node = parent;
1702 }
1703 } else {
1704 /* error */
1705 goto cleanup;
1706 }
1707 }
1708
Michal Vasko6741dc62021-02-04 09:27:45 +01001709 /* restore the full path for creating new nodes */
1710 while (orig_count > LY_ARRAY_COUNT(p)) {
1711 LY_ARRAY_INCREMENT(p);
1712 }
1713
Michal Vasko00cbf532020-06-15 13:58:47 +02001714 /* create all the non-existing nodes in a loop */
Michal Vaskod989ba02020-08-24 10:59:24 +02001715 for ( ; path_idx < LY_ARRAY_COUNT(p); ++path_idx) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001716 cur_parent = node;
1717 schema = p[path_idx].node;
1718
1719 switch (schema->nodetype) {
1720 case LYS_LIST:
1721 if (!(schema->flags & LYS_KEYLESS)) {
Radek Krejci092e33c2020-10-12 15:33:10 +02001722 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001723 /* creating opaque list without keys */
Michal Vasko501af032020-11-11 20:27:44 +01001724 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1725 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1726 LYD_NODEHINT_LIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001727 } else {
Michal Vasko8b776962021-01-12 12:21:49 +01001728 if (p[path_idx].pred_type != LY_PATH_PREDTYPE_LIST) {
1729 LOG_LOCSET(schema, NULL, NULL, NULL);
1730 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path \"%s\".",
1731 lys_nodetype2str(schema->nodetype), schema->name, path);
1732 LOG_LOCBACK(1, 0, 0, 0);
1733 ret = LY_EINVAL;
1734 goto cleanup;
1735 }
1736
Michal Vasko00cbf532020-06-15 13:58:47 +02001737 LY_CHECK_GOTO(ret = lyd_create_list(schema, p[path_idx].predicates, &node), cleanup);
1738 }
1739 break;
1740 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001741 /* fall through */
Michal Vasko00cbf532020-06-15 13:58:47 +02001742 case LYS_CONTAINER:
1743 case LYS_NOTIF:
1744 case LYS_RPC:
1745 case LYS_ACTION:
1746 LY_CHECK_GOTO(ret = lyd_create_inner(schema, &node), cleanup);
1747 break;
1748 case LYS_LEAFLIST:
Radek Krejci092e33c2020-10-12 15:33:10 +02001749 if ((options & LYD_NEW_PATH_OPAQ) && (p[path_idx].pred_type == LY_PATH_PREDTYPE_NONE)) {
Michal Vasko00cbf532020-06-15 13:58:47 +02001750 /* creating opaque leaf-list without value */
Michal Vasko501af032020-11-11 20:27:44 +01001751 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0,
1752 schema->module->name, strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL,
1753 LYD_NODEHINT_LEAFLIST, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001754 } else {
1755 assert(p[path_idx].pred_type == LY_PATH_PREDTYPE_LEAFLIST);
1756 LY_CHECK_GOTO(ret = lyd_create_term2(schema, &p[path_idx].predicates[0].value, &node), cleanup);
1757 }
1758 break;
1759 case LYS_LEAF:
Michal Vasko35880332020-12-08 13:08:12 +01001760 if (lysc_is_key(schema)) {
1761 /* it must have been already created or some error will occur later */
1762 assert(cur_parent);
1763 node = lyd_child(cur_parent);
1764 assert(node && (node->schema == schema));
1765 goto next_iter;
1766 }
1767
1768 /* make sure there is some value */
Michal Vasko00cbf532020-06-15 13:58:47 +02001769 if (!value) {
1770 value = "";
1771 }
1772
1773 r = LY_SUCCESS;
Radek Krejci092e33c2020-10-12 15:33:10 +02001774 if (options & LYD_NEW_PATH_OPAQ) {
Michal Vaskof937cfe2020-08-03 16:07:12 +02001775 r = lys_value_validate(NULL, schema, value, strlen(value));
Michal Vasko00cbf532020-06-15 13:58:47 +02001776 }
1777 if (!r) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001778 ret = lyd_create_term(schema, value, strlen(value), NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &node);
1779 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001780 } else {
1781 /* creating opaque leaf without value */
Michal Vasko501af032020-11-11 20:27:44 +01001782 LY_CHECK_GOTO(ret = lyd_create_opaq(ctx, schema->name, strlen(schema->name), NULL, 0, schema->module->name,
1783 strlen(schema->module->name), NULL, 0, NULL, LY_PREF_JSON, NULL, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001784 }
1785 break;
1786 case LYS_ANYDATA:
1787 case LYS_ANYXML:
Michal Vasko366a4a12020-12-04 16:23:57 +01001788 LY_CHECK_GOTO(ret = lyd_create_any(schema, value, value_type, 0, &node), cleanup);
Michal Vasko00cbf532020-06-15 13:58:47 +02001789 break;
1790 default:
1791 LOGINT(ctx);
1792 ret = LY_EINT;
1793 goto cleanup;
1794 }
1795
1796 if (cur_parent) {
1797 /* connect to the parent */
1798 lyd_insert_node(cur_parent, NULL, node);
1799 } else if (parent) {
1800 /* connect to top-level siblings */
1801 lyd_insert_node(NULL, &parent, node);
1802 }
1803
Michal Vasko35880332020-12-08 13:08:12 +01001804next_iter:
Michal Vasko00cbf532020-06-15 13:58:47 +02001805 /* update remembered nodes */
1806 if (!nparent) {
1807 nparent = node;
1808 }
1809 nnode = node;
1810 }
1811
1812cleanup:
1813 lyxp_expr_free(ctx, exp);
Michal Vasko6741dc62021-02-04 09:27:45 +01001814 if (p) {
1815 while (orig_count > LY_ARRAY_COUNT(p)) {
1816 LY_ARRAY_INCREMENT(p);
1817 }
1818 }
Michal Vasko00cbf532020-06-15 13:58:47 +02001819 ly_path_free(ctx, p);
1820 if (!ret) {
1821 /* set out params only on success */
1822 if (new_parent) {
1823 *new_parent = nparent;
1824 }
1825 if (new_node) {
1826 *new_node = nnode;
1827 }
Michal Vaskof4b95ba2020-12-11 08:42:33 +01001828 } else {
1829 lyd_free_tree(nparent);
Michal Vasko00cbf532020-06-15 13:58:47 +02001830 }
1831 return ret;
1832}
1833
Radek Krejci95ccd1b2021-03-12 14:57:22 +01001834API LY_ERR
1835lyd_new_path(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const char *value, uint32_t options,
1836 struct lyd_node **node)
1837{
1838 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1839 return lyd_new_path_(parent, ctx, NULL, path, value, LYD_ANYDATA_STRING, options, node, NULL);
1840}
1841
1842API LY_ERR
1843lyd_new_path2(struct lyd_node *parent, const struct ly_ctx *ctx, const char *path, const void *value,
1844 LYD_ANYDATA_VALUETYPE value_type, uint32_t options, struct lyd_node **new_parent, struct lyd_node **new_node)
1845{
1846 LY_CHECK_ARG_RET(ctx, parent || ctx, path, (path[0] == '/') || parent, LY_EINVAL);
1847 return lyd_new_path_(parent, ctx, NULL, path, value, value_type, options, new_parent, new_node);
1848}
1849
1850API LY_ERR
1851lyd_new_ext_path(struct lyd_node *parent, const struct lysc_ext_instance *ext, const char *path, const void *value,
1852 uint32_t options, struct lyd_node **node)
1853{
1854 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
1855
1856 LY_CHECK_ARG_RET(ctx, ext, path, (path[0] == '/') || parent, LY_EINVAL);
1857 return lyd_new_path_(parent, ctx, ext, path, value, LYD_ANYDATA_STRING, options, node, NULL);
1858}
1859
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001860LY_ERR
1861lyd_new_implicit_r(struct lyd_node *parent, struct lyd_node **first, const struct lysc_node *sparent,
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001862 const struct lys_module *mod, struct ly_set *node_when, struct ly_set *node_types, uint32_t impl_opts,
Radek Krejci0f969882020-08-21 16:56:47 +02001863 struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001864{
1865 LY_ERR ret;
Michal Vaskod1e53b92021-01-28 13:11:06 +01001866 const struct lysc_node *iter = NULL;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001867 struct lyd_node *node = NULL;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001868 struct lyd_value **dflts;
1869 LY_ARRAY_COUNT_TYPE u;
Michal Vasko630d9892020-12-08 17:11:08 +01001870 uint32_t getnext_opts;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001871
1872 assert(first && (parent || sparent || mod));
1873
1874 if (!sparent && parent) {
1875 sparent = parent->schema;
1876 }
1877
Michal Vasko630d9892020-12-08 17:11:08 +01001878 getnext_opts = LYS_GETNEXT_WITHCHOICE;
1879 if (impl_opts & LYD_IMPLICIT_OUTPUT) {
1880 getnext_opts |= LYS_GETNEXT_OUTPUT;
1881 }
1882
1883 while ((iter = lys_getnext(iter, sparent, mod ? mod->compiled : NULL, getnext_opts))) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001884 if ((impl_opts & LYD_IMPLICIT_NO_STATE) && (iter->flags & LYS_CONFIG_R)) {
1885 continue;
Michal Vasko44b19a12020-08-07 09:21:30 +02001886 } else if ((impl_opts & LYD_IMPLICIT_NO_CONFIG) && (iter->flags & LYS_CONFIG_W)) {
1887 continue;
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001888 }
1889
1890 switch (iter->nodetype) {
1891 case LYS_CHOICE:
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001892 node = lys_getnext_data(NULL, *first, NULL, iter, NULL);
1893 if (!node && ((struct lysc_node_choice *)iter)->dflt) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001894 /* create default case data */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001895 LY_CHECK_RET(lyd_new_implicit_r(parent, first, &((struct lysc_node_choice *)iter)->dflt->node,
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001896 NULL, node_when, node_types, impl_opts, diff));
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001897 } else if (node) {
1898 /* create any default data in the existing case */
1899 assert(node->schema->parent->nodetype == LYS_CASE);
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001900 LY_CHECK_RET(lyd_new_implicit_r(parent, first, node->schema->parent, NULL, node_when, node_types,
Michal Vaskobcf4d7d2020-11-18 18:16:49 +01001901 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001902 }
1903 break;
1904 case LYS_CONTAINER:
1905 if (!(iter->flags & LYS_PRESENCE) && lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
1906 /* create default NP container */
1907 LY_CHECK_RET(lyd_create_inner(iter, &node));
Radek Krejci9a3823e2021-01-27 20:26:46 +01001908 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001909 lyd_insert_node(parent, first, node);
1910
Michal Vaskoe16c7b72021-02-26 10:39:06 +01001911 if (lysc_node_when(iter) && node_when) {
1912 /* remember to resolve when */
1913 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
1914 }
Michal Vaskoe49b6322020-11-05 17:38:36 +01001915 if (diff) {
1916 /* add into diff */
1917 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1918 }
1919
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001920 /* create any default children */
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001921 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, node_when, node_types,
Michal Vasko69730152020-10-09 16:30:07 +02001922 impl_opts, diff));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001923 }
1924 break;
1925 case LYS_LEAF:
Michal Vasko69730152020-10-09 16:30:07 +02001926 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaf *)iter)->dflt &&
1927 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001928 /* create default leaf */
1929 ret = lyd_create_term2(iter, ((struct lysc_node_leaf *)iter)->dflt, &node);
1930 if (ret == LY_EINCOMPLETE) {
1931 if (node_types) {
1932 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001933 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001934 }
1935 } else if (ret) {
1936 return ret;
1937 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001938 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001939 lyd_insert_node(parent, first, node);
1940
Radek Krejci9a3823e2021-01-27 20:26:46 +01001941 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001942 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001943 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001944 }
1945 if (diff) {
1946 /* add into diff */
1947 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1948 }
1949 }
1950 break;
1951 case LYS_LEAFLIST:
Michal Vasko69730152020-10-09 16:30:07 +02001952 if (!(impl_opts & LYD_IMPLICIT_NO_DEFAULTS) && ((struct lysc_node_leaflist *)iter)->dflts &&
1953 lyd_find_sibling_val(*first, iter, NULL, 0, NULL)) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001954 /* create all default leaf-lists */
1955 dflts = ((struct lysc_node_leaflist *)iter)->dflts;
1956 LY_ARRAY_FOR(dflts, u) {
1957 ret = lyd_create_term2(iter, dflts[u], &node);
1958 if (ret == LY_EINCOMPLETE) {
1959 if (node_types) {
1960 /* remember to resolve type */
Radek Krejci3d92e442020-10-12 12:48:13 +02001961 LY_CHECK_RET(ly_set_add(node_types, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001962 }
1963 } else if (ret) {
1964 return ret;
1965 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001966 node->flags = LYD_DEFAULT | (lysc_node_when(node->schema) ? LYD_WHEN_TRUE : 0);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001967 lyd_insert_node(parent, first, node);
1968
Radek Krejci9a3823e2021-01-27 20:26:46 +01001969 if (lysc_node_when(iter) && node_when) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001970 /* remember to resolve when */
Radek Krejci3d92e442020-10-12 12:48:13 +02001971 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL));
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001972 }
1973 if (diff) {
1974 /* add into diff */
1975 LY_CHECK_RET(lyd_val_diff_add(node, LYD_DIFF_OP_CREATE, diff));
1976 }
1977 }
1978 }
1979 break;
1980 default:
1981 /* without defaults */
1982 break;
1983 }
1984 }
1985
1986 return LY_SUCCESS;
1987}
1988
1989API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001990lyd_new_implicit_tree(struct lyd_node *tree, uint32_t implicit_options, struct lyd_node **diff)
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001991{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001992 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01001993 struct lyd_node *node;
1994 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02001995
1996 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
1997 if (diff) {
1998 *diff = NULL;
1999 }
2000
Michal Vasko56daf732020-08-10 10:57:18 +02002001 LYD_TREE_DFS_BEGIN(tree, node) {
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002002 /* skip added default nodes */
Michal Vasko69730152020-10-09 16:30:07 +02002003 if (((node->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) &&
2004 (node->schema->nodetype & LYD_NODE_INNER)) {
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01002005 LY_CHECK_GOTO(ret = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, &node_when,
2006 NULL, implicit_options, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002007 }
2008
Michal Vasko56daf732020-08-10 10:57:18 +02002009 LYD_TREE_DFS_END(tree, node);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002010 }
2011
Michal Vasko3488ada2020-12-03 14:18:19 +01002012 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01002013 LY_CHECK_GOTO(ret = lyd_validate_unres(&tree, NULL, &node_when, NULL, NULL, diff), cleanup);
Michal Vasko3488ada2020-12-03 14:18:19 +01002014
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002015cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01002016 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002017 if (ret && diff) {
2018 lyd_free_all(*diff);
2019 *diff = NULL;
2020 }
2021 return ret;
2022}
2023
2024API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002025lyd_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 +02002026{
2027 const struct lys_module *mod;
2028 struct lyd_node *d = NULL;
2029 uint32_t i = 0;
2030 LY_ERR ret = LY_SUCCESS;
2031
2032 LY_CHECK_ARG_RET(ctx, tree, *tree || ctx, LY_EINVAL);
2033 if (diff) {
2034 *diff = NULL;
2035 }
2036 if (!ctx) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002037 ctx = LYD_CTX(*tree);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002038 }
2039
2040 /* add nodes for each module one-by-one */
2041 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
2042 if (!mod->implemented) {
2043 continue;
2044 }
2045
2046 LY_CHECK_GOTO(ret = lyd_new_implicit_module(tree, mod, implicit_options, diff ? &d : NULL), cleanup);
2047 if (d) {
2048 /* merge into one diff */
2049 lyd_insert_sibling(*diff, d, diff);
2050
2051 d = NULL;
2052 }
2053 }
2054
2055cleanup:
2056 if (ret && diff) {
2057 lyd_free_all(*diff);
2058 *diff = NULL;
2059 }
2060 return ret;
2061}
2062
2063API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002064lyd_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 +02002065{
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002066 LY_ERR ret = LY_SUCCESS;
Michal Vasko3488ada2020-12-03 14:18:19 +01002067 struct lyd_node *root, *d = NULL;
2068 struct ly_set node_when = {0};
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002069
2070 LY_CHECK_ARG_RET(NULL, tree, module, LY_EINVAL);
2071 if (diff) {
2072 *diff = NULL;
2073 }
2074
2075 /* add all top-level defaults for this module */
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01002076 LY_CHECK_GOTO(ret = lyd_new_implicit_r(NULL, tree, NULL, module, &node_when, NULL, implicit_options, diff), cleanup);
Michal Vasko3488ada2020-12-03 14:18:19 +01002077
2078 /* resolve when and remove any invalid defaults */
Michal Vaskod3bb12f2020-12-04 14:33:09 +01002079 LY_CHECK_GOTO(ret = lyd_validate_unres(tree, module, &node_when, NULL, NULL, diff), cleanup);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002080
2081 /* process nested nodes */
2082 LY_LIST_FOR(*tree, root) {
2083 /* skip added default nodes */
2084 if ((root->flags & (LYD_DEFAULT | LYD_NEW)) != (LYD_DEFAULT | LYD_NEW)) {
2085 LY_CHECK_GOTO(ret = lyd_new_implicit_tree(root, implicit_options, diff ? &d : NULL), cleanup);
2086
2087 if (d) {
2088 /* merge into one diff */
2089 lyd_insert_sibling(*diff, d, diff);
2090
2091 d = NULL;
2092 }
2093 }
2094 }
2095
2096cleanup:
Michal Vasko3488ada2020-12-03 14:18:19 +01002097 ly_set_erase(&node_when, NULL);
Michal Vaskoa6669ba2020-08-06 16:14:26 +02002098 if (ret && diff) {
2099 lyd_free_all(*diff);
2100 *diff = NULL;
2101 }
2102 return ret;
2103}
2104
Michal Vasko90932a92020-02-12 14:33:03 +01002105struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +02002106lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +01002107{
Michal Vaskob104f112020-07-17 09:54:54 +02002108 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +01002109 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02002110 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +01002111 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +01002112
Michal Vaskob104f112020-07-17 09:54:54 +02002113 assert(new_node);
2114
2115 if (!first_sibling || !new_node->schema) {
2116 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +01002117 return NULL;
2118 }
2119
Michal Vasko93b16062020-12-09 18:14:18 +01002120 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +01002121 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +01002122 getnext_opts = LYS_GETNEXT_OUTPUT;
2123 }
2124
Michal Vaskob104f112020-07-17 09:54:54 +02002125 if (first_sibling->parent && first_sibling->parent->children_ht) {
2126 /* find the anchor using hashes */
2127 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +01002128 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02002129 while (schema) {
2130 /* keep trying to find the first existing instance of the closest following schema sibling,
2131 * otherwise return NULL - inserting at the end */
2132 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
2133 break;
2134 }
2135
Michal Vasko93b16062020-12-09 18:14:18 +01002136 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02002137 }
2138 } else {
2139 /* find the anchor without hashes */
2140 match = (struct lyd_node *)first_sibling;
2141 if (!lysc_data_parent(new_node->schema)) {
2142 /* we are in top-level, skip all the data from preceding modules */
2143 LY_LIST_FOR(match, match) {
2144 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
2145 break;
2146 }
2147 }
2148 }
2149
2150 /* get the first schema sibling */
2151 sparent = lysc_data_parent(new_node->schema);
Michal Vasko93b16062020-12-09 18:14:18 +01002152 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02002153
2154 found = 0;
2155 LY_LIST_FOR(match, match) {
2156 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
2157 /* we have found an opaque node, which must be at the end, so use it OR
2158 * modules do not match, so we must have traversed all the data from new_node module (if any),
2159 * we have found the first node of the next module, that is what we want */
2160 break;
2161 }
2162
2163 /* skip schema nodes until we find the instantiated one */
2164 while (!found) {
2165 if (new_node->schema == schema) {
2166 /* we have found the schema of the new node, continue search to find the first
2167 * data node with a different schema (after our schema) */
2168 found = 1;
2169 break;
2170 }
2171 if (match->schema == schema) {
2172 /* current node (match) is a data node still before the new node, continue search in data */
2173 break;
2174 }
Michal Vasko93b16062020-12-09 18:14:18 +01002175 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +02002176 assert(schema);
2177 }
2178
2179 if (found && (match->schema != new_node->schema)) {
2180 /* find the next node after we have found our node schema data instance */
2181 break;
2182 }
2183 }
Michal Vasko90932a92020-02-12 14:33:03 +01002184 }
2185
2186 return match;
2187}
2188
2189/**
2190 * @brief Insert node after a sibling.
2191 *
Michal Vasko9f96a052020-03-10 09:41:45 +01002192 * Handles inserting into NP containers and key-less lists.
2193 *
Michal Vasko90932a92020-02-12 14:33:03 +01002194 * @param[in] sibling Sibling to insert after.
2195 * @param[in] node Node to insert.
2196 */
2197static void
Michal Vaskof03ed032020-03-04 13:31:44 +01002198lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002199{
Michal Vasko0249f7c2020-03-05 16:36:40 +01002200 struct lyd_node_inner *par;
2201
Michal Vasko90932a92020-02-12 14:33:03 +01002202 assert(!node->next && (node->prev == node));
2203
2204 node->next = sibling->next;
2205 node->prev = sibling;
2206 sibling->next = node;
2207 if (node->next) {
2208 /* sibling had a succeeding node */
2209 node->next->prev = node;
2210 } else {
2211 /* sibling was last, find first sibling and change its prev */
2212 if (sibling->parent) {
2213 sibling = sibling->parent->child;
2214 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +02002215 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +01002216 }
2217 sibling->prev = node;
2218 }
2219 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002220
Michal Vasko9f96a052020-03-10 09:41:45 +01002221 for (par = node->parent; par; par = par->parent) {
2222 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
2223 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01002224 par->flags &= ~LYD_DEFAULT;
2225 }
Michal Vaskob104f112020-07-17 09:54:54 +02002226 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002227 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01002228 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01002229 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01002230 }
Michal Vasko90932a92020-02-12 14:33:03 +01002231}
2232
2233/**
2234 * @brief Insert node before a sibling.
2235 *
Michal Vasko9f96a052020-03-10 09:41:45 +01002236 * Handles inserting into NP containers and key-less lists.
2237 *
Michal Vasko90932a92020-02-12 14:33:03 +01002238 * @param[in] sibling Sibling to insert before.
2239 * @param[in] node Node to insert.
2240 */
2241static void
Michal Vaskof03ed032020-03-04 13:31:44 +01002242lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002243{
Michal Vasko0249f7c2020-03-05 16:36:40 +01002244 struct lyd_node_inner *par;
2245
Michal Vasko90932a92020-02-12 14:33:03 +01002246 assert(!node->next && (node->prev == node));
2247
2248 node->next = sibling;
2249 /* covers situation of sibling being first */
2250 node->prev = sibling->prev;
2251 sibling->prev = node;
2252 if (node->prev->next) {
2253 /* sibling had a preceding node */
2254 node->prev->next = node;
2255 } else if (sibling->parent) {
2256 /* sibling was first and we must also change parent child pointer */
2257 sibling->parent->child = node;
2258 }
2259 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002260
Michal Vasko9f96a052020-03-10 09:41:45 +01002261 for (par = node->parent; par; par = par->parent) {
2262 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
2263 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01002264 par->flags &= ~LYD_DEFAULT;
2265 }
Michal Vaskob104f112020-07-17 09:54:54 +02002266 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002267 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01002268 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01002269 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01002270 }
Michal Vasko90932a92020-02-12 14:33:03 +01002271}
2272
2273/**
Michal Vaskob104f112020-07-17 09:54:54 +02002274 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +01002275 *
Michal Vasko9f96a052020-03-10 09:41:45 +01002276 * Handles inserting into NP containers and key-less lists.
2277 *
Michal Vasko90932a92020-02-12 14:33:03 +01002278 * @param[in] parent Parent to insert into.
2279 * @param[in] node Node to insert.
2280 */
2281static void
Michal Vaskob104f112020-07-17 09:54:54 +02002282lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002283{
2284 struct lyd_node_inner *par;
2285
Radek Krejcia1c1e542020-09-29 16:06:52 +02002286 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +01002287 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +01002288
2289 par = (struct lyd_node_inner *)parent;
2290
Michal Vaskob104f112020-07-17 09:54:54 +02002291 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +01002292 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002293
Michal Vaskod989ba02020-08-24 10:59:24 +02002294 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002295 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
2296 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +01002297 par->flags &= ~LYD_DEFAULT;
2298 }
Michal Vasko52927e22020-03-16 17:26:14 +01002299 if (par->schema && (par->schema->nodetype == LYS_LIST) && (par->schema->flags & LYS_KEYLESS)) {
Michal Vasko9f96a052020-03-10 09:41:45 +01002300 /* rehash key-less list */
Michal Vasko9e685082021-01-29 14:49:09 +01002301 lyd_hash(&par->node);
Michal Vasko9f96a052020-03-10 09:41:45 +01002302 }
Michal Vasko0249f7c2020-03-05 16:36:40 +01002303 }
Michal Vasko751cb4d2020-07-14 12:25:28 +02002304}
Michal Vasko0249f7c2020-03-05 16:36:40 +01002305
Michal Vasko751cb4d2020-07-14 12:25:28 +02002306/**
2307 * @brief Learn whether a list instance has all the keys.
2308 *
2309 * @param[in] list List instance to check.
2310 * @return non-zero if all the keys were found,
2311 * @return 0 otherwise.
2312 */
2313static int
2314lyd_insert_has_keys(const struct lyd_node *list)
2315{
2316 const struct lyd_node *key;
2317 const struct lysc_node *skey = NULL;
2318
2319 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +02002320 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +02002321 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
2322 if (!key || (key->schema != skey)) {
2323 /* key missing */
2324 return 0;
2325 }
2326
2327 key = key->next;
2328 }
2329
2330 /* all keys found */
2331 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +01002332}
2333
2334void
Michal Vaskob104f112020-07-17 09:54:54 +02002335lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +01002336{
Michal Vaskob104f112020-07-17 09:54:54 +02002337 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +01002338
Michal Vaskob104f112020-07-17 09:54:54 +02002339 /* inserting list without its keys is not supported */
2340 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +01002341 assert(!parent || !parent->schema ||
2342 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +01002343
Michal Vaskob104f112020-07-17 09:54:54 +02002344 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +01002345 parent = lyd_parent(*first_sibling_p);
Michal Vasko9b368d32020-02-14 13:53:31 +01002346 }
Michal Vasko90932a92020-02-12 14:33:03 +01002347
Michal Vaskob104f112020-07-17 09:54:54 +02002348 /* get first sibling */
Michal Vasko9e685082021-01-29 14:49:09 +01002349 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +01002350
Michal Vaskob104f112020-07-17 09:54:54 +02002351 /* find the anchor, our next node, so we can insert before it */
2352 anchor = lyd_insert_get_next_anchor(first_sibling, node);
2353 if (anchor) {
2354 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +01002355 if (!parent && (*first_sibling_p == anchor)) {
2356 /* move first sibling */
2357 *first_sibling_p = node;
2358 }
Michal Vaskob104f112020-07-17 09:54:54 +02002359 } else if (first_sibling) {
2360 lyd_insert_after_node(first_sibling->prev, node);
2361 } else if (parent) {
2362 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +01002363 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02002364 *first_sibling_p = node;
2365 }
2366
2367 /* insert into parent HT */
2368 lyd_insert_hash(node);
2369
2370 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +02002371 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +02002372 lyd_hash(parent);
2373
2374 /* now we can insert even the list into its parent HT */
2375 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +01002376 }
Michal Vasko90932a92020-02-12 14:33:03 +01002377}
2378
Michal Vasko717a4c32020-12-07 09:40:10 +01002379/**
2380 * @brief Check schema place of a node to be inserted.
2381 *
2382 * @param[in] parent Schema node of the parent data node.
2383 * @param[in] sibling Schema node of a sibling data node.
2384 * @param[in] schema Schema node if the data node to be inserted.
2385 * @return LY_SUCCESS on success.
2386 * @return LY_EINVAL if the place is invalid.
2387 */
Michal Vaskof03ed032020-03-04 13:31:44 +01002388static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +01002389lyd_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 +01002390{
2391 const struct lysc_node *par2;
2392
Michal Vasko62ed12d2020-05-21 10:08:25 +02002393 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +01002394 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
2395 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01002396
Michal Vasko717a4c32020-12-07 09:40:10 +01002397 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002398 /* opaque nodes can be inserted wherever */
2399 return LY_SUCCESS;
2400 }
2401
Michal Vasko717a4c32020-12-07 09:40:10 +01002402 if (!parent) {
2403 parent = lysc_data_parent(sibling);
2404 }
2405
Michal Vaskof03ed032020-03-04 13:31:44 +01002406 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02002407 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01002408
2409 if (parent) {
2410 /* inner node */
2411 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02002412 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02002413 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002414 return LY_EINVAL;
2415 }
2416 } else {
2417 /* top-level node */
2418 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02002419 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01002420 return LY_EINVAL;
2421 }
2422 }
2423
2424 return LY_SUCCESS;
2425}
2426
2427API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002428lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01002429{
2430 struct lyd_node *iter;
2431
Michal Vasko0ab974d2021-02-24 13:18:26 +01002432 LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01002433
Michal Vasko717a4c32020-12-07 09:40:10 +01002434 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002435
Michal Vasko0ab974d2021-02-24 13:18:26 +01002436 if (node->schema && (node->schema->flags & LYS_KEY)) {
Michal Vaskof03ed032020-03-04 13:31:44 +01002437 LOGERR(parent->schema->module->ctx, LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
2438 return LY_EINVAL;
2439 }
2440
2441 if (node->parent || node->prev->next) {
2442 lyd_unlink_tree(node);
2443 }
2444
2445 while (node) {
2446 iter = node->next;
2447 lyd_unlink_tree(node);
2448 lyd_insert_node(parent, NULL, node);
2449 node = iter;
2450 }
2451 return LY_SUCCESS;
2452}
2453
2454API LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02002455lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01002456{
2457 struct lyd_node *iter;
2458
Michal Vaskob104f112020-07-17 09:54:54 +02002459 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01002460
Michal Vaskob104f112020-07-17 09:54:54 +02002461 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +01002462 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01002463 }
2464
Michal Vasko553d0b52020-12-04 16:27:52 +01002465 if (sibling == node) {
2466 /* we need to keep the connection to siblings so we can insert into them */
2467 sibling = sibling->prev;
2468 }
2469
Michal Vaskob1b5c262020-03-05 14:29:47 +01002470 if (node->parent || node->prev->next) {
2471 lyd_unlink_tree(node);
2472 }
2473
2474 while (node) {
Michal Vasko71e795e2020-12-04 16:27:37 +01002475 if (lysc_is_key(node->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002476 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +02002477 return LY_EINVAL;
2478 }
2479
Michal Vaskob1b5c262020-03-05 14:29:47 +01002480 iter = node->next;
2481 lyd_unlink_tree(node);
2482 lyd_insert_node(NULL, &sibling, node);
2483 node = iter;
2484 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01002485
Michal Vaskob104f112020-07-17 09:54:54 +02002486 if (first) {
2487 /* find the first sibling */
2488 *first = sibling;
2489 while ((*first)->prev->next) {
2490 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +01002491 }
2492 }
2493
2494 return LY_SUCCESS;
2495}
2496
Michal Vaskob1b5c262020-03-05 14:29:47 +01002497API LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01002498lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
2499{
Michal Vaskof03ed032020-03-04 13:31:44 +01002500 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2501
Michal Vasko717a4c32020-12-07 09:40:10 +01002502 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002503
Michal Vaskob104f112020-07-17 09:54:54 +02002504 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002505 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002506 return LY_EINVAL;
2507 }
2508
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002509 lyd_unlink_tree(node);
2510 lyd_insert_before_node(sibling, node);
2511 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002512
Michal Vaskof03ed032020-03-04 13:31:44 +01002513 return LY_SUCCESS;
2514}
2515
2516API LY_ERR
2517lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
2518{
Michal Vaskof03ed032020-03-04 13:31:44 +01002519 LY_CHECK_ARG_RET(NULL, sibling, node, LY_EINVAL);
2520
Michal Vasko717a4c32020-12-07 09:40:10 +01002521 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01002522
Michal Vaskob104f112020-07-17 09:54:54 +02002523 if (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002524 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01002525 return LY_EINVAL;
2526 }
2527
Michal Vasko4bc2ce32020-12-08 10:06:16 +01002528 lyd_unlink_tree(node);
2529 lyd_insert_after_node(sibling, node);
2530 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01002531
Michal Vaskof03ed032020-03-04 13:31:44 +01002532 return LY_SUCCESS;
2533}
2534
2535API void
2536lyd_unlink_tree(struct lyd_node *node)
2537{
2538 struct lyd_node *iter;
2539
2540 if (!node) {
2541 return;
2542 }
2543
Michal Vaskob104f112020-07-17 09:54:54 +02002544 /* update hashes while still linked into the tree */
2545 lyd_unlink_hash(node);
2546
Michal Vaskof03ed032020-03-04 13:31:44 +01002547 /* unlink from siblings */
2548 if (node->prev->next) {
2549 node->prev->next = node->next;
2550 }
2551 if (node->next) {
2552 node->next->prev = node->prev;
2553 } else {
2554 /* unlinking the last node */
2555 if (node->parent) {
2556 iter = node->parent->child;
2557 } else {
2558 iter = node->prev;
2559 while (iter->prev != node) {
2560 iter = iter->prev;
2561 }
2562 }
2563 /* update the "last" pointer from the first node */
2564 iter->prev = node->prev;
2565 }
2566
2567 /* unlink from parent */
2568 if (node->parent) {
2569 if (node->parent->child == node) {
2570 /* the node is the first child */
2571 node->parent->child = node->next;
2572 }
2573
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002574 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +02002575 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
2576 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +02002577 LY_LIST_FOR(node->parent->child, iter) {
2578 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
2579 break;
2580 }
2581 }
2582 if (!iter) {
2583 node->parent->flags |= LYD_DEFAULT;
2584 }
2585 }
2586
Michal Vaskof03ed032020-03-04 13:31:44 +01002587 /* check for keyless list and update its hash */
Michal Vasko9e685082021-01-29 14:49:09 +01002588 for (iter = lyd_parent(node); iter; iter = lyd_parent(iter)) {
Michal Vasko413c7f22020-05-05 12:34:06 +02002589 if (iter->schema && (iter->schema->flags & LYS_KEYLESS)) {
Michal Vasko47718292021-02-26 10:12:44 +01002590 lyd_unlink_hash(iter);
Michal Vaskof03ed032020-03-04 13:31:44 +01002591 lyd_hash(iter);
Michal Vasko47718292021-02-26 10:12:44 +01002592 lyd_insert_hash(iter);
Michal Vaskof03ed032020-03-04 13:31:44 +01002593 }
2594 }
2595
2596 node->parent = NULL;
2597 }
2598
2599 node->next = NULL;
2600 node->prev = node;
2601}
2602
Michal Vaskoa5da3292020-08-12 13:10:50 +02002603void
Michal Vasko871a0252020-11-11 18:35:24 +01002604lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +02002605{
2606 struct lyd_meta *last, *iter;
2607
2608 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02002609
2610 if (!meta) {
2611 return;
2612 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002613
2614 for (iter = meta; iter; iter = iter->next) {
2615 iter->parent = parent;
2616 }
2617
2618 /* insert as the last attribute */
2619 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002620 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02002621 last->next = meta;
2622 } else {
2623 parent->meta = meta;
2624 }
2625
2626 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +01002627 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02002628 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +01002629 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +02002630 }
Radek Krejci1798aae2020-07-14 13:26:06 +02002631}
2632
2633LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01002634lyd_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 +02002635 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 +01002636 void *prefix_data, uint32_t hints, ly_bool clear_dflt, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01002637{
Radek Krejci2efc45b2020-12-22 16:25:44 +01002638 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01002639 struct lysc_ext_instance *ant = NULL;
Michal Vasko9f96a052020-03-10 09:41:45 +01002640 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02002641 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +01002642
Michal Vasko9f96a052020-03-10 09:41:45 +01002643 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002644
Radek Krejciddace2c2021-01-08 11:30:56 +01002645 LOG_LOCSET(parent ? parent->schema : NULL, parent, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002646
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002647 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko69730152020-10-09 16:30:07 +02002648 if ((mod->compiled->exts[u].def->plugin == lyext_plugins_internal[LYEXT_PLUGIN_INTERNAL_ANNOTATION].plugin) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002649 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +01002650 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02002651 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +01002652 break;
2653 }
2654 }
2655 if (!ant) {
2656 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +01002657 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Radek Krejci422afb12021-03-04 16:38:16 +01002658 mod->name, (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002659 ret = LY_EINVAL;
2660 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +01002661 }
2662
Michal Vasko9f96a052020-03-10 09:41:45 +01002663 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002664 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +01002665 mt->parent = parent;
2666 mt->annotation = ant;
Radek Krejci1b2eef82021-02-17 11:17:27 +01002667 ret = lyd_value_store(mod->ctx, &mt->value, *(const struct lysc_type **)ant->substmts[ANNOTATION_SUBSTMT_TYPE].storage,
2668 value, value_len, dynamic, format, prefix_data, hints, parent ? parent->schema : NULL, incomplete);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002669 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
2670 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
2671 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +01002672
Michal Vasko6f4cbb62020-02-28 11:15:47 +01002673 /* insert as the last attribute */
2674 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01002675 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01002676 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002677 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01002678 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002679 }
2680
Michal Vasko9f96a052020-03-10 09:41:45 +01002681 if (meta) {
2682 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01002683 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01002684
2685cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01002686 LOG_LOCBACK((parent && parent->schema) ? 1 : 0, parent ? 1 : 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01002687 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01002688}
2689
Michal Vaskoa5da3292020-08-12 13:10:50 +02002690void
2691lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
2692{
2693 struct lyd_attr *last, *iter;
2694 struct lyd_node_opaq *opaq;
2695
2696 assert(parent && !parent->schema);
2697
2698 if (!attr) {
2699 return;
2700 }
2701
2702 opaq = (struct lyd_node_opaq *)parent;
2703 for (iter = attr; iter; iter = iter->next) {
2704 iter->parent = opaq;
2705 }
2706
2707 /* insert as the last attribute */
2708 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002709 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02002710 last->next = attr;
2711 } else {
2712 opaq->attr = attr;
2713 }
2714}
2715
Michal Vasko52927e22020-03-16 17:26:14 +01002716LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002717lyd_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 +01002718 const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
2719 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 +01002720{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002721 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02002722 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01002723
2724 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002725 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01002726
2727 if (!value_len) {
2728 value = "";
2729 }
2730
2731 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002732 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02002733
Michal Vaskoad92b672020-11-12 13:11:31 +01002734 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002735 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002736 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002737 }
2738 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01002739 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01002740 }
2741
Michal Vasko52927e22020-03-16 17:26:14 +01002742 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002743 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
2744 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002745 *dynamic = 0;
2746 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02002747 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01002748 }
Michal Vasko501af032020-11-11 20:27:44 +01002749 at->format = format;
2750 at->val_prefix_data = val_prefix_data;
2751 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01002752
2753 /* insert as the last attribute */
2754 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02002755 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01002756 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02002757 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01002758 last->next = at;
2759 }
2760
Radek Krejci011e4aa2020-09-04 15:22:31 +02002761finish:
2762 if (ret) {
2763 lyd_free_attr_single(ctx, at);
2764 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01002765 *attr = at;
2766 }
2767 return LY_SUCCESS;
2768}
2769
Radek Krejci084289f2019-07-09 17:35:30 +02002770API const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02002771lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02002772{
Michal Vasko004d3152020-06-11 19:59:22 +02002773 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02002774
Michal Vasko004d3152020-06-11 19:59:22 +02002775 if (ly_path_eval(path, tree, &target)) {
2776 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02002777 }
2778
Michal Vasko004d3152020-06-11 19:59:22 +02002779 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02002780}
2781
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002782API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002783lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002784{
2785 const struct lyd_node *iter1, *iter2;
2786 struct lyd_node_term *term1, *term2;
2787 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01002788 struct lyd_node_opaq *opaq1, *opaq2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002789 size_t len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02002790
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002791 if (!node1 || !node2) {
2792 if (node1 == node2) {
2793 return LY_SUCCESS;
2794 } else {
2795 return LY_ENOT;
2796 }
2797 }
2798
Michal Vaskob7be7a82020-08-20 09:09:04 +02002799 if ((LYD_CTX(node1) != LYD_CTX(node2)) || (node1->schema != node2->schema)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002800 return LY_ENOT;
2801 }
2802
2803 if (node1->hash != node2->hash) {
2804 return LY_ENOT;
2805 }
Michal Vasko52927e22020-03-16 17:26:14 +01002806 /* 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 +02002807
Michal Vasko52927e22020-03-16 17:26:14 +01002808 if (!node1->schema) {
2809 opaq1 = (struct lyd_node_opaq *)node1;
2810 opaq2 = (struct lyd_node_opaq *)node2;
Michal Vaskoad92b672020-11-12 13:11:31 +01002811 if ((opaq1->name.name != opaq2->name.name) || (opaq1->format != opaq2->format) ||
2812 (opaq1->name.module_ns != opaq2->name.module_ns)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002813 return LY_ENOT;
2814 }
Michal Vasko52927e22020-03-16 17:26:14 +01002815 switch (opaq1->format) {
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002816 case LY_PREF_XML:
2817 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 +01002818 return LY_ENOT;
2819 }
2820 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002821 case LY_PREF_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +02002822 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
2823 if (strcmp(opaq1->value, opaq2->value)) {
2824 return LY_ENOT;
2825 }
2826 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002827 default:
Michal Vasko52927e22020-03-16 17:26:14 +01002828 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02002829 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01002830 return LY_EINT;
2831 }
2832 if (options & LYD_COMPARE_FULL_RECURSION) {
2833 iter1 = opaq1->child;
2834 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002835 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01002836 }
2837 return LY_SUCCESS;
2838 } else {
2839 switch (node1->schema->nodetype) {
2840 case LYS_LEAF:
2841 case LYS_LEAFLIST:
2842 if (options & LYD_COMPARE_DEFAULTS) {
2843 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2844 return LY_ENOT;
2845 }
2846 }
2847
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002848 term1 = (struct lyd_node_term *)node1;
2849 term2 = (struct lyd_node_term *)node2;
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02002850 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
Michal Vasko52927e22020-03-16 17:26:14 +01002851 case LYS_CONTAINER:
2852 if (options & LYD_COMPARE_DEFAULTS) {
2853 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
2854 return LY_ENOT;
2855 }
2856 }
2857 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko9e685082021-01-29 14:49:09 +01002858 iter1 = lyd_child(node1);
2859 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002860 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002861 }
2862 return LY_SUCCESS;
Michal Vasko1bf09392020-03-27 12:38:10 +01002863 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002864 case LYS_ACTION:
2865 if (options & LYD_COMPARE_FULL_RECURSION) {
2866 /* TODO action/RPC
2867 goto all_children_compare;
2868 */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002869 }
2870 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002871 case LYS_NOTIF:
2872 if (options & LYD_COMPARE_FULL_RECURSION) {
2873 /* TODO Notification
2874 goto all_children_compare;
2875 */
2876 }
2877 return LY_SUCCESS;
2878 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01002879 iter1 = lyd_child(node1);
2880 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01002881
2882 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
2883 /* lists with keys, their equivalence is based on their keys */
Michal Vasko544e58a2021-01-28 14:33:41 +01002884 for (const struct lysc_node *key = lysc_node_child(node1->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02002885 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01002886 key = key->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002887 if (lyd_compare_single(iter1, iter2, options)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002888 return LY_ENOT;
2889 }
2890 iter1 = iter1->next;
2891 iter2 = iter2->next;
2892 }
2893 } else {
2894 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
2895
Radek Krejci0f969882020-08-21 16:56:47 +02002896all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01002897 if (!iter1 && !iter2) {
2898 /* no children, nothing to compare */
2899 return LY_SUCCESS;
2900 }
2901
Michal Vaskod989ba02020-08-24 10:59:24 +02002902 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002903 if (lyd_compare_single(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002904 return LY_ENOT;
2905 }
2906 }
2907 if (iter1 || iter2) {
2908 return LY_ENOT;
2909 }
2910 }
2911 return LY_SUCCESS;
2912 case LYS_ANYXML:
2913 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02002914 any1 = (struct lyd_node_any *)node1;
2915 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01002916
2917 if (any1->value_type != any2->value_type) {
2918 return LY_ENOT;
2919 }
2920 switch (any1->value_type) {
2921 case LYD_ANYDATA_DATATREE:
2922 iter1 = any1->value.tree;
2923 iter2 = any2->value.tree;
2924 goto all_children_compare;
2925 case LYD_ANYDATA_STRING:
2926 case LYD_ANYDATA_XML:
2927 case LYD_ANYDATA_JSON:
2928 len1 = strlen(any1->value.str);
2929 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02002930 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002931 return LY_ENOT;
2932 }
2933 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002934 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02002935 len1 = lyd_lyb_data_length(any1->value.mem);
2936 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko69730152020-10-09 16:30:07 +02002937 if ((len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01002938 return LY_ENOT;
2939 }
2940 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01002941 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002942 }
2943 }
2944
Michal Vaskob7be7a82020-08-20 09:09:04 +02002945 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02002946 return LY_EINT;
2947}
Radek Krejci22ebdba2019-07-25 13:59:43 +02002948
Michal Vasko21725742020-06-29 11:49:25 +02002949API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002950lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02002951{
Michal Vaskod989ba02020-08-24 10:59:24 +02002952 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002953 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
2954 }
2955
Michal Vasko11a81432020-07-28 16:31:29 +02002956 if (node1 == node2) {
2957 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002958 }
Michal Vasko11a81432020-07-28 16:31:29 +02002959 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02002960}
2961
2962API LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02002963lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
2964{
2965 if (!meta1 || !meta2) {
2966 if (meta1 == meta2) {
2967 return LY_SUCCESS;
2968 } else {
2969 return LY_ENOT;
2970 }
2971 }
2972
Michal Vaskoa8083062020-11-06 17:22:10 +01002973 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02002974 return LY_ENOT;
2975 }
2976
Michal Vasko21725742020-06-29 11:49:25 +02002977 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
2978}
2979
Radek Krejci22ebdba2019-07-25 13:59:43 +02002980/**
Michal Vasko52927e22020-03-16 17:26:14 +01002981 * @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 +02002982 *
2983 * 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 +02002984 *
2985 * @param[in] node Original node to duplicate
2986 * @param[in] parent Parent to insert into, NULL for top-level sibling.
2987 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2988 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2989 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it int @p parent / @p first sibling).
2990 * @return LY_ERR value
Radek Krejci22ebdba2019-07-25 13:59:43 +02002991 */
Michal Vasko52927e22020-03-16 17:26:14 +01002992static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002993lyd_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 +02002994 struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002995{
Michal Vasko52927e22020-03-16 17:26:14 +01002996 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002997 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002998 struct lyd_meta *meta;
2999 struct lyd_node_any *any;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003000
Michal Vasko52927e22020-03-16 17:26:14 +01003001 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003002
Michal Vasko52927e22020-03-16 17:26:14 +01003003 if (!node->schema) {
3004 dup = calloc(1, sizeof(struct lyd_node_opaq));
3005 } else {
3006 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01003007 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01003008 case LYS_ACTION:
3009 case LYS_NOTIF:
3010 case LYS_CONTAINER:
3011 case LYS_LIST:
3012 dup = calloc(1, sizeof(struct lyd_node_inner));
3013 break;
3014 case LYS_LEAF:
3015 case LYS_LEAFLIST:
3016 dup = calloc(1, sizeof(struct lyd_node_term));
3017 break;
3018 case LYS_ANYDATA:
3019 case LYS_ANYXML:
3020 dup = calloc(1, sizeof(struct lyd_node_any));
3021 break;
3022 default:
Michal Vaskob7be7a82020-08-20 09:09:04 +02003023 LOGINT(LYD_CTX(node));
Michal Vasko52927e22020-03-16 17:26:14 +01003024 ret = LY_EINT;
3025 goto error;
3026 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02003027 }
Michal Vaskob7be7a82020-08-20 09:09:04 +02003028 LY_CHECK_ERR_GOTO(!dup, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003029
Michal Vaskof6df0a02020-06-16 13:08:34 +02003030 if (options & LYD_DUP_WITH_FLAGS) {
3031 dup->flags = node->flags;
3032 } else {
3033 dup->flags = (node->flags & LYD_DEFAULT) | LYD_NEW;
3034 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02003035 dup->schema = node->schema;
Michal Vasko52927e22020-03-16 17:26:14 +01003036 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003037
Michal Vasko25a32822020-07-09 15:48:22 +02003038 /* duplicate metadata */
3039 if (!(options & LYD_DUP_NO_META)) {
3040 LY_LIST_FOR(node->meta, meta) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003041 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
Michal Vasko25a32822020-07-09 15:48:22 +02003042 }
3043 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02003044
3045 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01003046 if (!dup->schema) {
3047 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
3048 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
3049 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003050
3051 if (options & LYD_DUP_RECURSIVE) {
3052 /* duplicate all the children */
3053 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003054 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01003055 }
3056 }
Michal Vaskoad92b672020-11-12 13:11:31 +01003057 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.name, 0, &opaq->name.name), error);
Michal Vasko52927e22020-03-16 17:26:14 +01003058 opaq->format = orig->format;
Michal Vaskoad92b672020-11-12 13:11:31 +01003059 if (orig->name.prefix) {
3060 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->name.prefix, 0, &opaq->name.prefix), error);
Michal Vasko52927e22020-03-16 17:26:14 +01003061 }
Michal Vaskoad92b672020-11-12 13:11:31 +01003062 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 +01003063 if (orig->val_prefix_data) {
3064 ret = ly_dup_prefix_data(LYD_CTX(node), opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
3065 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01003066 }
Radek Krejci011e4aa2020-09-04 15:22:31 +02003067 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), orig->value, 0, &opaq->value), error);
Michal Vasko52927e22020-03-16 17:26:14 +01003068 opaq->ctx = orig->ctx;
3069 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
3070 struct lyd_node_term *term = (struct lyd_node_term *)dup;
3071 struct lyd_node_term *orig = (struct lyd_node_term *)node;
3072
3073 term->hash = orig->hash;
Michal Vaskob7be7a82020-08-20 09:09:04 +02003074 LY_CHECK_ERR_GOTO(orig->value.realtype->plugin->duplicate(LYD_CTX(node), &orig->value, &term->value),
Michal Vasko69730152020-10-09 16:30:07 +02003075 LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."); ret = LY_EINT, error);
Michal Vasko52927e22020-03-16 17:26:14 +01003076 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
3077 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
3078 struct lyd_node *child;
3079
3080 if (options & LYD_DUP_RECURSIVE) {
3081 /* duplicate all the children */
3082 LY_LIST_FOR(orig->child, child) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003083 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003084 }
Michal Vasko69730152020-10-09 16:30:07 +02003085 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02003086 /* always duplicate keys of a list */
Radek Krejci22ebdba2019-07-25 13:59:43 +02003087 child = orig->child;
Michal Vasko544e58a2021-01-28 14:33:41 +01003088 for (const struct lysc_node *key = lysc_node_child(dup->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02003089 key && (key->flags & LYS_KEY);
Radek Krejci0fe9b512019-07-26 17:51:05 +02003090 key = key->next) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02003091 if (!child) {
3092 /* possibly not keys are present in filtered tree */
3093 break;
Radek Krejci0fe9b512019-07-26 17:51:05 +02003094 } else if (child->schema != key) {
3095 /* possibly not all keys are present in filtered tree,
3096 * but there can be also some non-key nodes */
3097 continue;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003098 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02003099 LY_CHECK_GOTO(ret = lyd_dup_r(child, dup, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003100 child = child->next;
3101 }
3102 }
3103 lyd_hash(dup);
3104 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02003105 dup->hash = node->hash;
3106 any = (struct lyd_node_any *)node;
3107 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003108 }
3109
Michal Vasko52927e22020-03-16 17:26:14 +01003110 /* insert */
3111 lyd_insert_node(parent, first, dup);
Michal Vasko52927e22020-03-16 17:26:14 +01003112
3113 if (dup_p) {
3114 *dup_p = dup;
3115 }
3116 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003117
3118error:
Michal Vasko52927e22020-03-16 17:26:14 +01003119 lyd_free_tree(dup);
3120 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003121}
3122
Michal Vasko3a41dff2020-07-15 14:30:28 +02003123static LY_ERR
3124lyd_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 +02003125 struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02003126{
Michal Vasko3a41dff2020-07-15 14:30:28 +02003127 const struct lyd_node_inner *orig_parent, *iter;
Radek Krejci857189e2020-09-01 13:26:36 +02003128 ly_bool repeat = 1;
Michal Vasko3a41dff2020-07-15 14:30:28 +02003129
3130 *dup_parent = NULL;
3131 *local_parent = NULL;
3132
3133 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
3134 if (parent && (parent->schema == orig_parent->schema)) {
3135 /* stop creating parents, connect what we have into the provided parent */
3136 iter = parent;
3137 repeat = 0;
3138 } else {
3139 iter = NULL;
3140 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, NULL, (struct lyd_node **)&iter, 0,
Radek Krejci0f969882020-08-21 16:56:47 +02003141 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02003142 }
3143 if (!*local_parent) {
3144 *local_parent = (struct lyd_node_inner *)iter;
3145 }
3146 if (iter->child) {
3147 /* 1) list - add after keys
3148 * 2) provided parent with some children */
3149 iter->child->prev->next = *dup_parent;
3150 if (*dup_parent) {
3151 (*dup_parent)->prev = iter->child->prev;
3152 iter->child->prev = *dup_parent;
3153 }
3154 } else {
3155 ((struct lyd_node_inner *)iter)->child = *dup_parent;
3156 }
3157 if (*dup_parent) {
3158 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
3159 }
3160 *dup_parent = (struct lyd_node *)iter;
3161 }
3162
3163 if (repeat && parent) {
3164 /* given parent and created parents chain actually do not interconnect */
Michal Vaskob7be7a82020-08-20 09:09:04 +02003165 LOGERR(LYD_CTX(node), LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02003166 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02003167 return LY_EINVAL;
3168 }
3169
3170 return LY_SUCCESS;
3171}
3172
3173static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003174lyd_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 +02003175{
3176 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003177 const struct lyd_node *orig; /* original node to be duplicated */
3178 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02003179 struct lyd_node *top = NULL; /* the most higher created node */
3180 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02003181
Michal Vasko3a41dff2020-07-15 14:30:28 +02003182 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003183
3184 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003185 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, parent, &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003186 } else {
3187 local_parent = parent;
3188 }
3189
Radek Krejci22ebdba2019-07-25 13:59:43 +02003190 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01003191 if (lysc_is_key(orig->schema)) {
3192 if (local_parent) {
3193 /* the key must already exist in the parent */
3194 rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
3195 LY_CHECK_ERR_GOTO(rc, LOGINT(LYD_CTX(node)), error);
3196 } else {
3197 assert(!(options & LYD_DUP_WITH_PARENTS));
3198 /* duplicating a single key, okay, I suppose... */
3199 rc = lyd_dup_r(orig, NULL, &first, options, first ? NULL : &first);
3200 LY_CHECK_GOTO(rc, error);
3201 }
3202 } else {
3203 /* if there is no local parent, it will be inserted into first */
Michal Vasko9e685082021-01-29 14:49:09 +01003204 rc = lyd_dup_r(orig, &local_parent->node, &first, options, first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01003205 LY_CHECK_GOTO(rc, error);
3206 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02003207 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02003208 break;
3209 }
3210 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02003211
3212 /* rehash if needed */
Michal Vaskod989ba02020-08-24 10:59:24 +02003213 for ( ; local_parent; local_parent = local_parent->parent) {
Michal Vasko69730152020-10-09 16:30:07 +02003214 if ((local_parent->schema->nodetype == LYS_LIST) && (local_parent->schema->flags & LYS_KEYLESS)) {
Michal Vasko9e685082021-01-29 14:49:09 +01003215 lyd_hash(&local_parent->node);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003216 }
3217 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02003218
3219 if (dup) {
3220 *dup = first;
3221 }
3222 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003223
3224error:
3225 if (top) {
3226 lyd_free_tree(top);
3227 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01003228 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02003229 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02003230 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02003231}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003232
Michal Vasko3a41dff2020-07-15 14:30:28 +02003233API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003234lyd_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 +02003235{
3236 return lyd_dup(node, parent, options, 1, dup);
3237}
3238
3239API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003240lyd_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 +02003241{
3242 return lyd_dup(node, parent, options, 0, dup);
3243}
3244
3245API LY_ERR
3246lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02003247{
Radek Krejci011e4aa2020-09-04 15:22:31 +02003248 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02003249 struct lyd_meta *mt, *last;
3250
Michal Vasko3a41dff2020-07-15 14:30:28 +02003251 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02003252
3253 /* create a copy */
3254 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003255 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02003256 mt->annotation = meta->annotation;
Michal Vaskob7be7a82020-08-20 09:09:04 +02003257 ret = meta->value.realtype->plugin->duplicate(LYD_CTX(node), &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02003258 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
3259 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02003260
3261 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02003262 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02003263 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02003264 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02003265 last->next = mt;
3266 } else {
3267 node->meta = mt;
3268 }
3269
Radek Krejci011e4aa2020-09-04 15:22:31 +02003270finish:
3271 if (ret) {
3272 lyd_free_meta_single(mt);
3273 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003274 *dup = mt;
3275 }
3276 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02003277}
3278
Michal Vasko4490d312020-06-16 13:08:55 +02003279/**
3280 * @brief Merge a source sibling into target siblings.
3281 *
3282 * @param[in,out] first_trg First target sibling, is updated if top-level.
3283 * @param[in] parent_trg Target parent.
3284 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
3285 * @param[in] options Merge options.
3286 * @return LY_ERR value.
3287 */
3288static LY_ERR
3289lyd_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 +02003290 uint16_t options)
Michal Vasko4490d312020-06-16 13:08:55 +02003291{
3292 LY_ERR ret;
3293 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02003294 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vasko4490d312020-06-16 13:08:55 +02003295 struct lysc_type *type;
Michal Vasko4490d312020-06-16 13:08:55 +02003296
3297 sibling_src = *sibling_src_p;
3298 if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
3299 /* try to find the exact instance */
3300 ret = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
3301 } else {
3302 /* try to simply find the node, there cannot be more instances */
3303 ret = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
3304 }
3305
3306 if (!ret) {
3307 /* node found, make sure even value matches for all node types */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003308 if ((match_trg->schema->nodetype == LYS_LEAF) && lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02003309 /* since they are different, they cannot both be default */
3310 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
3311
Michal Vasko3a41dff2020-07-15 14:30:28 +02003312 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
3313 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02003314 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02003315 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
3316 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02003317 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02003318
3319 /* copy flags and add LYD_NEW */
3320 match_trg->flags = sibling_src->flags | LYD_NEW;
3321 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02003322 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02003323 /* update value */
3324 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02003325 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02003326
3327 /* copy flags and add LYD_NEW */
3328 match_trg->flags = sibling_src->flags | LYD_NEW;
Michal Vasko4490d312020-06-16 13:08:55 +02003329 } else {
3330 /* check descendants, recursively */
Radek Krejcia1c1e542020-09-29 16:06:52 +02003331 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
Michal Vaskoe0665742021-02-11 11:08:44 +01003332 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 +02003333 }
3334 }
3335 } else {
3336 /* node not found, merge it */
3337 if (options & LYD_MERGE_DESTRUCT) {
3338 dup_src = (struct lyd_node *)sibling_src;
3339 lyd_unlink_tree(dup_src);
3340 /* spend it */
3341 *sibling_src_p = NULL;
3342 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02003343 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 +02003344 }
3345
3346 /* set LYD_NEW for all the new nodes, required for validation */
Michal Vasko56daf732020-08-10 10:57:18 +02003347 LYD_TREE_DFS_BEGIN(dup_src, elem) {
Michal Vasko4490d312020-06-16 13:08:55 +02003348 elem->flags |= LYD_NEW;
Michal Vasko56daf732020-08-10 10:57:18 +02003349 LYD_TREE_DFS_END(dup_src, elem);
Michal Vasko4490d312020-06-16 13:08:55 +02003350 }
3351
3352 lyd_insert_node(parent_trg, first_trg, dup_src);
3353 }
3354
3355 return LY_SUCCESS;
3356}
3357
Michal Vasko3a41dff2020-07-15 14:30:28 +02003358static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003359lyd_merge(struct lyd_node **target, const struct lyd_node *source, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02003360{
3361 const struct lyd_node *sibling_src, *tmp;
Radek Krejci857189e2020-09-01 13:26:36 +02003362 ly_bool first;
Michal Vasko4490d312020-06-16 13:08:55 +02003363
3364 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
3365
3366 if (!source) {
3367 /* nothing to merge */
3368 return LY_SUCCESS;
3369 }
3370
Michal Vasko831422b2020-11-24 11:20:51 +01003371 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003372 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02003373 return LY_EINVAL;
3374 }
3375
3376 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Radek Krejci857189e2020-09-01 13:26:36 +02003377 first = (sibling_src == source) ? 1 : 0;
Michal Vasko4490d312020-06-16 13:08:55 +02003378 LY_CHECK_RET(lyd_merge_sibling_r(target, NULL, &sibling_src, options));
3379 if (first && !sibling_src) {
3380 /* source was spent (unlinked), move to the next node */
3381 source = tmp;
3382 }
3383
Michal Vasko3a41dff2020-07-15 14:30:28 +02003384 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02003385 break;
3386 }
3387 }
3388
3389 if (options & LYD_MERGE_DESTRUCT) {
3390 /* free any leftover source data that were not merged */
3391 lyd_free_siblings((struct lyd_node *)source);
3392 }
3393
3394 return LY_SUCCESS;
3395}
3396
Michal Vasko3a41dff2020-07-15 14:30:28 +02003397API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003398lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003399{
3400 return lyd_merge(target, source, options, 1);
3401}
3402
3403API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02003404lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02003405{
3406 return lyd_merge(target, source, options, 0);
3407}
3408
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003409static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003410lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003411{
Michal Vasko14654712020-02-06 08:35:21 +01003412 /* ending \0 */
3413 ++reqlen;
3414
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003415 if (reqlen > *buflen) {
3416 if (is_static) {
3417 return LY_EINCOMPLETE;
3418 }
3419
3420 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
3421 if (!*buffer) {
3422 return LY_EMEM;
3423 }
3424
3425 *buflen = reqlen;
3426 }
3427
3428 return LY_SUCCESS;
3429}
3430
Michal Vaskod59035b2020-07-08 12:00:06 +02003431LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003432lyd_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 +02003433{
3434 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003435 size_t len;
3436 const char *val;
3437 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003438
Radek Krejcia1c1e542020-09-29 16:06:52 +02003439 for (key = lyd_child(node); key && (key->schema->flags & LYS_KEY); key = key->next) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02003440 val = LYD_CANON_VALUE(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003441 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003442 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003443
3444 quot = '\'';
3445 if (strchr(val, '\'')) {
3446 quot = '"';
3447 }
3448 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003449 }
3450
3451 return LY_SUCCESS;
3452}
3453
3454/**
3455 * @brief Append leaf-list value predicate to path.
3456 *
3457 * @param[in] node Node to print.
3458 * @param[in,out] buffer Buffer to print to.
3459 * @param[in,out] buflen Current buffer length.
3460 * @param[in,out] bufused Current number of characters used in @p buffer.
3461 * @param[in] is_static Whether buffer is static or can be reallocated.
3462 * @return LY_ERR
3463 */
3464static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003465lyd_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 +02003466{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003467 size_t len;
3468 const char *val;
3469 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003470
Michal Vaskob7be7a82020-08-20 09:09:04 +02003471 val = LYD_CANON_VALUE(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01003472 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003473 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003474
3475 quot = '\'';
3476 if (strchr(val, '\'')) {
3477 quot = '"';
3478 }
3479 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
3480
Michal Vaskoba99a3e2020-08-18 15:50:05 +02003481 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003482}
3483
3484/**
3485 * @brief Append node position (relative to its other instances) predicate to path.
3486 *
3487 * @param[in] node Node to print.
3488 * @param[in,out] buffer Buffer to print to.
3489 * @param[in,out] buflen Current buffer length.
3490 * @param[in,out] bufused Current number of characters used in @p buffer.
3491 * @param[in] is_static Whether buffer is static or can be reallocated.
3492 * @return LY_ERR
3493 */
3494static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02003495lyd_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 +02003496{
3497 const struct lyd_node *first, *iter;
3498 size_t len;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003499 uint64_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003500 char *val = NULL;
3501 LY_ERR rc;
3502
3503 if (node->parent) {
3504 first = node->parent->child;
3505 } else {
Michal Vaskoe070bfe2020-08-31 12:27:25 +02003506 for (first = node; first->prev->next; first = first->prev) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003507 }
3508 pos = 1;
3509 for (iter = first; iter != node; iter = iter->next) {
3510 if (iter->schema == node->schema) {
3511 ++pos;
3512 }
3513 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02003514 if (asprintf(&val, "%" PRIu64, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003515 return LY_EMEM;
3516 }
3517
3518 len = 1 + strlen(val) + 1;
3519 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
3520 if (rc != LY_SUCCESS) {
3521 goto cleanup;
3522 }
3523
3524 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
3525
3526cleanup:
3527 free(val);
3528 return rc;
3529}
3530
3531API char *
3532lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
3533{
Radek Krejci857189e2020-09-01 13:26:36 +02003534 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02003535 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01003536 size_t bufused = 0, len;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003537 const struct lyd_node *iter;
3538 const struct lys_module *mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02003539 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003540
3541 LY_CHECK_ARG_RET(NULL, node, NULL);
3542 if (buffer) {
3543 LY_CHECK_ARG_RET(node->schema->module->ctx, buflen > 1, NULL);
3544 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01003545 } else {
3546 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003547 }
3548
3549 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01003550 case LYD_PATH_STD:
3551 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01003552 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01003553 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003554 ++depth;
3555 }
3556
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003557 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01003558 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003559 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01003560 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003561iter_print:
3562 /* print prefix and name */
3563 mod = NULL;
Michal Vasko69730152020-10-09 16:30:07 +02003564 if (iter->schema && (!iter->parent || (iter->schema->module != iter->parent->schema->module))) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003565 mod = iter->schema->module;
3566 }
3567
3568 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01003569 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
3570 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003571 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
3572 if (rc != LY_SUCCESS) {
3573 break;
3574 }
3575
3576 /* print next node */
Radek Krejci1798aae2020-07-14 13:26:06 +02003577 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "",
Michal Vaskoad92b672020-11-12 13:11:31 +01003578 iter->schema ? iter->schema->name : ((struct lyd_node_opaq *)iter)->name.name);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003579
Michal Vasko790b2bc2020-08-03 13:35:06 +02003580 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01003581 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02003582 switch (iter->schema->nodetype) {
3583 case LYS_LIST:
3584 if (iter->schema->flags & LYS_KEYLESS) {
3585 /* print its position */
3586 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3587 } else {
3588 /* print all list keys in predicates */
3589 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
3590 }
3591 break;
3592 case LYS_LEAFLIST:
3593 if (iter->schema->flags & LYS_CONFIG_W) {
3594 /* print leaf-list value */
3595 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
3596 } else {
3597 /* print its position */
3598 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
3599 }
3600 break;
3601 default:
3602 /* nothing to print more */
3603 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003604 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003605 }
3606 if (rc != LY_SUCCESS) {
3607 break;
3608 }
3609
Michal Vasko14654712020-02-06 08:35:21 +01003610 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02003611 }
3612 break;
3613 }
3614
3615 return buffer;
3616}
Michal Vaskoe444f752020-02-10 12:20:06 +01003617
Michal Vasko25a32822020-07-09 15:48:22 +02003618API struct lyd_meta *
3619lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
3620{
3621 struct lyd_meta *ret = NULL;
3622 const struct ly_ctx *ctx;
3623 const char *prefix, *tmp;
3624 char *str;
3625 size_t pref_len, name_len;
3626
3627 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
3628
3629 if (!first) {
3630 return NULL;
3631 }
3632
3633 ctx = first->annotation->module->ctx;
3634
3635 /* parse the name */
3636 tmp = name;
3637 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3638 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3639 return NULL;
3640 }
3641
3642 /* find the module */
3643 if (prefix) {
3644 str = strndup(prefix, pref_len);
3645 module = ly_ctx_get_module_latest(ctx, str);
3646 free(str);
Radek Krejci422afb12021-03-04 16:38:16 +01003647 LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", (int)pref_len, prefix), NULL);
Michal Vasko25a32822020-07-09 15:48:22 +02003648 }
3649
3650 /* find the metadata */
3651 LY_LIST_FOR(first, first) {
3652 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3653 ret = (struct lyd_meta *)first;
3654 break;
3655 }
3656 }
3657
3658 return ret;
3659}
3660
Michal Vasko9b368d32020-02-14 13:53:31 +01003661API LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003662lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3663{
3664 struct lyd_node **match_p;
3665 struct lyd_node_inner *parent;
3666
Michal Vaskof03ed032020-03-04 13:31:44 +01003667 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003668
Michal Vasko6da1e952020-12-09 18:14:38 +01003669 if (!siblings || (siblings->schema && target->schema &&
3670 (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003671 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003672 if (match) {
3673 *match = NULL;
3674 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003675 return LY_ENOTFOUND;
3676 }
3677
3678 /* find first sibling */
3679 if (siblings->parent) {
3680 siblings = siblings->parent->child;
3681 } else {
3682 while (siblings->prev->next) {
3683 siblings = siblings->prev;
3684 }
3685 }
3686
Michal Vasko9e685082021-01-29 14:49:09 +01003687 parent = siblings->parent;
Michal Vasko6da1e952020-12-09 18:14:38 +01003688 if (parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003689 assert(target->hash);
3690
3691 /* find by hash */
3692 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003693 /* check even value when needed */
Michal Vasko8f359bf2020-07-28 10:41:15 +02003694 if (!(target->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !lyd_compare_single(target, *match_p, 0)) {
Michal Vaskoda859032020-07-14 12:20:14 +02003695 siblings = *match_p;
3696 } else {
3697 siblings = NULL;
3698 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003699 } else {
3700 /* not found */
3701 siblings = NULL;
3702 }
3703 } else {
3704 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02003705 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02003706 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003707 break;
3708 }
3709 }
3710 }
3711
3712 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003713 if (match) {
3714 *match = NULL;
3715 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003716 return LY_ENOTFOUND;
3717 }
3718
Michal Vasko9b368d32020-02-14 13:53:31 +01003719 if (match) {
3720 *match = (struct lyd_node *)siblings;
3721 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003722 return LY_SUCCESS;
3723}
3724
Radek Krejci857189e2020-09-01 13:26:36 +02003725/**
3726 * @brief Comparison callback to match schema node with a schema of a data node.
3727 *
3728 * @param[in] val1_p Pointer to the schema node
3729 * @param[in] val2_p Pointer to the data node
Michal Vasko62524a92021-02-26 10:08:50 +01003730 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +02003731 */
3732static ly_bool
3733lyd_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 +01003734{
3735 struct lysc_node *val1;
3736 struct lyd_node *val2;
3737
3738 val1 = *((struct lysc_node **)val1_p);
3739 val2 = *((struct lyd_node **)val2_p);
3740
Michal Vasko90932a92020-02-12 14:33:03 +01003741 if (val1 == val2->schema) {
3742 /* schema match is enough */
3743 return 1;
3744 } else {
3745 return 0;
3746 }
3747}
3748
Michal Vasko92239c72020-11-18 18:17:25 +01003749/**
3750 * @brief Search in the given siblings (NOT recursively) for the first schema node data instance.
3751 * Uses hashes - should be used whenever possible for best performance.
3752 *
3753 * @param[in] siblings Siblings to search in including preceding and succeeding nodes.
3754 * @param[in] schema Target data node schema to find.
3755 * @param[out] match Can be NULL, otherwise the found data node.
3756 * @return LY_SUCCESS on success, @p match set.
3757 * @return LY_ENOTFOUND if not found, @p match set to NULL.
3758 * @return LY_ERR value if another error occurred.
3759 */
Michal Vasko90932a92020-02-12 14:33:03 +01003760static LY_ERR
3761lyd_find_sibling_schema(const struct lyd_node *siblings, const struct lysc_node *schema, struct lyd_node **match)
3762{
3763 struct lyd_node **match_p;
3764 struct lyd_node_inner *parent;
3765 uint32_t hash;
Michal Vasko62524a92021-02-26 10:08:50 +01003766 lyht_value_equal_cb ht_cb;
Michal Vasko90932a92020-02-12 14:33:03 +01003767
Michal Vaskob104f112020-07-17 09:54:54 +02003768 assert(siblings && schema);
Michal Vasko90932a92020-02-12 14:33:03 +01003769
Michal Vasko9e685082021-01-29 14:49:09 +01003770 parent = siblings->parent;
Michal Vasko08fd6132020-11-18 18:17:45 +01003771 if (parent && parent->schema && parent->children_ht) {
Michal Vasko90932a92020-02-12 14:33:03 +01003772 /* calculate our hash */
3773 hash = dict_hash_multi(0, schema->module->name, strlen(schema->module->name));
3774 hash = dict_hash_multi(hash, schema->name, strlen(schema->name));
3775 hash = dict_hash_multi(hash, NULL, 0);
3776
3777 /* use special hash table function */
3778 ht_cb = lyht_set_cb(parent->children_ht, lyd_hash_table_schema_val_equal);
3779
3780 /* find by hash */
3781 if (!lyht_find(parent->children_ht, &schema, hash, (void **)&match_p)) {
3782 siblings = *match_p;
3783 } else {
3784 /* not found */
3785 siblings = NULL;
3786 }
3787
3788 /* set the original hash table compare function back */
3789 lyht_set_cb(parent->children_ht, ht_cb);
3790 } else {
Michal Vaskob104f112020-07-17 09:54:54 +02003791 /* find first sibling */
3792 if (siblings->parent) {
3793 siblings = siblings->parent->child;
3794 } else {
3795 while (siblings->prev->next) {
3796 siblings = siblings->prev;
3797 }
3798 }
3799
3800 /* search manually without hashes */
Michal Vaskod989ba02020-08-24 10:59:24 +02003801 for ( ; siblings; siblings = siblings->next) {
Michal Vasko90932a92020-02-12 14:33:03 +01003802 if (siblings->schema == schema) {
3803 /* schema match is enough */
3804 break;
3805 }
3806 }
3807 }
3808
3809 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003810 if (match) {
3811 *match = NULL;
3812 }
Michal Vasko90932a92020-02-12 14:33:03 +01003813 return LY_ENOTFOUND;
3814 }
3815
Michal Vasko9b368d32020-02-14 13:53:31 +01003816 if (match) {
3817 *match = (struct lyd_node *)siblings;
3818 }
Michal Vasko90932a92020-02-12 14:33:03 +01003819 return LY_SUCCESS;
3820}
3821
Michal Vaskoe444f752020-02-10 12:20:06 +01003822API LY_ERR
3823lyd_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 +02003824 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003825{
3826 LY_ERR rc;
3827 struct lyd_node *target = NULL;
3828
Michal Vasko4c583e82020-07-17 12:16:14 +02003829 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vaskoe444f752020-02-10 12:20:06 +01003830
Michal Vasko08fd6132020-11-18 18:17:45 +01003831 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema)))) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02003832 /* no data or schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003833 if (match) {
3834 *match = NULL;
3835 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003836 return LY_ENOTFOUND;
3837 }
3838
Michal Vaskof03ed032020-03-04 13:31:44 +01003839 if (key_or_value && !val_len) {
3840 val_len = strlen(key_or_value);
3841 }
3842
Michal Vaskob104f112020-07-17 09:54:54 +02003843 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3844 /* create a data node and find the instance */
3845 if (schema->nodetype == LYS_LEAFLIST) {
3846 /* target used attributes: schema, hash, value */
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003847 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_PREF_JSON, NULL, LYD_HINT_DATA, NULL, &target);
3848 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003849 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003850 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02003851 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003852 }
3853
3854 /* find it */
3855 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003856 } else {
3857 /* find the first schema node instance */
3858 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003859 }
3860
Michal Vaskoe444f752020-02-10 12:20:06 +01003861 lyd_free_tree(target);
3862 return rc;
3863}
Michal Vaskoccc02342020-05-21 10:09:21 +02003864
3865API LY_ERR
Michal Vasko1d4af6c2021-02-22 13:31:26 +01003866lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
3867{
3868 LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
3869
3870 for ( ; first; first = first->next) {
3871 if (!first->schema && !strcmp(LYD_NAME(first), name)) {
3872 break;
3873 }
3874 }
3875
3876 if (match) {
3877 *match = (struct lyd_node *)first;
3878 }
3879 return first ? LY_SUCCESS : LY_ENOTFOUND;
3880}
3881
3882API LY_ERR
Michal Vaskoccc02342020-05-21 10:09:21 +02003883lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
3884{
3885 LY_ERR ret = LY_SUCCESS;
3886 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +02003887 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02003888 uint32_t i;
3889
3890 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
3891
3892 memset(&xp_set, 0, sizeof xp_set);
3893
3894 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +02003895 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
3896 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003897
3898 /* evaluate expression */
Michal Vasko400e9672021-01-11 13:39:17 +01003899 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 +02003900 LY_CHECK_GOTO(ret, cleanup);
3901
3902 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02003903 ret = ly_set_new(set);
3904 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003905
3906 /* transform into ly_set */
3907 if (xp_set.type == LYXP_SET_NODE_SET) {
3908 /* allocate memory for all the elements once (even though not all items must be elements but most likely will be) */
3909 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003910 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(ctx_node)); ret = LY_EMEM, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003911 (*set)->size = xp_set.used;
3912
3913 for (i = 0; i < xp_set.used; ++i) {
3914 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +02003915 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +02003916 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02003917 }
3918 }
3919 }
3920
3921cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02003922 lyxp_set_free_content(&xp_set);
Michal Vaskob7be7a82020-08-20 09:09:04 +02003923 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
Radek Krejci8f45abc2020-11-26 12:15:13 +01003924 if (ret) {
3925 ly_set_free(*set, NULL);
3926 *set = NULL;
3927 }
Michal Vaskoccc02342020-05-21 10:09:21 +02003928 return ret;
3929}
Radek Krejcica989142020-11-05 11:32:22 +01003930
Michal Vasko3e1f6552021-01-14 09:27:55 +01003931API LY_ERR
3932lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
3933{
3934 LY_ERR ret = LY_SUCCESS;
3935 struct lyxp_expr *expr = NULL;
3936 struct ly_path *lypath = NULL;
3937
3938 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
3939
3940 /* parse the path */
3941 ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), LY_PATH_BEGIN_EITHER, LY_PATH_LREF_FALSE,
3942 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
3943 LY_CHECK_GOTO(ret, cleanup);
3944
3945 /* compile the path */
Radek Krejcid5d37432021-03-12 13:46:40 +01003946 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, NULL, expr, LY_PATH_LREF_FALSE,
Michal Vasko3e1f6552021-01-14 09:27:55 +01003947 output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_SINGLE, LY_PREF_JSON,
3948 (void *)LYD_CTX(ctx_node), NULL, &lypath);
3949 LY_CHECK_GOTO(ret, cleanup);
3950
3951 /* evaluate the path */
3952 ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
3953
3954cleanup:
3955 lyxp_expr_free(LYD_CTX(ctx_node), expr);
3956 ly_path_free(LYD_CTX(ctx_node), lypath);
3957 return ret;
3958}
3959
Radek Krejcica989142020-11-05 11:32:22 +01003960API uint32_t
3961lyd_list_pos(const struct lyd_node *instance)
3962{
3963 const struct lyd_node *iter = NULL;
3964 uint32_t pos = 0;
3965
3966 if (!instance || !(instance->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
3967 return 0;
3968 }
3969
3970 /* data instances are ordered, so we can stop when we found instance of other schema node */
3971 for (iter = instance; iter->schema == instance->schema; iter = iter->prev) {
Radek Krejcibb27df32020-11-13 15:39:16 +01003972 if (pos && (iter->next == NULL)) {
Radek Krejcica989142020-11-05 11:32:22 +01003973 /* overrun to the end of the siblings list */
3974 break;
3975 }
3976 ++pos;
3977 }
3978
3979 return pos;
3980}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003981
3982API struct lyd_node *
3983lyd_first_sibling(const struct lyd_node *node)
3984{
3985 struct lyd_node *start;
3986
3987 if (!node) {
3988 return NULL;
3989 }
3990
3991 /* get the first sibling */
3992 if (node->parent) {
3993 start = node->parent->child;
3994 } else {
Radek Krejcibb27df32020-11-13 15:39:16 +01003995 for (start = (struct lyd_node *)node; start->prev->next; start = start->prev) {}
Radek Krejci4233f9b2020-11-05 12:38:35 +01003996 }
3997
3998 return start;
3999}