blob: 6db020aa0d07d099a22311b5ca129c0028d33465 [file] [log] [blame]
Michal Vaskocde73ac2019-11-14 16:10:27 +01001/**
2 * @file validation.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief Validation
5 *
Michal Vasko906bafa2022-04-22 12:28:55 +02006 * Copyright (c) 2019 - 2022 CESNET, z.s.p.o.
Michal Vaskocde73ac2019-11-14 16:10:27 +01007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Christian Hopps32874e12021-05-01 09:43:54 -040014#define _GNU_SOURCE /* asprintf, strdup */
Michal Vasko81bc5512020-11-13 18:05:18 +010015
Michal Vaskofbed4ea2020-07-08 10:43:30 +020016#include "validation.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010017
18#include <assert.h>
Radek Krejci77114102021-03-10 15:21:57 +010019#include <limits.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include <stdint.h>
Michal Vasko52927e22020-03-16 17:26:14 +010021#include <stdio.h>
22#include <stdlib.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020023#include <string.h>
Michal Vaskocde73ac2019-11-14 16:10:27 +010024
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
Michal Vasko69730152020-10-09 16:30:07 +020026#include "compat.h"
Michal Vasko8104fd42020-07-13 11:09:51 +020027#include "diff.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "hash_table.h"
29#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020030#include "parser_data.h"
Radek Krejci77114102021-03-10 15:21:57 +010031#include "parser_internal.h"
Radek Krejci1b2eef82021-02-17 11:17:27 +010032#include "plugins_exts.h"
Radek Krejcif1ca0ac2021-04-12 16:00:06 +020033#include "plugins_exts/metadata.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020034#include "plugins_types.h"
35#include "set.h"
36#include "tree.h"
Radek Krejci47fab892020-11-05 17:02:41 +010037#include "tree_data.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010038#include "tree_data_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020039#include "tree_schema.h"
Michal Vasko14654712020-02-06 08:35:21 +010040#include "tree_schema_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020041#include "xpath.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010042
Michal Vaskoa6669ba2020-08-06 16:14:26 +020043LY_ERR
Michal Vasko8104fd42020-07-13 11:09:51 +020044lyd_val_diff_add(const struct lyd_node *node, enum lyd_diff_op op, struct lyd_node **diff)
45{
46 LY_ERR ret = LY_SUCCESS;
47 struct lyd_node *new_diff = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010048 const struct lyd_node *prev_inst;
Michal Vaskoe78faec2021-04-08 17:24:43 +020049 char *key = NULL, *value = NULL, *position = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010050 size_t buflen = 0, bufused = 0;
Michal Vaskoe78faec2021-04-08 17:24:43 +020051 uint32_t pos;
Michal Vasko8104fd42020-07-13 11:09:51 +020052
53 assert((op == LYD_DIFF_OP_DELETE) || (op == LYD_DIFF_OP_CREATE));
54
Michal Vasko81bc5512020-11-13 18:05:18 +010055 if ((op == LYD_DIFF_OP_CREATE) && lysc_is_userordered(node->schema)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +020056 if (lysc_is_dup_inst_list(node->schema)) {
57 pos = lyd_list_pos(node);
Michal Vasko81bc5512020-11-13 18:05:18 +010058
Michal Vaskoe78faec2021-04-08 17:24:43 +020059 /* generate position meta */
60 if (pos > 1) {
61 if (asprintf(&position, "%" PRIu32, pos - 1) == -1) {
62 LOGMEM(LYD_CTX(node));
63 ret = LY_EMEM;
64 goto cleanup;
65 }
Michal Vasko81bc5512020-11-13 18:05:18 +010066 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020067 position = strdup("");
68 LY_CHECK_ERR_GOTO(!position, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
Michal Vasko81bc5512020-11-13 18:05:18 +010069 }
70 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020071 if (node->prev->next && (node->prev->schema == node->schema)) {
72 prev_inst = node->prev;
Michal Vasko81bc5512020-11-13 18:05:18 +010073 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020074 /* first instance */
75 prev_inst = NULL;
76 }
77
78 if (node->schema->nodetype == LYS_LIST) {
79 /* generate key meta */
80 if (prev_inst) {
81 LY_CHECK_GOTO(ret = lyd_path_list_predicate(prev_inst, &key, &buflen, &bufused, 0), cleanup);
82 } else {
83 key = strdup("");
84 LY_CHECK_ERR_GOTO(!key, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
85 }
86 } else {
87 /* generate value meta */
88 if (prev_inst) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +020089 value = strdup(lyd_get_value(prev_inst));
Michal Vaskoe78faec2021-04-08 17:24:43 +020090 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
91 } else {
92 value = strdup("");
93 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
94 }
Michal Vasko81bc5512020-11-13 18:05:18 +010095 }
96 }
97 }
98
Michal Vasko8104fd42020-07-13 11:09:51 +020099 /* create new diff tree */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200100 LY_CHECK_GOTO(ret = lyd_diff_add(node, op, NULL, NULL, key, value, position, NULL, NULL, &new_diff), cleanup);
Michal Vasko8104fd42020-07-13 11:09:51 +0200101
102 /* merge into existing diff */
Michal Vaskoc0e58e82020-11-11 19:04:33 +0100103 ret = lyd_diff_merge_all(diff, new_diff, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +0200104
Michal Vasko81bc5512020-11-13 18:05:18 +0100105cleanup:
Michal Vasko8104fd42020-07-13 11:09:51 +0200106 lyd_free_tree(new_diff);
Michal Vasko81bc5512020-11-13 18:05:18 +0100107 free(key);
108 free(value);
Michal Vaskoe78faec2021-04-08 17:24:43 +0200109 free(position);
Michal Vasko8104fd42020-07-13 11:09:51 +0200110 return ret;
111}
112
113/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100114 * @brief Evaluate all relevant "when" conditions of a node.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100115 *
Michal Vaskobd4db892020-11-23 16:58:20 +0100116 * @param[in] tree Data tree.
117 * @param[in] node Node whose relevant when conditions will be evaluated.
118 * @param[in] schema Schema node of @p node. It may not be possible to use directly if @p node is opaque.
Michal Vasko976ec432021-12-06 15:42:22 +0100119 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobd4db892020-11-23 16:58:20 +0100120 * @param[out] disabled First when that evaluated false, if any.
121 * @return LY_SUCCESS on success.
122 * @return LY_EINCOMPLETE if a referenced node does not have its when evaluated.
123 * @return LY_ERR value on error.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100124 */
125static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100126lyd_validate_node_when(const struct lyd_node *tree, const struct lyd_node *node, const struct lysc_node *schema,
Michal Vasko976ec432021-12-06 15:42:22 +0100127 uint32_t xpath_options, const struct lysc_when **disabled)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100128{
Michal Vasko8104fd42020-07-13 11:09:51 +0200129 LY_ERR ret;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100130 const struct lyd_node *ctx_node;
131 struct lyxp_set xp_set;
Michal Vaskobd4db892020-11-23 16:58:20 +0100132 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100133
Michal Vaskobd4db892020-11-23 16:58:20 +0100134 assert(!node->schema || (node->schema == schema));
Michal Vaskocde73ac2019-11-14 16:10:27 +0100135
Michal Vaskobd4db892020-11-23 16:58:20 +0100136 *disabled = NULL;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100137
Michal Vaskobd4db892020-11-23 16:58:20 +0100138 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100139 const struct lysc_when *when;
140 struct lysc_when **when_list = lysc_node_when(schema);
Michal Vasko26bbb272022-08-02 14:54:33 +0200141
Radek Krejci9a3823e2021-01-27 20:26:46 +0100142 LY_ARRAY_FOR(when_list, u) {
143 when = when_list[u];
Michal Vaskocde73ac2019-11-14 16:10:27 +0100144
Michal Vaskobd4db892020-11-23 16:58:20 +0100145 /* get context node */
146 if (when->context == schema) {
147 ctx_node = node;
148 } else {
149 assert((!when->context && !node->parent) || (when->context == node->parent->schema));
Michal Vasko9e685082021-01-29 14:49:09 +0100150 ctx_node = lyd_parent(node);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100151 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100152
153 /* evaluate when */
154 memset(&xp_set, 0, sizeof xp_set);
Radek Krejci8df109d2021-04-23 12:19:08 +0200155 ret = lyxp_eval(LYD_CTX(node), when->cond, schema->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200156 ctx_node, ctx_node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskobd4db892020-11-23 16:58:20 +0100157 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
158
159 /* return error or LY_EINCOMPLETE for dependant unresolved when */
160 LY_CHECK_RET(ret);
161
162 if (!xp_set.val.bln) {
163 /* false when */
164 *disabled = when;
165 return LY_SUCCESS;
Michal Vasko8104fd42020-07-13 11:09:51 +0200166 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100167 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100168
169 schema = schema->parent;
170 } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
171
172 return LY_SUCCESS;
173}
174
175/**
176 * @brief Evaluate when conditions of collected unres nodes.
177 *
178 * @param[in,out] tree Data tree, is updated if some nodes are autodeleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100179 * @param[in] mod Module of the @p tree to take into consideration when deleting @p tree and moving it.
180 * If set, it is expected @p tree should point to the first node of @p mod. Otherwise it will simply be
181 * the first top-level sibling.
Michal Vaskobd4db892020-11-23 16:58:20 +0100182 * @param[in] node_when Set with nodes with "when" conditions.
Michal Vasko976ec432021-12-06 15:42:22 +0100183 * @param[in] xpath_options Additional XPath options to use.
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200184 * @param[in,out] node_types Set with nodes with unresolved types, remove any with false "when" parents.
Michal Vaskobd4db892020-11-23 16:58:20 +0100185 * @param[in,out] diff Validation diff.
186 * @return LY_SUCCESS on success.
187 * @return LY_ERR value on error.
188 */
189static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100190lyd_validate_unres_when(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when,
Michal Vasko976ec432021-12-06 15:42:22 +0100191 uint32_t xpath_options, struct ly_set *node_types, struct lyd_node **diff)
Michal Vaskobd4db892020-11-23 16:58:20 +0100192{
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200193 LY_ERR rc, r;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200194 uint32_t i, idx;
Michal Vaskobd4db892020-11-23 16:58:20 +0100195 const struct lysc_when *disabled;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200196 struct lyd_node *node = NULL, *elem;
Michal Vaskobd4db892020-11-23 16:58:20 +0100197
198 if (!node_when->count) {
199 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100200 }
201
Michal Vaskobd4db892020-11-23 16:58:20 +0100202 i = node_when->count;
203 do {
204 --i;
205 node = node_when->dnodes[i];
Radek Krejciddace2c2021-01-08 11:30:56 +0100206 LOG_LOCSET(node->schema, node, NULL, NULL);
Michal Vaskobd4db892020-11-23 16:58:20 +0100207
208 /* evaluate all when expressions that affect this node's existence */
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200209 r = lyd_validate_node_when(*tree, node, node->schema, xpath_options, &disabled);
210 if (!r) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100211 if (disabled) {
212 /* when false */
213 if (node->flags & LYD_WHEN_TRUE) {
214 /* autodelete */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100215 lyd_del_move_root(tree, node, mod);
Michal Vaskobd4db892020-11-23 16:58:20 +0100216 if (diff) {
217 /* add into diff */
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200218 LY_CHECK_GOTO(rc = lyd_val_diff_add(node, LYD_DIFF_OP_DELETE, diff), error);
Michal Vaskobd4db892020-11-23 16:58:20 +0100219 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200220
221 /* remove from node types set, if present */
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200222 if (node_types && node_types->count) {
Michal Vasko36ce6b22021-07-26 09:19:21 +0200223 LYD_TREE_DFS_BEGIN(node, elem) {
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200224 /* only term nodes with a validation callback can be in node_types */
225 if ((elem->schema->nodetype & LYD_NODE_TERM) &&
226 ((struct lysc_node_leaf *)elem->schema)->type->plugin->validate &&
227 ly_set_contains(node_types, elem, &idx)) {
228 LY_CHECK_GOTO(rc = ly_set_rm_index(node_types, idx, NULL), error);
Michal Vasko36ce6b22021-07-26 09:19:21 +0200229 }
230 LYD_TREE_DFS_END(node, elem);
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200231 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200232 }
233
234 /* free */
Michal Vaskobd4db892020-11-23 16:58:20 +0100235 lyd_free_tree(node);
236 } else {
237 /* invalid data */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100238 LOGVAL(LYD_CTX(node), LY_VCODE_NOWHEN, disabled->cond->expr);
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200239 rc = LY_EVALID;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100240 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100241 }
242 } else {
243 /* when true */
244 node->flags |= LYD_WHEN_TRUE;
245 }
246
Michal Vasko413af592021-12-13 11:50:51 +0100247 /* remove this node from the set keeping the order, its when was resolved */
248 ly_set_rm_index_ordered(node_when, i, NULL);
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200249 } else if (r != LY_EINCOMPLETE) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100250 /* error */
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200251 rc = r;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100252 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100253 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100254
Radek Krejciddace2c2021-01-08 11:30:56 +0100255 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskobd4db892020-11-23 16:58:20 +0100256 } while (i);
257
258 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100259
260error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100261 LOG_LOCBACK(1, 1, 0, 0);
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200262 return rc;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100263}
264
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200265LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +0200266lyd_validate_unres(struct lyd_node **tree, const struct lys_module *mod, enum lyd_type data_type, struct ly_set *node_when,
Michal Vasko135719f2022-08-25 12:18:17 +0200267 uint32_t when_xp_opts, struct ly_set *node_types, struct ly_set *meta_types, struct ly_set *ext_node,
268 struct ly_set *ext_val, uint32_t val_opts, struct lyd_node **diff)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100269{
270 LY_ERR ret = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200271 uint32_t i;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100272
Michal Vaskoddd76592022-01-17 13:34:48 +0100273 if (ext_val && ext_val->count) {
274 /* first validate parsed extension data */
275 i = ext_val->count;
276 do {
277 --i;
278
279 struct lyd_ctx_ext_val *ext_v = ext_val->objs[i];
280
281 /* validate extension data */
Michal Vaskofbbea932022-06-07 11:00:55 +0200282 ret = ext_v->ext->def->plugin->validate(ext_v->ext, ext_v->sibling, *tree, data_type, val_opts, diff);
Michal Vaskoddd76592022-01-17 13:34:48 +0100283 LY_CHECK_RET(ret);
284
285 /* remove this item from the set */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200286 ly_set_rm_index(ext_val, i, free);
Michal Vaskoddd76592022-01-17 13:34:48 +0100287 } while (i);
288 }
289
Michal Vasko135719f2022-08-25 12:18:17 +0200290 if (ext_node && ext_node->count) {
291 /* validate data nodes with extension instances */
292 i = ext_node->count;
293 do {
294 --i;
295
296 struct lyd_ctx_ext_node *ext_n = ext_node->objs[i];
297
298 /* validate the node */
Michal Vaskoeba23112022-08-26 08:35:41 +0200299 ret = ext_n->ext->def->plugin->node(ext_n->ext, ext_n->node, val_opts);
Michal Vasko135719f2022-08-25 12:18:17 +0200300 LY_CHECK_RET(ret);
301
302 /* remove this item from the set */
303 ly_set_rm_index(ext_node, i, free);
304 } while (i);
305 }
306
Michal Vaskob1b5c262020-03-05 14:29:47 +0100307 if (node_when) {
308 /* evaluate all when conditions */
309 uint32_t prev_count;
Michal Vasko26bbb272022-08-02 14:54:33 +0200310
Michal Vaskob1b5c262020-03-05 14:29:47 +0100311 do {
312 prev_count = node_when->count;
Michal Vasko976ec432021-12-06 15:42:22 +0100313 LY_CHECK_RET(lyd_validate_unres_when(tree, mod, node_when, when_xp_opts, node_types, diff));
Radek Krejci0f969882020-08-21 16:56:47 +0200314 /* there must have been some when conditions resolved */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100315 } while (prev_count > node_when->count);
Michal Vaskocde73ac2019-11-14 16:10:27 +0100316
Michal Vaskob1b5c262020-03-05 14:29:47 +0100317 /* there could have been no cyclic when dependencies, checked during compilation */
318 assert(!node_when->count);
319 }
320
321 if (node_types && node_types->count) {
322 /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200323 i = node_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100324 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200325 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100326
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100327 struct lyd_node_term *node = node_types->objs[i];
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200328 struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100329
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200330 /* resolve the value of the node */
Michal Vaskoe0608fa2022-10-25 15:01:24 +0200331 LOG_LOCSET(NULL, &node->node, NULL, NULL);
Michal Vasko9e685082021-01-29 14:49:09 +0100332 ret = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree);
Michal Vaskoe0608fa2022-10-25 15:01:24 +0200333 LOG_LOCBACK(0, 1, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100334 LY_CHECK_RET(ret);
335
336 /* remove this node from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200337 ly_set_rm_index(node_types, i, NULL);
338 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100339 }
340
Michal Vasko9f96a052020-03-10 09:41:45 +0100341 if (meta_types && meta_types->count) {
342 /* ... and metadata values */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200343 i = meta_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100344 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200345 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100346
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100347 struct lyd_meta *meta = meta_types->objs[i];
Michal Vasko193dacd2022-10-13 08:43:05 +0200348 struct lysc_type *type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100349
Michal Vasko9f96a052020-03-10 09:41:45 +0100350 /* validate and store the value of the metadata */
Michal Vaskofbd037c2022-11-08 10:34:20 +0100351 lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100352 ret = lyd_value_validate_incomplete(LYD_CTX(meta->parent), type, &meta->value, meta->parent, *tree);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100353 LY_CHECK_RET(ret);
354
355 /* remove this attr from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200356 ly_set_rm_index(meta_types, i, NULL);
357 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100358 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100359
360 return ret;
361}
362
Michal Vaskobb844672020-07-03 11:06:12 +0200363/**
364 * @brief Validate instance duplication.
365 *
366 * @param[in] first First sibling to search in.
367 * @param[in] node Data node instance to check.
368 * @return LY_ERR value.
369 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100370static LY_ERR
371lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100372{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100373 struct lyd_node **match_p;
Radek Krejci857189e2020-09-01 13:26:36 +0200374 ly_bool fail = 0;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100375
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100376 assert(node->flags & LYD_NEW);
377
Michal Vaskod6c18af2021-02-12 12:07:31 +0100378 /* key-less list or non-configuration leaf-list */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200379 if (lysc_is_dup_inst_list(node->schema)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100380 /* duplicate instances allowed */
381 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100382 }
383
Michal Vaskob1b5c262020-03-05 14:29:47 +0100384 /* find exactly the same next instance using hashes if possible */
385 if (node->parent && node->parent->children_ht) {
386 if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
387 fail = 1;
388 }
389 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200390 for ( ; first; first = first->next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100391 if (first == node) {
392 continue;
393 }
394
395 if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
396 if (first->schema == node->schema) {
397 fail = 1;
398 break;
399 }
Michal Vasko8f359bf2020-07-28 10:41:15 +0200400 } else if (!lyd_compare_single(first, node, 0)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100401 fail = 1;
402 break;
403 }
404 }
405 }
406
407 if (fail) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100408 LOGVAL(node->schema->module->ctx, LY_VCODE_DUP, node->schema->name);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100409 return LY_EVALID;
410 }
411 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100412}
413
Michal Vaskobb844672020-07-03 11:06:12 +0200414/**
415 * @brief Validate multiple case data existence with possible autodelete.
416 *
417 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100418 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200419 * @param[in] choic Choice node whose cases to check.
Michal Vasko8104fd42020-07-13 11:09:51 +0200420 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200421 * @return LY_ERR value.
422 */
Michal Vaskocde73ac2019-11-14 16:10:27 +0100423static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100424lyd_validate_cases(struct lyd_node **first, const struct lys_module *mod, const struct lysc_node_choice *choic,
425 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100426{
427 const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
428 struct lyd_node *match, *to_del;
Radek Krejci857189e2020-09-01 13:26:36 +0200429 ly_bool found;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100430
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100431 LOG_LOCSET(&choic->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100432
Michal Vaskob1b5c262020-03-05 14:29:47 +0100433 LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
434 found = 0;
435 iter = NULL;
436 match = NULL;
437 while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) {
438 if (match->flags & LYD_NEW) {
439 /* a new case data found, nothing more to look for */
440 found = 2;
441 break;
442 } else {
443 /* and old case data found */
444 if (found == 0) {
445 found = 1;
446 }
447 }
448 }
449
450 if (found == 1) {
451 /* there should not be 2 old cases */
452 if (old_case) {
453 /* old data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100454 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, old_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100455 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100456 return LY_EVALID;
457 }
458
459 /* remember an old existing case */
460 old_case = scase;
461 } else if (found == 2) {
462 if (new_case) {
463 /* new data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100464 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, new_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100465 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100466 return LY_EVALID;
467 }
468
469 /* remember a new existing case */
470 new_case = scase;
471 }
472 }
473
Radek Krejciddace2c2021-01-08 11:30:56 +0100474 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100475
Michal Vaskob1b5c262020-03-05 14:29:47 +0100476 if (old_case && new_case) {
477 /* auto-delete old case */
478 iter = NULL;
479 match = NULL;
480 to_del = NULL;
481 while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100482 lyd_del_move_root(first, to_del, mod);
483
Michal Vasko8104fd42020-07-13 11:09:51 +0200484 /* free previous node */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100485 lyd_free_tree(to_del);
Michal Vasko8104fd42020-07-13 11:09:51 +0200486 if (diff) {
487 /* add into diff */
488 LY_CHECK_RET(lyd_val_diff_add(match, LYD_DIFF_OP_DELETE, diff));
489 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100490 to_del = match;
491 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100492 lyd_del_move_root(first, to_del, mod);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100493 lyd_free_tree(to_del);
494 }
495
496 return LY_SUCCESS;
497}
498
Michal Vaskobb844672020-07-03 11:06:12 +0200499/**
500 * @brief Check whether a schema node can have some default values (true for NP containers as well).
501 *
502 * @param[in] schema Schema node to check.
503 * @return non-zero if yes,
504 * @return 0 otherwise.
505 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100506static int
507lyd_val_has_default(const struct lysc_node *schema)
508{
509 switch (schema->nodetype) {
510 case LYS_LEAF:
511 if (((struct lysc_node_leaf *)schema)->dflt) {
512 return 1;
513 }
514 break;
515 case LYS_LEAFLIST:
516 if (((struct lysc_node_leaflist *)schema)->dflts) {
517 return 1;
518 }
519 break;
520 case LYS_CONTAINER:
521 if (!(schema->flags & LYS_PRESENCE)) {
522 return 1;
523 }
524 break;
525 default:
526 break;
527 }
528
529 return 0;
530}
531
Michal Vaskobb844672020-07-03 11:06:12 +0200532/**
Michal Vasko42266212022-12-01 08:33:11 +0100533 * @brief Properly delete a node as part of auto-delete validation tasks.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100534 *
535 * @param[in,out] first First sibling, is updated if needed.
Michal Vasko42266212022-12-01 08:33:11 +0100536 * @param[in] del Node instance to delete.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100537 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vasko42266212022-12-01 08:33:11 +0100538 * @param[in,out] node Current iteration node, update it if it is deleted.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100539 * @param[in,out] diff Validation diff.
Michal Vasko42266212022-12-01 08:33:11 +0100540 * @return 1 if @p node auto-deleted and updated to its next sibling.
541 * @return 0 if @p node was not auto-deleted.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100542 */
Michal Vasko42266212022-12-01 08:33:11 +0100543static ly_bool
544lyd_validate_autodel_node_del(struct lyd_node **first, struct lyd_node *del, const struct lys_module *mod,
545 struct lyd_node **node, struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100546{
547 struct lyd_node *iter;
Michal Vasko42266212022-12-01 08:33:11 +0100548 ly_bool node_autodel = 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100549
Michal Vasko42266212022-12-01 08:33:11 +0100550 lyd_del_move_root(first, del, mod);
551 if (del == *node) {
552 *node = (*node)->next;
553 node_autodel = 1;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100554 }
555 if (diff) {
556 /* add into diff */
Michal Vasko42266212022-12-01 08:33:11 +0100557 if ((del->schema->nodetype == LYS_CONTAINER) && !(del->schema->flags & LYS_PRESENCE)) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100558 /* we do not want to track NP container changes, but remember any removed children */
Michal Vasko42266212022-12-01 08:33:11 +0100559 LY_LIST_FOR(lyd_child(del), iter) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100560 lyd_val_diff_add(iter, LYD_DIFF_OP_DELETE, diff);
561 }
562 } else {
Michal Vasko42266212022-12-01 08:33:11 +0100563 lyd_val_diff_add(del, LYD_DIFF_OP_DELETE, diff);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100564 }
565 }
Michal Vasko42266212022-12-01 08:33:11 +0100566 lyd_free_tree(del);
567
568 return node_autodel;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100569}
570
571/**
Michal Vasko42266212022-12-01 08:33:11 +0100572 * @brief Auto-delete leaf-list default instances to prevent validation errors.
Michal Vaskobb844672020-07-03 11:06:12 +0200573 *
574 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vasko42266212022-12-01 08:33:11 +0100575 * @param[in,out] node New data node instance to check, is updated if auto-deleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100576 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vasko8104fd42020-07-13 11:09:51 +0200577 * @param[in,out] diff Validation diff.
Michal Vasko42266212022-12-01 08:33:11 +0100578 * @return 1 if @p node auto-deleted and updated to its next sibling.
579 * @return 0 if @p node was not auto-deleted.
Michal Vaskobb844672020-07-03 11:06:12 +0200580 */
Michal Vasko42266212022-12-01 08:33:11 +0100581static ly_bool
582lyd_validate_autodel_leaflist_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
583 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100584{
Michal Vasko42266212022-12-01 08:33:11 +0100585 const struct lysc_node *schema;
586 struct lyd_node *iter, *next;
587 ly_bool found = 0, node_autodel = 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100588
Michal Vasko42266212022-12-01 08:33:11 +0100589 assert((*node)->flags & LYD_NEW);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100590
Michal Vasko42266212022-12-01 08:33:11 +0100591 schema = (*node)->schema;
592 assert(schema->nodetype == LYS_LEAFLIST);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100593
Michal Vasko42266212022-12-01 08:33:11 +0100594 /* check whether there is any explicit instance */
595 LYD_LIST_FOR_INST(*first, schema, iter) {
596 if (!(iter->flags & LYD_DEFAULT)) {
597 found = 1;
598 break;
599 }
600 }
601 if (!found) {
602 /* no explicit instance, keep defaults as they are */
603 return 0;
604 }
605
606 LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) {
607 if (iter->flags & LYD_DEFAULT) {
608 /* default instance found, remove it */
609 if (lyd_validate_autodel_node_del(first, iter, mod, node, diff)) {
610 node_autodel = 1;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100611 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100612 }
613 }
Michal Vasko42266212022-12-01 08:33:11 +0100614
615 return node_autodel;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100616}
617
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100618/**
Michal Vasko42266212022-12-01 08:33:11 +0100619 * @brief Auto-delete container or leaf default instances to prevent validation errors.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100620 *
621 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vasko42266212022-12-01 08:33:11 +0100622 * @param[in,out] node New data node instance to check, is updated if auto-deleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100623 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100624 * @param[in,out] diff Validation diff.
Michal Vasko42266212022-12-01 08:33:11 +0100625 * @return 1 if @p node auto-deleted and updated to its next sibling.
626 * @return 0 if @p node was not auto-deleted.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100627 */
Michal Vasko42266212022-12-01 08:33:11 +0100628static ly_bool
629lyd_validate_autodel_cont_leaf_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
630 struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100631{
Michal Vasko42266212022-12-01 08:33:11 +0100632 const struct lysc_node *schema;
633 struct lyd_node *iter, *next;
634 ly_bool found = 0, node_autodel = 0;
635
636 assert((*node)->flags & LYD_NEW);
637
638 schema = (*node)->schema;
639 assert(schema->nodetype & (LYS_LEAF | LYS_CONTAINER));
640
641 /* check whether there is any explicit instance */
642 LYD_LIST_FOR_INST(*first, schema, iter) {
643 if (!(iter->flags & LYD_DEFAULT)) {
644 found = 1;
645 break;
646 }
647 }
648
649 if (found) {
650 /* remove all default instances */
651 LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) {
652 if (iter->flags & LYD_DEFAULT) {
653 /* default instance, remove it */
654 if (lyd_validate_autodel_node_del(first, iter, mod, node, diff)) {
655 node_autodel = 1;
656 }
657 }
658 }
659 } else {
660 /* remove a single old default instance, if any */
661 LYD_LIST_FOR_INST(*first, schema, iter) {
662 if ((iter->flags & LYD_DEFAULT) && !(iter->flags & LYD_NEW)) {
663 /* old default instance, remove it */
664 if (lyd_validate_autodel_node_del(first, iter, mod, node, diff)) {
665 node_autodel = 1;
666 }
667 break;
668 }
669 }
670 }
671
672 return node_autodel;
673}
674
675/**
676 * @brief Auto-delete leftover default nodes of deleted cases (that have no existing explicit data).
677 *
678 * @param[in,out] first First sibling to search in, is updated if needed.
679 * @param[in,out] node Default data node instance to check.
680 * @param[in] mod Module of the siblings, NULL for nested siblings.
681 * @param[in,out] diff Validation diff.
682 * @return 1 if @p node auto-deleted and updated to its next sibling.
683 * @return 0 if @p node was not auto-deleted.
684 */
685static ly_bool
686lyd_validate_autodel_case_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
687 struct lyd_node **diff)
688{
689 const struct lysc_node *schema;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100690 struct lysc_node_choice *choic;
691 struct lyd_node *iter = NULL;
692 const struct lysc_node *slast = NULL;
Michal Vasko42266212022-12-01 08:33:11 +0100693 ly_bool node_autodel = 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100694
Michal Vasko42266212022-12-01 08:33:11 +0100695 assert((*node)->flags & LYD_DEFAULT);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100696
Michal Vasko42266212022-12-01 08:33:11 +0100697 schema = (*node)->schema;
698
699 if (!schema->parent || (schema->parent->nodetype != LYS_CASE)) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100700 /* the default node is not a descendant of a case */
Michal Vasko42266212022-12-01 08:33:11 +0100701 return 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100702 }
703
Michal Vasko42266212022-12-01 08:33:11 +0100704 choic = (struct lysc_node_choice *)schema->parent->parent;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100705 assert(choic->nodetype == LYS_CHOICE);
706
Michal Vasko42266212022-12-01 08:33:11 +0100707 if (choic->dflt && (choic->dflt == (struct lysc_node_case *)schema->parent)) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100708 /* data of a default case, keep them */
Michal Vasko42266212022-12-01 08:33:11 +0100709 return 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100710 }
711
712 /* try to find an explicit node of the case */
Michal Vasko42266212022-12-01 08:33:11 +0100713 while ((iter = lys_getnext_data(iter, *first, &slast, schema->parent, NULL))) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100714 if (!(iter->flags & LYD_DEFAULT)) {
715 break;
716 }
717 }
718
719 if (!iter) {
720 /* there are only default nodes of the case meaning it does not exist and neither should any default nodes
721 * of the case, remove this one default node */
Michal Vasko42266212022-12-01 08:33:11 +0100722 if (lyd_validate_autodel_node_del(first, *node, mod, node, diff)) {
723 node_autodel = 1;
724 }
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100725 }
Michal Vasko42266212022-12-01 08:33:11 +0100726
727 return node_autodel;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100728}
729
Michal Vasko17f76642021-08-03 17:01:30 +0200730/**
731 * @brief Validate new siblings in choices, recursively for nested choices.
732 *
733 * @param[in,out] first First sibling.
734 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
735 * @param[in] mod Module of the siblings, NULL for nested siblings.
736 * @param[in,out] diff Validation diff.
737 * @return LY_ERR value.
738 */
739static LY_ERR
740lyd_validate_choice_r(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
Radek Krejci0f969882020-08-21 16:56:47 +0200741 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100742{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100743 const struct lysc_node *snode = NULL;
744
Michal Vaskob1b5c262020-03-05 14:29:47 +0100745 while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
746 /* check case duplicites */
747 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100748 LY_CHECK_RET(lyd_validate_cases(first, mod, (struct lysc_node_choice *)snode, diff));
Michal Vasko17f76642021-08-03 17:01:30 +0200749
750 /* check for nested choice */
751 LY_CHECK_RET(lyd_validate_choice_r(first, snode, mod, diff));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100752 }
753 }
754
Michal Vasko17f76642021-08-03 17:01:30 +0200755 return LY_SUCCESS;
756}
757
758LY_ERR
759lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
760 struct lyd_node **diff)
761{
Michal Vasko42266212022-12-01 08:33:11 +0100762 LY_ERR r;
763 struct lyd_node *node;
764 const struct lysc_node *last_dflt_schema = NULL;
Michal Vasko17f76642021-08-03 17:01:30 +0200765
766 assert(first && (sparent || mod));
767
768 /* validate choices */
769 LY_CHECK_RET(lyd_validate_choice_r(first, sparent, mod, diff));
770
Michal Vasko42266212022-12-01 08:33:11 +0100771 node = *first;
772 while (node) {
Michal Vasko6a6e3082022-05-10 10:32:38 +0200773 if (!node->schema || (mod && (lyd_owner_module(node) != mod))) {
774 /* opaque node or all top-level data from this module checked */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100775 break;
776 }
777
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100778 if (!(node->flags & (LYD_NEW | LYD_DEFAULT))) {
779 /* check only new and default nodes */
Michal Vasko42266212022-12-01 08:33:11 +0100780 node = node->next;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100781 continue;
782 }
783
Michal Vasko42266212022-12-01 08:33:11 +0100784 if (lyd_val_has_default(node->schema) && (node->schema != last_dflt_schema) && (node->flags & LYD_NEW)) {
785 /* remove old default(s) of the new node if an explicit instance exists */
786 last_dflt_schema = node->schema;
787 if (node->schema->nodetype == LYS_LEAFLIST) {
788 if (lyd_validate_autodel_leaflist_dflt(first, &node, mod, diff)) {
789 continue;
790 }
791 } else {
792 if (lyd_validate_autodel_cont_leaf_dflt(first, &node, mod, diff)) {
793 continue;
794 }
795 }
796 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100797
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100798 if (node->flags & LYD_NEW) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100799 /* then check new node instance duplicities */
Michal Vasko42266212022-12-01 08:33:11 +0100800 LOG_LOCSET(NULL, node, NULL, NULL);
801 r = lyd_validate_duplicates(*first, node);
802 LOG_LOCBACK(0, 1, 0, 0);
803 LY_CHECK_RET(r);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100804
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100805 /* this node is valid */
806 node->flags &= ~LYD_NEW;
807 }
808
809 if (node->flags & LYD_DEFAULT) {
810 /* remove leftover default nodes from a no-longer existing case */
Michal Vasko42266212022-12-01 08:33:11 +0100811 if (lyd_validate_autodel_case_dflt(first, &node, mod, diff)) {
812 continue;
813 }
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100814 }
Michal Vasko42266212022-12-01 08:33:11 +0100815
816 /* next iter */
817 node = node->next;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100818 }
819
820 return LY_SUCCESS;
821}
822
Michal Vaskobb844672020-07-03 11:06:12 +0200823/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100824 * @brief Evaluate any "when" conditions of a non-existent data node with existing parent.
825 *
826 * @param[in] first First data sibling of the non-existing node.
827 * @param[in] parent Data parent of the non-existing node.
828 * @param[in] snode Schema node of the non-existing node.
829 * @param[out] disabled First when that evaluated false, if any.
830 * @return LY_ERR value.
831 */
832static LY_ERR
833lyd_validate_dummy_when(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
834 const struct lysc_when **disabled)
835{
836 LY_ERR ret = LY_SUCCESS;
837 struct lyd_node *tree, *dummy = NULL;
Michal Vaskoa27245c2022-05-02 09:01:35 +0200838 uint32_t xp_opts;
Michal Vaskobd4db892020-11-23 16:58:20 +0100839
840 /* find root */
841 if (parent) {
842 tree = (struct lyd_node *)parent;
843 while (tree->parent) {
844 tree = lyd_parent(tree);
845 }
846 tree = lyd_first_sibling(tree);
847 } else {
Michal Vaskobd99b5e2022-04-29 11:15:47 +0200848 /* is the first sibling from the same module, but may not be the actual first */
849 tree = lyd_first_sibling(first);
Michal Vaskobd4db892020-11-23 16:58:20 +0100850 }
851
852 /* create dummy opaque node */
Michal Vasko0ab974d2021-02-24 13:18:26 +0100853 ret = lyd_new_opaq((struct lyd_node *)parent, snode->module->ctx, snode->name, NULL, NULL, snode->module->name, &dummy);
Michal Vaskobd4db892020-11-23 16:58:20 +0100854 LY_CHECK_GOTO(ret, cleanup);
855
856 /* connect it if needed */
857 if (!parent) {
858 if (first) {
859 lyd_insert_sibling((struct lyd_node *)first, dummy, &tree);
860 } else {
861 assert(!tree);
862 tree = dummy;
863 }
864 }
865
Michal Vaskoa27245c2022-05-02 09:01:35 +0200866 /* explicitly specified accesible tree */
867 if (snode->flags & LYS_CONFIG_W) {
868 xp_opts = LYXP_ACCESS_TREE_CONFIG;
869 } else {
870 xp_opts = LYXP_ACCESS_TREE_ALL;
871 }
872
Michal Vaskobd4db892020-11-23 16:58:20 +0100873 /* evaluate all when */
Michal Vaskoa27245c2022-05-02 09:01:35 +0200874 ret = lyd_validate_node_when(tree, dummy, snode, xp_opts, disabled);
Michal Vaskobd4db892020-11-23 16:58:20 +0100875 if (ret == LY_EINCOMPLETE) {
876 /* all other when must be resolved by now */
877 LOGINT(snode->module->ctx);
878 ret = LY_EINT;
879 goto cleanup;
880 } else if (ret) {
881 /* error */
882 goto cleanup;
883 }
884
885cleanup:
886 lyd_free_tree(dummy);
887 return ret;
888}
889
890/**
Michal Vaskobb844672020-07-03 11:06:12 +0200891 * @brief Validate mandatory node existence.
892 *
893 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100894 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200895 * @param[in] snode Schema node to validate.
896 * @return LY_ERR value.
897 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100898static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100899lyd_validate_mandatory(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode)
Michal Vaskoa3881362020-01-21 15:57:35 +0100900{
Michal Vaskobd4db892020-11-23 16:58:20 +0100901 const struct lysc_when *disabled;
902
Michal Vaskoa3881362020-01-21 15:57:35 +0100903 if (snode->nodetype == LYS_CHOICE) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100904 /* some data of a choice case exist */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100905 if (lys_getnext_data(NULL, first, NULL, snode, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100906 return LY_SUCCESS;
907 }
908 } else {
909 assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY));
Michal Vaskoa3881362020-01-21 15:57:35 +0100910
Michal Vaskob1b5c262020-03-05 14:29:47 +0100911 if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100912 /* data instance found */
913 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100914 }
915 }
916
Michal Vaskobd4db892020-11-23 16:58:20 +0100917 disabled = NULL;
918 if (lysc_has_when(snode)) {
919 /* if there are any when conditions, they must be true for a validation error */
920 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
921 }
922
923 if (!disabled) {
924 /* node instance not found */
Michal Vasko538b8952021-02-17 11:27:26 +0100925 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200926 LOGVAL_APPTAG(snode->module->ctx, "missing-choice", LY_VCODE_NOMAND_CHOIC, snode->name);
Michal Vasko538b8952021-02-17 11:27:26 +0100927 } else {
928 LOGVAL(snode->module->ctx, LY_VCODE_NOMAND, snode->name);
929 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100930 return LY_EVALID;
931 }
932
933 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100934}
935
Michal Vaskobb844672020-07-03 11:06:12 +0200936/**
937 * @brief Validate min/max-elements constraints, if any.
938 *
939 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100940 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200941 * @param[in] snode Schema node to validate.
942 * @param[in] min Minimum number of elements, 0 for no restriction.
943 * @param[in] max Max number of elements, 0 for no restriction.
944 * @return LY_ERR value.
945 */
Michal Vaskoa3881362020-01-21 15:57:35 +0100946static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100947lyd_validate_minmax(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
948 uint32_t min, uint32_t max)
Michal Vaskoa3881362020-01-21 15:57:35 +0100949{
Michal Vaskoacd83e72020-02-04 14:12:01 +0100950 uint32_t count = 0;
Michal Vasko4c583e82020-07-17 12:16:14 +0200951 struct lyd_node *iter;
Michal Vaskobd4db892020-11-23 16:58:20 +0100952 const struct lysc_when *disabled;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100953 ly_bool invalid_instance = 0;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100954
Michal Vasko9b368d32020-02-14 13:53:31 +0100955 assert(min || max);
956
Michal Vasko4c583e82020-07-17 12:16:14 +0200957 LYD_LIST_FOR_INST(first, snode, iter) {
958 ++count;
Michal Vasko9b368d32020-02-14 13:53:31 +0100959
Michal Vasko4c583e82020-07-17 12:16:14 +0200960 if (min && (count == min)) {
961 /* satisfied */
962 min = 0;
963 if (!max) {
964 /* nothing more to check */
Michal Vasko9b368d32020-02-14 13:53:31 +0100965 break;
966 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100967 }
Michal Vasko4c583e82020-07-17 12:16:14 +0200968 if (max && (count > max)) {
969 /* not satisifed */
Radek Krejciddace2c2021-01-08 11:30:56 +0100970 LOG_LOCSET(NULL, iter, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100971 invalid_instance = 1;
Michal Vasko4c583e82020-07-17 12:16:14 +0200972 break;
973 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100974 }
975
Michal Vasko9b368d32020-02-14 13:53:31 +0100976 if (min) {
977 assert(count < min);
Michal Vaskobd4db892020-11-23 16:58:20 +0100978
979 disabled = NULL;
980 if (lysc_has_when(snode)) {
981 /* if there are any when conditions, they must be true for a validation error */
982 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
983 }
984
985 if (!disabled) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200986 LOGVAL_APPTAG(snode->module->ctx, "too-few-elements", LY_VCODE_NOMIN, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100987 goto failure;
Michal Vaskobd4db892020-11-23 16:58:20 +0100988 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100989 } else if (max && (count > max)) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200990 LOGVAL_APPTAG(snode->module->ctx, "too-many-elements", LY_VCODE_NOMAX, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100991 goto failure;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100992 }
993
Michal Vaskoa3881362020-01-21 15:57:35 +0100994 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100995
996failure:
Radek Krejciddace2c2021-01-08 11:30:56 +0100997 LOG_LOCBACK(0, invalid_instance, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100998 return LY_EVALID;
Michal Vaskoa3881362020-01-21 15:57:35 +0100999}
1000
Michal Vaskobb844672020-07-03 11:06:12 +02001001/**
1002 * @brief Find node referenced by a list unique statement.
1003 *
1004 * @param[in] uniq_leaf Unique leaf to find.
1005 * @param[in] list List instance to use for the search.
1006 * @return Found leaf,
1007 * @return NULL if no leaf found.
1008 */
Michal Vasko14654712020-02-06 08:35:21 +01001009static struct lyd_node *
Michal Vaskobb844672020-07-03 11:06:12 +02001010lyd_val_uniq_find_leaf(const struct lysc_node_leaf *uniq_leaf, const struct lyd_node *list)
Michal Vasko14654712020-02-06 08:35:21 +01001011{
Michal Vasko9b368d32020-02-14 13:53:31 +01001012 struct lyd_node *node;
1013 const struct lysc_node *iter;
1014 size_t depth = 0, i;
Michal Vasko14654712020-02-06 08:35:21 +01001015
Michal Vasko9b368d32020-02-14 13:53:31 +01001016 /* get leaf depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001017 for (iter = &uniq_leaf->node; iter && (iter != list->schema); iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02001018 ++depth;
Michal Vasko14654712020-02-06 08:35:21 +01001019 }
Michal Vasko9b368d32020-02-14 13:53:31 +01001020
Michal Vaskobb844672020-07-03 11:06:12 +02001021 node = (struct lyd_node *)list;
Michal Vasko9b368d32020-02-14 13:53:31 +01001022 while (node && depth) {
1023 /* find schema node with this depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001024 for (i = depth - 1, iter = &uniq_leaf->node; i; iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02001025 --i;
Michal Vasko9b368d32020-02-14 13:53:31 +01001026 }
1027
1028 /* find iter instance in children */
1029 assert(iter->nodetype & (LYS_CONTAINER | LYS_LEAF));
Radek Krejcia1c1e542020-09-29 16:06:52 +02001030 lyd_find_sibling_val(lyd_child(node), iter, NULL, 0, &node);
Michal Vasko9b368d32020-02-14 13:53:31 +01001031 --depth;
1032 }
1033
Michal Vasko14654712020-02-06 08:35:21 +01001034 return node;
1035}
1036
Michal Vaskobb844672020-07-03 11:06:12 +02001037/**
1038 * @brief Callback for comparing 2 list unique leaf values.
1039 *
Michal Vasko62524a92021-02-26 10:08:50 +01001040 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +02001041 *
Michal Vaskobb844672020-07-03 11:06:12 +02001042 * @param[in] cb_data 0 to compare all uniques, n to compare only n-th unique.
Michal Vasko14654712020-02-06 08:35:21 +01001043 */
Radek Krejci857189e2020-09-01 13:26:36 +02001044static ly_bool
1045lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *cb_data)
Michal Vasko14654712020-02-06 08:35:21 +01001046{
1047 struct ly_ctx *ctx;
1048 struct lysc_node_list *slist;
1049 struct lyd_node *diter, *first, *second;
1050 struct lyd_value *val1, *val2;
1051 char *path1, *path2, *uniq_str, *ptr;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001052 LY_ARRAY_COUNT_TYPE u, v, action;
Michal Vasko14654712020-02-06 08:35:21 +01001053
1054 assert(val1_p && val2_p);
1055
1056 first = *((struct lyd_node **)val1_p);
1057 second = *((struct lyd_node **)val2_p);
Michal Vasko41e630c2021-07-23 12:47:18 +02001058 action = (uintptr_t)cb_data;
Michal Vasko14654712020-02-06 08:35:21 +01001059
1060 assert(first && (first->schema->nodetype == LYS_LIST));
1061 assert(second && (second->schema == first->schema));
1062
1063 ctx = first->schema->module->ctx;
1064
1065 slist = (struct lysc_node_list *)first->schema;
1066
1067 /* compare unique leaves */
1068 if (action > 0) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001069 u = action - 1;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001070 if (u < LY_ARRAY_COUNT(slist->uniques)) {
Michal Vasko14654712020-02-06 08:35:21 +01001071 goto uniquecheck;
1072 }
1073 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001074 LY_ARRAY_FOR(slist->uniques, u) {
Michal Vasko14654712020-02-06 08:35:21 +01001075uniquecheck:
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001076 LY_ARRAY_FOR(slist->uniques[u], v) {
Michal Vasko14654712020-02-06 08:35:21 +01001077 /* first */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001078 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], first);
Michal Vasko14654712020-02-06 08:35:21 +01001079 if (diter) {
1080 val1 = &((struct lyd_node_term *)diter)->value;
1081 } else {
1082 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001083 val1 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001084 }
1085
1086 /* second */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001087 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], second);
Michal Vasko14654712020-02-06 08:35:21 +01001088 if (diter) {
1089 val2 = &((struct lyd_node_term *)diter)->value;
1090 } else {
1091 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001092 val2 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001093 }
1094
1095 if (!val1 || !val2 || val1->realtype->plugin->compare(val1, val2)) {
1096 /* values differ or either one is not set */
1097 break;
1098 }
1099 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001100 if (v && (v == LY_ARRAY_COUNT(slist->uniques[u]))) {
Michal Vasko14654712020-02-06 08:35:21 +01001101 /* all unique leafs are the same in this set, create this nice error */
Radek Krejci635d2b82021-01-04 11:26:51 +01001102 path1 = lyd_path(first, LYD_PATH_STD, NULL, 0);
1103 path2 = lyd_path(second, LYD_PATH_STD, NULL, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001104
1105 /* use buffer to rebuild the unique string */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001106#define UNIQ_BUF_SIZE 1024
1107 uniq_str = malloc(UNIQ_BUF_SIZE);
Michal Vasko14654712020-02-06 08:35:21 +01001108 uniq_str[0] = '\0';
1109 ptr = uniq_str;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001110 LY_ARRAY_FOR(slist->uniques[u], v) {
1111 if (v) {
Michal Vasko14654712020-02-06 08:35:21 +01001112 strcpy(ptr, " ");
1113 ++ptr;
1114 }
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001115 ptr = lysc_path_until((struct lysc_node *)slist->uniques[u][v], &slist->node, LYSC_PATH_LOG,
Radek Krejcif13b87b2020-12-01 22:02:17 +01001116 ptr, UNIQ_BUF_SIZE - (ptr - uniq_str));
Michal Vasko14654712020-02-06 08:35:21 +01001117 if (!ptr) {
1118 /* path will be incomplete, whatever */
1119 break;
1120 }
1121
1122 ptr += strlen(ptr);
1123 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001124 LOG_LOCSET(NULL, second, NULL, NULL);
Michal Vaskoe9391c72021-10-05 10:04:56 +02001125 LOGVAL_APPTAG(ctx, "data-not-unique", LY_VCODE_NOUNIQ, uniq_str, path1, path2);
Radek Krejciddace2c2021-01-08 11:30:56 +01001126 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001127
1128 free(path1);
1129 free(path2);
1130 free(uniq_str);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001131#undef UNIQ_BUF_SIZE
1132
Michal Vasko14654712020-02-06 08:35:21 +01001133 return 1;
1134 }
1135
1136 if (action > 0) {
1137 /* done */
1138 return 0;
1139 }
1140 }
1141
1142 return 0;
1143}
1144
Michal Vaskobb844672020-07-03 11:06:12 +02001145/**
1146 * @brief Validate list unique leaves.
1147 *
1148 * @param[in] first First sibling to search in.
1149 * @param[in] snode Schema node to validate.
1150 * @param[in] uniques List unique arrays to validate.
1151 * @return LY_ERR value.
1152 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001153static LY_ERR
Michal Vaskobb844672020-07-03 11:06:12 +02001154lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode, const struct lysc_node_leaf ***uniques)
Michal Vaskoa3881362020-01-21 15:57:35 +01001155{
Michal Vaskob1b5c262020-03-05 14:29:47 +01001156 const struct lyd_node *diter;
Michal Vasko14654712020-02-06 08:35:21 +01001157 struct ly_set *set;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001158 LY_ARRAY_COUNT_TYPE u, v, x = 0;
Michal Vasko14654712020-02-06 08:35:21 +01001159 LY_ERR ret = LY_SUCCESS;
Michal Vasko626196f2022-08-05 12:49:52 +02001160 uint32_t hash, i;
Radek Krejci813c02d2021-04-26 10:29:19 +02001161 size_t key_len;
1162 ly_bool dyn;
1163 const void *hash_key;
Michal Vasko41e630c2021-07-23 12:47:18 +02001164 void *cb_data;
Michal Vasko14654712020-02-06 08:35:21 +01001165 struct hash_table **uniqtables = NULL;
1166 struct lyd_value *val;
1167 struct ly_ctx *ctx = snode->module->ctx;
1168
1169 assert(uniques);
1170
1171 /* get all list instances */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001172 LY_CHECK_RET(ly_set_new(&set));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001173 LY_LIST_FOR(first, diter) {
Michal Vasko9b368d32020-02-14 13:53:31 +01001174 if (diter->schema == snode) {
Radek Krejci3d92e442020-10-12 12:48:13 +02001175 ret = ly_set_add(set, (void *)diter, 1, NULL);
Michal Vaskob0099a92020-08-31 14:55:23 +02001176 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko9b368d32020-02-14 13:53:31 +01001177 }
1178 }
Michal Vasko14654712020-02-06 08:35:21 +01001179
1180 if (set->count == 2) {
1181 /* simple comparison */
1182 if (lyd_val_uniq_list_equal(&set->objs[0], &set->objs[1], 0, (void *)0)) {
1183 /* instance duplication */
1184 ret = LY_EVALID;
1185 goto cleanup;
1186 }
1187 } else if (set->count > 2) {
1188 /* use hashes for comparison */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001189 uniqtables = malloc(LY_ARRAY_COUNT(uniques) * sizeof *uniqtables);
Michal Vasko14654712020-02-06 08:35:21 +01001190 LY_CHECK_ERR_GOTO(!uniqtables, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001191 x = LY_ARRAY_COUNT(uniques);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001192 for (v = 0; v < x; v++) {
Michal Vasko41e630c2021-07-23 12:47:18 +02001193 cb_data = (void *)(uintptr_t)(v + 1L);
Michal Vasko626196f2022-08-05 12:49:52 +02001194 uniqtables[v] = lyht_new(lyht_get_fixed_size(set->count), sizeof(struct lyd_node *),
1195 lyd_val_uniq_list_equal, cb_data, 0);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001196 LY_CHECK_ERR_GOTO(!uniqtables[v], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001197 }
1198
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001199 for (i = 0; i < set->count; i++) {
Michal Vasko14654712020-02-06 08:35:21 +01001200 /* loop for unique - get the hash for the instances */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001201 for (u = 0; u < x; u++) {
Michal Vasko14654712020-02-06 08:35:21 +01001202 val = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001203 for (v = hash = 0; v < LY_ARRAY_COUNT(uniques[u]); v++) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001204 diter = lyd_val_uniq_find_leaf(uniques[u][v], set->objs[i]);
Michal Vasko14654712020-02-06 08:35:21 +01001205 if (diter) {
1206 val = &((struct lyd_node_term *)diter)->value;
1207 } else {
1208 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001209 val = uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001210 }
1211 if (!val) {
1212 /* unique item not present nor has default value */
1213 break;
1214 }
1215
Radek Krejci813c02d2021-04-26 10:29:19 +02001216 /* get hash key */
Michal Vaskodcfac2c2021-05-10 11:36:37 +02001217 hash_key = val->realtype->plugin->print(NULL, val, LY_VALUE_LYB, NULL, &dyn, &key_len);
Radek Krejci813c02d2021-04-26 10:29:19 +02001218 hash = dict_hash_multi(hash, hash_key, key_len);
1219 if (dyn) {
1220 free((void *)hash_key);
Michal Vasko14654712020-02-06 08:35:21 +01001221 }
1222 }
1223 if (!val) {
1224 /* skip this list instance since its unique set is incomplete */
1225 continue;
1226 }
1227
1228 /* finish the hash value */
1229 hash = dict_hash_multi(hash, NULL, 0);
1230
1231 /* insert into the hashtable */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001232 ret = lyht_insert(uniqtables[u], &set->objs[i], hash, NULL);
Michal Vasko14654712020-02-06 08:35:21 +01001233 if (ret == LY_EEXIST) {
1234 /* instance duplication */
1235 ret = LY_EVALID;
1236 }
1237 LY_CHECK_GOTO(ret != LY_SUCCESS, cleanup);
1238 }
1239 }
1240 }
1241
1242cleanup:
1243 ly_set_free(set, NULL);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001244 for (v = 0; v < x; v++) {
1245 if (!uniqtables[v]) {
Michal Vasko14654712020-02-06 08:35:21 +01001246 /* failed when allocating uniquetables[j], following j are not allocated */
1247 break;
1248 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001249 lyht_free(uniqtables[v]);
Michal Vasko14654712020-02-06 08:35:21 +01001250 }
1251 free(uniqtables);
1252
1253 return ret;
Michal Vaskoa3881362020-01-21 15:57:35 +01001254}
1255
Michal Vaskobb844672020-07-03 11:06:12 +02001256/**
1257 * @brief Validate data siblings based on generic schema node restrictions, recursively for schema-only nodes.
1258 *
1259 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +01001260 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +02001261 * @param[in] sparent Schema parent of the nodes to check.
1262 * @param[in] mod Module of the nodes to check.
1263 * @param[in] val_opts Validation options, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +01001264 * @param[in] int_opts Internal parser options.
Michal Vaskobb844672020-07-03 11:06:12 +02001265 * @return LY_ERR value.
1266 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001267static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001268lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lyd_node *parent,
Michal Vaskoe0665742021-02-11 11:08:44 +01001269 const struct lysc_node *sparent, const struct lysc_module *mod, uint32_t val_opts, uint32_t int_opts)
Michal Vaskocde73ac2019-11-14 16:10:27 +01001270{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001271 LY_ERR ret = LY_SUCCESS;
Michal Vasko6c16cda2021-02-04 11:05:52 +01001272 const struct lysc_node *snode = NULL, *scase;
Michal Vaskoa3881362020-01-21 15:57:35 +01001273 struct lysc_node_list *slist;
Michal Vaskod8958df2020-08-05 13:27:36 +02001274 struct lysc_node_leaflist *sllist;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001275 uint32_t getnext_opts;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001276
Michal Vaskoe0665742021-02-11 11:08:44 +01001277 getnext_opts = LYS_GETNEXT_WITHCHOICE | (int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001278
Michal Vaskoa3881362020-01-21 15:57:35 +01001279 /* disabled nodes are skipped by lys_getnext */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001280 while ((snode = lys_getnext(snode, sparent, mod, getnext_opts))) {
Radek Krejci7931b192020-06-25 17:05:03 +02001281 if ((val_opts & LYD_VALIDATE_NO_STATE) && (snode->flags & LYS_CONFIG_R)) {
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001282 continue;
1283 }
1284
Radek Krejciddace2c2021-01-08 11:30:56 +01001285 LOG_LOCSET(snode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001286
Michal Vaskoa3881362020-01-21 15:57:35 +01001287 /* check min-elements and max-elements */
Michal Vaskod8958df2020-08-05 13:27:36 +02001288 if (snode->nodetype == LYS_LIST) {
Michal Vaskoa3881362020-01-21 15:57:35 +01001289 slist = (struct lysc_node_list *)snode;
1290 if (slist->min || slist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001291 ret = lyd_validate_minmax(first, parent, snode, slist->min, slist->max);
1292 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001293 }
Michal Vaskod8958df2020-08-05 13:27:36 +02001294 } else if (snode->nodetype == LYS_LEAFLIST) {
1295 sllist = (struct lysc_node_leaflist *)snode;
1296 if (sllist->min || sllist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001297 ret = lyd_validate_minmax(first, parent, snode, sllist->min, sllist->max);
1298 LY_CHECK_GOTO(ret, error);
Michal Vaskod8958df2020-08-05 13:27:36 +02001299 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001300
Michal Vaskoacd83e72020-02-04 14:12:01 +01001301 } else if (snode->flags & LYS_MAND_TRUE) {
Radek Krejcif6a11002020-08-21 13:29:07 +02001302 /* check generic mandatory existence */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001303 ret = lyd_validate_mandatory(first, parent, snode);
1304 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001305 }
1306
1307 /* check unique */
1308 if (snode->nodetype == LYS_LIST) {
1309 slist = (struct lysc_node_list *)snode;
1310 if (slist->uniques) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001311 ret = lyd_validate_unique(first, snode, (const struct lysc_node_leaf ***)slist->uniques);
1312 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001313 }
1314 }
1315
Michal Vasko6c16cda2021-02-04 11:05:52 +01001316 if (snode->nodetype == LYS_CHOICE) {
1317 /* find the existing case, if any */
1318 LY_LIST_FOR(lysc_node_child(snode), scase) {
1319 if (lys_getnext_data(NULL, first, NULL, scase, NULL)) {
1320 /* validate only this case */
Michal Vaskoe0665742021-02-11 11:08:44 +01001321 ret = lyd_validate_siblings_schema_r(first, parent, scase, mod, val_opts, int_opts);
Michal Vasko6c16cda2021-02-04 11:05:52 +01001322 LY_CHECK_GOTO(ret, error);
1323 break;
1324 }
1325 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001326 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001327
Radek Krejciddace2c2021-01-08 11:30:56 +01001328 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001329 }
1330
Michal Vaskoacd83e72020-02-04 14:12:01 +01001331 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001332
1333error:
Radek Krejciddace2c2021-01-08 11:30:56 +01001334 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001335 return ret;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001336}
1337
Michal Vaskobb844672020-07-03 11:06:12 +02001338/**
1339 * @brief Validate obsolete nodes, only warnings are printed.
1340 *
1341 * @param[in] node Node to check.
1342 */
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001343static void
1344lyd_validate_obsolete(const struct lyd_node *node)
1345{
1346 const struct lysc_node *snode;
1347
1348 snode = node->schema;
1349 do {
1350 if (snode->flags & LYS_STATUS_OBSLT) {
1351 LOGWRN(snode->module->ctx, "Obsolete schema node \"%s\" instantiated in data.", snode->name);
1352 break;
1353 }
1354
1355 snode = snode->parent;
1356 } while (snode && (snode->nodetype & (LYS_CHOICE | LYS_CASE)));
1357}
1358
Michal Vaskobb844672020-07-03 11:06:12 +02001359/**
1360 * @brief Validate must conditions of a data node.
1361 *
1362 * @param[in] node Node to validate.
Michal Vaskoe0665742021-02-11 11:08:44 +01001363 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001364 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobb844672020-07-03 11:06:12 +02001365 * @return LY_ERR value.
1366 */
Michal Vaskocc048b22020-03-27 15:52:38 +01001367static LY_ERR
Michal Vasko906bafa2022-04-22 12:28:55 +02001368lyd_validate_must(const struct lyd_node *node, uint32_t int_opts, uint32_t xpath_options)
Michal Vaskocc048b22020-03-27 15:52:38 +01001369{
Michal Vaskoa1db2342021-07-19 12:23:23 +02001370 LY_ERR ret;
Michal Vaskocc048b22020-03-27 15:52:38 +01001371 struct lyxp_set xp_set;
1372 struct lysc_must *musts;
1373 const struct lyd_node *tree;
Radek Krejci9a3823e2021-01-27 20:26:46 +01001374 const struct lysc_node *schema;
Michal Vaskoe9391c72021-10-05 10:04:56 +02001375 const char *emsg, *eapptag;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001376 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocc048b22020-03-27 15:52:38 +01001377
Michal Vaskoe0665742021-02-11 11:08:44 +01001378 assert((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) != (LYD_INTOPT_RPC | LYD_INTOPT_REPLY));
1379 assert((int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) != (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY));
1380
Radek Krejci9a3823e2021-01-27 20:26:46 +01001381 if (node->schema->nodetype & (LYS_ACTION | LYS_RPC)) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001382 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001383 schema = &((struct lysc_node_action *)node->schema)->input.node;
Michal Vaskoe0665742021-02-11 11:08:44 +01001384 } else if (int_opts & LYD_INTOPT_REPLY) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001385 schema = &((struct lysc_node_action *)node->schema)->output.node;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001386 } else {
Michal Vaskoa1db2342021-07-19 12:23:23 +02001387 LOGINT_RET(LYD_CTX(node));
Michal Vaskocb7526d2020-03-30 15:08:26 +02001388 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001389 } else {
1390 schema = node->schema;
Michal Vaskocc048b22020-03-27 15:52:38 +01001391 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001392 musts = lysc_node_musts(schema);
Michal Vaskocc048b22020-03-27 15:52:38 +01001393 if (!musts) {
1394 /* no must to evaluate */
1395 return LY_SUCCESS;
1396 }
1397
1398 /* find first top-level node */
Michal Vasko9e685082021-01-29 14:49:09 +01001399 for (tree = node; tree->parent; tree = lyd_parent(tree)) {}
Michal Vaskof9221e62021-02-04 12:10:14 +01001400 tree = lyd_first_sibling(tree);
Michal Vaskocc048b22020-03-27 15:52:38 +01001401
1402 LY_ARRAY_FOR(musts, u) {
1403 memset(&xp_set, 0, sizeof xp_set);
1404
1405 /* evaluate must */
Michal Vaskoa1db2342021-07-19 12:23:23 +02001406 ret = lyxp_eval(LYD_CTX(node), musts[u].cond, node->schema->module, LY_VALUE_SCHEMA_RESOLVED,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02001407 musts[u].prefixes, node, node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskoa1db2342021-07-19 12:23:23 +02001408 if (ret == LY_EINCOMPLETE) {
1409 LOGINT_RET(LYD_CTX(node));
1410 } else if (ret) {
1411 return ret;
1412 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001413
1414 /* check the result */
1415 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02001416 if (!xp_set.val.bln) {
Michal Vaskoe9391c72021-10-05 10:04:56 +02001417 /* use specific error information */
1418 emsg = musts[u].emsg;
1419 eapptag = musts[u].eapptag ? musts[u].eapptag : "must-violation";
1420 if (emsg) {
1421 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LYVE_DATA, "%s", emsg);
1422 } else {
1423 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LY_VCODE_NOMUST, musts[u].cond->expr);
1424 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001425 return LY_EVALID;
1426 }
1427 }
1428
1429 return LY_SUCCESS;
1430}
1431
Michal Vaskoe0665742021-02-11 11:08:44 +01001432/**
1433 * @brief Perform all remaining validation tasks, the data tree must be final when calling this function.
1434 *
1435 * @param[in] first First sibling.
1436 * @param[in] parent Data parent.
1437 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
1438 * @param[in] mod Module of the siblings, NULL for nested siblings.
1439 * @param[in] val_opts Validation options (@ref datavalidationoptions).
1440 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001441 * @param[in] must_xp_opts Additional XPath options to use for evaluating "must".
Michal Vaskoe0665742021-02-11 11:08:44 +01001442 * @return LY_ERR value.
1443 */
1444static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001445lyd_validate_final_r(struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *sparent,
Michal Vasko906bafa2022-04-22 12:28:55 +02001446 const struct lys_module *mod, uint32_t val_opts, uint32_t int_opts, uint32_t must_xp_opts)
Michal Vaskoacd83e72020-02-04 14:12:01 +01001447{
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001448 LY_ERR r;
1449 const char *innode;
Radek Krejci7f769d72020-07-11 23:13:56 +02001450 struct lyd_node *next = NULL, *node;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001451
Michal Vasko14654712020-02-06 08:35:21 +01001452 /* validate all restrictions of nodes themselves */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001453 LY_LIST_FOR_SAFE(first, next, node) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001454 if (node->flags & LYD_EXT) {
1455 /* ext instance data should have already been validated */
1456 continue;
1457 }
1458
Radek Krejciddace2c2021-01-08 11:30:56 +01001459 LOG_LOCSET(node->schema, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001460
Michal Vaskoa8c61722020-03-27 16:59:32 +01001461 /* opaque data */
1462 if (!node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001463 r = lyd_parse_opaq_error(node);
Michal Vasko6344e7a2022-05-10 10:08:53 +02001464 LOG_LOCBACK(0, 1, 0, 0);
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001465 return r;
Michal Vaskoa8c61722020-03-27 16:59:32 +01001466 }
1467
Michal Vasko6344e7a2022-05-10 10:08:53 +02001468 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1469 /* all top-level data from this module checked */
1470 LOG_LOCBACK(1, 1, 0, 0);
1471 break;
1472 }
1473
Michal Vasko8d289f92021-12-02 10:11:00 +01001474 /* no state/input/output/op data */
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001475 innode = NULL;
Radek Krejci7931b192020-06-25 17:05:03 +02001476 if ((val_opts & LYD_VALIDATE_NO_STATE) && (node->schema->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001477 innode = "state";
Michal Vaskoe0665742021-02-11 11:08:44 +01001478 } else if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) && (node->schema->flags & LYS_IS_OUTPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001479 innode = "output";
Michal Vaskoe0665742021-02-11 11:08:44 +01001480 } else if ((int_opts & LYD_INTOPT_REPLY) && (node->schema->flags & LYS_IS_INPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001481 innode = "input";
Michal Vasko8d289f92021-12-02 10:11:00 +01001482 } else if (!(int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_RPC)) {
1483 innode = "rpc";
1484 } else if (!(int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_ACTION)) {
1485 innode = "action";
1486 } else if (!(int_opts & LYD_INTOPT_NOTIF) && (node->schema->nodetype == LYS_NOTIF)) {
1487 innode = "notification";
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001488 }
1489 if (innode) {
1490 LOGVAL(LYD_CTX(node), LY_VCODE_UNEXPNODE, innode, node->schema->name);
1491 LOG_LOCBACK(1, 1, 0, 0);
1492 return LY_EVALID;
Michal Vasko5b37a352020-03-06 13:38:33 +01001493 }
1494
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001495 /* obsolete data */
1496 lyd_validate_obsolete(node);
1497
Michal Vaskocc048b22020-03-27 15:52:38 +01001498 /* node's musts */
Michal Vasko906bafa2022-04-22 12:28:55 +02001499 if ((r = lyd_validate_must(node, int_opts, must_xp_opts))) {
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001500 LOG_LOCBACK(1, 1, 0, 0);
1501 return r;
1502 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001503
Michal Vasko53d97a12020-11-05 17:39:10 +01001504 /* node value was checked by plugins */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001505
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001506 /* next iter */
Radek Krejciddace2c2021-01-08 11:30:56 +01001507 LOG_LOCBACK(1, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001508 }
Michal Vaskocde73ac2019-11-14 16:10:27 +01001509
Michal Vasko14654712020-02-06 08:35:21 +01001510 /* validate schema-based restrictions */
Michal Vaskoe0665742021-02-11 11:08:44 +01001511 LY_CHECK_RET(lyd_validate_siblings_schema_r(first, parent, sparent, mod ? mod->compiled : NULL, val_opts, int_opts));
Michal Vasko14654712020-02-06 08:35:21 +01001512
Michal Vaskob1b5c262020-03-05 14:29:47 +01001513 LY_LIST_FOR(first, node) {
Michal Vasko19034e22021-07-19 12:24:14 +02001514 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1515 /* all top-level data from this module checked */
1516 break;
1517 }
1518
Michal Vasko14654712020-02-06 08:35:21 +01001519 /* validate all children recursively */
Michal Vasko906bafa2022-04-22 12:28:55 +02001520 LY_CHECK_RET(lyd_validate_final_r(lyd_child(node), node, node->schema, NULL, val_opts, int_opts, must_xp_opts));
Michal Vaskocde73ac2019-11-14 16:10:27 +01001521
Michal Vaskob1b5c262020-03-05 14:29:47 +01001522 /* set default for containers */
Michal Vasko4754d4a2022-12-01 10:11:21 +01001523 lyd_cont_set_dflt(node);
Michal Vasko9b368d32020-02-14 13:53:31 +01001524 }
1525
1526 return LY_SUCCESS;
1527}
1528
Radek Krejci7931b192020-06-25 17:05:03 +02001529/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001530 * @brief Validate extension instance data by storing it in its unres set.
1531 *
1532 * @param[in] sibling First sibling with ::LYD_EXT flag, all the following ones are expected to have it, too.
1533 * @param[in,out] ext_val Set with parsed extension instance data to validate.
1534 * @return LY_ERR value.
1535 */
1536static LY_ERR
1537lyd_validate_nested_ext(struct lyd_node *sibling, struct ly_set *ext_val)
1538{
1539 struct lyd_node *node;
1540 struct lyd_ctx_ext_val *ext_v;
1541 struct lysc_ext_instance *nested_exts, *ext = NULL;
1542 LY_ARRAY_COUNT_TYPE u;
1543
1544 /* check of basic assumptions */
1545 if (!sibling->parent || !sibling->parent->schema) {
1546 LOGINT_RET(LYD_CTX(sibling));
1547 }
1548 LY_LIST_FOR(sibling, node) {
1549 if (!(node->flags & LYD_EXT)) {
1550 LOGINT_RET(LYD_CTX(sibling));
1551 }
1552 }
1553
1554 /* try to find the extension instance */
1555 nested_exts = sibling->parent->schema->exts;
1556 LY_ARRAY_FOR(nested_exts, u) {
1557 if (nested_exts[u].def->plugin->validate) {
1558 if (ext) {
1559 /* more extension instances with validate callback */
1560 LOGINT_RET(LYD_CTX(sibling));
1561 }
1562 ext = &nested_exts[u];
1563 }
1564 }
1565 if (!ext) {
1566 /* no extension instance with validate callback */
1567 LOGINT_RET(LYD_CTX(sibling));
1568 }
1569
1570 /* store for validation */
1571 ext_v = malloc(sizeof *ext_v);
1572 LY_CHECK_ERR_RET(!ext_v, LOGMEM(LYD_CTX(sibling)), LY_EMEM);
1573 ext_v->ext = ext;
1574 ext_v->sibling = sibling;
1575 LY_CHECK_RET(ly_set_add(ext_val, ext_v, 1, NULL));
1576
1577 return LY_SUCCESS;
1578}
1579
Michal Vasko135719f2022-08-25 12:18:17 +02001580LY_ERR
1581lyd_validate_node_ext(struct lyd_node *node, struct ly_set *ext_node)
1582{
1583 struct lyd_ctx_ext_node *ext_n;
1584 struct lysc_ext_instance *exts;
1585 LY_ARRAY_COUNT_TYPE u;
1586
1587 /* try to find a relevant extension instance with node callback */
1588 exts = node->schema->exts;
1589 LY_ARRAY_FOR(exts, u) {
1590 if (exts[u].def->plugin && exts[u].def->plugin->node) {
1591 /* store for validation */
1592 ext_n = malloc(sizeof *ext_n);
1593 LY_CHECK_ERR_RET(!ext_n, LOGMEM(LYD_CTX(node)), LY_EMEM);
1594 ext_n->ext = &exts[u];
1595 ext_n->node = node;
1596 LY_CHECK_RET(ly_set_add(ext_node, ext_n, 1, NULL));
1597 }
1598 }
1599
1600 return LY_SUCCESS;
1601}
1602
Michal Vaskoddd76592022-01-17 13:34:48 +01001603/**
Michal Vaskobb844672020-07-03 11:06:12 +02001604 * @brief Validate the whole data subtree.
1605 *
1606 * @param[in] root Subtree root.
Michal Vaskoe0665742021-02-11 11:08:44 +01001607 * @param[in,out] node_when Set for nodes with when conditions.
Michal Vasko32711382020-12-03 14:14:31 +01001608 * @param[in,out] node_types Set for unres node types.
1609 * @param[in,out] meta_types Set for unres metadata types.
Michal Vasko1a6e6902022-08-26 08:35:09 +02001610 * @param[in,out] ext_node Set with nodes with extensions to validate.
Michal Vaskoddd76592022-01-17 13:34:48 +01001611 * @param[in,out] ext_val Set for parsed extension data to validate.
Michal Vasko29adfbe2020-12-08 17:12:03 +01001612 * @param[in] impl_opts Implicit options, see @ref implicitoptions.
Michal Vasko8104fd42020-07-13 11:09:51 +02001613 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +02001614 * @return LY_ERR value.
Radek Krejci7931b192020-06-25 17:05:03 +02001615 */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001616static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001617lyd_validate_subtree(struct lyd_node *root, struct ly_set *node_when, struct ly_set *node_types,
Michal Vasko1a6e6902022-08-26 08:35:09 +02001618 struct ly_set *meta_types, struct ly_set *ext_node, struct ly_set *ext_val, uint32_t impl_opts,
1619 struct lyd_node **diff)
Michal Vaskofea12c62020-03-30 11:00:15 +02001620{
1621 const struct lyd_meta *meta;
Michal Vasko193dacd2022-10-13 08:43:05 +02001622 const struct lysc_type *type;
Michal Vasko56daf732020-08-10 10:57:18 +02001623 struct lyd_node *node;
Michal Vaskofea12c62020-03-30 11:00:15 +02001624
Michal Vasko56daf732020-08-10 10:57:18 +02001625 LYD_TREE_DFS_BEGIN(root, node) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001626 if (node->flags & LYD_EXT) {
1627 /* validate using the extension instance callback */
1628 return lyd_validate_nested_ext(node, ext_val);
1629 }
1630
Michal Vasko5900da42021-08-04 11:02:43 +02001631 if (!node->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001632 /* do not validate opaque nodes */
aPiecek18a844e2021-08-10 11:06:24 +02001633 goto next_node;
Michal Vasko5900da42021-08-04 11:02:43 +02001634 }
1635
Michal Vasko0275cf62020-11-05 17:40:30 +01001636 LY_LIST_FOR(node->meta, meta) {
Michal Vaskofbd037c2022-11-08 10:34:20 +01001637 lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type);
Michal Vasko193dacd2022-10-13 08:43:05 +02001638 if (type->plugin->validate) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001639 /* metadata type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001640 LY_CHECK_RET(ly_set_add(meta_types, (void *)meta, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001641 }
Michal Vasko0275cf62020-11-05 17:40:30 +01001642 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001643
Michal Vasko0275cf62020-11-05 17:40:30 +01001644 if ((node->schema->nodetype & LYD_NODE_TERM) && ((struct lysc_node_leaf *)node->schema)->type->plugin->validate) {
1645 /* node type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001646 LY_CHECK_RET(ly_set_add(node_types, (void *)node, 1, NULL));
Michal Vasko0275cf62020-11-05 17:40:30 +01001647 } else if (node->schema->nodetype & LYD_NODE_INNER) {
1648 /* new node validation, autodelete */
Michal Vaskoe0665742021-02-11 11:08:44 +01001649 LY_CHECK_RET(lyd_validate_new(lyd_node_child_p(node), node->schema, NULL, diff));
Michal Vaskofea12c62020-03-30 11:00:15 +02001650
Michal Vasko0275cf62020-11-05 17:40:30 +01001651 /* add nested defaults */
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001652 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, NULL, NULL, NULL, impl_opts, diff));
Michal Vasko0275cf62020-11-05 17:40:30 +01001653 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001654
Michal Vaskof4d67ea2021-03-31 13:53:21 +02001655 if (lysc_has_when(node->schema)) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001656 /* when evaluation */
Michal Vasko32711382020-12-03 14:14:31 +01001657 LY_CHECK_RET(ly_set_add(node_when, (void *)node, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001658 }
1659
Michal Vasko1a6e6902022-08-26 08:35:09 +02001660 /* store for ext instance node validation, if needed */
1661 LY_CHECK_RET(lyd_validate_node_ext(node, ext_node));
1662
aPiecek18a844e2021-08-10 11:06:24 +02001663next_node:
Michal Vasko56daf732020-08-10 10:57:18 +02001664 LYD_TREE_DFS_END(root, node);
Michal Vaskofea12c62020-03-30 11:00:15 +02001665 }
1666
1667 return LY_SUCCESS;
1668}
1669
Michal Vaskoe0665742021-02-11 11:08:44 +01001670LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001671lyd_validate(struct lyd_node **tree, const struct lys_module *module, const struct ly_ctx *ctx, uint32_t val_opts,
Michal Vaskoddd76592022-01-17 13:34:48 +01001672 ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p, struct ly_set *meta_types_p,
Michal Vasko135719f2022-08-25 12:18:17 +02001673 struct ly_set *ext_node_p, struct ly_set *ext_val_p, struct lyd_node **diff)
Michal Vaskof03ed032020-03-04 13:31:44 +01001674{
1675 LY_ERR ret = LY_SUCCESS;
Michal Vasko73e47212020-12-03 14:20:16 +01001676 struct lyd_node *first, *next, **first2, *iter;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001677 const struct lys_module *mod;
Michal Vasko135719f2022-08-25 12:18:17 +02001678 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_node = {0}, ext_val = {0};
Michal Vaskob1b5c262020-03-05 14:29:47 +01001679 uint32_t i = 0;
Michal Vaskof03ed032020-03-04 13:31:44 +01001680
Michal Vaskoe0665742021-02-11 11:08:44 +01001681 assert(tree && ctx);
Michal Vasko135719f2022-08-25 12:18:17 +02001682 assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) ||
1683 (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001684
1685 if (!node_when_p) {
1686 node_when_p = &node_when;
1687 node_types_p = &node_types;
1688 meta_types_p = &meta_types;
Michal Vasko135719f2022-08-25 12:18:17 +02001689 ext_node_p = &ext_node;
Michal Vaskoddd76592022-01-17 13:34:48 +01001690 ext_val_p = &ext_val;
Michal Vasko8104fd42020-07-13 11:09:51 +02001691 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001692
Michal Vaskob1b5c262020-03-05 14:29:47 +01001693 next = *tree;
1694 while (1) {
Radek Krejci7931b192020-06-25 17:05:03 +02001695 if (val_opts & LYD_VALIDATE_PRESENT) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001696 mod = lyd_data_next_module(&next, &first);
1697 } else {
Michal Vasko26e80012020-07-08 10:55:46 +02001698 mod = lyd_mod_next_module(next, module, ctx, &i, &first);
Michal Vaskof03ed032020-03-04 13:31:44 +01001699 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001700 if (!mod) {
1701 break;
1702 }
Michal Vasko7c4cf1e2020-06-22 10:04:30 +02001703 if (!first || (first == *tree)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001704 /* make sure first2 changes are carried to tree */
1705 first2 = tree;
1706 } else {
1707 first2 = &first;
1708 }
1709
1710 /* validate new top-level nodes of this module, autodelete */
Michal Vasko8104fd42020-07-13 11:09:51 +02001711 ret = lyd_validate_new(first2, NULL, mod, diff);
1712 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001713
Radek Krejci7be7b9f2021-02-24 11:46:27 +01001714 /* add all top-level defaults for this module, if going to validate subtree, do not add into unres sets
1715 * (lyd_validate_subtree() adds all the nodes in that case) */
Michal Vaskoddd76592022-01-17 13:34:48 +01001716 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, validate_subtree ? NULL : node_when_p,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001717 validate_subtree ? NULL : node_types_p, validate_subtree ? NULL : ext_node_p,
1718 (val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, diff);
Michal Vasko8104fd42020-07-13 11:09:51 +02001719 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001720
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001721 /* our first module node pointer may no longer be the first */
Michal Vasko598063b2021-07-19 11:39:05 +02001722 first = *first2;
1723 lyd_first_module_sibling(&first, mod);
1724 if (!first || (first == *tree)) {
1725 first2 = tree;
1726 } else {
1727 first2 = &first;
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001728 }
1729
Michal Vaskoe0665742021-02-11 11:08:44 +01001730 if (validate_subtree) {
1731 /* process nested nodes */
1732 LY_LIST_FOR(*first2, iter) {
Michal Vasko0e72b7a2021-07-16 14:53:27 +02001733 if (lyd_owner_module(iter) != mod) {
1734 break;
1735 }
1736
Michal Vasko1a6e6902022-08-26 08:35:09 +02001737 ret = lyd_validate_subtree(iter, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p,
Michal Vaskoe0665742021-02-11 11:08:44 +01001738 (val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, diff);
1739 LY_CHECK_GOTO(ret, cleanup);
1740 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001741 }
1742
1743 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vasko135719f2022-08-25 12:18:17 +02001744 ret = lyd_validate_unres(first2, mod, LYD_TYPE_DATA_YANG, node_when_p, 0, node_types_p, meta_types_p,
1745 ext_node_p, ext_val_p, val_opts, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001746 LY_CHECK_GOTO(ret, cleanup);
1747
1748 /* perform final validation that assumes the data tree is final */
Michal Vasko906bafa2022-04-22 12:28:55 +02001749 ret = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +02001750 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskof03ed032020-03-04 13:31:44 +01001751 }
1752
Michal Vaskof03ed032020-03-04 13:31:44 +01001753cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001754 ly_set_erase(&node_when, NULL);
Michal Vasko32711382020-12-03 14:14:31 +01001755 ly_set_erase(&node_types, NULL);
1756 ly_set_erase(&meta_types, NULL);
Michal Vasko135719f2022-08-25 12:18:17 +02001757 ly_set_erase(&ext_node, free);
Michal Vaskoddd76592022-01-17 13:34:48 +01001758 ly_set_erase(&ext_val, free);
Michal Vaskof03ed032020-03-04 13:31:44 +01001759 return ret;
1760}
Michal Vaskob1b5c262020-03-05 14:29:47 +01001761
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001762LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001763lyd_validate_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t val_opts, struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +01001764{
Michal Vaskoe0665742021-02-11 11:08:44 +01001765 LY_CHECK_ARG_RET(NULL, tree, *tree || ctx, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001766 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001767 if (!ctx) {
1768 ctx = LYD_CTX(*tree);
1769 }
1770 if (diff) {
1771 *diff = NULL;
1772 }
1773
Michal Vasko135719f2022-08-25 12:18:17 +02001774 return lyd_validate(tree, NULL, ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001775}
1776
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001777LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001778lyd_validate_module(struct lyd_node **tree, const struct lys_module *module, uint32_t val_opts, struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +01001779{
Michal Vaskoe0665742021-02-11 11:08:44 +01001780 LY_CHECK_ARG_RET(NULL, tree, *tree || module, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001781 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module ? module->ctx : NULL, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001782 if (diff) {
1783 *diff = NULL;
1784 }
1785
Michal Vasko135719f2022-08-25 12:18:17 +02001786 return lyd_validate(tree, module, (*tree) ? LYD_CTX(*tree) : module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL,
1787 diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001788}
Michal Vaskofea12c62020-03-30 11:00:15 +02001789
Michal Vaskobb844672020-07-03 11:06:12 +02001790/**
1791 * @brief Find nodes for merging an operation into data tree for validation.
1792 *
1793 * @param[in] op_tree Full operation data tree.
1794 * @param[in] op_node Operation node itself.
1795 * @param[in] tree Data tree to be merged into.
1796 * @param[out] op_subtree Operation subtree to merge.
Michal Vasko2f03d222020-12-09 18:15:51 +01001797 * @param[out] tree_sibling Data tree sibling to merge next to, is set if @p tree_parent is NULL.
1798 * @param[out] tree_parent Data tree parent to merge into, is set if @p tree_sibling is NULL.
Michal Vaskobb844672020-07-03 11:06:12 +02001799 */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001800static void
Michal Vaskobb844672020-07-03 11:06:12 +02001801lyd_val_op_merge_find(const struct lyd_node *op_tree, const struct lyd_node *op_node, const struct lyd_node *tree,
Michal Vasko2f03d222020-12-09 18:15:51 +01001802 struct lyd_node **op_subtree, struct lyd_node **tree_sibling, struct lyd_node **tree_parent)
Michal Vaskofea12c62020-03-30 11:00:15 +02001803{
Michal Vaskocb7526d2020-03-30 15:08:26 +02001804 const struct lyd_node *tree_iter, *op_iter;
Michal Vaskob10c93b2022-12-14 12:16:27 +01001805 struct lyd_node *match = NULL;
Michal Vaskofea12c62020-03-30 11:00:15 +02001806 uint32_t i, cur_depth, op_depth;
Michal Vaskofea12c62020-03-30 11:00:15 +02001807
Michal Vasko2f03d222020-12-09 18:15:51 +01001808 *op_subtree = NULL;
1809 *tree_sibling = NULL;
1810 *tree_parent = NULL;
1811
Michal Vaskocb7526d2020-03-30 15:08:26 +02001812 /* learn op depth (top-level being depth 0) */
Michal Vaskofea12c62020-03-30 11:00:15 +02001813 op_depth = 0;
Michal Vasko9e685082021-01-29 14:49:09 +01001814 for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001815 ++op_depth;
1816 }
1817
1818 /* find where to merge op */
1819 tree_iter = tree;
1820 cur_depth = op_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001821 while (cur_depth && tree_iter) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001822 /* find op iter in tree */
1823 lyd_find_sibling_first(tree_iter, op_iter, &match);
1824 if (!match) {
1825 break;
1826 }
1827
1828 /* move tree_iter */
Radek Krejcia1c1e542020-09-29 16:06:52 +02001829 tree_iter = lyd_child(match);
Michal Vaskofea12c62020-03-30 11:00:15 +02001830
1831 /* move depth */
1832 --cur_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001833
1834 /* find next op parent */
1835 op_iter = op_node;
1836 for (i = 0; i < cur_depth; ++i) {
Michal Vasko9e685082021-01-29 14:49:09 +01001837 op_iter = lyd_parent(op_iter);
Michal Vasko2f03d222020-12-09 18:15:51 +01001838 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001839 }
1840
Michal Vasko2f03d222020-12-09 18:15:51 +01001841 assert(op_iter);
Michal Vaskobb844672020-07-03 11:06:12 +02001842 *op_subtree = (struct lyd_node *)op_iter;
Michal Vasko2f03d222020-12-09 18:15:51 +01001843 if (!tree || tree_iter) {
1844 /* there is no tree whatsoever or this is the last found sibling */
1845 *tree_sibling = (struct lyd_node *)tree_iter;
1846 } else {
1847 /* matching parent was found but it has no children to insert next to */
1848 assert(match);
1849 *tree_parent = match;
1850 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001851}
1852
Michal Vaskoe0665742021-02-11 11:08:44 +01001853/**
1854 * @brief Validate an RPC/action request, reply, or notification.
1855 *
1856 * @param[in] op_tree Full operation data tree.
1857 * @param[in] op_node Operation node itself.
1858 * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
1859 * @param[in] int_opts Internal parser options.
Michal Vaskofbbea932022-06-07 11:00:55 +02001860 * @param[in] data_type Type of validated data.
Michal Vaskoe0665742021-02-11 11:08:44 +01001861 * @param[in] validate_subtree Whether subtree was already validated (as part of data parsing) or not (separate validation).
1862 * @param[in] node_when_p Set of nodes with when conditions, if NULL a local set is used.
1863 * @param[in] node_types_p Set of unres node types, if NULL a local set is used.
1864 * @param[in] meta_types_p Set of unres metadata types, if NULL a local set is used.
Michal Vasko135719f2022-08-25 12:18:17 +02001865 * @param[in] ext_node_p Set of unres nodes with extensions to validate, if NULL a local set is used.
Michal Vaskoddd76592022-01-17 13:34:48 +01001866 * @param[in] ext_val_p Set of parsed extension data to validate, if NULL a local set is used.
Michal Vaskoe0665742021-02-11 11:08:44 +01001867 * @param[out] diff Optional diff with any changes made by the validation.
1868 * @return LY_SUCCESS on success.
1869 * @return LY_ERR error on error.
1870 */
1871static LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +02001872_lyd_validate_op(struct lyd_node *op_tree, struct lyd_node *op_node, const struct lyd_node *dep_tree, enum lyd_type data_type,
Michal Vaskoddd76592022-01-17 13:34:48 +01001873 uint32_t int_opts, ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p,
Michal Vasko135719f2022-08-25 12:18:17 +02001874 struct ly_set *meta_types_p, struct ly_set *ext_node_p, struct ly_set *ext_val_p, struct lyd_node **diff)
Michal Vaskocb7526d2020-03-30 15:08:26 +02001875{
Michal Vaskoe0665742021-02-11 11:08:44 +01001876 LY_ERR rc = LY_SUCCESS;
Michal Vaskofbbea932022-06-07 11:00:55 +02001877 struct lyd_node *tree_sibling, *tree_parent, *op_subtree, *op_parent, *op_sibling_before, *op_sibling_after, *child;
Michal Vasko135719f2022-08-25 12:18:17 +02001878 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_node = {0}, ext_val = {0};
Michal Vaskocb7526d2020-03-30 15:08:26 +02001879
Michal Vaskoe0665742021-02-11 11:08:44 +01001880 assert(op_tree && op_node);
Michal Vasko135719f2022-08-25 12:18:17 +02001881 assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) ||
1882 (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001883
1884 if (!node_when_p) {
1885 node_when_p = &node_when;
1886 node_types_p = &node_types;
1887 meta_types_p = &meta_types;
Michal Vasko135719f2022-08-25 12:18:17 +02001888 ext_node_p = &ext_node;
Michal Vaskoddd76592022-01-17 13:34:48 +01001889 ext_val_p = &ext_val;
Michal Vaskoe0665742021-02-11 11:08:44 +01001890 }
1891
1892 /* merge op_tree into dep_tree */
1893 lyd_val_op_merge_find(op_tree, op_node, dep_tree, &op_subtree, &tree_sibling, &tree_parent);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001894 op_sibling_before = op_subtree->prev->next ? op_subtree->prev : NULL;
1895 op_sibling_after = op_subtree->next;
Michal Vaskoe0665742021-02-11 11:08:44 +01001896 op_parent = lyd_parent(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001897
Michal Vaskoe0665742021-02-11 11:08:44 +01001898 lyd_unlink_tree(op_subtree);
Michal Vasko6ee6f432021-07-16 09:49:14 +02001899 lyd_insert_node(tree_parent, &tree_sibling, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001900 if (!dep_tree) {
1901 dep_tree = tree_sibling;
1902 }
1903
1904 LOG_LOCSET(NULL, op_node, NULL, NULL);
1905
1906 if (int_opts & LYD_INTOPT_REPLY) {
1907 /* add output children defaults */
Michal Vaskoddd76592022-01-17 13:34:48 +01001908 rc = lyd_new_implicit_r(op_node, lyd_node_child_p(op_node), NULL, NULL, node_when_p, node_types_p,
Michal Vaskofcbd78f2022-08-26 08:34:15 +02001909 ext_node_p, LYD_IMPLICIT_OUTPUT, diff);
Michal Vaskoe0665742021-02-11 11:08:44 +01001910 LY_CHECK_GOTO(rc, cleanup);
1911
1912 if (validate_subtree) {
1913 /* skip validating the operation itself, go to children directly */
1914 LY_LIST_FOR(lyd_child(op_node), child) {
Michal Vasko1a6e6902022-08-26 08:35:09 +02001915 rc = lyd_validate_subtree(child, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001916 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001917 }
1918 }
1919 } else {
1920 if (validate_subtree) {
1921 /* prevalidate whole operation subtree */
Michal Vasko1a6e6902022-08-26 08:35:09 +02001922 rc = lyd_validate_subtree(op_node, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001923 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001924 }
1925 }
1926
Michal Vasko906bafa2022-04-22 12:28:55 +02001927 /* finish incompletely validated terminal values/attributes and when conditions on the full tree,
1928 * account for unresolved 'when' that may appear in the non-validated dependency data tree */
Michal Vaskofbbea932022-06-07 11:00:55 +02001929 LY_CHECK_GOTO(rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, node_when_p, LYXP_IGNORE_WHEN,
Michal Vasko135719f2022-08-25 12:18:17 +02001930 node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001931
1932 /* perform final validation of the operation/notification */
1933 lyd_validate_obsolete(op_node);
Michal Vasko906bafa2022-04-22 12:28:55 +02001934 LY_CHECK_GOTO(rc = lyd_validate_must(op_node, int_opts, LYXP_IGNORE_WHEN), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001935
1936 /* final validation of all the descendants */
Michal Vasko906bafa2022-04-22 12:28:55 +02001937 rc = lyd_validate_final_r(lyd_child(op_node), op_node, op_node->schema, NULL, 0, int_opts, LYXP_IGNORE_WHEN);
1938 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001939
1940cleanup:
1941 LOG_LOCBACK(0, 1, 0, 0);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001942
Michal Vaskoe0665742021-02-11 11:08:44 +01001943 /* restore operation tree */
1944 lyd_unlink_tree(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001945 if (op_sibling_before) {
1946 lyd_insert_after_node(op_sibling_before, op_subtree);
1947 } else if (op_sibling_after) {
1948 lyd_insert_before_node(op_sibling_after, op_subtree);
1949 } else if (op_parent) {
Michal Vasko6ee6f432021-07-16 09:49:14 +02001950 lyd_insert_node(op_parent, NULL, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001951 }
1952
1953 ly_set_erase(&node_when, NULL);
1954 ly_set_erase(&node_types, NULL);
1955 ly_set_erase(&meta_types, NULL);
Michal Vasko135719f2022-08-25 12:18:17 +02001956 ly_set_erase(&ext_node, free);
Michal Vaskoddd76592022-01-17 13:34:48 +01001957 ly_set_erase(&ext_val, free);
Michal Vaskoe0665742021-02-11 11:08:44 +01001958 return rc;
1959}
1960
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001961LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01001962lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type, struct lyd_node **diff)
1963{
1964 struct lyd_node *op_node;
1965 uint32_t int_opts;
Michal Vaskofbbea932022-06-07 11:00:55 +02001966 struct ly_set ext_val = {0};
1967 LY_ERR rc;
Michal Vaskoe0665742021-02-11 11:08:44 +01001968
Michal Vasko2da45692022-04-29 09:51:08 +02001969 LY_CHECK_ARG_RET(NULL, op_tree, !dep_tree || !dep_tree->parent, (data_type == LYD_TYPE_RPC_YANG) ||
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001970 (data_type == LYD_TYPE_NOTIF_YANG) || (data_type == LYD_TYPE_REPLY_YANG), LY_EINVAL);
Michal Vasko8104fd42020-07-13 11:09:51 +02001971 if (diff) {
1972 *diff = NULL;
1973 }
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001974 if (data_type == LYD_TYPE_RPC_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001975 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001976 } else if (data_type == LYD_TYPE_NOTIF_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001977 int_opts = LYD_INTOPT_NOTIF;
1978 } else {
1979 int_opts = LYD_INTOPT_REPLY;
1980 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001981
Michal Vasko2da45692022-04-29 09:51:08 +02001982 if (op_tree->schema && (op_tree->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF))) {
1983 /* we have the operation/notification, adjust the pointers */
1984 op_node = op_tree;
1985 while (op_tree->parent) {
1986 op_tree = lyd_parent(op_tree);
Michal Vaskocb7526d2020-03-30 15:08:26 +02001987 }
Michal Vasko2da45692022-04-29 09:51:08 +02001988 } else {
1989 /* find the operation/notification */
1990 while (op_tree->parent) {
1991 op_tree = lyd_parent(op_tree);
1992 }
1993 LYD_TREE_DFS_BEGIN(op_tree, op_node) {
1994 if (!op_node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001995 return lyd_parse_opaq_error(op_node);
Michal Vaskofbbea932022-06-07 11:00:55 +02001996 } else if (op_node->flags & LYD_EXT) {
1997 /* fully validate the rest using the extension instance callback */
1998 LY_CHECK_RET(lyd_validate_nested_ext(op_node, &ext_val));
Michal Vasko135719f2022-08-25 12:18:17 +02001999 rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, NULL, 0, NULL, NULL, NULL,
2000 &ext_val, 0, diff);
Michal Vaskofbbea932022-06-07 11:00:55 +02002001 ly_set_erase(&ext_val, free);
2002 return rc;
Michal Vasko2da45692022-04-29 09:51:08 +02002003 }
2004
2005 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) &&
2006 (op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
2007 break;
2008 } else if ((int_opts & LYD_INTOPT_NOTIF) && (op_node->schema->nodetype == LYS_NOTIF)) {
2009 break;
2010 }
2011 LYD_TREE_DFS_END(op_tree, op_node);
2012 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02002013 }
Michal Vasko2da45692022-04-29 09:51:08 +02002014
Michal Vaskoe0665742021-02-11 11:08:44 +01002015 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) {
Michal Vasko9b232082022-06-07 10:59:31 +02002016 if (!op_node || !(op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002017 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No RPC/action to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02002018 return LY_EINVAL;
2019 }
2020 } else {
Michal Vasko9b232082022-06-07 10:59:31 +02002021 if (!op_node || (op_node->schema->nodetype != LYS_NOTIF)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002022 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No notification to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02002023 return LY_EINVAL;
2024 }
2025 }
2026
Michal Vaskoe0665742021-02-11 11:08:44 +01002027 /* validate */
Michal Vasko135719f2022-08-25 12:18:17 +02002028 return _lyd_validate_op(op_tree, op_node, dep_tree, data_type, int_opts, 1, NULL, NULL, NULL, NULL, NULL, diff);
Michal Vaskofea12c62020-03-30 11:00:15 +02002029}