blob: ceaea547ac0f002012591881aa5a19e87551e48c [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
Michal Vaskob1b5c262020-03-05 14:29:47 +01002 * @file tree_data.c
Radek Krejcie7b95092019-05-15 11:03:07 +02003 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02004 * @brief Data tree functions
Radek Krejcie7b95092019-05-15 11:03:07 +02005 *
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02006 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
Radek Krejcie7b95092019-05-15 11:03:07 +02007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
16
17#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020018
Radek Krejci084289f2019-07-09 17:35:30 +020019#include <assert.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <ctype.h>
Radek Krejci47fab892020-11-05 17:02:41 +010021#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdarg.h>
23#include <stdint.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include <stdio.h>
25#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <string.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020027
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020029#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020030#include "context.h"
31#include "dict.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020032#include "diff.h"
Michal Vasko90932a92020-02-12 14:33:03 +010033#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020035#include "in_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020037#include "parser_data.h"
38#include "parser_internal.h"
Michal Vasko004d3152020-06-11 19:59:22 +020039#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020040#include "plugins.h"
Radek Krejcif1ca0ac2021-04-12 16:00:06 +020041#include "plugins_exts/metadata.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010042#include "plugins_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020043#include "plugins_types.h"
44#include "set.h"
45#include "tree.h"
46#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010047#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020048#include "tree_schema.h"
49#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020050#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020051#include "xml.h"
52#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020053
Radek Krejci7931b192020-06-25 17:05:03 +020054static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +020055lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +020056{
Michal Vasko69730152020-10-09 16:30:07 +020057 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020058 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +020059 const char *path = in->method.fpath.filepath;
60 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +020061
62 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +020063 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +020064
Radek Krejcif13b87b2020-12-01 22:02:17 +010065 if ((len >= LY_XML_SUFFIX_LEN + 1) &&
66 !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020067 format = LYD_XML;
Radek Krejcif13b87b2020-12-01 22:02:17 +010068 } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
69 !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020070 format = LYD_JSON;
Radek Krejcif13b87b2020-12-01 22:02:17 +010071 } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
72 !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020073 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +020074 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +020075 }
76
Radek Krejci7931b192020-06-25 17:05:03 +020077 return format;
78}
Radek Krejcie7b95092019-05-15 11:03:07 +020079
Michal Vaskoe0665742021-02-11 11:08:44 +010080/**
81 * @brief Parse YANG data into a data tree.
82 *
83 * @param[in] ctx libyang context.
Radek Krejcif16e2542021-02-17 15:39:23 +010084 * @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 +010085 * @param[in] parent Parent to connect the parsed nodes to, if any.
86 * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
87 * @param[in] in Input handle to read the input from.
88 * @param[in] format Expected format of the data in @p in.
89 * @param[in] parse_opts Options for parser.
90 * @param[in] val_opts Options for validation.
91 * @param[out] op Optional pointer to the parsed operation, if any.
92 * @return LY_ERR value.
93 */
94static LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +010095lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, struct lyd_node **first_p,
96 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 +020097{
Michal Vaskoe0665742021-02-11 11:08:44 +010098 LY_ERR rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +020099 struct lyd_ctx *lydctx = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100100 struct ly_set parsed = {0};
101 struct lyd_node *first;
102 uint32_t i;
Michal Vaskoddd76592022-01-17 13:34:48 +0100103 ly_bool subtree_sibling = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200104
Michal Vaskoe0665742021-02-11 11:08:44 +0100105 assert(ctx && (parent || first_p));
Radek Krejci7931b192020-06-25 17:05:03 +0200106
107 format = lyd_parse_get_format(in, format);
Michal Vaskoe0665742021-02-11 11:08:44 +0100108 if (first_p) {
109 *first_p = NULL;
110 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200111
Michal Vasko63f3d842020-07-08 10:10:14 +0200112 /* remember input position */
113 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200114
Michal Vaskoe0665742021-02-11 11:08:44 +0100115 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200116 switch (format) {
117 case LYD_XML:
Michal Vaskoddd76592022-01-17 13:34:48 +0100118 rc = lyd_parse_xml(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, NULL, &parsed,
119 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200120 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200121 case LYD_JSON:
Michal Vaskoddd76592022-01-17 13:34:48 +0100122 rc = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed,
123 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200124 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200125 case LYD_LYB:
Michal Vaskoddd76592022-01-17 13:34:48 +0100126 rc = lyd_parse_lyb(ctx, ext, parent, first_p, in, parse_opts, val_opts, LYD_TYPE_DATA_YANG, &parsed,
127 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200128 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200129 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100130 LOGARG(ctx, format);
131 rc = LY_EINVAL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100132 break;
133 }
134 LY_CHECK_GOTO(rc, cleanup);
135
136 if (parent) {
137 /* get first top-level sibling */
138 for (first = parent; first->parent; first = lyd_parent(first)) {}
139 first = lyd_first_sibling(first);
140 first_p = &first;
Radek Krejci7931b192020-06-25 17:05:03 +0200141 }
142
Michal Vaskoe0665742021-02-11 11:08:44 +0100143 if (!(parse_opts & LYD_PARSE_ONLY)) {
144 /* validate data */
Michal Vaskoddd76592022-01-17 13:34:48 +0100145 rc = 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 +0200146 &lydctx->ext_node, &lydctx->ext_val, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100147 LY_CHECK_GOTO(rc, cleanup);
148 }
Radek Krejci7931b192020-06-25 17:05:03 +0200149
Michal Vaskoe0665742021-02-11 11:08:44 +0100150 /* set the operation node */
151 if (op) {
152 *op = lydctx->op_node;
Radek Krejci1798aae2020-07-14 13:26:06 +0200153 }
154
155cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +0100156 if (lydctx) {
157 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200158 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100159 if (rc) {
160 if (parent) {
161 /* free all the parsed subtrees */
162 for (i = 0; i < parsed.count; ++i) {
163 lyd_free_tree(parsed.dnodes[i]);
164 }
165 } else {
166 /* free everything */
167 lyd_free_all(*first_p);
168 *first_p = NULL;
169 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100170 } else if (subtree_sibling) {
171 rc = LY_ENOT;
Michal Vaskoe0665742021-02-11 11:08:44 +0100172 }
173 ly_set_erase(&parsed, NULL);
174 return rc;
Radek Krejci7931b192020-06-25 17:05:03 +0200175}
176
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100177LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100178lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
179 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
180{
181 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
182
183 LY_CHECK_ARG_RET(ctx, ext, in, parent || tree, LY_EINVAL);
184 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
185 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
186
187 return lyd_parse(ctx, ext, parent, tree, in, format, parse_options, validate_options, NULL);
188}
189
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100190LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100191lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
192 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
193{
194 LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
195 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
196 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
197
Radek Krejcif16e2542021-02-17 15:39:23 +0100198 return lyd_parse(ctx, NULL, parent, tree, in, format, parse_options, validate_options, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100199}
200
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100201LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100202lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
203 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200204{
205 LY_ERR ret;
206 struct ly_in *in;
207
208 LY_CHECK_RET(ly_in_new_memory(data, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100209 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200210
211 ly_in_free(in, 0);
212 return ret;
213}
214
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100215LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200216lyd_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 +0200217 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200218{
219 LY_ERR ret;
220 struct ly_in *in;
221
222 LY_CHECK_RET(ly_in_new_fd(fd, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100223 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200224
225 ly_in_free(in, 0);
226 return ret;
227}
228
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100229LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200230lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
231 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200232{
233 LY_ERR ret;
234 struct ly_in *in;
235
236 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100237 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200238
239 ly_in_free(in, 0);
240 return ret;
241}
242
Radek Krejcif16e2542021-02-17 15:39:23 +0100243/**
244 * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
245 * for schema nodes locked inside the extension instance.
246 *
247 * At least one of @p parent, @p tree, or @p op must always be set.
248 *
249 * Specific @p data_type values have different parameter meaning as follows:
250 * - ::LYD_TYPE_RPC_NETCONF:
251 * - @p parent - must be NULL, the whole RPC is expected;
252 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
253 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
254 * a separate opaque data tree, even if the function fails, this may be returned;
255 * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
256 *
257 * - ::LYD_TYPE_NOTIF_NETCONF:
258 * - @p parent - must be NULL, the whole notification is expected;
259 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
260 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
261 * a separate opaque data tree, even if the function fails, this may be returned;
262 * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
263 *
264 * - ::LYD_TYPE_REPLY_NETCONF:
265 * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
266 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
267 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
268 * a separate opaque data tree, even if the function fails, this may be returned;
269 * - @p op - must be NULL, the reply is appended to the RPC;
270 * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
271 *
272 * @param[in] ctx libyang context.
273 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
274 * @param[in] parent Optional parent to connect the parsed nodes to.
275 * @param[in] in Input handle to read the input from.
276 * @param[in] format Expected format of the data in @p in.
277 * @param[in] data_type Expected operation to parse (@ref datatype).
278 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
279 * @param[out] op Optional parsed operation node.
280 * @return LY_ERR value.
281 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
282 */
283static LY_ERR
284lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
285 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 +0200286{
Michal Vaskoe0665742021-02-11 11:08:44 +0100287 LY_ERR rc = LY_SUCCESS;
288 struct lyd_ctx *lydctx = NULL;
289 struct ly_set parsed = {0};
290 struct lyd_node *first = NULL, *envp = NULL;
291 uint32_t i, parse_opts, val_opts;
Radek Krejci7931b192020-06-25 17:05:03 +0200292
Michal Vasko27fb0262021-02-23 09:42:01 +0100293 if (!ctx) {
294 ctx = LYD_CTX(parent);
295 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200296 if (tree) {
297 *tree = NULL;
298 }
299 if (op) {
300 *op = NULL;
301 }
302
Radek Krejci7931b192020-06-25 17:05:03 +0200303 format = lyd_parse_get_format(in, format);
Radek Krejci7931b192020-06-25 17:05:03 +0200304
Michal Vasko63f3d842020-07-08 10:10:14 +0200305 /* remember input position */
306 in->func_start = in->current;
307
Michal Vaskoe0665742021-02-11 11:08:44 +0100308 /* check params based on the data type */
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100309 if ((data_type == LYD_TYPE_RPC_NETCONF) || (data_type == LYD_TYPE_NOTIF_NETCONF)) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100310 LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100311 } else if (data_type == LYD_TYPE_REPLY_NETCONF) {
312 LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op,
313 LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100314 }
Michal Vasko140ede92022-05-10 09:27:30 +0200315 parse_opts = LYD_PARSE_ONLY | LYD_PARSE_STRICT;
Michal Vaskoe0665742021-02-11 11:08:44 +0100316 val_opts = 0;
317
318 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200319 switch (format) {
320 case LYD_XML:
Michal Vaskoddd76592022-01-17 13:34:48 +0100321 rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, NULL, &lydctx);
Michal Vasko299d5d12021-02-16 16:36:37 +0100322 if (rc && envp) {
323 /* special situation when the envelopes were parsed successfully */
324 if (tree) {
325 *tree = envp;
Michal Vasko73792a12022-05-10 09:28:45 +0200326 } else {
327 lyd_free_all(envp);
Michal Vasko299d5d12021-02-16 16:36:37 +0100328 }
Michal Vasko73792a12022-05-10 09:28:45 +0200329 goto cleanup;
Michal Vasko299d5d12021-02-16 16:36:37 +0100330 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100331 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200332 case LYD_JSON:
Michal Vaskoddd76592022-01-17 13:34:48 +0100333 rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100334 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200335 case LYD_LYB:
Michal Vaskoddd76592022-01-17 13:34:48 +0100336 rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100337 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200338 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100339 LOGARG(ctx, format);
340 rc = LY_EINVAL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200341 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200342 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100343 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci7931b192020-06-25 17:05:03 +0200344
Michal Vaskoe0665742021-02-11 11:08:44 +0100345 /* set out params correctly */
346 if (tree) {
347 if (envp) {
348 /* special out param meaning */
349 *tree = envp;
350 } else {
351 *tree = parent ? NULL : first;
352 }
353 }
354 if (op) {
355 *op = lydctx->op_node;
356 }
357
358cleanup:
359 if (lydctx) {
360 lydctx->free(lydctx);
361 }
362 if (rc) {
Michal Vasko73792a12022-05-10 09:28:45 +0200363 /* free all the parsed nodes */
364 if (parsed.count) {
365 i = parsed.count;
366 do {
367 --i;
Michal Vaskoe0665742021-02-11 11:08:44 +0100368 lyd_free_tree(parsed.dnodes[i]);
Michal Vasko73792a12022-05-10 09:28:45 +0200369 } while (i);
370 }
371 if (tree && ((format != LYD_XML) || !envp)) {
372 *tree = NULL;
373 }
374 if (op) {
375 *op = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100376 }
377 }
378 ly_set_erase(&parsed, NULL);
379 return rc;
Radek Krejcie7b95092019-05-15 11:03:07 +0200380}
Radek Krejci084289f2019-07-09 17:35:30 +0200381
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100382LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100383lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
384 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
385{
386 LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
387
388 return lyd_parse_op_(ctx, NULL, parent, in, format, data_type, tree, op);
389}
390
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100391LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100392lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
393 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
394{
395 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
396
397 LY_CHECK_ARG_RET(ctx, ext, in, data_type, parent || tree || op, LY_EINVAL);
398
399 return lyd_parse_op_(ctx, ext, parent, in, format, data_type, tree, op);
400}
401
Michal Vasko90932a92020-02-12 14:33:03 +0100402struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +0200403lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +0100404{
Michal Vaskob104f112020-07-17 09:54:54 +0200405 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +0100406 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200407 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +0100408 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +0100409
Michal Vaskob104f112020-07-17 09:54:54 +0200410 assert(new_node);
411
Michal Vasko9beceb82022-04-05 12:14:15 +0200412 if (!first_sibling || !new_node->schema || (LYD_CTX(first_sibling) != LYD_CTX(new_node))) {
Michal Vaskob104f112020-07-17 09:54:54 +0200413 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +0100414 return NULL;
415 }
416
Michal Vasko93b16062020-12-09 18:14:18 +0100417 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +0100418 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +0100419 getnext_opts = LYS_GETNEXT_OUTPUT;
420 }
421
Michal Vaskoa2756f02021-07-09 13:20:28 +0200422 if (first_sibling->parent && first_sibling->parent->schema && first_sibling->parent->children_ht) {
Michal Vaskob104f112020-07-17 09:54:54 +0200423 /* find the anchor using hashes */
424 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +0100425 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200426 while (schema) {
427 /* keep trying to find the first existing instance of the closest following schema sibling,
428 * otherwise return NULL - inserting at the end */
429 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
430 break;
431 }
432
Michal Vasko93b16062020-12-09 18:14:18 +0100433 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200434 }
435 } else {
436 /* find the anchor without hashes */
437 match = (struct lyd_node *)first_sibling;
Michal Vasko3a708622021-07-15 14:20:10 +0200438 sparent = lysc_data_parent(new_node->schema);
439 if (!sparent) {
Michal Vaskob104f112020-07-17 09:54:54 +0200440 /* we are in top-level, skip all the data from preceding modules */
441 LY_LIST_FOR(match, match) {
442 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
443 break;
444 }
445 }
446 }
447
448 /* get the first schema sibling */
Michal Vasko93b16062020-12-09 18:14:18 +0100449 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200450
451 found = 0;
452 LY_LIST_FOR(match, match) {
453 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
454 /* we have found an opaque node, which must be at the end, so use it OR
455 * modules do not match, so we must have traversed all the data from new_node module (if any),
456 * we have found the first node of the next module, that is what we want */
457 break;
458 }
459
460 /* skip schema nodes until we find the instantiated one */
461 while (!found) {
462 if (new_node->schema == schema) {
463 /* we have found the schema of the new node, continue search to find the first
464 * data node with a different schema (after our schema) */
465 found = 1;
466 break;
467 }
468 if (match->schema == schema) {
469 /* current node (match) is a data node still before the new node, continue search in data */
470 break;
471 }
Michal Vasko93b16062020-12-09 18:14:18 +0100472 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200473 assert(schema);
474 }
475
476 if (found && (match->schema != new_node->schema)) {
477 /* find the next node after we have found our node schema data instance */
478 break;
479 }
480 }
Michal Vasko90932a92020-02-12 14:33:03 +0100481 }
482
483 return match;
484}
485
Michal Vaskoc61dd062022-06-07 11:01:28 +0200486void
Michal Vaskof03ed032020-03-04 13:31:44 +0100487lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100488{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100489 struct lyd_node_inner *par;
490
Michal Vasko90932a92020-02-12 14:33:03 +0100491 assert(!node->next && (node->prev == node));
492
493 node->next = sibling->next;
494 node->prev = sibling;
495 sibling->next = node;
496 if (node->next) {
497 /* sibling had a succeeding node */
498 node->next->prev = node;
499 } else {
500 /* sibling was last, find first sibling and change its prev */
501 if (sibling->parent) {
502 sibling = sibling->parent->child;
503 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200504 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +0100505 }
506 sibling->prev = node;
507 }
508 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100509
Michal Vasko9f96a052020-03-10 09:41:45 +0100510 for (par = node->parent; par; par = par->parent) {
511 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
512 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100513 par->flags &= ~LYD_DEFAULT;
514 }
515 }
Michal Vasko90932a92020-02-12 14:33:03 +0100516}
517
Michal Vaskoc61dd062022-06-07 11:01:28 +0200518void
Michal Vaskof03ed032020-03-04 13:31:44 +0100519lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100520{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100521 struct lyd_node_inner *par;
522
Michal Vasko90932a92020-02-12 14:33:03 +0100523 assert(!node->next && (node->prev == node));
524
525 node->next = sibling;
526 /* covers situation of sibling being first */
527 node->prev = sibling->prev;
528 sibling->prev = node;
529 if (node->prev->next) {
530 /* sibling had a preceding node */
531 node->prev->next = node;
532 } else if (sibling->parent) {
533 /* sibling was first and we must also change parent child pointer */
534 sibling->parent->child = node;
535 }
536 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100537
Michal Vasko9f96a052020-03-10 09:41:45 +0100538 for (par = node->parent; par; par = par->parent) {
539 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
540 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100541 par->flags &= ~LYD_DEFAULT;
542 }
543 }
Michal Vasko90932a92020-02-12 14:33:03 +0100544}
545
546/**
Michal Vaskob104f112020-07-17 09:54:54 +0200547 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +0100548 *
Michal Vasko9f96a052020-03-10 09:41:45 +0100549 * Handles inserting into NP containers and key-less lists.
550 *
Michal Vasko90932a92020-02-12 14:33:03 +0100551 * @param[in] parent Parent to insert into.
552 * @param[in] node Node to insert.
553 */
554static void
Michal Vaskob104f112020-07-17 09:54:54 +0200555lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100556{
557 struct lyd_node_inner *par;
558
Radek Krejcia1c1e542020-09-29 16:06:52 +0200559 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +0100560 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +0100561
562 par = (struct lyd_node_inner *)parent;
563
Michal Vaskob104f112020-07-17 09:54:54 +0200564 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +0100565 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100566
Michal Vaskod989ba02020-08-24 10:59:24 +0200567 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +0100568 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
569 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100570 par->flags &= ~LYD_DEFAULT;
571 }
572 }
Michal Vasko751cb4d2020-07-14 12:25:28 +0200573}
Michal Vasko0249f7c2020-03-05 16:36:40 +0100574
Michal Vasko751cb4d2020-07-14 12:25:28 +0200575/**
576 * @brief Learn whether a list instance has all the keys.
577 *
578 * @param[in] list List instance to check.
579 * @return non-zero if all the keys were found,
580 * @return 0 otherwise.
581 */
582static int
583lyd_insert_has_keys(const struct lyd_node *list)
584{
585 const struct lyd_node *key;
586 const struct lysc_node *skey = NULL;
587
588 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +0200589 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +0200590 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
591 if (!key || (key->schema != skey)) {
592 /* key missing */
593 return 0;
594 }
595
596 key = key->next;
597 }
598
599 /* all keys found */
600 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +0100601}
602
603void
Michal Vasko6ee6f432021-07-16 09:49:14 +0200604lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node, ly_bool last)
Michal Vasko90932a92020-02-12 14:33:03 +0100605{
Michal Vaskob104f112020-07-17 09:54:54 +0200606 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +0100607
Michal Vaskob104f112020-07-17 09:54:54 +0200608 /* inserting list without its keys is not supported */
609 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +0100610 assert(!parent || !parent->schema ||
611 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +0100612
Michal Vaskob104f112020-07-17 09:54:54 +0200613 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +0100614 parent = lyd_parent(*first_sibling_p);
Michal Vasko9b368d32020-02-14 13:53:31 +0100615 }
Michal Vasko90932a92020-02-12 14:33:03 +0100616
Michal Vaskob104f112020-07-17 09:54:54 +0200617 /* get first sibling */
Michal Vasko9e685082021-01-29 14:49:09 +0100618 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +0100619
Michal Vasko9beceb82022-04-05 12:14:15 +0200620 if (last || (first_sibling && (first_sibling->flags & LYD_EXT))) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200621 /* no next anchor */
622 anchor = NULL;
623 } else {
624 /* find the anchor, our next node, so we can insert before it */
625 anchor = lyd_insert_get_next_anchor(first_sibling, node);
626 }
627
Michal Vaskob104f112020-07-17 09:54:54 +0200628 if (anchor) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200629 /* insert before the anchor */
Michal Vaskob104f112020-07-17 09:54:54 +0200630 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +0100631 if (!parent && (*first_sibling_p == anchor)) {
632 /* move first sibling */
633 *first_sibling_p = node;
634 }
Michal Vaskob104f112020-07-17 09:54:54 +0200635 } else if (first_sibling) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200636 /* insert as the last node */
Michal Vaskob104f112020-07-17 09:54:54 +0200637 lyd_insert_after_node(first_sibling->prev, node);
638 } else if (parent) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200639 /* insert as the only child */
Michal Vaskob104f112020-07-17 09:54:54 +0200640 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +0100641 } else {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200642 /* insert as the only sibling */
Michal Vaskob104f112020-07-17 09:54:54 +0200643 *first_sibling_p = node;
644 }
645
646 /* insert into parent HT */
647 lyd_insert_hash(node);
648
649 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +0200650 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +0200651 lyd_hash(parent);
652
653 /* now we can insert even the list into its parent HT */
654 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +0100655 }
Michal Vasko90932a92020-02-12 14:33:03 +0100656}
657
Michal Vasko717a4c32020-12-07 09:40:10 +0100658/**
659 * @brief Check schema place of a node to be inserted.
660 *
661 * @param[in] parent Schema node of the parent data node.
662 * @param[in] sibling Schema node of a sibling data node.
663 * @param[in] schema Schema node if the data node to be inserted.
664 * @return LY_SUCCESS on success.
665 * @return LY_EINVAL if the place is invalid.
666 */
Michal Vaskof03ed032020-03-04 13:31:44 +0100667static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +0100668lyd_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 +0100669{
670 const struct lysc_node *par2;
671
Michal Vasko62ed12d2020-05-21 10:08:25 +0200672 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +0100673 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
674 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +0100675
Michal Vasko717a4c32020-12-07 09:40:10 +0100676 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +0100677 /* opaque nodes can be inserted wherever */
678 return LY_SUCCESS;
679 }
680
Michal Vasko717a4c32020-12-07 09:40:10 +0100681 if (!parent) {
682 parent = lysc_data_parent(sibling);
683 }
684
Michal Vaskof03ed032020-03-04 13:31:44 +0100685 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +0200686 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +0100687
688 if (parent) {
689 /* inner node */
690 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +0200691 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +0200692 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100693 return LY_EINVAL;
694 }
695 } else {
696 /* top-level node */
697 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +0200698 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100699 return LY_EINVAL;
700 }
701 }
702
703 return LY_SUCCESS;
704}
705
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100706LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +0200707lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +0100708{
709 struct lyd_node *iter;
710
Michal Vasko0ab974d2021-02-24 13:18:26 +0100711 LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100712 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(parent), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100713
Michal Vasko717a4c32020-12-07 09:40:10 +0100714 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100715
Michal Vasko0ab974d2021-02-24 13:18:26 +0100716 if (node->schema && (node->schema->flags & LYS_KEY)) {
Michal Vaskoddd76592022-01-17 13:34:48 +0100717 LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100718 return LY_EINVAL;
719 }
720
721 if (node->parent || node->prev->next) {
722 lyd_unlink_tree(node);
723 }
724
725 while (node) {
726 iter = node->next;
727 lyd_unlink_tree(node);
Michal Vasko6ee6f432021-07-16 09:49:14 +0200728 lyd_insert_node(parent, NULL, node, 0);
Michal Vaskof03ed032020-03-04 13:31:44 +0100729 node = iter;
730 }
731 return LY_SUCCESS;
732}
733
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100734LIBYANG_API_DEF LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200735lyplg_ext_insert(struct lyd_node *parent, struct lyd_node *first)
Michal Vaskoddd76592022-01-17 13:34:48 +0100736{
737 struct lyd_node *iter;
738
739 LY_CHECK_ARG_RET(NULL, parent, first, !first->parent, !first->prev->next,
740 !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
741
742 if (first->schema && (first->schema->flags & LYS_KEY)) {
743 LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", first->schema->name);
744 return LY_EINVAL;
745 }
746
747 while (first) {
748 iter = first->next;
749 lyd_unlink_tree(first);
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100750 lyd_insert_node(parent, NULL, first, 1);
Michal Vaskoddd76592022-01-17 13:34:48 +0100751 first = iter;
752 }
753 return LY_SUCCESS;
754}
755
756LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +0200757lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100758{
759 struct lyd_node *iter;
760
Michal Vaskob104f112020-07-17 09:54:54 +0200761 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100762
Michal Vaskob104f112020-07-17 09:54:54 +0200763 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +0100764 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100765 }
766
Michal Vasko553d0b52020-12-04 16:27:52 +0100767 if (sibling == node) {
768 /* we need to keep the connection to siblings so we can insert into them */
769 sibling = sibling->prev;
770 }
771
Michal Vaskob1b5c262020-03-05 14:29:47 +0100772 if (node->parent || node->prev->next) {
773 lyd_unlink_tree(node);
774 }
775
776 while (node) {
Michal Vasko71e795e2020-12-04 16:27:37 +0100777 if (lysc_is_key(node->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200778 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +0200779 return LY_EINVAL;
780 }
781
Michal Vaskob1b5c262020-03-05 14:29:47 +0100782 iter = node->next;
783 lyd_unlink_tree(node);
Michal Vasko6ee6f432021-07-16 09:49:14 +0200784 lyd_insert_node(NULL, &sibling, node, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100785 node = iter;
786 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100787
Michal Vaskob104f112020-07-17 09:54:54 +0200788 if (first) {
789 /* find the first sibling */
790 *first = sibling;
791 while ((*first)->prev->next) {
792 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100793 }
794 }
795
796 return LY_SUCCESS;
797}
798
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100799LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +0100800lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
801{
Michal Vaskobce230b2022-04-19 09:55:31 +0200802 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100803 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100804
Michal Vasko717a4c32020-12-07 09:40:10 +0100805 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100806
Michal Vaskoab7a2bf2022-04-01 14:37:54 +0200807 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200808 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +0100809 return LY_EINVAL;
810 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +0200811 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
812 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert before a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +0100813 return LY_EINVAL;
814 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100815
Michal Vasko4bc2ce32020-12-08 10:06:16 +0100816 lyd_unlink_tree(node);
817 lyd_insert_before_node(sibling, node);
818 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +0100819
Michal Vaskof03ed032020-03-04 13:31:44 +0100820 return LY_SUCCESS;
821}
822
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100823LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +0100824lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
825{
Michal Vaskobce230b2022-04-19 09:55:31 +0200826 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100827 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100828
Michal Vasko717a4c32020-12-07 09:40:10 +0100829 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100830
Michal Vaskoab7a2bf2022-04-01 14:37:54 +0200831 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200832 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +0100833 return LY_EINVAL;
834 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +0200835 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
836 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert after a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +0100837 return LY_EINVAL;
838 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100839
Michal Vasko4bc2ce32020-12-08 10:06:16 +0100840 lyd_unlink_tree(node);
841 lyd_insert_after_node(sibling, node);
842 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +0100843
Michal Vaskof03ed032020-03-04 13:31:44 +0100844 return LY_SUCCESS;
845}
846
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100847LIBYANG_API_DEF void
Michal Vasko66d508c2021-07-21 16:07:09 +0200848lyd_unlink_siblings(struct lyd_node *node)
849{
850 struct lyd_node *next, *elem, *first = NULL;
851
852 LY_LIST_FOR_SAFE(node, next, elem) {
853 lyd_unlink_tree(elem);
854 lyd_insert_node(NULL, &first, elem, 1);
855 }
856}
857
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100858LIBYANG_API_DEF void
Michal Vaskof03ed032020-03-04 13:31:44 +0100859lyd_unlink_tree(struct lyd_node *node)
860{
861 struct lyd_node *iter;
862
863 if (!node) {
864 return;
865 }
866
Michal Vaskob104f112020-07-17 09:54:54 +0200867 /* update hashes while still linked into the tree */
868 lyd_unlink_hash(node);
869
Michal Vaskof03ed032020-03-04 13:31:44 +0100870 /* unlink from siblings */
871 if (node->prev->next) {
872 node->prev->next = node->next;
873 }
874 if (node->next) {
875 node->next->prev = node->prev;
876 } else {
877 /* unlinking the last node */
878 if (node->parent) {
879 iter = node->parent->child;
880 } else {
881 iter = node->prev;
882 while (iter->prev != node) {
883 iter = iter->prev;
884 }
885 }
886 /* update the "last" pointer from the first node */
887 iter->prev = node->prev;
888 }
889
890 /* unlink from parent */
891 if (node->parent) {
892 if (node->parent->child == node) {
893 /* the node is the first child */
894 node->parent->child = node->next;
895 }
896
Michal Vaskoab49dbe2020-07-17 12:32:47 +0200897 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko69730152020-10-09 16:30:07 +0200898 if (node->parent->schema && (node->parent->schema->nodetype == LYS_CONTAINER) &&
899 !(node->parent->flags & LYD_DEFAULT) && !(node->parent->schema->flags & LYS_PRESENCE)) {
Michal Vaskoab49dbe2020-07-17 12:32:47 +0200900 LY_LIST_FOR(node->parent->child, iter) {
901 if ((iter != node) && !(iter->flags & LYD_DEFAULT)) {
902 break;
903 }
904 }
905 if (!iter) {
906 node->parent->flags |= LYD_DEFAULT;
907 }
908 }
909
Michal Vaskof03ed032020-03-04 13:31:44 +0100910 node->parent = NULL;
911 }
912
913 node->next = NULL;
914 node->prev = node;
915}
916
Michal Vaskoa5da3292020-08-12 13:10:50 +0200917void
Michal Vasko871a0252020-11-11 18:35:24 +0100918lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +0200919{
920 struct lyd_meta *last, *iter;
921
922 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200923
924 if (!meta) {
925 return;
926 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200927
928 for (iter = meta; iter; iter = iter->next) {
929 iter->parent = parent;
930 }
931
932 /* insert as the last attribute */
933 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +0200934 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +0200935 last->next = meta;
936 } else {
937 parent->meta = meta;
938 }
939
940 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +0100941 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200942 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +0100943 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +0200944 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200945}
946
947LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +0100948lyd_create_meta(struct lyd_node *parent, struct lyd_meta **meta, const struct lys_module *mod, const char *name,
Radek Krejci8df109d2021-04-23 12:19:08 +0200949 size_t name_len, const char *value, size_t value_len, ly_bool *dynamic, LY_VALUE_FORMAT format,
Michal Vaskoddd76592022-01-17 13:34:48 +0100950 void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node, ly_bool clear_dflt, ly_bool *incomplete)
Michal Vasko90932a92020-02-12 14:33:03 +0100951{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100952 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100953 struct lysc_ext_instance *ant = NULL;
Michal Vasko193dacd2022-10-13 08:43:05 +0200954 const struct lysc_type *ant_type;
Michal Vasko9f96a052020-03-10 09:41:45 +0100955 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200956 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100957
Michal Vasko9f96a052020-03-10 09:41:45 +0100958 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100959
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200960 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko193dacd2022-10-13 08:43:05 +0200961 if (!strncmp(mod->compiled->exts[u].def->plugin->id, "ly2 metadata", 12) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200962 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +0100963 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200964 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +0100965 break;
966 }
967 }
968 if (!ant) {
969 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100970 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Radek Krejci422afb12021-03-04 16:38:16 +0100971 mod->name, (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100972 ret = LY_EINVAL;
973 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +0100974 }
975
Michal Vasko9f96a052020-03-10 09:41:45 +0100976 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100977 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +0100978 mt->parent = parent;
979 mt->annotation = ant;
Michal Vasko193dacd2022-10-13 08:43:05 +0200980 lyplg_ext_get_storage(ant, LY_STMT_TYPE, (const void **)&ant_type);
981 ret = lyd_value_store(mod->ctx, &mt->value, ant_type, value, value_len, dynamic, format, prefix_data, hints,
Michal Vaskoddd76592022-01-17 13:34:48 +0100982 ctx_node, incomplete);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100983 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
984 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
985 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +0100986
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100987 /* insert as the last attribute */
988 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +0100989 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +0100990 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +0200991 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +0100992 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +0100993 }
994
Michal Vasko9f96a052020-03-10 09:41:45 +0100995 if (meta) {
996 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +0100997 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100998
999cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +01001000 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01001001}
1002
Michal Vaskoa5da3292020-08-12 13:10:50 +02001003void
1004lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
1005{
1006 struct lyd_attr *last, *iter;
1007 struct lyd_node_opaq *opaq;
1008
1009 assert(parent && !parent->schema);
1010
1011 if (!attr) {
1012 return;
1013 }
1014
1015 opaq = (struct lyd_node_opaq *)parent;
1016 for (iter = attr; iter; iter = iter->next) {
1017 iter->parent = opaq;
1018 }
1019
1020 /* insert as the last attribute */
1021 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001022 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02001023 last->next = attr;
1024 } else {
1025 opaq->attr = attr;
1026 }
1027}
1028
Michal Vasko52927e22020-03-16 17:26:14 +01001029LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001030lyd_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 +01001031 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 +02001032 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 +01001033{
Radek Krejci011e4aa2020-09-04 15:22:31 +02001034 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001035 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01001036
1037 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001038 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01001039
Michal Vasko2a3722d2021-06-16 11:52:39 +02001040 if (!value_len && (!dynamic || !*dynamic)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001041 value = "";
1042 }
1043
1044 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001045 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02001046
Michal Vaskoad92b672020-11-12 13:11:31 +01001047 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001048 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001049 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001050 }
1051 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001052 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001053 }
1054
Michal Vasko52927e22020-03-16 17:26:14 +01001055 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001056 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
1057 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001058 *dynamic = 0;
1059 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001060 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001061 }
Michal Vasko501af032020-11-11 20:27:44 +01001062 at->format = format;
1063 at->val_prefix_data = val_prefix_data;
1064 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01001065
1066 /* insert as the last attribute */
1067 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02001068 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01001069 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001070 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01001071 last->next = at;
1072 }
1073
Radek Krejci011e4aa2020-09-04 15:22:31 +02001074finish:
1075 if (ret) {
1076 lyd_free_attr_single(ctx, at);
1077 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01001078 *attr = at;
1079 }
1080 return LY_SUCCESS;
1081}
1082
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001083LIBYANG_API_DEF const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02001084lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02001085{
Michal Vasko004d3152020-06-11 19:59:22 +02001086 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02001087
Michal Vasko004d3152020-06-11 19:59:22 +02001088 if (ly_path_eval(path, tree, &target)) {
1089 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02001090 }
1091
Michal Vasko004d3152020-06-11 19:59:22 +02001092 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02001093}
1094
aPiecek2f63f952021-03-30 12:22:18 +02001095/**
1096 * @brief Check the equality of the two schemas from different contexts.
1097 *
1098 * @param schema1 of first node.
1099 * @param schema2 of second node.
1100 * @return 1 if the schemas are equal otherwise 0.
1101 */
1102static ly_bool
1103lyd_compare_schema_equal(const struct lysc_node *schema1, const struct lysc_node *schema2)
1104{
1105 if (!schema1 && !schema2) {
1106 return 1;
1107 } else if (!schema1 || !schema2) {
1108 return 0;
1109 }
1110
1111 assert(schema1->module->ctx != schema2->module->ctx);
1112
1113 if (schema1->nodetype != schema2->nodetype) {
1114 return 0;
1115 }
1116
1117 if (strcmp(schema1->name, schema2->name)) {
1118 return 0;
1119 }
1120
1121 if (strcmp(schema1->module->name, schema2->module->name)) {
1122 return 0;
1123 }
1124
1125 if (schema1->module->revision || schema2->module->revision) {
1126 if (!schema1->module->revision || !schema2->module->revision) {
1127 return 0;
1128 }
1129 if (strcmp(schema1->module->revision, schema2->module->revision)) {
1130 return 0;
1131 }
1132 }
1133
1134 return 1;
1135}
1136
1137/**
1138 * @brief Check the equality of the schemas for all parent nodes.
1139 *
1140 * Both nodes must be from different contexts.
1141 *
1142 * @param node1 Data of first node.
1143 * @param node2 Data of second node.
1144 * @return 1 if the all related parental schemas are equal otherwise 0.
1145 */
1146static ly_bool
1147lyd_compare_schema_parents_equal(const struct lyd_node *node1, const struct lyd_node *node2)
1148{
1149 const struct lysc_node *parent1, *parent2;
1150
1151 assert(node1 && node2);
1152
1153 for (parent1 = node1->schema->parent, parent2 = node2->schema->parent;
1154 parent1 && parent2;
1155 parent1 = parent1->parent, parent2 = parent2->parent) {
1156 if (!lyd_compare_schema_equal(parent1, parent2)) {
1157 return 0;
1158 }
1159 }
1160
1161 if (parent1 || parent2) {
1162 return 0;
1163 }
1164
1165 return 1;
1166}
1167
1168/**
1169 * @brief Internal implementation of @ref lyd_compare_single.
1170 * @copydoc lyd_compare_single
1171 * @param[in] parental_schemas_checked Flag used for optimization.
1172 * When this function is called for the first time, the flag must be set to 0.
1173 * The @ref lyd_compare_schema_parents_equal should be called only once during
1174 * recursive calls, and this is accomplished by setting to 1 in the lyd_compare_single_ body.
1175 */
1176static LY_ERR
1177lyd_compare_single_(const struct lyd_node *node1, const struct lyd_node *node2,
1178 uint32_t options, ly_bool parental_schemas_checked)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001179{
1180 const struct lyd_node *iter1, *iter2;
1181 struct lyd_node_term *term1, *term2;
1182 struct lyd_node_any *any1, *any2;
Michal Vasko52927e22020-03-16 17:26:14 +01001183 struct lyd_node_opaq *opaq1, *opaq2;
Michal Vaskof3c80a72022-08-17 10:22:04 +02001184 int len1, len2;
Radek Krejci084289f2019-07-09 17:35:30 +02001185
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001186 if (!node1 || !node2) {
1187 if (node1 == node2) {
1188 return LY_SUCCESS;
1189 } else {
1190 return LY_ENOT;
1191 }
1192 }
1193
aPiecek2f63f952021-03-30 12:22:18 +02001194 if (LYD_CTX(node1) == LYD_CTX(node2)) {
1195 /* same contexts */
1196 if (node1->schema != node2->schema) {
1197 return LY_ENOT;
1198 }
1199 } else {
1200 /* different contexts */
1201 if (!lyd_compare_schema_equal(node1->schema, node2->schema)) {
1202 return LY_ENOT;
1203 }
1204 if (!parental_schemas_checked) {
1205 if (!lyd_compare_schema_parents_equal(node1, node2)) {
1206 return LY_ENOT;
1207 }
1208 parental_schemas_checked = 1;
1209 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001210 }
1211
1212 if (node1->hash != node2->hash) {
1213 return LY_ENOT;
1214 }
aPiecek2f63f952021-03-30 12:22:18 +02001215 /* 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 +02001216
Michal Vasko52927e22020-03-16 17:26:14 +01001217 if (!node1->schema) {
1218 opaq1 = (struct lyd_node_opaq *)node1;
1219 opaq2 = (struct lyd_node_opaq *)node2;
aPiecek2f63f952021-03-30 12:22:18 +02001220 if ((strcmp(opaq1->name.name, opaq2->name.name)) || (opaq1->format != opaq2->format) ||
1221 (strcmp(opaq1->name.module_ns, opaq2->name.module_ns))) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001222 return LY_ENOT;
1223 }
Michal Vasko52927e22020-03-16 17:26:14 +01001224 switch (opaq1->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +02001225 case LY_VALUE_XML:
Radek Krejci09c77442021-04-26 11:10:34 +02001226 if (lyxml_value_compare(LYD_CTX(node1), opaq1->value, opaq1->val_prefix_data, LYD_CTX(node2), opaq2->value,
1227 opaq2->val_prefix_data)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001228 return LY_ENOT;
1229 }
1230 break;
Radek Krejci8df109d2021-04-23 12:19:08 +02001231 case LY_VALUE_JSON:
Radek Krejci1798aae2020-07-14 13:26:06 +02001232 /* prefixes in JSON are unique, so it is not necessary to canonize the values */
1233 if (strcmp(opaq1->value, opaq2->value)) {
1234 return LY_ENOT;
1235 }
1236 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001237 default:
Michal Vasko52927e22020-03-16 17:26:14 +01001238 /* not allowed */
Michal Vaskob7be7a82020-08-20 09:09:04 +02001239 LOGINT(LYD_CTX(node1));
Michal Vasko52927e22020-03-16 17:26:14 +01001240 return LY_EINT;
1241 }
1242 if (options & LYD_COMPARE_FULL_RECURSION) {
1243 iter1 = opaq1->child;
1244 iter2 = opaq2->child;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001245 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01001246 }
1247 return LY_SUCCESS;
1248 } else {
1249 switch (node1->schema->nodetype) {
1250 case LYS_LEAF:
1251 case LYS_LEAFLIST:
1252 if (options & LYD_COMPARE_DEFAULTS) {
1253 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
1254 return LY_ENOT;
1255 }
1256 }
1257
Michal Vasko1a2bf2e2020-06-16 13:07:48 +02001258 term1 = (struct lyd_node_term *)node1;
1259 term2 = (struct lyd_node_term *)node2;
aPiecek2f63f952021-03-30 12:22:18 +02001260
1261 /* same contexts */
1262 if (LYD_CTX(node1) == LYD_CTX(node2)) {
1263 return term1->value.realtype->plugin->compare(&term1->value, &term2->value);
1264 }
1265
1266 /* different contexts */
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001267 if (strcmp(lyd_get_value(node1), lyd_get_value(node2))) {
aPiecek2f63f952021-03-30 12:22:18 +02001268 return LY_ENOT;
1269 }
1270 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001271 case LYS_CONTAINER:
Michal Vaskoc8187dc2022-05-13 12:26:40 +02001272 case LYS_RPC:
1273 case LYS_ACTION:
1274 case LYS_NOTIF:
Michal Vasko52927e22020-03-16 17:26:14 +01001275 if (options & LYD_COMPARE_DEFAULTS) {
1276 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
1277 return LY_ENOT;
1278 }
1279 }
1280 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko9e685082021-01-29 14:49:09 +01001281 iter1 = lyd_child(node1);
1282 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01001283 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001284 }
1285 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001286 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01001287 iter1 = lyd_child(node1);
1288 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01001289
1290 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
1291 /* lists with keys, their equivalence is based on their keys */
Michal Vasko544e58a2021-01-28 14:33:41 +01001292 for (const struct lysc_node *key = lysc_node_child(node1->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02001293 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01001294 key = key->next) {
aPiecek2f63f952021-03-30 12:22:18 +02001295 if (lyd_compare_single_(iter1, iter2, options, parental_schemas_checked)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001296 return LY_ENOT;
1297 }
1298 iter1 = iter1->next;
1299 iter2 = iter2->next;
1300 }
1301 } else {
1302 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
1303
Radek Krejci0f969882020-08-21 16:56:47 +02001304all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01001305 if (!iter1 && !iter2) {
1306 /* no children, nothing to compare */
1307 return LY_SUCCESS;
1308 }
1309
Michal Vaskod989ba02020-08-24 10:59:24 +02001310 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
aPiecek2f63f952021-03-30 12:22:18 +02001311 if (lyd_compare_single_(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION, parental_schemas_checked)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001312 return LY_ENOT;
1313 }
1314 }
1315 if (iter1 || iter2) {
1316 return LY_ENOT;
1317 }
1318 }
1319 return LY_SUCCESS;
1320 case LYS_ANYXML:
1321 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02001322 any1 = (struct lyd_node_any *)node1;
1323 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01001324
1325 if (any1->value_type != any2->value_type) {
1326 return LY_ENOT;
1327 }
1328 switch (any1->value_type) {
1329 case LYD_ANYDATA_DATATREE:
1330 iter1 = any1->value.tree;
1331 iter2 = any2->value.tree;
1332 goto all_children_compare;
1333 case LYD_ANYDATA_STRING:
1334 case LYD_ANYDATA_XML:
1335 case LYD_ANYDATA_JSON:
Michal Vasko3b4ec412022-09-22 15:24:14 +02001336 if ((!any1->value.str && any2->value.str) || (any1->value.str && !any2->value.str)) {
1337 return LY_ENOT;
1338 } else if (!any1->value.str && !any2->value.str) {
1339 return LY_SUCCESS;
1340 }
Michal Vasko52927e22020-03-16 17:26:14 +01001341 len1 = strlen(any1->value.str);
1342 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02001343 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001344 return LY_ENOT;
1345 }
1346 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001347 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02001348 len1 = lyd_lyb_data_length(any1->value.mem);
1349 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko2b97d472022-08-17 09:29:03 +02001350 if ((len1 == -1) || (len2 == -1) || (len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001351 return LY_ENOT;
1352 }
1353 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001354 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001355 }
1356 }
1357
Michal Vaskob7be7a82020-08-20 09:09:04 +02001358 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001359 return LY_EINT;
1360}
Radek Krejci22ebdba2019-07-25 13:59:43 +02001361
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001362LIBYANG_API_DEF LY_ERR
aPiecek2f63f952021-03-30 12:22:18 +02001363lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
1364{
1365 return lyd_compare_single_(node1, node2, options, 0);
1366}
1367
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001368LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001369lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02001370{
Michal Vaskod989ba02020-08-24 10:59:24 +02001371 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02001372 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
1373 }
1374
Michal Vasko11a81432020-07-28 16:31:29 +02001375 if (node1 == node2) {
1376 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02001377 }
Michal Vasko11a81432020-07-28 16:31:29 +02001378 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02001379}
1380
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001381LIBYANG_API_DEF LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02001382lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
1383{
1384 if (!meta1 || !meta2) {
1385 if (meta1 == meta2) {
1386 return LY_SUCCESS;
1387 } else {
1388 return LY_ENOT;
1389 }
1390 }
1391
Michal Vaskoa8083062020-11-06 17:22:10 +01001392 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02001393 return LY_ENOT;
1394 }
1395
Michal Vasko21725742020-06-29 11:49:25 +02001396 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
1397}
1398
Radek Krejci22ebdba2019-07-25 13:59:43 +02001399/**
Michal Vasko9cf62422021-07-01 13:29:32 +02001400 * @brief Create a copy of the attribute.
1401 *
1402 * @param[in] attr Attribute to copy.
1403 * @param[in] node Opaque where to append the new attribute.
1404 * @param[out] dup Optional created attribute copy.
1405 * @return LY_ERR value.
1406 */
1407static LY_ERR
1408lyd_dup_attr_single(const struct lyd_attr *attr, struct lyd_node *node, struct lyd_attr **dup)
1409{
1410 LY_ERR ret = LY_SUCCESS;
1411 struct lyd_attr *a, *last;
1412 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)node;
1413
1414 LY_CHECK_ARG_RET(NULL, attr, node, !node->schema, LY_EINVAL);
1415
1416 /* create a copy */
1417 a = calloc(1, sizeof *attr);
1418 LY_CHECK_ERR_RET(!a, LOGMEM(LYD_CTX(node)), LY_EMEM);
1419
1420 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.name, 0, &a->name.name), finish);
1421 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.prefix, 0, &a->name.prefix), finish);
1422 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.module_ns, 0, &a->name.module_ns), finish);
1423 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->value, 0, &a->value), finish);
1424 a->hints = attr->hints;
1425 a->format = attr->format;
1426 if (attr->val_prefix_data) {
1427 ret = ly_dup_prefix_data(LYD_CTX(node), attr->format, attr->val_prefix_data, &a->val_prefix_data);
1428 LY_CHECK_GOTO(ret, finish);
1429 }
1430
1431 /* insert as the last attribute */
1432 a->parent = opaq;
1433 if (opaq->attr) {
1434 for (last = opaq->attr; last->next; last = last->next) {}
1435 last->next = a;
1436 } else {
1437 opaq->attr = a;
1438 }
1439
1440finish:
1441 if (ret) {
1442 lyd_free_attr_single(LYD_CTX(node), a);
1443 } else if (dup) {
1444 *dup = a;
1445 }
1446 return LY_SUCCESS;
1447}
1448
1449/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001450 * @brief Find @p schema equivalent in @p trg_ctx.
1451 *
1452 * @param[in] schema Schema node to find.
1453 * @param[in] trg_ctx Target context to search in.
1454 * @param[in] parent Data parent of @p schema, if any.
1455 * @param[out] trg_schema Found schema from @p trg_ctx to use.
1456 * @return LY_RRR value.
1457 */
1458static LY_ERR
Michal Vasko9beceb82022-04-05 12:14:15 +02001459lyd_dup_find_schema(const struct lysc_node *schema, const struct ly_ctx *trg_ctx, const struct lyd_node *parent,
Michal Vaskoddd76592022-01-17 13:34:48 +01001460 const struct lysc_node **trg_schema)
1461{
Michal Vasko9beceb82022-04-05 12:14:15 +02001462 const struct lysc_node *src_parent = NULL, *trg_parent = NULL, *sp, *tp;
1463 const struct lys_module *trg_mod = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +01001464 char *path;
1465
1466 if (!schema) {
1467 /* opaque node */
1468 *trg_schema = NULL;
1469 return LY_SUCCESS;
1470 }
1471
Michal Vasko9beceb82022-04-05 12:14:15 +02001472 if (lysc_data_parent(schema) && parent && parent->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001473 /* start from schema parent */
Michal Vasko9beceb82022-04-05 12:14:15 +02001474 trg_parent = parent->schema;
1475 src_parent = lysc_data_parent(schema);
1476 }
1477
1478 do {
1479 /* find the next parent */
1480 sp = schema;
1481 while (sp->parent != src_parent) {
1482 sp = sp->parent;
1483 }
1484 src_parent = sp;
1485
1486 if (!src_parent->parent) {
1487 /* find the module first */
1488 trg_mod = ly_ctx_get_module_implemented(trg_ctx, src_parent->module->name);
1489 if (!trg_mod) {
1490 LOGERR(trg_ctx, LY_ENOTFOUND, "Module \"%s\" not present/implemented in the target context.",
1491 src_parent->module->name);
1492 return LY_ENOTFOUND;
1493 }
1494 }
1495
1496 /* find the next parent */
1497 assert(trg_parent || trg_mod);
1498 tp = NULL;
1499 while ((tp = lys_getnext(tp, trg_parent, trg_mod ? trg_mod->compiled : NULL, 0))) {
1500 if (!strcmp(tp->name, src_parent->name) && !strcmp(tp->module->name, src_parent->module->name)) {
1501 break;
1502 }
1503 }
1504 if (!tp) {
1505 /* schema node not found */
1506 path = lysc_path(src_parent, LYSC_PATH_LOG, NULL, 0);
1507 LOGERR(trg_ctx, LY_ENOTFOUND, "Schema node \"%s\" not found in the target context.", path);
1508 free(path);
Michal Vaskoddd76592022-01-17 13:34:48 +01001509 return LY_ENOTFOUND;
1510 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001511
Michal Vasko9beceb82022-04-05 12:14:15 +02001512 trg_parent = tp;
1513 } while (schema != src_parent);
Michal Vaskoddd76592022-01-17 13:34:48 +01001514
Michal Vasko9beceb82022-04-05 12:14:15 +02001515 /* success */
1516 *trg_schema = trg_parent;
1517 return LY_SUCCESS;
Michal Vaskoddd76592022-01-17 13:34:48 +01001518}
1519
1520/**
Michal Vasko52927e22020-03-16 17:26:14 +01001521 * @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 +02001522 *
Michal Vaskoddd76592022-01-17 13:34:48 +01001523 * Ignores ::LYD_DUP_WITH_PARENTS and ::LYD_DUP_WITH_SIBLINGS which are supposed to be handled by lyd_dup().
Radek Krejcif8b95172020-05-15 14:51:06 +02001524 *
Michal Vaskoddd76592022-01-17 13:34:48 +01001525 * @param[in] node Node to duplicate.
1526 * @param[in] trg_ctx Target context for duplicated nodes.
Radek Krejcif8b95172020-05-15 14:51:06 +02001527 * @param[in] parent Parent to insert into, NULL for top-level sibling.
Michal Vasko67177e52021-08-25 11:15:15 +02001528 * @param[in] insert_last Whether the duplicated node can be inserted as the last child of @p parent. Set for
1529 * recursive duplication as an optimization.
Radek Krejcif8b95172020-05-15 14:51:06 +02001530 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
1531 * @param[in] options Bitmask of options flags, see @ref dupoptions.
Michal Vaskoddd76592022-01-17 13:34:48 +01001532 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it to @p parent / @p first).
1533 * @return LY_ERR value.
Radek Krejci22ebdba2019-07-25 13:59:43 +02001534 */
Michal Vasko52927e22020-03-16 17:26:14 +01001535static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001536lyd_dup_r(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent, ly_bool insert_last,
1537 struct lyd_node **first, uint32_t options, struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02001538{
Michal Vasko52927e22020-03-16 17:26:14 +01001539 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001540 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02001541 struct lyd_meta *meta;
Michal Vasko9cf62422021-07-01 13:29:32 +02001542 struct lyd_attr *attr;
Michal Vasko61551fa2020-07-09 15:45:45 +02001543 struct lyd_node_any *any;
Michal Vaskoddd76592022-01-17 13:34:48 +01001544 const struct lysc_type *type;
1545 const char *val_can;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001546
Michal Vasko52927e22020-03-16 17:26:14 +01001547 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001548
Michal Vasko19175b62022-04-01 09:17:07 +02001549 if (node->flags & LYD_EXT) {
Michal Vasko53ac4dd2022-06-07 10:56:08 +02001550 if (options & LYD_DUP_NO_EXT) {
1551 /* no not duplicate this subtree */
1552 return LY_SUCCESS;
1553 }
1554
Michal Vasko19175b62022-04-01 09:17:07 +02001555 /* we need to use the same context */
1556 trg_ctx = LYD_CTX(node);
1557 }
1558
Michal Vasko52927e22020-03-16 17:26:14 +01001559 if (!node->schema) {
1560 dup = calloc(1, sizeof(struct lyd_node_opaq));
Michal Vaskoddd76592022-01-17 13:34:48 +01001561 ((struct lyd_node_opaq *)dup)->ctx = trg_ctx;
Michal Vasko52927e22020-03-16 17:26:14 +01001562 } else {
1563 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01001564 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01001565 case LYS_ACTION:
1566 case LYS_NOTIF:
1567 case LYS_CONTAINER:
1568 case LYS_LIST:
1569 dup = calloc(1, sizeof(struct lyd_node_inner));
1570 break;
1571 case LYS_LEAF:
1572 case LYS_LEAFLIST:
1573 dup = calloc(1, sizeof(struct lyd_node_term));
1574 break;
1575 case LYS_ANYDATA:
1576 case LYS_ANYXML:
1577 dup = calloc(1, sizeof(struct lyd_node_any));
1578 break;
1579 default:
Michal Vaskoddd76592022-01-17 13:34:48 +01001580 LOGINT(trg_ctx);
Michal Vasko52927e22020-03-16 17:26:14 +01001581 ret = LY_EINT;
1582 goto error;
1583 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02001584 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001585 LY_CHECK_ERR_GOTO(!dup, LOGMEM(trg_ctx); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001586
Michal Vaskof6df0a02020-06-16 13:08:34 +02001587 if (options & LYD_DUP_WITH_FLAGS) {
1588 dup->flags = node->flags;
1589 } else {
Michal Vasko19175b62022-04-01 09:17:07 +02001590 dup->flags = (node->flags & (LYD_DEFAULT | LYD_EXT)) | LYD_NEW;
Michal Vaskof6df0a02020-06-16 13:08:34 +02001591 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001592 if (trg_ctx == LYD_CTX(node)) {
1593 dup->schema = node->schema;
1594 } else {
Michal Vasko27f536f2022-04-01 09:17:30 +02001595 ret = lyd_dup_find_schema(node->schema, trg_ctx, parent, &dup->schema);
1596 if (ret) {
1597 /* has no schema but is not an opaque node */
1598 free(dup);
1599 dup = NULL;
1600 goto error;
1601 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001602 }
Michal Vasko52927e22020-03-16 17:26:14 +01001603 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001604
Michal Vasko9cf62422021-07-01 13:29:32 +02001605 /* duplicate metadata/attributes */
Michal Vasko25a32822020-07-09 15:48:22 +02001606 if (!(options & LYD_DUP_NO_META)) {
Michal Vasko9cf62422021-07-01 13:29:32 +02001607 if (!node->schema) {
1608 LY_LIST_FOR(((struct lyd_node_opaq *)node)->attr, attr) {
1609 LY_CHECK_GOTO(ret = lyd_dup_attr_single(attr, dup, NULL), error);
1610 }
1611 } else {
1612 LY_LIST_FOR(node->meta, meta) {
1613 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
1614 }
Michal Vasko25a32822020-07-09 15:48:22 +02001615 }
1616 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02001617
1618 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01001619 if (!dup->schema) {
1620 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
1621 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
1622 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001623
1624 if (options & LYD_DUP_RECURSIVE) {
1625 /* duplicate all the children */
1626 LY_LIST_FOR(orig->child, child) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001627 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01001628 }
1629 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001630 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.name, 0, &opaq->name.name), error);
1631 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.prefix, 0, &opaq->name.prefix), error);
1632 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.module_ns, 0, &opaq->name.module_ns), error);
1633 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->value, 0, &opaq->value), error);
Michal Vasko9cf62422021-07-01 13:29:32 +02001634 opaq->hints = orig->hints;
1635 opaq->format = orig->format;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001636 if (orig->val_prefix_data) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001637 ret = ly_dup_prefix_data(trg_ctx, opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001638 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01001639 }
Michal Vasko52927e22020-03-16 17:26:14 +01001640 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
1641 struct lyd_node_term *term = (struct lyd_node_term *)dup;
1642 struct lyd_node_term *orig = (struct lyd_node_term *)node;
1643
1644 term->hash = orig->hash;
Michal Vaskoddd76592022-01-17 13:34:48 +01001645 if (trg_ctx == LYD_CTX(node)) {
1646 ret = orig->value.realtype->plugin->duplicate(trg_ctx, &orig->value, &term->value);
1647 LY_CHECK_ERR_GOTO(ret, LOGERR(trg_ctx, ret, "Value duplication failed."), error);
1648 } else {
1649 /* store canonical value in the target context */
1650 val_can = lyd_get_value(node);
1651 type = ((struct lysc_node_leaf *)term->schema)->type;
1652 ret = lyd_value_store(trg_ctx, &term->value, type, val_can, strlen(val_can), NULL, LY_VALUE_CANON, NULL,
1653 LYD_HINT_DATA, term->schema, NULL);
1654 LY_CHECK_GOTO(ret, error);
1655 }
Michal Vasko52927e22020-03-16 17:26:14 +01001656 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
1657 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
1658 struct lyd_node *child;
1659
1660 if (options & LYD_DUP_RECURSIVE) {
1661 /* duplicate all the children */
1662 LY_LIST_FOR(orig->child, child) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001663 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001664 }
Michal Vasko69730152020-10-09 16:30:07 +02001665 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02001666 /* always duplicate keys of a list */
Michal Vasko9beceb82022-04-05 12:14:15 +02001667 for (child = orig->child; child && lysc_is_key(child->schema); child = child->next) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001668 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001669 }
1670 }
1671 lyd_hash(dup);
1672 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02001673 dup->hash = node->hash;
1674 any = (struct lyd_node_any *)node;
1675 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001676 }
1677
Michal Vasko52927e22020-03-16 17:26:14 +01001678 /* insert */
Michal Vasko67177e52021-08-25 11:15:15 +02001679 lyd_insert_node(parent, first, dup, insert_last);
Michal Vasko52927e22020-03-16 17:26:14 +01001680
1681 if (dup_p) {
1682 *dup_p = dup;
1683 }
1684 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001685
1686error:
Michal Vasko52927e22020-03-16 17:26:14 +01001687 lyd_free_tree(dup);
1688 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001689}
1690
Michal Vasko29d674b2021-08-25 11:18:35 +02001691/**
1692 * @brief Get a parent node to connect duplicated subtree to.
1693 *
1694 * @param[in] node Node (subtree) to duplicate.
Michal Vaskoddd76592022-01-17 13:34:48 +01001695 * @param[in] trg_ctx Target context for duplicated nodes.
Michal Vasko29d674b2021-08-25 11:18:35 +02001696 * @param[in] parent Initial parent to connect to.
1697 * @param[in] options Bitmask of options flags, see @ref dupoptions.
1698 * @param[out] dup_parent First duplicated parent node, if any.
1699 * @param[out] local_parent Correct parent to directly connect duplicated @p node to.
1700 * @return LY_ERR value.
1701 */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001702static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001703lyd_dup_get_local_parent(const struct lyd_node *node, const struct ly_ctx *trg_ctx, const struct lyd_node_inner *parent,
1704 uint32_t options, struct lyd_node **dup_parent, struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02001705{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001706 const struct lyd_node_inner *orig_parent, *iter;
Michal Vasko83522192022-07-20 08:07:34 +02001707 ly_bool repeat = 1, ext_parent = 0;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001708
1709 *dup_parent = NULL;
1710 *local_parent = NULL;
1711
Michal Vasko83522192022-07-20 08:07:34 +02001712 if (node->flags & LYD_EXT) {
1713 ext_parent = 1;
1714 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001715 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
Michal Vasko83522192022-07-20 08:07:34 +02001716 if (ext_parent) {
1717 /* use the standard context */
1718 trg_ctx = LYD_CTX(orig_parent);
1719 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001720 if (parent && (parent->schema == orig_parent->schema)) {
1721 /* stop creating parents, connect what we have into the provided parent */
1722 iter = parent;
1723 repeat = 0;
1724 } else {
1725 iter = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +01001726 LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, trg_ctx, NULL, 0, (struct lyd_node **)&iter, options,
Radek Krejci0f969882020-08-21 16:56:47 +02001727 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001728 }
1729 if (!*local_parent) {
1730 *local_parent = (struct lyd_node_inner *)iter;
1731 }
1732 if (iter->child) {
1733 /* 1) list - add after keys
1734 * 2) provided parent with some children */
1735 iter->child->prev->next = *dup_parent;
1736 if (*dup_parent) {
1737 (*dup_parent)->prev = iter->child->prev;
1738 iter->child->prev = *dup_parent;
1739 }
1740 } else {
1741 ((struct lyd_node_inner *)iter)->child = *dup_parent;
1742 }
1743 if (*dup_parent) {
1744 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
1745 }
1746 *dup_parent = (struct lyd_node *)iter;
Michal Vasko83522192022-07-20 08:07:34 +02001747 if (orig_parent->flags & LYD_EXT) {
1748 ext_parent = 1;
1749 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001750 }
1751
1752 if (repeat && parent) {
1753 /* given parent and created parents chain actually do not interconnect */
Michal Vaskoddd76592022-01-17 13:34:48 +01001754 LOGERR(trg_ctx, LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02001755 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001756 return LY_EINVAL;
1757 }
1758
1759 return LY_SUCCESS;
1760}
1761
1762static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001763lyd_dup(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent, uint32_t options,
1764 ly_bool nosiblings, struct lyd_node **dup)
Michal Vasko3a41dff2020-07-15 14:30:28 +02001765{
1766 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001767 const struct lyd_node *orig; /* original node to be duplicated */
1768 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02001769 struct lyd_node *top = NULL; /* the most higher created node */
1770 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02001771
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001772 assert(node && trg_ctx);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001773
1774 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001775 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 +02001776 &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001777 } else {
1778 local_parent = parent;
1779 }
1780
Radek Krejci22ebdba2019-07-25 13:59:43 +02001781 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01001782 if (lysc_is_key(orig->schema)) {
1783 if (local_parent) {
1784 /* the key must already exist in the parent */
1785 rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
Michal Vaskoddd76592022-01-17 13:34:48 +01001786 LY_CHECK_ERR_GOTO(rc, LOGINT(trg_ctx), error);
Michal Vasko35f4d772021-01-12 12:08:57 +01001787 } else {
1788 assert(!(options & LYD_DUP_WITH_PARENTS));
1789 /* duplicating a single key, okay, I suppose... */
Michal Vaskoddd76592022-01-17 13:34:48 +01001790 rc = lyd_dup_r(orig, trg_ctx, NULL, 0, &first, options, first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01001791 LY_CHECK_GOTO(rc, error);
1792 }
1793 } else {
1794 /* if there is no local parent, it will be inserted into first */
Michal Vaskoddd76592022-01-17 13:34:48 +01001795 rc = lyd_dup_r(orig, trg_ctx, local_parent ? &local_parent->node : NULL, 0, &first, options,
1796 first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01001797 LY_CHECK_GOTO(rc, error);
1798 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001799 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02001800 break;
1801 }
1802 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001803
Michal Vasko3a41dff2020-07-15 14:30:28 +02001804 if (dup) {
1805 *dup = first;
1806 }
1807 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001808
1809error:
1810 if (top) {
1811 lyd_free_tree(top);
1812 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01001813 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001814 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001815 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001816}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02001817
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001818/**
1819 * @brief Check the context of node and parent when duplicating nodes.
1820 *
1821 * @param[in] node Node to duplicate.
1822 * @param[in] parent Parent of the duplicated node(s).
1823 * @return LY_ERR value.
1824 */
1825static LY_ERR
1826lyd_dup_ctx_check(const struct lyd_node *node, const struct lyd_node_inner *parent)
1827{
1828 const struct lyd_node *iter;
1829
1830 if (!node || !parent) {
1831 return LY_SUCCESS;
1832 }
1833
1834 if ((LYD_CTX(node) != LYD_CTX(parent))) {
1835 /* try to find top-level ext data parent */
1836 for (iter = node; iter && !(iter->flags & LYD_EXT); iter = lyd_parent(iter)) {}
1837
1838 if (!iter || !lyd_parent(iter) || (LYD_CTX(lyd_parent(iter)) != LYD_CTX(parent))) {
1839 LOGERR(NULL, LY_EINVAL, "Different contexts used in node duplication.");
1840 return LY_EINVAL;
1841 }
1842 }
1843
1844 return LY_SUCCESS;
1845}
1846
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001847LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001848lyd_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 +02001849{
Michal Vaskoddd76592022-01-17 13:34:48 +01001850 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001851 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01001852
1853 return lyd_dup(node, LYD_CTX(node), parent, options, 1, dup);
1854}
1855
1856LIBYANG_API_DEF LY_ERR
1857lyd_dup_single_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
1858 uint32_t options, struct lyd_node **dup)
1859{
1860 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
1861
1862 return lyd_dup(node, trg_ctx, parent, options, 1, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001863}
1864
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001865LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001866lyd_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 +02001867{
Michal Vaskoddd76592022-01-17 13:34:48 +01001868 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001869 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01001870
1871 return lyd_dup(node, LYD_CTX(node), parent, options, 0, dup);
1872}
1873
1874LIBYANG_API_DEF LY_ERR
1875lyd_dup_siblings_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
1876 uint32_t options, struct lyd_node **dup)
1877{
1878 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
1879
1880 return lyd_dup(node, trg_ctx, parent, options, 0, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001881}
1882
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001883LIBYANG_API_DEF LY_ERR
Michal Vasko3a41dff2020-07-15 14:30:28 +02001884lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02001885{
Radek Krejci011e4aa2020-09-04 15:22:31 +02001886 LY_ERR ret = LY_SUCCESS;
Michal Vasko33c48972022-07-20 10:28:07 +02001887 const struct ly_ctx *ctx;
Michal Vasko25a32822020-07-09 15:48:22 +02001888 struct lyd_meta *mt, *last;
1889
Michal Vasko3a41dff2020-07-15 14:30:28 +02001890 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02001891
Michal Vasko33c48972022-07-20 10:28:07 +02001892 /* log to node context but value must always use the annotation context */
1893 ctx = meta->annotation->module->ctx;
1894
Michal Vasko25a32822020-07-09 15:48:22 +02001895 /* create a copy */
1896 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02001897 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02001898 mt->annotation = meta->annotation;
Michal Vasko33c48972022-07-20 10:28:07 +02001899 ret = meta->value.realtype->plugin->duplicate(ctx, &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02001900 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
Michal Vasko33c48972022-07-20 10:28:07 +02001901 LY_CHECK_GOTO(ret = lydict_insert(ctx, meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02001902
1903 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02001904 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02001905 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001906 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02001907 last->next = mt;
1908 } else {
1909 node->meta = mt;
1910 }
1911
Radek Krejci011e4aa2020-09-04 15:22:31 +02001912finish:
1913 if (ret) {
1914 lyd_free_meta_single(mt);
1915 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001916 *dup = mt;
1917 }
1918 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02001919}
1920
Michal Vasko4490d312020-06-16 13:08:55 +02001921/**
1922 * @brief Merge a source sibling into target siblings.
1923 *
1924 * @param[in,out] first_trg First target sibling, is updated if top-level.
1925 * @param[in] parent_trg Target parent.
1926 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
Michal Vaskocd3f6172021-05-18 16:14:50 +02001927 * @param[in] merge_cb Optional merge callback.
1928 * @param[in] cb_data Arbitrary callback data.
Michal Vasko4490d312020-06-16 13:08:55 +02001929 * @param[in] options Merge options.
Michal Vaskocd3f6172021-05-18 16:14:50 +02001930 * @param[in,out] dup_inst Duplicate instance cache for all @p first_trg siblings.
Michal Vasko4490d312020-06-16 13:08:55 +02001931 * @return LY_ERR value.
1932 */
1933static LY_ERR
1934lyd_merge_sibling_r(struct lyd_node **first_trg, struct lyd_node *parent_trg, const struct lyd_node **sibling_src_p,
Michal Vaskocd3f6172021-05-18 16:14:50 +02001935 lyd_merge_cb merge_cb, void *cb_data, uint16_t options, struct lyd_dup_inst **dup_inst)
Michal Vasko4490d312020-06-16 13:08:55 +02001936{
Michal Vasko4490d312020-06-16 13:08:55 +02001937 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02001938 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vaskod1afa502022-01-27 16:18:12 +01001939 struct lyd_node_opaq *opaq_trg, *opaq_src;
Michal Vasko4490d312020-06-16 13:08:55 +02001940 struct lysc_type *type;
Michal Vaskocd3f6172021-05-18 16:14:50 +02001941 struct lyd_dup_inst *child_dup_inst = NULL;
1942 LY_ERR ret;
1943 ly_bool first_inst = 0;
Michal Vasko4490d312020-06-16 13:08:55 +02001944
1945 sibling_src = *sibling_src_p;
Michal Vaskocd3f6172021-05-18 16:14:50 +02001946 if (!sibling_src->schema) {
1947 /* try to find the same opaque node */
1948 lyd_find_sibling_opaq_next(*first_trg, LYD_NAME(sibling_src), &match_trg);
1949 } else if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
Michal Vasko4490d312020-06-16 13:08:55 +02001950 /* try to find the exact instance */
Michal Vaskocd3f6172021-05-18 16:14:50 +02001951 lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02001952 } else {
1953 /* try to simply find the node, there cannot be more instances */
Michal Vaskocd3f6172021-05-18 16:14:50 +02001954 lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02001955 }
1956
Michal Vaskocd3f6172021-05-18 16:14:50 +02001957 if (match_trg) {
1958 /* update match as needed */
1959 LY_CHECK_RET(lyd_dup_inst_next(&match_trg, *first_trg, dup_inst));
1960 } else {
1961 /* first instance of this node */
1962 first_inst = 1;
1963 }
1964
1965 if (match_trg) {
1966 /* call callback */
1967 if (merge_cb) {
1968 LY_CHECK_RET(merge_cb(match_trg, sibling_src, cb_data));
1969 }
1970
Michal Vasko4490d312020-06-16 13:08:55 +02001971 /* node found, make sure even value matches for all node types */
Michal Vaskod1afa502022-01-27 16:18:12 +01001972 if (!match_trg->schema) {
1973 if (lyd_compare_single(sibling_src, match_trg, 0)) {
1974 /* update value */
1975 opaq_trg = (struct lyd_node_opaq *)match_trg;
1976 opaq_src = (struct lyd_node_opaq *)sibling_src;
1977
1978 lydict_remove(LYD_CTX(opaq_trg), opaq_trg->value);
1979 lydict_insert(LYD_CTX(opaq_trg), opaq_src->value, 0, &opaq_trg->value);
1980 opaq_trg->hints = opaq_src->hints;
1981
1982 ly_free_prefix_data(opaq_trg->format, opaq_trg->val_prefix_data);
1983 opaq_trg->format = opaq_src->format;
1984 ly_dup_prefix_data(LYD_CTX(opaq_trg), opaq_src->format, opaq_src->val_prefix_data,
1985 &opaq_trg->val_prefix_data);
1986 }
1987 } else if ((match_trg->schema->nodetype == LYS_LEAF) &&
1988 lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02001989 /* since they are different, they cannot both be default */
1990 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
1991
Michal Vasko3a41dff2020-07-15 14:30:28 +02001992 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
1993 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02001994 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02001995 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
1996 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02001997 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02001998
1999 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002000 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vasko4490d312020-06-16 13:08:55 +02002001 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002002 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002003 /* update value */
2004 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002005 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002006
2007 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002008 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002009 }
2010
2011 /* check descendants, recursively */
2012 ret = LY_SUCCESS;
2013 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
2014 ret = lyd_merge_sibling_r(lyd_node_child_p(match_trg), match_trg, &child_src, merge_cb, cb_data, options,
2015 &child_dup_inst);
2016 if (ret) {
2017 break;
Michal Vasko4490d312020-06-16 13:08:55 +02002018 }
2019 }
Michal Vaskocd3f6172021-05-18 16:14:50 +02002020 lyd_dup_inst_free(child_dup_inst);
2021 LY_CHECK_RET(ret);
Michal Vasko4490d312020-06-16 13:08:55 +02002022 } else {
2023 /* node not found, merge it */
2024 if (options & LYD_MERGE_DESTRUCT) {
2025 dup_src = (struct lyd_node *)sibling_src;
2026 lyd_unlink_tree(dup_src);
2027 /* spend it */
2028 *sibling_src_p = NULL;
2029 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002030 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 +02002031 }
2032
Michal Vasko7e8315b2021-08-03 17:01:06 +02002033 if (!(options & LYD_MERGE_WITH_FLAGS)) {
2034 /* set LYD_NEW for all the new nodes, required for validation */
2035 LYD_TREE_DFS_BEGIN(dup_src, elem) {
2036 elem->flags |= LYD_NEW;
2037 LYD_TREE_DFS_END(dup_src, elem);
2038 }
Michal Vasko4490d312020-06-16 13:08:55 +02002039 }
2040
Michal Vaskocd3f6172021-05-18 16:14:50 +02002041 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02002042 lyd_insert_node(parent_trg, first_trg, dup_src, 0);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002043
2044 if (first_inst) {
2045 /* remember not to find this instance next time */
2046 LY_CHECK_RET(lyd_dup_inst_next(&dup_src, *first_trg, dup_inst));
2047 }
2048
2049 /* call callback, no source node */
2050 if (merge_cb) {
2051 LY_CHECK_RET(merge_cb(dup_src, NULL, cb_data));
2052 }
Michal Vasko4490d312020-06-16 13:08:55 +02002053 }
2054
2055 return LY_SUCCESS;
2056}
2057
Michal Vasko3a41dff2020-07-15 14:30:28 +02002058static LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002059lyd_merge(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2060 lyd_merge_cb merge_cb, void *cb_data, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02002061{
2062 const struct lyd_node *sibling_src, *tmp;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002063 struct lyd_dup_inst *dup_inst = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02002064 ly_bool first;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002065 LY_ERR ret = LY_SUCCESS;
Michal Vasko4490d312020-06-16 13:08:55 +02002066
2067 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002068 LY_CHECK_CTX_EQUAL_RET(*target ? LYD_CTX(*target) : NULL, source ? LYD_CTX(source) : NULL, mod ? mod->ctx : NULL,
2069 LY_EINVAL);
Michal Vasko4490d312020-06-16 13:08:55 +02002070
2071 if (!source) {
2072 /* nothing to merge */
2073 return LY_SUCCESS;
2074 }
2075
Michal Vasko831422b2020-11-24 11:20:51 +01002076 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002077 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02002078 return LY_EINVAL;
2079 }
2080
2081 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Michal Vaskocd3f6172021-05-18 16:14:50 +02002082 if (mod && (lyd_owner_module(sibling_src) != mod)) {
2083 /* skip data nodes from different modules */
2084 continue;
2085 }
2086
Radek Krejci857189e2020-09-01 13:26:36 +02002087 first = (sibling_src == source) ? 1 : 0;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002088 ret = lyd_merge_sibling_r(target, NULL, &sibling_src, merge_cb, cb_data, options, &dup_inst);
2089 if (ret) {
2090 break;
2091 }
Michal Vasko4490d312020-06-16 13:08:55 +02002092 if (first && !sibling_src) {
2093 /* source was spent (unlinked), move to the next node */
2094 source = tmp;
2095 }
2096
Michal Vasko3a41dff2020-07-15 14:30:28 +02002097 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02002098 break;
2099 }
2100 }
2101
2102 if (options & LYD_MERGE_DESTRUCT) {
2103 /* free any leftover source data that were not merged */
2104 lyd_free_siblings((struct lyd_node *)source);
2105 }
2106
Michal Vaskocd3f6172021-05-18 16:14:50 +02002107 lyd_dup_inst_free(dup_inst);
2108 return ret;
Michal Vasko4490d312020-06-16 13:08:55 +02002109}
2110
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002111LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002112lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002113{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002114 return lyd_merge(target, source, NULL, NULL, NULL, options, 1);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002115}
2116
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002117LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002118lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002119{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002120 return lyd_merge(target, source, NULL, NULL, NULL, options, 0);
2121}
2122
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002123LIBYANG_API_DEF LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002124lyd_merge_module(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2125 lyd_merge_cb merge_cb, void *cb_data, uint16_t options)
2126{
2127 return lyd_merge(target, source, mod, merge_cb, cb_data, options, 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002128}
2129
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002130static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002131lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002132{
Michal Vasko14654712020-02-06 08:35:21 +01002133 /* ending \0 */
2134 ++reqlen;
2135
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002136 if (reqlen > *buflen) {
2137 if (is_static) {
2138 return LY_EINCOMPLETE;
2139 }
2140
2141 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
2142 if (!*buffer) {
2143 return LY_EMEM;
2144 }
2145
2146 *buflen = reqlen;
2147 }
2148
2149 return LY_SUCCESS;
2150}
2151
Michal Vaskod59035b2020-07-08 12:00:06 +02002152LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002153lyd_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 +02002154{
2155 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002156 size_t len;
2157 const char *val;
2158 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002159
Michal Vasko824d0832021-11-04 15:36:51 +01002160 for (key = lyd_child(node); key && key->schema && (key->schema->flags & LYS_KEY); key = key->next) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002161 val = lyd_get_value(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002162 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002163 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002164
2165 quot = '\'';
2166 if (strchr(val, '\'')) {
2167 quot = '"';
2168 }
2169 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002170 }
2171
2172 return LY_SUCCESS;
2173}
2174
2175/**
2176 * @brief Append leaf-list value predicate to path.
2177 *
2178 * @param[in] node Node to print.
2179 * @param[in,out] buffer Buffer to print to.
2180 * @param[in,out] buflen Current buffer length.
2181 * @param[in,out] bufused Current number of characters used in @p buffer.
2182 * @param[in] is_static Whether buffer is static or can be reallocated.
2183 * @return LY_ERR
2184 */
2185static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002186lyd_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 +02002187{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002188 size_t len;
2189 const char *val;
2190 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002191
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002192 val = lyd_get_value(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01002193 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002194 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002195
2196 quot = '\'';
2197 if (strchr(val, '\'')) {
2198 quot = '"';
2199 }
2200 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
2201
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002202 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002203}
2204
2205/**
2206 * @brief Append node position (relative to its other instances) predicate to path.
2207 *
2208 * @param[in] node Node to print.
2209 * @param[in,out] buffer Buffer to print to.
2210 * @param[in,out] buflen Current buffer length.
2211 * @param[in,out] bufused Current number of characters used in @p buffer.
2212 * @param[in] is_static Whether buffer is static or can be reallocated.
2213 * @return LY_ERR
2214 */
2215static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002216lyd_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 +02002217{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002218 size_t len;
Michal Vasko50cc0562021-05-18 16:15:43 +02002219 uint32_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002220 char *val = NULL;
2221 LY_ERR rc;
2222
Michal Vasko50cc0562021-05-18 16:15:43 +02002223 pos = lyd_list_pos(node);
2224 if (asprintf(&val, "%" PRIu32, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002225 return LY_EMEM;
2226 }
2227
2228 len = 1 + strlen(val) + 1;
2229 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
2230 if (rc != LY_SUCCESS) {
2231 goto cleanup;
2232 }
2233
2234 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
2235
2236cleanup:
2237 free(val);
2238 return rc;
2239}
2240
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002241LIBYANG_API_DEF char *
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002242lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
2243{
Radek Krejci857189e2020-09-01 13:26:36 +02002244 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002245 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01002246 size_t bufused = 0, len;
Michal Vasko12eb6222022-03-18 13:35:49 +01002247 const struct lyd_node *iter, *parent;
2248 const struct lys_module *mod, *prev_mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02002249 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002250
2251 LY_CHECK_ARG_RET(NULL, node, NULL);
2252 if (buffer) {
Michal Vasko16385f42021-05-18 16:16:09 +02002253 LY_CHECK_ARG_RET(LYD_CTX(node), buflen > 1, NULL);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002254 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01002255 } else {
2256 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002257 }
2258
2259 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01002260 case LYD_PATH_STD:
2261 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01002262 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01002263 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002264 ++depth;
2265 }
2266
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002267 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01002268 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002269 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01002270 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002271iter_print:
Michal Vasko12eb6222022-03-18 13:35:49 +01002272 /* get the module */
2273 mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
2274 parent = lyd_parent(iter);
2275 prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
2276 if (prev_mod == mod) {
2277 mod = NULL;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002278 }
2279
2280 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01002281 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2282 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002283 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
2284 if (rc != LY_SUCCESS) {
2285 break;
2286 }
2287
2288 /* print next node */
Michal Vaskodbf3e652022-10-21 08:46:25 +02002289 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002290
Michal Vasko790b2bc2020-08-03 13:35:06 +02002291 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01002292 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02002293 switch (iter->schema->nodetype) {
2294 case LYS_LIST:
2295 if (iter->schema->flags & LYS_KEYLESS) {
2296 /* print its position */
2297 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2298 } else {
2299 /* print all list keys in predicates */
2300 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
2301 }
2302 break;
2303 case LYS_LEAFLIST:
2304 if (iter->schema->flags & LYS_CONFIG_W) {
2305 /* print leaf-list value */
2306 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
2307 } else {
2308 /* print its position */
2309 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2310 }
2311 break;
2312 default:
2313 /* nothing to print more */
2314 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002315 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002316 }
2317 if (rc != LY_SUCCESS) {
2318 break;
2319 }
2320
Michal Vasko14654712020-02-06 08:35:21 +01002321 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002322 }
2323 break;
2324 }
2325
2326 return buffer;
2327}
Michal Vaskoe444f752020-02-10 12:20:06 +01002328
Michal Vaskodbf3e652022-10-21 08:46:25 +02002329char *
2330lyd_path_set(const struct ly_set *dnodes, LYD_PATH_TYPE pathtype)
2331{
2332 uint32_t depth;
2333 size_t bufused = 0, buflen = 0, len;
2334 char *buffer = NULL;
2335 const struct lyd_node *iter, *parent;
2336 const struct lys_module *mod, *prev_mod;
2337 LY_ERR rc = LY_SUCCESS;
2338
2339 switch (pathtype) {
2340 case LYD_PATH_STD:
2341 case LYD_PATH_STD_NO_LAST_PRED:
2342 for (depth = 1; depth <= dnodes->count; ++depth) {
2343 /* current node */
2344 iter = dnodes->dnodes[depth - 1];
2345 mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
2346
2347 /* parent */
2348 parent = (depth > 1) ? dnodes->dnodes[depth - 2] : NULL;
2349 assert(!parent || !iter->schema || !parent->schema || (lysc_data_parent(iter->schema) == parent->schema));
2350
2351 /* get module to print, if any */
2352 prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
2353 if (prev_mod == mod) {
2354 mod = NULL;
2355 }
2356
2357 /* realloc string */
2358 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2359 strlen(((struct lyd_node_opaq *)iter)->name.name));
2360 if ((rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, 0))) {
2361 break;
2362 }
2363
2364 /* print next node */
2365 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
2366
2367 /* do not always print the last (first) predicate */
2368 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
2369 switch (iter->schema->nodetype) {
2370 case LYS_LIST:
2371 if (iter->schema->flags & LYS_KEYLESS) {
2372 /* print its position */
2373 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2374 } else {
2375 /* print all list keys in predicates */
2376 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, 0);
2377 }
2378 break;
2379 case LYS_LEAFLIST:
2380 if (iter->schema->flags & LYS_CONFIG_W) {
2381 /* print leaf-list value */
2382 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, 0);
2383 } else {
2384 /* print its position */
2385 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2386 }
2387 break;
2388 default:
2389 /* nothing to print more */
2390 break;
2391 }
2392 }
2393 if (rc) {
2394 break;
2395 }
2396 }
2397 break;
2398 }
2399
2400 return buffer;
2401}
2402
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002403LIBYANG_API_DEF struct lyd_meta *
Michal Vasko25a32822020-07-09 15:48:22 +02002404lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
2405{
2406 struct lyd_meta *ret = NULL;
2407 const struct ly_ctx *ctx;
2408 const char *prefix, *tmp;
2409 char *str;
2410 size_t pref_len, name_len;
2411
2412 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002413 LY_CHECK_CTX_EQUAL_RET(first ? first->annotation->module->ctx : NULL, module ? module->ctx : NULL, NULL);
Michal Vasko25a32822020-07-09 15:48:22 +02002414
2415 if (!first) {
2416 return NULL;
2417 }
2418
2419 ctx = first->annotation->module->ctx;
2420
2421 /* parse the name */
2422 tmp = name;
2423 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
2424 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
2425 return NULL;
2426 }
2427
2428 /* find the module */
2429 if (prefix) {
2430 str = strndup(prefix, pref_len);
2431 module = ly_ctx_get_module_latest(ctx, str);
2432 free(str);
Radek Krejci422afb12021-03-04 16:38:16 +01002433 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 +02002434 }
2435
2436 /* find the metadata */
2437 LY_LIST_FOR(first, first) {
2438 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
2439 ret = (struct lyd_meta *)first;
2440 break;
2441 }
2442 }
2443
2444 return ret;
2445}
2446
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002447LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01002448lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
2449{
Michal Vasko9beceb82022-04-05 12:14:15 +02002450 struct lyd_node **match_p, *iter, *dup = NULL;
Michal Vaskoe444f752020-02-10 12:20:06 +01002451 struct lyd_node_inner *parent;
Michal Vaskoe78faec2021-04-08 17:24:43 +02002452 ly_bool found;
Michal Vaskoe444f752020-02-10 12:20:06 +01002453
Michal Vaskof03ed032020-03-04 13:31:44 +01002454 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02002455 if (!siblings) {
2456 /* no data */
2457 if (match) {
2458 *match = NULL;
2459 }
2460 return LY_ENOTFOUND;
2461 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002462
Michal Vasko9beceb82022-04-05 12:14:15 +02002463 if (LYD_CTX(siblings) != LYD_CTX(target)) {
2464 /* create a duplicate in this context */
2465 LY_CHECK_RET(lyd_dup_single_to_ctx(target, LYD_CTX(siblings), NULL, 0, &dup));
2466 target = dup;
2467 }
2468
2469 if ((siblings->schema && target->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
2470 /* schema mismatch */
2471 lyd_free_tree(dup);
Michal Vasko9b368d32020-02-14 13:53:31 +01002472 if (match) {
2473 *match = NULL;
2474 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002475 return LY_ENOTFOUND;
2476 }
2477
Michal Vaskoe78faec2021-04-08 17:24:43 +02002478 /* get first sibling */
2479 siblings = lyd_first_sibling(siblings);
Michal Vaskoe444f752020-02-10 12:20:06 +01002480
Michal Vasko9e685082021-01-29 14:49:09 +01002481 parent = siblings->parent;
Michal Vasko6da1e952020-12-09 18:14:38 +01002482 if (parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01002483 assert(target->hash);
2484
Michal Vaskoe78faec2021-04-08 17:24:43 +02002485 if (lysc_is_dup_inst_list(target->schema)) {
2486 /* we must search the instances from beginning to find the first matching one */
2487 found = 0;
2488 LYD_LIST_FOR_INST(siblings, target->schema, iter) {
2489 if (!lyd_compare_single(target, iter, 0)) {
2490 found = 1;
2491 break;
2492 }
2493 }
2494 if (found) {
2495 siblings = iter;
Michal Vaskoda859032020-07-14 12:20:14 +02002496 } else {
2497 siblings = NULL;
2498 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002499 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +02002500 /* find by hash */
2501 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
2502 siblings = *match_p;
2503 } else {
2504 /* not found */
2505 siblings = NULL;
2506 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002507 }
2508 } else {
2509 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02002510 for ( ; siblings; siblings = siblings->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02002511 if (!lyd_compare_single(siblings, target, 0)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01002512 break;
2513 }
2514 }
2515 }
2516
Michal Vasko9beceb82022-04-05 12:14:15 +02002517 lyd_free_tree(dup);
Michal Vaskoe444f752020-02-10 12:20:06 +01002518 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01002519 if (match) {
2520 *match = NULL;
2521 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002522 return LY_ENOTFOUND;
2523 }
2524
Michal Vasko9b368d32020-02-14 13:53:31 +01002525 if (match) {
2526 *match = (struct lyd_node *)siblings;
2527 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002528 return LY_SUCCESS;
2529}
2530
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002531LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01002532lyd_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 +02002533 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01002534{
2535 LY_ERR rc;
2536 struct lyd_node *target = NULL;
Michal Vasko9beceb82022-04-05 12:14:15 +02002537 const struct lyd_node *parent;
Michal Vaskoe444f752020-02-10 12:20:06 +01002538
Michal Vasko4c583e82020-07-17 12:16:14 +02002539 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02002540 if (!siblings) {
2541 /* no data */
2542 if (match) {
2543 *match = NULL;
2544 }
2545 return LY_ENOTFOUND;
2546 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002547
Michal Vasko9beceb82022-04-05 12:14:15 +02002548 if ((LYD_CTX(siblings) != schema->module->ctx)) {
2549 /* parent of ext nodes is useless */
2550 parent = (siblings->flags & LYD_EXT) ? NULL : lyd_parent(siblings);
2551 LY_CHECK_RET(lyd_dup_find_schema(schema, LYD_CTX(siblings), parent, &schema));
2552 }
2553
2554 if (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema))) {
2555 /* schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01002556 if (match) {
2557 *match = NULL;
2558 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002559 return LY_ENOTFOUND;
2560 }
2561
Michal Vaskof03ed032020-03-04 13:31:44 +01002562 if (key_or_value && !val_len) {
2563 val_len = strlen(key_or_value);
2564 }
2565
Michal Vaskob104f112020-07-17 09:54:54 +02002566 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
2567 /* create a data node and find the instance */
2568 if (schema->nodetype == LYS_LEAFLIST) {
2569 /* target used attributes: schema, hash, value */
Radek Krejci8df109d2021-04-23 12:19:08 +02002570 rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, NULL, &target);
Michal Vaskofeca4fb2020-10-05 08:58:40 +02002571 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02002572 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01002573 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02002574 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01002575 }
2576
2577 /* find it */
2578 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02002579 } else {
2580 /* find the first schema node instance */
2581 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01002582 }
2583
Michal Vaskoe444f752020-02-10 12:20:06 +01002584 lyd_free_tree(target);
2585 return rc;
2586}
Michal Vaskoccc02342020-05-21 10:09:21 +02002587
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002588LIBYANG_API_DEF LY_ERR
Michal Vaskoe78faec2021-04-08 17:24:43 +02002589lyd_find_sibling_dup_inst_set(const struct lyd_node *siblings, const struct lyd_node *target, struct ly_set **set)
2590{
2591 struct lyd_node **match_p, *first, *iter;
2592 struct lyd_node_inner *parent;
2593
Michal Vasko83ae7772022-06-08 10:01:55 +02002594 LY_CHECK_ARG_RET(NULL, target, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002595 LY_CHECK_CTX_EQUAL_RET(siblings ? LYD_CTX(siblings) : NULL, LYD_CTX(target), LY_EINVAL);
Michal Vaskoe78faec2021-04-08 17:24:43 +02002596
2597 LY_CHECK_RET(ly_set_new(set));
2598
2599 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
2600 /* no data or schema mismatch */
2601 return LY_ENOTFOUND;
2602 }
2603
2604 /* get first sibling */
2605 siblings = lyd_first_sibling(siblings);
2606
2607 parent = siblings->parent;
2608 if (parent && parent->schema && parent->children_ht) {
2609 assert(target->hash);
2610
2611 /* find the first instance */
2612 lyd_find_sibling_first(siblings, target, &first);
2613 if (first) {
2614 /* add it so that it is the first in the set */
2615 if (ly_set_add(*set, first, 1, NULL)) {
2616 goto error;
2617 }
2618
2619 /* find by hash */
2620 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
2621 iter = *match_p;
2622 } else {
2623 /* not found */
2624 iter = NULL;
2625 }
2626 while (iter) {
2627 /* add all found nodes into the set */
2628 if ((iter != first) && !lyd_compare_single(iter, target, 0) && ly_set_add(*set, iter, 1, NULL)) {
2629 goto error;
2630 }
2631
2632 /* find next instance */
2633 if (lyht_find_next(parent->children_ht, &iter, iter->hash, (void **)&match_p)) {
2634 iter = NULL;
2635 } else {
2636 iter = *match_p;
2637 }
2638 }
2639 }
2640 } else {
2641 /* no children hash table */
2642 LY_LIST_FOR(siblings, siblings) {
2643 if (!lyd_compare_single(target, siblings, 0)) {
2644 ly_set_add(*set, (void *)siblings, 1, NULL);
2645 }
2646 }
2647 }
2648
2649 if (!(*set)->count) {
2650 return LY_ENOTFOUND;
2651 }
2652 return LY_SUCCESS;
2653
2654error:
2655 ly_set_free(*set, NULL);
2656 *set = NULL;
2657 return LY_EMEM;
2658}
2659
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002660LIBYANG_API_DEF LY_ERR
Michal Vasko1d4af6c2021-02-22 13:31:26 +01002661lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
2662{
2663 LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
2664
2665 for ( ; first; first = first->next) {
2666 if (!first->schema && !strcmp(LYD_NAME(first), name)) {
2667 break;
2668 }
2669 }
2670
2671 if (match) {
2672 *match = (struct lyd_node *)first;
2673 }
2674 return first ? LY_SUCCESS : LY_ENOTFOUND;
2675}
2676
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002677LIBYANG_API_DEF LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01002678lyd_find_xpath4(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath, LY_VALUE_FORMAT format,
2679 void *prefix_data, const struct lyxp_var *vars, struct ly_set **set)
Michal Vaskoccc02342020-05-21 10:09:21 +02002680{
2681 LY_ERR ret = LY_SUCCESS;
Michal Vasko8bd9cc72021-07-16 14:06:10 +02002682 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +02002683 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02002684 uint32_t i;
2685
Michal Vaskoddd76592022-01-17 13:34:48 +01002686 LY_CHECK_ARG_RET(NULL, tree, xpath, format, set, LY_EINVAL);
Michal Vaskoccc02342020-05-21 10:09:21 +02002687
Michal Vasko37c69432021-04-12 14:48:24 +02002688 *set = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02002689
Michal Vaskoddd76592022-01-17 13:34:48 +01002690 /* parse expression */
Michal Vaskoe3716b32021-12-13 16:58:25 +01002691 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(tree), xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002692 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002693
2694 /* evaluate expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02002695 ret = lyxp_eval(LYD_CTX(tree), exp, NULL, format, prefix_data, ctx_node, ctx_node, tree, vars, &xp_set,
2696 LYXP_IGNORE_WHEN);
Michal Vaskoccc02342020-05-21 10:09:21 +02002697 LY_CHECK_GOTO(ret, cleanup);
2698
Michal Vaskoc0d91642022-11-03 13:56:29 +01002699 if (xp_set.type != LYXP_SET_NODE_SET) {
2700 LOGERR(LYD_CTX(tree), LY_EINVAL, "XPath \"%s\" result is not a node set.", xpath);
2701 ret = LY_EINVAL;
2702 goto cleanup;
2703 }
2704
Michal Vaskoccc02342020-05-21 10:09:21 +02002705 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02002706 ret = ly_set_new(set);
2707 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002708
Michal Vaskoc0d91642022-11-03 13:56:29 +01002709 /* transform into ly_set, allocate memory for all the elements once (even though not all items must be
2710 * elements but most likely will be) */
2711 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
2712 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(tree)); ret = LY_EMEM, cleanup);
2713 (*set)->size = xp_set.used;
Michal Vaskoccc02342020-05-21 10:09:21 +02002714
Michal Vaskoc0d91642022-11-03 13:56:29 +01002715 for (i = 0; i < xp_set.used; ++i) {
2716 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
2717 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
2718 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002719 }
2720 }
2721
2722cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02002723 lyxp_set_free_content(&xp_set);
Michal Vaskoe3716b32021-12-13 16:58:25 +01002724 lyxp_expr_free((struct ly_ctx *)LYD_CTX(tree), exp);
Radek Krejci8f45abc2020-11-26 12:15:13 +01002725 if (ret) {
2726 ly_set_free(*set, NULL);
2727 *set = NULL;
2728 }
Michal Vaskoccc02342020-05-21 10:09:21 +02002729 return ret;
2730}
Radek Krejcica989142020-11-05 11:32:22 +01002731
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002732LIBYANG_API_DEF LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01002733lyd_find_xpath3(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath,
2734 const struct lyxp_var *vars, struct ly_set **set)
2735{
2736 LY_CHECK_ARG_RET(NULL, tree, xpath, set, LY_EINVAL);
2737
2738 return lyd_find_xpath4(ctx_node, tree, xpath, LY_VALUE_JSON, NULL, vars, set);
2739}
2740
2741LIBYANG_API_DEF LY_ERR
Michal Vaskoe3716b32021-12-13 16:58:25 +01002742lyd_find_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, struct ly_set **set)
2743{
2744 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
2745
Michal Vaskoddd76592022-01-17 13:34:48 +01002746 return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, vars, set);
Michal Vaskoe3716b32021-12-13 16:58:25 +01002747}
2748
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002749LIBYANG_API_DEF LY_ERR
aPiecekfba75362021-10-07 12:39:48 +02002750lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
2751{
Michal Vaskoe3716b32021-12-13 16:58:25 +01002752 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
2753
Michal Vaskoddd76592022-01-17 13:34:48 +01002754 return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, NULL, set);
aPiecekfba75362021-10-07 12:39:48 +02002755}
2756
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002757LIBYANG_API_DEF LY_ERR
Michal Vasko10fabfc2022-08-09 08:55:43 +02002758lyd_eval_xpath3(const struct lyd_node *ctx_node, const struct lys_module *cur_mod, const char *xpath,
2759 LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, ly_bool *result)
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002760{
2761 LY_ERR ret = LY_SUCCESS;
Michal Vasko8bd9cc72021-07-16 14:06:10 +02002762 struct lyxp_set xp_set = {0};
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002763 struct lyxp_expr *exp = NULL;
2764
2765 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, result, LY_EINVAL);
2766
2767 /* compile expression */
2768 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
2769 LY_CHECK_GOTO(ret, cleanup);
2770
2771 /* evaluate expression */
Michal Vasko10fabfc2022-08-09 08:55:43 +02002772 ret = lyxp_eval(LYD_CTX(ctx_node), exp, cur_mod, format, prefix_data, ctx_node, ctx_node, ctx_node, vars, &xp_set,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02002773 LYXP_IGNORE_WHEN);
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002774 LY_CHECK_GOTO(ret, cleanup);
2775
2776 /* transform into boolean */
2777 ret = lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
2778 LY_CHECK_GOTO(ret, cleanup);
2779
2780 /* set result */
2781 *result = xp_set.val.bln;
2782
2783cleanup:
2784 lyxp_set_free_content(&xp_set);
2785 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
2786 return ret;
2787}
2788
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002789LIBYANG_API_DEF LY_ERR
Michal Vasko10fabfc2022-08-09 08:55:43 +02002790lyd_eval_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, ly_bool *result)
2791{
2792 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, vars, result);
2793}
2794
2795LIBYANG_API_DEF LY_ERR
aPiecekfba75362021-10-07 12:39:48 +02002796lyd_eval_xpath(const struct lyd_node *ctx_node, const char *xpath, ly_bool *result)
2797{
Michal Vasko10fabfc2022-08-09 08:55:43 +02002798 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, NULL, result);
aPiecekfba75362021-10-07 12:39:48 +02002799}
2800
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002801LIBYANG_API_DEF LY_ERR
Michal Vasko3e1f6552021-01-14 09:27:55 +01002802lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
2803{
2804 LY_ERR ret = LY_SUCCESS;
2805 struct lyxp_expr *expr = NULL;
2806 struct ly_path *lypath = NULL;
2807
2808 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
2809
2810 /* parse the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02002811 ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), 0, LY_PATH_BEGIN_EITHER,
Michal Vasko3e1f6552021-01-14 09:27:55 +01002812 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
2813 LY_CHECK_GOTO(ret, cleanup);
2814
2815 /* compile the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02002816 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, NULL, expr,
Michal Vasko0884d212021-10-14 09:21:46 +02002817 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 +01002818 LY_CHECK_GOTO(ret, cleanup);
2819
2820 /* evaluate the path */
2821 ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
2822
2823cleanup:
2824 lyxp_expr_free(LYD_CTX(ctx_node), expr);
2825 ly_path_free(LYD_CTX(ctx_node), lypath);
2826 return ret;
2827}
2828
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002829LIBYANG_API_DEF LY_ERR
Michal Vaskobb22b182021-06-14 08:14:21 +02002830lyd_find_target(const struct ly_path *path, const struct lyd_node *tree, struct lyd_node **match)
2831{
2832 LY_ERR ret;
2833 struct lyd_node *m;
2834
2835 LY_CHECK_ARG_RET(NULL, path, LY_EINVAL);
2836
2837 ret = ly_path_eval(path, tree, &m);
2838 if (ret) {
2839 if (match) {
2840 *match = NULL;
2841 }
2842 return LY_ENOTFOUND;
2843 }
2844
2845 if (match) {
2846 *match = m;
2847 }
2848 return LY_SUCCESS;
2849}