blob: d968205fbe9d25b64fa7446ce4e03e9d1fd7a630 [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 Vaskoe3ed7dc2022-11-30 11:39:44 +01004 * @author Michal Vasko <mvasko@cesnet.cz>
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02005 * @brief Data tree functions
Radek Krejcie7b95092019-05-15 11:03:07 +02006 *
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +01007 * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
Radek Krejcie7b95092019-05-15 11:03:07 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#define _GNU_SOURCE
17
18#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020019
Radek Krejci084289f2019-07-09 17:35:30 +020020#include <assert.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020021#include <ctype.h>
Radek Krejci47fab892020-11-05 17:02:41 +010022#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdarg.h>
24#include <stdint.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include <stdio.h>
26#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include <string.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020028
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"
Michal Vasko8f702ee2024-02-20 15:44:24 +010037#include "ly_common.h"
Radek Krejci7931b192020-06-25 17:05:03 +020038#include "parser_data.h"
39#include "parser_internal.h"
Michal Vasko004d3152020-06-11 19:59:22 +020040#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020041#include "plugins.h"
Radek Krejcif1ca0ac2021-04-12 16:00:06 +020042#include "plugins_exts/metadata.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010043#include "plugins_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020044#include "plugins_types.h"
45#include "set.h"
46#include "tree.h"
47#include "tree_data_internal.h"
aPiecek6cf1d162023-11-08 16:07:00 +010048#include "tree_data_sorted.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010049#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020050#include "tree_schema.h"
51#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020052#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020053#include "xml.h"
54#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020055
Michal Vaskof277d362023-04-24 09:08:31 +020056static LY_ERR lyd_compare_siblings_(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options,
57 ly_bool parental_schemas_checked);
58
Radek Krejci7931b192020-06-25 17:05:03 +020059static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +020060lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +020061{
Michal Vasko69730152020-10-09 16:30:07 +020062 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020063 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +020064 const char *path = in->method.fpath.filepath;
65 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +020066
67 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +020068 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +020069
Radek Krejcif13b87b2020-12-01 22:02:17 +010070 if ((len >= LY_XML_SUFFIX_LEN + 1) &&
71 !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020072 format = LYD_XML;
Radek Krejcif13b87b2020-12-01 22:02:17 +010073 } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
74 !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020075 format = LYD_JSON;
Radek Krejcif13b87b2020-12-01 22:02:17 +010076 } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
77 !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020078 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +020079 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +020080 }
81
Radek Krejci7931b192020-06-25 17:05:03 +020082 return format;
83}
Radek Krejcie7b95092019-05-15 11:03:07 +020084
Michal Vaskoe0665742021-02-11 11:08:44 +010085/**
86 * @brief Parse YANG data into a data tree.
87 *
88 * @param[in] ctx libyang context.
Radek Krejcif16e2542021-02-17 15:39:23 +010089 * @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 +010090 * @param[in] parent Parent to connect the parsed nodes to, if any.
Michal Vaskob36c56f2024-01-31 12:50:07 +010091 * @param[in,out] first_p Pointer to the first parsed node.
Michal Vaskoe0665742021-02-11 11:08:44 +010092 * @param[in] in Input handle to read the input from.
93 * @param[in] format Expected format of the data in @p in.
94 * @param[in] parse_opts Options for parser.
95 * @param[in] val_opts Options for validation.
96 * @param[out] op Optional pointer to the parsed operation, if any.
97 * @return LY_ERR value.
98 */
99static LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100100lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, struct lyd_node **first_p,
101 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 +0200102{
stewegd8e2fc92023-05-31 09:52:56 +0200103 LY_ERR r = LY_SUCCESS, rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200104 struct lyd_ctx *lydctx = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100105 struct ly_set parsed = {0};
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100106 uint32_t i, int_opts = 0;
Michal Vasko7a266772024-01-23 11:02:38 +0100107 const struct ly_err_item *eitem;
Michal Vaskoddd76592022-01-17 13:34:48 +0100108 ly_bool subtree_sibling = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200109
Michal Vaskoe0665742021-02-11 11:08:44 +0100110 assert(ctx && (parent || first_p));
Radek Krejci7931b192020-06-25 17:05:03 +0200111
112 format = lyd_parse_get_format(in, format);
Michal Vaskoe0665742021-02-11 11:08:44 +0100113 if (first_p) {
114 *first_p = NULL;
115 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200116
Michal Vasko63f3d842020-07-08 10:10:14 +0200117 /* remember input position */
118 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200119
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100120 /* set internal options */
121 if (!(parse_opts & LYD_PARSE_SUBTREE)) {
122 int_opts = LYD_INTOPT_WITH_SIBLINGS;
123 }
124
Michal Vaskoe0665742021-02-11 11:08:44 +0100125 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200126 switch (format) {
127 case LYD_XML:
Michal Vaskod027f382023-02-10 09:13:25 +0100128 r = lyd_parse_xml(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100129 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200130 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200131 case LYD_JSON:
Michal Vaskod027f382023-02-10 09:13:25 +0100132 r = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100133 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200134 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200135 case LYD_LYB:
Michal Vaskod027f382023-02-10 09:13:25 +0100136 r = lyd_parse_lyb(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100137 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200138 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200139 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100140 LOGARG(ctx, format);
Michal Vaskod027f382023-02-10 09:13:25 +0100141 r = LY_EINVAL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100142 break;
143 }
Michal Vasko50da8cd2023-03-10 08:38:59 +0100144 if (r) {
145 rc = r;
Michal Vasko7a266772024-01-23 11:02:38 +0100146 if ((r != LY_EVALID) || !lydctx || !(lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR)) {
147 goto cleanup;
148 }
149
150 eitem = ly_err_last(ctx);
151 assert(eitem);
152 if (eitem->vecode == LYVE_SYNTAX) {
153 /* cannot get more errors on a syntax error */
Michal Vasko50da8cd2023-03-10 08:38:59 +0100154 goto cleanup;
155 }
156 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100157
Michal Vaskoa6139e02023-10-03 14:13:22 +0200158 if (parent && parsed.count) {
159 /* use the first parsed node */
Michal Vaskob36c56f2024-01-31 12:50:07 +0100160 if (first_p) {
161 *first_p = parsed.dnodes[0];
162 } else {
163 first_p = &parsed.dnodes[0];
164 }
Radek Krejci7931b192020-06-25 17:05:03 +0200165 }
166
Michal Vaskoe0665742021-02-11 11:08:44 +0100167 if (!(parse_opts & LYD_PARSE_ONLY)) {
168 /* validate data */
Michal Vasko9f6dd7c2023-04-06 08:46:30 +0200169 r = lyd_validate(first_p, NULL, ctx, val_opts, 0, &lydctx->node_when, &lydctx->node_types, &lydctx->meta_types,
Michal Vasko135719f2022-08-25 12:18:17 +0200170 &lydctx->ext_node, &lydctx->ext_val, NULL);
Michal Vasko9f6dd7c2023-04-06 08:46:30 +0200171 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +0100172 }
Radek Krejci7931b192020-06-25 17:05:03 +0200173
Michal Vaskoe0665742021-02-11 11:08:44 +0100174 /* set the operation node */
175 if (op) {
176 *op = lydctx->op_node;
Radek Krejci1798aae2020-07-14 13:26:06 +0200177 }
178
179cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +0100180 if (lydctx) {
181 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200182 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100183 if (rc) {
184 if (parent) {
185 /* free all the parsed subtrees */
186 for (i = 0; i < parsed.count; ++i) {
187 lyd_free_tree(parsed.dnodes[i]);
188 }
189 } else {
190 /* free everything */
191 lyd_free_all(*first_p);
192 *first_p = NULL;
193 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100194 } else if (subtree_sibling) {
195 rc = LY_ENOT;
Michal Vaskoe0665742021-02-11 11:08:44 +0100196 }
197 ly_set_erase(&parsed, NULL);
198 return rc;
Radek Krejci7931b192020-06-25 17:05:03 +0200199}
200
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100201LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100202lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
203 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
204{
205 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
206
207 LY_CHECK_ARG_RET(ctx, ext, in, parent || tree, LY_EINVAL);
208 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
209 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
210
211 return lyd_parse(ctx, ext, parent, tree, in, format, parse_options, validate_options, NULL);
212}
213
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100214LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100215lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
216 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
217{
218 LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
219 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
220 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
221
Radek Krejcif16e2542021-02-17 15:39:23 +0100222 return lyd_parse(ctx, NULL, parent, tree, in, format, parse_options, validate_options, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100223}
224
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100225LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100226lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
227 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200228{
229 LY_ERR ret;
230 struct ly_in *in;
231
232 LY_CHECK_RET(ly_in_new_memory(data, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100233 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200234
235 ly_in_free(in, 0);
236 return ret;
237}
238
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100239LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200240lyd_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 +0200241 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200242{
243 LY_ERR ret;
244 struct ly_in *in;
245
246 LY_CHECK_RET(ly_in_new_fd(fd, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100247 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200248
249 ly_in_free(in, 0);
250 return ret;
251}
252
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100253LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200254lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
255 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200256{
257 LY_ERR ret;
258 struct ly_in *in;
259
260 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100261 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200262
263 ly_in_free(in, 0);
264 return ret;
265}
266
Radek Krejcif16e2542021-02-17 15:39:23 +0100267/**
268 * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
269 * for schema nodes locked inside the extension instance.
270 *
271 * At least one of @p parent, @p tree, or @p op must always be set.
272 *
Michal Vasko820efe82023-05-12 15:47:43 +0200273 * Specific @p data_type values have different parameter meaning as mentioned for ::lyd_parse_op().
Radek Krejcif16e2542021-02-17 15:39:23 +0100274 *
275 * @param[in] ctx libyang context.
276 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
277 * @param[in] parent Optional parent to connect the parsed nodes to.
278 * @param[in] in Input handle to read the input from.
279 * @param[in] format Expected format of the data in @p in.
280 * @param[in] data_type Expected operation to parse (@ref datatype).
281 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
282 * @param[out] op Optional parsed operation node.
283 * @return LY_ERR value.
284 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
285 */
286static LY_ERR
287lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
288 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 +0200289{
Michal Vaskoe0665742021-02-11 11:08:44 +0100290 LY_ERR rc = LY_SUCCESS;
291 struct lyd_ctx *lydctx = NULL;
292 struct ly_set parsed = {0};
293 struct lyd_node *first = NULL, *envp = NULL;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100294 uint32_t i, parse_opts, val_opts, int_opts = 0;
Michal Vasko820efe82023-05-12 15:47:43 +0200295 ly_bool proto_msg = 0;
Radek Krejci7931b192020-06-25 17:05:03 +0200296
Michal Vasko27fb0262021-02-23 09:42:01 +0100297 if (!ctx) {
298 ctx = LYD_CTX(parent);
299 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200300 if (tree) {
301 *tree = NULL;
302 }
303 if (op) {
304 *op = NULL;
305 }
306
Radek Krejci7931b192020-06-25 17:05:03 +0200307 format = lyd_parse_get_format(in, format);
Radek Krejci7931b192020-06-25 17:05:03 +0200308
Michal Vasko63f3d842020-07-08 10:10:14 +0200309 /* remember input position */
310 in->func_start = in->current;
311
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100312 /* set parse and validation opts */
Michal Vasko140ede92022-05-10 09:27:30 +0200313 parse_opts = LYD_PARSE_ONLY | LYD_PARSE_STRICT;
Michal Vaskoe0665742021-02-11 11:08:44 +0100314 val_opts = 0;
315
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100316 switch (data_type) {
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100317 case LYD_TYPE_RPC_NETCONF:
318 case LYD_TYPE_NOTIF_NETCONF:
319 LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
Michal Vasko820efe82023-05-12 15:47:43 +0200320 proto_msg = 1;
321 break;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100322 case LYD_TYPE_REPLY_NETCONF:
Michal Vasko820efe82023-05-12 15:47:43 +0200323 LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema, parent->schema->nodetype & (LYS_RPC | LYS_ACTION),
324 tree, !op, LY_EINVAL);
325 proto_msg = 1;
326 break;
327 case LYD_TYPE_RPC_RESTCONF:
328 case LYD_TYPE_REPLY_RESTCONF:
329 LY_CHECK_ARG_RET(ctx, parent, parent->schema, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op, LY_EINVAL);
330 proto_msg = 1;
331 break;
332 case LYD_TYPE_NOTIF_RESTCONF:
333 LY_CHECK_ARG_RET(ctx, format == LYD_JSON, !parent, tree, op, LY_EINVAL);
334 proto_msg = 1;
335 break;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100336
Michal Vasko820efe82023-05-12 15:47:43 +0200337 /* set internal opts */
338 case LYD_TYPE_RPC_YANG:
Michal Vasko5df28522023-08-25 08:04:37 +0200339 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION | (parent ? LYD_INTOPT_WITH_SIBLINGS : LYD_INTOPT_NO_SIBLINGS);
Michal Vasko820efe82023-05-12 15:47:43 +0200340 break;
341 case LYD_TYPE_NOTIF_YANG:
Michal Vasko5df28522023-08-25 08:04:37 +0200342 int_opts = LYD_INTOPT_NOTIF | (parent ? LYD_INTOPT_WITH_SIBLINGS : LYD_INTOPT_NO_SIBLINGS);
Michal Vasko820efe82023-05-12 15:47:43 +0200343 break;
344 case LYD_TYPE_REPLY_YANG:
Michal Vasko5df28522023-08-25 08:04:37 +0200345 int_opts = LYD_INTOPT_REPLY | (parent ? LYD_INTOPT_WITH_SIBLINGS : LYD_INTOPT_NO_SIBLINGS);
Michal Vasko820efe82023-05-12 15:47:43 +0200346 break;
347 case LYD_TYPE_DATA_YANG:
348 LOGINT(ctx);
349 rc = LY_EINT;
350 goto cleanup;
351 }
352
353 /* parse a full protocol message */
354 if (proto_msg) {
355 if (format == LYD_XML) {
356 /* parse the NETCONF (or RESTCONF XML) message */
357 rc = lyd_parse_xml_netconf(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
358 } else {
359 /* parse the RESTCONF message */
360 rc = lyd_parse_json_restconf(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
361 }
Michal Vasko3a163bc2023-01-10 14:23:56 +0100362 if (rc) {
363 if (envp) {
364 /* special situation when the envelopes were parsed successfully */
365 *tree = envp;
366 }
Michal Vasko73792a12022-05-10 09:28:45 +0200367 goto cleanup;
Michal Vasko299d5d12021-02-16 16:36:37 +0100368 }
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100369
370 /* set out params correctly */
Michal Vasko472baa82022-12-01 16:17:41 +0100371 if (envp) {
372 /* special out param meaning */
373 *tree = envp;
374 } else {
375 *tree = parent ? NULL : first;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100376 }
377 if (op) {
378 *op = lydctx->op_node;
379 }
380 goto cleanup;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100381 }
382
383 /* parse the data */
384 switch (format) {
385 case LYD_XML:
386 rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100387 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200388 case LYD_JSON:
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100389 rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100390 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200391 case LYD_LYB:
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100392 rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100393 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200394 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100395 LOGARG(ctx, format);
396 rc = LY_EINVAL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200397 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200398 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100399 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci7931b192020-06-25 17:05:03 +0200400
Michal Vaskoe0665742021-02-11 11:08:44 +0100401 /* set out params correctly */
402 if (tree) {
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100403 *tree = parent ? NULL : first;
Michal Vaskoe0665742021-02-11 11:08:44 +0100404 }
405 if (op) {
406 *op = lydctx->op_node;
407 }
408
409cleanup:
410 if (lydctx) {
411 lydctx->free(lydctx);
412 }
413 if (rc) {
Michal Vasko73792a12022-05-10 09:28:45 +0200414 /* free all the parsed nodes */
415 if (parsed.count) {
416 i = parsed.count;
417 do {
418 --i;
Michal Vaskoe0665742021-02-11 11:08:44 +0100419 lyd_free_tree(parsed.dnodes[i]);
Michal Vasko73792a12022-05-10 09:28:45 +0200420 } while (i);
421 }
Michal Vasko6fbf07b2023-08-08 13:54:48 +0200422 if (tree && !envp) {
Michal Vasko73792a12022-05-10 09:28:45 +0200423 *tree = NULL;
424 }
425 if (op) {
426 *op = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100427 }
428 }
429 ly_set_erase(&parsed, NULL);
430 return rc;
Radek Krejcie7b95092019-05-15 11:03:07 +0200431}
Radek Krejci084289f2019-07-09 17:35:30 +0200432
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100433LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100434lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
435 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
436{
437 LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
438
439 return lyd_parse_op_(ctx, NULL, parent, in, format, data_type, tree, op);
440}
441
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100442LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100443lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
444 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
445{
446 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
447
448 LY_CHECK_ARG_RET(ctx, ext, in, data_type, parent || tree || op, LY_EINVAL);
449
450 return lyd_parse_op_(ctx, ext, parent, in, format, data_type, tree, op);
451}
452
Michal Vasko90932a92020-02-12 14:33:03 +0100453struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +0200454lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +0100455{
Michal Vaskob104f112020-07-17 09:54:54 +0200456 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +0100457 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200458 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +0100459 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +0100460
Michal Vaskob104f112020-07-17 09:54:54 +0200461 assert(new_node);
462
Michal Vasko9beceb82022-04-05 12:14:15 +0200463 if (!first_sibling || !new_node->schema || (LYD_CTX(first_sibling) != LYD_CTX(new_node))) {
Michal Vaskob104f112020-07-17 09:54:54 +0200464 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +0100465 return NULL;
466 }
467
Michal Vasko93b16062020-12-09 18:14:18 +0100468 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +0100469 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +0100470 getnext_opts = LYS_GETNEXT_OUTPUT;
471 }
472
Michal Vaskoa2756f02021-07-09 13:20:28 +0200473 if (first_sibling->parent && first_sibling->parent->schema && first_sibling->parent->children_ht) {
Michal Vaskob104f112020-07-17 09:54:54 +0200474 /* find the anchor using hashes */
475 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +0100476 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200477 while (schema) {
478 /* keep trying to find the first existing instance of the closest following schema sibling,
479 * otherwise return NULL - inserting at the end */
480 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
481 break;
482 }
483
Michal Vasko93b16062020-12-09 18:14:18 +0100484 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200485 }
486 } else {
487 /* find the anchor without hashes */
488 match = (struct lyd_node *)first_sibling;
Michal Vasko3a708622021-07-15 14:20:10 +0200489 sparent = lysc_data_parent(new_node->schema);
490 if (!sparent) {
Michal Vaskob104f112020-07-17 09:54:54 +0200491 /* we are in top-level, skip all the data from preceding modules */
492 LY_LIST_FOR(match, match) {
493 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
494 break;
495 }
496 }
497 }
498
499 /* get the first schema sibling */
Michal Vasko93b16062020-12-09 18:14:18 +0100500 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vasko9a463472023-08-08 09:43:33 +0200501 if (!schema) {
Michal Vasko60d929e2023-08-21 11:54:42 +0200502 /* must be a top-level extension instance data, no anchor */
503 return NULL;
Michal Vasko9a463472023-08-08 09:43:33 +0200504 }
Michal Vaskob104f112020-07-17 09:54:54 +0200505
506 found = 0;
507 LY_LIST_FOR(match, match) {
508 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
509 /* we have found an opaque node, which must be at the end, so use it OR
510 * modules do not match, so we must have traversed all the data from new_node module (if any),
511 * we have found the first node of the next module, that is what we want */
512 break;
513 }
514
515 /* skip schema nodes until we find the instantiated one */
516 while (!found) {
517 if (new_node->schema == schema) {
518 /* we have found the schema of the new node, continue search to find the first
519 * data node with a different schema (after our schema) */
520 found = 1;
521 break;
522 }
523 if (match->schema == schema) {
524 /* current node (match) is a data node still before the new node, continue search in data */
525 break;
526 }
Michal Vasko9a463472023-08-08 09:43:33 +0200527
Michal Vasko93b16062020-12-09 18:14:18 +0100528 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vasko9a463472023-08-08 09:43:33 +0200529 if (!schema) {
Michal Vasko60d929e2023-08-21 11:54:42 +0200530 /* must be a top-level extension instance data, no anchor */
531 return NULL;
Michal Vasko9a463472023-08-08 09:43:33 +0200532 }
Michal Vaskob104f112020-07-17 09:54:54 +0200533 }
534
535 if (found && (match->schema != new_node->schema)) {
536 /* find the next node after we have found our node schema data instance */
537 break;
538 }
539 }
Michal Vasko90932a92020-02-12 14:33:03 +0100540 }
541
542 return match;
543}
544
Michal Vaskoc61dd062022-06-07 11:01:28 +0200545void
aPiecek743184b2024-02-01 13:25:56 +0100546lyd_insert_after_node(struct lyd_node **first_sibling_p, struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100547{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100548 struct lyd_node_inner *par;
aPiecek743184b2024-02-01 13:25:56 +0100549 struct lyd_node *first_sibling;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100550
Michal Vasko90932a92020-02-12 14:33:03 +0100551 assert(!node->next && (node->prev == node));
552
aPiecek743184b2024-02-01 13:25:56 +0100553 if (sibling->next) {
Michal Vasko90932a92020-02-12 14:33:03 +0100554 /* sibling had a succeeding node */
aPiecek743184b2024-02-01 13:25:56 +0100555 sibling->next->prev = node;
556 node->next = sibling->next;
Michal Vasko90932a92020-02-12 14:33:03 +0100557 } else {
558 /* sibling was last, find first sibling and change its prev */
aPiecek743184b2024-02-01 13:25:56 +0100559 if (first_sibling_p && *first_sibling_p) {
560 assert(!(*first_sibling_p)->prev->next);
561 (*first_sibling_p)->prev = node;
Michal Vasko90932a92020-02-12 14:33:03 +0100562 } else {
aPiecek743184b2024-02-01 13:25:56 +0100563 first_sibling = lyd_first_sibling(sibling);
564 first_sibling->prev = node;
565 if (first_sibling_p) {
566 *first_sibling_p = first_sibling;
567 }
Michal Vasko90932a92020-02-12 14:33:03 +0100568 }
Michal Vasko90932a92020-02-12 14:33:03 +0100569 }
aPiecek743184b2024-02-01 13:25:56 +0100570 node->prev = sibling;
571 sibling->next = node;
Michal Vasko90932a92020-02-12 14:33:03 +0100572 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100573
Michal Vasko9f96a052020-03-10 09:41:45 +0100574 for (par = node->parent; par; par = par->parent) {
575 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
576 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100577 par->flags &= ~LYD_DEFAULT;
578 }
579 }
Michal Vasko90932a92020-02-12 14:33:03 +0100580}
581
Michal Vaskoc61dd062022-06-07 11:01:28 +0200582void
Michal Vaskof03ed032020-03-04 13:31:44 +0100583lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100584{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100585 struct lyd_node_inner *par;
586
Michal Vasko90932a92020-02-12 14:33:03 +0100587 assert(!node->next && (node->prev == node));
588
589 node->next = sibling;
590 /* covers situation of sibling being first */
591 node->prev = sibling->prev;
592 sibling->prev = node;
593 if (node->prev->next) {
594 /* sibling had a preceding node */
595 node->prev->next = node;
596 } else if (sibling->parent) {
597 /* sibling was first and we must also change parent child pointer */
598 sibling->parent->child = node;
599 }
600 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100601
Michal Vasko9f96a052020-03-10 09:41:45 +0100602 for (par = node->parent; par; par = par->parent) {
603 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
604 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100605 par->flags &= ~LYD_DEFAULT;
606 }
607 }
Michal Vasko90932a92020-02-12 14:33:03 +0100608}
609
610/**
Michal Vaskob104f112020-07-17 09:54:54 +0200611 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +0100612 *
Michal Vasko9f96a052020-03-10 09:41:45 +0100613 * Handles inserting into NP containers and key-less lists.
614 *
Michal Vasko90932a92020-02-12 14:33:03 +0100615 * @param[in] parent Parent to insert into.
616 * @param[in] node Node to insert.
617 */
618static void
Michal Vaskob104f112020-07-17 09:54:54 +0200619lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100620{
621 struct lyd_node_inner *par;
622
Radek Krejcia1c1e542020-09-29 16:06:52 +0200623 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +0100624 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +0100625
626 par = (struct lyd_node_inner *)parent;
627
Michal Vaskob104f112020-07-17 09:54:54 +0200628 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +0100629 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100630
Michal Vaskod989ba02020-08-24 10:59:24 +0200631 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +0100632 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
633 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100634 par->flags &= ~LYD_DEFAULT;
635 }
636 }
Michal Vasko751cb4d2020-07-14 12:25:28 +0200637}
Michal Vasko0249f7c2020-03-05 16:36:40 +0100638
Michal Vasko751cb4d2020-07-14 12:25:28 +0200639/**
640 * @brief Learn whether a list instance has all the keys.
641 *
642 * @param[in] list List instance to check.
643 * @return non-zero if all the keys were found,
644 * @return 0 otherwise.
645 */
646static int
647lyd_insert_has_keys(const struct lyd_node *list)
648{
649 const struct lyd_node *key;
650 const struct lysc_node *skey = NULL;
651
652 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +0200653 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +0200654 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
655 if (!key || (key->schema != skey)) {
656 /* key missing */
657 return 0;
658 }
659
660 key = key->next;
661 }
662
663 /* all keys found */
664 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +0100665}
666
aPiecek6cf1d162023-11-08 16:07:00 +0100667/**
668 * @brief Get the first subsequent data node that contains a different schema definition.
669 *
670 * @param[in] first_sibling First sibling, NULL if no top-level sibling exist yet.
671 * @param[in] node Node to be inserted.
672 * @return Subsequent data node with a different schema.
673 */
674static struct lyd_node *
675lyd_insert_node_find_anchor(struct lyd_node *first_sibling, struct lyd_node *node)
676{
677 struct lyd_node *anchor;
678
679 if (first_sibling && (first_sibling->flags & LYD_EXT)) {
680 return NULL;
681 }
682
683 /* find the anchor, so we can insert somewhere before it */
684 anchor = lyd_insert_get_next_anchor(first_sibling, node);
685 /* cannot insert data node after opaque nodes */
686 if (!anchor && node->schema && first_sibling && !first_sibling->prev->schema) {
687 anchor = first_sibling->prev;
688 while ((anchor != first_sibling) && !anchor->prev->schema) {
689 anchor = anchor->prev;
690 }
691 }
692
693 return anchor;
694}
695
696/**
aPiecek61880852024-01-11 14:10:29 +0100697 * @brief Insert @p node as the last node.
aPiecek6cf1d162023-11-08 16:07:00 +0100698 *
699 * @param[in] parent Parent to insert into, NULL for top-level sibling.
aPiecek743184b2024-02-01 13:25:56 +0100700 * @param[in,out] first_sibling First sibling, NULL if no top-level sibling exist yet.
701 * Can be also NULL if @p parent is set.
aPiecek6cf1d162023-11-08 16:07:00 +0100702 * @param[in] node Individual node (without siblings) to insert.
aPiecek6cf1d162023-11-08 16:07:00 +0100703 */
704static void
aPiecek743184b2024-02-01 13:25:56 +0100705lyd_insert_node_last(struct lyd_node *parent, struct lyd_node **first_sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100706{
aPiecek743184b2024-02-01 13:25:56 +0100707 assert(first_sibling && node);
708
709 if (*first_sibling) {
aPiecek743184b2024-02-01 13:25:56 +0100710 lyd_insert_after_node(first_sibling, (*first_sibling)->prev, node);
Michal Vaskob104f112020-07-17 09:54:54 +0200711 } else if (parent) {
712 lyd_insert_only_child(parent, node);
aPiecek743184b2024-02-01 13:25:56 +0100713 *first_sibling = node;
714 } else {
715 *first_sibling = node;
Michal Vaskob104f112020-07-17 09:54:54 +0200716 }
aPiecek6cf1d162023-11-08 16:07:00 +0100717}
718
aPieceke6955f42024-01-19 14:01:54 +0100719void
aPiecek743184b2024-02-01 13:25:56 +0100720lyd_insert_node_ordby_schema(struct lyd_node *parent, struct lyd_node **first_sibling, struct lyd_node *node)
aPiecek6cf1d162023-11-08 16:07:00 +0100721{
aPiecek61880852024-01-11 14:10:29 +0100722 struct lyd_node *anchor;
aPiecek6cf1d162023-11-08 16:07:00 +0100723
aPiecek743184b2024-02-01 13:25:56 +0100724 assert(first_sibling && node);
725
726 if ((anchor = lyd_insert_node_find_anchor(*first_sibling, node))) {
aPiecek6cf1d162023-11-08 16:07:00 +0100727 lyd_insert_before_node(anchor, node);
aPiecek743184b2024-02-01 13:25:56 +0100728 *first_sibling = *first_sibling != anchor ? *first_sibling : node;
aPiecek6f9253c2024-02-13 11:05:12 +0100729 } else if (*first_sibling && node->schema && !(*first_sibling)->prev->schema) {
730 /* cannot insert data node after opaque nodes */
731 anchor = (*first_sibling)->prev;
732 while ((anchor != *first_sibling) && !anchor->prev->schema) {
733 anchor = anchor->prev;
734 }
735 lyd_insert_before_node(anchor, node);
736 *first_sibling = *first_sibling != anchor ? *first_sibling : node;
aPiecek6cf1d162023-11-08 16:07:00 +0100737 } else {
aPiecek61880852024-01-11 14:10:29 +0100738 lyd_insert_node_last(parent, first_sibling, node);
aPiecek6cf1d162023-11-08 16:07:00 +0100739 }
aPiecek6cf1d162023-11-08 16:07:00 +0100740}
741
742void
aPiecek1462ab12024-02-07 09:13:29 +0100743lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node, uint32_t order)
aPiecek6cf1d162023-11-08 16:07:00 +0100744{
745 LY_ERR ret = LY_SUCCESS;
aPiecek61880852024-01-11 14:10:29 +0100746 struct lyd_node *first_sibling, *leader;
aPiecek6cf1d162023-11-08 16:07:00 +0100747
748 /* inserting list without its keys is not supported */
749 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
750 assert(!parent || !parent->schema ||
751 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
752
aPiecek61880852024-01-11 14:10:29 +0100753 if (!parent && first_sibling_p && (*first_sibling_p)) {
aPiecek6cf1d162023-11-08 16:07:00 +0100754 parent = lyd_parent(*first_sibling_p);
755 }
aPiecek61880852024-01-11 14:10:29 +0100756 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
aPiecek6cf1d162023-11-08 16:07:00 +0100757
aPiecek6f9253c2024-02-13 11:05:12 +0100758 if ((order == LYD_INSERT_NODE_LAST) || !node->schema || (first_sibling && (first_sibling->flags & LYD_EXT))) {
aPiecek743184b2024-02-01 13:25:56 +0100759 lyd_insert_node_last(parent, &first_sibling, node);
aPiecek1462ab12024-02-07 09:13:29 +0100760 } else if (order == LYD_INSERT_NODE_LAST_BY_SCHEMA) {
761 lyd_insert_node_ordby_schema(parent, &first_sibling, node);
aPiecek61880852024-01-11 14:10:29 +0100762 } else if (lyds_is_supported(node) &&
763 (lyd_find_sibling_schema(first_sibling, node->schema, &leader) == LY_SUCCESS)) {
aPiecek743184b2024-02-01 13:25:56 +0100764 ret = lyds_insert(&first_sibling, &leader, node);
aPiecek6cf1d162023-11-08 16:07:00 +0100765 if (ret) {
766 /* The operation on the sorting tree unexpectedly failed due to some internal issue,
767 * but insert the node anyway although the nodes will not be sorted.
768 */
769 LOGWRN(LYD_CTX(node), "Data in \"%s\" are not sorted.", node->schema->name);
aPiecek743184b2024-02-01 13:25:56 +0100770 lyd_insert_node_ordby_schema(parent, &first_sibling, node);
aPiecek6cf1d162023-11-08 16:07:00 +0100771 }
772 } else {
aPiecek743184b2024-02-01 13:25:56 +0100773 lyd_insert_node_ordby_schema(parent, &first_sibling, node);
aPiecek6cf1d162023-11-08 16:07:00 +0100774 }
Michal Vaskob104f112020-07-17 09:54:54 +0200775
776 /* insert into parent HT */
777 lyd_insert_hash(node);
778
779 /* finish hashes for our parent, if needed and possible */
Michal Vaskoa878a892023-08-18 12:22:07 +0200780 if (node->schema && (node->schema->flags & LYS_KEY) && parent && parent->schema && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +0200781 lyd_hash(parent);
782
783 /* now we can insert even the list into its parent HT */
784 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +0100785 }
aPiecek61880852024-01-11 14:10:29 +0100786
787 if (first_sibling_p) {
aPiecek743184b2024-02-01 13:25:56 +0100788 *first_sibling_p = first_sibling;
aPiecek61880852024-01-11 14:10:29 +0100789 }
aPiecek1462ab12024-02-07 09:13:29 +0100790
791#ifndef NDEBUG
792 if ((order == LYD_INSERT_NODE_LAST) && lyds_is_supported(node) &&
793 (node->prev->schema == node->schema) && (lyds_compare_single(node->prev, node) > 0)) {
794 LOGWRN(LYD_CTX(node), "Data in \"%s\" are not sorted, inserted node should not be added to the end.",
795 node->schema->name);
796 }
797#endif
Michal Vasko90932a92020-02-12 14:33:03 +0100798}
799
Michal Vasko717a4c32020-12-07 09:40:10 +0100800/**
aPiecekcada0d72024-01-11 15:04:12 +0100801 * @brief Check that @p node can be unlinked.
802 *
803 * @param[in] node Node to check
804 * @return LY_ERR value.
805 */
806static LY_ERR
807lyd_unlink_check(struct lyd_node *node)
808{
809 if (!node) {
810 return LY_SUCCESS;
811 }
812
813 if (lysc_is_key(node->schema) && node->parent) {
814 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot unlink a list key \"%s\", unlink the list instance instead.",
815 LYD_NAME(node));
816 return LY_EINVAL;
817 }
818
819 return LY_SUCCESS;
820}
821
822/**
823 * @brief Move schema instances before anchor or as the last.
824 *
825 * The nodes will remain sorted according to the schema.
826 *
aPiecek743184b2024-02-01 13:25:56 +0100827 * @param[in] first_dst First sibling, destination.
aPiecekcada0d72024-01-11 15:04:12 +0100828 * @param[in] node Starting node, all following nodes with the same schema will be moved.
829 * @param[out] next_p Next node that has a different schema or NULL.
830 * @return LY_ERR value.
831 */
832static LY_ERR
aPiecek743184b2024-02-01 13:25:56 +0100833lyd_move_nodes_ordby_schema(struct lyd_node **first_dst, struct lyd_node *node, struct lyd_node **next_p)
aPiecekcada0d72024-01-11 15:04:12 +0100834{
aPiecek743184b2024-02-01 13:25:56 +0100835 struct lyd_node *second, *anchor, *iter, *next, *dst, *src, *first_src = NULL;
aPiecekcada0d72024-01-11 15:04:12 +0100836
aPiecek743184b2024-02-01 13:25:56 +0100837 assert(first_dst && *first_dst && !(*first_dst)->prev->next && node && next_p);
aPiecekcada0d72024-01-11 15:04:12 +0100838
aPiecek743184b2024-02-01 13:25:56 +0100839 if ((anchor = lyd_insert_node_find_anchor(*first_dst, node))) {
aPiecekcada0d72024-01-11 15:04:12 +0100840 /* move the first node to the correct place according to the schema */
841 LY_CHECK_RET(lyd_unlink_check(node));
842 second = node->next;
aPiecek743184b2024-02-01 13:25:56 +0100843 lyd_unlink_ignore_lyds(&first_src, node);
aPiecekcada0d72024-01-11 15:04:12 +0100844 lyd_insert_before_node(anchor, node);
845 lyd_insert_hash(node);
aPiecek743184b2024-02-01 13:25:56 +0100846 *first_dst = *first_dst != anchor ? *first_dst : node;
aPiecekcada0d72024-01-11 15:04:12 +0100847 if (!second || (node->schema != second->schema)) {
848 /* no more nodes to move */
849 *next_p = second;
850 return LY_SUCCESS;
851 }
852 dst = node;
853 src = second;
854 } else {
855 /* just move all instances to the end */
aPiecek743184b2024-02-01 13:25:56 +0100856 dst = (*first_dst)->prev;
aPiecekcada0d72024-01-11 15:04:12 +0100857 src = node;
858 }
859
860 /* move the rest of source instances after @p node */
861 LY_LIST_FOR_SAFE(src, next, iter) {
862 LY_CHECK_RET(lyd_unlink_check(iter));
863 if (iter->schema != src->schema) {
864 break;
865 }
aPiecek743184b2024-02-01 13:25:56 +0100866 lyd_unlink_ignore_lyds(&first_src, iter);
867 lyd_insert_after_node(first_dst, dst, iter);
aPiecekcada0d72024-01-11 15:04:12 +0100868 lyd_insert_hash(iter);
869 dst = iter;
870 }
871 *next_p = iter;
872
873 return LY_SUCCESS;
874}
875
876/**
877 * @brief Move nodes regardless of schema.
878 *
879 * The destination for the move is NULL, or a childless parent.
880 *
881 * @param[in] parent Parent to insert into, NULL for top-level sibling.
882 * @param[in] first_src First sibling, all following nodes will be moved.
883 * @return LY_ERR value.
884 */
885static LY_ERR
886lyd_move_nodes_at_once(struct lyd_node *parent, struct lyd_node *first_src)
887{
aPiecek743184b2024-02-01 13:25:56 +0100888 struct lyd_node *start, *next, *iter, *first_dst;
aPiecekcada0d72024-01-11 15:04:12 +0100889
890 assert(!lyd_child(parent) && first_src && !first_src->prev->next && !first_src->parent);
891
892 LY_CHECK_RET(lyd_unlink_check(first_src));
893
894 /* move the first node */
895 start = first_src->next;
aPiecek743184b2024-02-01 13:25:56 +0100896 first_dst = first_src;
aPiecekcada0d72024-01-11 15:04:12 +0100897 if (parent) {
aPiecek743184b2024-02-01 13:25:56 +0100898 lyd_unlink_ignore_lyds(&first_src, first_dst);
899 lyd_insert_only_child(parent, first_dst);
900 lyd_insert_hash(first_dst);
aPiecekcada0d72024-01-11 15:04:12 +0100901 } else {
aPiecek743184b2024-02-01 13:25:56 +0100902 lyd_unlink_ignore_lyds(&first_src, first_dst);
aPiecekcada0d72024-01-11 15:04:12 +0100903 }
904
905 /* move the rest of the nodes */
906 LY_LIST_FOR_SAFE(start, next, iter) {
907 LY_CHECK_RET(lyd_unlink_check(iter));
aPiecek743184b2024-02-01 13:25:56 +0100908 lyd_unlink_ignore_lyds(&first_src, iter);
909 lyd_insert_after_node(&first_dst, first_dst->prev, iter);
aPiecekcada0d72024-01-11 15:04:12 +0100910 lyd_insert_hash(iter);
911 }
912
913 return LY_SUCCESS;
914}
915
916/**
917 * @brief Move the nodes in parts according to the schema.
918 *
aPiecek743184b2024-02-01 13:25:56 +0100919 * @param[in,out] first_dst First sibling, destination.
aPiecekcada0d72024-01-11 15:04:12 +0100920 * @param[in] first_src First sibling, all following nodes will be moved.
921 * @return LY_ERR value.
922 */
923static LY_ERR
aPiecek743184b2024-02-01 13:25:56 +0100924lyd_move_nodes_by_schema(struct lyd_node **first_dst, struct lyd_node *first_src)
aPiecekcada0d72024-01-11 15:04:12 +0100925{
926 LY_ERR ret;
927 struct lyd_node *next, *iter, *leader;
928
aPiecek743184b2024-02-01 13:25:56 +0100929 assert(first_dst && *first_dst && !(*first_dst)->prev->next && first_src &&
930 !first_src->prev->next && !first_src->parent);
aPiecekcada0d72024-01-11 15:04:12 +0100931
932 for (iter = first_src; iter; iter = next) {
933 if (lyds_is_supported(iter) &&
aPiecek743184b2024-02-01 13:25:56 +0100934 (lyd_find_sibling_schema(*first_dst, iter->schema, &leader) == LY_SUCCESS)) {
935 ret = lyds_merge(first_dst, &leader, &first_src, iter, &next);
aPiecekcada0d72024-01-11 15:04:12 +0100936 if (ret) {
937 /* The operation on the sorting tree unexpectedly failed due to some internal issue,
938 * but insert the node anyway although the nodes will not be sorted.
939 */
940 LOGWRN(LYD_CTX(first_src), "Data in \"%s\" are not sorted.", leader->schema->name);
aPiecek743184b2024-02-01 13:25:56 +0100941 LY_CHECK_RET(lyd_move_nodes_ordby_schema(first_dst, next, &next));
aPiecekcada0d72024-01-11 15:04:12 +0100942 }
943 } else {
aPiecek743184b2024-02-01 13:25:56 +0100944 LY_CHECK_RET(lyd_move_nodes_ordby_schema(first_dst, iter, &next));
aPiecekcada0d72024-01-11 15:04:12 +0100945 }
aPiecekcada0d72024-01-11 15:04:12 +0100946 }
947
948 return LY_SUCCESS;
949}
950
951/**
952 * @brief Move a nodes into parent/siblings.
953 *
954 * @param[in] parent Parent to insert into, NULL for top-level sibling.
aPiecek743184b2024-02-01 13:25:56 +0100955 * @param[in,out] first_dst_p First sibling, NULL if no top-level sibling exist yet.
956 * Can be also NULL if @p parent is set.
aPiecekcada0d72024-01-11 15:04:12 +0100957 * @param[in] first_src First sibling, all following nodes will be moved.
958 * @return LY_ERR value.
959 */
960static LY_ERR
aPiecek743184b2024-02-01 13:25:56 +0100961lyd_move_nodes(struct lyd_node *parent, struct lyd_node **first_dst_p, struct lyd_node *first_src)
aPiecekcada0d72024-01-11 15:04:12 +0100962{
963 LY_ERR ret;
aPiecek743184b2024-02-01 13:25:56 +0100964 struct lyd_node *first_dst;
aPiecekcada0d72024-01-11 15:04:12 +0100965
aPiecek743184b2024-02-01 13:25:56 +0100966 assert((parent || first_dst_p) && first_src && !first_src->prev->next);
aPiecekcada0d72024-01-11 15:04:12 +0100967
aPiecek743184b2024-02-01 13:25:56 +0100968 if (!first_dst_p || !*first_dst_p) {
969 first_dst = lyd_child(parent);
aPiecekcada0d72024-01-11 15:04:12 +0100970 } else {
aPiecek743184b2024-02-01 13:25:56 +0100971 first_dst = *first_dst_p;
972 }
973
974 if (first_dst) {
975 ret = lyd_move_nodes_by_schema(&first_dst, first_src);
976 } else {
977 ret = lyd_move_nodes_at_once(parent, first_src);
978 first_dst = first_src;
979 }
980
981 if (first_dst_p) {
982 *first_dst_p = first_dst;
aPiecekcada0d72024-01-11 15:04:12 +0100983 }
984
985 return ret;
986}
987
988/**
Michal Vasko717a4c32020-12-07 09:40:10 +0100989 * @brief Check schema place of a node to be inserted.
990 *
991 * @param[in] parent Schema node of the parent data node.
992 * @param[in] sibling Schema node of a sibling data node.
993 * @param[in] schema Schema node if the data node to be inserted.
994 * @return LY_SUCCESS on success.
995 * @return LY_EINVAL if the place is invalid.
996 */
Michal Vaskof03ed032020-03-04 13:31:44 +0100997static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +0100998lyd_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 +0100999{
1000 const struct lysc_node *par2;
1001
Michal Vasko62ed12d2020-05-21 10:08:25 +02001002 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +01001003 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
1004 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +01001005
Michal Vasko717a4c32020-12-07 09:40:10 +01001006 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +01001007 /* opaque nodes can be inserted wherever */
1008 return LY_SUCCESS;
1009 }
1010
Michal Vasko717a4c32020-12-07 09:40:10 +01001011 if (!parent) {
1012 parent = lysc_data_parent(sibling);
1013 }
1014
Michal Vaskof03ed032020-03-04 13:31:44 +01001015 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +02001016 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +01001017
1018 if (parent) {
1019 /* inner node */
1020 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +02001021 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +02001022 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001023 return LY_EINVAL;
1024 }
1025 } else {
1026 /* top-level node */
1027 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +02001028 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +01001029 return LY_EINVAL;
1030 }
1031 }
1032
1033 return LY_SUCCESS;
1034}
1035
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001036LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001037lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01001038{
Michal Vasko0ab974d2021-02-24 13:18:26 +01001039 LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001040 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(parent), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001041
Michal Vasko717a4c32020-12-07 09:40:10 +01001042 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01001043
aPiecekcada0d72024-01-11 15:04:12 +01001044 if (node->parent || node->prev->next || !node->next) {
aPiecekdfde77d2024-01-15 15:16:01 +01001045 LY_CHECK_RET(lyd_unlink_tree(node));
aPiecek1462ab12024-02-07 09:13:29 +01001046 lyd_insert_node(parent, NULL, node, LYD_INSERT_NODE_DEFAULT);
aPiecekcada0d72024-01-11 15:04:12 +01001047 } else {
aPiecekdfde77d2024-01-15 15:16:01 +01001048 LY_CHECK_RET(lyd_move_nodes(parent, NULL, node));
Michal Vaskof03ed032020-03-04 13:31:44 +01001049 }
aPiecekcada0d72024-01-11 15:04:12 +01001050
Michal Vaskof03ed032020-03-04 13:31:44 +01001051 return LY_SUCCESS;
1052}
1053
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001054LIBYANG_API_DEF LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +02001055lyplg_ext_insert(struct lyd_node *parent, struct lyd_node *first)
Michal Vaskoddd76592022-01-17 13:34:48 +01001056{
1057 struct lyd_node *iter;
1058
1059 LY_CHECK_ARG_RET(NULL, parent, first, !first->parent, !first->prev->next,
1060 !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
1061
1062 if (first->schema && (first->schema->flags & LYS_KEY)) {
1063 LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", first->schema->name);
1064 return LY_EINVAL;
1065 }
1066
1067 while (first) {
1068 iter = first->next;
Michal Vasko2e784f82024-01-11 09:51:22 +01001069 lyd_unlink(first);
aPiecek1462ab12024-02-07 09:13:29 +01001070 lyd_insert_node(parent, NULL, first, LYD_INSERT_NODE_LAST);
Michal Vaskoddd76592022-01-17 13:34:48 +01001071 first = iter;
1072 }
1073 return LY_SUCCESS;
1074}
1075
1076LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +02001077lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +01001078{
aPiecekcada0d72024-01-11 15:04:12 +01001079 struct lyd_node *first_sibling;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001080
Michal Vasko1849d4e2024-07-03 14:03:59 +02001081 LY_CHECK_ARG_RET(NULL, node, sibling != node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001082
Michal Vaskob104f112020-07-17 09:54:54 +02001083 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +01001084 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001085 }
1086
aPiecekcada0d72024-01-11 15:04:12 +01001087 first_sibling = lyd_first_sibling(sibling);
1088 if (node->parent || node->prev->next || !node->next) {
aPiecekdfde77d2024-01-15 15:16:01 +01001089 LY_CHECK_RET(lyd_unlink_tree(node));
aPiecek1462ab12024-02-07 09:13:29 +01001090 lyd_insert_node(NULL, &first_sibling, node, LYD_INSERT_NODE_DEFAULT);
aPiecekcada0d72024-01-11 15:04:12 +01001091 } else {
aPiecek743184b2024-02-01 13:25:56 +01001092 LY_CHECK_RET(lyd_move_nodes(NULL, &first_sibling, node));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001093 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001094
Michal Vaskob104f112020-07-17 09:54:54 +02001095 if (first) {
aPiecek743184b2024-02-01 13:25:56 +01001096 *first = first_sibling;
Michal Vasko0249f7c2020-03-05 16:36:40 +01001097 }
1098
1099 return LY_SUCCESS;
1100}
1101
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001102LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01001103lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
1104{
Michal Vaskobce230b2022-04-19 09:55:31 +02001105 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001106 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001107
Michal Vasko717a4c32020-12-07 09:40:10 +01001108 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01001109
Michal Vaskoab7a2bf2022-04-01 14:37:54 +02001110 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001111 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01001112 return LY_EINVAL;
1113 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +02001114 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
1115 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert before a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +01001116 return LY_EINVAL;
1117 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001118
Michal Vasko2e784f82024-01-11 09:51:22 +01001119 lyd_unlink(node);
Michal Vasko4bc2ce32020-12-08 10:06:16 +01001120 lyd_insert_before_node(sibling, node);
1121 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01001122
Michal Vaskof03ed032020-03-04 13:31:44 +01001123 return LY_SUCCESS;
1124}
1125
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001126LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +01001127lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
1128{
Michal Vaskobce230b2022-04-19 09:55:31 +02001129 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001130 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001131
Michal Vasko717a4c32020-12-07 09:40:10 +01001132 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +01001133
Michal Vaskoab7a2bf2022-04-01 14:37:54 +02001134 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001135 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +01001136 return LY_EINVAL;
1137 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +02001138 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
1139 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert after a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +01001140 return LY_EINVAL;
1141 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001142
Michal Vasko2e784f82024-01-11 09:51:22 +01001143 lyd_unlink(node);
aPiecek743184b2024-02-01 13:25:56 +01001144 lyd_insert_after_node(NULL, sibling, node);
Michal Vasko4bc2ce32020-12-08 10:06:16 +01001145 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +01001146
Michal Vaskof03ed032020-03-04 13:31:44 +01001147 return LY_SUCCESS;
1148}
1149
Michal Vasko2e784f82024-01-11 09:51:22 +01001150void
aPiecek743184b2024-02-01 13:25:56 +01001151lyd_unlink_ignore_lyds(struct lyd_node **first_sibling_p, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +01001152{
aPiecek743184b2024-02-01 13:25:56 +01001153 struct lyd_node *first_sibling;
aPiecek6cf1d162023-11-08 16:07:00 +01001154
Michal Vaskob104f112020-07-17 09:54:54 +02001155 /* update hashes while still linked into the tree */
1156 lyd_unlink_hash(node);
1157
stewegf9041a22024-01-18 13:29:12 +01001158 /* unlink leafref nodes */
1159 if (node->schema && (node->schema->nodetype & LYD_NODE_TERM)) {
1160 lyd_free_leafref_nodes((struct lyd_node_term *)node);
1161 }
1162
Michal Vaskof03ed032020-03-04 13:31:44 +01001163 /* unlink from siblings */
Michal Vaskof03ed032020-03-04 13:31:44 +01001164 if (node->next) {
1165 node->next->prev = node->prev;
aPiecek743184b2024-02-01 13:25:56 +01001166 if (node->prev->next) {
1167 node->prev->next = node->next;
1168 } else if (first_sibling_p) {
1169 /* unlinking the first node */
1170 *first_sibling_p = node->next;
1171 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001172 } else {
1173 /* unlinking the last node */
aPiecek743184b2024-02-01 13:25:56 +01001174 /* update the "last" pointer from the first node */
1175 if (first_sibling_p && *first_sibling_p) {
1176 (*first_sibling_p)->prev = node->prev;
Michal Vaskof03ed032020-03-04 13:31:44 +01001177 } else {
aPiecek743184b2024-02-01 13:25:56 +01001178 first_sibling = lyd_first_sibling(node);
1179 first_sibling->prev = node->prev;
1180 if (first_sibling_p) {
1181 *first_sibling_p = first_sibling;
Michal Vaskof03ed032020-03-04 13:31:44 +01001182 }
1183 }
aPiecek743184b2024-02-01 13:25:56 +01001184 node->prev->next = NULL;
Michal Vaskof03ed032020-03-04 13:31:44 +01001185 }
1186
1187 /* unlink from parent */
1188 if (node->parent) {
1189 if (node->parent->child == node) {
1190 /* the node is the first child */
1191 node->parent->child = node->next;
1192 }
1193
Michal Vaskoab49dbe2020-07-17 12:32:47 +02001194 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko4754d4a2022-12-01 10:11:21 +01001195 lyd_cont_set_dflt(lyd_parent(node));
Michal Vaskoab49dbe2020-07-17 12:32:47 +02001196
Michal Vaskof03ed032020-03-04 13:31:44 +01001197 node->parent = NULL;
1198 }
1199
1200 node->next = NULL;
1201 node->prev = node;
1202}
1203
aPiecekcada0d72024-01-11 15:04:12 +01001204void
1205lyd_unlink(struct lyd_node *node)
1206{
1207 struct lyd_node *leader;
1208
1209 if (!node) {
1210 return;
1211 }
1212
1213 /* unlink from the lyds tree */
1214 if (lyds_is_supported(node)) {
1215 if (!node->prev->next || (node->prev->schema != node->schema)) {
1216 leader = node;
1217 } else {
1218 lyd_find_sibling_val(node, node->schema, NULL, 0, &leader);
1219 assert(leader);
1220 }
1221 lyds_unlink(&leader, node);
1222 }
1223
1224 /* unlink data tree */
aPiecek743184b2024-02-01 13:25:56 +01001225 lyd_unlink_ignore_lyds(NULL, node);
aPiecekcada0d72024-01-11 15:04:12 +01001226}
1227
aPiecekdfde77d2024-01-15 15:16:01 +01001228LIBYANG_API_DEF LY_ERR
Michal Vasko2e784f82024-01-11 09:51:22 +01001229lyd_unlink_siblings(struct lyd_node *node)
1230{
aPiecek743184b2024-02-01 13:25:56 +01001231 struct lyd_node *next, *iter, *leader, *start, *first_sibling = NULL;
Michal Vasko2e784f82024-01-11 09:51:22 +01001232
aPiecekcada0d72024-01-11 15:04:12 +01001233 if (lyds_is_supported(node) && node->prev->next && (node->prev->schema == node->schema)) {
1234 /* unlink starts at the non-first item in the (leaf-)list */
1235 lyd_find_sibling_val(node, node->schema, NULL, 0, &leader);
aPiecek743184b2024-02-01 13:25:56 +01001236 lyds_split(&first_sibling, leader, node, &start);
aPiecekcada0d72024-01-11 15:04:12 +01001237 } else {
1238 /* unlink @p node */
aPiecekdfde77d2024-01-15 15:16:01 +01001239 LY_CHECK_RET(lyd_unlink_check(node));
aPiecekcada0d72024-01-11 15:04:12 +01001240 start = node->next;
aPiecek743184b2024-02-01 13:25:56 +01001241 lyd_unlink_ignore_lyds(&first_sibling, node);
aPiecekcada0d72024-01-11 15:04:12 +01001242 }
Michal Vasko2e784f82024-01-11 09:51:22 +01001243
aPiecekcada0d72024-01-11 15:04:12 +01001244 /* continue unlinking the rest */
1245 LY_LIST_FOR_SAFE(start, next, iter) {
aPiecekdfde77d2024-01-15 15:16:01 +01001246 LY_CHECK_RET(lyd_unlink_check(iter));
aPiecek743184b2024-02-01 13:25:56 +01001247 lyd_unlink_ignore_lyds(&first_sibling, iter);
1248 lyd_insert_after_node(&node, node->prev, iter);
aPiecekcada0d72024-01-11 15:04:12 +01001249 lyd_insert_hash(iter);
Michal Vasko2e784f82024-01-11 09:51:22 +01001250 }
aPiecekdfde77d2024-01-15 15:16:01 +01001251
1252 return LY_SUCCESS;
Michal Vasko2e784f82024-01-11 09:51:22 +01001253}
1254
aPiecekdfde77d2024-01-15 15:16:01 +01001255LIBYANG_API_DEF LY_ERR
Michal Vasko2e784f82024-01-11 09:51:22 +01001256lyd_unlink_tree(struct lyd_node *node)
1257{
aPiecekdfde77d2024-01-15 15:16:01 +01001258 LY_CHECK_RET(lyd_unlink_check(node));
Michal Vasko2e784f82024-01-11 09:51:22 +01001259 lyd_unlink(node);
aPiecekdfde77d2024-01-15 15:16:01 +01001260
1261 return LY_SUCCESS;
Michal Vasko2e784f82024-01-11 09:51:22 +01001262}
1263
Michal Vaskoa5da3292020-08-12 13:10:50 +02001264void
Michal Vasko871a0252020-11-11 18:35:24 +01001265lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +02001266{
1267 struct lyd_meta *last, *iter;
1268
1269 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +02001270
1271 if (!meta) {
1272 return;
1273 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001274
1275 for (iter = meta; iter; iter = iter->next) {
1276 iter->parent = parent;
1277 }
1278
1279 /* insert as the last attribute */
1280 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001281 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02001282 last->next = meta;
1283 } else {
1284 parent->meta = meta;
1285 }
1286
1287 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +01001288 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02001289 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +01001290 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +02001291 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001292}
1293
aPiecek0e92afc2023-11-08 10:48:02 +01001294void
1295lyd_unlink_meta_single(struct lyd_meta *meta)
1296{
1297 struct lyd_meta *iter;
1298
1299 if (!meta) {
1300 return;
1301 }
1302
1303 if (meta->parent && (meta->parent->meta == meta)) {
1304 meta->parent->meta = meta->next;
1305 } else if (meta->parent) {
1306 for (iter = meta->parent->meta; iter->next && (iter->next != meta); iter = iter->next) {}
1307 if (iter->next) {
1308 iter->next = meta->next;
1309 }
1310 }
1311
1312 meta->next = NULL;
1313 meta->parent = NULL;
1314}
1315
aPiecek0b1df642023-11-06 16:15:33 +01001316/**
1317 * @brief Get the annotation definition in the module.
1318 *
1319 * @param[in] mod Metadata module (with the annotation definition).
1320 * @param[in] name Attribute name.
1321 * @param[in] name_len Length of @p name, must be set correctly.
1322 * @return compiled YANG extension instance on success.
1323 */
1324static struct lysc_ext_instance *
1325lyd_get_meta_annotation(const struct lys_module *mod, const char *name, size_t name_len)
1326{
1327 LY_ARRAY_COUNT_TYPE u;
1328 struct lyplg_ext *plugin;
1329
1330 if (!mod) {
1331 return NULL;
1332 }
1333
1334 LY_ARRAY_FOR(mod->compiled->exts, u) {
1335 plugin = mod->compiled->exts[u].def->plugin;
1336 if (plugin && !strncmp(plugin->id, "ly2 metadata", 12) &&
1337 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
1338 return &mod->compiled->exts[u];
1339 }
1340 }
1341
1342 return NULL;
1343}
1344
Radek Krejci1798aae2020-07-14 13:26:06 +02001345LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +01001346lyd_create_meta(struct lyd_node *parent, struct lyd_meta **meta, const struct lys_module *mod, const char *name,
stewegd4cde642024-02-21 08:34:16 +01001347 size_t name_len, const char *value, size_t value_len, ly_bool is_utf8, ly_bool store_only, ly_bool *dynamic,
1348 LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node, ly_bool clear_dflt,
1349 ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +01001350{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001351 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +01001352 struct lysc_ext_instance *ant = NULL;
Michal Vasko193dacd2022-10-13 08:43:05 +02001353 const struct lysc_type *ant_type;
Michal Vasko9f96a052020-03-10 09:41:45 +01001354 struct lyd_meta *mt, *last;
Michal Vasko90932a92020-02-12 14:33:03 +01001355
Michal Vasko9f96a052020-03-10 09:41:45 +01001356 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +01001357
aPiecek0b1df642023-11-06 16:15:33 +01001358 ant = lyd_get_meta_annotation(mod, name, name_len);
Michal Vasko90932a92020-02-12 14:33:03 +01001359 if (!ant) {
1360 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001361 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Radek Krejci422afb12021-03-04 16:38:16 +01001362 mod->name, (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001363 ret = LY_EINVAL;
1364 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +01001365 }
1366
Michal Vasko9f96a052020-03-10 09:41:45 +01001367 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001368 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +01001369 mt->parent = parent;
1370 mt->annotation = ant;
Michal Vaskofbd037c2022-11-08 10:34:20 +01001371 lyplg_ext_get_storage(ant, LY_STMT_TYPE, sizeof ant_type, (const void **)&ant_type);
stewegd4cde642024-02-21 08:34:16 +01001372 ret = lyd_value_store(mod->ctx, &mt->value, ant_type, value, value_len, is_utf8, store_only, dynamic, format, prefix_data, hints,
Michal Vaskoddd76592022-01-17 13:34:48 +01001373 ctx_node, incomplete);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001374 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
1375 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
1376 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +01001377
Michal Vasko6f4cbb62020-02-28 11:15:47 +01001378 /* insert as the last attribute */
1379 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01001380 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01001381 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001382 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01001383 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01001384 }
1385
Michal Vasko9f96a052020-03-10 09:41:45 +01001386 if (meta) {
1387 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01001388 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001389
1390cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +01001391 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01001392}
1393
Michal Vaskoa5da3292020-08-12 13:10:50 +02001394void
1395lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
1396{
1397 struct lyd_attr *last, *iter;
1398 struct lyd_node_opaq *opaq;
1399
1400 assert(parent && !parent->schema);
1401
1402 if (!attr) {
1403 return;
1404 }
1405
1406 opaq = (struct lyd_node_opaq *)parent;
1407 for (iter = attr; iter; iter = iter->next) {
1408 iter->parent = opaq;
1409 }
1410
1411 /* insert as the last attribute */
1412 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001413 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02001414 last->next = attr;
1415 } else {
1416 opaq->attr = attr;
1417 }
1418}
1419
Michal Vasko52927e22020-03-16 17:26:14 +01001420LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001421lyd_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 +01001422 const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
Radek Krejci8df109d2021-04-23 12:19:08 +02001423 size_t value_len, ly_bool *dynamic, LY_VALUE_FORMAT format, void *val_prefix_data, uint32_t hints)
Michal Vasko52927e22020-03-16 17:26:14 +01001424{
Radek Krejci011e4aa2020-09-04 15:22:31 +02001425 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001426 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01001427
1428 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001429 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01001430
Michal Vasko2a3722d2021-06-16 11:52:39 +02001431 if (!value_len && (!dynamic || !*dynamic)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001432 value = "";
1433 }
1434
1435 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001436 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02001437
Michal Vaskoad92b672020-11-12 13:11:31 +01001438 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001439 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001440 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001441 }
1442 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001443 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001444 }
1445
Michal Vasko52927e22020-03-16 17:26:14 +01001446 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001447 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
1448 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001449 *dynamic = 0;
1450 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001451 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001452 }
Michal Vasko501af032020-11-11 20:27:44 +01001453 at->format = format;
1454 at->val_prefix_data = val_prefix_data;
1455 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01001456
1457 /* insert as the last attribute */
1458 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02001459 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01001460 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001461 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01001462 last->next = at;
1463 }
1464
Radek Krejci011e4aa2020-09-04 15:22:31 +02001465finish:
1466 if (ret) {
1467 lyd_free_attr_single(ctx, at);
1468 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01001469 *attr = at;
1470 }
1471 return LY_SUCCESS;
1472}
1473
aPiecek2f63f952021-03-30 12:22:18 +02001474/**
1475 * @brief Check the equality of the two schemas from different contexts.
1476 *
1477 * @param schema1 of first node.
1478 * @param schema2 of second node.
1479 * @return 1 if the schemas are equal otherwise 0.
1480 */
1481static ly_bool
1482lyd_compare_schema_equal(const struct lysc_node *schema1, const struct lysc_node *schema2)
1483{
1484 if (!schema1 && !schema2) {
1485 return 1;
1486 } else if (!schema1 || !schema2) {
1487 return 0;
1488 }
1489
1490 assert(schema1->module->ctx != schema2->module->ctx);
1491
1492 if (schema1->nodetype != schema2->nodetype) {
1493 return 0;
1494 }
1495
1496 if (strcmp(schema1->name, schema2->name)) {
1497 return 0;
1498 }
1499
1500 if (strcmp(schema1->module->name, schema2->module->name)) {
1501 return 0;
1502 }
1503
aPiecek2f63f952021-03-30 12:22:18 +02001504 return 1;
1505}
1506
1507/**
1508 * @brief Check the equality of the schemas for all parent nodes.
1509 *
1510 * Both nodes must be from different contexts.
1511 *
1512 * @param node1 Data of first node.
1513 * @param node2 Data of second node.
1514 * @return 1 if the all related parental schemas are equal otherwise 0.
1515 */
1516static ly_bool
1517lyd_compare_schema_parents_equal(const struct lyd_node *node1, const struct lyd_node *node2)
1518{
1519 const struct lysc_node *parent1, *parent2;
1520
1521 assert(node1 && node2);
1522
1523 for (parent1 = node1->schema->parent, parent2 = node2->schema->parent;
1524 parent1 && parent2;
1525 parent1 = parent1->parent, parent2 = parent2->parent) {
1526 if (!lyd_compare_schema_equal(parent1, parent2)) {
1527 return 0;
1528 }
1529 }
1530
1531 if (parent1 || parent2) {
1532 return 0;
1533 }
1534
1535 return 1;
1536}
1537
1538/**
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001539 * @brief Compare 2 nodes values including opaque node values.
1540 *
1541 * @param[in] node1 First node to compare.
1542 * @param[in] node2 Second node to compare.
1543 * @return LY_SUCCESS if equal.
1544 * @return LY_ENOT if not equal.
1545 * @return LY_ERR on error.
1546 */
1547static LY_ERR
1548lyd_compare_single_value(const struct lyd_node *node1, const struct lyd_node *node2)
1549{
1550 const struct lyd_node_opaq *opaq1 = NULL, *opaq2 = NULL;
1551 const char *val1, *val2, *col;
1552 const struct lys_module *mod;
1553 char *val_dyn = NULL;
1554 LY_ERR rc = LY_SUCCESS;
1555
1556 if (!node1->schema) {
1557 opaq1 = (struct lyd_node_opaq *)node1;
1558 }
1559 if (!node2->schema) {
1560 opaq2 = (struct lyd_node_opaq *)node2;
1561 }
1562
1563 if (opaq1 && opaq2 && (opaq1->format == LY_VALUE_XML) && (opaq2->format == LY_VALUE_XML)) {
1564 /* opaque XML and opaque XML node */
1565 if (lyxml_value_compare(LYD_CTX(node1), opaq1->value, opaq1->val_prefix_data, LYD_CTX(node2), opaq2->value,
1566 opaq2->val_prefix_data)) {
1567 return LY_ENOT;
1568 }
1569 return LY_SUCCESS;
1570 }
1571
1572 /* get their values */
1573 if (opaq1 && ((opaq1->format == LY_VALUE_XML) || (opaq1->format == LY_VALUE_STR_NS)) && (col = strchr(opaq1->value, ':'))) {
1574 /* XML value with a prefix, try to transform it into a JSON (canonical) value */
1575 mod = ly_resolve_prefix(LYD_CTX(node1), opaq1->value, col - opaq1->value, opaq1->format, opaq1->val_prefix_data);
1576 if (!mod) {
1577 /* unable to compare */
1578 return LY_ENOT;
1579 }
1580
1581 if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
1582 LOGMEM(LYD_CTX(node1));
1583 return LY_EMEM;
1584 }
1585 val1 = val_dyn;
1586 } else {
1587 val1 = lyd_get_value(node1);
1588 }
1589 if (opaq2 && ((opaq2->format == LY_VALUE_XML) || (opaq2->format == LY_VALUE_STR_NS)) && (col = strchr(opaq2->value, ':'))) {
1590 mod = ly_resolve_prefix(LYD_CTX(node2), opaq2->value, col - opaq2->value, opaq2->format, opaq2->val_prefix_data);
1591 if (!mod) {
1592 return LY_ENOT;
1593 }
1594
1595 assert(!val_dyn);
1596 if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
1597 LOGMEM(LYD_CTX(node2));
1598 return LY_EMEM;
1599 }
1600 val2 = val_dyn;
1601 } else {
1602 val2 = lyd_get_value(node2);
1603 }
1604
1605 /* compare values */
1606 if (strcmp(val1, val2)) {
1607 rc = LY_ENOT;
1608 }
1609
1610 free(val_dyn);
1611 return rc;
1612}
1613
1614/**
Michal Vaskof277d362023-04-24 09:08:31 +02001615 * @brief Compare 2 data nodes if they are equivalent regarding the schema tree.
1616 *
1617 * Works correctly even if @p node1 and @p node2 have different contexts.
1618 *
1619 * @param[in] node1 The first node to compare.
1620 * @param[in] node2 The second node to compare.
1621 * @param[in] options Various @ref datacompareoptions.
1622 * @param[in] parental_schemas_checked Flag set if parent schemas were checked for match.
1623 * @return LY_SUCCESS if the nodes are equivalent.
1624 * @return LY_ENOT if the nodes are not equivalent.
aPiecek2f63f952021-03-30 12:22:18 +02001625 */
1626static LY_ERR
Michal Vaskof277d362023-04-24 09:08:31 +02001627lyd_compare_single_schema(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options,
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001628 ly_bool parental_schemas_checked)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001629{
aPiecek2f63f952021-03-30 12:22:18 +02001630 if (LYD_CTX(node1) == LYD_CTX(node2)) {
1631 /* same contexts */
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001632 if (options & LYD_COMPARE_OPAQ) {
1633 if (lyd_node_schema(node1) != lyd_node_schema(node2)) {
1634 return LY_ENOT;
1635 }
1636 } else {
1637 if (node1->schema != node2->schema) {
1638 return LY_ENOT;
1639 }
aPiecek2f63f952021-03-30 12:22:18 +02001640 }
1641 } else {
1642 /* different contexts */
1643 if (!lyd_compare_schema_equal(node1->schema, node2->schema)) {
1644 return LY_ENOT;
1645 }
1646 if (!parental_schemas_checked) {
1647 if (!lyd_compare_schema_parents_equal(node1, node2)) {
1648 return LY_ENOT;
1649 }
1650 parental_schemas_checked = 1;
1651 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001652 }
1653
Michal Vaskof277d362023-04-24 09:08:31 +02001654 return LY_SUCCESS;
1655}
1656
1657/**
1658 * @brief Compare 2 data nodes if they are equivalent regarding the data they contain.
1659 *
1660 * Works correctly even if @p node1 and @p node2 have different contexts.
1661 *
1662 * @param[in] node1 The first node to compare.
1663 * @param[in] node2 The second node to compare.
1664 * @param[in] options Various @ref datacompareoptions.
1665 * @return LY_SUCCESS if the nodes are equivalent.
1666 * @return LY_ENOT if the nodes are not equivalent.
1667 */
1668static LY_ERR
1669lyd_compare_single_data(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
1670{
1671 const struct lyd_node *iter1, *iter2;
1672 struct lyd_node_any *any1, *any2;
1673 int len1, len2;
1674 LY_ERR r;
1675
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001676 if (!(options & LYD_COMPARE_OPAQ) && (node1->hash != node2->hash)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001677 return LY_ENOT;
1678 }
aPiecek2f63f952021-03-30 12:22:18 +02001679 /* equal hashes do not mean equal nodes, they can be just in collision so the nodes must be checked explicitly */
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001680
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001681 if (!node1->schema || !node2->schema) {
1682 if (!(options & LYD_COMPARE_OPAQ) && ((node1->schema && !node2->schema) || (!node1->schema && node2->schema))) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001683 return LY_ENOT;
1684 }
Michal Vasko7b0500d2023-03-20 15:22:46 +01001685 if ((!node1->schema && !node2->schema) || (node1->schema && (node1->schema->nodetype & LYD_NODE_TERM)) ||
1686 (node2->schema && (node2->schema->nodetype & LYD_NODE_TERM))) {
1687 /* compare values only if there are any to compare */
1688 if ((r = lyd_compare_single_value(node1, node2))) {
1689 return r;
1690 }
Michal Vasko52927e22020-03-16 17:26:14 +01001691 }
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001692
Michal Vasko52927e22020-03-16 17:26:14 +01001693 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vaskof277d362023-04-24 09:08:31 +02001694 return lyd_compare_siblings_(lyd_child(node1), lyd_child(node2), options, 1);
Michal Vasko52927e22020-03-16 17:26:14 +01001695 }
1696 return LY_SUCCESS;
1697 } else {
1698 switch (node1->schema->nodetype) {
1699 case LYS_LEAF:
1700 case LYS_LEAFLIST:
1701 if (options & LYD_COMPARE_DEFAULTS) {
1702 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
1703 return LY_ENOT;
1704 }
1705 }
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001706 if ((r = lyd_compare_single_value(node1, node2))) {
1707 return r;
aPiecek2f63f952021-03-30 12:22:18 +02001708 }
1709
aPiecek2f63f952021-03-30 12:22:18 +02001710 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001711 case LYS_CONTAINER:
Michal Vaskoc8187dc2022-05-13 12:26:40 +02001712 case LYS_RPC:
1713 case LYS_ACTION:
1714 case LYS_NOTIF:
Michal Vaskoa38adc72023-04-25 10:14:28 +02001715 /* implicit container is always equal to a container with non-default descendants */
Michal Vasko52927e22020-03-16 17:26:14 +01001716 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vaskof277d362023-04-24 09:08:31 +02001717 return lyd_compare_siblings_(lyd_child(node1), lyd_child(node2), options, 1);
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001718 }
1719 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001720 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01001721 iter1 = lyd_child(node1);
1722 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01001723
Michal Vaskoee9b9482023-06-19 13:17:48 +02001724 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vaskof277d362023-04-24 09:08:31 +02001725 return lyd_compare_siblings_(iter1, iter2, options, 1);
Michal Vaskoee9b9482023-06-19 13:17:48 +02001726 } else if (node1->schema->flags & LYS_KEYLESS) {
1727 /* always equal */
1728 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001729 }
Michal Vaskoee9b9482023-06-19 13:17:48 +02001730
1731 /* lists with keys, their equivalence is based on their keys */
1732 for (const struct lysc_node *key = lysc_node_child(node1->schema);
1733 key && (key->flags & LYS_KEY);
1734 key = key->next) {
1735 if (!iter1 || !iter2) {
1736 return (iter1 == iter2) ? LY_SUCCESS : LY_ENOT;
1737 }
1738 r = lyd_compare_single_schema(iter1, iter2, options, 1);
1739 LY_CHECK_RET(r);
1740 r = lyd_compare_single_data(iter1, iter2, options);
1741 LY_CHECK_RET(r);
1742
1743 iter1 = iter1->next;
1744 iter2 = iter2->next;
1745 }
1746
1747 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001748 case LYS_ANYXML:
1749 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02001750 any1 = (struct lyd_node_any *)node1;
1751 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01001752
1753 if (any1->value_type != any2->value_type) {
1754 return LY_ENOT;
1755 }
1756 switch (any1->value_type) {
1757 case LYD_ANYDATA_DATATREE:
Michal Vaskof277d362023-04-24 09:08:31 +02001758 return lyd_compare_siblings_(any1->value.tree, any2->value.tree, options, 1);
Michal Vasko52927e22020-03-16 17:26:14 +01001759 case LYD_ANYDATA_STRING:
1760 case LYD_ANYDATA_XML:
1761 case LYD_ANYDATA_JSON:
Michal Vasko3b4ec412022-09-22 15:24:14 +02001762 if ((!any1->value.str && any2->value.str) || (any1->value.str && !any2->value.str)) {
1763 return LY_ENOT;
1764 } else if (!any1->value.str && !any2->value.str) {
1765 return LY_SUCCESS;
1766 }
Michal Vasko52927e22020-03-16 17:26:14 +01001767 len1 = strlen(any1->value.str);
1768 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02001769 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001770 return LY_ENOT;
1771 }
1772 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001773 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02001774 len1 = lyd_lyb_data_length(any1->value.mem);
1775 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko2b97d472022-08-17 09:29:03 +02001776 if ((len1 == -1) || (len2 == -1) || (len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001777 return LY_ENOT;
1778 }
1779 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001780 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001781 }
1782 }
1783
Michal Vaskob7be7a82020-08-20 09:09:04 +02001784 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001785 return LY_EINT;
1786}
Radek Krejci22ebdba2019-07-25 13:59:43 +02001787
Michal Vaskof277d362023-04-24 09:08:31 +02001788/**
1789 * @brief Compare all siblings at a node level.
1790 *
1791 * @param[in] node1 First sibling list.
1792 * @param[in] node2 Second sibling list.
1793 * @param[in] options Various @ref datacompareoptions.
1794 * @param[in] parental_schemas_checked Flag set if parent schemas were checked for match.
1795 * @return LY_SUCCESS if equal.
1796 * @return LY_ENOT if not equal.
1797 * @return LY_ERR on error.
1798 */
1799static LY_ERR
1800lyd_compare_siblings_(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options,
1801 ly_bool parental_schemas_checked)
1802{
1803 LY_ERR r;
1804 const struct lyd_node *iter2;
1805
1806 while (node1 && node2) {
1807 /* schema match */
1808 r = lyd_compare_single_schema(node1, node2, options, parental_schemas_checked);
1809 LY_CHECK_RET(r);
1810
1811 if (node1->schema && (((node1->schema->nodetype == LYS_LIST) && !(node1->schema->flags & LYS_KEYLESS)) ||
1812 ((node1->schema->nodetype == LYS_LEAFLIST) && (node1->schema->flags & LYS_CONFIG_W))) &&
1813 (node1->schema->flags & LYS_ORDBY_SYSTEM)) {
1814 /* find a matching instance in case they are ordered differently */
1815 r = lyd_find_sibling_first(node2, node1, (struct lyd_node **)&iter2);
1816 if (r == LY_ENOTFOUND) {
1817 /* no matching instance, data not equal */
1818 r = LY_ENOT;
1819 }
1820 LY_CHECK_RET(r);
1821 } else {
1822 /* compare with the current node */
1823 iter2 = node2;
1824 }
1825
1826 /* data match */
1827 r = lyd_compare_single_data(node1, iter2, options | LYD_COMPARE_FULL_RECURSION);
1828 LY_CHECK_RET(r);
1829
1830 node1 = node1->next;
1831 node2 = node2->next;
1832 }
1833
1834 return (node1 || node2) ? LY_ENOT : LY_SUCCESS;
1835}
1836
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001837LIBYANG_API_DEF LY_ERR
aPiecek2f63f952021-03-30 12:22:18 +02001838lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
1839{
Michal Vaskof277d362023-04-24 09:08:31 +02001840 LY_ERR r;
1841
1842 if (!node1 || !node2) {
1843 return (node1 == node2) ? LY_SUCCESS : LY_ENOT;
1844 }
1845
1846 /* schema match */
1847 if ((r = lyd_compare_single_schema(node1, node2, options, 0))) {
1848 return r;
1849 }
1850
1851 /* data match */
1852 return lyd_compare_single_data(node1, node2, options);
aPiecek2f63f952021-03-30 12:22:18 +02001853}
1854
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001855LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001856lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02001857{
Michal Vaskof277d362023-04-24 09:08:31 +02001858 return lyd_compare_siblings_(node1, node2, options, 0);
Michal Vasko8f359bf2020-07-28 10:41:15 +02001859}
1860
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001861LIBYANG_API_DEF LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02001862lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
1863{
aPiecek0a6705b2023-11-14 14:20:58 +01001864 const struct ly_ctx *ctx;
1865
Michal Vasko21725742020-06-29 11:49:25 +02001866 if (!meta1 || !meta2) {
1867 if (meta1 == meta2) {
1868 return LY_SUCCESS;
1869 } else {
1870 return LY_ENOT;
1871 }
1872 }
1873
aPiecek0a6705b2023-11-14 14:20:58 +01001874 ctx = meta1->annotation->module->ctx;
1875 if ((ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02001876 return LY_ENOT;
1877 }
1878
aPiecek0a6705b2023-11-14 14:20:58 +01001879 return meta1->value.realtype->plugin->compare(ctx, &meta1->value, &meta2->value);
Michal Vasko21725742020-06-29 11:49:25 +02001880}
1881
Radek Krejci22ebdba2019-07-25 13:59:43 +02001882/**
Michal Vasko9cf62422021-07-01 13:29:32 +02001883 * @brief Create a copy of the attribute.
1884 *
1885 * @param[in] attr Attribute to copy.
1886 * @param[in] node Opaque where to append the new attribute.
1887 * @param[out] dup Optional created attribute copy.
1888 * @return LY_ERR value.
1889 */
1890static LY_ERR
1891lyd_dup_attr_single(const struct lyd_attr *attr, struct lyd_node *node, struct lyd_attr **dup)
1892{
1893 LY_ERR ret = LY_SUCCESS;
1894 struct lyd_attr *a, *last;
1895 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)node;
1896
1897 LY_CHECK_ARG_RET(NULL, attr, node, !node->schema, LY_EINVAL);
1898
1899 /* create a copy */
1900 a = calloc(1, sizeof *attr);
1901 LY_CHECK_ERR_RET(!a, LOGMEM(LYD_CTX(node)), LY_EMEM);
1902
1903 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.name, 0, &a->name.name), finish);
1904 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.prefix, 0, &a->name.prefix), finish);
1905 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.module_ns, 0, &a->name.module_ns), finish);
1906 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->value, 0, &a->value), finish);
1907 a->hints = attr->hints;
1908 a->format = attr->format;
1909 if (attr->val_prefix_data) {
1910 ret = ly_dup_prefix_data(LYD_CTX(node), attr->format, attr->val_prefix_data, &a->val_prefix_data);
1911 LY_CHECK_GOTO(ret, finish);
1912 }
1913
1914 /* insert as the last attribute */
1915 a->parent = opaq;
1916 if (opaq->attr) {
1917 for (last = opaq->attr; last->next; last = last->next) {}
1918 last->next = a;
1919 } else {
1920 opaq->attr = a;
1921 }
1922
1923finish:
1924 if (ret) {
1925 lyd_free_attr_single(LYD_CTX(node), a);
1926 } else if (dup) {
1927 *dup = a;
1928 }
1929 return LY_SUCCESS;
1930}
1931
1932/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001933 * @brief Find @p schema equivalent in @p trg_ctx.
1934 *
1935 * @param[in] schema Schema node to find.
1936 * @param[in] trg_ctx Target context to search in.
1937 * @param[in] parent Data parent of @p schema, if any.
Michal Vaskoaf3df492022-12-02 14:03:52 +01001938 * @param[in] log Whether to log directly.
Michal Vaskoddd76592022-01-17 13:34:48 +01001939 * @param[out] trg_schema Found schema from @p trg_ctx to use.
1940 * @return LY_RRR value.
1941 */
1942static LY_ERR
Michal Vaskoaf3df492022-12-02 14:03:52 +01001943lyd_find_schema_ctx(const struct lysc_node *schema, const struct ly_ctx *trg_ctx, const struct lyd_node *parent,
1944 ly_bool log, const struct lysc_node **trg_schema)
Michal Vaskoddd76592022-01-17 13:34:48 +01001945{
Michal Vasko9beceb82022-04-05 12:14:15 +02001946 const struct lysc_node *src_parent = NULL, *trg_parent = NULL, *sp, *tp;
1947 const struct lys_module *trg_mod = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +01001948 char *path;
1949
1950 if (!schema) {
1951 /* opaque node */
1952 *trg_schema = NULL;
1953 return LY_SUCCESS;
1954 }
1955
Michal Vasko9beceb82022-04-05 12:14:15 +02001956 if (lysc_data_parent(schema) && parent && parent->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001957 /* start from schema parent */
Michal Vasko9beceb82022-04-05 12:14:15 +02001958 trg_parent = parent->schema;
1959 src_parent = lysc_data_parent(schema);
1960 }
1961
1962 do {
1963 /* find the next parent */
1964 sp = schema;
Michal Vaskob6808202022-12-02 14:04:23 +01001965 while (lysc_data_parent(sp) != src_parent) {
1966 sp = lysc_data_parent(sp);
Michal Vasko9beceb82022-04-05 12:14:15 +02001967 }
1968 src_parent = sp;
1969
1970 if (!src_parent->parent) {
1971 /* find the module first */
1972 trg_mod = ly_ctx_get_module_implemented(trg_ctx, src_parent->module->name);
1973 if (!trg_mod) {
Michal Vaskoaf3df492022-12-02 14:03:52 +01001974 if (log) {
1975 LOGERR(trg_ctx, LY_ENOTFOUND, "Module \"%s\" not present/implemented in the target context.",
1976 src_parent->module->name);
1977 }
Michal Vasko9beceb82022-04-05 12:14:15 +02001978 return LY_ENOTFOUND;
1979 }
1980 }
1981
1982 /* find the next parent */
1983 assert(trg_parent || trg_mod);
1984 tp = NULL;
1985 while ((tp = lys_getnext(tp, trg_parent, trg_mod ? trg_mod->compiled : NULL, 0))) {
1986 if (!strcmp(tp->name, src_parent->name) && !strcmp(tp->module->name, src_parent->module->name)) {
1987 break;
1988 }
1989 }
1990 if (!tp) {
1991 /* schema node not found */
Michal Vaskoaf3df492022-12-02 14:03:52 +01001992 if (log) {
1993 path = lysc_path(src_parent, LYSC_PATH_LOG, NULL, 0);
1994 LOGERR(trg_ctx, LY_ENOTFOUND, "Schema node \"%s\" not found in the target context.", path);
1995 free(path);
1996 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001997 return LY_ENOTFOUND;
1998 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001999
Michal Vasko9beceb82022-04-05 12:14:15 +02002000 trg_parent = tp;
2001 } while (schema != src_parent);
Michal Vaskoddd76592022-01-17 13:34:48 +01002002
Michal Vasko9beceb82022-04-05 12:14:15 +02002003 /* success */
2004 *trg_schema = trg_parent;
2005 return LY_SUCCESS;
Michal Vaskoddd76592022-01-17 13:34:48 +01002006}
2007
2008/**
Michal Vasko52927e22020-03-16 17:26:14 +01002009 * @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 +02002010 *
aPiecek55653c92023-11-09 13:43:19 +01002011 * Ignores ::LYD_DUP_WITH_PARENTS which is supposed to be handled by lyd_dup().
Radek Krejcif8b95172020-05-15 14:51:06 +02002012 *
Michal Vaskoddd76592022-01-17 13:34:48 +01002013 * @param[in] node Node to duplicate.
2014 * @param[in] trg_ctx Target context for duplicated nodes.
Radek Krejcif8b95172020-05-15 14:51:06 +02002015 * @param[in] parent Parent to insert into, NULL for top-level sibling.
aPiecek1462ab12024-02-07 09:13:29 +01002016 * @param[in] insert_order Options for inserting (sorting) duplicated node, @ref insertorder.
Radek Krejcif8b95172020-05-15 14:51:06 +02002017 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
2018 * @param[in] options Bitmask of options flags, see @ref dupoptions.
Michal Vaskoddd76592022-01-17 13:34:48 +01002019 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it to @p parent / @p first).
2020 * @return LY_ERR value.
Radek Krejci22ebdba2019-07-25 13:59:43 +02002021 */
Michal Vasko52927e22020-03-16 17:26:14 +01002022static LY_ERR
aPiecek1462ab12024-02-07 09:13:29 +01002023lyd_dup_r(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent, uint32_t insert_order,
Michal Vaskoddd76592022-01-17 13:34:48 +01002024 struct lyd_node **first, uint32_t options, struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002025{
Michal Vasko52927e22020-03-16 17:26:14 +01002026 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002027 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02002028 struct lyd_meta *meta;
Michal Vasko9cf62422021-07-01 13:29:32 +02002029 struct lyd_attr *attr;
Michal Vasko61551fa2020-07-09 15:45:45 +02002030 struct lyd_node_any *any;
Michal Vaskoddd76592022-01-17 13:34:48 +01002031 const struct lysc_type *type;
2032 const char *val_can;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002033
Michal Vasko52927e22020-03-16 17:26:14 +01002034 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002035
Michal Vasko19175b62022-04-01 09:17:07 +02002036 if (node->flags & LYD_EXT) {
Michal Vasko53ac4dd2022-06-07 10:56:08 +02002037 if (options & LYD_DUP_NO_EXT) {
2038 /* no not duplicate this subtree */
2039 return LY_SUCCESS;
2040 }
2041
Michal Vasko19175b62022-04-01 09:17:07 +02002042 /* we need to use the same context */
2043 trg_ctx = LYD_CTX(node);
2044 }
2045
Michal Vasko52927e22020-03-16 17:26:14 +01002046 if (!node->schema) {
2047 dup = calloc(1, sizeof(struct lyd_node_opaq));
Michal Vaskoddd76592022-01-17 13:34:48 +01002048 ((struct lyd_node_opaq *)dup)->ctx = trg_ctx;
Michal Vasko52927e22020-03-16 17:26:14 +01002049 } else {
2050 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01002051 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01002052 case LYS_ACTION:
2053 case LYS_NOTIF:
2054 case LYS_CONTAINER:
2055 case LYS_LIST:
2056 dup = calloc(1, sizeof(struct lyd_node_inner));
2057 break;
2058 case LYS_LEAF:
2059 case LYS_LEAFLIST:
2060 dup = calloc(1, sizeof(struct lyd_node_term));
2061 break;
2062 case LYS_ANYDATA:
2063 case LYS_ANYXML:
2064 dup = calloc(1, sizeof(struct lyd_node_any));
2065 break;
2066 default:
Michal Vaskoddd76592022-01-17 13:34:48 +01002067 LOGINT(trg_ctx);
Michal Vasko52927e22020-03-16 17:26:14 +01002068 ret = LY_EINT;
2069 goto error;
2070 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002071 }
Michal Vaskoddd76592022-01-17 13:34:48 +01002072 LY_CHECK_ERR_GOTO(!dup, LOGMEM(trg_ctx); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002073
Michal Vaskof6df0a02020-06-16 13:08:34 +02002074 if (options & LYD_DUP_WITH_FLAGS) {
2075 dup->flags = node->flags;
2076 } else {
Michal Vasko19175b62022-04-01 09:17:07 +02002077 dup->flags = (node->flags & (LYD_DEFAULT | LYD_EXT)) | LYD_NEW;
Michal Vaskof6df0a02020-06-16 13:08:34 +02002078 }
Igor Ryzhov9e7af662023-10-31 13:27:56 +02002079 if (options & LYD_DUP_WITH_PRIV) {
2080 dup->priv = node->priv;
2081 }
Michal Vaskoddd76592022-01-17 13:34:48 +01002082 if (trg_ctx == LYD_CTX(node)) {
2083 dup->schema = node->schema;
2084 } else {
Michal Vaskoaf3df492022-12-02 14:03:52 +01002085 ret = lyd_find_schema_ctx(node->schema, trg_ctx, parent, 1, &dup->schema);
Michal Vasko27f536f2022-04-01 09:17:30 +02002086 if (ret) {
2087 /* has no schema but is not an opaque node */
2088 free(dup);
2089 dup = NULL;
2090 goto error;
2091 }
Michal Vaskoddd76592022-01-17 13:34:48 +01002092 }
Michal Vasko52927e22020-03-16 17:26:14 +01002093 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002094
Michal Vasko9cf62422021-07-01 13:29:32 +02002095 /* duplicate metadata/attributes */
Michal Vasko25a32822020-07-09 15:48:22 +02002096 if (!(options & LYD_DUP_NO_META)) {
Michal Vasko9cf62422021-07-01 13:29:32 +02002097 if (!node->schema) {
2098 LY_LIST_FOR(((struct lyd_node_opaq *)node)->attr, attr) {
2099 LY_CHECK_GOTO(ret = lyd_dup_attr_single(attr, dup, NULL), error);
2100 }
2101 } else {
2102 LY_LIST_FOR(node->meta, meta) {
aPiecek41680342023-11-08 10:19:44 +01002103 LY_CHECK_GOTO(ret = lyd_dup_meta_single_to_ctx(trg_ctx, meta, dup, NULL), error);
Michal Vasko9cf62422021-07-01 13:29:32 +02002104 }
Michal Vasko25a32822020-07-09 15:48:22 +02002105 }
2106 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02002107
2108 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01002109 if (!dup->schema) {
2110 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
2111 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
2112 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002113
2114 if (options & LYD_DUP_RECURSIVE) {
2115 /* duplicate all the children */
2116 LY_LIST_FOR(orig->child, child) {
aPiecek1462ab12024-02-07 09:13:29 +01002117 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, LYD_INSERT_NODE_LAST, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01002118 }
2119 }
Michal Vaskoddd76592022-01-17 13:34:48 +01002120 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.name, 0, &opaq->name.name), error);
2121 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.prefix, 0, &opaq->name.prefix), error);
2122 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.module_ns, 0, &opaq->name.module_ns), error);
2123 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->value, 0, &opaq->value), error);
Michal Vasko9cf62422021-07-01 13:29:32 +02002124 opaq->hints = orig->hints;
2125 opaq->format = orig->format;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002126 if (orig->val_prefix_data) {
Michal Vaskoddd76592022-01-17 13:34:48 +01002127 ret = ly_dup_prefix_data(trg_ctx, opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01002128 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01002129 }
Michal Vasko52927e22020-03-16 17:26:14 +01002130 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
2131 struct lyd_node_term *term = (struct lyd_node_term *)dup;
2132 struct lyd_node_term *orig = (struct lyd_node_term *)node;
2133
2134 term->hash = orig->hash;
Michal Vaskoddd76592022-01-17 13:34:48 +01002135 if (trg_ctx == LYD_CTX(node)) {
2136 ret = orig->value.realtype->plugin->duplicate(trg_ctx, &orig->value, &term->value);
2137 LY_CHECK_ERR_GOTO(ret, LOGERR(trg_ctx, ret, "Value duplication failed."), error);
2138 } else {
2139 /* store canonical value in the target context */
2140 val_can = lyd_get_value(node);
2141 type = ((struct lysc_node_leaf *)term->schema)->type;
stewegd4cde642024-02-21 08:34:16 +01002142 ret = lyd_value_store(trg_ctx, &term->value, type, val_can, strlen(val_can), 1, 1, NULL, LY_VALUE_CANON, NULL,
Michal Vaskoddd76592022-01-17 13:34:48 +01002143 LYD_HINT_DATA, term->schema, NULL);
2144 LY_CHECK_GOTO(ret, error);
2145 }
Michal Vasko52927e22020-03-16 17:26:14 +01002146 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
2147 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
2148 struct lyd_node *child;
2149
2150 if (options & LYD_DUP_RECURSIVE) {
Ondrej Kusnirik747486a2024-08-19 10:52:44 +02002151 /* create a hash table with the size of the previous hash table (duplicate) */
2152 if (orig->children_ht) {
2153 ((struct lyd_node_inner *)dup)->children_ht = lyht_new(orig->children_ht->size, sizeof(struct lyd_node *), lyd_hash_table_val_equal, NULL, 1);
2154 }
2155
Michal Vasko52927e22020-03-16 17:26:14 +01002156 /* duplicate all the children */
2157 LY_LIST_FOR(orig->child, child) {
aPiecek1462ab12024-02-07 09:13:29 +01002158 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, LYD_INSERT_NODE_LAST, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002159 }
Michal Vasko69730152020-10-09 16:30:07 +02002160 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002161 /* always duplicate keys of a list */
Michal Vasko9beceb82022-04-05 12:14:15 +02002162 for (child = orig->child; child && lysc_is_key(child->schema); child = child->next) {
aPiecek1462ab12024-02-07 09:13:29 +01002163 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, LYD_INSERT_NODE_LAST, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002164 }
2165 }
2166 lyd_hash(dup);
2167 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02002168 dup->hash = node->hash;
2169 any = (struct lyd_node_any *)node;
2170 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002171 }
2172
Michal Vasko52927e22020-03-16 17:26:14 +01002173 /* insert */
aPiecek1462ab12024-02-07 09:13:29 +01002174 lyd_insert_node(parent, first, dup, insert_order);
Michal Vasko52927e22020-03-16 17:26:14 +01002175
2176 if (dup_p) {
2177 *dup_p = dup;
2178 }
2179 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002180
2181error:
Michal Vasko52927e22020-03-16 17:26:14 +01002182 lyd_free_tree(dup);
2183 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002184}
2185
Michal Vasko29d674b2021-08-25 11:18:35 +02002186/**
2187 * @brief Get a parent node to connect duplicated subtree to.
2188 *
2189 * @param[in] node Node (subtree) to duplicate.
Michal Vaskoddd76592022-01-17 13:34:48 +01002190 * @param[in] trg_ctx Target context for duplicated nodes.
Michal Vasko29d674b2021-08-25 11:18:35 +02002191 * @param[in] parent Initial parent to connect to.
2192 * @param[in] options Bitmask of options flags, see @ref dupoptions.
2193 * @param[out] dup_parent First duplicated parent node, if any.
2194 * @param[out] local_parent Correct parent to directly connect duplicated @p node to.
2195 * @return LY_ERR value.
2196 */
Michal Vasko3a41dff2020-07-15 14:30:28 +02002197static LY_ERR
Michal Vasko58d89e92023-05-23 09:56:19 +02002198lyd_dup_get_local_parent(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent,
2199 uint32_t options, struct lyd_node **dup_parent, struct lyd_node **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02002200{
Michal Vasko58d89e92023-05-23 09:56:19 +02002201 const struct lyd_node *orig_parent;
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002202 struct lyd_node *iter = NULL;
Michal Vasko83522192022-07-20 08:07:34 +02002203 ly_bool repeat = 1, ext_parent = 0;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002204
2205 *dup_parent = NULL;
2206 *local_parent = NULL;
2207
Michal Vasko83522192022-07-20 08:07:34 +02002208 if (node->flags & LYD_EXT) {
2209 ext_parent = 1;
2210 }
Michal Vasko58d89e92023-05-23 09:56:19 +02002211 for (orig_parent = lyd_parent(node); repeat && orig_parent; orig_parent = lyd_parent(orig_parent)) {
Michal Vasko83522192022-07-20 08:07:34 +02002212 if (ext_parent) {
2213 /* use the standard context */
2214 trg_ctx = LYD_CTX(orig_parent);
2215 }
Michal Vasko13c5b212023-02-14 10:03:01 +01002216 if (parent && (LYD_CTX(parent) == LYD_CTX(orig_parent)) && (parent->schema == orig_parent->schema)) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002217 /* stop creating parents, connect what we have into the provided parent */
2218 iter = parent;
2219 repeat = 0;
Michal Vasko13c5b212023-02-14 10:03:01 +01002220 } else if (parent && (LYD_CTX(parent) != LYD_CTX(orig_parent)) &&
2221 lyd_compare_schema_equal(parent->schema, orig_parent->schema) &&
Michal Vasko58d89e92023-05-23 09:56:19 +02002222 lyd_compare_schema_parents_equal(parent, orig_parent)) {
Michal Vasko13c5b212023-02-14 10:03:01 +01002223 iter = parent;
2224 repeat = 0;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002225 } else {
2226 iter = NULL;
aPiecek1462ab12024-02-07 09:13:29 +01002227 LY_CHECK_RET(lyd_dup_r(orig_parent, trg_ctx, NULL, LYD_INSERT_NODE_DEFAULT, &iter, options, &iter));
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002228
2229 /* insert into the previous duplicated parent */
2230 if (*dup_parent) {
aPiecek1462ab12024-02-07 09:13:29 +01002231 lyd_insert_node(iter, NULL, *dup_parent, LYD_INSERT_NODE_DEFAULT);
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002232 }
2233
2234 /* update the last duplicated parent */
2235 *dup_parent = iter;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002236 }
Michal Vasko58d89e92023-05-23 09:56:19 +02002237
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002238 /* set the first parent */
Michal Vasko3a41dff2020-07-15 14:30:28 +02002239 if (!*local_parent) {
Michal Vasko58d89e92023-05-23 09:56:19 +02002240 *local_parent = iter;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002241 }
Michal Vasko58d89e92023-05-23 09:56:19 +02002242
Michal Vasko83522192022-07-20 08:07:34 +02002243 if (orig_parent->flags & LYD_EXT) {
2244 ext_parent = 1;
2245 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002246 }
2247
2248 if (repeat && parent) {
2249 /* given parent and created parents chain actually do not interconnect */
Michal Vasko58d89e92023-05-23 09:56:19 +02002250 LOGERR(trg_ctx, LY_EINVAL, "None of the duplicated node \"%s\" schema parents match the provided parent \"%s\".",
2251 LYD_NAME(node), LYD_NAME(parent));
Michal Vasko3a41dff2020-07-15 14:30:28 +02002252 return LY_EINVAL;
2253 }
2254
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002255 if (*dup_parent && parent) {
2256 /* last insert into a prevously-existing parent */
aPiecek1462ab12024-02-07 09:13:29 +01002257 lyd_insert_node(parent, NULL, *dup_parent, LYD_INSERT_NODE_DEFAULT);
Michal Vaskoeaef7c92023-10-17 10:06:15 +02002258 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002259 return LY_SUCCESS;
2260}
2261
2262static LY_ERR
Michal Vasko58d89e92023-05-23 09:56:19 +02002263lyd_dup(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent, uint32_t options,
aPieceka7a1de92024-02-12 14:07:12 +01002264 ly_bool nosiblings, struct lyd_node **dup_p)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002265{
2266 LY_ERR rc;
Michal Vasko9cd2be92024-09-06 13:29:47 +02002267 const struct lyd_node *orig; /* original node to be duplicated */
2268 struct lyd_node *first_dup = NULL; /* the first duplicated node, this is returned */
2269 struct lyd_node *top = NULL; /* the most higher created node */
2270 struct lyd_node *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
2271 struct lyd_node *dup = NULL; /* duplicate node */
2272 struct lyd_node *first_sibling = NULL; /* first sibling node */
2273 const struct lyd_node *first_llist = NULL; /* first duplicated (leaf-)list node, if any */
2274 uint32_t insert_order;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002275
Michal Vasko1feb9bb2022-07-20 08:44:07 +02002276 assert(node && trg_ctx);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002277
2278 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vaskoddd76592022-01-17 13:34:48 +01002279 LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, trg_ctx, parent, options & (LYD_DUP_WITH_FLAGS | LYD_DUP_NO_META),
Michal Vasko20909752021-05-18 16:13:38 +02002280 &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002281 } else {
2282 local_parent = parent;
2283 }
2284
Radek Krejci22ebdba2019-07-25 13:59:43 +02002285 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01002286 if (lysc_is_key(orig->schema)) {
2287 if (local_parent) {
2288 /* the key must already exist in the parent */
aPieceka7a1de92024-02-12 14:07:12 +01002289 rc = lyd_find_sibling_schema(lyd_child(local_parent), orig->schema, &dup);
Michal Vaskoddd76592022-01-17 13:34:48 +01002290 LY_CHECK_ERR_GOTO(rc, LOGINT(trg_ctx), error);
Michal Vasko35f4d772021-01-12 12:08:57 +01002291 } else {
2292 assert(!(options & LYD_DUP_WITH_PARENTS));
2293 /* duplicating a single key, okay, I suppose... */
aPieceka7a1de92024-02-12 14:07:12 +01002294 rc = lyd_dup_r(orig, trg_ctx, NULL, LYD_INSERT_NODE_DEFAULT, &first_sibling, options, &dup);
Michal Vasko35f4d772021-01-12 12:08:57 +01002295 LY_CHECK_GOTO(rc, error);
2296 }
2297 } else {
Michal Vasko9cd2be92024-09-06 13:29:47 +02002298 /* decide insert order */
2299 insert_order = (options & LYD_DUP_NO_LYDS) ? LYD_INSERT_NODE_LAST_BY_SCHEMA : LYD_INSERT_NODE_DEFAULT;
2300 if (first_llist) {
2301 if (orig->schema != first_llist->schema) {
2302 /* all the (leaf-)list instances duplicated */
2303 first_llist = NULL;
2304 } else {
2305 /* duplicating all the instances of a (leaf-)list, no need to change their order */
2306 insert_order = LYD_INSERT_NODE_LAST;
2307 }
2308 } else if (orig->schema && (orig->schema->nodetype & (LYS_LIST | LYS_LEAFLIST))) {
2309 /* duplicating the first (leaf-)list instance, duplicate the rest more efficiently */
2310 first_llist = orig;
2311 }
2312
2313 /* duplicate the node */
2314 rc = lyd_dup_r(orig, trg_ctx, local_parent, insert_order, &first_sibling, options, &dup);
Michal Vasko35f4d772021-01-12 12:08:57 +01002315 LY_CHECK_GOTO(rc, error);
Michal Vasko9cd2be92024-09-06 13:29:47 +02002316
2317 if (first_llist && dup->next) {
2318 /* orig was not the last node (because we are inserting into a parent with some previous instances),
2319 * we must check find the order */
2320 first_llist = NULL;
2321 }
Michal Vasko35f4d772021-01-12 12:08:57 +01002322 }
aPieceka7a1de92024-02-12 14:07:12 +01002323 first_dup = first_dup ? first_dup : dup;
2324
Michal Vasko9cd2be92024-09-06 13:29:47 +02002325 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02002326 break;
2327 }
2328 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002329
aPieceka7a1de92024-02-12 14:07:12 +01002330 if (dup_p) {
2331 *dup_p = first_dup;
Michal Vasko3a41dff2020-07-15 14:30:28 +02002332 }
2333 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002334
2335error:
2336 if (top) {
2337 lyd_free_tree(top);
aPieceka7a1de92024-02-12 14:07:12 +01002338 } else if (first_dup) {
2339 lyd_free_siblings(first_dup);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002340 } else {
aPieceka7a1de92024-02-12 14:07:12 +01002341 lyd_free_siblings(dup);
Radek Krejci22ebdba2019-07-25 13:59:43 +02002342 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02002343 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02002344}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002345
Michal Vasko1feb9bb2022-07-20 08:44:07 +02002346/**
2347 * @brief Check the context of node and parent when duplicating nodes.
2348 *
2349 * @param[in] node Node to duplicate.
2350 * @param[in] parent Parent of the duplicated node(s).
2351 * @return LY_ERR value.
2352 */
2353static LY_ERR
2354lyd_dup_ctx_check(const struct lyd_node *node, const struct lyd_node_inner *parent)
2355{
2356 const struct lyd_node *iter;
2357
2358 if (!node || !parent) {
2359 return LY_SUCCESS;
2360 }
2361
2362 if ((LYD_CTX(node) != LYD_CTX(parent))) {
2363 /* try to find top-level ext data parent */
2364 for (iter = node; iter && !(iter->flags & LYD_EXT); iter = lyd_parent(iter)) {}
2365
2366 if (!iter || !lyd_parent(iter) || (LYD_CTX(lyd_parent(iter)) != LYD_CTX(parent))) {
Michal Vaskoce55b462023-02-14 10:03:32 +01002367 LOGERR(LYD_CTX(node), LY_EINVAL, "Different contexts used in node duplication.");
Michal Vasko1feb9bb2022-07-20 08:44:07 +02002368 return LY_EINVAL;
2369 }
2370 }
2371
2372 return LY_SUCCESS;
2373}
2374
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002375LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002376lyd_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 +02002377{
Michal Vaskoddd76592022-01-17 13:34:48 +01002378 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02002379 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01002380
Michal Vasko58d89e92023-05-23 09:56:19 +02002381 return lyd_dup(node, LYD_CTX(node), (struct lyd_node *)parent, options, 1, dup);
Michal Vaskoddd76592022-01-17 13:34:48 +01002382}
2383
2384LIBYANG_API_DEF LY_ERR
2385lyd_dup_single_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
2386 uint32_t options, struct lyd_node **dup)
2387{
2388 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
2389
Michal Vasko58d89e92023-05-23 09:56:19 +02002390 return lyd_dup(node, trg_ctx, (struct lyd_node *)parent, options, 1, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002391}
2392
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002393LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002394lyd_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 +02002395{
Michal Vaskoddd76592022-01-17 13:34:48 +01002396 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02002397 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01002398
Michal Vasko58d89e92023-05-23 09:56:19 +02002399 return lyd_dup(node, LYD_CTX(node), (struct lyd_node *)parent, options, 0, dup);
Michal Vaskoddd76592022-01-17 13:34:48 +01002400}
2401
2402LIBYANG_API_DEF LY_ERR
2403lyd_dup_siblings_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
2404 uint32_t options, struct lyd_node **dup)
2405{
2406 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
2407
Michal Vasko58d89e92023-05-23 09:56:19 +02002408 return lyd_dup(node, trg_ctx, (struct lyd_node *)parent, options, 0, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002409}
2410
aPiecek41680342023-11-08 10:19:44 +01002411LY_ERR
2412lyd_dup_meta_single_to_ctx(const struct ly_ctx *parent_ctx, const struct lyd_meta *meta, struct lyd_node *parent,
2413 struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02002414{
Radek Krejci011e4aa2020-09-04 15:22:31 +02002415 LY_ERR ret = LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002416 struct lyd_meta *mt, *last;
aPiecek41680342023-11-08 10:19:44 +01002417 const struct lysc_type *ant_type;
2418 struct lys_module *mod;
2419 const char *val_can;
Michal Vasko25a32822020-07-09 15:48:22 +02002420
aPiecek41680342023-11-08 10:19:44 +01002421 LY_CHECK_ARG_RET(NULL, meta, parent, LY_EINVAL);
Michal Vasko33c48972022-07-20 10:28:07 +02002422
Michal Vasko25a32822020-07-09 15:48:22 +02002423 /* create a copy */
2424 mt = calloc(1, sizeof *mt);
aPiecek41680342023-11-08 10:19:44 +01002425 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(parent)), LY_EMEM);
2426
2427 if (parent_ctx != meta->annotation->module->ctx) {
2428 /* different contexts */
2429 mod = ly_ctx_get_module(parent_ctx, meta->annotation->module->name, meta->annotation->module->revision);
2430
2431 /* annotation */
2432 mt->annotation = lyd_get_meta_annotation(mod, meta->name, strlen(meta->name));
2433 lyplg_ext_get_storage(mt->annotation, LY_STMT_TYPE, sizeof ant_type, (const void **)&ant_type);
2434 LY_CHECK_ERR_GOTO((ret = mt->annotation ? LY_SUCCESS : LY_EINVAL), LOGERR(parent_ctx, LY_EINVAL,
2435 "Annotation for metadata %s not found, value duplication failed.", meta->name), finish);
2436
2437 /* duplicate callback expect only the same contexts, so use the store callback */
2438 val_can = lyd_value_get_canonical(meta->annotation->module->ctx, &meta->value);
stewegd4cde642024-02-21 08:34:16 +01002439 ret = lyd_value_store(parent_ctx, &mt->value, ant_type, val_can, strlen(val_can), 1, 1, NULL,
aPiecek41680342023-11-08 10:19:44 +01002440 LY_VALUE_CANON, NULL, LYD_HINT_DATA, parent->schema, NULL);
2441 } else {
2442 /* annotation */
2443 mt->annotation = meta->annotation;
2444 /* duplication of value */
2445 ret = meta->value.realtype->plugin->duplicate(parent_ctx, &meta->value, &mt->value);
2446 }
2447 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(parent), LY_EINT, "Value duplication failed."), finish);
2448 LY_CHECK_GOTO(ret = lydict_insert(parent_ctx, meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02002449
2450 /* insert as the last attribute */
aPiecek41680342023-11-08 10:19:44 +01002451 mt->parent = parent;
2452 if (parent->meta) {
2453 for (last = parent->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02002454 last->next = mt;
2455 } else {
aPiecek41680342023-11-08 10:19:44 +01002456 parent->meta = mt;
Michal Vasko25a32822020-07-09 15:48:22 +02002457 }
2458
Radek Krejci011e4aa2020-09-04 15:22:31 +02002459finish:
2460 if (ret) {
2461 lyd_free_meta_single(mt);
2462 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002463 *dup = mt;
2464 }
2465 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002466}
2467
aPiecek41680342023-11-08 10:19:44 +01002468LIBYANG_API_DEF LY_ERR
2469lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
2470{
2471 LY_CHECK_ARG_RET(NULL, meta, LY_EINVAL);
2472
2473 /* log to node context but value must always use the annotation context */
2474 return lyd_dup_meta_single_to_ctx(meta->annotation->module->ctx, meta, node, dup);
2475}
2476
Michal Vasko4490d312020-06-16 13:08:55 +02002477/**
2478 * @brief Merge a source sibling into target siblings.
2479 *
2480 * @param[in,out] first_trg First target sibling, is updated if top-level.
2481 * @param[in] parent_trg Target parent.
aPiecek55653c92023-11-09 13:43:19 +01002482 * @param[in,out] sibling_src_p Source sibling to merge, set to NULL if spent.
Michal Vaskocd3f6172021-05-18 16:14:50 +02002483 * @param[in] merge_cb Optional merge callback.
2484 * @param[in] cb_data Arbitrary callback data.
Michal Vasko4490d312020-06-16 13:08:55 +02002485 * @param[in] options Merge options.
aPieceke6955f42024-01-19 14:01:54 +01002486 * @param[in] lyds Pool of lyds data which can be reused.
2487 * @param[in,out] leader_p Cached first instance of target (leaf-)list.
Michal Vaskocd3f6172021-05-18 16:14:50 +02002488 * @param[in,out] dup_inst Duplicate instance cache for all @p first_trg siblings.
Michal Vasko4490d312020-06-16 13:08:55 +02002489 * @return LY_ERR value.
2490 */
2491static LY_ERR
aPieceke6955f42024-01-19 14:01:54 +01002492lyd_merge_sibling_r(struct lyd_node **first_trg, struct lyd_node *parent_trg,
2493 const struct lyd_node **sibling_src_p, lyd_merge_cb merge_cb, void *cb_data, uint16_t options,
2494 struct lyds_pool *lyds, struct lyd_node **leader_p, struct ly_ht **dup_inst)
Michal Vasko4490d312020-06-16 13:08:55 +02002495{
Michal Vasko4490d312020-06-16 13:08:55 +02002496 const struct lyd_node *child_src, *tmp, *sibling_src;
aPieceke6955f42024-01-19 14:01:54 +01002497 struct lyd_node *match_trg, *dup_src, *elem, *leader;
Michal Vaskod1afa502022-01-27 16:18:12 +01002498 struct lyd_node_opaq *opaq_trg, *opaq_src;
Michal Vasko4490d312020-06-16 13:08:55 +02002499 struct lysc_type *type;
aPieceke6955f42024-01-19 14:01:54 +01002500 const struct lysc_node *schema;
Michal Vasko8efac242023-03-30 08:24:56 +02002501 struct ly_ht *child_dup_inst = NULL;
Michal Vasko42c96e22024-01-18 08:18:06 +01002502 LY_ERR r;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002503 ly_bool first_inst = 0;
Michal Vasko4490d312020-06-16 13:08:55 +02002504
2505 sibling_src = *sibling_src_p;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002506 if (!sibling_src->schema) {
2507 /* try to find the same opaque node */
Michal Vasko42c96e22024-01-18 08:18:06 +01002508 r = lyd_find_sibling_opaq_next(*first_trg, LYD_NAME(sibling_src), &match_trg);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002509 } else if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002510 /* try to find the exact instance */
Michal Vasko42c96e22024-01-18 08:18:06 +01002511 r = lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02002512 } else {
2513 /* try to simply find the node, there cannot be more instances */
Michal Vasko42c96e22024-01-18 08:18:06 +01002514 r = lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02002515 }
Michal Vasko42c96e22024-01-18 08:18:06 +01002516 LY_CHECK_RET(r && (r != LY_ENOTFOUND), r);
Michal Vasko4490d312020-06-16 13:08:55 +02002517
Michal Vaskocd3f6172021-05-18 16:14:50 +02002518 if (match_trg) {
2519 /* update match as needed */
2520 LY_CHECK_RET(lyd_dup_inst_next(&match_trg, *first_trg, dup_inst));
2521 } else {
2522 /* first instance of this node */
2523 first_inst = 1;
2524 }
2525
2526 if (match_trg) {
2527 /* call callback */
2528 if (merge_cb) {
2529 LY_CHECK_RET(merge_cb(match_trg, sibling_src, cb_data));
2530 }
2531
Michal Vasko4490d312020-06-16 13:08:55 +02002532 /* node found, make sure even value matches for all node types */
Michal Vaskod1afa502022-01-27 16:18:12 +01002533 if (!match_trg->schema) {
2534 if (lyd_compare_single(sibling_src, match_trg, 0)) {
2535 /* update value */
2536 opaq_trg = (struct lyd_node_opaq *)match_trg;
2537 opaq_src = (struct lyd_node_opaq *)sibling_src;
2538
2539 lydict_remove(LYD_CTX(opaq_trg), opaq_trg->value);
2540 lydict_insert(LYD_CTX(opaq_trg), opaq_src->value, 0, &opaq_trg->value);
2541 opaq_trg->hints = opaq_src->hints;
2542
2543 ly_free_prefix_data(opaq_trg->format, opaq_trg->val_prefix_data);
2544 opaq_trg->format = opaq_src->format;
2545 ly_dup_prefix_data(LYD_CTX(opaq_trg), opaq_src->format, opaq_src->val_prefix_data,
2546 &opaq_trg->val_prefix_data);
2547 }
2548 } else if ((match_trg->schema->nodetype == LYS_LEAF) &&
2549 lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002550 /* since they are different, they cannot both be default */
2551 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
2552
Michal Vasko3a41dff2020-07-15 14:30:28 +02002553 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
2554 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002555 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002556 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
2557 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02002558 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02002559
2560 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002561 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vasko4490d312020-06-16 13:08:55 +02002562 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002563 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002564 /* update value */
2565 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002566 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002567
2568 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002569 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002570 }
2571
2572 /* check descendants, recursively */
Michal Vasko42c96e22024-01-18 08:18:06 +01002573 r = LY_SUCCESS;
aPieceke6955f42024-01-19 14:01:54 +01002574 leader = NULL;
2575 schema = NULL;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002576 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
aPieceke6955f42024-01-19 14:01:54 +01002577 if ((options & LYD_MERGE_DESTRUCT) && (schema != child_src->schema) && LYDS_NODE_IS_LEADER(child_src)) {
2578 schema = child_src->schema;
2579 /* unlink lyds data and add them to the pool */
2580 lyds_pool_add((struct lyd_node *)child_src, lyds);
2581 }
2582
2583 r = lyd_merge_sibling_r(lyd_node_child_p(match_trg), match_trg, &child_src,
2584 merge_cb, cb_data, options, lyds, &leader, &child_dup_inst);
Michal Vasko42c96e22024-01-18 08:18:06 +01002585 if (r) {
Michal Vaskocd3f6172021-05-18 16:14:50 +02002586 break;
Michal Vasko4490d312020-06-16 13:08:55 +02002587 }
2588 }
aPieceke6955f42024-01-19 14:01:54 +01002589
Michal Vaskocd3f6172021-05-18 16:14:50 +02002590 lyd_dup_inst_free(child_dup_inst);
Michal Vasko42c96e22024-01-18 08:18:06 +01002591 LY_CHECK_RET(r);
Michal Vasko4490d312020-06-16 13:08:55 +02002592 } else {
2593 /* node not found, merge it */
2594 if (options & LYD_MERGE_DESTRUCT) {
2595 dup_src = (struct lyd_node *)sibling_src;
aPiecek743184b2024-02-01 13:25:56 +01002596 lyd_unlink_ignore_lyds(NULL, dup_src);
Michal Vasko4490d312020-06-16 13:08:55 +02002597 /* spend it */
2598 *sibling_src_p = NULL;
2599 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002600 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 +02002601 }
2602
Michal Vasko7e8315b2021-08-03 17:01:06 +02002603 if (!(options & LYD_MERGE_WITH_FLAGS)) {
2604 /* set LYD_NEW for all the new nodes, required for validation */
2605 LYD_TREE_DFS_BEGIN(dup_src, elem) {
2606 elem->flags |= LYD_NEW;
2607 LYD_TREE_DFS_END(dup_src, elem);
2608 }
Michal Vasko4490d312020-06-16 13:08:55 +02002609 }
2610
aPieceke6955f42024-01-19 14:01:54 +01002611 if (lyds->rbn) {
2612 /* insert node and try to reuse free lyds data */
2613 lyds_insert2(parent_trg, first_trg, leader_p, dup_src, lyds);
2614 } else {
2615 /* generic insert node */
aPiecek1462ab12024-02-07 09:13:29 +01002616 lyd_insert_node(parent_trg, first_trg, dup_src, LYD_INSERT_NODE_DEFAULT);
aPieceke6955f42024-01-19 14:01:54 +01002617 }
Michal Vaskocd3f6172021-05-18 16:14:50 +02002618
2619 if (first_inst) {
2620 /* remember not to find this instance next time */
2621 LY_CHECK_RET(lyd_dup_inst_next(&dup_src, *first_trg, dup_inst));
2622 }
2623
2624 /* call callback, no source node */
2625 if (merge_cb) {
2626 LY_CHECK_RET(merge_cb(dup_src, NULL, cb_data));
2627 }
Michal Vasko4490d312020-06-16 13:08:55 +02002628 }
2629
2630 return LY_SUCCESS;
2631}
2632
Michal Vasko3a41dff2020-07-15 14:30:28 +02002633static LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002634lyd_merge(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2635 lyd_merge_cb merge_cb, void *cb_data, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02002636{
2637 const struct lyd_node *sibling_src, *tmp;
aPieceke6955f42024-01-19 14:01:54 +01002638 const struct lysc_node *schema;
2639 struct lyd_node *leader;
Michal Vasko8efac242023-03-30 08:24:56 +02002640 struct ly_ht *dup_inst = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02002641 ly_bool first;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002642 LY_ERR ret = LY_SUCCESS;
aPieceke6955f42024-01-19 14:01:54 +01002643 struct lyds_pool lyds = {0};
Michal Vasko4490d312020-06-16 13:08:55 +02002644
2645 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002646 LY_CHECK_CTX_EQUAL_RET(*target ? LYD_CTX(*target) : NULL, source ? LYD_CTX(source) : NULL, mod ? mod->ctx : NULL,
2647 LY_EINVAL);
Michal Vasko4490d312020-06-16 13:08:55 +02002648
2649 if (!source) {
2650 /* nothing to merge */
2651 return LY_SUCCESS;
2652 }
2653
Michal Vasko831422b2020-11-24 11:20:51 +01002654 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002655 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02002656 return LY_EINVAL;
2657 }
2658
aPieceke6955f42024-01-19 14:01:54 +01002659 leader = NULL;
2660 schema = NULL;
Michal Vasko4490d312020-06-16 13:08:55 +02002661 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Michal Vaskocd3f6172021-05-18 16:14:50 +02002662 if (mod && (lyd_owner_module(sibling_src) != mod)) {
2663 /* skip data nodes from different modules */
2664 continue;
2665 }
2666
aPieceke6955f42024-01-19 14:01:54 +01002667 if ((options & LYD_MERGE_DESTRUCT) && (schema != sibling_src->schema) && LYDS_NODE_IS_LEADER(sibling_src)) {
2668 schema = sibling_src->schema;
2669 /* unlink lyds data and add them to the pool */
2670 lyds_pool_add((struct lyd_node *)sibling_src, &lyds);
2671 }
2672
Radek Krejci857189e2020-09-01 13:26:36 +02002673 first = (sibling_src == source) ? 1 : 0;
aPieceke6955f42024-01-19 14:01:54 +01002674 ret = lyd_merge_sibling_r(target, NULL, &sibling_src, merge_cb, cb_data, options,
2675 &lyds, &leader, &dup_inst);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002676 if (ret) {
2677 break;
2678 }
Michal Vasko4490d312020-06-16 13:08:55 +02002679 if (first && !sibling_src) {
2680 /* source was spent (unlinked), move to the next node */
2681 source = tmp;
2682 }
2683
Michal Vasko3a41dff2020-07-15 14:30:28 +02002684 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02002685 break;
2686 }
2687 }
aPieceke6955f42024-01-19 14:01:54 +01002688 lyds_pool_clean(&lyds);
Michal Vasko4490d312020-06-16 13:08:55 +02002689
2690 if (options & LYD_MERGE_DESTRUCT) {
2691 /* free any leftover source data that were not merged */
2692 lyd_free_siblings((struct lyd_node *)source);
2693 }
2694
Michal Vaskocd3f6172021-05-18 16:14:50 +02002695 lyd_dup_inst_free(dup_inst);
2696 return ret;
Michal Vasko4490d312020-06-16 13:08:55 +02002697}
2698
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002699LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002700lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002701{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002702 return lyd_merge(target, source, NULL, NULL, NULL, options, 1);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002703}
2704
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002705LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002706lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002707{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002708 return lyd_merge(target, source, NULL, NULL, NULL, options, 0);
2709}
2710
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002711LIBYANG_API_DEF LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002712lyd_merge_module(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2713 lyd_merge_cb merge_cb, void *cb_data, uint16_t options)
2714{
2715 return lyd_merge(target, source, mod, merge_cb, cb_data, options, 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002716}
2717
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002718static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002719lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002720{
Michal Vasko14654712020-02-06 08:35:21 +01002721 /* ending \0 */
2722 ++reqlen;
2723
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002724 if (reqlen > *buflen) {
2725 if (is_static) {
2726 return LY_EINCOMPLETE;
2727 }
2728
2729 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
2730 if (!*buffer) {
2731 return LY_EMEM;
2732 }
2733
2734 *buflen = reqlen;
2735 }
2736
2737 return LY_SUCCESS;
2738}
2739
Michal Vaskod59035b2020-07-08 12:00:06 +02002740LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002741lyd_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 +02002742{
2743 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002744 size_t len;
2745 const char *val;
2746 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002747
Michal Vasko824d0832021-11-04 15:36:51 +01002748 for (key = lyd_child(node); key && key->schema && (key->schema->flags & LYS_KEY); key = key->next) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002749 val = lyd_get_value(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002750 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002751 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002752
2753 quot = '\'';
2754 if (strchr(val, '\'')) {
2755 quot = '"';
2756 }
2757 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002758 }
2759
2760 return LY_SUCCESS;
2761}
2762
2763/**
2764 * @brief Append leaf-list value predicate to path.
2765 *
2766 * @param[in] node Node to print.
2767 * @param[in,out] buffer Buffer to print to.
2768 * @param[in,out] buflen Current buffer length.
2769 * @param[in,out] bufused Current number of characters used in @p buffer.
2770 * @param[in] is_static Whether buffer is static or can be reallocated.
2771 * @return LY_ERR
2772 */
2773static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002774lyd_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 +02002775{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002776 size_t len;
2777 const char *val;
2778 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002779
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002780 val = lyd_get_value(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01002781 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002782 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002783
2784 quot = '\'';
2785 if (strchr(val, '\'')) {
2786 quot = '"';
2787 }
2788 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
2789
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002790 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002791}
2792
2793/**
2794 * @brief Append node position (relative to its other instances) predicate to path.
2795 *
2796 * @param[in] node Node to print.
2797 * @param[in,out] buffer Buffer to print to.
2798 * @param[in,out] buflen Current buffer length.
2799 * @param[in,out] bufused Current number of characters used in @p buffer.
2800 * @param[in] is_static Whether buffer is static or can be reallocated.
2801 * @return LY_ERR
2802 */
2803static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002804lyd_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 +02002805{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002806 size_t len;
Michal Vasko50cc0562021-05-18 16:15:43 +02002807 uint32_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002808 char *val = NULL;
2809 LY_ERR rc;
2810
Michal Vasko50cc0562021-05-18 16:15:43 +02002811 pos = lyd_list_pos(node);
2812 if (asprintf(&val, "%" PRIu32, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002813 return LY_EMEM;
2814 }
2815
2816 len = 1 + strlen(val) + 1;
2817 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
2818 if (rc != LY_SUCCESS) {
2819 goto cleanup;
2820 }
2821
2822 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
2823
2824cleanup:
2825 free(val);
2826 return rc;
2827}
2828
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002829LIBYANG_API_DEF char *
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002830lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
2831{
Radek Krejci857189e2020-09-01 13:26:36 +02002832 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002833 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01002834 size_t bufused = 0, len;
Michal Vasko12eb6222022-03-18 13:35:49 +01002835 const struct lyd_node *iter, *parent;
2836 const struct lys_module *mod, *prev_mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02002837 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002838
2839 LY_CHECK_ARG_RET(NULL, node, NULL);
2840 if (buffer) {
Michal Vasko16385f42021-05-18 16:16:09 +02002841 LY_CHECK_ARG_RET(LYD_CTX(node), buflen > 1, NULL);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002842 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01002843 } else {
2844 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002845 }
2846
2847 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01002848 case LYD_PATH_STD:
2849 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01002850 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01002851 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002852 ++depth;
2853 }
2854
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002855 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01002856 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002857 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01002858 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002859iter_print:
Michal Vasko12eb6222022-03-18 13:35:49 +01002860 /* get the module */
Michal Vasko420cc252023-08-24 08:14:24 +02002861 mod = lyd_node_module(iter);
Michal Vasko12eb6222022-03-18 13:35:49 +01002862 parent = lyd_parent(iter);
Michal Vasko420cc252023-08-24 08:14:24 +02002863 prev_mod = lyd_node_module(parent);
Michal Vasko12eb6222022-03-18 13:35:49 +01002864 if (prev_mod == mod) {
2865 mod = NULL;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002866 }
2867
2868 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01002869 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2870 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002871 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
2872 if (rc != LY_SUCCESS) {
2873 break;
2874 }
2875
2876 /* print next node */
Michal Vaskodbf3e652022-10-21 08:46:25 +02002877 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002878
Michal Vasko790b2bc2020-08-03 13:35:06 +02002879 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01002880 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02002881 switch (iter->schema->nodetype) {
2882 case LYS_LIST:
2883 if (iter->schema->flags & LYS_KEYLESS) {
2884 /* print its position */
2885 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2886 } else {
2887 /* print all list keys in predicates */
2888 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
2889 }
2890 break;
2891 case LYS_LEAFLIST:
2892 if (iter->schema->flags & LYS_CONFIG_W) {
2893 /* print leaf-list value */
2894 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
2895 } else {
2896 /* print its position */
2897 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2898 }
2899 break;
2900 default:
2901 /* nothing to print more */
2902 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002903 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002904 }
2905 if (rc != LY_SUCCESS) {
2906 break;
2907 }
2908
Michal Vasko14654712020-02-06 08:35:21 +01002909 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002910 }
2911 break;
2912 }
2913
2914 return buffer;
2915}
Michal Vaskoe444f752020-02-10 12:20:06 +01002916
Michal Vaskodbf3e652022-10-21 08:46:25 +02002917char *
2918lyd_path_set(const struct ly_set *dnodes, LYD_PATH_TYPE pathtype)
2919{
2920 uint32_t depth;
2921 size_t bufused = 0, buflen = 0, len;
2922 char *buffer = NULL;
2923 const struct lyd_node *iter, *parent;
2924 const struct lys_module *mod, *prev_mod;
2925 LY_ERR rc = LY_SUCCESS;
2926
2927 switch (pathtype) {
2928 case LYD_PATH_STD:
2929 case LYD_PATH_STD_NO_LAST_PRED:
2930 for (depth = 1; depth <= dnodes->count; ++depth) {
2931 /* current node */
2932 iter = dnodes->dnodes[depth - 1];
Michal Vasko420cc252023-08-24 08:14:24 +02002933 mod = lyd_node_module(iter);
Michal Vaskodbf3e652022-10-21 08:46:25 +02002934
2935 /* parent */
2936 parent = (depth > 1) ? dnodes->dnodes[depth - 2] : NULL;
Michal Vasko85be65e2023-06-13 09:44:17 +02002937 assert(!parent || !iter->schema || !parent->schema || (parent->schema->nodetype & LYD_NODE_ANY) ||
2938 (lysc_data_parent(iter->schema) == parent->schema) ||
Michal Vasko539d6a92023-09-11 10:31:12 +02002939 (!lysc_data_parent(iter->schema) && (LYD_CTX(iter) != LYD_CTX(parent))) ||
2940 (parent->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vaskodbf3e652022-10-21 08:46:25 +02002941
2942 /* get module to print, if any */
Michal Vasko420cc252023-08-24 08:14:24 +02002943 prev_mod = lyd_node_module(parent);
Michal Vaskodbf3e652022-10-21 08:46:25 +02002944 if (prev_mod == mod) {
2945 mod = NULL;
2946 }
2947
2948 /* realloc string */
2949 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2950 strlen(((struct lyd_node_opaq *)iter)->name.name));
2951 if ((rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, 0))) {
2952 break;
2953 }
2954
2955 /* print next node */
2956 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
2957
2958 /* do not always print the last (first) predicate */
2959 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
2960 switch (iter->schema->nodetype) {
2961 case LYS_LIST:
2962 if (iter->schema->flags & LYS_KEYLESS) {
2963 /* print its position */
2964 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2965 } else {
2966 /* print all list keys in predicates */
2967 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, 0);
2968 }
2969 break;
2970 case LYS_LEAFLIST:
2971 if (iter->schema->flags & LYS_CONFIG_W) {
2972 /* print leaf-list value */
2973 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, 0);
2974 } else {
2975 /* print its position */
2976 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2977 }
2978 break;
2979 default:
2980 /* nothing to print more */
2981 break;
2982 }
2983 }
2984 if (rc) {
2985 break;
2986 }
2987 }
2988 break;
2989 }
2990
2991 return buffer;
2992}
2993
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002994LIBYANG_API_DEF struct lyd_meta *
Michal Vasko25a32822020-07-09 15:48:22 +02002995lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
2996{
2997 struct lyd_meta *ret = NULL;
2998 const struct ly_ctx *ctx;
2999 const char *prefix, *tmp;
3000 char *str;
3001 size_t pref_len, name_len;
3002
3003 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01003004 LY_CHECK_CTX_EQUAL_RET(first ? first->annotation->module->ctx : NULL, module ? module->ctx : NULL, NULL);
Michal Vasko25a32822020-07-09 15:48:22 +02003005
3006 if (!first) {
3007 return NULL;
3008 }
3009
3010 ctx = first->annotation->module->ctx;
3011
3012 /* parse the name */
3013 tmp = name;
3014 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
3015 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
3016 return NULL;
3017 }
3018
3019 /* find the module */
3020 if (prefix) {
3021 str = strndup(prefix, pref_len);
3022 module = ly_ctx_get_module_latest(ctx, str);
3023 free(str);
Radek Krejci422afb12021-03-04 16:38:16 +01003024 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 +02003025 }
3026
3027 /* find the metadata */
3028 LY_LIST_FOR(first, first) {
3029 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
3030 ret = (struct lyd_meta *)first;
3031 break;
3032 }
3033 }
3034
3035 return ret;
3036}
3037
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003038LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003039lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
3040{
Michal Vasko9beceb82022-04-05 12:14:15 +02003041 struct lyd_node **match_p, *iter, *dup = NULL;
Michal Vaskoe444f752020-02-10 12:20:06 +01003042 struct lyd_node_inner *parent;
Michal Vaskoe78faec2021-04-08 17:24:43 +02003043 ly_bool found;
Michal Vaskoe444f752020-02-10 12:20:06 +01003044
Michal Vaskof03ed032020-03-04 13:31:44 +01003045 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02003046 if (!siblings) {
3047 /* no data */
3048 if (match) {
3049 *match = NULL;
3050 }
3051 return LY_ENOTFOUND;
3052 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003053
Michal Vasko9beceb82022-04-05 12:14:15 +02003054 if (LYD_CTX(siblings) != LYD_CTX(target)) {
3055 /* create a duplicate in this context */
3056 LY_CHECK_RET(lyd_dup_single_to_ctx(target, LYD_CTX(siblings), NULL, 0, &dup));
3057 target = dup;
3058 }
3059
3060 if ((siblings->schema && target->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
3061 /* schema mismatch */
3062 lyd_free_tree(dup);
Michal Vasko9b368d32020-02-14 13:53:31 +01003063 if (match) {
3064 *match = NULL;
3065 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003066 return LY_ENOTFOUND;
3067 }
3068
Michal Vaskoe78faec2021-04-08 17:24:43 +02003069 /* get first sibling */
3070 siblings = lyd_first_sibling(siblings);
Michal Vaskoe444f752020-02-10 12:20:06 +01003071
Michal Vasko9e685082021-01-29 14:49:09 +01003072 parent = siblings->parent;
Michal Vasko39311152023-08-07 11:03:41 +02003073 if (target->schema && parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01003074 assert(target->hash);
3075
Michal Vaskoe78faec2021-04-08 17:24:43 +02003076 if (lysc_is_dup_inst_list(target->schema)) {
3077 /* we must search the instances from beginning to find the first matching one */
3078 found = 0;
3079 LYD_LIST_FOR_INST(siblings, target->schema, iter) {
Michal Vaskoee9b9482023-06-19 13:17:48 +02003080 if (!lyd_compare_single(target, iter, LYD_COMPARE_FULL_RECURSION)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +02003081 found = 1;
3082 break;
3083 }
3084 }
3085 if (found) {
3086 siblings = iter;
Michal Vaskoda859032020-07-14 12:20:14 +02003087 } else {
3088 siblings = NULL;
3089 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003090 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +02003091 /* find by hash */
3092 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
3093 siblings = *match_p;
3094 } else {
3095 /* not found */
3096 siblings = NULL;
3097 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003098 }
3099 } else {
Michal Vasko39311152023-08-07 11:03:41 +02003100 /* no children hash table or cannot be used */
Michal Vaskod989ba02020-08-24 10:59:24 +02003101 for ( ; siblings; siblings = siblings->next) {
Michal Vaskoee9b9482023-06-19 13:17:48 +02003102 if (lysc_is_dup_inst_list(target->schema)) {
3103 if (!lyd_compare_single(siblings, target, LYD_COMPARE_FULL_RECURSION)) {
3104 break;
3105 }
3106 } else {
Michal Vaskod8a52012023-08-15 11:38:10 +02003107 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoee9b9482023-06-19 13:17:48 +02003108 break;
3109 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003110 }
3111 }
3112 }
3113
Michal Vasko9beceb82022-04-05 12:14:15 +02003114 lyd_free_tree(dup);
Michal Vaskoe444f752020-02-10 12:20:06 +01003115 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01003116 if (match) {
3117 *match = NULL;
3118 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003119 return LY_ENOTFOUND;
3120 }
3121
Michal Vasko9b368d32020-02-14 13:53:31 +01003122 if (match) {
3123 *match = (struct lyd_node *)siblings;
3124 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003125 return LY_SUCCESS;
3126}
3127
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003128LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01003129lyd_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 +02003130 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01003131{
3132 LY_ERR rc;
3133 struct lyd_node *target = NULL;
Michal Vasko9beceb82022-04-05 12:14:15 +02003134 const struct lyd_node *parent;
Michal Vaskoe444f752020-02-10 12:20:06 +01003135
Michal Vasko4c583e82020-07-17 12:16:14 +02003136 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02003137 if (!siblings) {
3138 /* no data */
3139 if (match) {
3140 *match = NULL;
3141 }
3142 return LY_ENOTFOUND;
3143 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003144
Michal Vasko9beceb82022-04-05 12:14:15 +02003145 if ((LYD_CTX(siblings) != schema->module->ctx)) {
3146 /* parent of ext nodes is useless */
3147 parent = (siblings->flags & LYD_EXT) ? NULL : lyd_parent(siblings);
Michal Vaskoaf3df492022-12-02 14:03:52 +01003148 if (lyd_find_schema_ctx(schema, LYD_CTX(siblings), parent, 0, &schema)) {
3149 /* no schema node in siblings so certainly no data node either */
3150 if (match) {
3151 *match = NULL;
3152 }
3153 return LY_ENOTFOUND;
3154 }
Michal Vasko9beceb82022-04-05 12:14:15 +02003155 }
3156
3157 if (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema))) {
3158 /* schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01003159 if (match) {
3160 *match = NULL;
3161 }
Michal Vaskoe444f752020-02-10 12:20:06 +01003162 return LY_ENOTFOUND;
3163 }
3164
Michal Vaskof03ed032020-03-04 13:31:44 +01003165 if (key_or_value && !val_len) {
3166 val_len = strlen(key_or_value);
3167 }
3168
Michal Vaskob104f112020-07-17 09:54:54 +02003169 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
3170 /* create a data node and find the instance */
3171 if (schema->nodetype == LYS_LEAFLIST) {
3172 /* target used attributes: schema, hash, value */
stewegd4cde642024-02-21 08:34:16 +01003173 rc = lyd_create_term(schema, key_or_value, val_len, 0, 1, NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, NULL, &target);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02003174 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02003175 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01003176 /* target used attributes: schema, hash, child (all keys) */
stewegd4cde642024-02-21 08:34:16 +01003177 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, 1, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01003178 }
3179
3180 /* find it */
3181 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02003182 } else {
3183 /* find the first schema node instance */
3184 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01003185 }
3186
Michal Vaskoe444f752020-02-10 12:20:06 +01003187 lyd_free_tree(target);
3188 return rc;
3189}
Michal Vaskoccc02342020-05-21 10:09:21 +02003190
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003191LIBYANG_API_DEF LY_ERR
Michal Vaskoe78faec2021-04-08 17:24:43 +02003192lyd_find_sibling_dup_inst_set(const struct lyd_node *siblings, const struct lyd_node *target, struct ly_set **set)
3193{
3194 struct lyd_node **match_p, *first, *iter;
3195 struct lyd_node_inner *parent;
Michal Vaskoee9b9482023-06-19 13:17:48 +02003196 uint32_t comp_opts;
Michal Vaskoe78faec2021-04-08 17:24:43 +02003197
Michal Vasko83ae7772022-06-08 10:01:55 +02003198 LY_CHECK_ARG_RET(NULL, target, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01003199 LY_CHECK_CTX_EQUAL_RET(siblings ? LYD_CTX(siblings) : NULL, LYD_CTX(target), LY_EINVAL);
Michal Vaskoe78faec2021-04-08 17:24:43 +02003200
3201 LY_CHECK_RET(ly_set_new(set));
3202
3203 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
3204 /* no data or schema mismatch */
3205 return LY_ENOTFOUND;
3206 }
3207
Michal Vaskoee9b9482023-06-19 13:17:48 +02003208 /* set options */
Michal Vaskod8a52012023-08-15 11:38:10 +02003209 comp_opts = (lysc_is_dup_inst_list(target->schema) ? LYD_COMPARE_FULL_RECURSION : 0);
Michal Vaskoee9b9482023-06-19 13:17:48 +02003210
Michal Vaskoe78faec2021-04-08 17:24:43 +02003211 /* get first sibling */
3212 siblings = lyd_first_sibling(siblings);
3213
3214 parent = siblings->parent;
3215 if (parent && parent->schema && parent->children_ht) {
3216 assert(target->hash);
3217
3218 /* find the first instance */
3219 lyd_find_sibling_first(siblings, target, &first);
3220 if (first) {
3221 /* add it so that it is the first in the set */
3222 if (ly_set_add(*set, first, 1, NULL)) {
3223 goto error;
3224 }
3225
3226 /* find by hash */
3227 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
3228 iter = *match_p;
3229 } else {
3230 /* not found */
3231 iter = NULL;
3232 }
3233 while (iter) {
3234 /* add all found nodes into the set */
Michal Vaskoee9b9482023-06-19 13:17:48 +02003235 if ((iter != first) && !lyd_compare_single(iter, target, comp_opts) && ly_set_add(*set, iter, 1, NULL)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +02003236 goto error;
3237 }
3238
3239 /* find next instance */
3240 if (lyht_find_next(parent->children_ht, &iter, iter->hash, (void **)&match_p)) {
3241 iter = NULL;
3242 } else {
3243 iter = *match_p;
3244 }
3245 }
3246 }
3247 } else {
3248 /* no children hash table */
3249 LY_LIST_FOR(siblings, siblings) {
Michal Vaskoee9b9482023-06-19 13:17:48 +02003250 if (!lyd_compare_single(target, siblings, comp_opts)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +02003251 ly_set_add(*set, (void *)siblings, 1, NULL);
3252 }
3253 }
3254 }
3255
3256 if (!(*set)->count) {
3257 return LY_ENOTFOUND;
3258 }
3259 return LY_SUCCESS;
3260
3261error:
3262 ly_set_free(*set, NULL);
3263 *set = NULL;
3264 return LY_EMEM;
3265}
3266
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003267LIBYANG_API_DEF LY_ERR
Michal Vasko1d4af6c2021-02-22 13:31:26 +01003268lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
3269{
3270 LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
3271
Michal Vaskoe271a312023-08-15 11:46:30 +02003272 if (first && first->schema) {
3273 first = first->prev;
3274 if (first->schema) {
3275 /* no opaque nodes */
3276 first = NULL;
3277 } else {
3278 /* opaque nodes are at the end, find quickly the first */
3279 while (!first->prev->schema) {
3280 first = first->prev;
3281 }
3282 }
3283 }
3284
Michal Vasko1d4af6c2021-02-22 13:31:26 +01003285 for ( ; first; first = first->next) {
Michal Vaskoe271a312023-08-15 11:46:30 +02003286 assert(!first->schema);
3287 if (!strcmp(LYD_NAME(first), name)) {
Michal Vasko1d4af6c2021-02-22 13:31:26 +01003288 break;
3289 }
3290 }
3291
3292 if (match) {
3293 *match = (struct lyd_node *)first;
3294 }
3295 return first ? LY_SUCCESS : LY_ENOTFOUND;
3296}
3297
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003298LIBYANG_API_DEF LY_ERR
Michal Vaskod96e2372023-02-24 16:07:51 +01003299lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
Michal Vaskoccc02342020-05-21 10:09:21 +02003300{
Michal Vaskod96e2372023-02-24 16:07:51 +01003301 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
Michal Vaskoccc02342020-05-21 10:09:21 +02003302
Michal Vaskobe1b0cb2024-01-22 14:32:15 +01003303 return lyd_find_xpath3(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, NULL, set);
Michal Vaskod96e2372023-02-24 16:07:51 +01003304}
Michal Vaskoccc02342020-05-21 10:09:21 +02003305
Michal Vaskod96e2372023-02-24 16:07:51 +01003306LIBYANG_API_DEF LY_ERR
3307lyd_find_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, struct ly_set **set)
3308{
3309 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
Michal Vaskoccc02342020-05-21 10:09:21 +02003310
Michal Vaskobe1b0cb2024-01-22 14:32:15 +01003311 return lyd_find_xpath3(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, vars, set);
Michal Vaskoccc02342020-05-21 10:09:21 +02003312}
Radek Krejcica989142020-11-05 11:32:22 +01003313
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003314LIBYANG_API_DEF LY_ERR
Michal Vaskobe1b0cb2024-01-22 14:32:15 +01003315lyd_find_xpath3(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath, LY_VALUE_FORMAT format,
Michal Vaskod96e2372023-02-24 16:07:51 +01003316 void *prefix_data, const struct lyxp_var *vars, struct ly_set **set)
Michal Vaskoe3716b32021-12-13 16:58:25 +01003317{
Michal Vaskod96e2372023-02-24 16:07:51 +01003318 LY_CHECK_ARG_RET(NULL, tree, xpath, set, LY_EINVAL);
Michal Vaskoe3716b32021-12-13 16:58:25 +01003319
Michal Vaskod96e2372023-02-24 16:07:51 +01003320 *set = NULL;
3321
3322 return lyd_eval_xpath4(ctx_node, tree, NULL, xpath, format, prefix_data, vars, NULL, set, NULL, NULL, NULL);
Michal Vaskoe3716b32021-12-13 16:58:25 +01003323}
3324
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003325LIBYANG_API_DEF LY_ERR
Michal Vaskod96e2372023-02-24 16:07:51 +01003326lyd_eval_xpath(const struct lyd_node *ctx_node, const char *xpath, ly_bool *result)
aPiecekfba75362021-10-07 12:39:48 +02003327{
Michal Vaskod96e2372023-02-24 16:07:51 +01003328 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, NULL, result);
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02003329}
3330
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003331LIBYANG_API_DEF LY_ERR
Michal Vasko10fabfc2022-08-09 08:55:43 +02003332lyd_eval_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, ly_bool *result)
3333{
3334 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, vars, result);
3335}
3336
3337LIBYANG_API_DEF LY_ERR
Michal Vaskod96e2372023-02-24 16:07:51 +01003338lyd_eval_xpath3(const struct lyd_node *ctx_node, const struct lys_module *cur_mod, const char *xpath,
3339 LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, ly_bool *result)
aPiecekfba75362021-10-07 12:39:48 +02003340{
Michal Vaskod96e2372023-02-24 16:07:51 +01003341 return lyd_eval_xpath4(ctx_node, ctx_node, cur_mod, xpath, format, prefix_data, vars, NULL, NULL, NULL, NULL, result);
3342}
3343
3344LIBYANG_API_DEF LY_ERR
3345lyd_eval_xpath4(const struct lyd_node *ctx_node, const struct lyd_node *tree, const struct lys_module *cur_mod,
3346 const char *xpath, LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, LY_XPATH_TYPE *ret_type,
3347 struct ly_set **node_set, char **string, long double *number, ly_bool *boolean)
3348{
3349 LY_ERR ret = LY_SUCCESS;
3350 struct lyxp_set xp_set = {0};
3351 struct lyxp_expr *exp = NULL;
3352 uint32_t i;
3353
3354 LY_CHECK_ARG_RET(NULL, tree, xpath, ((ret_type && node_set && string && number && boolean) ||
3355 (node_set && !string && !number && !boolean) || (!node_set && string && !number && !boolean) ||
3356 (!node_set && !string && number && !boolean) || (!node_set && !string && !number && boolean)), LY_EINVAL);
3357
3358 /* parse expression */
3359 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(tree), xpath, 0, 1, &exp);
3360 LY_CHECK_GOTO(ret, cleanup);
3361
3362 /* evaluate expression */
3363 ret = lyxp_eval(LYD_CTX(tree), exp, cur_mod, format, prefix_data, ctx_node, ctx_node, tree, vars, &xp_set,
3364 LYXP_IGNORE_WHEN);
3365 LY_CHECK_GOTO(ret, cleanup);
3366
3367 /* return expected result type without or with casting */
3368 if (node_set) {
3369 /* node set */
3370 if (xp_set.type == LYXP_SET_NODE_SET) {
3371 /* transform into a set */
3372 LY_CHECK_GOTO(ret = ly_set_new(node_set), cleanup);
3373 (*node_set)->objs = malloc(xp_set.used * sizeof *(*node_set)->objs);
3374 LY_CHECK_ERR_GOTO(!(*node_set)->objs, LOGMEM(LYD_CTX(tree)); ret = LY_EMEM, cleanup);
3375 (*node_set)->size = xp_set.used;
3376 for (i = 0; i < xp_set.used; ++i) {
3377 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
3378 ret = ly_set_add(*node_set, xp_set.val.nodes[i].node, 1, NULL);
3379 LY_CHECK_GOTO(ret, cleanup);
3380 }
3381 }
3382 if (ret_type) {
3383 *ret_type = LY_XPATH_NODE_SET;
3384 }
3385 } else if (!string && !number && !boolean) {
3386 LOGERR(LYD_CTX(tree), LY_EINVAL, "XPath \"%s\" result is not a node set.", xpath);
3387 ret = LY_EINVAL;
3388 goto cleanup;
3389 }
3390 }
3391
3392 if (string) {
3393 if ((xp_set.type != LYXP_SET_STRING) && !node_set) {
3394 /* cast into string */
3395 LY_CHECK_GOTO(ret = lyxp_set_cast(&xp_set, LYXP_SET_STRING), cleanup);
3396 }
3397 if (xp_set.type == LYXP_SET_STRING) {
3398 /* string */
3399 *string = xp_set.val.str;
3400 xp_set.val.str = NULL;
3401 if (ret_type) {
3402 *ret_type = LY_XPATH_STRING;
3403 }
3404 }
3405 }
3406
3407 if (number) {
3408 if ((xp_set.type != LYXP_SET_NUMBER) && !node_set) {
3409 /* cast into number */
3410 LY_CHECK_GOTO(ret = lyxp_set_cast(&xp_set, LYXP_SET_NUMBER), cleanup);
3411 }
3412 if (xp_set.type == LYXP_SET_NUMBER) {
3413 /* number */
3414 *number = xp_set.val.num;
3415 if (ret_type) {
3416 *ret_type = LY_XPATH_NUMBER;
3417 }
3418 }
3419 }
3420
3421 if (boolean) {
3422 if ((xp_set.type != LYXP_SET_BOOLEAN) && !node_set) {
3423 /* cast into boolean */
3424 LY_CHECK_GOTO(ret = lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN), cleanup);
3425 }
3426 if (xp_set.type == LYXP_SET_BOOLEAN) {
3427 /* boolean */
3428 *boolean = xp_set.val.bln;
3429 if (ret_type) {
3430 *ret_type = LY_XPATH_BOOLEAN;
3431 }
3432 }
3433 }
3434
3435cleanup:
3436 lyxp_set_free_content(&xp_set);
3437 lyxp_expr_free((struct ly_ctx *)LYD_CTX(tree), exp);
3438 return ret;
aPiecekfba75362021-10-07 12:39:48 +02003439}
3440
Michal Vasko99a77882024-01-04 14:50:51 +01003441/**
3442 * @brief Hash table node equal callback.
3443 */
3444static ly_bool
3445lyd_trim_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
3446{
3447 struct lyd_node *node1, *node2;
3448
3449 node1 = *(struct lyd_node **)val1_p;
3450 node2 = *(struct lyd_node **)val2_p;
3451
3452 return node1 == node2;
3453}
3454
3455LIBYANG_API_DEF LY_ERR
3456lyd_trim_xpath(struct lyd_node **tree, const char *xpath, const struct lyxp_var *vars)
3457{
3458 LY_ERR ret = LY_SUCCESS;
Michal Vaskoea4943c2024-01-16 15:27:29 +01003459 struct ly_ctx *ctx = NULL;
Michal Vasko99a77882024-01-04 14:50:51 +01003460 struct lyxp_set xp_set = {0};
3461 struct lyxp_expr *exp = NULL;
3462 struct lyd_node *node, *parent;
3463 struct lyxp_set_hash_node hnode;
3464 struct ly_ht *parent_ht = NULL;
3465 struct ly_set free_set = {0};
3466 uint32_t i, hash;
3467 ly_bool is_result;
3468
3469 LY_CHECK_ARG_RET(NULL, tree, xpath, LY_EINVAL);
3470
3471 if (!*tree) {
3472 /* nothing to do */
3473 goto cleanup;
3474 }
3475
3476 *tree = lyd_first_sibling(*tree);
3477 ctx = (struct ly_ctx *)LYD_CTX(*tree);
3478
3479 /* parse expression */
3480 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
3481 LY_CHECK_GOTO(ret, cleanup);
3482
3483 /* evaluate expression */
3484 ret = lyxp_eval(ctx, exp, NULL, LY_VALUE_JSON, NULL, *tree, *tree, *tree, vars, &xp_set, LYXP_IGNORE_WHEN);
3485 LY_CHECK_GOTO(ret, cleanup);
3486
3487 /* create hash table for all the parents of results */
Michal Vasko0a0716d2024-01-04 15:02:12 +01003488 parent_ht = lyht_new(32, sizeof node, lyd_trim_equal_cb, NULL, 1);
Michal Vasko99a77882024-01-04 14:50:51 +01003489 LY_CHECK_GOTO(!parent_ht, cleanup);
3490
3491 for (i = 0; i < xp_set.used; ++i) {
3492 if (xp_set.val.nodes[i].type != LYXP_NODE_ELEM) {
3493 /* ignore */
3494 continue;
3495 }
3496
3497 for (parent = lyd_parent(xp_set.val.nodes[i].node); parent; parent = lyd_parent(parent)) {
3498 /* add the parent into parent_ht */
3499 ret = lyht_insert(parent_ht, &parent, parent->hash, NULL);
3500 if (ret == LY_EEXIST) {
3501 /* shared parent, we are done */
3502 break;
3503 }
3504 LY_CHECK_GOTO(ret, cleanup);
3505 }
3506 }
3507
3508 hnode.type = LYXP_NODE_ELEM;
3509 LY_LIST_FOR(*tree, parent) {
3510 LYD_TREE_DFS_BEGIN(parent, node) {
3511 if (lysc_is_key(node->schema)) {
3512 /* ignore */
3513 goto next_iter;
3514 }
3515
3516 /* check the results */
3517 is_result = 0;
3518 if (xp_set.ht) {
3519 hnode.node = node;
3520 hash = lyht_hash_multi(0, (const char *)&hnode.node, sizeof hnode.node);
3521 hash = lyht_hash_multi(hash, (const char *)&hnode.type, sizeof hnode.type);
3522 hash = lyht_hash_multi(hash, NULL, 0);
3523
3524 if (!lyht_find(xp_set.ht, &hnode, hash, NULL)) {
3525 is_result = 1;
3526 }
3527 } else {
3528 /* not enough elements for a hash table */
3529 for (i = 0; i < xp_set.used; ++i) {
3530 if (xp_set.val.nodes[i].type != LYXP_NODE_ELEM) {
3531 /* ignore */
3532 continue;
3533 }
3534
3535 if (xp_set.val.nodes[i].node == node) {
3536 is_result = 1;
3537 break;
3538 }
3539 }
3540 }
3541
3542 if (is_result) {
3543 /* keep the whole subtree if the node is in the results */
3544 LYD_TREE_DFS_continue = 1;
3545 } else if (lyht_find(parent_ht, &node, node->hash, NULL)) {
3546 /* free the whole subtree if the node is not even among the selected parents */
3547 ret = ly_set_add(&free_set, node, 1, NULL);
3548 LY_CHECK_GOTO(ret, cleanup);
3549 LYD_TREE_DFS_continue = 1;
3550 } /* else keep the parent node because a subtree is in the results */
3551
3552next_iter:
3553 LYD_TREE_DFS_END(parent, node);
3554 }
3555 }
3556
3557 /* free */
3558 for (i = 0; i < free_set.count; ++i) {
3559 node = free_set.dnodes[i];
3560 if (*tree == node) {
3561 *tree = (*tree)->next;
3562 }
3563 lyd_free_tree(node);
3564 }
3565
3566cleanup:
3567 lyxp_set_free_content(&xp_set);
3568 lyxp_expr_free(ctx, exp);
3569 lyht_free(parent_ht, NULL);
3570 ly_set_erase(&free_set, NULL);
3571 return ret;
3572}
3573
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003574LIBYANG_API_DEF LY_ERR
Michal Vasko3e1f6552021-01-14 09:27:55 +01003575lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
3576{
3577 LY_ERR ret = LY_SUCCESS;
3578 struct lyxp_expr *expr = NULL;
3579 struct ly_path *lypath = NULL;
3580
3581 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
3582
3583 /* parse the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02003584 ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), 0, LY_PATH_BEGIN_EITHER,
Michal Vasko32ca49b2023-02-17 15:11:35 +01003585 LY_PATH_PREFIX_FIRST, LY_PATH_PRED_SIMPLE, &expr);
Michal Vasko3e1f6552021-01-14 09:27:55 +01003586 LY_CHECK_GOTO(ret, cleanup);
3587
3588 /* compile the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02003589 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, NULL, expr,
Michal Vasko0884d212021-10-14 09:21:46 +02003590 output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_SINGLE, 0, LY_VALUE_JSON, NULL, &lypath);
Michal Vasko3e1f6552021-01-14 09:27:55 +01003591 LY_CHECK_GOTO(ret, cleanup);
3592
3593 /* evaluate the path */
Michal Vasko838829d2023-10-09 16:06:43 +02003594 ret = ly_path_eval_partial(lypath, ctx_node, NULL, 0, NULL, match);
Michal Vasko3e1f6552021-01-14 09:27:55 +01003595
3596cleanup:
3597 lyxp_expr_free(LYD_CTX(ctx_node), expr);
Michal Vasko59391122024-08-16 15:38:02 +02003598 ly_path_free(LYD_CTX(ctx_node), lypath);
Michal Vasko3e1f6552021-01-14 09:27:55 +01003599 return ret;
3600}
3601
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01003602LIBYANG_API_DEF LY_ERR
Michal Vaskobb22b182021-06-14 08:14:21 +02003603lyd_find_target(const struct ly_path *path, const struct lyd_node *tree, struct lyd_node **match)
3604{
3605 LY_ERR ret;
3606 struct lyd_node *m;
3607
3608 LY_CHECK_ARG_RET(NULL, path, LY_EINVAL);
3609
Michal Vasko90189962023-02-28 12:10:34 +01003610 ret = ly_path_eval(path, tree, NULL, &m);
Michal Vaskobb22b182021-06-14 08:14:21 +02003611 if (ret) {
3612 if (match) {
3613 *match = NULL;
3614 }
3615 return LY_ENOTFOUND;
3616 }
3617
3618 if (match) {
3619 *match = m;
3620 }
3621 return LY_SUCCESS;
3622}
Irfand3b351a2023-09-14 14:52:15 +02003623
stewegf9041a22024-01-18 13:29:12 +01003624LY_ERR
3625lyd_get_or_create_leafref_links_record(const struct lyd_node_term *node, struct lyd_leafref_links_rec **record, ly_bool create)
3626{
3627 struct ly_ht *ht;
3628 uint32_t hash;
Michal Vaskob46061d2024-01-18 13:58:13 +01003629 struct lyd_leafref_links_rec rec = {0};
stewegf9041a22024-01-18 13:29:12 +01003630
3631 assert(node);
3632 assert(record);
3633
Michal Vaskob46061d2024-01-18 13:58:13 +01003634 *record = NULL;
3635
stewegf9041a22024-01-18 13:29:12 +01003636 if (!(ly_ctx_get_options(LYD_CTX(node)) & LY_CTX_LEAFREF_LINKING)) {
stewegf9041a22024-01-18 13:29:12 +01003637 return LY_EDENIED;
3638 }
3639
3640 rec.node = node;
stewegf9041a22024-01-18 13:29:12 +01003641 ht = LYD_CTX(node)->leafref_links_ht;
Michal Vasko67bf5872024-01-18 13:58:25 +01003642 hash = lyht_hash((const char *)&node, sizeof node);
3643
stewegf9041a22024-01-18 13:29:12 +01003644 if (lyht_find(ht, &rec, hash, (void **)record) == LY_ENOTFOUND) {
3645 if (create) {
3646 LY_CHECK_RET(lyht_insert_no_check(ht, &rec, hash, (void **)record));
3647 } else {
stewegf9041a22024-01-18 13:29:12 +01003648 return LY_ENOTFOUND;
3649 }
3650 }
3651
3652 return LY_SUCCESS;
3653}
3654
3655LIBYANG_API_DEF LY_ERR
3656lyd_leafref_get_links(const struct lyd_node_term *node, const struct lyd_leafref_links_rec **record)
3657{
3658 LY_CHECK_ARG_RET(NULL, node, record, LY_EINVAL);
3659
3660 return lyd_get_or_create_leafref_links_record(node, (struct lyd_leafref_links_rec **)record, 0);
3661}
3662
3663LY_ERR
3664lyd_link_leafref_node(const struct lyd_node_term *node, const struct lyd_node_term *leafref_node)
3665{
stewegf9041a22024-01-18 13:29:12 +01003666 const struct lyd_node_term **item = NULL;
3667 struct lyd_leafref_links_rec *rec;
steweg67388952024-01-25 12:14:50 +01003668 LY_ARRAY_COUNT_TYPE u;
stewegf9041a22024-01-18 13:29:12 +01003669
3670 assert(node);
3671 assert(leafref_node);
3672
3673 if (!(ly_ctx_get_options(LYD_CTX(node)) & LY_CTX_LEAFREF_LINKING)) {
3674 return LY_EDENIED;
3675 }
3676
steweg67388952024-01-25 12:14:50 +01003677 /* add leafref node into the list of target node */
stewegf9041a22024-01-18 13:29:12 +01003678 LY_CHECK_RET(lyd_get_or_create_leafref_links_record(node, &rec, 1));
3679 LY_ARRAY_FOR(rec->leafref_nodes, u) {
3680 if (rec->leafref_nodes[u] == leafref_node) {
3681 return LY_SUCCESS;
3682 }
3683 }
3684
3685 LY_ARRAY_NEW_RET(LYD_CTX(node), rec->leafref_nodes, item, LY_EMEM);
3686 *item = leafref_node;
steweg67388952024-01-25 12:14:50 +01003687
3688 /* add target node into the list of leafref node*/
stewegf9041a22024-01-18 13:29:12 +01003689 LY_CHECK_RET(lyd_get_or_create_leafref_links_record(leafref_node, &rec, 1));
steweg67388952024-01-25 12:14:50 +01003690 LY_ARRAY_FOR(rec->target_nodes, u) {
3691 if (rec->target_nodes[u] == node) {
3692 return LY_SUCCESS;
3693 }
3694 }
3695
3696 LY_ARRAY_NEW_RET(LYD_CTX(node), rec->target_nodes, item, LY_EMEM);
3697 *item = node;
3698
stewegf9041a22024-01-18 13:29:12 +01003699 return LY_SUCCESS;
3700}
3701
3702LIBYANG_API_DEF LY_ERR
3703lyd_leafref_link_node_tree(const struct lyd_node *tree)
3704{
3705 const struct lyd_node *sibling, *elem;
steweg67388952024-01-25 12:14:50 +01003706 struct ly_set *targets = NULL;
stewegf9041a22024-01-18 13:29:12 +01003707 char *errmsg;
3708 struct lyd_node_term *leafref_node;
3709 struct lysc_node_leaf *leaf_schema;
3710 struct lysc_type_leafref *lref;
steweg67388952024-01-25 12:14:50 +01003711 LY_ERR ret = LY_SUCCESS;
3712 uint32_t i;
stewegf9041a22024-01-18 13:29:12 +01003713
3714 LY_CHECK_ARG_RET(NULL, tree, LY_EINVAL);
3715
3716 if (!(ly_ctx_get_options(LYD_CTX(tree)) & LY_CTX_LEAFREF_LINKING)) {
3717 return LY_EDENIED;
3718 }
3719
3720 LY_LIST_FOR(tree, sibling) {
3721 LYD_TREE_DFS_BEGIN(sibling, elem) {
steweg0e1e5092024-02-12 09:06:04 +01003722 if (elem->schema && (elem->schema->nodetype & LYD_NODE_TERM)) {
stewegf9041a22024-01-18 13:29:12 +01003723 leafref_node = (struct lyd_node_term *)elem;
3724 leaf_schema = (struct lysc_node_leaf *)elem->schema;
Michal Vaskob46061d2024-01-18 13:58:13 +01003725
stewegf9041a22024-01-18 13:29:12 +01003726 if (leaf_schema->type->basetype == LY_TYPE_LEAFREF) {
3727 lref = (struct lysc_type_leafref *)leaf_schema->type;
steweg67388952024-01-25 12:14:50 +01003728 ly_set_free(targets, NULL);
3729 if (lyplg_type_resolve_leafref(lref, elem, &leafref_node->value, tree, &targets, &errmsg)) {
Michal Vaskob46061d2024-01-18 13:58:13 +01003730 /* leafref target not found */
stewegf9041a22024-01-18 13:29:12 +01003731 free(errmsg);
Michal Vaskob46061d2024-01-18 13:58:13 +01003732 } else {
3733 /* leafref target found, link it */
steweg67388952024-01-25 12:14:50 +01003734 for (i = 0; i < targets->count; ++i) {
3735 if (targets->dnodes[i]->schema->nodetype & LYD_NODE_TERM) {
3736 ret = lyd_link_leafref_node((struct lyd_node_term *)targets->dnodes[i], leafref_node);
3737 LY_CHECK_GOTO(ret, cleanup);
3738 }
3739 }
stewegf9041a22024-01-18 13:29:12 +01003740 }
3741 }
3742 }
3743 LYD_TREE_DFS_END(sibling, elem);
3744 }
3745 }
Michal Vaskob46061d2024-01-18 13:58:13 +01003746
steweg67388952024-01-25 12:14:50 +01003747cleanup:
3748 ly_set_free(targets, NULL);
3749 return ret;
stewegf9041a22024-01-18 13:29:12 +01003750}
3751
3752LY_ERR
3753lyd_unlink_leafref_node(const struct lyd_node_term *node, const struct lyd_node_term *leafref_node)
3754{
3755 LY_ERR ret;
3756 struct lyd_leafref_links_rec *rec;
3757
3758 assert(node);
3759 assert(leafref_node);
3760
3761 if (!(ly_ctx_get_options(LYD_CTX(node)) & LY_CTX_LEAFREF_LINKING)) {
3762 return LY_EDENIED;
3763 }
3764
steweg67388952024-01-25 12:14:50 +01003765 /* remove link from target node to leafref node */
stewegf9041a22024-01-18 13:29:12 +01003766 ret = lyd_get_or_create_leafref_links_record(node, &rec, 0);
3767 if (ret == LY_SUCCESS) {
3768 LY_ARRAY_REMOVE_VALUE(rec->leafref_nodes, leafref_node);
steweg67388952024-01-25 12:14:50 +01003769 if ((LY_ARRAY_COUNT(rec->leafref_nodes) == 0) && (LY_ARRAY_COUNT(rec->target_nodes) == 0)) {
stewegf9041a22024-01-18 13:29:12 +01003770 lyd_free_leafref_nodes(node);
3771 }
3772 } else if (ret != LY_ENOTFOUND) {
3773 return ret;
3774 }
3775
steweg67388952024-01-25 12:14:50 +01003776 /* remove link from leafref node to target node */
stewegf9041a22024-01-18 13:29:12 +01003777 ret = lyd_get_or_create_leafref_links_record(leafref_node, &rec, 0);
3778 if (ret == LY_SUCCESS) {
steweg67388952024-01-25 12:14:50 +01003779 LY_ARRAY_REMOVE_VALUE(rec->target_nodes, node);
3780 if ((LY_ARRAY_COUNT(rec->leafref_nodes) == 0) && (LY_ARRAY_COUNT(rec->target_nodes) == 0)) {
stewegf9041a22024-01-18 13:29:12 +01003781 lyd_free_leafref_nodes(leafref_node);
3782 }
3783 } else if (ret != LY_ENOTFOUND) {
3784 return ret;
3785 }
3786
3787 return LY_SUCCESS;
3788}