summaryrefslogtreecommitdiffstats
path: root/src/tree_data.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/tree_data.c2943
1 files changed, 2943 insertions, 0 deletions
diff --git a/src/tree_data.c b/src/tree_data.c
new file mode 100644
index 0000000..d6a04ff
--- /dev/null
+++ b/src/tree_data.c
@@ -0,0 +1,2943 @@
+/**
+ * @file tree_data.c
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @author Michal Vasko <mvasko@cesnet.cz>
+ * @brief Data tree functions
+ *
+ * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
+ *
+ * This source code is licensed under BSD 3-Clause License (the "License").
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://opensource.org/licenses/BSD-3-Clause
+ */
+
+#define _GNU_SOURCE
+
+#include "tree_data.h"
+
+#include <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "compat.h"
+#include "context.h"
+#include "dict.h"
+#include "diff.h"
+#include "hash_table.h"
+#include "in.h"
+#include "in_internal.h"
+#include "log.h"
+#include "parser_data.h"
+#include "parser_internal.h"
+#include "path.h"
+#include "plugins.h"
+#include "plugins_exts/metadata.h"
+#include "plugins_internal.h"
+#include "plugins_types.h"
+#include "set.h"
+#include "tree.h"
+#include "tree_data_internal.h"
+#include "tree_edit.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+#include "validation.h"
+#include "xml.h"
+#include "xpath.h"
+
+static LYD_FORMAT
+lyd_parse_get_format(const struct ly_in *in, LYD_FORMAT format)
+{
+ if (!format && (in->type == LY_IN_FILEPATH)) {
+ /* unknown format - try to detect it from filename's suffix */
+ const char *path = in->method.fpath.filepath;
+ size_t len = strlen(path);
+
+ /* ignore trailing whitespaces */
+ for ( ; len > 0 && isspace(path[len - 1]); len--) {}
+
+ if ((len >= LY_XML_SUFFIX_LEN + 1) &&
+ !strncmp(&path[len - LY_XML_SUFFIX_LEN], LY_XML_SUFFIX, LY_XML_SUFFIX_LEN)) {
+ format = LYD_XML;
+ } else if ((len >= LY_JSON_SUFFIX_LEN + 1) &&
+ !strncmp(&path[len - LY_JSON_SUFFIX_LEN], LY_JSON_SUFFIX, LY_JSON_SUFFIX_LEN)) {
+ format = LYD_JSON;
+ } else if ((len >= LY_LYB_SUFFIX_LEN + 1) &&
+ !strncmp(&path[len - LY_LYB_SUFFIX_LEN], LY_LYB_SUFFIX, LY_LYB_SUFFIX_LEN)) {
+ format = LYD_LYB;
+ } /* else still unknown */
+ }
+
+ return format;
+}
+
+/**
+ * @brief Parse YANG data into a data tree.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] ext Optional extenion instance to parse data following the schema tree specified in the extension instance
+ * @param[in] parent Parent to connect the parsed nodes to, if any.
+ * @param[in,out] first_p Pointer to the first top-level parsed node, used only if @p parent is NULL.
+ * @param[in] in Input handle to read the input from.
+ * @param[in] format Expected format of the data in @p in.
+ * @param[in] parse_opts Options for parser.
+ * @param[in] val_opts Options for validation.
+ * @param[out] op Optional pointer to the parsed operation, if any.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_parse(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, struct lyd_node **first_p,
+ struct ly_in *in, LYD_FORMAT format, uint32_t parse_opts, uint32_t val_opts, struct lyd_node **op)
+{
+ LY_ERR rc = LY_SUCCESS;
+ struct lyd_ctx *lydctx = NULL;
+ struct ly_set parsed = {0};
+ struct lyd_node *first;
+ uint32_t i, int_opts = 0;
+ ly_bool subtree_sibling = 0;
+
+ assert(ctx && (parent || first_p));
+
+ format = lyd_parse_get_format(in, format);
+ if (first_p) {
+ *first_p = NULL;
+ }
+
+ /* remember input position */
+ in->func_start = in->current;
+
+ /* set internal options */
+ if (!(parse_opts & LYD_PARSE_SUBTREE)) {
+ int_opts = LYD_INTOPT_WITH_SIBLINGS;
+ }
+
+ /* parse the data */
+ switch (format) {
+ case LYD_XML:
+ rc = lyd_parse_xml(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
+ &subtree_sibling, &lydctx);
+ break;
+ case LYD_JSON:
+ rc = lyd_parse_json(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
+ &subtree_sibling, &lydctx);
+ break;
+ case LYD_LYB:
+ rc = lyd_parse_lyb(ctx, ext, parent, first_p, in, parse_opts, val_opts, int_opts, &parsed,
+ &subtree_sibling, &lydctx);
+ break;
+ case LYD_UNKNOWN:
+ LOGARG(ctx, format);
+ rc = LY_EINVAL;
+ break;
+ }
+ LY_CHECK_GOTO(rc, cleanup);
+
+ if (parent) {
+ /* get first top-level sibling */
+ for (first = parent; first->parent; first = lyd_parent(first)) {}
+ first = lyd_first_sibling(first);
+ first_p = &first;
+ }
+
+ if (!(parse_opts & LYD_PARSE_ONLY)) {
+ /* validate data */
+ rc = lyd_validate(first_p, NULL, ctx, val_opts, 0, &lydctx->node_when, &lydctx->node_types, &lydctx->meta_types,
+ &lydctx->ext_node, &lydctx->ext_val, NULL);
+ LY_CHECK_GOTO(rc, cleanup);
+ }
+
+ /* set the operation node */
+ if (op) {
+ *op = lydctx->op_node;
+ }
+
+cleanup:
+ if (lydctx) {
+ lydctx->free(lydctx);
+ }
+ if (rc) {
+ if (parent) {
+ /* free all the parsed subtrees */
+ for (i = 0; i < parsed.count; ++i) {
+ lyd_free_tree(parsed.dnodes[i]);
+ }
+ } else {
+ /* free everything */
+ lyd_free_all(*first_p);
+ *first_p = NULL;
+ }
+ } else if (subtree_sibling) {
+ rc = LY_ENOT;
+ }
+ ly_set_erase(&parsed, NULL);
+ return rc;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
+ uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
+{
+ const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
+
+ LY_CHECK_ARG_RET(ctx, ext, in, parent || tree, LY_EINVAL);
+ LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
+ LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
+
+ return lyd_parse(ctx, ext, parent, tree, in, format, parse_options, validate_options, NULL);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
+ uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree)
+{
+ LY_CHECK_ARG_RET(ctx, ctx, in, parent || tree, LY_EINVAL);
+ LY_CHECK_ARG_RET(ctx, !(parse_options & ~LYD_PARSE_OPTS_MASK), LY_EINVAL);
+ LY_CHECK_ARG_RET(ctx, !(validate_options & ~LYD_VALIDATE_OPTS_MASK), LY_EINVAL);
+
+ return lyd_parse(ctx, NULL, parent, tree, in, format, parse_options, validate_options, NULL);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
+ uint32_t validate_options, struct lyd_node **tree)
+{
+ LY_ERR ret;
+ struct ly_in *in;
+
+ LY_CHECK_RET(ly_in_new_memory(data, &in));
+ ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
+
+ ly_in_free(in, 0);
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_data_fd(const struct ly_ctx *ctx, int fd, LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options,
+ struct lyd_node **tree)
+{
+ LY_ERR ret;
+ struct ly_in *in;
+
+ LY_CHECK_RET(ly_in_new_fd(fd, &in));
+ ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
+
+ ly_in_free(in, 0);
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format, uint32_t parse_options,
+ uint32_t validate_options, struct lyd_node **tree)
+{
+ LY_ERR ret;
+ struct ly_in *in;
+
+ LY_CHECK_RET(ly_in_new_filepath(path, 0, &in));
+ ret = lyd_parse_data(ctx, NULL, in, format, parse_options, validate_options, tree);
+
+ ly_in_free(in, 0);
+ return ret;
+}
+
+/**
+ * @brief Parse YANG data into an operation data tree, in case the extension instance is specified, keep the searching
+ * for schema nodes locked inside the extension instance.
+ *
+ * At least one of @p parent, @p tree, or @p op must always be set.
+ *
+ * Specific @p data_type values have different parameter meaning as follows:
+ * - ::LYD_TYPE_RPC_NETCONF:
+ * - @p parent - must be NULL, the whole RPC is expected;
+ * - @p format - must be ::LYD_XML, NETCONF supports only this format;
+ * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
+ * a separate opaque data tree, even if the function fails, this may be returned;
+ * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
+ *
+ * - ::LYD_TYPE_NOTIF_NETCONF:
+ * - @p parent - must be NULL, the whole notification is expected;
+ * - @p format - must be ::LYD_XML, NETCONF supports only this format;
+ * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
+ * a separate opaque data tree, even if the function fails, this may be returned;
+ * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
+ *
+ * - ::LYD_TYPE_REPLY_NETCONF:
+ * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
+ * - @p format - must be ::LYD_XML, NETCONF supports only this format;
+ * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
+ * a separate opaque data tree, even if the function fails, this may be returned;
+ * - @p op - must be NULL, the reply is appended to the RPC;
+ * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
+ *
+ * @param[in] ctx libyang context.
+ * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
+ * @param[in] parent Optional parent to connect the parsed nodes to.
+ * @param[in] in Input handle to read the input from.
+ * @param[in] format Expected format of the data in @p in.
+ * @param[in] data_type Expected operation to parse (@ref datatype).
+ * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
+ * @param[out] op Optional parsed operation node.
+ * @return LY_ERR value.
+ * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
+ */
+static LY_ERR
+lyd_parse_op_(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
+ struct ly_in *in, LYD_FORMAT format, enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
+{
+ LY_ERR rc = LY_SUCCESS;
+ struct lyd_ctx *lydctx = NULL;
+ struct ly_set parsed = {0};
+ struct lyd_node *first = NULL, *envp = NULL;
+ uint32_t i, parse_opts, val_opts, int_opts = 0;
+
+ if (!ctx) {
+ ctx = LYD_CTX(parent);
+ }
+ if (tree) {
+ *tree = NULL;
+ }
+ if (op) {
+ *op = NULL;
+ }
+
+ format = lyd_parse_get_format(in, format);
+
+ /* remember input position */
+ in->func_start = in->current;
+
+ /* set parse and validation opts */
+ parse_opts = LYD_PARSE_ONLY | LYD_PARSE_STRICT;
+ val_opts = 0;
+
+ switch (data_type) {
+
+ /* special XML NETCONF data types */
+ case LYD_TYPE_RPC_NETCONF:
+ case LYD_TYPE_NOTIF_NETCONF:
+ LY_CHECK_ARG_RET(ctx, format == LYD_XML, !parent, tree, op, LY_EINVAL);
+ /* fallthrough */
+ case LYD_TYPE_REPLY_NETCONF:
+ if (data_type == LYD_TYPE_REPLY_NETCONF) {
+ LY_CHECK_ARG_RET(ctx, format == LYD_XML, parent, parent->schema->nodetype & (LYS_RPC | LYS_ACTION), tree, !op,
+ LY_EINVAL);
+ }
+
+ /* parse the NETCONF message */
+ rc = lyd_parse_xml_netconf(ctx, ext, parent, &first, in, parse_opts, val_opts, data_type, &envp, &parsed, &lydctx);
+ if (rc) {
+ if (envp) {
+ /* special situation when the envelopes were parsed successfully */
+ *tree = envp;
+ }
+ goto cleanup;
+ }
+
+ /* set out params correctly */
+ if (envp) {
+ /* special out param meaning */
+ *tree = envp;
+ } else {
+ *tree = parent ? NULL : first;
+ }
+ if (op) {
+ *op = lydctx->op_node;
+ }
+ goto cleanup;
+
+ /* set internal opts */
+ case LYD_TYPE_RPC_YANG:
+ int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NO_SIBLINGS;
+ break;
+ case LYD_TYPE_NOTIF_YANG:
+ int_opts = LYD_INTOPT_NOTIF | LYD_INTOPT_NO_SIBLINGS;
+ break;
+ case LYD_TYPE_REPLY_YANG:
+ int_opts = LYD_INTOPT_REPLY | LYD_INTOPT_NO_SIBLINGS;
+ break;
+ case LYD_TYPE_DATA_YANG:
+ LOGINT(ctx);
+ rc = LY_EINT;
+ goto cleanup;
+ }
+
+ /* parse the data */
+ switch (format) {
+ case LYD_XML:
+ rc = lyd_parse_xml(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
+ break;
+ case LYD_JSON:
+ rc = lyd_parse_json(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
+ break;
+ case LYD_LYB:
+ rc = lyd_parse_lyb(ctx, ext, parent, &first, in, parse_opts, val_opts, int_opts, &parsed, NULL, &lydctx);
+ break;
+ case LYD_UNKNOWN:
+ LOGARG(ctx, format);
+ rc = LY_EINVAL;
+ break;
+ }
+ LY_CHECK_GOTO(rc, cleanup);
+
+ /* set out params correctly */
+ if (tree) {
+ *tree = parent ? NULL : first;
+ }
+ if (op) {
+ *op = lydctx->op_node;
+ }
+
+cleanup:
+ if (lydctx) {
+ lydctx->free(lydctx);
+ }
+ if (rc) {
+ /* free all the parsed nodes */
+ if (parsed.count) {
+ i = parsed.count;
+ do {
+ --i;
+ lyd_free_tree(parsed.dnodes[i]);
+ } while (i);
+ }
+ if (tree && ((format != LYD_XML) || !envp)) {
+ *tree = NULL;
+ }
+ if (op) {
+ *op = NULL;
+ }
+ }
+ ly_set_erase(&parsed, NULL);
+ return rc;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
+ enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
+{
+ LY_CHECK_ARG_RET(ctx, ctx || parent, in, data_type, parent || tree || op, LY_EINVAL);
+
+ return lyd_parse_op_(ctx, NULL, parent, in, format, data_type, tree, op);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
+ enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op)
+{
+ const struct ly_ctx *ctx = ext ? ext->module->ctx : NULL;
+
+ LY_CHECK_ARG_RET(ctx, ext, in, data_type, parent || tree || op, LY_EINVAL);
+
+ return lyd_parse_op_(ctx, ext, parent, in, format, data_type, tree, op);
+}
+
+struct lyd_node *
+lyd_insert_get_next_anchor(const struct lyd_node *first_sibling, const struct lyd_node *new_node)
+{
+ const struct lysc_node *schema, *sparent;
+ struct lyd_node *match = NULL;
+ ly_bool found;
+ uint32_t getnext_opts;
+
+ assert(new_node);
+
+ if (!first_sibling || !new_node->schema || (LYD_CTX(first_sibling) != LYD_CTX(new_node))) {
+ /* insert at the end, no next anchor */
+ return NULL;
+ }
+
+ getnext_opts = 0;
+ if (new_node->schema->flags & LYS_IS_OUTPUT) {
+ getnext_opts = LYS_GETNEXT_OUTPUT;
+ }
+
+ if (first_sibling->parent && first_sibling->parent->schema && first_sibling->parent->children_ht) {
+ /* find the anchor using hashes */
+ sparent = first_sibling->parent->schema;
+ schema = lys_getnext(new_node->schema, sparent, NULL, getnext_opts);
+ while (schema) {
+ /* keep trying to find the first existing instance of the closest following schema sibling,
+ * otherwise return NULL - inserting at the end */
+ if (!lyd_find_sibling_schema(first_sibling, schema, &match)) {
+ break;
+ }
+
+ schema = lys_getnext(schema, sparent, NULL, getnext_opts);
+ }
+ } else {
+ /* find the anchor without hashes */
+ match = (struct lyd_node *)first_sibling;
+ sparent = lysc_data_parent(new_node->schema);
+ if (!sparent) {
+ /* we are in top-level, skip all the data from preceding modules */
+ LY_LIST_FOR(match, match) {
+ if (!match->schema || (strcmp(lyd_owner_module(match)->name, lyd_owner_module(new_node)->name) >= 0)) {
+ break;
+ }
+ }
+ }
+
+ /* get the first schema sibling */
+ schema = lys_getnext(NULL, sparent, new_node->schema->module->compiled, getnext_opts);
+
+ found = 0;
+ LY_LIST_FOR(match, match) {
+ if (!match->schema || (lyd_owner_module(match) != lyd_owner_module(new_node))) {
+ /* we have found an opaque node, which must be at the end, so use it OR
+ * modules do not match, so we must have traversed all the data from new_node module (if any),
+ * we have found the first node of the next module, that is what we want */
+ break;
+ }
+
+ /* skip schema nodes until we find the instantiated one */
+ while (!found) {
+ if (new_node->schema == schema) {
+ /* we have found the schema of the new node, continue search to find the first
+ * data node with a different schema (after our schema) */
+ found = 1;
+ break;
+ }
+ if (match->schema == schema) {
+ /* current node (match) is a data node still before the new node, continue search in data */
+ break;
+ }
+ schema = lys_getnext(schema, sparent, new_node->schema->module->compiled, getnext_opts);
+ assert(schema);
+ }
+
+ if (found && (match->schema != new_node->schema)) {
+ /* find the next node after we have found our node schema data instance */
+ break;
+ }
+ }
+ }
+
+ return match;
+}
+
+void
+lyd_insert_after_node(struct lyd_node *sibling, struct lyd_node *node)
+{
+ struct lyd_node_inner *par;
+
+ assert(!node->next && (node->prev == node));
+
+ node->next = sibling->next;
+ node->prev = sibling;
+ sibling->next = node;
+ if (node->next) {
+ /* sibling had a succeeding node */
+ node->next->prev = node;
+ } else {
+ /* sibling was last, find first sibling and change its prev */
+ if (sibling->parent) {
+ sibling = sibling->parent->child;
+ } else {
+ for ( ; sibling->prev->next != node; sibling = sibling->prev) {}
+ }
+ sibling->prev = node;
+ }
+ node->parent = sibling->parent;
+
+ for (par = node->parent; par; par = par->parent) {
+ if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
+ /* remove default flags from NP containers */
+ par->flags &= ~LYD_DEFAULT;
+ }
+ }
+}
+
+void
+lyd_insert_before_node(struct lyd_node *sibling, struct lyd_node *node)
+{
+ struct lyd_node_inner *par;
+
+ assert(!node->next && (node->prev == node));
+
+ node->next = sibling;
+ /* covers situation of sibling being first */
+ node->prev = sibling->prev;
+ sibling->prev = node;
+ if (node->prev->next) {
+ /* sibling had a preceding node */
+ node->prev->next = node;
+ } else if (sibling->parent) {
+ /* sibling was first and we must also change parent child pointer */
+ sibling->parent->child = node;
+ }
+ node->parent = sibling->parent;
+
+ for (par = node->parent; par; par = par->parent) {
+ if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
+ /* remove default flags from NP containers */
+ par->flags &= ~LYD_DEFAULT;
+ }
+ }
+}
+
+/**
+ * @brief Insert node as the first and only child of a parent.
+ *
+ * Handles inserting into NP containers and key-less lists.
+ *
+ * @param[in] parent Parent to insert into.
+ * @param[in] node Node to insert.
+ */
+static void
+lyd_insert_only_child(struct lyd_node *parent, struct lyd_node *node)
+{
+ struct lyd_node_inner *par;
+
+ assert(parent && !lyd_child(parent) && !node->next && (node->prev == node));
+ assert(!parent->schema || (parent->schema->nodetype & LYD_NODE_INNER));
+
+ par = (struct lyd_node_inner *)parent;
+
+ par->child = node;
+ node->parent = par;
+
+ for ( ; par; par = par->parent) {
+ if ((par->flags & LYD_DEFAULT) && !(node->flags & LYD_DEFAULT)) {
+ /* remove default flags from NP containers */
+ par->flags &= ~LYD_DEFAULT;
+ }
+ }
+}
+
+/**
+ * @brief Learn whether a list instance has all the keys.
+ *
+ * @param[in] list List instance to check.
+ * @return non-zero if all the keys were found,
+ * @return 0 otherwise.
+ */
+static int
+lyd_insert_has_keys(const struct lyd_node *list)
+{
+ const struct lyd_node *key;
+ const struct lysc_node *skey = NULL;
+
+ assert(list->schema->nodetype == LYS_LIST);
+ key = lyd_child(list);
+ while ((skey = lys_getnext(skey, list->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
+ if (!key || (key->schema != skey)) {
+ /* key missing */
+ return 0;
+ }
+
+ key = key->next;
+ }
+
+ /* all keys found */
+ return 1;
+}
+
+void
+lyd_insert_node(struct lyd_node *parent, struct lyd_node **first_sibling_p, struct lyd_node *node, ly_bool last)
+{
+ struct lyd_node *anchor, *first_sibling;
+
+ /* inserting list without its keys is not supported */
+ assert((parent || first_sibling_p) && node && (node->hash || !node->schema));
+ assert(!parent || !parent->schema ||
+ (parent->schema->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_RPC | LYS_ACTION | LYS_NOTIF)));
+
+ if (!parent && first_sibling_p && (*first_sibling_p) && (*first_sibling_p)->parent) {
+ parent = lyd_parent(*first_sibling_p);
+ }
+
+ /* get first sibling */
+ first_sibling = parent ? lyd_child(parent) : *first_sibling_p;
+
+ if (last || (first_sibling && (first_sibling->flags & LYD_EXT))) {
+ /* no next anchor */
+ anchor = NULL;
+ } else {
+ /* find the anchor, our next node, so we can insert before it */
+ anchor = lyd_insert_get_next_anchor(first_sibling, node);
+ }
+
+ if (anchor) {
+ /* insert before the anchor */
+ lyd_insert_before_node(anchor, node);
+ if (!parent && (*first_sibling_p == anchor)) {
+ /* move first sibling */
+ *first_sibling_p = node;
+ }
+ } else if (first_sibling) {
+ /* insert as the last node */
+ lyd_insert_after_node(first_sibling->prev, node);
+ } else if (parent) {
+ /* insert as the only child */
+ lyd_insert_only_child(parent, node);
+ } else {
+ /* insert as the only sibling */
+ *first_sibling_p = node;
+ }
+
+ /* insert into parent HT */
+ lyd_insert_hash(node);
+
+ /* finish hashes for our parent, if needed and possible */
+ if (node->schema && (node->schema->flags & LYS_KEY) && parent && lyd_insert_has_keys(parent)) {
+ lyd_hash(parent);
+
+ /* now we can insert even the list into its parent HT */
+ lyd_insert_hash(parent);
+ }
+}
+
+/**
+ * @brief Check schema place of a node to be inserted.
+ *
+ * @param[in] parent Schema node of the parent data node.
+ * @param[in] sibling Schema node of a sibling data node.
+ * @param[in] schema Schema node if the data node to be inserted.
+ * @return LY_SUCCESS on success.
+ * @return LY_EINVAL if the place is invalid.
+ */
+static LY_ERR
+lyd_insert_check_schema(const struct lysc_node *parent, const struct lysc_node *sibling, const struct lysc_node *schema)
+{
+ const struct lysc_node *par2;
+
+ assert(!parent || !(parent->nodetype & (LYS_CASE | LYS_CHOICE)));
+ assert(!sibling || !(sibling->nodetype & (LYS_CASE | LYS_CHOICE)));
+ assert(!schema || !(schema->nodetype & (LYS_CASE | LYS_CHOICE)));
+
+ if (!schema || (!parent && !sibling)) {
+ /* opaque nodes can be inserted wherever */
+ return LY_SUCCESS;
+ }
+
+ if (!parent) {
+ parent = lysc_data_parent(sibling);
+ }
+
+ /* find schema parent */
+ par2 = lysc_data_parent(schema);
+
+ if (parent) {
+ /* inner node */
+ if (par2 != parent) {
+ LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, parent of \"%s\" is not \"%s\".", schema->name,
+ parent->name);
+ return LY_EINVAL;
+ }
+ } else {
+ /* top-level node */
+ if (par2) {
+ LOGERR(schema->module->ctx, LY_EINVAL, "Cannot insert, node \"%s\" is not top-level.", schema->name);
+ return LY_EINVAL;
+ }
+ }
+
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_insert_child(struct lyd_node *parent, struct lyd_node *node)
+{
+ struct lyd_node *iter;
+
+ LY_CHECK_ARG_RET(NULL, parent, node, !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
+ LY_CHECK_CTX_EQUAL_RET(LYD_CTX(parent), LYD_CTX(node), LY_EINVAL);
+
+ LY_CHECK_RET(lyd_insert_check_schema(parent->schema, NULL, node->schema));
+
+ if (node->schema && (node->schema->flags & LYS_KEY)) {
+ LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
+ return LY_EINVAL;
+ }
+
+ if (node->parent || node->prev->next) {
+ lyd_unlink_tree(node);
+ }
+
+ while (node) {
+ iter = node->next;
+ lyd_unlink_tree(node);
+ lyd_insert_node(parent, NULL, node, 0);
+ node = iter;
+ }
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyplg_ext_insert(struct lyd_node *parent, struct lyd_node *first)
+{
+ struct lyd_node *iter;
+
+ LY_CHECK_ARG_RET(NULL, parent, first, !first->parent, !first->prev->next,
+ !parent->schema || (parent->schema->nodetype & LYD_NODE_INNER), LY_EINVAL);
+
+ if (first->schema && (first->schema->flags & LYS_KEY)) {
+ LOGERR(LYD_CTX(parent), LY_EINVAL, "Cannot insert key \"%s\".", first->schema->name);
+ return LY_EINVAL;
+ }
+
+ while (first) {
+ iter = first->next;
+ lyd_unlink_tree(first);
+ lyd_insert_node(parent, NULL, first, 1);
+ first = iter;
+ }
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_insert_sibling(struct lyd_node *sibling, struct lyd_node *node, struct lyd_node **first)
+{
+ struct lyd_node *iter;
+
+ LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
+
+ if (sibling) {
+ LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
+ }
+
+ if (sibling == node) {
+ /* we need to keep the connection to siblings so we can insert into them */
+ sibling = sibling->prev;
+ }
+
+ if (node->parent || node->prev->next) {
+ lyd_unlink_tree(node);
+ }
+
+ while (node) {
+ if (lysc_is_key(node->schema)) {
+ LOGERR(LYD_CTX(node), LY_EINVAL, "Cannot insert key \"%s\".", node->schema->name);
+ return LY_EINVAL;
+ }
+
+ iter = node->next;
+ lyd_unlink_tree(node);
+ lyd_insert_node(NULL, &sibling, node, 0);
+ node = iter;
+ }
+
+ if (first) {
+ /* find the first sibling */
+ *first = sibling;
+ while ((*first)->prev->next) {
+ *first = (*first)->prev;
+ }
+ }
+
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_insert_before(struct lyd_node *sibling, struct lyd_node *node)
+{
+ LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
+ LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
+
+ LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
+
+ if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
+ LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
+ return LY_EINVAL;
+ }
+ if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
+ LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert before a different schema node instance.");
+ return LY_EINVAL;
+ }
+
+ lyd_unlink_tree(node);
+ lyd_insert_before_node(sibling, node);
+ lyd_insert_hash(node);
+
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_insert_after(struct lyd_node *sibling, struct lyd_node *node)
+{
+ LY_CHECK_ARG_RET(NULL, sibling, node, sibling != node, LY_EINVAL);
+ LY_CHECK_CTX_EQUAL_RET(LYD_CTX(sibling), LYD_CTX(node), LY_EINVAL);
+
+ LY_CHECK_RET(lyd_insert_check_schema(NULL, sibling->schema, node->schema));
+
+ if (node->schema && (!(node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) || !(node->schema->flags & LYS_ORDBY_USER))) {
+ LOGERR(LYD_CTX(sibling), LY_EINVAL, "Can be used only for user-ordered nodes.");
+ return LY_EINVAL;
+ }
+ if (node->schema && sibling->schema && (node->schema != sibling->schema)) {
+ LOGERR(LYD_CTX(sibling), LY_EINVAL, "Cannot insert after a different schema node instance.");
+ return LY_EINVAL;
+ }
+
+ lyd_unlink_tree(node);
+ lyd_insert_after_node(sibling, node);
+ lyd_insert_hash(node);
+
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF void
+lyd_unlink_siblings(struct lyd_node *node)
+{
+ struct lyd_node *next, *elem, *first = NULL;
+
+ LY_LIST_FOR_SAFE(node, next, elem) {
+ lyd_unlink_tree(elem);
+ lyd_insert_node(NULL, &first, elem, 1);
+ }
+}
+
+LIBYANG_API_DEF void
+lyd_unlink_tree(struct lyd_node *node)
+{
+ struct lyd_node *iter;
+
+ if (!node) {
+ return;
+ }
+
+ /* update hashes while still linked into the tree */
+ lyd_unlink_hash(node);
+
+ /* unlink from siblings */
+ if (node->prev->next) {
+ node->prev->next = node->next;
+ }
+ if (node->next) {
+ node->next->prev = node->prev;
+ } else {
+ /* unlinking the last node */
+ if (node->parent) {
+ iter = node->parent->child;
+ } else {
+ iter = node->prev;
+ while (iter->prev != node) {
+ iter = iter->prev;
+ }
+ }
+ /* update the "last" pointer from the first node */
+ iter->prev = node->prev;
+ }
+
+ /* unlink from parent */
+ if (node->parent) {
+ if (node->parent->child == node) {
+ /* the node is the first child */
+ node->parent->child = node->next;
+ }
+
+ /* check for NP container whether its last non-default node is not being unlinked */
+ lyd_cont_set_dflt(lyd_parent(node));
+
+ node->parent = NULL;
+ }
+
+ node->next = NULL;
+ node->prev = node;
+}
+
+void
+lyd_insert_meta(struct lyd_node *parent, struct lyd_meta *meta, ly_bool clear_dflt)
+{
+ struct lyd_meta *last, *iter;
+
+ assert(parent);
+
+ if (!meta) {
+ return;
+ }
+
+ for (iter = meta; iter; iter = iter->next) {
+ iter->parent = parent;
+ }
+
+ /* insert as the last attribute */
+ if (parent->meta) {
+ for (last = parent->meta; last->next; last = last->next) {}
+ last->next = meta;
+ } else {
+ parent->meta = meta;
+ }
+
+ /* remove default flags from NP containers */
+ while (clear_dflt && parent && (parent->schema->nodetype == LYS_CONTAINER) && (parent->flags & LYD_DEFAULT)) {
+ parent->flags &= ~LYD_DEFAULT;
+ parent = lyd_parent(parent);
+ }
+}
+
+LY_ERR
+lyd_create_meta(struct lyd_node *parent, struct lyd_meta **meta, const struct lys_module *mod, const char *name,
+ size_t name_len, const char *value, size_t value_len, ly_bool *dynamic, LY_VALUE_FORMAT format,
+ void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node, ly_bool clear_dflt, ly_bool *incomplete)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lysc_ext_instance *ant = NULL;
+ const struct lysc_type *ant_type;
+ struct lyd_meta *mt, *last;
+ LY_ARRAY_COUNT_TYPE u;
+
+ assert((parent || meta) && mod);
+
+ LY_ARRAY_FOR(mod->compiled->exts, u) {
+ if (!strncmp(mod->compiled->exts[u].def->plugin->id, "ly2 metadata", 12) &&
+ !ly_strncmp(mod->compiled->exts[u].argument, name, name_len)) {
+ /* we have the annotation definition */
+ ant = &mod->compiled->exts[u];
+ break;
+ }
+ }
+ if (!ant) {
+ /* attribute is not defined as a metadata annotation (RFC 7952) */
+ LOGVAL(mod->ctx, LYVE_REFERENCE, "Annotation definition for attribute \"%s:%.*s\" not found.",
+ mod->name, (int)name_len, name);
+ ret = LY_EINVAL;
+ goto cleanup;
+ }
+
+ mt = calloc(1, sizeof *mt);
+ LY_CHECK_ERR_GOTO(!mt, LOGMEM(mod->ctx); ret = LY_EMEM, cleanup);
+ mt->parent = parent;
+ mt->annotation = ant;
+ lyplg_ext_get_storage(ant, LY_STMT_TYPE, sizeof ant_type, (const void **)&ant_type);
+ ret = lyd_value_store(mod->ctx, &mt->value, ant_type, value, value_len, dynamic, format, prefix_data, hints,
+ ctx_node, incomplete);
+ LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
+ ret = lydict_insert(mod->ctx, name, name_len, &mt->name);
+ LY_CHECK_ERR_GOTO(ret, free(mt), cleanup);
+
+ /* insert as the last attribute */
+ if (parent) {
+ lyd_insert_meta(parent, mt, clear_dflt);
+ } else if (*meta) {
+ for (last = *meta; last->next; last = last->next) {}
+ last->next = mt;
+ }
+
+ if (meta) {
+ *meta = mt;
+ }
+
+cleanup:
+ return ret;
+}
+
+void
+lyd_insert_attr(struct lyd_node *parent, struct lyd_attr *attr)
+{
+ struct lyd_attr *last, *iter;
+ struct lyd_node_opaq *opaq;
+
+ assert(parent && !parent->schema);
+
+ if (!attr) {
+ return;
+ }
+
+ opaq = (struct lyd_node_opaq *)parent;
+ for (iter = attr; iter; iter = iter->next) {
+ iter->parent = opaq;
+ }
+
+ /* insert as the last attribute */
+ if (opaq->attr) {
+ for (last = opaq->attr; last->next; last = last->next) {}
+ last->next = attr;
+ } else {
+ opaq->attr = attr;
+ }
+}
+
+LY_ERR
+lyd_create_attr(struct lyd_node *parent, struct lyd_attr **attr, const struct ly_ctx *ctx, const char *name, size_t name_len,
+ const char *prefix, size_t prefix_len, const char *module_key, size_t module_key_len, const char *value,
+ size_t value_len, ly_bool *dynamic, LY_VALUE_FORMAT format, void *val_prefix_data, uint32_t hints)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyd_attr *at, *last;
+
+ assert(ctx && (parent || attr) && (!parent || !parent->schema));
+ assert(name && name_len && format);
+
+ if (!value_len && (!dynamic || !*dynamic)) {
+ value = "";
+ }
+
+ at = calloc(1, sizeof *at);
+ LY_CHECK_ERR_RET(!at, LOGMEM(ctx); ly_free_prefix_data(format, val_prefix_data), LY_EMEM);
+
+ LY_CHECK_GOTO(ret = lydict_insert(ctx, name, name_len, &at->name.name), finish);
+ if (prefix_len) {
+ LY_CHECK_GOTO(ret = lydict_insert(ctx, prefix, prefix_len, &at->name.prefix), finish);
+ }
+ if (module_key_len) {
+ LY_CHECK_GOTO(ret = lydict_insert(ctx, module_key, module_key_len, &at->name.module_ns), finish);
+ }
+
+ if (dynamic && *dynamic) {
+ ret = lydict_insert_zc(ctx, (char *)value, &at->value);
+ LY_CHECK_GOTO(ret, finish);
+ *dynamic = 0;
+ } else {
+ LY_CHECK_GOTO(ret = lydict_insert(ctx, value, value_len, &at->value), finish);
+ }
+ at->format = format;
+ at->val_prefix_data = val_prefix_data;
+ at->hints = hints;
+
+ /* insert as the last attribute */
+ if (parent) {
+ lyd_insert_attr(parent, at);
+ } else if (*attr) {
+ for (last = *attr; last->next; last = last->next) {}
+ last->next = at;
+ }
+
+finish:
+ if (ret) {
+ lyd_free_attr_single(ctx, at);
+ } else if (attr) {
+ *attr = at;
+ }
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF const struct lyd_node_term *
+lyd_target(const struct ly_path *path, const struct lyd_node *tree)
+{
+ struct lyd_node *target;
+
+ if (ly_path_eval(path, tree, &target)) {
+ return NULL;
+ }
+
+ return (struct lyd_node_term *)target;
+}
+
+/**
+ * @brief Check the equality of the two schemas from different contexts.
+ *
+ * @param schema1 of first node.
+ * @param schema2 of second node.
+ * @return 1 if the schemas are equal otherwise 0.
+ */
+static ly_bool
+lyd_compare_schema_equal(const struct lysc_node *schema1, const struct lysc_node *schema2)
+{
+ if (!schema1 && !schema2) {
+ return 1;
+ } else if (!schema1 || !schema2) {
+ return 0;
+ }
+
+ assert(schema1->module->ctx != schema2->module->ctx);
+
+ if (schema1->nodetype != schema2->nodetype) {
+ return 0;
+ }
+
+ if (strcmp(schema1->name, schema2->name)) {
+ return 0;
+ }
+
+ if (strcmp(schema1->module->name, schema2->module->name)) {
+ return 0;
+ }
+
+ if (schema1->module->revision || schema2->module->revision) {
+ if (!schema1->module->revision || !schema2->module->revision) {
+ return 0;
+ }
+ if (strcmp(schema1->module->revision, schema2->module->revision)) {
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+/**
+ * @brief Check the equality of the schemas for all parent nodes.
+ *
+ * Both nodes must be from different contexts.
+ *
+ * @param node1 Data of first node.
+ * @param node2 Data of second node.
+ * @return 1 if the all related parental schemas are equal otherwise 0.
+ */
+static ly_bool
+lyd_compare_schema_parents_equal(const struct lyd_node *node1, const struct lyd_node *node2)
+{
+ const struct lysc_node *parent1, *parent2;
+
+ assert(node1 && node2);
+
+ for (parent1 = node1->schema->parent, parent2 = node2->schema->parent;
+ parent1 && parent2;
+ parent1 = parent1->parent, parent2 = parent2->parent) {
+ if (!lyd_compare_schema_equal(parent1, parent2)) {
+ return 0;
+ }
+ }
+
+ if (parent1 || parent2) {
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * @brief Compare 2 nodes values including opaque node values.
+ *
+ * @param[in] node1 First node to compare.
+ * @param[in] node2 Second node to compare.
+ * @return LY_SUCCESS if equal.
+ * @return LY_ENOT if not equal.
+ * @return LY_ERR on error.
+ */
+static LY_ERR
+lyd_compare_single_value(const struct lyd_node *node1, const struct lyd_node *node2)
+{
+ const struct lyd_node_opaq *opaq1 = NULL, *opaq2 = NULL;
+ const char *val1, *val2, *col;
+ const struct lys_module *mod;
+ char *val_dyn = NULL;
+ LY_ERR rc = LY_SUCCESS;
+
+ if (!node1->schema) {
+ opaq1 = (struct lyd_node_opaq *)node1;
+ }
+ if (!node2->schema) {
+ opaq2 = (struct lyd_node_opaq *)node2;
+ }
+
+ if (opaq1 && opaq2 && (opaq1->format == LY_VALUE_XML) && (opaq2->format == LY_VALUE_XML)) {
+ /* opaque XML and opaque XML node */
+ if (lyxml_value_compare(LYD_CTX(node1), opaq1->value, opaq1->val_prefix_data, LYD_CTX(node2), opaq2->value,
+ opaq2->val_prefix_data)) {
+ return LY_ENOT;
+ }
+ return LY_SUCCESS;
+ }
+
+ /* get their values */
+ if (opaq1 && ((opaq1->format == LY_VALUE_XML) || (opaq1->format == LY_VALUE_STR_NS)) && (col = strchr(opaq1->value, ':'))) {
+ /* XML value with a prefix, try to transform it into a JSON (canonical) value */
+ mod = ly_resolve_prefix(LYD_CTX(node1), opaq1->value, col - opaq1->value, opaq1->format, opaq1->val_prefix_data);
+ if (!mod) {
+ /* unable to compare */
+ return LY_ENOT;
+ }
+
+ if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
+ LOGMEM(LYD_CTX(node1));
+ return LY_EMEM;
+ }
+ val1 = val_dyn;
+ } else {
+ val1 = lyd_get_value(node1);
+ }
+ if (opaq2 && ((opaq2->format == LY_VALUE_XML) || (opaq2->format == LY_VALUE_STR_NS)) && (col = strchr(opaq2->value, ':'))) {
+ mod = ly_resolve_prefix(LYD_CTX(node2), opaq2->value, col - opaq2->value, opaq2->format, opaq2->val_prefix_data);
+ if (!mod) {
+ return LY_ENOT;
+ }
+
+ assert(!val_dyn);
+ if (asprintf(&val_dyn, "%s%s", mod->name, col) == -1) {
+ LOGMEM(LYD_CTX(node2));
+ return LY_EMEM;
+ }
+ val2 = val_dyn;
+ } else {
+ val2 = lyd_get_value(node2);
+ }
+
+ /* compare values */
+ if (strcmp(val1, val2)) {
+ rc = LY_ENOT;
+ }
+
+ free(val_dyn);
+ return rc;
+}
+
+/**
+ * @brief Internal implementation of @ref lyd_compare_single.
+ * @copydoc lyd_compare_single
+ * @param[in] parental_schemas_checked Flag used for optimization.
+ * When this function is called for the first time, the flag must be set to 0.
+ * The @ref lyd_compare_schema_parents_equal should be called only once during
+ * recursive calls, and this is accomplished by setting to 1 in the lyd_compare_single_ body.
+ */
+static LY_ERR
+lyd_compare_single_(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options,
+ ly_bool parental_schemas_checked)
+{
+ const struct lyd_node *iter1, *iter2;
+ struct lyd_node_any *any1, *any2;
+ int len1, len2;
+ LY_ERR r;
+
+ if (!node1 || !node2) {
+ if (node1 == node2) {
+ return LY_SUCCESS;
+ } else {
+ return LY_ENOT;
+ }
+ }
+
+ if (LYD_CTX(node1) == LYD_CTX(node2)) {
+ /* same contexts */
+ if (options & LYD_COMPARE_OPAQ) {
+ if (lyd_node_schema(node1) != lyd_node_schema(node2)) {
+ return LY_ENOT;
+ }
+ } else {
+ if (node1->schema != node2->schema) {
+ return LY_ENOT;
+ }
+ }
+ } else {
+ /* different contexts */
+ if (!lyd_compare_schema_equal(node1->schema, node2->schema)) {
+ return LY_ENOT;
+ }
+ if (!parental_schemas_checked) {
+ if (!lyd_compare_schema_parents_equal(node1, node2)) {
+ return LY_ENOT;
+ }
+ parental_schemas_checked = 1;
+ }
+ }
+
+ if (!(options & LYD_COMPARE_OPAQ) && (node1->hash != node2->hash)) {
+ return LY_ENOT;
+ }
+ /* equal hashes do not mean equal nodes, they can be just in collision so the nodes must be checked explicitly */
+
+ if (!node1->schema || !node2->schema) {
+ if (!(options & LYD_COMPARE_OPAQ) && ((node1->schema && !node2->schema) || (!node1->schema && node2->schema))) {
+ return LY_ENOT;
+ }
+ if ((r = lyd_compare_single_value(node1, node2))) {
+ return r;
+ }
+
+ if (options & LYD_COMPARE_FULL_RECURSION) {
+ iter1 = lyd_child(node1);
+ iter2 = lyd_child(node2);
+ goto all_children_compare;
+ }
+ return LY_SUCCESS;
+ } else {
+ switch (node1->schema->nodetype) {
+ case LYS_LEAF:
+ case LYS_LEAFLIST:
+ if (options & LYD_COMPARE_DEFAULTS) {
+ if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
+ return LY_ENOT;
+ }
+ }
+ if ((r = lyd_compare_single_value(node1, node2))) {
+ return r;
+ }
+
+ return LY_SUCCESS;
+ case LYS_CONTAINER:
+ case LYS_RPC:
+ case LYS_ACTION:
+ case LYS_NOTIF:
+ if (options & LYD_COMPARE_DEFAULTS) {
+ if ((node1->flags & LYD_DEFAULT) != (node2->flags & LYD_DEFAULT)) {
+ return LY_ENOT;
+ }
+ }
+ if (options & LYD_COMPARE_FULL_RECURSION) {
+ iter1 = lyd_child(node1);
+ iter2 = lyd_child(node2);
+ goto all_children_compare;
+ }
+ return LY_SUCCESS;
+ case LYS_LIST:
+ iter1 = lyd_child(node1);
+ iter2 = lyd_child(node2);
+
+ if (!(node1->schema->flags & LYS_KEYLESS) && !(options & LYD_COMPARE_FULL_RECURSION)) {
+ /* lists with keys, their equivalence is based on their keys */
+ for (const struct lysc_node *key = lysc_node_child(node1->schema);
+ key && (key->flags & LYS_KEY);
+ key = key->next) {
+ if (lyd_compare_single_(iter1, iter2, options, parental_schemas_checked)) {
+ return LY_ENOT;
+ }
+ iter1 = iter1->next;
+ iter2 = iter2->next;
+ }
+ } else {
+ /* lists without keys, their equivalence is based on equivalence of all the children (both direct and indirect) */
+
+all_children_compare:
+ if (!iter1 && !iter2) {
+ /* no children, nothing to compare */
+ return LY_SUCCESS;
+ }
+
+ for ( ; iter1 && iter2; iter1 = iter1->next, iter2 = iter2->next) {
+ if (lyd_compare_single_(iter1, iter2, options | LYD_COMPARE_FULL_RECURSION, parental_schemas_checked)) {
+ return LY_ENOT;
+ }
+ }
+ if (iter1 || iter2) {
+ return LY_ENOT;
+ }
+ }
+ return LY_SUCCESS;
+ case LYS_ANYXML:
+ case LYS_ANYDATA:
+ any1 = (struct lyd_node_any *)node1;
+ any2 = (struct lyd_node_any *)node2;
+
+ if (any1->value_type != any2->value_type) {
+ return LY_ENOT;
+ }
+ switch (any1->value_type) {
+ case LYD_ANYDATA_DATATREE:
+ iter1 = any1->value.tree;
+ iter2 = any2->value.tree;
+ goto all_children_compare;
+ case LYD_ANYDATA_STRING:
+ case LYD_ANYDATA_XML:
+ case LYD_ANYDATA_JSON:
+ if ((!any1->value.str && any2->value.str) || (any1->value.str && !any2->value.str)) {
+ return LY_ENOT;
+ } else if (!any1->value.str && !any2->value.str) {
+ return LY_SUCCESS;
+ }
+ len1 = strlen(any1->value.str);
+ len2 = strlen(any2->value.str);
+ if ((len1 != len2) || strcmp(any1->value.str, any2->value.str)) {
+ return LY_ENOT;
+ }
+ return LY_SUCCESS;
+ case LYD_ANYDATA_LYB:
+ len1 = lyd_lyb_data_length(any1->value.mem);
+ len2 = lyd_lyb_data_length(any2->value.mem);
+ if ((len1 == -1) || (len2 == -1) || (len1 != len2) || memcmp(any1->value.mem, any2->value.mem, len1)) {
+ return LY_ENOT;
+ }
+ return LY_SUCCESS;
+ }
+ }
+ }
+
+ LOGINT(LYD_CTX(node1));
+ return LY_EINT;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_compare_single(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
+{
+ return lyd_compare_single_(node1, node2, options, 0);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_compare_siblings(const struct lyd_node *node1, const struct lyd_node *node2, uint32_t options)
+{
+ for ( ; node1 && node2; node1 = node1->next, node2 = node2->next) {
+ LY_CHECK_RET(lyd_compare_single(node1, node2, options));
+ }
+
+ if (node1 == node2) {
+ return LY_SUCCESS;
+ }
+ return LY_ENOT;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_compare_meta(const struct lyd_meta *meta1, const struct lyd_meta *meta2)
+{
+ if (!meta1 || !meta2) {
+ if (meta1 == meta2) {
+ return LY_SUCCESS;
+ } else {
+ return LY_ENOT;
+ }
+ }
+
+ if ((meta1->annotation->module->ctx != meta2->annotation->module->ctx) || (meta1->annotation != meta2->annotation)) {
+ return LY_ENOT;
+ }
+
+ return meta1->value.realtype->plugin->compare(&meta1->value, &meta2->value);
+}
+
+/**
+ * @brief Create a copy of the attribute.
+ *
+ * @param[in] attr Attribute to copy.
+ * @param[in] node Opaque where to append the new attribute.
+ * @param[out] dup Optional created attribute copy.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_dup_attr_single(const struct lyd_attr *attr, struct lyd_node *node, struct lyd_attr **dup)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyd_attr *a, *last;
+ struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)node;
+
+ LY_CHECK_ARG_RET(NULL, attr, node, !node->schema, LY_EINVAL);
+
+ /* create a copy */
+ a = calloc(1, sizeof *attr);
+ LY_CHECK_ERR_RET(!a, LOGMEM(LYD_CTX(node)), LY_EMEM);
+
+ LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.name, 0, &a->name.name), finish);
+ LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.prefix, 0, &a->name.prefix), finish);
+ LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->name.module_ns, 0, &a->name.module_ns), finish);
+ LY_CHECK_GOTO(ret = lydict_insert(LYD_CTX(node), attr->value, 0, &a->value), finish);
+ a->hints = attr->hints;
+ a->format = attr->format;
+ if (attr->val_prefix_data) {
+ ret = ly_dup_prefix_data(LYD_CTX(node), attr->format, attr->val_prefix_data, &a->val_prefix_data);
+ LY_CHECK_GOTO(ret, finish);
+ }
+
+ /* insert as the last attribute */
+ a->parent = opaq;
+ if (opaq->attr) {
+ for (last = opaq->attr; last->next; last = last->next) {}
+ last->next = a;
+ } else {
+ opaq->attr = a;
+ }
+
+finish:
+ if (ret) {
+ lyd_free_attr_single(LYD_CTX(node), a);
+ } else if (dup) {
+ *dup = a;
+ }
+ return LY_SUCCESS;
+}
+
+/**
+ * @brief Find @p schema equivalent in @p trg_ctx.
+ *
+ * @param[in] schema Schema node to find.
+ * @param[in] trg_ctx Target context to search in.
+ * @param[in] parent Data parent of @p schema, if any.
+ * @param[in] log Whether to log directly.
+ * @param[out] trg_schema Found schema from @p trg_ctx to use.
+ * @return LY_RRR value.
+ */
+static LY_ERR
+lyd_find_schema_ctx(const struct lysc_node *schema, const struct ly_ctx *trg_ctx, const struct lyd_node *parent,
+ ly_bool log, const struct lysc_node **trg_schema)
+{
+ const struct lysc_node *src_parent = NULL, *trg_parent = NULL, *sp, *tp;
+ const struct lys_module *trg_mod = NULL;
+ char *path;
+
+ if (!schema) {
+ /* opaque node */
+ *trg_schema = NULL;
+ return LY_SUCCESS;
+ }
+
+ if (lysc_data_parent(schema) && parent && parent->schema) {
+ /* start from schema parent */
+ trg_parent = parent->schema;
+ src_parent = lysc_data_parent(schema);
+ }
+
+ do {
+ /* find the next parent */
+ sp = schema;
+ while (lysc_data_parent(sp) != src_parent) {
+ sp = lysc_data_parent(sp);
+ }
+ src_parent = sp;
+
+ if (!src_parent->parent) {
+ /* find the module first */
+ trg_mod = ly_ctx_get_module_implemented(trg_ctx, src_parent->module->name);
+ if (!trg_mod) {
+ if (log) {
+ LOGERR(trg_ctx, LY_ENOTFOUND, "Module \"%s\" not present/implemented in the target context.",
+ src_parent->module->name);
+ }
+ return LY_ENOTFOUND;
+ }
+ }
+
+ /* find the next parent */
+ assert(trg_parent || trg_mod);
+ tp = NULL;
+ while ((tp = lys_getnext(tp, trg_parent, trg_mod ? trg_mod->compiled : NULL, 0))) {
+ if (!strcmp(tp->name, src_parent->name) && !strcmp(tp->module->name, src_parent->module->name)) {
+ break;
+ }
+ }
+ if (!tp) {
+ /* schema node not found */
+ if (log) {
+ path = lysc_path(src_parent, LYSC_PATH_LOG, NULL, 0);
+ LOGERR(trg_ctx, LY_ENOTFOUND, "Schema node \"%s\" not found in the target context.", path);
+ free(path);
+ }
+ return LY_ENOTFOUND;
+ }
+
+ trg_parent = tp;
+ } while (schema != src_parent);
+
+ /* success */
+ *trg_schema = trg_parent;
+ return LY_SUCCESS;
+}
+
+/**
+ * @brief Duplicate a single node and connect it into @p parent (if present) or last of @p first siblings.
+ *
+ * Ignores ::LYD_DUP_WITH_PARENTS and ::LYD_DUP_WITH_SIBLINGS which are supposed to be handled by lyd_dup().
+ *
+ * @param[in] node Node to duplicate.
+ * @param[in] trg_ctx Target context for duplicated nodes.
+ * @param[in] parent Parent to insert into, NULL for top-level sibling.
+ * @param[in] insert_last Whether the duplicated node can be inserted as the last child of @p parent. Set for
+ * recursive duplication as an optimization.
+ * @param[in,out] first First sibling, NULL if no top-level sibling exist yet. Can be also NULL if @p parent is set.
+ * @param[in] options Bitmask of options flags, see @ref dupoptions.
+ * @param[out] dup_p Pointer where the created duplicated node is placed (besides connecting it to @p parent / @p first).
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_dup_r(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node *parent, ly_bool insert_last,
+ struct lyd_node **first, uint32_t options, struct lyd_node **dup_p)
+{
+ LY_ERR ret;
+ struct lyd_node *dup = NULL;
+ struct lyd_meta *meta;
+ struct lyd_attr *attr;
+ struct lyd_node_any *any;
+ const struct lysc_type *type;
+ const char *val_can;
+
+ LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
+
+ if (node->flags & LYD_EXT) {
+ if (options & LYD_DUP_NO_EXT) {
+ /* no not duplicate this subtree */
+ return LY_SUCCESS;
+ }
+
+ /* we need to use the same context */
+ trg_ctx = LYD_CTX(node);
+ }
+
+ if (!node->schema) {
+ dup = calloc(1, sizeof(struct lyd_node_opaq));
+ ((struct lyd_node_opaq *)dup)->ctx = trg_ctx;
+ } else {
+ switch (node->schema->nodetype) {
+ case LYS_RPC:
+ case LYS_ACTION:
+ case LYS_NOTIF:
+ case LYS_CONTAINER:
+ case LYS_LIST:
+ dup = calloc(1, sizeof(struct lyd_node_inner));
+ break;
+ case LYS_LEAF:
+ case LYS_LEAFLIST:
+ dup = calloc(1, sizeof(struct lyd_node_term));
+ break;
+ case LYS_ANYDATA:
+ case LYS_ANYXML:
+ dup = calloc(1, sizeof(struct lyd_node_any));
+ break;
+ default:
+ LOGINT(trg_ctx);
+ ret = LY_EINT;
+ goto error;
+ }
+ }
+ LY_CHECK_ERR_GOTO(!dup, LOGMEM(trg_ctx); ret = LY_EMEM, error);
+
+ if (options & LYD_DUP_WITH_FLAGS) {
+ dup->flags = node->flags;
+ } else {
+ dup->flags = (node->flags & (LYD_DEFAULT | LYD_EXT)) | LYD_NEW;
+ }
+ if (trg_ctx == LYD_CTX(node)) {
+ dup->schema = node->schema;
+ } else {
+ ret = lyd_find_schema_ctx(node->schema, trg_ctx, parent, 1, &dup->schema);
+ if (ret) {
+ /* has no schema but is not an opaque node */
+ free(dup);
+ dup = NULL;
+ goto error;
+ }
+ }
+ dup->prev = dup;
+
+ /* duplicate metadata/attributes */
+ if (!(options & LYD_DUP_NO_META)) {
+ if (!node->schema) {
+ LY_LIST_FOR(((struct lyd_node_opaq *)node)->attr, attr) {
+ LY_CHECK_GOTO(ret = lyd_dup_attr_single(attr, dup, NULL), error);
+ }
+ } else {
+ LY_LIST_FOR(node->meta, meta) {
+ LY_CHECK_GOTO(ret = lyd_dup_meta_single(meta, dup, NULL), error);
+ }
+ }
+ }
+
+ /* nodetype-specific work */
+ if (!dup->schema) {
+ struct lyd_node_opaq *opaq = (struct lyd_node_opaq *)dup;
+ struct lyd_node_opaq *orig = (struct lyd_node_opaq *)node;
+ struct lyd_node *child;
+
+ if (options & LYD_DUP_RECURSIVE) {
+ /* duplicate all the children */
+ LY_LIST_FOR(orig->child, child) {
+ LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
+ }
+ }
+ LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.name, 0, &opaq->name.name), error);
+ LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.prefix, 0, &opaq->name.prefix), error);
+ LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->name.module_ns, 0, &opaq->name.module_ns), error);
+ LY_CHECK_GOTO(ret = lydict_insert(trg_ctx, orig->value, 0, &opaq->value), error);
+ opaq->hints = orig->hints;
+ opaq->format = orig->format;
+ if (orig->val_prefix_data) {
+ ret = ly_dup_prefix_data(trg_ctx, opaq->format, orig->val_prefix_data, &opaq->val_prefix_data);
+ LY_CHECK_GOTO(ret, error);
+ }
+ } else if (dup->schema->nodetype & LYD_NODE_TERM) {
+ struct lyd_node_term *term = (struct lyd_node_term *)dup;
+ struct lyd_node_term *orig = (struct lyd_node_term *)node;
+
+ term->hash = orig->hash;
+ if (trg_ctx == LYD_CTX(node)) {
+ ret = orig->value.realtype->plugin->duplicate(trg_ctx, &orig->value, &term->value);
+ LY_CHECK_ERR_GOTO(ret, LOGERR(trg_ctx, ret, "Value duplication failed."), error);
+ } else {
+ /* store canonical value in the target context */
+ val_can = lyd_get_value(node);
+ type = ((struct lysc_node_leaf *)term->schema)->type;
+ ret = lyd_value_store(trg_ctx, &term->value, type, val_can, strlen(val_can), NULL, LY_VALUE_CANON, NULL,
+ LYD_HINT_DATA, term->schema, NULL);
+ LY_CHECK_GOTO(ret, error);
+ }
+ } else if (dup->schema->nodetype & LYD_NODE_INNER) {
+ struct lyd_node_inner *orig = (struct lyd_node_inner *)node;
+ struct lyd_node *child;
+
+ if (options & LYD_DUP_RECURSIVE) {
+ /* duplicate all the children */
+ LY_LIST_FOR(orig->child, child) {
+ LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
+ }
+ } else if ((dup->schema->nodetype == LYS_LIST) && !(dup->schema->flags & LYS_KEYLESS)) {
+ /* always duplicate keys of a list */
+ for (child = orig->child; child && lysc_is_key(child->schema); child = child->next) {
+ LY_CHECK_GOTO(ret = lyd_dup_r(child, trg_ctx, dup, 1, NULL, options, NULL), error);
+ }
+ }
+ lyd_hash(dup);
+ } else if (dup->schema->nodetype & LYD_NODE_ANY) {
+ dup->hash = node->hash;
+ any = (struct lyd_node_any *)node;
+ LY_CHECK_GOTO(ret = lyd_any_copy_value(dup, &any->value, any->value_type), error);
+ }
+
+ /* insert */
+ lyd_insert_node(parent, first, dup, insert_last);
+
+ if (dup_p) {
+ *dup_p = dup;
+ }
+ return LY_SUCCESS;
+
+error:
+ lyd_free_tree(dup);
+ return ret;
+}
+
+/**
+ * @brief Get a parent node to connect duplicated subtree to.
+ *
+ * @param[in] node Node (subtree) to duplicate.
+ * @param[in] trg_ctx Target context for duplicated nodes.
+ * @param[in] parent Initial parent to connect to.
+ * @param[in] options Bitmask of options flags, see @ref dupoptions.
+ * @param[out] dup_parent First duplicated parent node, if any.
+ * @param[out] local_parent Correct parent to directly connect duplicated @p node to.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_dup_get_local_parent(const struct lyd_node *node, const struct ly_ctx *trg_ctx, const struct lyd_node_inner *parent,
+ uint32_t options, struct lyd_node **dup_parent, struct lyd_node_inner **local_parent)
+{
+ const struct lyd_node_inner *orig_parent, *iter;
+ ly_bool repeat = 1, ext_parent = 0;
+
+ *dup_parent = NULL;
+ *local_parent = NULL;
+
+ if (node->flags & LYD_EXT) {
+ ext_parent = 1;
+ }
+ for (orig_parent = node->parent; repeat && orig_parent; orig_parent = orig_parent->parent) {
+ if (ext_parent) {
+ /* use the standard context */
+ trg_ctx = LYD_CTX(orig_parent);
+ }
+ if (parent && (parent->schema == orig_parent->schema)) {
+ /* stop creating parents, connect what we have into the provided parent */
+ iter = parent;
+ repeat = 0;
+ } else {
+ iter = NULL;
+ LY_CHECK_RET(lyd_dup_r((struct lyd_node *)orig_parent, trg_ctx, NULL, 0, (struct lyd_node **)&iter, options,
+ (struct lyd_node **)&iter));
+ }
+ if (!*local_parent) {
+ *local_parent = (struct lyd_node_inner *)iter;
+ }
+ if (iter->child) {
+ /* 1) list - add after keys
+ * 2) provided parent with some children */
+ iter->child->prev->next = *dup_parent;
+ if (*dup_parent) {
+ (*dup_parent)->prev = iter->child->prev;
+ iter->child->prev = *dup_parent;
+ }
+ } else {
+ ((struct lyd_node_inner *)iter)->child = *dup_parent;
+ }
+ if (*dup_parent) {
+ (*dup_parent)->parent = (struct lyd_node_inner *)iter;
+ }
+ *dup_parent = (struct lyd_node *)iter;
+ if (orig_parent->flags & LYD_EXT) {
+ ext_parent = 1;
+ }
+ }
+
+ if (repeat && parent) {
+ /* given parent and created parents chain actually do not interconnect */
+ LOGERR(trg_ctx, LY_EINVAL,
+ "Invalid argument parent (%s()) - does not interconnect with the created node's parents chain.", __func__);
+ return LY_EINVAL;
+ }
+
+ return LY_SUCCESS;
+}
+
+static LY_ERR
+lyd_dup(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent, uint32_t options,
+ ly_bool nosiblings, struct lyd_node **dup)
+{
+ LY_ERR rc;
+ const struct lyd_node *orig; /* original node to be duplicated */
+ struct lyd_node *first = NULL; /* the first duplicated node, this is returned */
+ struct lyd_node *top = NULL; /* the most higher created node */
+ struct lyd_node_inner *local_parent = NULL; /* the direct parent node for the duplicated node(s) */
+
+ assert(node && trg_ctx);
+
+ if (options & LYD_DUP_WITH_PARENTS) {
+ LY_CHECK_GOTO(rc = lyd_dup_get_local_parent(node, trg_ctx, parent, options & (LYD_DUP_WITH_FLAGS | LYD_DUP_NO_META),
+ &top, &local_parent), error);
+ } else {
+ local_parent = parent;
+ }
+
+ LY_LIST_FOR(node, orig) {
+ if (lysc_is_key(orig->schema)) {
+ if (local_parent) {
+ /* the key must already exist in the parent */
+ rc = lyd_find_sibling_schema(local_parent->child, orig->schema, first ? NULL : &first);
+ LY_CHECK_ERR_GOTO(rc, LOGINT(trg_ctx), error);
+ } else {
+ assert(!(options & LYD_DUP_WITH_PARENTS));
+ /* duplicating a single key, okay, I suppose... */
+ rc = lyd_dup_r(orig, trg_ctx, NULL, 0, &first, options, first ? NULL : &first);
+ LY_CHECK_GOTO(rc, error);
+ }
+ } else {
+ /* if there is no local parent, it will be inserted into first */
+ rc = lyd_dup_r(orig, trg_ctx, local_parent ? &local_parent->node : NULL, 0, &first, options,
+ first ? NULL : &first);
+ LY_CHECK_GOTO(rc, error);
+ }
+ if (nosiblings) {
+ break;
+ }
+ }
+
+ if (dup) {
+ *dup = first;
+ }
+ return LY_SUCCESS;
+
+error:
+ if (top) {
+ lyd_free_tree(top);
+ } else {
+ lyd_free_siblings(first);
+ }
+ return rc;
+}
+
+/**
+ * @brief Check the context of node and parent when duplicating nodes.
+ *
+ * @param[in] node Node to duplicate.
+ * @param[in] parent Parent of the duplicated node(s).
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_dup_ctx_check(const struct lyd_node *node, const struct lyd_node_inner *parent)
+{
+ const struct lyd_node *iter;
+
+ if (!node || !parent) {
+ return LY_SUCCESS;
+ }
+
+ if ((LYD_CTX(node) != LYD_CTX(parent))) {
+ /* try to find top-level ext data parent */
+ for (iter = node; iter && !(iter->flags & LYD_EXT); iter = lyd_parent(iter)) {}
+
+ if (!iter || !lyd_parent(iter) || (LYD_CTX(lyd_parent(iter)) != LYD_CTX(parent))) {
+ LOGERR(NULL, LY_EINVAL, "Different contexts used in node duplication.");
+ return LY_EINVAL;
+ }
+ }
+
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_dup_single(const struct lyd_node *node, struct lyd_node_inner *parent, uint32_t options, struct lyd_node **dup)
+{
+ LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
+ LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
+
+ return lyd_dup(node, LYD_CTX(node), parent, options, 1, dup);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_dup_single_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
+ uint32_t options, struct lyd_node **dup)
+{
+ LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
+
+ return lyd_dup(node, trg_ctx, parent, options, 1, dup);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_dup_siblings(const struct lyd_node *node, struct lyd_node_inner *parent, uint32_t options, struct lyd_node **dup)
+{
+ LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
+ LY_CHECK_RET(lyd_dup_ctx_check(node, parent));
+
+ return lyd_dup(node, LYD_CTX(node), parent, options, 0, dup);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_dup_siblings_to_ctx(const struct lyd_node *node, const struct ly_ctx *trg_ctx, struct lyd_node_inner *parent,
+ uint32_t options, struct lyd_node **dup)
+{
+ LY_CHECK_ARG_RET(trg_ctx, node, trg_ctx, LY_EINVAL);
+
+ return lyd_dup(node, trg_ctx, parent, options, 0, dup);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_dup_meta_single(const struct lyd_meta *meta, struct lyd_node *node, struct lyd_meta **dup)
+{
+ LY_ERR ret = LY_SUCCESS;
+ const struct ly_ctx *ctx;
+ struct lyd_meta *mt, *last;
+
+ LY_CHECK_ARG_RET(NULL, meta, node, LY_EINVAL);
+
+ /* log to node context but value must always use the annotation context */
+ ctx = meta->annotation->module->ctx;
+
+ /* create a copy */
+ mt = calloc(1, sizeof *mt);
+ LY_CHECK_ERR_RET(!mt, LOGMEM(LYD_CTX(node)), LY_EMEM);
+ mt->annotation = meta->annotation;
+ ret = meta->value.realtype->plugin->duplicate(ctx, &meta->value, &mt->value);
+ LY_CHECK_ERR_GOTO(ret, LOGERR(LYD_CTX(node), LY_EINT, "Value duplication failed."), finish);
+ LY_CHECK_GOTO(ret = lydict_insert(ctx, meta->name, 0, &mt->name), finish);
+
+ /* insert as the last attribute */
+ mt->parent = node;
+ if (node->meta) {
+ for (last = node->meta; last->next; last = last->next) {}
+ last->next = mt;
+ } else {
+ node->meta = mt;
+ }
+
+finish:
+ if (ret) {
+ lyd_free_meta_single(mt);
+ } else if (dup) {
+ *dup = mt;
+ }
+ return LY_SUCCESS;
+}
+
+/**
+ * @brief Merge a source sibling into target siblings.
+ *
+ * @param[in,out] first_trg First target sibling, is updated if top-level.
+ * @param[in] parent_trg Target parent.
+ * @param[in,out] sibling_src Source sibling to merge, set to NULL if spent.
+ * @param[in] merge_cb Optional merge callback.
+ * @param[in] cb_data Arbitrary callback data.
+ * @param[in] options Merge options.
+ * @param[in,out] dup_inst Duplicate instance cache for all @p first_trg siblings.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+lyd_merge_sibling_r(struct lyd_node **first_trg, struct lyd_node *parent_trg, const struct lyd_node **sibling_src_p,
+ lyd_merge_cb merge_cb, void *cb_data, uint16_t options, struct lyd_dup_inst **dup_inst)
+{
+ const struct lyd_node *child_src, *tmp, *sibling_src;
+ struct lyd_node *match_trg, *dup_src, *elem;
+ struct lyd_node_opaq *opaq_trg, *opaq_src;
+ struct lysc_type *type;
+ struct lyd_dup_inst *child_dup_inst = NULL;
+ LY_ERR ret;
+ ly_bool first_inst = 0;
+
+ sibling_src = *sibling_src_p;
+ if (!sibling_src->schema) {
+ /* try to find the same opaque node */
+ lyd_find_sibling_opaq_next(*first_trg, LYD_NAME(sibling_src), &match_trg);
+ } else if (sibling_src->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
+ /* try to find the exact instance */
+ lyd_find_sibling_first(*first_trg, sibling_src, &match_trg);
+ } else {
+ /* try to simply find the node, there cannot be more instances */
+ lyd_find_sibling_val(*first_trg, sibling_src->schema, NULL, 0, &match_trg);
+ }
+
+ if (match_trg) {
+ /* update match as needed */
+ LY_CHECK_RET(lyd_dup_inst_next(&match_trg, *first_trg, dup_inst));
+ } else {
+ /* first instance of this node */
+ first_inst = 1;
+ }
+
+ if (match_trg) {
+ /* call callback */
+ if (merge_cb) {
+ LY_CHECK_RET(merge_cb(match_trg, sibling_src, cb_data));
+ }
+
+ /* node found, make sure even value matches for all node types */
+ if (!match_trg->schema) {
+ if (lyd_compare_single(sibling_src, match_trg, 0)) {
+ /* update value */
+ opaq_trg = (struct lyd_node_opaq *)match_trg;
+ opaq_src = (struct lyd_node_opaq *)sibling_src;
+
+ lydict_remove(LYD_CTX(opaq_trg), opaq_trg->value);
+ lydict_insert(LYD_CTX(opaq_trg), opaq_src->value, 0, &opaq_trg->value);
+ opaq_trg->hints = opaq_src->hints;
+
+ ly_free_prefix_data(opaq_trg->format, opaq_trg->val_prefix_data);
+ opaq_trg->format = opaq_src->format;
+ ly_dup_prefix_data(LYD_CTX(opaq_trg), opaq_src->format, opaq_src->val_prefix_data,
+ &opaq_trg->val_prefix_data);
+ }
+ } else if ((match_trg->schema->nodetype == LYS_LEAF) &&
+ lyd_compare_single(sibling_src, match_trg, LYD_COMPARE_DEFAULTS)) {
+ /* since they are different, they cannot both be default */
+ assert(!(sibling_src->flags & LYD_DEFAULT) || !(match_trg->flags & LYD_DEFAULT));
+
+ /* update value (or only LYD_DEFAULT flag) only if flag set or the source node is not default */
+ if ((options & LYD_MERGE_DEFAULTS) || !(sibling_src->flags & LYD_DEFAULT)) {
+ type = ((struct lysc_node_leaf *)match_trg->schema)->type;
+ type->plugin->free(LYD_CTX(match_trg), &((struct lyd_node_term *)match_trg)->value);
+ LY_CHECK_RET(type->plugin->duplicate(LYD_CTX(match_trg), &((struct lyd_node_term *)sibling_src)->value,
+ &((struct lyd_node_term *)match_trg)->value));
+
+ /* copy flags and add LYD_NEW */
+ match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
+ }
+ } else if ((match_trg->schema->nodetype & LYS_ANYDATA) && lyd_compare_single(sibling_src, match_trg, 0)) {
+ /* update value */
+ LY_CHECK_RET(lyd_any_copy_value(match_trg, &((struct lyd_node_any *)sibling_src)->value,
+ ((struct lyd_node_any *)sibling_src)->value_type));
+
+ /* copy flags and add LYD_NEW */
+ match_trg->flags = sibling_src->flags | ((options & LYD_MERGE_WITH_FLAGS) ? 0 : LYD_NEW);
+ }
+
+ /* check descendants, recursively */
+ ret = LY_SUCCESS;
+ LY_LIST_FOR_SAFE(lyd_child_no_keys(sibling_src), tmp, child_src) {
+ ret = lyd_merge_sibling_r(lyd_node_child_p(match_trg), match_trg, &child_src, merge_cb, cb_data, options,
+ &child_dup_inst);
+ if (ret) {
+ break;
+ }
+ }
+ lyd_dup_inst_free(child_dup_inst);
+ LY_CHECK_RET(ret);
+ } else {
+ /* node not found, merge it */
+ if (options & LYD_MERGE_DESTRUCT) {
+ dup_src = (struct lyd_node *)sibling_src;
+ lyd_unlink_tree(dup_src);
+ /* spend it */
+ *sibling_src_p = NULL;
+ } else {
+ LY_CHECK_RET(lyd_dup_single(sibling_src, NULL, LYD_DUP_RECURSIVE | LYD_DUP_WITH_FLAGS, &dup_src));
+ }
+
+ if (!(options & LYD_MERGE_WITH_FLAGS)) {
+ /* set LYD_NEW for all the new nodes, required for validation */
+ LYD_TREE_DFS_BEGIN(dup_src, elem) {
+ elem->flags |= LYD_NEW;
+ LYD_TREE_DFS_END(dup_src, elem);
+ }
+ }
+
+ /* insert */
+ lyd_insert_node(parent_trg, first_trg, dup_src, 0);
+
+ if (first_inst) {
+ /* remember not to find this instance next time */
+ LY_CHECK_RET(lyd_dup_inst_next(&dup_src, *first_trg, dup_inst));
+ }
+
+ /* call callback, no source node */
+ if (merge_cb) {
+ LY_CHECK_RET(merge_cb(dup_src, NULL, cb_data));
+ }
+ }
+
+ return LY_SUCCESS;
+}
+
+static LY_ERR
+lyd_merge(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
+ lyd_merge_cb merge_cb, void *cb_data, uint16_t options, ly_bool nosiblings)
+{
+ const struct lyd_node *sibling_src, *tmp;
+ struct lyd_dup_inst *dup_inst = NULL;
+ ly_bool first;
+ LY_ERR ret = LY_SUCCESS;
+
+ LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
+ LY_CHECK_CTX_EQUAL_RET(*target ? LYD_CTX(*target) : NULL, source ? LYD_CTX(source) : NULL, mod ? mod->ctx : NULL,
+ LY_EINVAL);
+
+ if (!source) {
+ /* nothing to merge */
+ return LY_SUCCESS;
+ }
+
+ if ((*target && lysc_data_parent((*target)->schema)) || lysc_data_parent(source->schema)) {
+ LOGERR(LYD_CTX(source), LY_EINVAL, "Invalid arguments - can merge only 2 top-level subtrees (%s()).", __func__);
+ return LY_EINVAL;
+ }
+
+ LY_LIST_FOR_SAFE(source, tmp, sibling_src) {
+ if (mod && (lyd_owner_module(sibling_src) != mod)) {
+ /* skip data nodes from different modules */
+ continue;
+ }
+
+ first = (sibling_src == source) ? 1 : 0;
+ ret = lyd_merge_sibling_r(target, NULL, &sibling_src, merge_cb, cb_data, options, &dup_inst);
+ if (ret) {
+ break;
+ }
+ if (first && !sibling_src) {
+ /* source was spent (unlinked), move to the next node */
+ source = tmp;
+ }
+
+ if (nosiblings) {
+ break;
+ }
+ }
+
+ if (options & LYD_MERGE_DESTRUCT) {
+ /* free any leftover source data that were not merged */
+ lyd_free_siblings((struct lyd_node *)source);
+ }
+
+ lyd_dup_inst_free(dup_inst);
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_merge_tree(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
+{
+ return lyd_merge(target, source, NULL, NULL, NULL, options, 1);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_merge_siblings(struct lyd_node **target, const struct lyd_node *source, uint16_t options)
+{
+ return lyd_merge(target, source, NULL, NULL, NULL, options, 0);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_merge_module(struct lyd_node **target, const struct lyd_node *source, const struct lys_module *mod,
+ lyd_merge_cb merge_cb, void *cb_data, uint16_t options)
+{
+ return lyd_merge(target, source, mod, merge_cb, cb_data, options, 0);
+}
+
+static LY_ERR
+lyd_path_str_enlarge(char **buffer, size_t *buflen, size_t reqlen, ly_bool is_static)
+{
+ /* ending \0 */
+ ++reqlen;
+
+ if (reqlen > *buflen) {
+ if (is_static) {
+ return LY_EINCOMPLETE;
+ }
+
+ *buffer = ly_realloc(*buffer, reqlen * sizeof **buffer);
+ if (!*buffer) {
+ return LY_EMEM;
+ }
+
+ *buflen = reqlen;
+ }
+
+ return LY_SUCCESS;
+}
+
+LY_ERR
+lyd_path_list_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
+{
+ const struct lyd_node *key;
+ size_t len;
+ const char *val;
+ char quot;
+
+ for (key = lyd_child(node); key && key->schema && (key->schema->flags & LYS_KEY); key = key->next) {
+ val = lyd_get_value(key);
+ len = 1 + strlen(key->schema->name) + 2 + strlen(val) + 2;
+ LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
+
+ quot = '\'';
+ if (strchr(val, '\'')) {
+ quot = '"';
+ }
+ *bufused += sprintf(*buffer + *bufused, "[%s=%c%s%c]", key->schema->name, quot, val, quot);
+ }
+
+ return LY_SUCCESS;
+}
+
+/**
+ * @brief Append leaf-list value predicate to path.
+ *
+ * @param[in] node Node to print.
+ * @param[in,out] buffer Buffer to print to.
+ * @param[in,out] buflen Current buffer length.
+ * @param[in,out] bufused Current number of characters used in @p buffer.
+ * @param[in] is_static Whether buffer is static or can be reallocated.
+ * @return LY_ERR
+ */
+static LY_ERR
+lyd_path_leaflist_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
+{
+ size_t len;
+ const char *val;
+ char quot;
+
+ val = lyd_get_value(node);
+ len = 4 + strlen(val) + 2; /* "[.='" + val + "']" */
+ LY_CHECK_RET(lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static));
+
+ quot = '\'';
+ if (strchr(val, '\'')) {
+ quot = '"';
+ }
+ *bufused += sprintf(*buffer + *bufused, "[.=%c%s%c]", quot, val, quot);
+
+ return LY_SUCCESS;
+}
+
+/**
+ * @brief Append node position (relative to its other instances) predicate to path.
+ *
+ * @param[in] node Node to print.
+ * @param[in,out] buffer Buffer to print to.
+ * @param[in,out] buflen Current buffer length.
+ * @param[in,out] bufused Current number of characters used in @p buffer.
+ * @param[in] is_static Whether buffer is static or can be reallocated.
+ * @return LY_ERR
+ */
+static LY_ERR
+lyd_path_position_predicate(const struct lyd_node *node, char **buffer, size_t *buflen, size_t *bufused, ly_bool is_static)
+{
+ size_t len;
+ uint32_t pos;
+ char *val = NULL;
+ LY_ERR rc;
+
+ pos = lyd_list_pos(node);
+ if (asprintf(&val, "%" PRIu32, pos) == -1) {
+ return LY_EMEM;
+ }
+
+ len = 1 + strlen(val) + 1;
+ rc = lyd_path_str_enlarge(buffer, buflen, *bufused + len, is_static);
+ if (rc != LY_SUCCESS) {
+ goto cleanup;
+ }
+
+ *bufused += sprintf(*buffer + *bufused, "[%s]", val);
+
+cleanup:
+ free(val);
+ return rc;
+}
+
+LIBYANG_API_DEF char *
+lyd_path(const struct lyd_node *node, LYD_PATH_TYPE pathtype, char *buffer, size_t buflen)
+{
+ ly_bool is_static = 0;
+ uint32_t i, depth;
+ size_t bufused = 0, len;
+ const struct lyd_node *iter, *parent;
+ const struct lys_module *mod, *prev_mod;
+ LY_ERR rc = LY_SUCCESS;
+
+ LY_CHECK_ARG_RET(NULL, node, NULL);
+ if (buffer) {
+ LY_CHECK_ARG_RET(LYD_CTX(node), buflen > 1, NULL);
+ is_static = 1;
+ } else {
+ buflen = 0;
+ }
+
+ switch (pathtype) {
+ case LYD_PATH_STD:
+ case LYD_PATH_STD_NO_LAST_PRED:
+ depth = 1;
+ for (iter = node; iter->parent; iter = lyd_parent(iter)) {
+ ++depth;
+ }
+
+ goto iter_print;
+ while (depth) {
+ /* find the right node */
+ for (iter = node, i = 1; i < depth; iter = lyd_parent(iter), ++i) {}
+iter_print:
+ /* get the module */
+ mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
+ parent = lyd_parent(iter);
+ prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
+ if (prev_mod == mod) {
+ mod = NULL;
+ }
+
+ /* realloc string */
+ len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
+ strlen(((struct lyd_node_opaq *)iter)->name.name));
+ rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, is_static);
+ if (rc != LY_SUCCESS) {
+ break;
+ }
+
+ /* print next node */
+ bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
+
+ /* do not always print the last (first) predicate */
+ if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
+ switch (iter->schema->nodetype) {
+ case LYS_LIST:
+ if (iter->schema->flags & LYS_KEYLESS) {
+ /* print its position */
+ rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
+ } else {
+ /* print all list keys in predicates */
+ rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, is_static);
+ }
+ break;
+ case LYS_LEAFLIST:
+ if (iter->schema->flags & LYS_CONFIG_W) {
+ /* print leaf-list value */
+ rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, is_static);
+ } else {
+ /* print its position */
+ rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, is_static);
+ }
+ break;
+ default:
+ /* nothing to print more */
+ break;
+ }
+ }
+ if (rc != LY_SUCCESS) {
+ break;
+ }
+
+ --depth;
+ }
+ break;
+ }
+
+ return buffer;
+}
+
+char *
+lyd_path_set(const struct ly_set *dnodes, LYD_PATH_TYPE pathtype)
+{
+ uint32_t depth;
+ size_t bufused = 0, buflen = 0, len;
+ char *buffer = NULL;
+ const struct lyd_node *iter, *parent;
+ const struct lys_module *mod, *prev_mod;
+ LY_ERR rc = LY_SUCCESS;
+
+ switch (pathtype) {
+ case LYD_PATH_STD:
+ case LYD_PATH_STD_NO_LAST_PRED:
+ for (depth = 1; depth <= dnodes->count; ++depth) {
+ /* current node */
+ iter = dnodes->dnodes[depth - 1];
+ mod = iter->schema ? iter->schema->module : lyd_owner_module(iter);
+
+ /* parent */
+ parent = (depth > 1) ? dnodes->dnodes[depth - 2] : NULL;
+ assert(!parent || !iter->schema || !parent->schema || (lysc_data_parent(iter->schema) == parent->schema) ||
+ (!lysc_data_parent(iter->schema) && (LYD_CTX(iter) != LYD_CTX(parent))));
+
+ /* get module to print, if any */
+ prev_mod = (parent && parent->schema) ? parent->schema->module : lyd_owner_module(parent);
+ if (prev_mod == mod) {
+ mod = NULL;
+ }
+
+ /* realloc string */
+ len = 1 + (mod ? strlen(mod->name) + 1 : 0) + (iter->schema ? strlen(iter->schema->name) :
+ strlen(((struct lyd_node_opaq *)iter)->name.name));
+ if ((rc = lyd_path_str_enlarge(&buffer, &buflen, bufused + len, 0))) {
+ break;
+ }
+
+ /* print next node */
+ bufused += sprintf(buffer + bufused, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", LYD_NAME(iter));
+
+ /* do not always print the last (first) predicate */
+ if (iter->schema && ((depth > 1) || (pathtype == LYD_PATH_STD))) {
+ switch (iter->schema->nodetype) {
+ case LYS_LIST:
+ if (iter->schema->flags & LYS_KEYLESS) {
+ /* print its position */
+ rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
+ } else {
+ /* print all list keys in predicates */
+ rc = lyd_path_list_predicate(iter, &buffer, &buflen, &bufused, 0);
+ }
+ break;
+ case LYS_LEAFLIST:
+ if (iter->schema->flags & LYS_CONFIG_W) {
+ /* print leaf-list value */
+ rc = lyd_path_leaflist_predicate(iter, &buffer, &buflen, &bufused, 0);
+ } else {
+ /* print its position */
+ rc = lyd_path_position_predicate(iter, &buffer, &buflen, &bufused, 0);
+ }
+ break;
+ default:
+ /* nothing to print more */
+ break;
+ }
+ }
+ if (rc) {
+ break;
+ }
+ }
+ break;
+ }
+
+ return buffer;
+}
+
+LIBYANG_API_DEF struct lyd_meta *
+lyd_find_meta(const struct lyd_meta *first, const struct lys_module *module, const char *name)
+{
+ struct lyd_meta *ret = NULL;
+ const struct ly_ctx *ctx;
+ const char *prefix, *tmp;
+ char *str;
+ size_t pref_len, name_len;
+
+ LY_CHECK_ARG_RET(NULL, module || strchr(name, ':'), name, NULL);
+ LY_CHECK_CTX_EQUAL_RET(first ? first->annotation->module->ctx : NULL, module ? module->ctx : NULL, NULL);
+
+ if (!first) {
+ return NULL;
+ }
+
+ ctx = first->annotation->module->ctx;
+
+ /* parse the name */
+ tmp = name;
+ if (ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len) || tmp[0]) {
+ LOGERR(ctx, LY_EINVAL, "Metadata name \"%s\" is not valid.", name);
+ return NULL;
+ }
+
+ /* find the module */
+ if (prefix) {
+ str = strndup(prefix, pref_len);
+ module = ly_ctx_get_module_latest(ctx, str);
+ free(str);
+ LY_CHECK_ERR_RET(!module, LOGERR(ctx, LY_EINVAL, "Module \"%.*s\" not found.", (int)pref_len, prefix), NULL);
+ }
+
+ /* find the metadata */
+ LY_LIST_FOR(first, first) {
+ if ((first->annotation->module == module) && !strcmp(first->name, name)) {
+ ret = (struct lyd_meta *)first;
+ break;
+ }
+ }
+
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_sibling_first(const struct lyd_node *siblings, const struct lyd_node *target, struct lyd_node **match)
+{
+ struct lyd_node **match_p, *iter, *dup = NULL;
+ struct lyd_node_inner *parent;
+ ly_bool found;
+
+ LY_CHECK_ARG_RET(NULL, target, LY_EINVAL);
+ if (!siblings) {
+ /* no data */
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ if (LYD_CTX(siblings) != LYD_CTX(target)) {
+ /* create a duplicate in this context */
+ LY_CHECK_RET(lyd_dup_single_to_ctx(target, LYD_CTX(siblings), NULL, 0, &dup));
+ target = dup;
+ }
+
+ if ((siblings->schema && target->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
+ /* schema mismatch */
+ lyd_free_tree(dup);
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ /* get first sibling */
+ siblings = lyd_first_sibling(siblings);
+
+ parent = siblings->parent;
+ if (parent && parent->schema && parent->children_ht) {
+ assert(target->hash);
+
+ if (lysc_is_dup_inst_list(target->schema)) {
+ /* we must search the instances from beginning to find the first matching one */
+ found = 0;
+ LYD_LIST_FOR_INST(siblings, target->schema, iter) {
+ if (!lyd_compare_single(target, iter, 0)) {
+ found = 1;
+ break;
+ }
+ }
+ if (found) {
+ siblings = iter;
+ } else {
+ siblings = NULL;
+ }
+ } else {
+ /* find by hash */
+ if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
+ siblings = *match_p;
+ } else {
+ /* not found */
+ siblings = NULL;
+ }
+ }
+ } else {
+ /* no children hash table */
+ for ( ; siblings; siblings = siblings->next) {
+ if (!lyd_compare_single(siblings, target, LYD_COMPARE_OPAQ)) {
+ break;
+ }
+ }
+ }
+
+ lyd_free_tree(dup);
+ if (!siblings) {
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ if (match) {
+ *match = (struct lyd_node *)siblings;
+ }
+ return LY_SUCCESS;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_sibling_val(const struct lyd_node *siblings, const struct lysc_node *schema, const char *key_or_value,
+ size_t val_len, struct lyd_node **match)
+{
+ LY_ERR rc;
+ struct lyd_node *target = NULL;
+ const struct lyd_node *parent;
+
+ LY_CHECK_ARG_RET(NULL, schema, !(schema->nodetype & (LYS_CHOICE | LYS_CASE)), LY_EINVAL);
+ if (!siblings) {
+ /* no data */
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ if ((LYD_CTX(siblings) != schema->module->ctx)) {
+ /* parent of ext nodes is useless */
+ parent = (siblings->flags & LYD_EXT) ? NULL : lyd_parent(siblings);
+ if (lyd_find_schema_ctx(schema, LYD_CTX(siblings), parent, 0, &schema)) {
+ /* no schema node in siblings so certainly no data node either */
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+ }
+
+ if (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(schema))) {
+ /* schema mismatch */
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ if (key_or_value && !val_len) {
+ val_len = strlen(key_or_value);
+ }
+
+ if ((schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && key_or_value) {
+ /* create a data node and find the instance */
+ if (schema->nodetype == LYS_LEAFLIST) {
+ /* target used attributes: schema, hash, value */
+ rc = lyd_create_term(schema, key_or_value, val_len, NULL, LY_VALUE_JSON, NULL, LYD_HINT_DATA, NULL, &target);
+ LY_CHECK_RET(rc);
+ } else {
+ /* target used attributes: schema, hash, child (all keys) */
+ LY_CHECK_RET(lyd_create_list2(schema, key_or_value, val_len, &target));
+ }
+
+ /* find it */
+ rc = lyd_find_sibling_first(siblings, target, match);
+ } else {
+ /* find the first schema node instance */
+ rc = lyd_find_sibling_schema(siblings, schema, match);
+ }
+
+ lyd_free_tree(target);
+ return rc;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_sibling_dup_inst_set(const struct lyd_node *siblings, const struct lyd_node *target, struct ly_set **set)
+{
+ struct lyd_node **match_p, *first, *iter;
+ struct lyd_node_inner *parent;
+
+ LY_CHECK_ARG_RET(NULL, target, set, LY_EINVAL);
+ LY_CHECK_CTX_EQUAL_RET(siblings ? LYD_CTX(siblings) : NULL, LYD_CTX(target), LY_EINVAL);
+
+ LY_CHECK_RET(ly_set_new(set));
+
+ if (!siblings || (siblings->schema && (lysc_data_parent(siblings->schema) != lysc_data_parent(target->schema)))) {
+ /* no data or schema mismatch */
+ return LY_ENOTFOUND;
+ }
+
+ /* get first sibling */
+ siblings = lyd_first_sibling(siblings);
+
+ parent = siblings->parent;
+ if (parent && parent->schema && parent->children_ht) {
+ assert(target->hash);
+
+ /* find the first instance */
+ lyd_find_sibling_first(siblings, target, &first);
+ if (first) {
+ /* add it so that it is the first in the set */
+ if (ly_set_add(*set, first, 1, NULL)) {
+ goto error;
+ }
+
+ /* find by hash */
+ if (!lyht_find(parent->children_ht, &target, target->hash, (void **)&match_p)) {
+ iter = *match_p;
+ } else {
+ /* not found */
+ iter = NULL;
+ }
+ while (iter) {
+ /* add all found nodes into the set */
+ if ((iter != first) && !lyd_compare_single(iter, target, 0) && ly_set_add(*set, iter, 1, NULL)) {
+ goto error;
+ }
+
+ /* find next instance */
+ if (lyht_find_next(parent->children_ht, &iter, iter->hash, (void **)&match_p)) {
+ iter = NULL;
+ } else {
+ iter = *match_p;
+ }
+ }
+ }
+ } else {
+ /* no children hash table */
+ LY_LIST_FOR(siblings, siblings) {
+ if (!lyd_compare_single(target, siblings, LYD_COMPARE_OPAQ)) {
+ ly_set_add(*set, (void *)siblings, 1, NULL);
+ }
+ }
+ }
+
+ if (!(*set)->count) {
+ return LY_ENOTFOUND;
+ }
+ return LY_SUCCESS;
+
+error:
+ ly_set_free(*set, NULL);
+ *set = NULL;
+ return LY_EMEM;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_sibling_opaq_next(const struct lyd_node *first, const char *name, struct lyd_node **match)
+{
+ LY_CHECK_ARG_RET(NULL, name, LY_EINVAL);
+
+ for ( ; first; first = first->next) {
+ if (!first->schema && !strcmp(LYD_NAME(first), name)) {
+ break;
+ }
+ }
+
+ if (match) {
+ *match = (struct lyd_node *)first;
+ }
+ return first ? LY_SUCCESS : LY_ENOTFOUND;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_xpath4(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath, LY_VALUE_FORMAT format,
+ void *prefix_data, const struct lyxp_var *vars, struct ly_set **set)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyxp_set xp_set = {0};
+ struct lyxp_expr *exp = NULL;
+ uint32_t i;
+
+ LY_CHECK_ARG_RET(NULL, tree, xpath, format, set, LY_EINVAL);
+
+ *set = NULL;
+
+ /* parse expression */
+ ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(tree), xpath, 0, 1, &exp);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* evaluate expression */
+ ret = lyxp_eval(LYD_CTX(tree), exp, NULL, format, prefix_data, ctx_node, ctx_node, tree, vars, &xp_set,
+ LYXP_IGNORE_WHEN);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ if (xp_set.type != LYXP_SET_NODE_SET) {
+ LOGERR(LYD_CTX(tree), LY_EINVAL, "XPath \"%s\" result is not a node set.", xpath);
+ ret = LY_EINVAL;
+ goto cleanup;
+ }
+
+ /* allocate return set */
+ ret = ly_set_new(set);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* transform into ly_set, allocate memory for all the elements once (even though not all items must be
+ * elements but most likely will be) */
+ (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
+ LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(LYD_CTX(tree)); ret = LY_EMEM, cleanup);
+ (*set)->size = xp_set.used;
+
+ for (i = 0; i < xp_set.used; ++i) {
+ if (xp_set.val.nodes[i].type == LYXP_NODE_ELEM) {
+ ret = ly_set_add(*set, xp_set.val.nodes[i].node, 1, NULL);
+ LY_CHECK_GOTO(ret, cleanup);
+ }
+ }
+
+cleanup:
+ lyxp_set_free_content(&xp_set);
+ lyxp_expr_free((struct ly_ctx *)LYD_CTX(tree), exp);
+ if (ret) {
+ ly_set_free(*set, NULL);
+ *set = NULL;
+ }
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_xpath3(const struct lyd_node *ctx_node, const struct lyd_node *tree, const char *xpath,
+ const struct lyxp_var *vars, struct ly_set **set)
+{
+ LY_CHECK_ARG_RET(NULL, tree, xpath, set, LY_EINVAL);
+
+ return lyd_find_xpath4(ctx_node, tree, xpath, LY_VALUE_JSON, NULL, vars, set);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, struct ly_set **set)
+{
+ LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
+
+ return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, vars, set);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_xpath(const struct lyd_node *ctx_node, const char *xpath, struct ly_set **set)
+{
+ LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
+
+ return lyd_find_xpath4(ctx_node, ctx_node, xpath, LY_VALUE_JSON, NULL, NULL, set);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_eval_xpath3(const struct lyd_node *ctx_node, const struct lys_module *cur_mod, const char *xpath,
+ LY_VALUE_FORMAT format, void *prefix_data, const struct lyxp_var *vars, ly_bool *result)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyxp_set xp_set = {0};
+ struct lyxp_expr *exp = NULL;
+
+ LY_CHECK_ARG_RET(NULL, ctx_node, xpath, result, LY_EINVAL);
+
+ /* compile expression */
+ ret = lyxp_expr_parse((struct ly_ctx *)LYD_CTX(ctx_node), xpath, 0, 1, &exp);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* evaluate expression */
+ ret = lyxp_eval(LYD_CTX(ctx_node), exp, cur_mod, format, prefix_data, ctx_node, ctx_node, ctx_node, vars, &xp_set,
+ LYXP_IGNORE_WHEN);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* transform into boolean */
+ ret = lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* set result */
+ *result = xp_set.val.bln;
+
+cleanup:
+ lyxp_set_free_content(&xp_set);
+ lyxp_expr_free((struct ly_ctx *)LYD_CTX(ctx_node), exp);
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_eval_xpath2(const struct lyd_node *ctx_node, const char *xpath, const struct lyxp_var *vars, ly_bool *result)
+{
+ return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, vars, result);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_eval_xpath(const struct lyd_node *ctx_node, const char *xpath, ly_bool *result)
+{
+ return lyd_eval_xpath3(ctx_node, NULL, xpath, LY_VALUE_JSON, NULL, NULL, result);
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_path(const struct lyd_node *ctx_node, const char *path, ly_bool output, struct lyd_node **match)
+{
+ LY_ERR ret = LY_SUCCESS;
+ struct lyxp_expr *expr = NULL;
+ struct ly_path *lypath = NULL;
+
+ LY_CHECK_ARG_RET(NULL, ctx_node, ctx_node->schema, path, LY_EINVAL);
+
+ /* parse the path */
+ ret = ly_path_parse(LYD_CTX(ctx_node), ctx_node->schema, path, strlen(path), 0, LY_PATH_BEGIN_EITHER,
+ LY_PATH_PREFIX_OPTIONAL, LY_PATH_PRED_SIMPLE, &expr);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* compile the path */
+ ret = ly_path_compile(LYD_CTX(ctx_node), NULL, ctx_node->schema, NULL, expr,
+ output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_SINGLE, 0, LY_VALUE_JSON, NULL, &lypath);
+ LY_CHECK_GOTO(ret, cleanup);
+
+ /* evaluate the path */
+ ret = ly_path_eval_partial(lypath, ctx_node, NULL, match);
+
+cleanup:
+ lyxp_expr_free(LYD_CTX(ctx_node), expr);
+ ly_path_free(LYD_CTX(ctx_node), lypath);
+ return ret;
+}
+
+LIBYANG_API_DEF LY_ERR
+lyd_find_target(const struct ly_path *path, const struct lyd_node *tree, struct lyd_node **match)
+{
+ LY_ERR ret;
+ struct lyd_node *m;
+
+ LY_CHECK_ARG_RET(NULL, path, LY_EINVAL);
+
+ ret = ly_path_eval(path, tree, &m);
+ if (ret) {
+ if (match) {
+ *match = NULL;
+ }
+ return LY_ENOTFOUND;
+ }
+
+ if (match) {
+ *match = m;
+ }
+ return LY_SUCCESS;
+}