blob: 4abb79fb5d46caf1546c2b9679aec70ce1608d1d [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
Michal Vaskob1b5c262020-03-05 14:29:47 +01002 * @file tree_data.c
Radek Krejcie7b95092019-05-15 11:03:07 +02003 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +01004 * @author Michal Vasko <mvasko@cesnet.cz>
Michal Vasko6cd9b6b2020-06-22 10:05:22 +02005 * @brief Data tree functions
Radek Krejcie7b95092019-05-15 11:03:07 +02006 *
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +01007 * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
Radek Krejcie7b95092019-05-15 11:03:07 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#define _GNU_SOURCE
17
18#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020019
Radek Krejci084289f2019-07-09 17:35:30 +020020#include <assert.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020021#include <ctype.h>
Radek Krejci47fab892020-11-05 17:02:41 +010022#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdarg.h>
24#include <stdint.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include <stdio.h>
26#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include <string.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020028
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020030#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "context.h"
32#include "dict.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020033#include "diff.h"
Michal Vasko90932a92020-02-12 14:33:03 +010034#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010035#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020036#include "in_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020037#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020038#include "parser_data.h"
39#include "parser_internal.h"
Michal Vasko004d3152020-06-11 19:59:22 +020040#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020041#include "plugins.h"
Radek Krejcif1ca0ac2021-04-12 16:00:06 +020042#include "plugins_exts/metadata.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010043#include "plugins_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020044#include "plugins_types.h"
45#include "set.h"
46#include "tree.h"
47#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010048#include "tree_edit.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020049#include "tree_schema.h"
50#include "tree_schema_internal.h"
Michal Vaskoa6669ba2020-08-06 16:14:26 +020051#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020052#include "xml.h"
53#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020054
Radek Krejci7931b192020-06-25 17:05:03 +020055static LYD_FORMAT
Michal Vasko63f3d842020-07-08 10:10:14 +020056lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
Radek Krejcie7b95092019-05-15 11:03:07 +020057{
Michal Vasko69730152020-10-09 16:30:07 +020058 if (!format && (in->type == LY_IN_FILEPATH)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020059 /* unknown format - try to detect it from filename's suffix */
Radek Krejci7931b192020-06-25 17:05:03 +020060 const char *path = in->method.fpath.filepath;
61 size_t len = strlen(path);
Radek Krejcie7b95092019-05-15 11:03:07 +020062
63 /* ignore trailing whitespaces */
Michal Vaskod989ba02020-08-24 10:59:24 +020064 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
Radek Krejcie7b95092019-05-15 11:03:07 +020065
Radek Krejcif13b87b2020-12-01 22:02:17 +010066 if ((len >= LY_XML_SUFFIX_LEN + 1) &&
67 !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020068 format = LYD_XML;
Radek Krejcif13b87b2020-12-01 22:02:17 +010069 } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
70 !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020071 format = LYD_JSON;
Radek Krejcif13b87b2020-12-01 22:02:17 +010072 } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
73 !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
Radek Krejcie7b95092019-05-15 11:03:07 +020074 format = LYD_LYB;
Radek Krejci7931b192020-06-25 17:05:03 +020075 } /* else still unknown */
Radek Krejcie7b95092019-05-15 11:03:07 +020076 }
77
Radek Krejci7931b192020-06-25 17:05:03 +020078 return format;
79}
Radek Krejcie7b95092019-05-15 11:03:07 +020080
Michal Vaskoe0665742021-02-11 11:08:44 +010081/**
82 * @brief Parse YANG data into a data tree.
83 *
84 * @param[in] ctx libyang context.
Radek Krejcif16e2542021-02-17 15:39:23 +010085 * @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 +010086 * @param[in] parent Parent to connect the parsed nodes to, if any.
87 * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
88 * @param[in] in Input handle to read the input from.
89 * @param[in] format Expected format of the data in @p in.
90 * @param[in] parse_opts Options for parser.
91 * @param[in] val_opts Options for validation.
92 * @param[out] op Optional pointer to the parsed operation, if any.
93 * @return LY_ERR value.
94 */
95static LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +010096lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, struct lyd_node **first_p,
97 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 +020098{
Michal Vaskod027f382023-02-10 09:13:25 +010099 LY_ERR r, rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200100 struct lyd_ctx *lydctx = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100101 struct ly_set parsed = {0};
102 struct lyd_node *first;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100103 uint32_t i, int_opts = 0;
Michal Vaskoddd76592022-01-17 13:34:48 +0100104 ly_bool subtree_sibling = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200105
Michal Vaskoe0665742021-02-11 11:08:44 +0100106 assert(ctx && (parent || first_p));
Radek Krejci7931b192020-06-25 17:05:03 +0200107
108 format = lyd_parse_get_format(in, format);
Michal Vaskoe0665742021-02-11 11:08:44 +0100109 if (first_p) {
110 *first_p = NULL;
111 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200112
Michal Vasko63f3d842020-07-08 10:10:14 +0200113 /* remember input position */
114 in->func_start = in->current;
Radek Krejci7931b192020-06-25 17:05:03 +0200115
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100116 /* set internal options */
117 if (!(parse_opts & LYD_PARSE_SUBTREE)) {
118 int_opts = LYD_INTOPT_WITH_SIBLINGS;
119 }
120
Michal Vaskoe0665742021-02-11 11:08:44 +0100121 /* parse the data */
Radek Krejci7931b192020-06-25 17:05:03 +0200122 switch (format) {
123 case LYD_XML:
Michal Vaskod027f382023-02-10 09:13:25 +0100124 r = lyd_parse_xml(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100125 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200126 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200127 case LYD_JSON:
Michal Vaskod027f382023-02-10 09:13:25 +0100128 r = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100129 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200130 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200131 case LYD_LYB:
Michal Vaskod027f382023-02-10 09:13:25 +0100132 r = lyd_parse_lyb(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
Michal Vaskoddd76592022-01-17 13:34:48 +0100133 &subtree_sibling, &lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200134 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200135 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100136 LOGARG(ctx, format);
Michal Vaskod027f382023-02-10 09:13:25 +0100137 r = LY_EINVAL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100138 break;
139 }
Michal Vaskod027f382023-02-10 09:13:25 +0100140 LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +0100141
142 if (parent) {
143 /* get first top-level sibling */
144 for (first = parent; first->parent; first = lyd_parent(first)) {}
145 first = lyd_first_sibling(first);
146 first_p = &first;
Radek Krejci7931b192020-06-25 17:05:03 +0200147 }
148
Michal Vaskoe0665742021-02-11 11:08:44 +0100149 if (!(parse_opts & LYD_PARSE_ONLY)) {
150 /* validate data */
Michal Vaskoddd76592022-01-17 13:34:48 +0100151 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 +0200152 &lydctx->ext_node, &lydctx->ext_val, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100153 LY_CHECK_GOTO(rc, cleanup);
154 }
Radek Krejci7931b192020-06-25 17:05:03 +0200155
Michal Vaskoe0665742021-02-11 11:08:44 +0100156 /* set the operation node */
157 if (op) {
158 *op = lydctx->op_node;
Radek Krejci1798aae2020-07-14 13:26:06 +0200159 }
160
161cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +0100162 if (lydctx) {
163 lydctx->free(lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200164 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100165 if (rc) {
166 if (parent) {
167 /* free all the parsed subtrees */
168 for (i = 0; i < parsed.count; ++i) {
169 lyd_free_tree(parsed.dnodes[i]);
170 }
171 } else {
172 /* free everything */
173 lyd_free_all(*first_p);
174 *first_p = NULL;
175 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100176 } else if (subtree_sibling) {
177 rc = LY_ENOT;
Michal Vaskoe0665742021-02-11 11:08:44 +0100178 }
179 ly_set_erase(&parsed, NULL);
180 return rc;
Radek Krejci7931b192020-06-25 17:05:03 +0200181}
182
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100183LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100184lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
185 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
186{
187 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
188
189 LY_CHECK_ARG_RET(ctx, ext, in, parent || tree, LY_EINVAL);
190 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
191 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
192
193 return lyd_parse(ctx, ext, parent, tree, in, format, parse_options, validate_options, NULL);
194}
195
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100196LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100197lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
198 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
199{
200 LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
201 LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
202 LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
203
Radek Krejcif16e2542021-02-17 15:39:23 +0100204 return lyd_parse(ctx, NULL, parent, tree, in, format, parse_options, validate_options, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +0100205}
206
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100207LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100208lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
209 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200210{
211 LY_ERR ret;
212 struct ly_in *in;
213
214 LY_CHECK_RET(ly_in_new_memory(data, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100215 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200216
217 ly_in_free(in, 0);
218 return ret;
219}
220
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100221LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200222lyd_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 +0200223 struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200224{
225 LY_ERR ret;
226 struct ly_in *in;
227
228 LY_CHECK_RET(ly_in_new_fd(fd, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100229 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200230
231 ly_in_free(in, 0);
232 return ret;
233}
234
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100235LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200236lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
237 uint32_t validate_options, struct lyd_node **tree)
Radek Krejci7931b192020-06-25 17:05:03 +0200238{
239 LY_ERR ret;
240 struct ly_in *in;
241
242 LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
Michal Vaskoe0665742021-02-11 11:08:44 +0100243 ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200244
245 ly_in_free(in, 0);
246 return ret;
247}
248
Radek Krejcif16e2542021-02-17 15:39:23 +0100249/**
250 * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
251 * for schema nodes locked inside the extension instance.
252 *
253 * At least one of @p parent, @p tree, or @p op must always be set.
254 *
255 * Specific @p data_type values have different parameter meaning as follows:
256 * - ::LYD_TYPE_RPC_NETCONF:
257 * - @p parent - must be NULL, the whole RPC is expected;
258 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
259 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
260 * a separate opaque data tree, even if the function fails, this may be returned;
261 * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
262 *
263 * - ::LYD_TYPE_NOTIF_NETCONF:
264 * - @p parent - must be NULL, the whole notification is expected;
265 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
266 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
267 * a separate opaque data tree, even if the function fails, this may be returned;
268 * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
269 *
270 * - ::LYD_TYPE_REPLY_NETCONF:
271 * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
272 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
273 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
274 * a separate opaque data tree, even if the function fails, this may be returned;
275 * - @p op - must be NULL, the reply is appended to the RPC;
276 * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
277 *
278 * @param[in] ctx libyang context.
279 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
280 * @param[in] parent Optional parent to connect the parsed nodes to.
281 * @param[in] in Input handle to read the input from.
282 * @param[in] format Expected format of the data in @p in.
283 * @param[in] data_type Expected operation to parse (@ref datatype).
284 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
285 * @param[out] op Optional parsed operation node.
286 * @return LY_ERR value.
287 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
288 */
289static LY_ERR
290lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
291 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 +0200292{
Michal Vaskoe0665742021-02-11 11:08:44 +0100293 LY_ERR rc = LY_SUCCESS;
294 struct lyd_ctx *lydctx = NULL;
295 struct ly_set parsed = {0};
296 struct lyd_node *first = NULL, *envp = NULL;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100297 uint32_t i, parse_opts, val_opts, int_opts = 0;
Radek Krejci7931b192020-06-25 17:05:03 +0200298
Michal Vasko27fb0262021-02-23 09:42:01 +0100299 if (!ctx) {
300 ctx = LYD_CTX(parent);
301 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200302 if (tree) {
303 *tree = NULL;
304 }
305 if (op) {
306 *op = NULL;
307 }
308
Radek Krejci7931b192020-06-25 17:05:03 +0200309 format = lyd_parse_get_format(in, format);
Radek Krejci7931b192020-06-25 17:05:03 +0200310
Michal Vasko63f3d842020-07-08 10:10:14 +0200311 /* remember input position */
312 in->func_start = in->current;
313
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100314 /* set parse and validation opts */
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
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100318 switch (data_type) {
319
320 /* special XML NETCONF data types */
321 case LYD_TYPE_RPC_NETCONF:
322 case LYD_TYPE_NOTIF_NETCONF:
323 LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
324 /* fallthrough */
325 case LYD_TYPE_REPLY_NETCONF:
326 if (data_type == LYD_TYPE_REPLY_NETCONF) {
327 LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op,
328 LY_EINVAL);
329 }
330
331 /* parse the NETCONF message */
332 rc = lyd_parse_xml_netconf(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
Michal Vasko3a163bc2023-01-10 14:23:56 +0100333 if (rc) {
334 if (envp) {
335 /* special situation when the envelopes were parsed successfully */
336 *tree = envp;
337 }
Michal Vasko73792a12022-05-10 09:28:45 +0200338 goto cleanup;
Michal Vasko299d5d12021-02-16 16:36:37 +0100339 }
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100340
341 /* set out params correctly */
Michal Vasko472baa82022-12-01 16:17:41 +0100342 if (envp) {
343 /* special out param meaning */
344 *tree = envp;
345 } else {
346 *tree = parent ? NULL : first;
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100347 }
348 if (op) {
349 *op = lydctx->op_node;
350 }
351 goto cleanup;
352
353 /* set internal opts */
354 case LYD_TYPE_RPC_YANG:
355 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NO_SIBLINGS;
356 break;
357 case LYD_TYPE_NOTIF_YANG:
358 int_opts = LYD_INTOPT_NOTIF | LYD_INTOPT_NO_SIBLINGS;
359 break;
360 case LYD_TYPE_REPLY_YANG:
361 int_opts = LYD_INTOPT_REPLY | LYD_INTOPT_NO_SIBLINGS;
362 break;
363 case LYD_TYPE_DATA_YANG:
364 LOGINT(ctx);
365 rc = LY_EINT;
366 goto cleanup;
367 }
368
369 /* parse the data */
370 switch (format) {
371 case LYD_XML:
372 rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100373 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200374 case LYD_JSON:
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100375 rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100376 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200377 case LYD_LYB:
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100378 rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
Michal Vaskoe0665742021-02-11 11:08:44 +0100379 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200380 case LYD_UNKNOWN:
Michal Vaskod74978f2021-02-12 11:59:36 +0100381 LOGARG(ctx, format);
382 rc = LY_EINVAL;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200383 break;
Radek Krejci7931b192020-06-25 17:05:03 +0200384 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100385 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci7931b192020-06-25 17:05:03 +0200386
Michal Vaskoe0665742021-02-11 11:08:44 +0100387 /* set out params correctly */
388 if (tree) {
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100389 *tree = parent ? NULL : first;
Michal Vaskoe0665742021-02-11 11:08:44 +0100390 }
391 if (op) {
392 *op = lydctx->op_node;
393 }
394
395cleanup:
396 if (lydctx) {
397 lydctx->free(lydctx);
398 }
399 if (rc) {
Michal Vasko73792a12022-05-10 09:28:45 +0200400 /* free all the parsed nodes */
401 if (parsed.count) {
402 i = parsed.count;
403 do {
404 --i;
Michal Vaskoe0665742021-02-11 11:08:44 +0100405 lyd_free_tree(parsed.dnodes[i]);
Michal Vasko73792a12022-05-10 09:28:45 +0200406 } while (i);
407 }
408 if (tree && ((format != LYD_XML) || !envp)) {
409 *tree = NULL;
410 }
411 if (op) {
412 *op = NULL;
Michal Vaskoe0665742021-02-11 11:08:44 +0100413 }
414 }
415 ly_set_erase(&parsed, NULL);
416 return rc;
Radek Krejcie7b95092019-05-15 11:03:07 +0200417}
Radek Krejci084289f2019-07-09 17:35:30 +0200418
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100419LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100420lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
421 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
422{
423 LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
424
425 return lyd_parse_op_(ctx, NULL, parent, in, format, data_type, tree, op);
426}
427
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100428LIBYANG_API_DEF LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +0100429lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
430 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
431{
432 const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
433
434 LY_CHECK_ARG_RET(ctx, ext, in, data_type, parent || tree || op, LY_EINVAL);
435
436 return lyd_parse_op_(ctx, ext, parent, in, format, data_type, tree, op);
437}
438
Michal Vasko90932a92020-02-12 14:33:03 +0100439struct lyd_node *
Michal Vaskob104f112020-07-17 09:54:54 +0200440lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
Michal Vasko90932a92020-02-12 14:33:03 +0100441{
Michal Vaskob104f112020-07-17 09:54:54 +0200442 const struct lysc_node *schema, *sparent;
Michal Vasko90932a92020-02-12 14:33:03 +0100443 struct lyd_node *match = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200444 ly_bool found;
Michal Vasko93b16062020-12-09 18:14:18 +0100445 uint32_t getnext_opts;
Michal Vasko90932a92020-02-12 14:33:03 +0100446
Michal Vaskob104f112020-07-17 09:54:54 +0200447 assert(new_node);
448
Michal Vasko9beceb82022-04-05 12:14:15 +0200449 if (!first_sibling || !new_node->schema || (LYD_CTX(first_sibling) != LYD_CTX(new_node))) {
Michal Vaskob104f112020-07-17 09:54:54 +0200450 /* insert at the end, no next anchor */
Michal Vasko90932a92020-02-12 14:33:03 +0100451 return NULL;
452 }
453
Michal Vasko93b16062020-12-09 18:14:18 +0100454 getnext_opts = 0;
Michal Vaskod1e53b92021-01-28 13:11:06 +0100455 if (new_node->schema->flags & LYS_IS_OUTPUT) {
Michal Vasko93b16062020-12-09 18:14:18 +0100456 getnext_opts = LYS_GETNEXT_OUTPUT;
457 }
458
Michal Vaskoa2756f02021-07-09 13:20:28 +0200459 if (first_sibling->parent && first_sibling->parent->schema && first_sibling->parent->children_ht) {
Michal Vaskob104f112020-07-17 09:54:54 +0200460 /* find the anchor using hashes */
461 sparent = first_sibling->parent->schema;
Michal Vasko93b16062020-12-09 18:14:18 +0100462 schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200463 while (schema) {
464 /* keep trying to find the first existing instance of the closest following schema sibling,
465 * otherwise return NULL - inserting at the end */
466 if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
467 break;
468 }
469
Michal Vasko93b16062020-12-09 18:14:18 +0100470 schema = lys_getnext(schema, sparent, NULL, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200471 }
472 } else {
473 /* find the anchor without hashes */
474 match = (struct lyd_node *)first_sibling;
Michal Vasko3a708622021-07-15 14:20:10 +0200475 sparent = lysc_data_parent(new_node->schema);
476 if (!sparent) {
Michal Vaskob104f112020-07-17 09:54:54 +0200477 /* we are in top-level, skip all the data from preceding modules */
478 LY_LIST_FOR(match, match) {
479 if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
480 break;
481 }
482 }
483 }
484
485 /* get the first schema sibling */
Michal Vasko93b16062020-12-09 18:14:18 +0100486 schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200487
488 found = 0;
489 LY_LIST_FOR(match, match) {
490 if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
491 /* we have found an opaque node, which must be at the end, so use it OR
492 * modules do not match, so we must have traversed all the data from new_node module (if any),
493 * we have found the first node of the next module, that is what we want */
494 break;
495 }
496
497 /* skip schema nodes until we find the instantiated one */
498 while (!found) {
499 if (new_node->schema == schema) {
500 /* we have found the schema of the new node, continue search to find the first
501 * data node with a different schema (after our schema) */
502 found = 1;
503 break;
504 }
505 if (match->schema == schema) {
506 /* current node (match) is a data node still before the new node, continue search in data */
507 break;
508 }
Michal Vasko93b16062020-12-09 18:14:18 +0100509 schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
Michal Vaskob104f112020-07-17 09:54:54 +0200510 assert(schema);
511 }
512
513 if (found && (match->schema != new_node->schema)) {
514 /* find the next node after we have found our node schema data instance */
515 break;
516 }
517 }
Michal Vasko90932a92020-02-12 14:33:03 +0100518 }
519
520 return match;
521}
522
Michal Vaskoc61dd062022-06-07 11:01:28 +0200523void
Michal Vaskof03ed032020-03-04 13:31:44 +0100524lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100525{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100526 struct lyd_node_inner *par;
527
Michal Vasko90932a92020-02-12 14:33:03 +0100528 assert(!node->next && (node->prev == node));
529
530 node->next = sibling->next;
531 node->prev = sibling;
532 sibling->next = node;
533 if (node->next) {
534 /* sibling had a succeeding node */
535 node->next->prev = node;
536 } else {
537 /* sibling was last, find first sibling and change its prev */
538 if (sibling->parent) {
539 sibling = sibling->parent->child;
540 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200541 for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
Michal Vasko90932a92020-02-12 14:33:03 +0100542 }
543 sibling->prev = node;
544 }
545 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100546
Michal Vasko9f96a052020-03-10 09:41:45 +0100547 for (par = node->parent; par; par = par->parent) {
548 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
549 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100550 par->flags &= ~LYD_DEFAULT;
551 }
552 }
Michal Vasko90932a92020-02-12 14:33:03 +0100553}
554
Michal Vaskoc61dd062022-06-07 11:01:28 +0200555void
Michal Vaskof03ed032020-03-04 13:31:44 +0100556lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100557{
Michal Vasko0249f7c2020-03-05 16:36:40 +0100558 struct lyd_node_inner *par;
559
Michal Vasko90932a92020-02-12 14:33:03 +0100560 assert(!node->next && (node->prev == node));
561
562 node->next = sibling;
563 /* covers situation of sibling being first */
564 node->prev = sibling->prev;
565 sibling->prev = node;
566 if (node->prev->next) {
567 /* sibling had a preceding node */
568 node->prev->next = node;
569 } else if (sibling->parent) {
570 /* sibling was first and we must also change parent child pointer */
571 sibling->parent->child = node;
572 }
573 node->parent = sibling->parent;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100574
Michal Vasko9f96a052020-03-10 09:41:45 +0100575 for (par = node->parent; par; par = par->parent) {
576 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
577 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100578 par->flags &= ~LYD_DEFAULT;
579 }
580 }
Michal Vasko90932a92020-02-12 14:33:03 +0100581}
582
583/**
Michal Vaskob104f112020-07-17 09:54:54 +0200584 * @brief Insert node as the first and only child of a parent.
Michal Vasko90932a92020-02-12 14:33:03 +0100585 *
Michal Vasko9f96a052020-03-10 09:41:45 +0100586 * Handles inserting into NP containers and key-less lists.
587 *
Michal Vasko90932a92020-02-12 14:33:03 +0100588 * @param[in] parent Parent to insert into.
589 * @param[in] node Node to insert.
590 */
591static void
Michal Vaskob104f112020-07-17 09:54:54 +0200592lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vasko90932a92020-02-12 14:33:03 +0100593{
594 struct lyd_node_inner *par;
595
Radek Krejcia1c1e542020-09-29 16:06:52 +0200596 assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
Michal Vasko52927e22020-03-16 17:26:14 +0100597 assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
Michal Vasko90932a92020-02-12 14:33:03 +0100598
599 par = (struct lyd_node_inner *)parent;
600
Michal Vaskob104f112020-07-17 09:54:54 +0200601 par->child = node;
Michal Vasko90932a92020-02-12 14:33:03 +0100602 node->parent = par;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100603
Michal Vaskod989ba02020-08-24 10:59:24 +0200604 for ( ; par; par = par->parent) {
Michal Vasko9f96a052020-03-10 09:41:45 +0100605 if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
606 /* remove default flags from NP containers */
Michal Vasko0249f7c2020-03-05 16:36:40 +0100607 par->flags &= ~LYD_DEFAULT;
608 }
609 }
Michal Vasko751cb4d2020-07-14 12:25:28 +0200610}
Michal Vasko0249f7c2020-03-05 16:36:40 +0100611
Michal Vasko751cb4d2020-07-14 12:25:28 +0200612/**
613 * @brief Learn whether a list instance has all the keys.
614 *
615 * @param[in] list List instance to check.
616 * @return non-zero if all the keys were found,
617 * @return 0 otherwise.
618 */
619static int
620lyd_insert_has_keys(const struct lyd_node *list)
621{
622 const struct lyd_node *key;
623 const struct lysc_node *skey = NULL;
624
625 assert(list->schema->nodetype == LYS_LIST);
Radek Krejcia1c1e542020-09-29 16:06:52 +0200626 key = lyd_child(list);
Michal Vasko751cb4d2020-07-14 12:25:28 +0200627 while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
628 if (!key || (key->schema != skey)) {
629 /* key missing */
630 return 0;
631 }
632
633 key = key->next;
634 }
635
636 /* all keys found */
637 return 1;
Michal Vasko90932a92020-02-12 14:33:03 +0100638}
639
640void
Michal Vasko6ee6f432021-07-16 09:49:14 +0200641lyd_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 +0100642{
Michal Vaskob104f112020-07-17 09:54:54 +0200643 struct lyd_node *anchor, *first_sibling;
Michal Vasko90932a92020-02-12 14:33:03 +0100644
Michal Vaskob104f112020-07-17 09:54:54 +0200645 /* inserting list without its keys is not supported */
646 assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
Michal Vaskof756c942020-11-06 17:21:37 +0100647 assert(!parent || !parent->schema ||
648 (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
Michal Vasko9b368d32020-02-14 13:53:31 +0100649
Michal Vaskob104f112020-07-17 09:54:54 +0200650 if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +0100651 parent = lyd_parent(*first_sibling_p);
Michal Vasko9b368d32020-02-14 13:53:31 +0100652 }
Michal Vasko90932a92020-02-12 14:33:03 +0100653
Michal Vaskob104f112020-07-17 09:54:54 +0200654 /* get first sibling */
Michal Vasko9e685082021-01-29 14:49:09 +0100655 first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
Michal Vasko9f96a052020-03-10 09:41:45 +0100656
Michal Vasko9beceb82022-04-05 12:14:15 +0200657 if (last || (first_sibling && (first_sibling->flags & LYD_EXT))) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200658 /* no next anchor */
659 anchor = NULL;
660 } else {
661 /* find the anchor, our next node, so we can insert before it */
662 anchor = lyd_insert_get_next_anchor(first_sibling, node);
663 }
664
Michal Vaskob104f112020-07-17 09:54:54 +0200665 if (anchor) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200666 /* insert before the anchor */
Michal Vaskob104f112020-07-17 09:54:54 +0200667 lyd_insert_before_node(anchor, node);
Michal Vasko26123192020-11-09 21:02:34 +0100668 if (!parent && (*first_sibling_p == anchor)) {
669 /* move first sibling */
670 *first_sibling_p = node;
671 }
Michal Vaskob104f112020-07-17 09:54:54 +0200672 } else if (first_sibling) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200673 /* insert as the last node */
Michal Vaskob104f112020-07-17 09:54:54 +0200674 lyd_insert_after_node(first_sibling->prev, node);
675 } else if (parent) {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200676 /* insert as the only child */
Michal Vaskob104f112020-07-17 09:54:54 +0200677 lyd_insert_only_child(parent, node);
Michal Vasko90932a92020-02-12 14:33:03 +0100678 } else {
Michal Vasko6ee6f432021-07-16 09:49:14 +0200679 /* insert as the only sibling */
Michal Vaskob104f112020-07-17 09:54:54 +0200680 *first_sibling_p = node;
681 }
682
683 /* insert into parent HT */
684 lyd_insert_hash(node);
685
686 /* finish hashes for our parent, if needed and possible */
Michal Vasko9e8de2d2020-09-01 08:17:10 +0200687 if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
Michal Vaskob104f112020-07-17 09:54:54 +0200688 lyd_hash(parent);
689
690 /* now we can insert even the list into its parent HT */
691 lyd_insert_hash(parent);
Michal Vasko90932a92020-02-12 14:33:03 +0100692 }
Michal Vasko90932a92020-02-12 14:33:03 +0100693}
694
Michal Vasko717a4c32020-12-07 09:40:10 +0100695/**
696 * @brief Check schema place of a node to be inserted.
697 *
698 * @param[in] parent Schema node of the parent data node.
699 * @param[in] sibling Schema node of a sibling data node.
700 * @param[in] schema Schema node if the data node to be inserted.
701 * @return LY_SUCCESS on success.
702 * @return LY_EINVAL if the place is invalid.
703 */
Michal Vaskof03ed032020-03-04 13:31:44 +0100704static LY_ERR
Michal Vasko717a4c32020-12-07 09:40:10 +0100705lyd_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 +0100706{
707 const struct lysc_node *par2;
708
Michal Vasko62ed12d2020-05-21 10:08:25 +0200709 assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vasko717a4c32020-12-07 09:40:10 +0100710 assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
711 assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
Michal Vaskof03ed032020-03-04 13:31:44 +0100712
Michal Vasko717a4c32020-12-07 09:40:10 +0100713 if (!schema || (!parent && !sibling)) {
Michal Vasko71e795e2020-12-04 16:27:37 +0100714 /* opaque nodes can be inserted wherever */
715 return LY_SUCCESS;
716 }
717
Michal Vasko717a4c32020-12-07 09:40:10 +0100718 if (!parent) {
719 parent = lysc_data_parent(sibling);
720 }
721
Michal Vaskof03ed032020-03-04 13:31:44 +0100722 /* find schema parent */
Michal Vasko62ed12d2020-05-21 10:08:25 +0200723 par2 = lysc_data_parent(schema);
Michal Vaskof03ed032020-03-04 13:31:44 +0100724
725 if (parent) {
726 /* inner node */
727 if (par2 != parent) {
Michal Vaskob104f112020-07-17 09:54:54 +0200728 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
Michal Vasko69730152020-10-09 16:30:07 +0200729 parent->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100730 return LY_EINVAL;
731 }
732 } else {
733 /* top-level node */
734 if (par2) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +0200735 LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100736 return LY_EINVAL;
737 }
738 }
739
740 return LY_SUCCESS;
741}
742
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100743LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +0200744lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
Michal Vaskof03ed032020-03-04 13:31:44 +0100745{
746 struct lyd_node *iter;
747
Michal Vasko0ab974d2021-02-24 13:18:26 +0100748 LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100749 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(parent), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100750
Michal Vasko717a4c32020-12-07 09:40:10 +0100751 LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100752
Michal Vasko0ab974d2021-02-24 13:18:26 +0100753 if (node->schema && (node->schema->flags & LYS_KEY)) {
Michal Vaskoddd76592022-01-17 13:34:48 +0100754 LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskof03ed032020-03-04 13:31:44 +0100755 return LY_EINVAL;
756 }
757
758 if (node->parent || node->prev->next) {
759 lyd_unlink_tree(node);
760 }
761
762 while (node) {
763 iter = node->next;
764 lyd_unlink_tree(node);
Michal Vasko6ee6f432021-07-16 09:49:14 +0200765 lyd_insert_node(parent, NULL, node, 0);
Michal Vaskof03ed032020-03-04 13:31:44 +0100766 node = iter;
767 }
768 return LY_SUCCESS;
769}
770
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100771LIBYANG_API_DEF LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200772lyplg_ext_insert(struct lyd_node *parent, struct lyd_node *first)
Michal Vaskoddd76592022-01-17 13:34:48 +0100773{
774 struct lyd_node *iter;
775
776 LY_CHECK_ARG_RET(NULL, parent, first, !first->parent, !first->prev->next,
777 !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
778
779 if (first->schema && (first->schema->flags & LYS_KEY)) {
780 LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", first->schema->name);
781 return LY_EINVAL;
782 }
783
784 while (first) {
785 iter = first->next;
786 lyd_unlink_tree(first);
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100787 lyd_insert_node(parent, NULL, first, 1);
Michal Vaskoddd76592022-01-17 13:34:48 +0100788 first = iter;
789 }
790 return LY_SUCCESS;
791}
792
793LIBYANG_API_DEF LY_ERR
Michal Vaskob104f112020-07-17 09:54:54 +0200794lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100795{
796 struct lyd_node *iter;
797
Michal Vaskob104f112020-07-17 09:54:54 +0200798 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100799
Michal Vaskob104f112020-07-17 09:54:54 +0200800 if (sibling) {
Michal Vasko717a4c32020-12-07 09:40:10 +0100801 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100802 }
803
Michal Vasko553d0b52020-12-04 16:27:52 +0100804 if (sibling == node) {
805 /* we need to keep the connection to siblings so we can insert into them */
806 sibling = sibling->prev;
807 }
808
Michal Vaskob1b5c262020-03-05 14:29:47 +0100809 if (node->parent || node->prev->next) {
810 lyd_unlink_tree(node);
811 }
812
813 while (node) {
Michal Vasko71e795e2020-12-04 16:27:37 +0100814 if (lysc_is_key(node->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200815 LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
Michal Vaskob104f112020-07-17 09:54:54 +0200816 return LY_EINVAL;
817 }
818
Michal Vaskob1b5c262020-03-05 14:29:47 +0100819 iter = node->next;
820 lyd_unlink_tree(node);
Michal Vasko6ee6f432021-07-16 09:49:14 +0200821 lyd_insert_node(NULL, &sibling, node, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100822 node = iter;
823 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100824
Michal Vaskob104f112020-07-17 09:54:54 +0200825 if (first) {
826 /* find the first sibling */
827 *first = sibling;
828 while ((*first)->prev->next) {
829 *first = (*first)->prev;
Michal Vasko0249f7c2020-03-05 16:36:40 +0100830 }
831 }
832
833 return LY_SUCCESS;
834}
835
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100836LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +0100837lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
838{
Michal Vaskobce230b2022-04-19 09:55:31 +0200839 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100840 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100841
Michal Vasko717a4c32020-12-07 09:40:10 +0100842 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100843
Michal Vaskoab7a2bf2022-04-01 14:37:54 +0200844 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200845 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +0100846 return LY_EINVAL;
847 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +0200848 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
849 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert before a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +0100850 return LY_EINVAL;
851 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100852
Michal Vasko4bc2ce32020-12-08 10:06:16 +0100853 lyd_unlink_tree(node);
854 lyd_insert_before_node(sibling, node);
855 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +0100856
Michal Vaskof03ed032020-03-04 13:31:44 +0100857 return LY_SUCCESS;
858}
859
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100860LIBYANG_API_DEF LY_ERR
Michal Vaskof03ed032020-03-04 13:31:44 +0100861lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
862{
Michal Vaskobce230b2022-04-19 09:55:31 +0200863 LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100864 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
Michal Vaskof03ed032020-03-04 13:31:44 +0100865
Michal Vasko717a4c32020-12-07 09:40:10 +0100866 LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
Michal Vaskof03ed032020-03-04 13:31:44 +0100867
Michal Vaskoab7a2bf2022-04-01 14:37:54 +0200868 if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +0200869 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
Michal Vaskof03ed032020-03-04 13:31:44 +0100870 return LY_EINVAL;
871 }
Michal Vasko5c0b27a2022-04-19 09:56:02 +0200872 if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
873 LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert after a different schema node instance.");
Michal Vasko7508ef22022-02-22 14:13:10 +0100874 return LY_EINVAL;
875 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100876
Michal Vasko4bc2ce32020-12-08 10:06:16 +0100877 lyd_unlink_tree(node);
878 lyd_insert_after_node(sibling, node);
879 lyd_insert_hash(node);
Michal Vaskof03ed032020-03-04 13:31:44 +0100880
Michal Vaskof03ed032020-03-04 13:31:44 +0100881 return LY_SUCCESS;
882}
883
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100884LIBYANG_API_DEF void
Michal Vasko66d508c2021-07-21 16:07:09 +0200885lyd_unlink_siblings(struct lyd_node *node)
886{
887 struct lyd_node *next, *elem, *first = NULL;
888
889 LY_LIST_FOR_SAFE(node, next, elem) {
890 lyd_unlink_tree(elem);
891 lyd_insert_node(NULL, &first, elem, 1);
892 }
893}
894
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100895LIBYANG_API_DEF void
Michal Vaskof03ed032020-03-04 13:31:44 +0100896lyd_unlink_tree(struct lyd_node *node)
897{
898 struct lyd_node *iter;
899
900 if (!node) {
901 return;
902 }
903
Michal Vaskob104f112020-07-17 09:54:54 +0200904 /* update hashes while still linked into the tree */
905 lyd_unlink_hash(node);
906
Michal Vaskof03ed032020-03-04 13:31:44 +0100907 /* unlink from siblings */
908 if (node->prev->next) {
909 node->prev->next = node->next;
910 }
911 if (node->next) {
912 node->next->prev = node->prev;
913 } else {
914 /* unlinking the last node */
915 if (node->parent) {
916 iter = node->parent->child;
917 } else {
918 iter = node->prev;
919 while (iter->prev != node) {
920 iter = iter->prev;
921 }
922 }
923 /* update the "last" pointer from the first node */
924 iter->prev = node->prev;
925 }
926
927 /* unlink from parent */
928 if (node->parent) {
929 if (node->parent->child == node) {
930 /* the node is the first child */
931 node->parent->child = node->next;
932 }
933
Michal Vaskoab49dbe2020-07-17 12:32:47 +0200934 /* check for NP container whether its last non-default node is not being unlinked */
Michal Vasko4754d4a2022-12-01 10:11:21 +0100935 lyd_cont_set_dflt(lyd_parent(node));
Michal Vaskoab49dbe2020-07-17 12:32:47 +0200936
Michal Vaskof03ed032020-03-04 13:31:44 +0100937 node->parent = NULL;
938 }
939
940 node->next = NULL;
941 node->prev = node;
942}
943
Michal Vaskoa5da3292020-08-12 13:10:50 +0200944void
Michal Vasko871a0252020-11-11 18:35:24 +0100945lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
Radek Krejci1798aae2020-07-14 13:26:06 +0200946{
947 struct lyd_meta *last, *iter;
948
949 assert(parent);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200950
951 if (!meta) {
952 return;
953 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200954
955 for (iter = meta; iter; iter = iter->next) {
956 iter->parent = parent;
957 }
958
959 /* insert as the last attribute */
960 if (parent->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +0200961 for (last = parent->meta; last->next; last = last->next) {}
Radek Krejci1798aae2020-07-14 13:26:06 +0200962 last->next = meta;
963 } else {
964 parent->meta = meta;
965 }
966
967 /* remove default flags from NP containers */
Michal Vasko871a0252020-11-11 18:35:24 +0100968 while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200969 parent->flags &= ~LYD_DEFAULT;
Michal Vasko9e685082021-01-29 14:49:09 +0100970 parent = lyd_parent(parent);
Radek Krejci1798aae2020-07-14 13:26:06 +0200971 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200972}
973
974LY_ERR
Michal Vasko9f96a052020-03-10 09:41:45 +0100975lyd_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 +0200976 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 +0100977 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 +0100978{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100979 LY_ERR ret = LY_SUCCESS;
Michal Vasko90932a92020-02-12 14:33:03 +0100980 struct lysc_ext_instance *ant = NULL;
Michal Vasko193dacd2022-10-13 08:43:05 +0200981 const struct lysc_type *ant_type;
Michal Vasko9f96a052020-03-10 09:41:45 +0100982 struct lyd_meta *mt, *last;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200983 LY_ARRAY_COUNT_TYPE u;
Michal Vasko90932a92020-02-12 14:33:03 +0100984
Michal Vasko9f96a052020-03-10 09:41:45 +0100985 assert((parent || meta) && mod);
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100986
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200987 LY_ARRAY_FOR(mod->compiled->exts, u) {
Michal Vasko193dacd2022-10-13 08:43:05 +0200988 if (!strncmp(mod->compiled->exts[u].def->plugin->id, "ly2 metadata", 12) &&
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200989 !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
Michal Vasko90932a92020-02-12 14:33:03 +0100990 /* we have the annotation definition */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200991 ant = &mod->compiled->exts[u];
Michal Vasko90932a92020-02-12 14:33:03 +0100992 break;
993 }
994 }
995 if (!ant) {
996 /* attribute is not defined as a metadata annotation (RFC 7952) */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100997 LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
Radek Krejci422afb12021-03-04 16:38:16 +0100998 mod->name, (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100999 ret = LY_EINVAL;
1000 goto cleanup;
Michal Vasko90932a92020-02-12 14:33:03 +01001001 }
1002
Michal Vasko9f96a052020-03-10 09:41:45 +01001003 mt = calloc(1, sizeof *mt);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001004 LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
Michal Vasko9f96a052020-03-10 09:41:45 +01001005 mt->parent = parent;
1006 mt->annotation = ant;
Michal Vaskofbd037c2022-11-08 10:34:20 +01001007 lyplg_ext_get_storage(ant, LY_STMT_TYPE, sizeof ant_type, (const void **)&ant_type);
Michal Vasko193dacd2022-10-13 08:43:05 +02001008 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 +01001009 ctx_node, incomplete);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001010 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
1011 ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
1012 LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
Michal Vasko90932a92020-02-12 14:33:03 +01001013
Michal Vasko6f4cbb62020-02-28 11:15:47 +01001014 /* insert as the last attribute */
1015 if (parent) {
Michal Vasko871a0252020-11-11 18:35:24 +01001016 lyd_insert_meta(parent, mt, clear_dflt);
Michal Vasko9f96a052020-03-10 09:41:45 +01001017 } else if (*meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001018 for (last = *meta; last->next; last = last->next) {}
Michal Vasko9f96a052020-03-10 09:41:45 +01001019 last->next = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01001020 }
1021
Michal Vasko9f96a052020-03-10 09:41:45 +01001022 if (meta) {
1023 *meta = mt;
Michal Vasko90932a92020-02-12 14:33:03 +01001024 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001025
1026cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +01001027 return ret;
Michal Vasko90932a92020-02-12 14:33:03 +01001028}
1029
Michal Vaskoa5da3292020-08-12 13:10:50 +02001030void
1031lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
1032{
1033 struct lyd_attr *last, *iter;
1034 struct lyd_node_opaq *opaq;
1035
1036 assert(parent && !parent->schema);
1037
1038 if (!attr) {
1039 return;
1040 }
1041
1042 opaq = (struct lyd_node_opaq *)parent;
1043 for (iter = attr; iter; iter = iter->next) {
1044 iter->parent = opaq;
1045 }
1046
1047 /* insert as the last attribute */
1048 if (opaq->attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001049 for (last = opaq->attr; last->next; last = last->next) {}
Michal Vaskoa5da3292020-08-12 13:10:50 +02001050 last->next = attr;
1051 } else {
1052 opaq->attr = attr;
1053 }
1054}
1055
Michal Vasko52927e22020-03-16 17:26:14 +01001056LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001057lyd_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 +01001058 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 +02001059 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 +01001060{
Radek Krejci011e4aa2020-09-04 15:22:31 +02001061 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001062 struct lyd_attr *at, *last;
Michal Vasko52927e22020-03-16 17:26:14 +01001063
1064 assert(ctx && (parent || attr) && (!parent || !parent->schema));
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001065 assert(name && name_len && format);
Michal Vasko52927e22020-03-16 17:26:14 +01001066
Michal Vasko2a3722d2021-06-16 11:52:39 +02001067 if (!value_len && (!dynamic || !*dynamic)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001068 value = "";
1069 }
1070
1071 at = calloc(1, sizeof *at);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001072 LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
Radek Krejcid46e46a2020-09-15 14:22:42 +02001073
Michal Vaskoad92b672020-11-12 13:11:31 +01001074 LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001075 if (prefix_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001076 LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001077 }
1078 if (module_key_len) {
Michal Vaskoad92b672020-11-12 13:11:31 +01001079 LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
Michal Vasko501af032020-11-11 20:27:44 +01001080 }
1081
Michal Vasko52927e22020-03-16 17:26:14 +01001082 if (dynamic && *dynamic) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001083 ret = lydict_insert_zc(ctx, (char *)value, &at->value);
1084 LY_CHECK_GOTO(ret, finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001085 *dynamic = 0;
1086 } else {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001087 LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
Michal Vasko52927e22020-03-16 17:26:14 +01001088 }
Michal Vasko501af032020-11-11 20:27:44 +01001089 at->format = format;
1090 at->val_prefix_data = val_prefix_data;
1091 at->hints = hints;
Michal Vasko52927e22020-03-16 17:26:14 +01001092
1093 /* insert as the last attribute */
1094 if (parent) {
Michal Vaskoa5da3292020-08-12 13:10:50 +02001095 lyd_insert_attr(parent, at);
Michal Vasko52927e22020-03-16 17:26:14 +01001096 } else if (*attr) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001097 for (last = *attr; last->next; last = last->next) {}
Michal Vasko52927e22020-03-16 17:26:14 +01001098 last->next = at;
1099 }
1100
Radek Krejci011e4aa2020-09-04 15:22:31 +02001101finish:
1102 if (ret) {
1103 lyd_free_attr_single(ctx, at);
1104 } else if (attr) {
Michal Vasko52927e22020-03-16 17:26:14 +01001105 *attr = at;
1106 }
1107 return LY_SUCCESS;
1108}
1109
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001110LIBYANG_API_DEF const struct lyd_node_term *
Michal Vasko004d3152020-06-11 19:59:22 +02001111lyd_target(const struct ly_path *path, const struct lyd_node *tree)
Radek Krejci084289f2019-07-09 17:35:30 +02001112{
Michal Vasko004d3152020-06-11 19:59:22 +02001113 struct lyd_node *target;
Radek Krejci084289f2019-07-09 17:35:30 +02001114
Michal Vasko004d3152020-06-11 19:59:22 +02001115 if (ly_path_eval(path, tree, &target)) {
1116 return NULL;
Radek Krejci084289f2019-07-09 17:35:30 +02001117 }
1118
Michal Vasko004d3152020-06-11 19:59:22 +02001119 return (struct lyd_node_term *)target;
Radek Krejci084289f2019-07-09 17:35:30 +02001120}
1121
aPiecek2f63f952021-03-30 12:22:18 +02001122/**
1123 * @brief Check the equality of the two schemas from different contexts.
1124 *
1125 * @param schema1 of first node.
1126 * @param schema2 of second node.
1127 * @return 1 if the schemas are equal otherwise 0.
1128 */
1129static ly_bool
1130lyd_compare_schema_equal(const struct lysc_node *schema1, const struct lysc_node *schema2)
1131{
1132 if (!schema1 && !schema2) {
1133 return 1;
1134 } else if (!schema1 || !schema2) {
1135 return 0;
1136 }
1137
1138 assert(schema1->module->ctx != schema2->module->ctx);
1139
1140 if (schema1->nodetype != schema2->nodetype) {
1141 return 0;
1142 }
1143
1144 if (strcmp(schema1->name, schema2->name)) {
1145 return 0;
1146 }
1147
1148 if (strcmp(schema1->module->name, schema2->module->name)) {
1149 return 0;
1150 }
1151
1152 if (schema1->module->revision || schema2->module->revision) {
1153 if (!schema1->module->revision || !schema2->module->revision) {
1154 return 0;
1155 }
1156 if (strcmp(schema1->module->revision, schema2->module->revision)) {
1157 return 0;
1158 }
1159 }
1160
1161 return 1;
1162}
1163
1164/**
1165 * @brief Check the equality of the schemas for all parent nodes.
1166 *
1167 * Both nodes must be from different contexts.
1168 *
1169 * @param node1 Data of first node.
1170 * @param node2 Data of second node.
1171 * @return 1 if the all related parental schemas are equal otherwise 0.
1172 */
1173static ly_bool
1174lyd_compare_schema_parents_equal(const struct lyd_node *node1, const struct lyd_node *node2)
1175{
1176 const struct lysc_node *parent1, *parent2;
1177
1178 assert(node1 && node2);
1179
1180 for (parent1 = node1->schema->parent, parent2 = node2->schema->parent;
1181 parent1 && parent2;
1182 parent1 = parent1->parent, parent2 = parent2->parent) {
1183 if (!lyd_compare_schema_equal(parent1, parent2)) {
1184 return 0;
1185 }
1186 }
1187
1188 if (parent1 || parent2) {
1189 return 0;
1190 }
1191
1192 return 1;
1193}
1194
1195/**
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001196 * @brief Compare 2 nodes values including opaque node values.
1197 *
1198 * @param[in] node1 First node to compare.
1199 * @param[in] node2 Second node to compare.
1200 * @return LY_SUCCESS if equal.
1201 * @return LY_ENOT if not equal.
1202 * @return LY_ERR on error.
1203 */
1204static LY_ERR
1205lyd_compare_single_value(const struct lyd_node *node1, const struct lyd_node *node2)
1206{
1207 const struct lyd_node_opaq *opaq1 = NULL, *opaq2 = NULL;
1208 const char *val1, *val2, *col;
1209 const struct lys_module *mod;
1210 char *val_dyn = NULL;
1211 LY_ERR rc = LY_SUCCESS;
1212
1213 if (!node1->schema) {
1214 opaq1 = (struct lyd_node_opaq *)node1;
1215 }
1216 if (!node2->schema) {
1217 opaq2 = (struct lyd_node_opaq *)node2;
1218 }
1219
1220 if (opaq1 && opaq2 && (opaq1->format == LY_VALUE_XML) && (opaq2->format == LY_VALUE_XML)) {
1221 /* opaque XML and opaque XML node */
1222 if (lyxml_value_compare(LYD_CTX(node1), opaq1->value, opaq1->val_prefix_data, LYD_CTX(node2), opaq2->value,
1223 opaq2->val_prefix_data)) {
1224 return LY_ENOT;
1225 }
1226 return LY_SUCCESS;
1227 }
1228
1229 /* get their values */
1230 if (opaq1 && ((opaq1->format == LY_VALUE_XML) || (opaq1->format == LY_VALUE_STR_NS)) && (col = strchr(opaq1->value, ':'))) {
1231 /* XML value with a prefix, try to transform it into a JSON (canonical) value */
1232 mod = ly_resolve_prefix(LYD_CTX(node1), opaq1->value, col - opaq1->value, opaq1->format, opaq1->val_prefix_data);
1233 if (!mod) {
1234 /* unable to compare */
1235 return LY_ENOT;
1236 }
1237
1238 if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
1239 LOGMEM(LYD_CTX(node1));
1240 return LY_EMEM;
1241 }
1242 val1 = val_dyn;
1243 } else {
1244 val1 = lyd_get_value(node1);
1245 }
1246 if (opaq2 && ((opaq2->format == LY_VALUE_XML) || (opaq2->format == LY_VALUE_STR_NS)) && (col = strchr(opaq2->value, ':'))) {
1247 mod = ly_resolve_prefix(LYD_CTX(node2), opaq2->value, col - opaq2->value, opaq2->format, opaq2->val_prefix_data);
1248 if (!mod) {
1249 return LY_ENOT;
1250 }
1251
1252 assert(!val_dyn);
1253 if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
1254 LOGMEM(LYD_CTX(node2));
1255 return LY_EMEM;
1256 }
1257 val2 = val_dyn;
1258 } else {
1259 val2 = lyd_get_value(node2);
1260 }
1261
1262 /* compare values */
1263 if (strcmp(val1, val2)) {
1264 rc = LY_ENOT;
1265 }
1266
1267 free(val_dyn);
1268 return rc;
1269}
1270
1271/**
aPiecek2f63f952021-03-30 12:22:18 +02001272 * @brief Internal implementation of @ref lyd_compare_single.
1273 * @copydoc lyd_compare_single
1274 * @param[in] parental_schemas_checked Flag used for optimization.
1275 * When this function is called for the first time, the flag must be set to 0.
1276 * The @ref lyd_compare_schema_parents_equal should be called only once during
1277 * recursive calls, and this is accomplished by setting to 1 in the lyd_compare_single_ body.
1278 */
1279static LY_ERR
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001280lyd_compare_single_(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options,
1281 ly_bool parental_schemas_checked)
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001282{
1283 const struct lyd_node *iter1, *iter2;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001284 struct lyd_node_any *any1, *any2;
Michal Vaskof3c80a72022-08-17 10:22:04 +02001285 int len1, len2;
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001286 LY_ERR r;
Radek Krejci084289f2019-07-09 17:35:30 +02001287
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001288 if (!node1 || !node2) {
1289 if (node1 == node2) {
1290 return LY_SUCCESS;
1291 } else {
1292 return LY_ENOT;
1293 }
1294 }
1295
aPiecek2f63f952021-03-30 12:22:18 +02001296 if (LYD_CTX(node1) == LYD_CTX(node2)) {
1297 /* same contexts */
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001298 if (options & LYD_COMPARE_OPAQ) {
1299 if (lyd_node_schema(node1) != lyd_node_schema(node2)) {
1300 return LY_ENOT;
1301 }
1302 } else {
1303 if (node1->schema != node2->schema) {
1304 return LY_ENOT;
1305 }
aPiecek2f63f952021-03-30 12:22:18 +02001306 }
1307 } else {
1308 /* different contexts */
1309 if (!lyd_compare_schema_equal(node1->schema, node2->schema)) {
1310 return LY_ENOT;
1311 }
1312 if (!parental_schemas_checked) {
1313 if (!lyd_compare_schema_parents_equal(node1, node2)) {
1314 return LY_ENOT;
1315 }
1316 parental_schemas_checked = 1;
1317 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001318 }
1319
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001320 if (!(options & LYD_COMPARE_OPAQ) && (node1->hash != node2->hash)) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001321 return LY_ENOT;
1322 }
aPiecek2f63f952021-03-30 12:22:18 +02001323 /* 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 +02001324
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001325 if (!node1->schema || !node2->schema) {
1326 if (!(options & LYD_COMPARE_OPAQ) && ((node1->schema && !node2->schema) || (!node1->schema && node2->schema))) {
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001327 return LY_ENOT;
1328 }
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001329 if ((r = lyd_compare_single_value(node1, node2))) {
1330 return r;
Michal Vasko52927e22020-03-16 17:26:14 +01001331 }
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001332
Michal Vasko52927e22020-03-16 17:26:14 +01001333 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001334 iter1 = lyd_child(node1);
1335 iter2 = lyd_child(node2);
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001336 goto all_children_compare;
Michal Vasko52927e22020-03-16 17:26:14 +01001337 }
1338 return LY_SUCCESS;
1339 } else {
1340 switch (node1->schema->nodetype) {
1341 case LYS_LEAF:
1342 case LYS_LEAFLIST:
1343 if (options & LYD_COMPARE_DEFAULTS) {
1344 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
1345 return LY_ENOT;
1346 }
1347 }
Michal Vaskodf8ebf62022-11-10 10:33:28 +01001348 if ((r = lyd_compare_single_value(node1, node2))) {
1349 return r;
aPiecek2f63f952021-03-30 12:22:18 +02001350 }
1351
aPiecek2f63f952021-03-30 12:22:18 +02001352 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001353 case LYS_CONTAINER:
Michal Vaskoc8187dc2022-05-13 12:26:40 +02001354 case LYS_RPC:
1355 case LYS_ACTION:
1356 case LYS_NOTIF:
Michal Vasko52927e22020-03-16 17:26:14 +01001357 if (options & LYD_COMPARE_DEFAULTS) {
1358 if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
1359 return LY_ENOT;
1360 }
1361 }
1362 if (options & LYD_COMPARE_FULL_RECURSION) {
Michal Vasko9e685082021-01-29 14:49:09 +01001363 iter1 = lyd_child(node1);
1364 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01001365 goto all_children_compare;
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001366 }
1367 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001368 case LYS_LIST:
Michal Vasko9e685082021-01-29 14:49:09 +01001369 iter1 = lyd_child(node1);
1370 iter2 = lyd_child(node2);
Michal Vasko52927e22020-03-16 17:26:14 +01001371
1372 if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
1373 /* lists with keys, their equivalence is based on their keys */
Michal Vasko544e58a2021-01-28 14:33:41 +01001374 for (const struct lysc_node *key = lysc_node_child(node1->schema);
Michal Vaskoc57d9a92020-06-23 13:28:27 +02001375 key && (key->flags & LYS_KEY);
Michal Vasko52927e22020-03-16 17:26:14 +01001376 key = key->next) {
aPiecek2f63f952021-03-30 12:22:18 +02001377 if (lyd_compare_single_(iter1, iter2, options, parental_schemas_checked)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001378 return LY_ENOT;
1379 }
1380 iter1 = iter1->next;
1381 iter2 = iter2->next;
1382 }
1383 } else {
1384 /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
1385
Radek Krejci0f969882020-08-21 16:56:47 +02001386all_children_compare:
Michal Vasko52927e22020-03-16 17:26:14 +01001387 if (!iter1 && !iter2) {
1388 /* no children, nothing to compare */
1389 return LY_SUCCESS;
1390 }
1391
Michal Vaskod989ba02020-08-24 10:59:24 +02001392 for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
aPiecek2f63f952021-03-30 12:22:18 +02001393 if (lyd_compare_single_(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION, parental_schemas_checked)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001394 return LY_ENOT;
1395 }
1396 }
1397 if (iter1 || iter2) {
1398 return LY_ENOT;
1399 }
1400 }
1401 return LY_SUCCESS;
1402 case LYS_ANYXML:
1403 case LYS_ANYDATA:
Michal Vasko22df3f02020-08-24 13:29:22 +02001404 any1 = (struct lyd_node_any *)node1;
1405 any2 = (struct lyd_node_any *)node2;
Michal Vasko52927e22020-03-16 17:26:14 +01001406
1407 if (any1->value_type != any2->value_type) {
1408 return LY_ENOT;
1409 }
1410 switch (any1->value_type) {
1411 case LYD_ANYDATA_DATATREE:
1412 iter1 = any1->value.tree;
1413 iter2 = any2->value.tree;
1414 goto all_children_compare;
1415 case LYD_ANYDATA_STRING:
1416 case LYD_ANYDATA_XML:
1417 case LYD_ANYDATA_JSON:
Michal Vasko3b4ec412022-09-22 15:24:14 +02001418 if ((!any1->value.str && any2->value.str) || (any1->value.str && !any2->value.str)) {
1419 return LY_ENOT;
1420 } else if (!any1->value.str && !any2->value.str) {
1421 return LY_SUCCESS;
1422 }
Michal Vasko52927e22020-03-16 17:26:14 +01001423 len1 = strlen(any1->value.str);
1424 len2 = strlen(any2->value.str);
Michal Vasko69730152020-10-09 16:30:07 +02001425 if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001426 return LY_ENOT;
1427 }
1428 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001429 case LYD_ANYDATA_LYB:
Michal Vasko60ea6352020-06-29 13:39:39 +02001430 len1 = lyd_lyb_data_length(any1->value.mem);
1431 len2 = lyd_lyb_data_length(any2->value.mem);
Michal Vasko2b97d472022-08-17 09:29:03 +02001432 if ((len1 == -1) || (len2 == -1) || (len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001433 return LY_ENOT;
1434 }
1435 return LY_SUCCESS;
Michal Vasko52927e22020-03-16 17:26:14 +01001436 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001437 }
1438 }
1439
Michal Vaskob7be7a82020-08-20 09:09:04 +02001440 LOGINT(LYD_CTX(node1));
Radek Krejci1f05b6a2019-07-18 16:15:06 +02001441 return LY_EINT;
1442}
Radek Krejci22ebdba2019-07-25 13:59:43 +02001443
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001444LIBYANG_API_DEF LY_ERR
aPiecek2f63f952021-03-30 12:22:18 +02001445lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
1446{
1447 return lyd_compare_single_(node1, node2, options, 0);
1448}
1449
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001450LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001451lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
Michal Vasko8f359bf2020-07-28 10:41:15 +02001452{
Michal Vaskod989ba02020-08-24 10:59:24 +02001453 for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
Michal Vasko8f359bf2020-07-28 10:41:15 +02001454 LY_CHECK_RET(lyd_compare_single(node1, node2, options));
1455 }
1456
Michal Vasko11a81432020-07-28 16:31:29 +02001457 if (node1 == node2) {
1458 return LY_SUCCESS;
Michal Vasko8f359bf2020-07-28 10:41:15 +02001459 }
Michal Vasko11a81432020-07-28 16:31:29 +02001460 return LY_ENOT;
Michal Vasko8f359bf2020-07-28 10:41:15 +02001461}
1462
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001463LIBYANG_API_DEF LY_ERR
Michal Vasko21725742020-06-29 11:49:25 +02001464lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
1465{
1466 if (!meta1 || !meta2) {
1467 if (meta1 == meta2) {
1468 return LY_SUCCESS;
1469 } else {
1470 return LY_ENOT;
1471 }
1472 }
1473
Michal Vaskoa8083062020-11-06 17:22:10 +01001474 if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
Michal Vasko21725742020-06-29 11:49:25 +02001475 return LY_ENOT;
1476 }
1477
Michal Vasko21725742020-06-29 11:49:25 +02001478 return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
1479}
1480
Radek Krejci22ebdba2019-07-25 13:59:43 +02001481/**
Michal Vasko9cf62422021-07-01 13:29:32 +02001482 * @brief Create a copy of the attribute.
1483 *
1484 * @param[in] attr Attribute to copy.
1485 * @param[in] node Opaque where to append the new attribute.
1486 * @param[out] dup Optional created attribute copy.
1487 * @return LY_ERR value.
1488 */
1489static LY_ERR
1490lyd_dup_attr_single(const struct lyd_attr *attr, struct lyd_node *node, struct lyd_attr **dup)
1491{
1492 LY_ERR ret = LY_SUCCESS;
1493 struct lyd_attr *a, *last;
1494 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)node;
1495
1496 LY_CHECK_ARG_RET(NULL, attr, node, !node->schema, LY_EINVAL);
1497
1498 /* create a copy */
1499 a = calloc(1, sizeof *attr);
1500 LY_CHECK_ERR_RET(!a, LOGMEM(LYD_CTX(node)), LY_EMEM);
1501
1502 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.name, 0, &a->name.name), finish);
1503 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.prefix, 0, &a->name.prefix), finish);
1504 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.module_ns, 0, &a->name.module_ns), finish);
1505 LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->value, 0, &a->value), finish);
1506 a->hints = attr->hints;
1507 a->format = attr->format;
1508 if (attr->val_prefix_data) {
1509 ret = ly_dup_prefix_data(LYD_CTX(node), attr->format, attr->val_prefix_data, &a->val_prefix_data);
1510 LY_CHECK_GOTO(ret, finish);
1511 }
1512
1513 /* insert as the last attribute */
1514 a->parent = opaq;
1515 if (opaq->attr) {
1516 for (last = opaq->attr; last->next; last = last->next) {}
1517 last->next = a;
1518 } else {
1519 opaq->attr = a;
1520 }
1521
1522finish:
1523 if (ret) {
1524 lyd_free_attr_single(LYD_CTX(node), a);
1525 } else if (dup) {
1526 *dup = a;
1527 }
1528 return LY_SUCCESS;
1529}
1530
1531/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001532 * @brief Find @p schema equivalent in @p trg_ctx.
1533 *
1534 * @param[in] schema Schema node to find.
1535 * @param[in] trg_ctx Target context to search in.
1536 * @param[in] parent Data parent of @p schema, if any.
Michal Vaskoaf3df492022-12-02 14:03:52 +01001537 * @param[in] log Whether to log directly.
Michal Vaskoddd76592022-01-17 13:34:48 +01001538 * @param[out] trg_schema Found schema from @p trg_ctx to use.
1539 * @return LY_RRR value.
1540 */
1541static LY_ERR
Michal Vaskoaf3df492022-12-02 14:03:52 +01001542lyd_find_schema_ctx(const struct lysc_node *schema, const struct ly_ctx *trg_ctx, const struct lyd_node *parent,
1543 ly_bool log, const struct lysc_node **trg_schema)
Michal Vaskoddd76592022-01-17 13:34:48 +01001544{
Michal Vasko9beceb82022-04-05 12:14:15 +02001545 const struct lysc_node *src_parent = NULL, *trg_parent = NULL, *sp, *tp;
1546 const struct lys_module *trg_mod = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +01001547 char *path;
1548
1549 if (!schema) {
1550 /* opaque node */
1551 *trg_schema = NULL;
1552 return LY_SUCCESS;
1553 }
1554
Michal Vasko9beceb82022-04-05 12:14:15 +02001555 if (lysc_data_parent(schema) && parent && parent->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001556 /* start from schema parent */
Michal Vasko9beceb82022-04-05 12:14:15 +02001557 trg_parent = parent->schema;
1558 src_parent = lysc_data_parent(schema);
1559 }
1560
1561 do {
1562 /* find the next parent */
1563 sp = schema;
Michal Vaskob6808202022-12-02 14:04:23 +01001564 while (lysc_data_parent(sp) != src_parent) {
1565 sp = lysc_data_parent(sp);
Michal Vasko9beceb82022-04-05 12:14:15 +02001566 }
1567 src_parent = sp;
1568
1569 if (!src_parent->parent) {
1570 /* find the module first */
1571 trg_mod = ly_ctx_get_module_implemented(trg_ctx, src_parent->module->name);
1572 if (!trg_mod) {
Michal Vaskoaf3df492022-12-02 14:03:52 +01001573 if (log) {
1574 LOGERR(trg_ctx, LY_ENOTFOUND, "Module \"%s\" not present/implemented in the target context.",
1575 src_parent->module->name);
1576 }
Michal Vasko9beceb82022-04-05 12:14:15 +02001577 return LY_ENOTFOUND;
1578 }
1579 }
1580
1581 /* find the next parent */
1582 assert(trg_parent || trg_mod);
1583 tp = NULL;
1584 while ((tp = lys_getnext(tp, trg_parent, trg_mod ? trg_mod->compiled : NULL, 0))) {
1585 if (!strcmp(tp->name, src_parent->name) && !strcmp(tp->module->name, src_parent->module->name)) {
1586 break;
1587 }
1588 }
1589 if (!tp) {
1590 /* schema node not found */
Michal Vaskoaf3df492022-12-02 14:03:52 +01001591 if (log) {
1592 path = lysc_path(src_parent, LYSC_PATH_LOG, NULL, 0);
1593 LOGERR(trg_ctx, LY_ENOTFOUND, "Schema node \"%s\" not found in the target context.", path);
1594 free(path);
1595 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001596 return LY_ENOTFOUND;
1597 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001598
Michal Vasko9beceb82022-04-05 12:14:15 +02001599 trg_parent = tp;
1600 } while (schema != src_parent);
Michal Vaskoddd76592022-01-17 13:34:48 +01001601
Michal Vasko9beceb82022-04-05 12:14:15 +02001602 /* success */
1603 *trg_schema = trg_parent;
1604 return LY_SUCCESS;
Michal Vaskoddd76592022-01-17 13:34:48 +01001605}
1606
1607/**
Michal Vasko52927e22020-03-16 17:26:14 +01001608 * @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 +02001609 *
Michal Vaskoddd76592022-01-17 13:34:48 +01001610 * 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 +02001611 *
Michal Vaskoddd76592022-01-17 13:34:48 +01001612 * @param[in] node Node to duplicate.
1613 * @param[in] trg_ctx Target context for duplicated nodes.
Radek Krejcif8b95172020-05-15 14:51:06 +02001614 * @param[in] parent Parent to insert into, NULL for top-level sibling.
Michal Vasko67177e52021-08-25 11:15:15 +02001615 * @param[in] insert_last Whether the duplicated node can be inserted as the last child of @p parent. Set for
1616 * recursive duplication as an optimization.
Radek Krejcif8b95172020-05-15 14:51:06 +02001617 * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
1618 * @param[in] options Bitmask of options flags, see @ref dupoptions.
Michal Vaskoddd76592022-01-17 13:34:48 +01001619 * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it to @p parent / @p first).
1620 * @return LY_ERR value.
Radek Krejci22ebdba2019-07-25 13:59:43 +02001621 */
Michal Vasko52927e22020-03-16 17:26:14 +01001622static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001623lyd_dup_r(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent, ly_bool insert_last,
1624 struct lyd_node **first, uint32_t options, struct lyd_node **dup_p)
Radek Krejci22ebdba2019-07-25 13:59:43 +02001625{
Michal Vasko52927e22020-03-16 17:26:14 +01001626 LY_ERR ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001627 struct lyd_node *dup = NULL;
Michal Vasko61551fa2020-07-09 15:45:45 +02001628 struct lyd_meta *meta;
Michal Vasko9cf62422021-07-01 13:29:32 +02001629 struct lyd_attr *attr;
Michal Vasko61551fa2020-07-09 15:45:45 +02001630 struct lyd_node_any *any;
Michal Vaskoddd76592022-01-17 13:34:48 +01001631 const struct lysc_type *type;
1632 const char *val_can;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001633
Michal Vasko52927e22020-03-16 17:26:14 +01001634 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001635
Michal Vasko19175b62022-04-01 09:17:07 +02001636 if (node->flags & LYD_EXT) {
Michal Vasko53ac4dd2022-06-07 10:56:08 +02001637 if (options & LYD_DUP_NO_EXT) {
1638 /* no not duplicate this subtree */
1639 return LY_SUCCESS;
1640 }
1641
Michal Vasko19175b62022-04-01 09:17:07 +02001642 /* we need to use the same context */
1643 trg_ctx = LYD_CTX(node);
1644 }
1645
Michal Vasko52927e22020-03-16 17:26:14 +01001646 if (!node->schema) {
1647 dup = calloc(1, sizeof(struct lyd_node_opaq));
Michal Vaskoddd76592022-01-17 13:34:48 +01001648 ((struct lyd_node_opaq *)dup)->ctx = trg_ctx;
Michal Vasko52927e22020-03-16 17:26:14 +01001649 } else {
1650 switch (node->schema->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +01001651 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +01001652 case LYS_ACTION:
1653 case LYS_NOTIF:
1654 case LYS_CONTAINER:
1655 case LYS_LIST:
1656 dup = calloc(1, sizeof(struct lyd_node_inner));
1657 break;
1658 case LYS_LEAF:
1659 case LYS_LEAFLIST:
1660 dup = calloc(1, sizeof(struct lyd_node_term));
1661 break;
1662 case LYS_ANYDATA:
1663 case LYS_ANYXML:
1664 dup = calloc(1, sizeof(struct lyd_node_any));
1665 break;
1666 default:
Michal Vaskoddd76592022-01-17 13:34:48 +01001667 LOGINT(trg_ctx);
Michal Vasko52927e22020-03-16 17:26:14 +01001668 ret = LY_EINT;
1669 goto error;
1670 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02001671 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001672 LY_CHECK_ERR_GOTO(!dup, LOGMEM(trg_ctx); ret = LY_EMEM, error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001673
Michal Vaskof6df0a02020-06-16 13:08:34 +02001674 if (options & LYD_DUP_WITH_FLAGS) {
1675 dup->flags = node->flags;
1676 } else {
Michal Vasko19175b62022-04-01 09:17:07 +02001677 dup->flags = (node->flags & (LYD_DEFAULT | LYD_EXT)) | LYD_NEW;
Michal Vaskof6df0a02020-06-16 13:08:34 +02001678 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001679 if (trg_ctx == LYD_CTX(node)) {
1680 dup->schema = node->schema;
1681 } else {
Michal Vaskoaf3df492022-12-02 14:03:52 +01001682 ret = lyd_find_schema_ctx(node->schema, trg_ctx, parent, 1, &dup->schema);
Michal Vasko27f536f2022-04-01 09:17:30 +02001683 if (ret) {
1684 /* has no schema but is not an opaque node */
1685 free(dup);
1686 dup = NULL;
1687 goto error;
1688 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001689 }
Michal Vasko52927e22020-03-16 17:26:14 +01001690 dup->prev = dup;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001691
Michal Vasko9cf62422021-07-01 13:29:32 +02001692 /* duplicate metadata/attributes */
Michal Vasko25a32822020-07-09 15:48:22 +02001693 if (!(options & LYD_DUP_NO_META)) {
Michal Vasko9cf62422021-07-01 13:29:32 +02001694 if (!node->schema) {
1695 LY_LIST_FOR(((struct lyd_node_opaq *)node)->attr, attr) {
1696 LY_CHECK_GOTO(ret = lyd_dup_attr_single(attr, dup, NULL), error);
1697 }
1698 } else {
1699 LY_LIST_FOR(node->meta, meta) {
1700 LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
1701 }
Michal Vasko25a32822020-07-09 15:48:22 +02001702 }
1703 }
Radek Krejci22ebdba2019-07-25 13:59:43 +02001704
1705 /* nodetype-specific work */
Michal Vasko52927e22020-03-16 17:26:14 +01001706 if (!dup->schema) {
1707 struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
1708 struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
1709 struct lyd_node *child;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001710
1711 if (options & LYD_DUP_RECURSIVE) {
1712 /* duplicate all the children */
1713 LY_LIST_FOR(orig->child, child) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001714 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Michal Vasko52927e22020-03-16 17:26:14 +01001715 }
1716 }
Michal Vaskoddd76592022-01-17 13:34:48 +01001717 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.name, 0, &opaq->name.name), error);
1718 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.prefix, 0, &opaq->name.prefix), error);
1719 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.module_ns, 0, &opaq->name.module_ns), error);
1720 LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->value, 0, &opaq->value), error);
Michal Vasko9cf62422021-07-01 13:29:32 +02001721 opaq->hints = orig->hints;
1722 opaq->format = orig->format;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001723 if (orig->val_prefix_data) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001724 ret = ly_dup_prefix_data(trg_ctx, opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001725 LY_CHECK_GOTO(ret, error);
Michal Vasko52927e22020-03-16 17:26:14 +01001726 }
Michal Vasko52927e22020-03-16 17:26:14 +01001727 } else if (dup->schema->nodetype & LYD_NODE_TERM) {
1728 struct lyd_node_term *term = (struct lyd_node_term *)dup;
1729 struct lyd_node_term *orig = (struct lyd_node_term *)node;
1730
1731 term->hash = orig->hash;
Michal Vaskoddd76592022-01-17 13:34:48 +01001732 if (trg_ctx == LYD_CTX(node)) {
1733 ret = orig->value.realtype->plugin->duplicate(trg_ctx, &orig->value, &term->value);
1734 LY_CHECK_ERR_GOTO(ret, LOGERR(trg_ctx, ret, "Value duplication failed."), error);
1735 } else {
1736 /* store canonical value in the target context */
1737 val_can = lyd_get_value(node);
1738 type = ((struct lysc_node_leaf *)term->schema)->type;
1739 ret = lyd_value_store(trg_ctx, &term->value, type, val_can, strlen(val_can), NULL, LY_VALUE_CANON, NULL,
1740 LYD_HINT_DATA, term->schema, NULL);
1741 LY_CHECK_GOTO(ret, error);
1742 }
Michal Vasko52927e22020-03-16 17:26:14 +01001743 } else if (dup->schema->nodetype & LYD_NODE_INNER) {
1744 struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
1745 struct lyd_node *child;
1746
1747 if (options & LYD_DUP_RECURSIVE) {
1748 /* duplicate all the children */
1749 LY_LIST_FOR(orig->child, child) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001750 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001751 }
Michal Vasko69730152020-10-09 16:30:07 +02001752 } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02001753 /* always duplicate keys of a list */
Michal Vasko9beceb82022-04-05 12:14:15 +02001754 for (child = orig->child; child && lysc_is_key(child->schema); child = child->next) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001755 LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001756 }
1757 }
1758 lyd_hash(dup);
1759 } else if (dup->schema->nodetype & LYD_NODE_ANY) {
Michal Vasko61551fa2020-07-09 15:45:45 +02001760 dup->hash = node->hash;
1761 any = (struct lyd_node_any *)node;
1762 LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001763 }
1764
Michal Vasko52927e22020-03-16 17:26:14 +01001765 /* insert */
Michal Vasko67177e52021-08-25 11:15:15 +02001766 lyd_insert_node(parent, first, dup, insert_last);
Michal Vasko52927e22020-03-16 17:26:14 +01001767
1768 if (dup_p) {
1769 *dup_p = dup;
1770 }
1771 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001772
1773error:
Michal Vasko52927e22020-03-16 17:26:14 +01001774 lyd_free_tree(dup);
1775 return ret;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001776}
1777
Michal Vasko29d674b2021-08-25 11:18:35 +02001778/**
1779 * @brief Get a parent node to connect duplicated subtree to.
1780 *
1781 * @param[in] node Node (subtree) to duplicate.
Michal Vaskoddd76592022-01-17 13:34:48 +01001782 * @param[in] trg_ctx Target context for duplicated nodes.
Michal Vasko29d674b2021-08-25 11:18:35 +02001783 * @param[in] parent Initial parent to connect to.
1784 * @param[in] options Bitmask of options flags, see @ref dupoptions.
1785 * @param[out] dup_parent First duplicated parent node, if any.
1786 * @param[out] local_parent Correct parent to directly connect duplicated @p node to.
1787 * @return LY_ERR value.
1788 */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001789static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001790lyd_dup_get_local_parent(const struct lyd_node *node, const struct ly_ctx *trg_ctx, const struct lyd_node_inner *parent,
1791 uint32_t options, struct lyd_node **dup_parent, struct lyd_node_inner **local_parent)
Radek Krejci22ebdba2019-07-25 13:59:43 +02001792{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001793 const struct lyd_node_inner *orig_parent, *iter;
Michal Vasko83522192022-07-20 08:07:34 +02001794 ly_bool repeat = 1, ext_parent = 0;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001795
1796 *dup_parent = NULL;
1797 *local_parent = NULL;
1798
Michal Vasko83522192022-07-20 08:07:34 +02001799 if (node->flags & LYD_EXT) {
1800 ext_parent = 1;
1801 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001802 for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
Michal Vasko83522192022-07-20 08:07:34 +02001803 if (ext_parent) {
1804 /* use the standard context */
1805 trg_ctx = LYD_CTX(orig_parent);
1806 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001807 if (parent && (parent->schema == orig_parent->schema)) {
1808 /* stop creating parents, connect what we have into the provided parent */
1809 iter = parent;
1810 repeat = 0;
1811 } else {
1812 iter = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +01001813 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 +02001814 (struct lyd_node **)&iter));
Michal Vasko3a41dff2020-07-15 14:30:28 +02001815 }
1816 if (!*local_parent) {
1817 *local_parent = (struct lyd_node_inner *)iter;
1818 }
1819 if (iter->child) {
1820 /* 1) list - add after keys
1821 * 2) provided parent with some children */
1822 iter->child->prev->next = *dup_parent;
1823 if (*dup_parent) {
1824 (*dup_parent)->prev = iter->child->prev;
1825 iter->child->prev = *dup_parent;
1826 }
1827 } else {
1828 ((struct lyd_node_inner *)iter)->child = *dup_parent;
1829 }
1830 if (*dup_parent) {
1831 (*dup_parent)->parent = (struct lyd_node_inner *)iter;
1832 }
1833 *dup_parent = (struct lyd_node *)iter;
Michal Vasko83522192022-07-20 08:07:34 +02001834 if (orig_parent->flags & LYD_EXT) {
1835 ext_parent = 1;
1836 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001837 }
1838
1839 if (repeat && parent) {
1840 /* given parent and created parents chain actually do not interconnect */
Michal Vaskoddd76592022-01-17 13:34:48 +01001841 LOGERR(trg_ctx, LY_EINVAL,
Michal Vasko69730152020-10-09 16:30:07 +02001842 "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001843 return LY_EINVAL;
1844 }
1845
1846 return LY_SUCCESS;
1847}
1848
1849static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001850lyd_dup(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent, uint32_t options,
1851 ly_bool nosiblings, struct lyd_node **dup)
Michal Vasko3a41dff2020-07-15 14:30:28 +02001852{
1853 LY_ERR rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001854 const struct lyd_node *orig; /* original node to be duplicated */
1855 struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
Radek Krejci22ebdba2019-07-25 13:59:43 +02001856 struct lyd_node *top = NULL; /* the most higher created node */
1857 struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
Radek Krejci22ebdba2019-07-25 13:59:43 +02001858
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001859 assert(node && trg_ctx);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001860
1861 if (options & LYD_DUP_WITH_PARENTS) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001862 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 +02001863 &top, &local_parent), error);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001864 } else {
1865 local_parent = parent;
1866 }
1867
Radek Krejci22ebdba2019-07-25 13:59:43 +02001868 LY_LIST_FOR(node, orig) {
Michal Vasko35f4d772021-01-12 12:08:57 +01001869 if (lysc_is_key(orig->schema)) {
1870 if (local_parent) {
1871 /* the key must already exist in the parent */
1872 rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
Michal Vaskoddd76592022-01-17 13:34:48 +01001873 LY_CHECK_ERR_GOTO(rc, LOGINT(trg_ctx), error);
Michal Vasko35f4d772021-01-12 12:08:57 +01001874 } else {
1875 assert(!(options & LYD_DUP_WITH_PARENTS));
1876 /* duplicating a single key, okay, I suppose... */
Michal Vaskoddd76592022-01-17 13:34:48 +01001877 rc = lyd_dup_r(orig, trg_ctx, NULL, 0, &first, options, first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01001878 LY_CHECK_GOTO(rc, error);
1879 }
1880 } else {
1881 /* if there is no local parent, it will be inserted into first */
Michal Vaskoddd76592022-01-17 13:34:48 +01001882 rc = lyd_dup_r(orig, trg_ctx, local_parent ? &local_parent->node : NULL, 0, &first, options,
1883 first ? NULL : &first);
Michal Vasko35f4d772021-01-12 12:08:57 +01001884 LY_CHECK_GOTO(rc, error);
1885 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001886 if (nosiblings) {
Radek Krejci22ebdba2019-07-25 13:59:43 +02001887 break;
1888 }
1889 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001890
Michal Vasko3a41dff2020-07-15 14:30:28 +02001891 if (dup) {
1892 *dup = first;
1893 }
1894 return LY_SUCCESS;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001895
1896error:
1897 if (top) {
1898 lyd_free_tree(top);
1899 } else {
Michal Vaskof03ed032020-03-04 13:31:44 +01001900 lyd_free_siblings(first);
Radek Krejci22ebdba2019-07-25 13:59:43 +02001901 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001902 return rc;
Radek Krejci22ebdba2019-07-25 13:59:43 +02001903}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02001904
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001905/**
1906 * @brief Check the context of node and parent when duplicating nodes.
1907 *
1908 * @param[in] node Node to duplicate.
1909 * @param[in] parent Parent of the duplicated node(s).
1910 * @return LY_ERR value.
1911 */
1912static LY_ERR
1913lyd_dup_ctx_check(const struct lyd_node *node, const struct lyd_node_inner *parent)
1914{
1915 const struct lyd_node *iter;
1916
1917 if (!node || !parent) {
1918 return LY_SUCCESS;
1919 }
1920
1921 if ((LYD_CTX(node) != LYD_CTX(parent))) {
1922 /* try to find top-level ext data parent */
1923 for (iter = node; iter && !(iter->flags & LYD_EXT); iter = lyd_parent(iter)) {}
1924
1925 if (!iter || !lyd_parent(iter) || (LYD_CTX(lyd_parent(iter)) != LYD_CTX(parent))) {
1926 LOGERR(NULL, LY_EINVAL, "Different contexts used in node duplication.");
1927 return LY_EINVAL;
1928 }
1929 }
1930
1931 return LY_SUCCESS;
1932}
1933
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001934LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001935lyd_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 +02001936{
Michal Vaskoddd76592022-01-17 13:34:48 +01001937 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001938 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01001939
1940 return lyd_dup(node, LYD_CTX(node), parent, options, 1, dup);
1941}
1942
1943LIBYANG_API_DEF LY_ERR
1944lyd_dup_single_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
1945 uint32_t options, struct lyd_node **dup)
1946{
1947 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
1948
1949 return lyd_dup(node, trg_ctx, parent, options, 1, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001950}
1951
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001952LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001953lyd_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 +02001954{
Michal Vaskoddd76592022-01-17 13:34:48 +01001955 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
Michal Vasko1feb9bb2022-07-20 08:44:07 +02001956 LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
Michal Vaskoddd76592022-01-17 13:34:48 +01001957
1958 return lyd_dup(node, LYD_CTX(node), parent, options, 0, dup);
1959}
1960
1961LIBYANG_API_DEF LY_ERR
1962lyd_dup_siblings_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
1963 uint32_t options, struct lyd_node **dup)
1964{
1965 LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
1966
1967 return lyd_dup(node, trg_ctx, parent, options, 0, dup);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001968}
1969
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001970LIBYANG_API_DEF LY_ERR
Michal Vasko3a41dff2020-07-15 14:30:28 +02001971lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
Michal Vasko25a32822020-07-09 15:48:22 +02001972{
Radek Krejci011e4aa2020-09-04 15:22:31 +02001973 LY_ERR ret = LY_SUCCESS;
Michal Vasko33c48972022-07-20 10:28:07 +02001974 const struct ly_ctx *ctx;
Michal Vasko25a32822020-07-09 15:48:22 +02001975 struct lyd_meta *mt, *last;
1976
Michal Vasko3a41dff2020-07-15 14:30:28 +02001977 LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
Michal Vasko25a32822020-07-09 15:48:22 +02001978
Michal Vasko33c48972022-07-20 10:28:07 +02001979 /* log to node context but value must always use the annotation context */
1980 ctx = meta->annotation->module->ctx;
1981
Michal Vasko25a32822020-07-09 15:48:22 +02001982 /* create a copy */
1983 mt = calloc(1, sizeof *mt);
Michal Vaskob7be7a82020-08-20 09:09:04 +02001984 LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
Michal Vasko25a32822020-07-09 15:48:22 +02001985 mt->annotation = meta->annotation;
Michal Vasko33c48972022-07-20 10:28:07 +02001986 ret = meta->value.realtype->plugin->duplicate(ctx, &meta->value, &mt->value);
Radek Krejci011e4aa2020-09-04 15:22:31 +02001987 LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
Michal Vasko33c48972022-07-20 10:28:07 +02001988 LY_CHECK_GOTO(ret = lydict_insert(ctx, meta->name, 0, &mt->name), finish);
Michal Vasko25a32822020-07-09 15:48:22 +02001989
1990 /* insert as the last attribute */
Radek Krejci011e4aa2020-09-04 15:22:31 +02001991 mt->parent = node;
Michal Vasko25a32822020-07-09 15:48:22 +02001992 if (node->meta) {
Radek Krejci1e008d22020-08-17 11:37:37 +02001993 for (last = node->meta; last->next; last = last->next) {}
Michal Vasko25a32822020-07-09 15:48:22 +02001994 last->next = mt;
1995 } else {
1996 node->meta = mt;
1997 }
1998
Radek Krejci011e4aa2020-09-04 15:22:31 +02001999finish:
2000 if (ret) {
2001 lyd_free_meta_single(mt);
2002 } else if (dup) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002003 *dup = mt;
2004 }
2005 return LY_SUCCESS;
Michal Vasko25a32822020-07-09 15:48:22 +02002006}
2007
Michal Vasko4490d312020-06-16 13:08:55 +02002008/**
2009 * @brief Merge a source sibling into target siblings.
2010 *
2011 * @param[in,out] first_trg First target sibling, is updated if top-level.
2012 * @param[in] parent_trg Target parent.
2013 * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
Michal Vaskocd3f6172021-05-18 16:14:50 +02002014 * @param[in] merge_cb Optional merge callback.
2015 * @param[in] cb_data Arbitrary callback data.
Michal Vasko4490d312020-06-16 13:08:55 +02002016 * @param[in] options Merge options.
Michal Vaskocd3f6172021-05-18 16:14:50 +02002017 * @param[in,out] dup_inst Duplicate instance cache for all @p first_trg siblings.
Michal Vasko4490d312020-06-16 13:08:55 +02002018 * @return LY_ERR value.
2019 */
2020static LY_ERR
2021lyd_merge_sibling_r(struct lyd_node **first_trg, struct lyd_node *parent_trg, const struct lyd_node **sibling_src_p,
Michal Vasko271d2e32023-01-31 15:43:19 +01002022 lyd_merge_cb merge_cb, void *cb_data, uint16_t options, struct hash_table **dup_inst)
Michal Vasko4490d312020-06-16 13:08:55 +02002023{
Michal Vasko4490d312020-06-16 13:08:55 +02002024 const struct lyd_node *child_src, *tmp, *sibling_src;
Michal Vasko56daf732020-08-10 10:57:18 +02002025 struct lyd_node *match_trg, *dup_src, *elem;
Michal Vaskod1afa502022-01-27 16:18:12 +01002026 struct lyd_node_opaq *opaq_trg, *opaq_src;
Michal Vasko4490d312020-06-16 13:08:55 +02002027 struct lysc_type *type;
Michal Vasko271d2e32023-01-31 15:43:19 +01002028 struct hash_table *child_dup_inst = NULL;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002029 LY_ERR ret;
2030 ly_bool first_inst = 0;
Michal Vasko4490d312020-06-16 13:08:55 +02002031
2032 sibling_src = *sibling_src_p;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002033 if (!sibling_src->schema) {
2034 /* try to find the same opaque node */
2035 lyd_find_sibling_opaq_next(*first_trg, LYD_NAME(sibling_src), &match_trg);
2036 } else if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002037 /* try to find the exact instance */
Michal Vaskocd3f6172021-05-18 16:14:50 +02002038 lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02002039 } else {
2040 /* try to simply find the node, there cannot be more instances */
Michal Vaskocd3f6172021-05-18 16:14:50 +02002041 lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
Michal Vasko4490d312020-06-16 13:08:55 +02002042 }
2043
Michal Vaskocd3f6172021-05-18 16:14:50 +02002044 if (match_trg) {
2045 /* update match as needed */
2046 LY_CHECK_RET(lyd_dup_inst_next(&match_trg, *first_trg, dup_inst));
2047 } else {
2048 /* first instance of this node */
2049 first_inst = 1;
2050 }
2051
2052 if (match_trg) {
2053 /* call callback */
2054 if (merge_cb) {
2055 LY_CHECK_RET(merge_cb(match_trg, sibling_src, cb_data));
2056 }
2057
Michal Vasko4490d312020-06-16 13:08:55 +02002058 /* node found, make sure even value matches for all node types */
Michal Vaskod1afa502022-01-27 16:18:12 +01002059 if (!match_trg->schema) {
2060 if (lyd_compare_single(sibling_src, match_trg, 0)) {
2061 /* update value */
2062 opaq_trg = (struct lyd_node_opaq *)match_trg;
2063 opaq_src = (struct lyd_node_opaq *)sibling_src;
2064
2065 lydict_remove(LYD_CTX(opaq_trg), opaq_trg->value);
2066 lydict_insert(LYD_CTX(opaq_trg), opaq_src->value, 0, &opaq_trg->value);
2067 opaq_trg->hints = opaq_src->hints;
2068
2069 ly_free_prefix_data(opaq_trg->format, opaq_trg->val_prefix_data);
2070 opaq_trg->format = opaq_src->format;
2071 ly_dup_prefix_data(LYD_CTX(opaq_trg), opaq_src->format, opaq_src->val_prefix_data,
2072 &opaq_trg->val_prefix_data);
2073 }
2074 } else if ((match_trg->schema->nodetype == LYS_LEAF) &&
2075 lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002076 /* since they are different, they cannot both be default */
2077 assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
2078
Michal Vasko3a41dff2020-07-15 14:30:28 +02002079 /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
2080 if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
Michal Vasko4490d312020-06-16 13:08:55 +02002081 type = ((struct lysc_node_leaf *)match_trg->schema)->type;
Michal Vaskob7be7a82020-08-20 09:09:04 +02002082 type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
2083 LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
Michal Vasko69730152020-10-09 16:30:07 +02002084 &((struct lyd_node_term *)match_trg)->value));
Michal Vasko4490d312020-06-16 13:08:55 +02002085
2086 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002087 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vasko4490d312020-06-16 13:08:55 +02002088 }
Michal Vasko8f359bf2020-07-28 10:41:15 +02002089 } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
Michal Vasko4c583e82020-07-17 12:16:14 +02002090 /* update value */
2091 LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
Radek Krejci0f969882020-08-21 16:56:47 +02002092 ((struct lyd_node_any *)sibling_src)->value_type));
Michal Vasko4490d312020-06-16 13:08:55 +02002093
2094 /* copy flags and add LYD_NEW */
Michal Vasko7e8315b2021-08-03 17:01:06 +02002095 match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002096 }
2097
2098 /* check descendants, recursively */
2099 ret = LY_SUCCESS;
2100 LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
2101 ret = lyd_merge_sibling_r(lyd_node_child_p(match_trg), match_trg, &child_src, merge_cb, cb_data, options,
2102 &child_dup_inst);
2103 if (ret) {
2104 break;
Michal Vasko4490d312020-06-16 13:08:55 +02002105 }
2106 }
Michal Vaskocd3f6172021-05-18 16:14:50 +02002107 lyd_dup_inst_free(child_dup_inst);
2108 LY_CHECK_RET(ret);
Michal Vasko4490d312020-06-16 13:08:55 +02002109 } else {
2110 /* node not found, merge it */
2111 if (options & LYD_MERGE_DESTRUCT) {
2112 dup_src = (struct lyd_node *)sibling_src;
2113 lyd_unlink_tree(dup_src);
2114 /* spend it */
2115 *sibling_src_p = NULL;
2116 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +02002117 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 +02002118 }
2119
Michal Vasko7e8315b2021-08-03 17:01:06 +02002120 if (!(options & LYD_MERGE_WITH_FLAGS)) {
2121 /* set LYD_NEW for all the new nodes, required for validation */
2122 LYD_TREE_DFS_BEGIN(dup_src, elem) {
2123 elem->flags |= LYD_NEW;
2124 LYD_TREE_DFS_END(dup_src, elem);
2125 }
Michal Vasko4490d312020-06-16 13:08:55 +02002126 }
2127
Michal Vaskocd3f6172021-05-18 16:14:50 +02002128 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02002129 lyd_insert_node(parent_trg, first_trg, dup_src, 0);
Michal Vaskocd3f6172021-05-18 16:14:50 +02002130
2131 if (first_inst) {
2132 /* remember not to find this instance next time */
2133 LY_CHECK_RET(lyd_dup_inst_next(&dup_src, *first_trg, dup_inst));
2134 }
2135
2136 /* call callback, no source node */
2137 if (merge_cb) {
2138 LY_CHECK_RET(merge_cb(dup_src, NULL, cb_data));
2139 }
Michal Vasko4490d312020-06-16 13:08:55 +02002140 }
2141
2142 return LY_SUCCESS;
2143}
2144
Michal Vasko3a41dff2020-07-15 14:30:28 +02002145static LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002146lyd_merge(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2147 lyd_merge_cb merge_cb, void *cb_data, uint16_t options, ly_bool nosiblings)
Michal Vasko4490d312020-06-16 13:08:55 +02002148{
2149 const struct lyd_node *sibling_src, *tmp;
Michal Vasko271d2e32023-01-31 15:43:19 +01002150 struct hash_table *dup_inst = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +02002151 ly_bool first;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002152 LY_ERR ret = LY_SUCCESS;
Michal Vasko4490d312020-06-16 13:08:55 +02002153
2154 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002155 LY_CHECK_CTX_EQUAL_RET(*target ? LYD_CTX(*target) : NULL, source ? LYD_CTX(source) : NULL, mod ? mod->ctx : NULL,
2156 LY_EINVAL);
Michal Vasko4490d312020-06-16 13:08:55 +02002157
2158 if (!source) {
2159 /* nothing to merge */
2160 return LY_SUCCESS;
2161 }
2162
Michal Vasko831422b2020-11-24 11:20:51 +01002163 if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002164 LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
Michal Vasko4490d312020-06-16 13:08:55 +02002165 return LY_EINVAL;
2166 }
2167
2168 LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
Michal Vaskocd3f6172021-05-18 16:14:50 +02002169 if (mod && (lyd_owner_module(sibling_src) != mod)) {
2170 /* skip data nodes from different modules */
2171 continue;
2172 }
2173
Radek Krejci857189e2020-09-01 13:26:36 +02002174 first = (sibling_src == source) ? 1 : 0;
Michal Vaskocd3f6172021-05-18 16:14:50 +02002175 ret = lyd_merge_sibling_r(target, NULL, &sibling_src, merge_cb, cb_data, options, &dup_inst);
2176 if (ret) {
2177 break;
2178 }
Michal Vasko4490d312020-06-16 13:08:55 +02002179 if (first && !sibling_src) {
2180 /* source was spent (unlinked), move to the next node */
2181 source = tmp;
2182 }
2183
Michal Vasko3a41dff2020-07-15 14:30:28 +02002184 if (nosiblings) {
Michal Vasko4490d312020-06-16 13:08:55 +02002185 break;
2186 }
2187 }
2188
2189 if (options & LYD_MERGE_DESTRUCT) {
2190 /* free any leftover source data that were not merged */
2191 lyd_free_siblings((struct lyd_node *)source);
2192 }
2193
Michal Vaskocd3f6172021-05-18 16:14:50 +02002194 lyd_dup_inst_free(dup_inst);
2195 return ret;
Michal Vasko4490d312020-06-16 13:08:55 +02002196}
2197
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002198LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002199lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002200{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002201 return lyd_merge(target, source, NULL, NULL, NULL, options, 1);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002202}
2203
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002204LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02002205lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
Michal Vasko3a41dff2020-07-15 14:30:28 +02002206{
Michal Vaskocd3f6172021-05-18 16:14:50 +02002207 return lyd_merge(target, source, NULL, NULL, NULL, options, 0);
2208}
2209
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002210LIBYANG_API_DEF LY_ERR
Michal Vaskocd3f6172021-05-18 16:14:50 +02002211lyd_merge_module(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
2212 lyd_merge_cb merge_cb, void *cb_data, uint16_t options)
2213{
2214 return lyd_merge(target, source, mod, merge_cb, cb_data, options, 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +02002215}
2216
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002217static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002218lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002219{
Michal Vasko14654712020-02-06 08:35:21 +01002220 /* ending \0 */
2221 ++reqlen;
2222
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002223 if (reqlen > *buflen) {
2224 if (is_static) {
2225 return LY_EINCOMPLETE;
2226 }
2227
2228 *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
2229 if (!*buffer) {
2230 return LY_EMEM;
2231 }
2232
2233 *buflen = reqlen;
2234 }
2235
2236 return LY_SUCCESS;
2237}
2238
Michal Vaskod59035b2020-07-08 12:00:06 +02002239LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002240lyd_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 +02002241{
2242 const struct lyd_node *key;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002243 size_t len;
2244 const char *val;
2245 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002246
Michal Vasko824d0832021-11-04 15:36:51 +01002247 for (key = lyd_child(node); key && key->schema && (key->schema->flags & LYS_KEY); key = key->next) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002248 val = lyd_get_value(key);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002249 len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002250 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002251
2252 quot = '\'';
2253 if (strchr(val, '\'')) {
2254 quot = '"';
2255 }
2256 *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002257 }
2258
2259 return LY_SUCCESS;
2260}
2261
2262/**
2263 * @brief Append leaf-list value predicate to path.
2264 *
2265 * @param[in] node Node to print.
2266 * @param[in,out] buffer Buffer to print to.
2267 * @param[in,out] buflen Current buffer length.
2268 * @param[in,out] bufused Current number of characters used in @p buffer.
2269 * @param[in] is_static Whether buffer is static or can be reallocated.
2270 * @return LY_ERR
2271 */
2272static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002273lyd_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 +02002274{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002275 size_t len;
2276 const char *val;
2277 char quot;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002278
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02002279 val = lyd_get_value(node);
Radek Krejcif13b87b2020-12-01 22:02:17 +01002280 len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002281 LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002282
2283 quot = '\'';
2284 if (strchr(val, '\'')) {
2285 quot = '"';
2286 }
2287 *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
2288
Michal Vaskoba99a3e2020-08-18 15:50:05 +02002289 return LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002290}
2291
2292/**
2293 * @brief Append node position (relative to its other instances) predicate to path.
2294 *
2295 * @param[in] node Node to print.
2296 * @param[in,out] buffer Buffer to print to.
2297 * @param[in,out] buflen Current buffer length.
2298 * @param[in,out] bufused Current number of characters used in @p buffer.
2299 * @param[in] is_static Whether buffer is static or can be reallocated.
2300 * @return LY_ERR
2301 */
2302static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002303lyd_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 +02002304{
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002305 size_t len;
Michal Vasko50cc0562021-05-18 16:15:43 +02002306 uint32_t pos;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002307 char *val = NULL;
2308 LY_ERR rc;
2309
Michal Vasko50cc0562021-05-18 16:15:43 +02002310 pos = lyd_list_pos(node);
2311 if (asprintf(&val, "%" PRIu32, pos) == -1) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002312 return LY_EMEM;
2313 }
2314
2315 len = 1 + strlen(val) + 1;
2316 rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
2317 if (rc != LY_SUCCESS) {
2318 goto cleanup;
2319 }
2320
2321 *bufused += sprintf(*buffer + *bufused, "[%s]", val);
2322
2323cleanup:
2324 free(val);
2325 return rc;
2326}
2327
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002328LIBYANG_API_DEF char *
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002329lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
2330{
Radek Krejci857189e2020-09-01 13:26:36 +02002331 ly_bool is_static = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02002332 uint32_t i, depth;
Michal Vasko14654712020-02-06 08:35:21 +01002333 size_t bufused = 0, len;
Michal Vasko12eb6222022-03-18 13:35:49 +01002334 const struct lyd_node *iter, *parent;
2335 const struct lys_module *mod, *prev_mod;
Michal Vasko790b2bc2020-08-03 13:35:06 +02002336 LY_ERR rc = LY_SUCCESS;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002337
2338 LY_CHECK_ARG_RET(NULL, node, NULL);
2339 if (buffer) {
Michal Vasko16385f42021-05-18 16:16:09 +02002340 LY_CHECK_ARG_RET(LYD_CTX(node), buflen > 1, NULL);
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002341 is_static = 1;
Michal Vasko14654712020-02-06 08:35:21 +01002342 } else {
2343 buflen = 0;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002344 }
2345
2346 switch (pathtype) {
Radek Krejci635d2b82021-01-04 11:26:51 +01002347 case LYD_PATH_STD:
2348 case LYD_PATH_STD_NO_LAST_PRED:
Michal Vasko14654712020-02-06 08:35:21 +01002349 depth = 1;
Michal Vasko9e685082021-01-29 14:49:09 +01002350 for (iter = node; iter->parent; iter = lyd_parent(iter)) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002351 ++depth;
2352 }
2353
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002354 goto iter_print;
Michal Vasko14654712020-02-06 08:35:21 +01002355 while (depth) {
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002356 /* find the right node */
Michal Vasko9e685082021-01-29 14:49:09 +01002357 for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002358iter_print:
Michal Vasko12eb6222022-03-18 13:35:49 +01002359 /* get the module */
2360 mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
2361 parent = lyd_parent(iter);
2362 prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
2363 if (prev_mod == mod) {
2364 mod = NULL;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002365 }
2366
2367 /* realloc string */
Michal Vaskoad92b672020-11-12 13:11:31 +01002368 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2369 strlen(((struct lyd_node_opaq *)iter)->name.name));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002370 rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
2371 if (rc != LY_SUCCESS) {
2372 break;
2373 }
2374
2375 /* print next node */
Michal Vaskodbf3e652022-10-21 08:46:25 +02002376 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002377
Michal Vasko790b2bc2020-08-03 13:35:06 +02002378 /* do not always print the last (first) predicate */
Radek Krejci635d2b82021-01-04 11:26:51 +01002379 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
Michal Vasko790b2bc2020-08-03 13:35:06 +02002380 switch (iter->schema->nodetype) {
2381 case LYS_LIST:
2382 if (iter->schema->flags & LYS_KEYLESS) {
2383 /* print its position */
2384 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2385 } else {
2386 /* print all list keys in predicates */
2387 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
2388 }
2389 break;
2390 case LYS_LEAFLIST:
2391 if (iter->schema->flags & LYS_CONFIG_W) {
2392 /* print leaf-list value */
2393 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
2394 } else {
2395 /* print its position */
2396 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
2397 }
2398 break;
2399 default:
2400 /* nothing to print more */
2401 break;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002402 }
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002403 }
2404 if (rc != LY_SUCCESS) {
2405 break;
2406 }
2407
Michal Vasko14654712020-02-06 08:35:21 +01002408 --depth;
Michal Vasko5ec7cda2019-09-11 13:43:08 +02002409 }
2410 break;
2411 }
2412
2413 return buffer;
2414}
Michal Vaskoe444f752020-02-10 12:20:06 +01002415
Michal Vaskodbf3e652022-10-21 08:46:25 +02002416char *
2417lyd_path_set(const struct ly_set *dnodes, LYD_PATH_TYPE pathtype)
2418{
2419 uint32_t depth;
2420 size_t bufused = 0, buflen = 0, len;
2421 char *buffer = NULL;
2422 const struct lyd_node *iter, *parent;
2423 const struct lys_module *mod, *prev_mod;
2424 LY_ERR rc = LY_SUCCESS;
2425
2426 switch (pathtype) {
2427 case LYD_PATH_STD:
2428 case LYD_PATH_STD_NO_LAST_PRED:
2429 for (depth = 1; depth <= dnodes->count; ++depth) {
2430 /* current node */
2431 iter = dnodes->dnodes[depth - 1];
2432 mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
2433
2434 /* parent */
2435 parent = (depth > 1) ? dnodes->dnodes[depth - 2] : NULL;
Michal Vasko8c320b82022-11-21 15:51:57 +01002436 assert(!parent || !iter->schema || !parent->schema || (lysc_data_parent(iter->schema) == parent->schema) ||
2437 (!lysc_data_parent(iter->schema) && (LYD_CTX(iter) != LYD_CTX(parent))));
Michal Vaskodbf3e652022-10-21 08:46:25 +02002438
2439 /* get module to print, if any */
2440 prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
2441 if (prev_mod == mod) {
2442 mod = NULL;
2443 }
2444
2445 /* realloc string */
2446 len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
2447 strlen(((struct lyd_node_opaq *)iter)->name.name));
2448 if ((rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, 0))) {
2449 break;
2450 }
2451
2452 /* print next node */
2453 bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
2454
2455 /* do not always print the last (first) predicate */
2456 if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
2457 switch (iter->schema->nodetype) {
2458 case LYS_LIST:
2459 if (iter->schema->flags & LYS_KEYLESS) {
2460 /* print its position */
2461 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2462 } else {
2463 /* print all list keys in predicates */
2464 rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, 0);
2465 }
2466 break;
2467 case LYS_LEAFLIST:
2468 if (iter->schema->flags & LYS_CONFIG_W) {
2469 /* print leaf-list value */
2470 rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, 0);
2471 } else {
2472 /* print its position */
2473 rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
2474 }
2475 break;
2476 default:
2477 /* nothing to print more */
2478 break;
2479 }
2480 }
2481 if (rc) {
2482 break;
2483 }
2484 }
2485 break;
2486 }
2487
2488 return buffer;
2489}
2490
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002491LIBYANG_API_DEF struct lyd_meta *
Michal Vasko25a32822020-07-09 15:48:22 +02002492lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
2493{
2494 struct lyd_meta *ret = NULL;
2495 const struct ly_ctx *ctx;
2496 const char *prefix, *tmp;
2497 char *str;
2498 size_t pref_len, name_len;
2499
2500 LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002501 LY_CHECK_CTX_EQUAL_RET(first ? first->annotation->module->ctx : NULL, module ? module->ctx : NULL, NULL);
Michal Vasko25a32822020-07-09 15:48:22 +02002502
2503 if (!first) {
2504 return NULL;
2505 }
2506
2507 ctx = first->annotation->module->ctx;
2508
2509 /* parse the name */
2510 tmp = name;
2511 if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
2512 LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
2513 return NULL;
2514 }
2515
2516 /* find the module */
2517 if (prefix) {
2518 str = strndup(prefix, pref_len);
2519 module = ly_ctx_get_module_latest(ctx, str);
2520 free(str);
Radek Krejci422afb12021-03-04 16:38:16 +01002521 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 +02002522 }
2523
2524 /* find the metadata */
2525 LY_LIST_FOR(first, first) {
2526 if ((first->annotation->module == module) && !strcmp(first->name, name)) {
2527 ret = (struct lyd_meta *)first;
2528 break;
2529 }
2530 }
2531
2532 return ret;
2533}
2534
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002535LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01002536lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
2537{
Michal Vasko9beceb82022-04-05 12:14:15 +02002538 struct lyd_node **match_p, *iter, *dup = NULL;
Michal Vaskoe444f752020-02-10 12:20:06 +01002539 struct lyd_node_inner *parent;
Michal Vaskoe78faec2021-04-08 17:24:43 +02002540 ly_bool found;
Michal Vaskoe444f752020-02-10 12:20:06 +01002541
Michal Vaskof03ed032020-03-04 13:31:44 +01002542 LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02002543 if (!siblings) {
2544 /* no data */
2545 if (match) {
2546 *match = NULL;
2547 }
2548 return LY_ENOTFOUND;
2549 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002550
Michal Vasko9beceb82022-04-05 12:14:15 +02002551 if (LYD_CTX(siblings) != LYD_CTX(target)) {
2552 /* create a duplicate in this context */
2553 LY_CHECK_RET(lyd_dup_single_to_ctx(target, LYD_CTX(siblings), NULL, 0, &dup));
2554 target = dup;
2555 }
2556
2557 if ((siblings->schema && target->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
2558 /* schema mismatch */
2559 lyd_free_tree(dup);
Michal Vasko9b368d32020-02-14 13:53:31 +01002560 if (match) {
2561 *match = NULL;
2562 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002563 return LY_ENOTFOUND;
2564 }
2565
Michal Vaskoe78faec2021-04-08 17:24:43 +02002566 /* get first sibling */
2567 siblings = lyd_first_sibling(siblings);
Michal Vaskoe444f752020-02-10 12:20:06 +01002568
Michal Vasko9e685082021-01-29 14:49:09 +01002569 parent = siblings->parent;
Michal Vasko6da1e952020-12-09 18:14:38 +01002570 if (parent && parent->schema && parent->children_ht) {
Michal Vaskoe444f752020-02-10 12:20:06 +01002571 assert(target->hash);
2572
Michal Vaskoe78faec2021-04-08 17:24:43 +02002573 if (lysc_is_dup_inst_list(target->schema)) {
2574 /* we must search the instances from beginning to find the first matching one */
2575 found = 0;
2576 LYD_LIST_FOR_INST(siblings, target->schema, iter) {
2577 if (!lyd_compare_single(target, iter, 0)) {
2578 found = 1;
2579 break;
2580 }
2581 }
2582 if (found) {
2583 siblings = iter;
Michal Vaskoda859032020-07-14 12:20:14 +02002584 } else {
2585 siblings = NULL;
2586 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002587 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +02002588 /* find by hash */
2589 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
2590 siblings = *match_p;
2591 } else {
2592 /* not found */
2593 siblings = NULL;
2594 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002595 }
2596 } else {
2597 /* no children hash table */
Michal Vaskod989ba02020-08-24 10:59:24 +02002598 for ( ; siblings; siblings = siblings->next) {
Michal Vaskodf8ebf62022-11-10 10:33:28 +01002599 if (!lyd_compare_single(siblings, target, LYD_COMPARE_OPAQ)) {
Michal Vaskoe444f752020-02-10 12:20:06 +01002600 break;
2601 }
2602 }
2603 }
2604
Michal Vasko9beceb82022-04-05 12:14:15 +02002605 lyd_free_tree(dup);
Michal Vaskoe444f752020-02-10 12:20:06 +01002606 if (!siblings) {
Michal Vasko9b368d32020-02-14 13:53:31 +01002607 if (match) {
2608 *match = NULL;
2609 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002610 return LY_ENOTFOUND;
2611 }
2612
Michal Vasko9b368d32020-02-14 13:53:31 +01002613 if (match) {
2614 *match = (struct lyd_node *)siblings;
2615 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002616 return LY_SUCCESS;
2617}
2618
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002619LIBYANG_API_DEF LY_ERR
Michal Vaskoe444f752020-02-10 12:20:06 +01002620lyd_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 +02002621 size_t val_len, struct lyd_node **match)
Michal Vaskoe444f752020-02-10 12:20:06 +01002622{
2623 LY_ERR rc;
2624 struct lyd_node *target = NULL;
Michal Vasko9beceb82022-04-05 12:14:15 +02002625 const struct lyd_node *parent;
Michal Vaskoe444f752020-02-10 12:20:06 +01002626
Michal Vasko4c583e82020-07-17 12:16:14 +02002627 LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
Michal Vasko9beceb82022-04-05 12:14:15 +02002628 if (!siblings) {
2629 /* no data */
2630 if (match) {
2631 *match = NULL;
2632 }
2633 return LY_ENOTFOUND;
2634 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002635
Michal Vasko9beceb82022-04-05 12:14:15 +02002636 if ((LYD_CTX(siblings) != schema->module->ctx)) {
2637 /* parent of ext nodes is useless */
2638 parent = (siblings->flags & LYD_EXT) ? NULL : lyd_parent(siblings);
Michal Vaskoaf3df492022-12-02 14:03:52 +01002639 if (lyd_find_schema_ctx(schema, LYD_CTX(siblings), parent, 0, &schema)) {
2640 /* no schema node in siblings so certainly no data node either */
2641 if (match) {
2642 *match = NULL;
2643 }
2644 return LY_ENOTFOUND;
2645 }
Michal Vasko9beceb82022-04-05 12:14:15 +02002646 }
2647
2648 if (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema))) {
2649 /* schema mismatch */
Michal Vasko9b368d32020-02-14 13:53:31 +01002650 if (match) {
2651 *match = NULL;
2652 }
Michal Vaskoe444f752020-02-10 12:20:06 +01002653 return LY_ENOTFOUND;
2654 }
2655
Michal Vaskof03ed032020-03-04 13:31:44 +01002656 if (key_or_value && !val_len) {
2657 val_len = strlen(key_or_value);
2658 }
2659
Michal Vaskob104f112020-07-17 09:54:54 +02002660 if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
2661 /* create a data node and find the instance */
2662 if (schema->nodetype == LYS_LEAFLIST) {
2663 /* target used attributes: schema, hash, value */
Radek Krejci8df109d2021-04-23 12:19:08 +02002664 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 +02002665 LY_CHECK_RET(rc);
Michal Vaskob104f112020-07-17 09:54:54 +02002666 } else {
Michal Vasko90932a92020-02-12 14:33:03 +01002667 /* target used attributes: schema, hash, child (all keys) */
Michal Vasko004d3152020-06-11 19:59:22 +02002668 LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
Michal Vasko90932a92020-02-12 14:33:03 +01002669 }
2670
2671 /* find it */
2672 rc = lyd_find_sibling_first(siblings, target, match);
Michal Vaskob104f112020-07-17 09:54:54 +02002673 } else {
2674 /* find the first schema node instance */
2675 rc = lyd_find_sibling_schema(siblings, schema, match);
Michal Vaskoe444f752020-02-10 12:20:06 +01002676 }
2677
Michal Vaskoe444f752020-02-10 12:20:06 +01002678 lyd_free_tree(target);
2679 return rc;
2680}
Michal Vaskoccc02342020-05-21 10:09:21 +02002681
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002682LIBYANG_API_DEF LY_ERR
Michal Vaskoe78faec2021-04-08 17:24:43 +02002683lyd_find_sibling_dup_inst_set(const struct lyd_node *siblings, const struct lyd_node *target, struct ly_set **set)
2684{
2685 struct lyd_node **match_p, *first, *iter;
2686 struct lyd_node_inner *parent;
2687
Michal Vasko83ae7772022-06-08 10:01:55 +02002688 LY_CHECK_ARG_RET(NULL, target, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01002689 LY_CHECK_CTX_EQUAL_RET(siblings ? LYD_CTX(siblings) : NULL, LYD_CTX(target), LY_EINVAL);
Michal Vaskoe78faec2021-04-08 17:24:43 +02002690
2691 LY_CHECK_RET(ly_set_new(set));
2692
2693 if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
2694 /* no data or schema mismatch */
2695 return LY_ENOTFOUND;
2696 }
2697
2698 /* get first sibling */
2699 siblings = lyd_first_sibling(siblings);
2700
2701 parent = siblings->parent;
2702 if (parent && parent->schema && parent->children_ht) {
2703 assert(target->hash);
2704
2705 /* find the first instance */
2706 lyd_find_sibling_first(siblings, target, &first);
2707 if (first) {
2708 /* add it so that it is the first in the set */
2709 if (ly_set_add(*set, first, 1, NULL)) {
2710 goto error;
2711 }
2712
2713 /* find by hash */
2714 if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
2715 iter = *match_p;
2716 } else {
2717 /* not found */
2718 iter = NULL;
2719 }
2720 while (iter) {
2721 /* add all found nodes into the set */
2722 if ((iter != first) && !lyd_compare_single(iter, target, 0) && ly_set_add(*set, iter, 1, NULL)) {
2723 goto error;
2724 }
2725
2726 /* find next instance */
2727 if (lyht_find_next(parent->children_ht, &iter, iter->hash, (void **)&match_p)) {
2728 iter = NULL;
2729 } else {
2730 iter = *match_p;
2731 }
2732 }
2733 }
2734 } else {
2735 /* no children hash table */
2736 LY_LIST_FOR(siblings, siblings) {
Michal Vaskodf8ebf62022-11-10 10:33:28 +01002737 if (!lyd_compare_single(target, siblings, LYD_COMPARE_OPAQ)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +02002738 ly_set_add(*set, (void *)siblings, 1, NULL);
2739 }
2740 }
2741 }
2742
2743 if (!(*set)->count) {
2744 return LY_ENOTFOUND;
2745 }
2746 return LY_SUCCESS;
2747
2748error:
2749 ly_set_free(*set, NULL);
2750 *set = NULL;
2751 return LY_EMEM;
2752}
2753
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002754LIBYANG_API_DEF LY_ERR
Michal Vasko1d4af6c2021-02-22 13:31:26 +01002755lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
2756{
2757 LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
2758
2759 for ( ; first; first = first->next) {
2760 if (!first->schema && !strcmp(LYD_NAME(first), name)) {
2761 break;
2762 }
2763 }
2764
2765 if (match) {
2766 *match = (struct lyd_node *)first;
2767 }
2768 return first ? LY_SUCCESS : LY_ENOTFOUND;
2769}
2770
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002771LIBYANG_API_DEF LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01002772lyd_find_xpath4(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath, LY_VALUE_FORMAT format,
2773 void *prefix_data, const struct lyxp_var *vars, struct ly_set **set)
Michal Vaskoccc02342020-05-21 10:09:21 +02002774{
2775 LY_ERR ret = LY_SUCCESS;
Michal Vasko8bd9cc72021-07-16 14:06:10 +02002776 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +02002777 struct lyxp_expr *exp = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02002778 uint32_t i;
2779
Michal Vaskoddd76592022-01-17 13:34:48 +01002780 LY_CHECK_ARG_RET(NULL, tree, xpath, format, set, LY_EINVAL);
Michal Vaskoccc02342020-05-21 10:09:21 +02002781
Michal Vasko37c69432021-04-12 14:48:24 +02002782 *set = NULL;
Michal Vaskoccc02342020-05-21 10:09:21 +02002783
Michal Vaskoddd76592022-01-17 13:34:48 +01002784 /* parse expression */
Michal Vaskoe3716b32021-12-13 16:58:25 +01002785 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(tree), xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +02002786 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002787
2788 /* evaluate expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02002789 ret = lyxp_eval(LYD_CTX(tree), exp, NULL, format, prefix_data, ctx_node, ctx_node, tree, vars, &xp_set,
2790 LYXP_IGNORE_WHEN);
Michal Vaskoccc02342020-05-21 10:09:21 +02002791 LY_CHECK_GOTO(ret, cleanup);
2792
Michal Vaskoc0d91642022-11-03 13:56:29 +01002793 if (xp_set.type != LYXP_SET_NODE_SET) {
2794 LOGERR(LYD_CTX(tree), LY_EINVAL, "XPath \"%s\" result is not a node set.", xpath);
2795 ret = LY_EINVAL;
2796 goto cleanup;
2797 }
2798
Michal Vaskoccc02342020-05-21 10:09:21 +02002799 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +02002800 ret = ly_set_new(set);
2801 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002802
Michal Vaskoc0d91642022-11-03 13:56:29 +01002803 /* transform into ly_set, allocate memory for all the elements once (even though not all items must be
2804 * elements but most likely will be) */
2805 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
2806 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(tree)); ret = LY_EMEM, cleanup);
2807 (*set)->size = xp_set.used;
Michal Vaskoccc02342020-05-21 10:09:21 +02002808
Michal Vaskoc0d91642022-11-03 13:56:29 +01002809 for (i = 0; i < xp_set.used; ++i) {
2810 if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
2811 ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
2812 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoccc02342020-05-21 10:09:21 +02002813 }
2814 }
2815
2816cleanup:
Michal Vasko0691d522020-05-21 13:21:47 +02002817 lyxp_set_free_content(&xp_set);
Michal Vaskoe3716b32021-12-13 16:58:25 +01002818 lyxp_expr_free((struct ly_ctx *)LYD_CTX(tree), exp);
Radek Krejci8f45abc2020-11-26 12:15:13 +01002819 if (ret) {
2820 ly_set_free(*set, NULL);
2821 *set = NULL;
2822 }
Michal Vaskoccc02342020-05-21 10:09:21 +02002823 return ret;
2824}
Radek Krejcica989142020-11-05 11:32:22 +01002825
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002826LIBYANG_API_DEF LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01002827lyd_find_xpath3(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath,
2828 const struct lyxp_var *vars, struct ly_set **set)
2829{
2830 LY_CHECK_ARG_RET(NULL, tree, xpath, set, LY_EINVAL);
2831
2832 return lyd_find_xpath4(ctx_node, tree, xpath, LY_VALUE_JSON, NULL, vars, set);
2833}
2834
2835LIBYANG_API_DEF LY_ERR
Michal Vaskoe3716b32021-12-13 16:58:25 +01002836lyd_find_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, struct ly_set **set)
2837{
2838 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
2839
Michal Vaskoddd76592022-01-17 13:34:48 +01002840 return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, vars, set);
Michal Vaskoe3716b32021-12-13 16:58:25 +01002841}
2842
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002843LIBYANG_API_DEF LY_ERR
aPiecekfba75362021-10-07 12:39:48 +02002844lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
2845{
Michal Vaskoe3716b32021-12-13 16:58:25 +01002846 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
2847
Michal Vaskoddd76592022-01-17 13:34:48 +01002848 return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, NULL, set);
aPiecekfba75362021-10-07 12:39:48 +02002849}
2850
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002851LIBYANG_API_DEF LY_ERR
Michal Vasko10fabfc2022-08-09 08:55:43 +02002852lyd_eval_xpath3(const struct lyd_node *ctx_node, const struct lys_module *cur_mod, const char *xpath,
2853 LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, ly_bool *result)
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002854{
2855 LY_ERR ret = LY_SUCCESS;
Michal Vasko8bd9cc72021-07-16 14:06:10 +02002856 struct lyxp_set xp_set = {0};
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002857 struct lyxp_expr *exp = NULL;
2858
2859 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, result, LY_EINVAL);
2860
2861 /* compile expression */
2862 ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
2863 LY_CHECK_GOTO(ret, cleanup);
2864
2865 /* evaluate expression */
Michal Vasko10fabfc2022-08-09 08:55:43 +02002866 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 +02002867 LYXP_IGNORE_WHEN);
Michal Vaskoc9eb3ca2021-07-16 10:20:37 +02002868 LY_CHECK_GOTO(ret, cleanup);
2869
2870 /* transform into boolean */
2871 ret = lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
2872 LY_CHECK_GOTO(ret, cleanup);
2873
2874 /* set result */
2875 *result = xp_set.val.bln;
2876
2877cleanup:
2878 lyxp_set_free_content(&xp_set);
2879 lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
2880 return ret;
2881}
2882
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002883LIBYANG_API_DEF LY_ERR
Michal Vasko10fabfc2022-08-09 08:55:43 +02002884lyd_eval_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, ly_bool *result)
2885{
2886 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, vars, result);
2887}
2888
2889LIBYANG_API_DEF LY_ERR
aPiecekfba75362021-10-07 12:39:48 +02002890lyd_eval_xpath(const struct lyd_node *ctx_node, const char *xpath, ly_bool *result)
2891{
Michal Vasko10fabfc2022-08-09 08:55:43 +02002892 return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, NULL, result);
aPiecekfba75362021-10-07 12:39:48 +02002893}
2894
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002895LIBYANG_API_DEF LY_ERR
Michal Vasko3e1f6552021-01-14 09:27:55 +01002896lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
2897{
2898 LY_ERR ret = LY_SUCCESS;
2899 struct lyxp_expr *expr = NULL;
2900 struct ly_path *lypath = NULL;
2901
2902 LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
2903
2904 /* parse the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02002905 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 +01002906 LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
2907 LY_CHECK_GOTO(ret, cleanup);
2908
2909 /* compile the path */
Michal Vaskoed725d72021-06-23 12:03:45 +02002910 ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, NULL, expr,
Michal Vasko0884d212021-10-14 09:21:46 +02002911 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 +01002912 LY_CHECK_GOTO(ret, cleanup);
2913
2914 /* evaluate the path */
2915 ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
2916
2917cleanup:
2918 lyxp_expr_free(LYD_CTX(ctx_node), expr);
2919 ly_path_free(LYD_CTX(ctx_node), lypath);
2920 return ret;
2921}
2922
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002923LIBYANG_API_DEF LY_ERR
Michal Vaskobb22b182021-06-14 08:14:21 +02002924lyd_find_target(const struct ly_path *path, const struct lyd_node *tree, struct lyd_node **match)
2925{
2926 LY_ERR ret;
2927 struct lyd_node *m;
2928
2929 LY_CHECK_ARG_RET(NULL, path, LY_EINVAL);
2930
2931 ret = ly_path_eval(path, tree, &m);
2932 if (ret) {
2933 if (match) {
2934 *match = NULL;
2935 }
2936 return LY_ENOTFOUND;
2937 }
2938
2939 if (match) {
2940 *match = m;
2941 }
2942 return LY_SUCCESS;
2943}