blob: ecba13df8ecf8eba0df1f732612feac52df79c39 [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 Vaskoaf5a8dd2023-03-02 11:25:02 +01006 * Copyright (c) 2019 - 2023 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
Michal Vasko69730152020-10-09 16:30:07 +020025#include "compat.h"
Michal Vasko8104fd42020-07-13 11:09:51 +020026#include "diff.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020027#include "hash_table.h"
28#include "log.h"
Michal Vasko8f702ee2024-02-20 15:44:24 +010029#include "ly_common.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 Vaskod027f382023-02-10 09:13:25 +010043/**
44 * @brief Check validation error taking into account multi-error validation.
45 *
46 * @param[in] r Local return value.
47 * @param[in] err_cmd Command to perform on any error.
48 * @param[in] val_opts Validation options.
49 * @param[in] label Label to go to on fatal error.
50 */
51#define LY_VAL_ERR_GOTO(r, err_cmd, val_opts, label) \
52 if (r) { \
53 err_cmd; \
54 if ((r != LY_EVALID) || !(val_opts & LYD_VALIDATE_MULTI_ERROR)) { \
55 goto label; \
56 } \
57 }
58
Michal Vaskoa6669ba2020-08-06 16:14:26 +020059LY_ERR
Michal Vasko8104fd42020-07-13 11:09:51 +020060lyd_val_diff_add(const struct lyd_node *node, enum lyd_diff_op op, struct lyd_node **diff)
61{
62 LY_ERR ret = LY_SUCCESS;
63 struct lyd_node *new_diff = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010064 const struct lyd_node *prev_inst;
Michal Vaskoe78faec2021-04-08 17:24:43 +020065 char *key = NULL, *value = NULL, *position = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010066 size_t buflen = 0, bufused = 0;
Michal Vaskoe78faec2021-04-08 17:24:43 +020067 uint32_t pos;
Michal Vasko8104fd42020-07-13 11:09:51 +020068
69 assert((op == LYD_DIFF_OP_DELETE) || (op == LYD_DIFF_OP_CREATE));
70
Michal Vasko81bc5512020-11-13 18:05:18 +010071 if ((op == LYD_DIFF_OP_CREATE) && lysc_is_userordered(node->schema)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +020072 if (lysc_is_dup_inst_list(node->schema)) {
73 pos = lyd_list_pos(node);
Michal Vasko81bc5512020-11-13 18:05:18 +010074
Michal Vaskoe78faec2021-04-08 17:24:43 +020075 /* generate position meta */
76 if (pos > 1) {
77 if (asprintf(&position, "%" PRIu32, pos - 1) == -1) {
78 LOGMEM(LYD_CTX(node));
79 ret = LY_EMEM;
80 goto cleanup;
81 }
Michal Vasko81bc5512020-11-13 18:05:18 +010082 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020083 position = strdup("");
84 LY_CHECK_ERR_GOTO(!position, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
Michal Vasko81bc5512020-11-13 18:05:18 +010085 }
86 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020087 if (node->prev->next && (node->prev->schema == node->schema)) {
88 prev_inst = node->prev;
Michal Vasko81bc5512020-11-13 18:05:18 +010089 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020090 /* first instance */
91 prev_inst = NULL;
92 }
93
94 if (node->schema->nodetype == LYS_LIST) {
95 /* generate key meta */
96 if (prev_inst) {
97 LY_CHECK_GOTO(ret = lyd_path_list_predicate(prev_inst, &key, &buflen, &bufused, 0), cleanup);
98 } else {
99 key = strdup("");
100 LY_CHECK_ERR_GOTO(!key, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
101 }
102 } else {
103 /* generate value meta */
104 if (prev_inst) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200105 value = strdup(lyd_get_value(prev_inst));
Michal Vaskoe78faec2021-04-08 17:24:43 +0200106 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
107 } else {
108 value = strdup("");
109 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
110 }
Michal Vasko81bc5512020-11-13 18:05:18 +0100111 }
112 }
113 }
114
Michal Vasko8104fd42020-07-13 11:09:51 +0200115 /* create new diff tree */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200116 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 +0200117
118 /* merge into existing diff */
Michal Vaskoc0e58e82020-11-11 19:04:33 +0100119 ret = lyd_diff_merge_all(diff, new_diff, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +0200120
Michal Vasko81bc5512020-11-13 18:05:18 +0100121cleanup:
Michal Vasko8104fd42020-07-13 11:09:51 +0200122 lyd_free_tree(new_diff);
Michal Vasko81bc5512020-11-13 18:05:18 +0100123 free(key);
124 free(value);
Michal Vaskoe78faec2021-04-08 17:24:43 +0200125 free(position);
Michal Vasko8104fd42020-07-13 11:09:51 +0200126 return ret;
127}
128
129/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100130 * @brief Evaluate all relevant "when" conditions of a node.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100131 *
Michal Vaskobd4db892020-11-23 16:58:20 +0100132 * @param[in] tree Data tree.
133 * @param[in] node Node whose relevant when conditions will be evaluated.
134 * @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 +0100135 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobd4db892020-11-23 16:58:20 +0100136 * @param[out] disabled First when that evaluated false, if any.
137 * @return LY_SUCCESS on success.
138 * @return LY_EINCOMPLETE if a referenced node does not have its when evaluated.
139 * @return LY_ERR value on error.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100140 */
141static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100142lyd_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 +0100143 uint32_t xpath_options, const struct lysc_when **disabled)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100144{
Michal Vaskod027f382023-02-10 09:13:25 +0100145 LY_ERR r;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100146 const struct lyd_node *ctx_node;
147 struct lyxp_set xp_set;
Michal Vaskobd4db892020-11-23 16:58:20 +0100148 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100149
Michal Vaskobd4db892020-11-23 16:58:20 +0100150 assert(!node->schema || (node->schema == schema));
Michal Vaskocde73ac2019-11-14 16:10:27 +0100151
Michal Vaskobd4db892020-11-23 16:58:20 +0100152 *disabled = NULL;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100153
Michal Vaskobd4db892020-11-23 16:58:20 +0100154 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100155 const struct lysc_when *when;
156 struct lysc_when **when_list = lysc_node_when(schema);
Michal Vasko26bbb272022-08-02 14:54:33 +0200157
Radek Krejci9a3823e2021-01-27 20:26:46 +0100158 LY_ARRAY_FOR(when_list, u) {
159 when = when_list[u];
Michal Vaskocde73ac2019-11-14 16:10:27 +0100160
Michal Vaskobd4db892020-11-23 16:58:20 +0100161 /* get context node */
162 if (when->context == schema) {
163 ctx_node = node;
164 } else {
165 assert((!when->context && !node->parent) || (when->context == node->parent->schema));
Michal Vasko9e685082021-01-29 14:49:09 +0100166 ctx_node = lyd_parent(node);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100167 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100168
169 /* evaluate when */
170 memset(&xp_set, 0, sizeof xp_set);
Michal Vaskod027f382023-02-10 09:13:25 +0100171 r = lyxp_eval(LYD_CTX(node), when->cond, schema->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200172 ctx_node, ctx_node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskobd4db892020-11-23 16:58:20 +0100173 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
174
175 /* return error or LY_EINCOMPLETE for dependant unresolved when */
Michal Vaskod027f382023-02-10 09:13:25 +0100176 LY_CHECK_RET(r);
Michal Vaskobd4db892020-11-23 16:58:20 +0100177
178 if (!xp_set.val.bln) {
179 /* false when */
180 *disabled = when;
181 return LY_SUCCESS;
Michal Vasko8104fd42020-07-13 11:09:51 +0200182 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100183 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100184
185 schema = schema->parent;
186 } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
187
188 return LY_SUCCESS;
189}
190
191/**
Michal Vasko64eb14a2023-11-20 13:49:47 +0100192 * @brief Properly delete a node as part of auto-delete validation tasks.
193 *
194 * @param[in,out] first First sibling, is updated if needed.
195 * @param[in] del Node instance to delete.
196 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100197 * @param[in] np_cont_diff Whether to put NP container into diff or only its children.
Michal Vasko64eb14a2023-11-20 13:49:47 +0100198 * @param[in,out] node Optional current iteration node, update it if it is deleted.
199 * @param[in,out] node_when Optional set with nodes with "when" conditions, may be removed from.
200 * @param[in,out] diff Validation diff.
201 * @return 1 if @p node auto-deleted and updated to its next sibling.
202 * @return 0 if @p node was not auto-deleted.
203 */
204static ly_bool
205lyd_validate_autodel_node_del(struct lyd_node **first, struct lyd_node *del, const struct lys_module *mod,
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100206 int np_cont_diff, struct lyd_node **node, struct ly_set *node_types, struct lyd_node **diff)
Michal Vasko64eb14a2023-11-20 13:49:47 +0100207{
208 struct lyd_node *iter;
209 ly_bool node_autodel = 0;
210 uint32_t idx;
211
212 /* update pointers */
213 lyd_del_move_root(first, del, mod);
214 if (node && (del == *node)) {
215 *node = (*node)->next;
216 node_autodel = 1;
217 }
218
219 if (diff) {
220 /* add into diff */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100221 if (!np_cont_diff && (del->schema->nodetype == LYS_CONTAINER) && !(del->schema->flags & LYS_PRESENCE)) {
Michal Vasko64eb14a2023-11-20 13:49:47 +0100222 /* we do not want to track NP container changes, but remember any removed children */
223 LY_LIST_FOR(lyd_child(del), iter) {
224 lyd_val_diff_add(iter, LYD_DIFF_OP_DELETE, diff);
225 }
226 } else {
227 lyd_val_diff_add(del, LYD_DIFF_OP_DELETE, diff);
228 }
229 }
230
231 if (node_types && node_types->count) {
232 /* remove from node_types set */
233 LYD_TREE_DFS_BEGIN(del, iter) {
234 if (ly_set_contains(node_types, iter, &idx)) {
235 ly_set_rm_index(node_types, idx, NULL);
236 }
237 LYD_TREE_DFS_END(del, iter);
238 }
239 }
240
241 /* free */
242 lyd_free_tree(del);
243
244 return node_autodel;
245}
246
247/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100248 * @brief Evaluate when conditions of collected unres nodes.
249 *
250 * @param[in,out] tree Data tree, is updated if some nodes are autodeleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100251 * @param[in] mod Module of the @p tree to take into consideration when deleting @p tree and moving it.
252 * If set, it is expected @p tree should point to the first node of @p mod. Otherwise it will simply be
253 * the first top-level sibling.
Michal Vaskobd4db892020-11-23 16:58:20 +0100254 * @param[in] node_when Set with nodes with "when" conditions.
Michal Vaskod027f382023-02-10 09:13:25 +0100255 * @param[in] val_opts Validation options.
Michal Vasko976ec432021-12-06 15:42:22 +0100256 * @param[in] xpath_options Additional XPath options to use.
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200257 * @param[in,out] node_types Set with nodes with unresolved types, remove any with false "when" parents.
Michal Vaskobd4db892020-11-23 16:58:20 +0100258 * @param[in,out] diff Validation diff.
259 * @return LY_SUCCESS on success.
260 * @return LY_ERR value on error.
261 */
262static LY_ERR
Michal Vaskod027f382023-02-10 09:13:25 +0100263lyd_validate_unres_when(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when, uint32_t val_opts,
Michal Vasko976ec432021-12-06 15:42:22 +0100264 uint32_t xpath_options, struct ly_set *node_types, struct lyd_node **diff)
Michal Vaskobd4db892020-11-23 16:58:20 +0100265{
Michal Vaskod027f382023-02-10 09:13:25 +0100266 LY_ERR rc = LY_SUCCESS, r;
Michal Vasko64eb14a2023-11-20 13:49:47 +0100267 uint32_t i;
Michal Vaskobd4db892020-11-23 16:58:20 +0100268 const struct lysc_when *disabled;
Michal Vasko64eb14a2023-11-20 13:49:47 +0100269 struct lyd_node *node = NULL;
Michal Vaskobd4db892020-11-23 16:58:20 +0100270
271 if (!node_when->count) {
272 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100273 }
274
Michal Vaskobd4db892020-11-23 16:58:20 +0100275 i = node_when->count;
276 do {
277 --i;
278 node = node_when->dnodes[i];
Michal Vasko7a266772024-01-23 11:02:38 +0100279 LOG_LOCSET(node->schema, node);
Michal Vaskobd4db892020-11-23 16:58:20 +0100280
281 /* evaluate all when expressions that affect this node's existence */
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200282 r = lyd_validate_node_when(*tree, node, node->schema, xpath_options, &disabled);
283 if (!r) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100284 if (disabled) {
285 /* when false */
286 if (node->flags & LYD_WHEN_TRUE) {
287 /* autodelete */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100288 lyd_validate_autodel_node_del(tree, node, mod, 1, NULL, node_types, diff);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100289 } else if (val_opts & LYD_VALIDATE_OPERATIONAL) {
290 /* only a warning */
291 LOGWRN(LYD_CTX(node), "When condition \"%s\" not satisfied.", disabled->cond->expr);
Michal Vaskobd4db892020-11-23 16:58:20 +0100292 } else {
293 /* invalid data */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100294 LOGVAL(LYD_CTX(node), LY_VCODE_NOWHEN, disabled->cond->expr);
Michal Vaskod027f382023-02-10 09:13:25 +0100295 r = LY_EVALID;
296 LY_VAL_ERR_GOTO(r, rc = r, val_opts, error);
Michal Vaskobd4db892020-11-23 16:58:20 +0100297 }
298 } else {
299 /* when true */
300 node->flags |= LYD_WHEN_TRUE;
301 }
302
Michal Vasko413af592021-12-13 11:50:51 +0100303 /* remove this node from the set keeping the order, its when was resolved */
304 ly_set_rm_index_ordered(node_when, i, NULL);
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200305 } else if (r != LY_EINCOMPLETE) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100306 /* error */
Michal Vaskod027f382023-02-10 09:13:25 +0100307 LY_VAL_ERR_GOTO(r, rc = r, val_opts, error);
Michal Vaskobd4db892020-11-23 16:58:20 +0100308 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100309
Michal Vasko7a266772024-01-23 11:02:38 +0100310 LOG_LOCBACK(1, 1);
Michal Vaskobd4db892020-11-23 16:58:20 +0100311 } while (i);
312
Michal Vaskod027f382023-02-10 09:13:25 +0100313 return rc;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100314
315error:
Michal Vasko7a266772024-01-23 11:02:38 +0100316 LOG_LOCBACK(1, 1);
Michal Vasko6f0c5c72022-08-05 15:28:14 +0200317 return rc;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100318}
319
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200320LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +0200321lyd_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 +0200322 uint32_t when_xp_opts, struct ly_set *node_types, struct ly_set *meta_types, struct ly_set *ext_node,
323 struct ly_set *ext_val, uint32_t val_opts, struct lyd_node **diff)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100324{
Michal Vaskod027f382023-02-10 09:13:25 +0100325 LY_ERR r, rc = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200326 uint32_t i;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100327
Michal Vaskoddd76592022-01-17 13:34:48 +0100328 if (ext_val && ext_val->count) {
329 /* first validate parsed extension data */
330 i = ext_val->count;
331 do {
332 --i;
333
334 struct lyd_ctx_ext_val *ext_v = ext_val->objs[i];
335
336 /* validate extension data */
Michal Vaskod027f382023-02-10 09:13:25 +0100337 r = ext_v->ext->def->plugin->validate(ext_v->ext, ext_v->sibling, *tree, data_type, val_opts, diff);
338 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoddd76592022-01-17 13:34:48 +0100339
340 /* remove this item from the set */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200341 ly_set_rm_index(ext_val, i, free);
Michal Vaskoddd76592022-01-17 13:34:48 +0100342 } while (i);
343 }
344
Michal Vasko135719f2022-08-25 12:18:17 +0200345 if (ext_node && ext_node->count) {
346 /* validate data nodes with extension instances */
347 i = ext_node->count;
348 do {
349 --i;
350
351 struct lyd_ctx_ext_node *ext_n = ext_node->objs[i];
352
353 /* validate the node */
Michal Vaskod027f382023-02-10 09:13:25 +0100354 r = ext_n->ext->def->plugin->node(ext_n->ext, ext_n->node, val_opts);
355 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko135719f2022-08-25 12:18:17 +0200356
357 /* remove this item from the set */
358 ly_set_rm_index(ext_node, i, free);
359 } while (i);
360 }
361
Michal Vaskob1b5c262020-03-05 14:29:47 +0100362 if (node_when) {
363 /* evaluate all when conditions */
364 uint32_t prev_count;
Michal Vasko26bbb272022-08-02 14:54:33 +0200365
Michal Vaskob1b5c262020-03-05 14:29:47 +0100366 do {
367 prev_count = node_when->count;
Michal Vaskod027f382023-02-10 09:13:25 +0100368 r = lyd_validate_unres_when(tree, mod, node_when, val_opts, when_xp_opts, node_types, diff);
369 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
370
Radek Krejci0f969882020-08-21 16:56:47 +0200371 /* there must have been some when conditions resolved */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100372 } while (prev_count > node_when->count);
Michal Vaskocde73ac2019-11-14 16:10:27 +0100373
Michal Vaskob1b5c262020-03-05 14:29:47 +0100374 /* there could have been no cyclic when dependencies, checked during compilation */
Michal Vasko0b877d52023-11-20 13:50:08 +0100375 assert(!node_when->count || ((rc == LY_EVALID) && (val_opts & LYD_VALIDATE_MULTI_ERROR)));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100376 }
377
378 if (node_types && node_types->count) {
379 /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200380 i = node_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100381 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200382 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100383
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100384 struct lyd_node_term *node = node_types->objs[i];
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200385 struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100386
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200387 /* resolve the value of the node */
Michal Vasko7a266772024-01-23 11:02:38 +0100388 LOG_LOCSET(NULL, &node->node);
Michal Vaskod027f382023-02-10 09:13:25 +0100389 r = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree);
Michal Vasko7a266772024-01-23 11:02:38 +0100390 LOG_LOCBACK(0, 1);
Michal Vaskod027f382023-02-10 09:13:25 +0100391 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100392
393 /* remove this node from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200394 ly_set_rm_index(node_types, i, NULL);
395 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100396 }
397
Michal Vasko9f96a052020-03-10 09:41:45 +0100398 if (meta_types && meta_types->count) {
399 /* ... and metadata values */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200400 i = meta_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100401 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200402 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100403
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100404 struct lyd_meta *meta = meta_types->objs[i];
Michal Vasko193dacd2022-10-13 08:43:05 +0200405 struct lysc_type *type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100406
Michal Vasko9f96a052020-03-10 09:41:45 +0100407 /* validate and store the value of the metadata */
Michal Vaskofbd037c2022-11-08 10:34:20 +0100408 lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type);
Michal Vaskod027f382023-02-10 09:13:25 +0100409 r = lyd_value_validate_incomplete(LYD_CTX(meta->parent), type, &meta->value, meta->parent, *tree);
410 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100411
412 /* remove this attr from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200413 ly_set_rm_index(meta_types, i, NULL);
414 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100415 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100416
Michal Vaskod027f382023-02-10 09:13:25 +0100417cleanup:
418 return rc;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100419}
420
Michal Vaskobb844672020-07-03 11:06:12 +0200421/**
422 * @brief Validate instance duplication.
423 *
424 * @param[in] first First sibling to search in.
425 * @param[in] node Data node instance to check.
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100426 * @param[in] val_opts Validation options.
Michal Vaskobb844672020-07-03 11:06:12 +0200427 * @return LY_ERR value.
428 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100429static LY_ERR
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100430lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node, uint32_t val_opts)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100431{
Michal Vasko04a89c22023-10-03 14:03:09 +0200432 struct lyd_node **match_p, *match;
Radek Krejci857189e2020-09-01 13:26:36 +0200433 ly_bool fail = 0;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100434
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100435 assert(node->flags & LYD_NEW);
436
Michal Vaskod6c18af2021-02-12 12:07:31 +0100437 /* key-less list or non-configuration leaf-list */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200438 if (lysc_is_dup_inst_list(node->schema)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100439 /* duplicate instances allowed */
440 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100441 }
442
Michal Vaskob1b5c262020-03-05 14:29:47 +0100443 /* find exactly the same next instance using hashes if possible */
444 if (node->parent && node->parent->children_ht) {
Michal Vasko04a89c22023-10-03 14:03:09 +0200445 lyd_find_sibling_first(first, node, &match);
446 assert(match);
447
448 if (match != node) {
449 fail = 1;
450 } else if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100451 fail = 1;
452 }
453 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200454 for ( ; first; first = first->next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100455 if (first == node) {
456 continue;
457 }
458
459 if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
460 if (first->schema == node->schema) {
461 fail = 1;
462 break;
463 }
Michal Vasko8f359bf2020-07-28 10:41:15 +0200464 } else if (!lyd_compare_single(first, node, 0)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100465 fail = 1;
466 break;
467 }
468 }
469 }
470
471 if (fail) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100472 if ((node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (val_opts & LYD_VALIDATE_OPERATIONAL)) {
473 /* only a warning */
Michal Vasko7a266772024-01-23 11:02:38 +0100474 LOG_LOCSET(NULL, node);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100475 LOGWRN(node->schema->module->ctx, "Duplicate instance of \"%s\".", node->schema->name);
Michal Vasko7a266772024-01-23 11:02:38 +0100476 LOG_LOCBACK(0, 1);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100477 } else {
Michal Vasko7a266772024-01-23 11:02:38 +0100478 LOG_LOCSET(NULL, node);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100479 LOGVAL(node->schema->module->ctx, LY_VCODE_DUP, node->schema->name);
Michal Vasko7a266772024-01-23 11:02:38 +0100480 LOG_LOCBACK(0, 1);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100481 return LY_EVALID;
482 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100483 }
484 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100485}
486
Michal Vaskobb844672020-07-03 11:06:12 +0200487/**
488 * @brief Validate multiple case data existence with possible autodelete.
489 *
490 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100491 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200492 * @param[in] choic Choice node whose cases to check.
Michal Vasko8104fd42020-07-13 11:09:51 +0200493 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200494 * @return LY_ERR value.
495 */
Michal Vaskocde73ac2019-11-14 16:10:27 +0100496static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100497lyd_validate_cases(struct lyd_node **first, const struct lys_module *mod, const struct lysc_node_choice *choic,
498 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100499{
500 const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
501 struct lyd_node *match, *to_del;
Radek Krejci857189e2020-09-01 13:26:36 +0200502 ly_bool found;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100503
Michal Vasko7a266772024-01-23 11:02:38 +0100504 LOG_LOCSET(&choic->node, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100505
Michal Vaskob1b5c262020-03-05 14:29:47 +0100506 LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
507 found = 0;
508 iter = NULL;
509 match = NULL;
510 while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) {
511 if (match->flags & LYD_NEW) {
512 /* a new case data found, nothing more to look for */
513 found = 2;
514 break;
515 } else {
516 /* and old case data found */
517 if (found == 0) {
518 found = 1;
519 }
520 }
521 }
522
523 if (found == 1) {
524 /* there should not be 2 old cases */
525 if (old_case) {
526 /* old data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100527 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, old_case->name, scase->name);
Michal Vasko7a266772024-01-23 11:02:38 +0100528 LOG_LOCBACK(1, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100529 return LY_EVALID;
530 }
531
532 /* remember an old existing case */
533 old_case = scase;
534 } else if (found == 2) {
535 if (new_case) {
536 /* new data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100537 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, new_case->name, scase->name);
Michal Vasko7a266772024-01-23 11:02:38 +0100538 LOG_LOCBACK(1, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100539 return LY_EVALID;
540 }
541
542 /* remember a new existing case */
543 new_case = scase;
544 }
545 }
546
Michal Vasko7a266772024-01-23 11:02:38 +0100547 LOG_LOCBACK(1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100548
Michal Vaskob1b5c262020-03-05 14:29:47 +0100549 if (old_case && new_case) {
550 /* auto-delete old case */
551 iter = NULL;
552 match = NULL;
553 to_del = NULL;
554 while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100555 lyd_del_move_root(first, to_del, mod);
556
Michal Vasko8104fd42020-07-13 11:09:51 +0200557 /* free previous node */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100558 lyd_free_tree(to_del);
Michal Vasko8104fd42020-07-13 11:09:51 +0200559 if (diff) {
560 /* add into diff */
561 LY_CHECK_RET(lyd_val_diff_add(match, LYD_DIFF_OP_DELETE, diff));
562 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100563 to_del = match;
564 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100565 lyd_del_move_root(first, to_del, mod);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100566 lyd_free_tree(to_del);
567 }
568
569 return LY_SUCCESS;
570}
571
Michal Vaskobb844672020-07-03 11:06:12 +0200572/**
573 * @brief Check whether a schema node can have some default values (true for NP containers as well).
574 *
575 * @param[in] schema Schema node to check.
576 * @return non-zero if yes,
577 * @return 0 otherwise.
578 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100579static int
580lyd_val_has_default(const struct lysc_node *schema)
581{
582 switch (schema->nodetype) {
583 case LYS_LEAF:
584 if (((struct lysc_node_leaf *)schema)->dflt) {
585 return 1;
586 }
587 break;
588 case LYS_LEAFLIST:
589 if (((struct lysc_node_leaflist *)schema)->dflts) {
590 return 1;
591 }
592 break;
593 case LYS_CONTAINER:
594 if (!(schema->flags & LYS_PRESENCE)) {
595 return 1;
596 }
597 break;
598 default:
599 break;
600 }
601
602 return 0;
603}
604
Michal Vaskobb844672020-07-03 11:06:12 +0200605/**
Michal Vasko42266212022-12-01 08:33:11 +0100606 * @brief Auto-delete leaf-list default instances to prevent validation errors.
Michal Vaskobb844672020-07-03 11:06:12 +0200607 *
608 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vasko42266212022-12-01 08:33:11 +0100609 * @param[in,out] node New data node instance to check, is updated if auto-deleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100610 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vasko8104fd42020-07-13 11:09:51 +0200611 * @param[in,out] diff Validation diff.
Michal Vasko42266212022-12-01 08:33:11 +0100612 * @return 1 if @p node auto-deleted and updated to its next sibling.
613 * @return 0 if @p node was not auto-deleted.
Michal Vaskobb844672020-07-03 11:06:12 +0200614 */
Michal Vasko42266212022-12-01 08:33:11 +0100615static ly_bool
616lyd_validate_autodel_leaflist_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
617 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100618{
Michal Vasko42266212022-12-01 08:33:11 +0100619 const struct lysc_node *schema;
620 struct lyd_node *iter, *next;
621 ly_bool found = 0, node_autodel = 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100622
Michal Vasko42266212022-12-01 08:33:11 +0100623 assert((*node)->flags & LYD_NEW);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100624
Michal Vasko42266212022-12-01 08:33:11 +0100625 schema = (*node)->schema;
626 assert(schema->nodetype == LYS_LEAFLIST);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100627
Michal Vasko42266212022-12-01 08:33:11 +0100628 /* check whether there is any explicit instance */
629 LYD_LIST_FOR_INST(*first, schema, iter) {
630 if (!(iter->flags & LYD_DEFAULT)) {
631 found = 1;
632 break;
633 }
634 }
635 if (!found) {
636 /* no explicit instance, keep defaults as they are */
637 return 0;
638 }
639
640 LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) {
641 if (iter->flags & LYD_DEFAULT) {
642 /* default instance found, remove it */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100643 if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, diff)) {
Michal Vasko42266212022-12-01 08:33:11 +0100644 node_autodel = 1;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100645 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100646 }
647 }
Michal Vasko42266212022-12-01 08:33:11 +0100648
649 return node_autodel;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100650}
651
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100652/**
Michal Vasko42266212022-12-01 08:33:11 +0100653 * @brief Auto-delete container or leaf default instances to prevent validation errors.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100654 *
655 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vasko42266212022-12-01 08:33:11 +0100656 * @param[in,out] node New data node instance to check, is updated if auto-deleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100657 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100658 * @param[in,out] diff Validation diff.
Michal Vasko42266212022-12-01 08:33:11 +0100659 * @return 1 if @p node auto-deleted and updated to its next sibling.
660 * @return 0 if @p node was not auto-deleted.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100661 */
Michal Vasko42266212022-12-01 08:33:11 +0100662static ly_bool
663lyd_validate_autodel_cont_leaf_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
664 struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100665{
Michal Vasko42266212022-12-01 08:33:11 +0100666 const struct lysc_node *schema;
667 struct lyd_node *iter, *next;
668 ly_bool found = 0, node_autodel = 0;
669
670 assert((*node)->flags & LYD_NEW);
671
672 schema = (*node)->schema;
673 assert(schema->nodetype & (LYS_LEAF | LYS_CONTAINER));
674
675 /* check whether there is any explicit instance */
676 LYD_LIST_FOR_INST(*first, schema, iter) {
677 if (!(iter->flags & LYD_DEFAULT)) {
678 found = 1;
679 break;
680 }
681 }
682
683 if (found) {
684 /* remove all default instances */
685 LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) {
686 if (iter->flags & LYD_DEFAULT) {
687 /* default instance, remove it */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100688 if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, diff)) {
Michal Vasko42266212022-12-01 08:33:11 +0100689 node_autodel = 1;
690 }
691 }
692 }
693 } else {
694 /* remove a single old default instance, if any */
695 LYD_LIST_FOR_INST(*first, schema, iter) {
696 if ((iter->flags & LYD_DEFAULT) && !(iter->flags & LYD_NEW)) {
697 /* old default instance, remove it */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100698 if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, diff)) {
Michal Vasko42266212022-12-01 08:33:11 +0100699 node_autodel = 1;
700 }
701 break;
702 }
703 }
704 }
705
706 return node_autodel;
707}
708
709/**
710 * @brief Auto-delete leftover default nodes of deleted cases (that have no existing explicit data).
711 *
712 * @param[in,out] first First sibling to search in, is updated if needed.
713 * @param[in,out] node Default data node instance to check.
714 * @param[in] mod Module of the siblings, NULL for nested siblings.
715 * @param[in,out] diff Validation diff.
716 * @return 1 if @p node auto-deleted and updated to its next sibling.
717 * @return 0 if @p node was not auto-deleted.
718 */
719static ly_bool
720lyd_validate_autodel_case_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod,
721 struct lyd_node **diff)
722{
723 const struct lysc_node *schema;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100724 struct lysc_node_choice *choic;
725 struct lyd_node *iter = NULL;
726 const struct lysc_node *slast = NULL;
Michal Vasko42266212022-12-01 08:33:11 +0100727 ly_bool node_autodel = 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100728
Michal Vasko42266212022-12-01 08:33:11 +0100729 assert((*node)->flags & LYD_DEFAULT);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100730
Michal Vasko42266212022-12-01 08:33:11 +0100731 schema = (*node)->schema;
732
733 if (!schema->parent || (schema->parent->nodetype != LYS_CASE)) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100734 /* the default node is not a descendant of a case */
Michal Vasko42266212022-12-01 08:33:11 +0100735 return 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100736 }
737
Michal Vasko42266212022-12-01 08:33:11 +0100738 choic = (struct lysc_node_choice *)schema->parent->parent;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100739 assert(choic->nodetype == LYS_CHOICE);
740
Michal Vasko42266212022-12-01 08:33:11 +0100741 if (choic->dflt && (choic->dflt == (struct lysc_node_case *)schema->parent)) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100742 /* data of a default case, keep them */
Michal Vasko42266212022-12-01 08:33:11 +0100743 return 0;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100744 }
745
746 /* try to find an explicit node of the case */
Michal Vasko42266212022-12-01 08:33:11 +0100747 while ((iter = lys_getnext_data(iter, *first, &slast, schema->parent, NULL))) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100748 if (!(iter->flags & LYD_DEFAULT)) {
749 break;
750 }
751 }
752
753 if (!iter) {
754 /* there are only default nodes of the case meaning it does not exist and neither should any default nodes
755 * of the case, remove this one default node */
Michal Vaskoa7e92ec2023-11-21 09:18:39 +0100756 if (lyd_validate_autodel_node_del(first, *node, mod, 0, node, NULL, diff)) {
Michal Vasko42266212022-12-01 08:33:11 +0100757 node_autodel = 1;
758 }
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100759 }
Michal Vasko42266212022-12-01 08:33:11 +0100760
761 return node_autodel;
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100762}
763
Michal Vasko17f76642021-08-03 17:01:30 +0200764/**
765 * @brief Validate new siblings in choices, recursively for nested choices.
766 *
767 * @param[in,out] first First sibling.
768 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
769 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskod027f382023-02-10 09:13:25 +0100770 * @param[in] val_opts Validation options.
Michal Vasko17f76642021-08-03 17:01:30 +0200771 * @param[in,out] diff Validation diff.
772 * @return LY_ERR value.
773 */
774static LY_ERR
775lyd_validate_choice_r(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
Michal Vaskod027f382023-02-10 09:13:25 +0100776 uint32_t val_opts, struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100777{
Michal Vaskod027f382023-02-10 09:13:25 +0100778 LY_ERR r, rc = LY_SUCCESS;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100779 const struct lysc_node *snode = NULL;
780
Michal Vaskob1b5c262020-03-05 14:29:47 +0100781 while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
782 /* check case duplicites */
783 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskod027f382023-02-10 09:13:25 +0100784 r = lyd_validate_cases(first, mod, (struct lysc_node_choice *)snode, diff);
785 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko17f76642021-08-03 17:01:30 +0200786
787 /* check for nested choice */
Michal Vaskod027f382023-02-10 09:13:25 +0100788 r = lyd_validate_choice_r(first, snode, mod, val_opts, diff);
789 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100790 }
791 }
792
Michal Vaskod027f382023-02-10 09:13:25 +0100793cleanup:
794 return rc;
Michal Vasko17f76642021-08-03 17:01:30 +0200795}
796
797LY_ERR
798lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
Michal Vaskod027f382023-02-10 09:13:25 +0100799 uint32_t val_opts, struct lyd_node **diff)
Michal Vasko17f76642021-08-03 17:01:30 +0200800{
Michal Vaskod027f382023-02-10 09:13:25 +0100801 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko42266212022-12-01 08:33:11 +0100802 struct lyd_node *node;
803 const struct lysc_node *last_dflt_schema = NULL;
Michal Vasko17f76642021-08-03 17:01:30 +0200804
805 assert(first && (sparent || mod));
806
807 /* validate choices */
Michal Vaskod027f382023-02-10 09:13:25 +0100808 r = lyd_validate_choice_r(first, sparent, mod, val_opts, diff);
809 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko17f76642021-08-03 17:01:30 +0200810
Michal Vasko42266212022-12-01 08:33:11 +0100811 node = *first;
812 while (node) {
Michal Vasko6a6e3082022-05-10 10:32:38 +0200813 if (!node->schema || (mod && (lyd_owner_module(node) != mod))) {
814 /* opaque node or all top-level data from this module checked */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100815 break;
816 }
817
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100818 if (!(node->flags & (LYD_NEW | LYD_DEFAULT))) {
819 /* check only new and default nodes */
Michal Vasko42266212022-12-01 08:33:11 +0100820 node = node->next;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100821 continue;
822 }
823
Michal Vasko42266212022-12-01 08:33:11 +0100824 if (lyd_val_has_default(node->schema) && (node->schema != last_dflt_schema) && (node->flags & LYD_NEW)) {
825 /* remove old default(s) of the new node if an explicit instance exists */
826 last_dflt_schema = node->schema;
827 if (node->schema->nodetype == LYS_LEAFLIST) {
828 if (lyd_validate_autodel_leaflist_dflt(first, &node, mod, diff)) {
829 continue;
830 }
831 } else {
832 if (lyd_validate_autodel_cont_leaf_dflt(first, &node, mod, diff)) {
833 continue;
834 }
835 }
836 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100837
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100838 if (node->flags & LYD_NEW) {
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100839 /* then check new node instance duplicities */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100840 r = lyd_validate_duplicates(*first, node, val_opts);
Michal Vaskod027f382023-02-10 09:13:25 +0100841 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100842
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100843 /* this node is valid */
844 node->flags &= ~LYD_NEW;
845 }
846
847 if (node->flags & LYD_DEFAULT) {
848 /* remove leftover default nodes from a no-longer existing case */
Michal Vasko42266212022-12-01 08:33:11 +0100849 if (lyd_validate_autodel_case_dflt(first, &node, mod, diff)) {
850 continue;
851 }
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100852 }
Michal Vasko42266212022-12-01 08:33:11 +0100853
854 /* next iter */
855 node = node->next;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100856 }
857
Michal Vaskod027f382023-02-10 09:13:25 +0100858cleanup:
859 return rc;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100860}
861
Michal Vaskobb844672020-07-03 11:06:12 +0200862/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100863 * @brief Evaluate any "when" conditions of a non-existent data node with existing parent.
864 *
865 * @param[in] first First data sibling of the non-existing node.
866 * @param[in] parent Data parent of the non-existing node.
867 * @param[in] snode Schema node of the non-existing node.
868 * @param[out] disabled First when that evaluated false, if any.
869 * @return LY_ERR value.
870 */
871static LY_ERR
872lyd_validate_dummy_when(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
873 const struct lysc_when **disabled)
874{
Michal Vaskod027f382023-02-10 09:13:25 +0100875 LY_ERR rc = LY_SUCCESS;
Michal Vaskobd4db892020-11-23 16:58:20 +0100876 struct lyd_node *tree, *dummy = NULL;
Michal Vaskoa27245c2022-05-02 09:01:35 +0200877 uint32_t xp_opts;
Michal Vaskobd4db892020-11-23 16:58:20 +0100878
879 /* find root */
880 if (parent) {
881 tree = (struct lyd_node *)parent;
882 while (tree->parent) {
883 tree = lyd_parent(tree);
884 }
885 tree = lyd_first_sibling(tree);
886 } else {
Michal Vaskobd99b5e2022-04-29 11:15:47 +0200887 /* is the first sibling from the same module, but may not be the actual first */
888 tree = lyd_first_sibling(first);
Michal Vaskobd4db892020-11-23 16:58:20 +0100889 }
890
891 /* create dummy opaque node */
Michal Vaskod027f382023-02-10 09:13:25 +0100892 rc = lyd_new_opaq((struct lyd_node *)parent, snode->module->ctx, snode->name, NULL, NULL, snode->module->name, &dummy);
893 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskobd4db892020-11-23 16:58:20 +0100894
895 /* connect it if needed */
896 if (!parent) {
897 if (first) {
898 lyd_insert_sibling((struct lyd_node *)first, dummy, &tree);
899 } else {
900 assert(!tree);
901 tree = dummy;
902 }
903 }
904
Michal Vaskoa27245c2022-05-02 09:01:35 +0200905 /* explicitly specified accesible tree */
906 if (snode->flags & LYS_CONFIG_W) {
907 xp_opts = LYXP_ACCESS_TREE_CONFIG;
908 } else {
909 xp_opts = LYXP_ACCESS_TREE_ALL;
910 }
911
Michal Vaskobd4db892020-11-23 16:58:20 +0100912 /* evaluate all when */
Michal Vaskod027f382023-02-10 09:13:25 +0100913 rc = lyd_validate_node_when(tree, dummy, snode, xp_opts, disabled);
914 if (rc == LY_EINCOMPLETE) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100915 /* all other when must be resolved by now */
916 LOGINT(snode->module->ctx);
Michal Vaskod027f382023-02-10 09:13:25 +0100917 rc = LY_EINT;
Michal Vaskobd4db892020-11-23 16:58:20 +0100918 goto cleanup;
Michal Vaskod027f382023-02-10 09:13:25 +0100919 } else if (rc) {
Michal Vaskobd4db892020-11-23 16:58:20 +0100920 /* error */
921 goto cleanup;
922 }
923
924cleanup:
925 lyd_free_tree(dummy);
Michal Vaskod027f382023-02-10 09:13:25 +0100926 return rc;
Michal Vaskobd4db892020-11-23 16:58:20 +0100927}
928
929/**
Michal Vaskobb844672020-07-03 11:06:12 +0200930 * @brief Validate mandatory node existence.
931 *
932 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100933 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200934 * @param[in] snode Schema node to validate.
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100935 * @param[in] val_opts Validation options.
Michal Vaskobb844672020-07-03 11:06:12 +0200936 * @return LY_ERR value.
937 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100938static LY_ERR
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100939lyd_validate_mandatory(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
940 uint32_t val_opts)
Michal Vaskoa3881362020-01-21 15:57:35 +0100941{
Michal Vaskobd4db892020-11-23 16:58:20 +0100942 const struct lysc_when *disabled;
943
Michal Vaskoa3881362020-01-21 15:57:35 +0100944 if (snode->nodetype == LYS_CHOICE) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100945 /* some data of a choice case exist */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100946 if (lys_getnext_data(NULL, first, NULL, snode, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100947 return LY_SUCCESS;
948 }
949 } else {
950 assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY));
Michal Vaskoa3881362020-01-21 15:57:35 +0100951
Michal Vaskob1b5c262020-03-05 14:29:47 +0100952 if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100953 /* data instance found */
954 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100955 }
956 }
957
Michal Vaskobd4db892020-11-23 16:58:20 +0100958 disabled = NULL;
959 if (lysc_has_when(snode)) {
960 /* if there are any when conditions, they must be true for a validation error */
961 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
962 }
963
964 if (!disabled) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100965 if (val_opts & LYD_VALIDATE_OPERATIONAL) {
966 /* only a warning */
Michal Vasko7a266772024-01-23 11:02:38 +0100967 LOG_LOCSET(parent ? NULL : snode, parent);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100968 if (snode->nodetype == LYS_CHOICE) {
969 LOGWRN(snode->module->ctx, "Mandatory choice \"%s\" data do not exist.", snode->name);
970 } else {
971 LOGWRN(snode->module->ctx, "Mandatory node \"%s\" instance does not exist.", snode->name);
972 }
Michal Vasko7a266772024-01-23 11:02:38 +0100973 LOG_LOCBACK(parent ? 0 : 1, parent ? 1 : 0);
Michal Vasko538b8952021-02-17 11:27:26 +0100974 } else {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100975 /* node instance not found */
Michal Vasko7a266772024-01-23 11:02:38 +0100976 LOG_LOCSET(parent ? NULL : snode, parent);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100977 if (snode->nodetype == LYS_CHOICE) {
978 LOGVAL_APPTAG(snode->module->ctx, "missing-choice", LY_VCODE_NOMAND_CHOIC, snode->name);
979 } else {
980 LOGVAL(snode->module->ctx, LY_VCODE_NOMAND, snode->name);
981 }
Michal Vasko7a266772024-01-23 11:02:38 +0100982 LOG_LOCBACK(parent ? 0 : 1, parent ? 1 : 0);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100983 return LY_EVALID;
Michal Vasko538b8952021-02-17 11:27:26 +0100984 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100985 }
986
987 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100988}
989
Michal Vaskobb844672020-07-03 11:06:12 +0200990/**
991 * @brief Validate min/max-elements constraints, if any.
992 *
993 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100994 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200995 * @param[in] snode Schema node to validate.
996 * @param[in] min Minimum number of elements, 0 for no restriction.
997 * @param[in] max Max number of elements, 0 for no restriction.
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +0100998 * @param[in] val_opts Validation options.
Michal Vaskobb844672020-07-03 11:06:12 +0200999 * @return LY_ERR value.
1000 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001001static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001002lyd_validate_minmax(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001003 uint32_t min, uint32_t max, uint32_t val_opts)
Michal Vaskoa3881362020-01-21 15:57:35 +01001004{
Michal Vaskoacd83e72020-02-04 14:12:01 +01001005 uint32_t count = 0;
Michal Vasko4c583e82020-07-17 12:16:14 +02001006 struct lyd_node *iter;
Michal Vaskobd4db892020-11-23 16:58:20 +01001007 const struct lysc_when *disabled;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001008
Michal Vasko9b368d32020-02-14 13:53:31 +01001009 assert(min || max);
1010
Michal Vasko4c583e82020-07-17 12:16:14 +02001011 LYD_LIST_FOR_INST(first, snode, iter) {
1012 ++count;
Michal Vasko9b368d32020-02-14 13:53:31 +01001013
Michal Vasko4c583e82020-07-17 12:16:14 +02001014 if (min && (count == min)) {
1015 /* satisfied */
1016 min = 0;
1017 if (!max) {
1018 /* nothing more to check */
Michal Vasko9b368d32020-02-14 13:53:31 +01001019 break;
1020 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001021 }
Michal Vasko4c583e82020-07-17 12:16:14 +02001022 if (max && (count > max)) {
1023 /* not satisifed */
1024 break;
1025 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001026 }
1027
Michal Vasko9b368d32020-02-14 13:53:31 +01001028 if (min) {
1029 assert(count < min);
Michal Vaskobd4db892020-11-23 16:58:20 +01001030
1031 disabled = NULL;
1032 if (lysc_has_when(snode)) {
1033 /* if there are any when conditions, they must be true for a validation error */
1034 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
1035 }
1036
Michal Vasko6727c682023-02-17 10:40:26 +01001037 if (disabled) {
1038 /* satisfied */
1039 min = 0;
Michal Vaskobd4db892020-11-23 16:58:20 +01001040 }
Michal Vasko6727c682023-02-17 10:40:26 +01001041 }
1042 if (max && (count <= max)) {
1043 /* satisfied */
1044 max = 0;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001045 }
1046
Michal Vasko6727c682023-02-17 10:40:26 +01001047 if (min) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001048 if (val_opts & LYD_VALIDATE_OPERATIONAL) {
1049 /* only a warning */
Michal Vasko7a266772024-01-23 11:02:38 +01001050 LOG_LOCSET(snode, NULL);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001051 LOGWRN(snode->module->ctx, "Too few \"%s\" instances.", snode->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001052 LOG_LOCBACK(1, 0);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001053 } else {
Michal Vasko7a266772024-01-23 11:02:38 +01001054 LOG_LOCSET(snode, NULL);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001055 LOGVAL_APPTAG(snode->module->ctx, "too-few-elements", LY_VCODE_NOMIN, snode->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001056 LOG_LOCBACK(1, 0);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001057 return LY_EVALID;
1058 }
Michal Vasko6727c682023-02-17 10:40:26 +01001059 } else if (max) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001060 if (val_opts & LYD_VALIDATE_OPERATIONAL) {
1061 /* only a warning */
Michal Vasko7a266772024-01-23 11:02:38 +01001062 LOG_LOCSET(NULL, iter);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001063 LOGWRN(snode->module->ctx, "Too many \"%s\" instances.", snode->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001064 LOG_LOCBACK(0, 1);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001065 } else {
Michal Vasko7a266772024-01-23 11:02:38 +01001066 LOG_LOCSET(NULL, iter);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001067 LOGVAL_APPTAG(snode->module->ctx, "too-many-elements", LY_VCODE_NOMAX, snode->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001068 LOG_LOCBACK(0, 1);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001069 return LY_EVALID;
1070 }
Michal Vasko6727c682023-02-17 10:40:26 +01001071 }
Michal Vaskoa3881362020-01-21 15:57:35 +01001072 return LY_SUCCESS;
1073}
1074
Michal Vaskobb844672020-07-03 11:06:12 +02001075/**
1076 * @brief Find node referenced by a list unique statement.
1077 *
1078 * @param[in] uniq_leaf Unique leaf to find.
1079 * @param[in] list List instance to use for the search.
1080 * @return Found leaf,
1081 * @return NULL if no leaf found.
1082 */
Michal Vasko14654712020-02-06 08:35:21 +01001083static struct lyd_node *
Michal Vaskobb844672020-07-03 11:06:12 +02001084lyd_val_uniq_find_leaf(const struct lysc_node_leaf *uniq_leaf, const struct lyd_node *list)
Michal Vasko14654712020-02-06 08:35:21 +01001085{
Michal Vasko9b368d32020-02-14 13:53:31 +01001086 struct lyd_node *node;
1087 const struct lysc_node *iter;
1088 size_t depth = 0, i;
Michal Vasko14654712020-02-06 08:35:21 +01001089
Michal Vasko9b368d32020-02-14 13:53:31 +01001090 /* get leaf depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001091 for (iter = &uniq_leaf->node; iter && (iter != list->schema); iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02001092 ++depth;
Michal Vasko14654712020-02-06 08:35:21 +01001093 }
Michal Vasko9b368d32020-02-14 13:53:31 +01001094
Michal Vaskobb844672020-07-03 11:06:12 +02001095 node = (struct lyd_node *)list;
Michal Vasko9b368d32020-02-14 13:53:31 +01001096 while (node && depth) {
1097 /* find schema node with this depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001098 for (i = depth - 1, iter = &uniq_leaf->node; i; iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +02001099 --i;
Michal Vasko9b368d32020-02-14 13:53:31 +01001100 }
1101
1102 /* find iter instance in children */
1103 assert(iter->nodetype & (LYS_CONTAINER | LYS_LEAF));
Radek Krejcia1c1e542020-09-29 16:06:52 +02001104 lyd_find_sibling_val(lyd_child(node), iter, NULL, 0, &node);
Michal Vasko9b368d32020-02-14 13:53:31 +01001105 --depth;
1106 }
1107
Michal Vasko14654712020-02-06 08:35:21 +01001108 return node;
1109}
1110
Michal Vaskobb844672020-07-03 11:06:12 +02001111/**
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001112 * @brief Unique list validation callback argument.
1113 */
1114struct lyd_val_uniq_arg {
1115 LY_ARRAY_COUNT_TYPE action; /**< Action to perform - 0 to compare all uniques, n to compare only n-th unique. */
1116 uint32_t val_opts; /**< Validation options. */
1117};
1118
1119/**
Michal Vaskobb844672020-07-03 11:06:12 +02001120 * @brief Callback for comparing 2 list unique leaf values.
1121 *
Michal Vasko62524a92021-02-26 10:08:50 +01001122 * Implementation of ::lyht_value_equal_cb.
Michal Vasko14654712020-02-06 08:35:21 +01001123 */
Radek Krejci857189e2020-09-01 13:26:36 +02001124static ly_bool
1125lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *cb_data)
Michal Vasko14654712020-02-06 08:35:21 +01001126{
1127 struct ly_ctx *ctx;
1128 struct lysc_node_list *slist;
1129 struct lyd_node *diter, *first, *second;
1130 struct lyd_value *val1, *val2;
1131 char *path1, *path2, *uniq_str, *ptr;
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001132 LY_ARRAY_COUNT_TYPE u, v;
1133 struct lyd_val_uniq_arg *arg = cb_data;
1134 const uint32_t uniq_err_msg_size = 1024;
Michal Vasko14654712020-02-06 08:35:21 +01001135
1136 assert(val1_p && val2_p);
1137
1138 first = *((struct lyd_node **)val1_p);
1139 second = *((struct lyd_node **)val2_p);
Michal Vasko14654712020-02-06 08:35:21 +01001140
1141 assert(first && (first->schema->nodetype == LYS_LIST));
1142 assert(second && (second->schema == first->schema));
1143
1144 ctx = first->schema->module->ctx;
1145
1146 slist = (struct lysc_node_list *)first->schema;
1147
1148 /* compare unique leaves */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001149 if (arg->action > 0) {
1150 u = arg->action - 1;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001151 if (u < LY_ARRAY_COUNT(slist->uniques)) {
Michal Vasko14654712020-02-06 08:35:21 +01001152 goto uniquecheck;
1153 }
1154 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001155 LY_ARRAY_FOR(slist->uniques, u) {
Michal Vasko14654712020-02-06 08:35:21 +01001156uniquecheck:
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001157 LY_ARRAY_FOR(slist->uniques[u], v) {
Michal Vasko14654712020-02-06 08:35:21 +01001158 /* first */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001159 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], first);
Michal Vasko14654712020-02-06 08:35:21 +01001160 if (diter) {
1161 val1 = &((struct lyd_node_term *)diter)->value;
1162 } else {
1163 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001164 val1 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001165 }
1166
1167 /* second */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001168 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], second);
Michal Vasko14654712020-02-06 08:35:21 +01001169 if (diter) {
1170 val2 = &((struct lyd_node_term *)diter)->value;
1171 } else {
1172 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001173 val2 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001174 }
1175
aPiecek0a6705b2023-11-14 14:20:58 +01001176 if (!val1 || !val2 || val1->realtype->plugin->compare(ctx, val1, val2)) {
Michal Vasko14654712020-02-06 08:35:21 +01001177 /* values differ or either one is not set */
1178 break;
1179 }
1180 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001181 if (v && (v == LY_ARRAY_COUNT(slist->uniques[u]))) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001182 /* all unique leaves are the same in this set, create this nice error */
Radek Krejci635d2b82021-01-04 11:26:51 +01001183 path1 = lyd_path(first, LYD_PATH_STD, NULL, 0);
1184 path2 = lyd_path(second, LYD_PATH_STD, NULL, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001185
1186 /* use buffer to rebuild the unique string */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001187 uniq_str = malloc(uniq_err_msg_size);
Michal Vasko14654712020-02-06 08:35:21 +01001188 uniq_str[0] = '\0';
1189 ptr = uniq_str;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001190 LY_ARRAY_FOR(slist->uniques[u], v) {
1191 if (v) {
Michal Vasko14654712020-02-06 08:35:21 +01001192 strcpy(ptr, " ");
1193 ++ptr;
1194 }
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001195 ptr = lysc_path_until((struct lysc_node *)slist->uniques[u][v], &slist->node, LYSC_PATH_LOG,
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001196 ptr, uniq_err_msg_size - (ptr - uniq_str));
Michal Vasko14654712020-02-06 08:35:21 +01001197 if (!ptr) {
1198 /* path will be incomplete, whatever */
1199 break;
1200 }
1201
1202 ptr += strlen(ptr);
1203 }
Michal Vasko7a266772024-01-23 11:02:38 +01001204 LOG_LOCSET(NULL, second);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001205 if (arg->val_opts & LYD_VALIDATE_OPERATIONAL) {
1206 /* only a warning */
1207 LOGWRN(ctx, "Unique data leaf(s) \"%s\" not satisfied in \"%s\" and \"%s\".", uniq_str, path1, path2);
1208 } else {
1209 LOGVAL_APPTAG(ctx, "data-not-unique", LY_VCODE_NOUNIQ, uniq_str, path1, path2);
1210 }
Michal Vasko7a266772024-01-23 11:02:38 +01001211 LOG_LOCBACK(0, 1);
Michal Vasko14654712020-02-06 08:35:21 +01001212
1213 free(path1);
1214 free(path2);
1215 free(uniq_str);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001216
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001217 if (!(arg->val_opts & LYD_VALIDATE_OPERATIONAL)) {
1218 return 1;
1219 }
Michal Vasko14654712020-02-06 08:35:21 +01001220 }
1221
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001222 if (arg->action > 0) {
Michal Vasko14654712020-02-06 08:35:21 +01001223 /* done */
1224 return 0;
1225 }
1226 }
1227
1228 return 0;
1229}
1230
Michal Vaskobb844672020-07-03 11:06:12 +02001231/**
1232 * @brief Validate list unique leaves.
1233 *
1234 * @param[in] first First sibling to search in.
1235 * @param[in] snode Schema node to validate.
1236 * @param[in] uniques List unique arrays to validate.
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001237 * @param[in] val_opts Validation options.
Michal Vaskobb844672020-07-03 11:06:12 +02001238 * @return LY_ERR value.
1239 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001240static LY_ERR
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001241lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode, const struct lysc_node_leaf ***uniques,
1242 uint32_t val_opts)
Michal Vaskoa3881362020-01-21 15:57:35 +01001243{
Michal Vaskob1b5c262020-03-05 14:29:47 +01001244 const struct lyd_node *diter;
Michal Vasko14654712020-02-06 08:35:21 +01001245 struct ly_set *set;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001246 LY_ARRAY_COUNT_TYPE u, v, x = 0;
Michal Vasko14654712020-02-06 08:35:21 +01001247 LY_ERR ret = LY_SUCCESS;
Michal Vasko626196f2022-08-05 12:49:52 +02001248 uint32_t hash, i;
Radek Krejci813c02d2021-04-26 10:29:19 +02001249 size_t key_len;
1250 ly_bool dyn;
1251 const void *hash_key;
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001252 struct lyd_val_uniq_arg arg, *args = NULL;
Michal Vasko8efac242023-03-30 08:24:56 +02001253 struct ly_ht **uniqtables = NULL;
Michal Vasko14654712020-02-06 08:35:21 +01001254 struct lyd_value *val;
1255 struct ly_ctx *ctx = snode->module->ctx;
1256
1257 assert(uniques);
1258
1259 /* get all list instances */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001260 LY_CHECK_RET(ly_set_new(&set));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001261 LY_LIST_FOR(first, diter) {
Michal Vasko9b368d32020-02-14 13:53:31 +01001262 if (diter->schema == snode) {
Radek Krejci3d92e442020-10-12 12:48:13 +02001263 ret = ly_set_add(set, (void *)diter, 1, NULL);
Michal Vaskob0099a92020-08-31 14:55:23 +02001264 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko9b368d32020-02-14 13:53:31 +01001265 }
1266 }
Michal Vasko14654712020-02-06 08:35:21 +01001267
1268 if (set->count == 2) {
1269 /* simple comparison */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001270 arg.action = 0;
1271 arg.val_opts = val_opts;
1272 if (lyd_val_uniq_list_equal(&set->objs[0], &set->objs[1], 0, &arg)) {
Michal Vasko14654712020-02-06 08:35:21 +01001273 /* instance duplication */
1274 ret = LY_EVALID;
1275 goto cleanup;
1276 }
1277 } else if (set->count > 2) {
1278 /* use hashes for comparison */
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001279 uniqtables = malloc(LY_ARRAY_COUNT(uniques) * sizeof *uniqtables);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001280 args = malloc(LY_ARRAY_COUNT(uniques) * sizeof *args);
1281 LY_CHECK_ERR_GOTO(!uniqtables || !args, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001282 x = LY_ARRAY_COUNT(uniques);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001283 for (v = 0; v < x; v++) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001284 args[v].action = v + 1;
1285 args[v].val_opts = val_opts;
Michal Vasko626196f2022-08-05 12:49:52 +02001286 uniqtables[v] = lyht_new(lyht_get_fixed_size(set->count), sizeof(struct lyd_node *),
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001287 lyd_val_uniq_list_equal, &args[v], 0);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001288 LY_CHECK_ERR_GOTO(!uniqtables[v], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001289 }
1290
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001291 for (i = 0; i < set->count; i++) {
Michal Vasko14654712020-02-06 08:35:21 +01001292 /* loop for unique - get the hash for the instances */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001293 for (u = 0; u < x; u++) {
Michal Vasko14654712020-02-06 08:35:21 +01001294 val = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001295 for (v = hash = 0; v < LY_ARRAY_COUNT(uniques[u]); v++) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001296 diter = lyd_val_uniq_find_leaf(uniques[u][v], set->objs[i]);
Michal Vasko14654712020-02-06 08:35:21 +01001297 if (diter) {
1298 val = &((struct lyd_node_term *)diter)->value;
1299 } else {
1300 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001301 val = uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001302 }
1303 if (!val) {
1304 /* unique item not present nor has default value */
1305 break;
1306 }
1307
Radek Krejci813c02d2021-04-26 10:29:19 +02001308 /* get hash key */
Michal Vaskodcfac2c2021-05-10 11:36:37 +02001309 hash_key = val->realtype->plugin->print(NULL, val, LY_VALUE_LYB, NULL, &dyn, &key_len);
Michal Vaskoae130f52023-04-20 14:25:16 +02001310 hash = lyht_hash_multi(hash, hash_key, key_len);
Radek Krejci813c02d2021-04-26 10:29:19 +02001311 if (dyn) {
1312 free((void *)hash_key);
Michal Vasko14654712020-02-06 08:35:21 +01001313 }
1314 }
1315 if (!val) {
1316 /* skip this list instance since its unique set is incomplete */
1317 continue;
1318 }
1319
1320 /* finish the hash value */
Michal Vaskoae130f52023-04-20 14:25:16 +02001321 hash = lyht_hash_multi(hash, NULL, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001322
1323 /* insert into the hashtable */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001324 ret = lyht_insert(uniqtables[u], &set->objs[i], hash, NULL);
Michal Vasko14654712020-02-06 08:35:21 +01001325 if (ret == LY_EEXIST) {
1326 /* instance duplication */
1327 ret = LY_EVALID;
1328 }
1329 LY_CHECK_GOTO(ret != LY_SUCCESS, cleanup);
1330 }
1331 }
1332 }
1333
1334cleanup:
1335 ly_set_free(set, NULL);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001336 for (v = 0; v < x; v++) {
1337 if (!uniqtables[v]) {
Michal Vasko14654712020-02-06 08:35:21 +01001338 /* failed when allocating uniquetables[j], following j are not allocated */
1339 break;
1340 }
Michal Vasko77b7f90a2023-01-31 15:42:41 +01001341 lyht_free(uniqtables[v], NULL);
Michal Vasko14654712020-02-06 08:35:21 +01001342 }
1343 free(uniqtables);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001344 free(args);
Michal Vasko14654712020-02-06 08:35:21 +01001345
1346 return ret;
Michal Vaskoa3881362020-01-21 15:57:35 +01001347}
1348
Michal Vaskobb844672020-07-03 11:06:12 +02001349/**
1350 * @brief Validate data siblings based on generic schema node restrictions, recursively for schema-only nodes.
1351 *
1352 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +01001353 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +02001354 * @param[in] sparent Schema parent of the nodes to check.
1355 * @param[in] mod Module of the nodes to check.
1356 * @param[in] val_opts Validation options, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +01001357 * @param[in] int_opts Internal parser options.
Michal Vaskobb844672020-07-03 11:06:12 +02001358 * @return LY_ERR value.
1359 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001360static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001361lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lyd_node *parent,
Michal Vaskoe0665742021-02-11 11:08:44 +01001362 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 +01001363{
Michal Vaskod027f382023-02-10 09:13:25 +01001364 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko6c16cda2021-02-04 11:05:52 +01001365 const struct lysc_node *snode = NULL, *scase;
Michal Vaskoa3881362020-01-21 15:57:35 +01001366 struct lysc_node_list *slist;
Michal Vaskod8958df2020-08-05 13:27:36 +02001367 struct lysc_node_leaflist *sllist;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001368 uint32_t getnext_opts;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001369
Michal Vaskoe0665742021-02-11 11:08:44 +01001370 getnext_opts = LYS_GETNEXT_WITHCHOICE | (int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001371
Michal Vaskoa3881362020-01-21 15:57:35 +01001372 /* disabled nodes are skipped by lys_getnext */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001373 while ((snode = lys_getnext(snode, sparent, mod, getnext_opts))) {
Radek Krejci7931b192020-06-25 17:05:03 +02001374 if ((val_opts & LYD_VALIDATE_NO_STATE) && (snode->flags & LYS_CONFIG_R)) {
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001375 continue;
1376 }
1377
Michal Vaskoa3881362020-01-21 15:57:35 +01001378 /* check min-elements and max-elements */
Michal Vaskod8958df2020-08-05 13:27:36 +02001379 if (snode->nodetype == LYS_LIST) {
Michal Vaskoa3881362020-01-21 15:57:35 +01001380 slist = (struct lysc_node_list *)snode;
1381 if (slist->min || slist->max) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001382 r = lyd_validate_minmax(first, parent, snode, slist->min, slist->max, val_opts);
Michal Vasko6727c682023-02-17 10:40:26 +01001383 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoa3881362020-01-21 15:57:35 +01001384 }
Michal Vaskod8958df2020-08-05 13:27:36 +02001385 } else if (snode->nodetype == LYS_LEAFLIST) {
1386 sllist = (struct lysc_node_leaflist *)snode;
1387 if (sllist->min || sllist->max) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001388 r = lyd_validate_minmax(first, parent, snode, sllist->min, sllist->max, val_opts);
Michal Vasko6727c682023-02-17 10:40:26 +01001389 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskod8958df2020-08-05 13:27:36 +02001390 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001391
Michal Vaskoacd83e72020-02-04 14:12:01 +01001392 } else if (snode->flags & LYS_MAND_TRUE) {
Radek Krejcif6a11002020-08-21 13:29:07 +02001393 /* check generic mandatory existence */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001394 r = lyd_validate_mandatory(first, parent, snode, val_opts);
Michal Vasko6727c682023-02-17 10:40:26 +01001395 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoa3881362020-01-21 15:57:35 +01001396 }
1397
1398 /* check unique */
1399 if (snode->nodetype == LYS_LIST) {
1400 slist = (struct lysc_node_list *)snode;
1401 if (slist->uniques) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001402 r = lyd_validate_unique(first, snode, (const struct lysc_node_leaf ***)slist->uniques, val_opts);
Michal Vasko6727c682023-02-17 10:40:26 +01001403 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoa3881362020-01-21 15:57:35 +01001404 }
1405 }
1406
Michal Vasko6c16cda2021-02-04 11:05:52 +01001407 if (snode->nodetype == LYS_CHOICE) {
1408 /* find the existing case, if any */
1409 LY_LIST_FOR(lysc_node_child(snode), scase) {
1410 if (lys_getnext_data(NULL, first, NULL, scase, NULL)) {
1411 /* validate only this case */
Michal Vaskod027f382023-02-10 09:13:25 +01001412 r = lyd_validate_siblings_schema_r(first, parent, scase, mod, val_opts, int_opts);
Michal Vasko6727c682023-02-17 10:40:26 +01001413 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko6c16cda2021-02-04 11:05:52 +01001414 break;
1415 }
1416 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001417 }
Michal Vaskocde73ac2019-11-14 16:10:27 +01001418 }
1419
Michal Vasko6727c682023-02-17 10:40:26 +01001420cleanup:
Michal Vaskod027f382023-02-10 09:13:25 +01001421 return rc;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001422}
1423
Michal Vaskobb844672020-07-03 11:06:12 +02001424/**
1425 * @brief Validate obsolete nodes, only warnings are printed.
1426 *
1427 * @param[in] node Node to check.
1428 */
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001429static void
1430lyd_validate_obsolete(const struct lyd_node *node)
1431{
1432 const struct lysc_node *snode;
1433
1434 snode = node->schema;
1435 do {
1436 if (snode->flags & LYS_STATUS_OBSLT) {
Michal Vasko7a266772024-01-23 11:02:38 +01001437 LOG_LOCSET(NULL, node);
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001438 LOGWRN(snode->module->ctx, "Obsolete schema node \"%s\" instantiated in data.", snode->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001439 LOG_LOCBACK(0, 1);
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001440 break;
1441 }
1442
1443 snode = snode->parent;
1444 } while (snode && (snode->nodetype & (LYS_CHOICE | LYS_CASE)));
1445}
1446
Michal Vaskobb844672020-07-03 11:06:12 +02001447/**
1448 * @brief Validate must conditions of a data node.
1449 *
1450 * @param[in] node Node to validate.
Michal Vaskod027f382023-02-10 09:13:25 +01001451 * @param[in] val_opts Validation options.
Michal Vaskoe0665742021-02-11 11:08:44 +01001452 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001453 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobb844672020-07-03 11:06:12 +02001454 * @return LY_ERR value.
1455 */
Michal Vaskocc048b22020-03-27 15:52:38 +01001456static LY_ERR
Michal Vaskod027f382023-02-10 09:13:25 +01001457lyd_validate_must(const struct lyd_node *node, uint32_t val_opts, uint32_t int_opts, uint32_t xpath_options)
Michal Vaskocc048b22020-03-27 15:52:38 +01001458{
Michal Vaskod027f382023-02-10 09:13:25 +01001459 LY_ERR r, rc = LY_SUCCESS;
Michal Vaskocc048b22020-03-27 15:52:38 +01001460 struct lyxp_set xp_set;
1461 struct lysc_must *musts;
1462 const struct lyd_node *tree;
Radek Krejci9a3823e2021-01-27 20:26:46 +01001463 const struct lysc_node *schema;
Michal Vaskoe9391c72021-10-05 10:04:56 +02001464 const char *emsg, *eapptag;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001465 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocc048b22020-03-27 15:52:38 +01001466
Michal Vaskoe0665742021-02-11 11:08:44 +01001467 assert((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) != (LYD_INTOPT_RPC | LYD_INTOPT_REPLY));
1468 assert((int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) != (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY));
1469
Radek Krejci9a3823e2021-01-27 20:26:46 +01001470 if (node->schema->nodetype & (LYS_ACTION | LYS_RPC)) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001471 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001472 schema = &((struct lysc_node_action *)node->schema)->input.node;
Michal Vaskoe0665742021-02-11 11:08:44 +01001473 } else if (int_opts & LYD_INTOPT_REPLY) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001474 schema = &((struct lysc_node_action *)node->schema)->output.node;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001475 } else {
Michal Vaskoa1db2342021-07-19 12:23:23 +02001476 LOGINT_RET(LYD_CTX(node));
Michal Vaskocb7526d2020-03-30 15:08:26 +02001477 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001478 } else {
1479 schema = node->schema;
Michal Vaskocc048b22020-03-27 15:52:38 +01001480 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001481 musts = lysc_node_musts(schema);
Michal Vaskocc048b22020-03-27 15:52:38 +01001482 if (!musts) {
1483 /* no must to evaluate */
1484 return LY_SUCCESS;
1485 }
1486
1487 /* find first top-level node */
Michal Vasko9e685082021-01-29 14:49:09 +01001488 for (tree = node; tree->parent; tree = lyd_parent(tree)) {}
Michal Vaskof9221e62021-02-04 12:10:14 +01001489 tree = lyd_first_sibling(tree);
Michal Vaskocc048b22020-03-27 15:52:38 +01001490
1491 LY_ARRAY_FOR(musts, u) {
1492 memset(&xp_set, 0, sizeof xp_set);
1493
1494 /* evaluate must */
Michal Vaskod027f382023-02-10 09:13:25 +01001495 r = lyxp_eval(LYD_CTX(node), musts[u].cond, node->schema->module, LY_VALUE_SCHEMA_RESOLVED,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02001496 musts[u].prefixes, node, node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskod027f382023-02-10 09:13:25 +01001497 if (r == LY_EINCOMPLETE) {
Michal Vasko2deae4c2023-11-08 11:36:59 +01001498 LOGERR(LYD_CTX(node), LY_EINCOMPLETE,
1499 "Must \"%s\" depends on a node with a when condition, which has not been evaluated.", musts[u].cond->expr);
Michal Vaskoa1db2342021-07-19 12:23:23 +02001500 }
Michal Vaskod027f382023-02-10 09:13:25 +01001501 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskocc048b22020-03-27 15:52:38 +01001502
1503 /* check the result */
1504 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02001505 if (!xp_set.val.bln) {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001506 if (val_opts & LYD_VALIDATE_OPERATIONAL) {
1507 /* only a warning */
1508 emsg = musts[u].emsg;
Michal Vasko7a266772024-01-23 11:02:38 +01001509 LOG_LOCSET(NULL, node);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001510 if (emsg) {
1511 LOGWRN(LYD_CTX(node), "%s", emsg);
1512 } else {
1513 LOGWRN(LYD_CTX(node), "Must condition \"%s\" not satisfied.", musts[u].cond->expr);
1514 }
Michal Vasko7a266772024-01-23 11:02:38 +01001515 LOG_LOCBACK(0, 1);
Michal Vaskoe9391c72021-10-05 10:04:56 +02001516 } else {
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001517 /* use specific error information */
1518 emsg = musts[u].emsg;
1519 eapptag = musts[u].eapptag ? musts[u].eapptag : "must-violation";
Michal Vasko7a266772024-01-23 11:02:38 +01001520 LOG_LOCSET(NULL, node);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001521 if (emsg) {
1522 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LYVE_DATA, "%s", emsg);
1523 } else {
1524 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LY_VCODE_NOMUST, musts[u].cond->expr);
1525 }
Michal Vasko7a266772024-01-23 11:02:38 +01001526 LOG_LOCBACK(0, 1);
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001527 r = LY_EVALID;
1528 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoe9391c72021-10-05 10:04:56 +02001529 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001530 }
1531 }
1532
Michal Vaskod027f382023-02-10 09:13:25 +01001533cleanup:
1534 return rc;
Michal Vaskocc048b22020-03-27 15:52:38 +01001535}
1536
Michal Vaskoe0665742021-02-11 11:08:44 +01001537/**
1538 * @brief Perform all remaining validation tasks, the data tree must be final when calling this function.
1539 *
1540 * @param[in] first First sibling.
1541 * @param[in] parent Data parent.
1542 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
1543 * @param[in] mod Module of the siblings, NULL for nested siblings.
1544 * @param[in] val_opts Validation options (@ref datavalidationoptions).
1545 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001546 * @param[in] must_xp_opts Additional XPath options to use for evaluating "must".
Michal Vaskoe0665742021-02-11 11:08:44 +01001547 * @return LY_ERR value.
1548 */
1549static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001550lyd_validate_final_r(struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *sparent,
Michal Vasko906bafa2022-04-22 12:28:55 +02001551 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 +01001552{
Michal Vaskod027f382023-02-10 09:13:25 +01001553 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001554 const char *innode;
Michal Vaskob8093b92023-12-21 13:23:07 +01001555 struct lyd_node *node;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001556
Michal Vasko14654712020-02-06 08:35:21 +01001557 /* validate all restrictions of nodes themselves */
Michal Vaskob8093b92023-12-21 13:23:07 +01001558 LY_LIST_FOR(first, node) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001559 if (node->flags & LYD_EXT) {
1560 /* ext instance data should have already been validated */
1561 continue;
1562 }
1563
Michal Vaskoa8c61722020-03-27 16:59:32 +01001564 /* opaque data */
1565 if (!node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001566 r = lyd_parse_opaq_error(node);
Michal Vaskod027f382023-02-10 09:13:25 +01001567 goto next_iter;
Michal Vaskoa8c61722020-03-27 16:59:32 +01001568 }
1569
Michal Vasko6344e7a2022-05-10 10:08:53 +02001570 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1571 /* all top-level data from this module checked */
Michal Vasko6344e7a2022-05-10 10:08:53 +02001572 break;
1573 }
1574
Michal Vasko8d289f92021-12-02 10:11:00 +01001575 /* no state/input/output/op data */
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001576 innode = NULL;
Radek Krejci7931b192020-06-25 17:05:03 +02001577 if ((val_opts & LYD_VALIDATE_NO_STATE) && (node->schema->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001578 innode = "state";
Michal Vaskoe0665742021-02-11 11:08:44 +01001579 } else if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) && (node->schema->flags & LYS_IS_OUTPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001580 innode = "output";
Michal Vaskoe0665742021-02-11 11:08:44 +01001581 } else if ((int_opts & LYD_INTOPT_REPLY) && (node->schema->flags & LYS_IS_INPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001582 innode = "input";
Michal Vasko8d289f92021-12-02 10:11:00 +01001583 } else if (!(int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_RPC)) {
1584 innode = "rpc";
1585 } else if (!(int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_ACTION)) {
1586 innode = "action";
1587 } else if (!(int_opts & LYD_INTOPT_NOTIF) && (node->schema->nodetype == LYS_NOTIF)) {
1588 innode = "notification";
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001589 }
1590 if (innode) {
Michal Vasko7a266772024-01-23 11:02:38 +01001591 LOG_LOCSET(NULL, node);
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001592 LOGVAL(LYD_CTX(node), LY_VCODE_UNEXPNODE, innode, node->schema->name);
Michal Vasko7a266772024-01-23 11:02:38 +01001593 LOG_LOCBACK(0, 1);
Michal Vaskod027f382023-02-10 09:13:25 +01001594 r = LY_EVALID;
1595 goto next_iter;
Michal Vasko5b37a352020-03-06 13:38:33 +01001596 }
1597
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001598 /* obsolete data */
1599 lyd_validate_obsolete(node);
1600
Michal Vaskocc048b22020-03-27 15:52:38 +01001601 /* node's musts */
Michal Vaskod027f382023-02-10 09:13:25 +01001602 if ((r = lyd_validate_must(node, val_opts, int_opts, must_xp_opts))) {
1603 goto next_iter;
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001604 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001605
Michal Vasko53d97a12020-11-05 17:39:10 +01001606 /* node value was checked by plugins */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001607
Michal Vaskod027f382023-02-10 09:13:25 +01001608next_iter:
Michal Vaskod027f382023-02-10 09:13:25 +01001609 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001610 }
Michal Vaskocde73ac2019-11-14 16:10:27 +01001611
Michal Vasko14654712020-02-06 08:35:21 +01001612 /* validate schema-based restrictions */
Michal Vaskod027f382023-02-10 09:13:25 +01001613 r = lyd_validate_siblings_schema_r(first, parent, sparent, mod ? mod->compiled : NULL, val_opts, int_opts);
1614 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001615
Michal Vaskob1b5c262020-03-05 14:29:47 +01001616 LY_LIST_FOR(first, node) {
Michal Vaskodc9e27b2023-08-21 11:56:14 +02001617 if (!node->schema || (!node->parent && mod && (lyd_owner_module(node) != mod))) {
1618 /* only opaque data following or all top-level data from this module checked */
Michal Vasko19034e22021-07-19 12:24:14 +02001619 break;
1620 }
1621
Michal Vasko14654712020-02-06 08:35:21 +01001622 /* validate all children recursively */
Michal Vaskod027f382023-02-10 09:13:25 +01001623 r = lyd_validate_final_r(lyd_child(node), node, node->schema, NULL, val_opts, int_opts, must_xp_opts);
1624 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001625
Michal Vaskob1b5c262020-03-05 14:29:47 +01001626 /* set default for containers */
Michal Vasko4754d4a2022-12-01 10:11:21 +01001627 lyd_cont_set_dflt(node);
Michal Vasko9b368d32020-02-14 13:53:31 +01001628 }
1629
Michal Vaskod027f382023-02-10 09:13:25 +01001630cleanup:
1631 return rc;
Michal Vasko9b368d32020-02-14 13:53:31 +01001632}
1633
Radek Krejci7931b192020-06-25 17:05:03 +02001634/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001635 * @brief Validate extension instance data by storing it in its unres set.
1636 *
1637 * @param[in] sibling First sibling with ::LYD_EXT flag, all the following ones are expected to have it, too.
1638 * @param[in,out] ext_val Set with parsed extension instance data to validate.
1639 * @return LY_ERR value.
1640 */
1641static LY_ERR
1642lyd_validate_nested_ext(struct lyd_node *sibling, struct ly_set *ext_val)
1643{
1644 struct lyd_node *node;
1645 struct lyd_ctx_ext_val *ext_v;
1646 struct lysc_ext_instance *nested_exts, *ext = NULL;
1647 LY_ARRAY_COUNT_TYPE u;
1648
1649 /* check of basic assumptions */
1650 if (!sibling->parent || !sibling->parent->schema) {
1651 LOGINT_RET(LYD_CTX(sibling));
1652 }
1653 LY_LIST_FOR(sibling, node) {
1654 if (!(node->flags & LYD_EXT)) {
1655 LOGINT_RET(LYD_CTX(sibling));
1656 }
1657 }
1658
1659 /* try to find the extension instance */
1660 nested_exts = sibling->parent->schema->exts;
1661 LY_ARRAY_FOR(nested_exts, u) {
1662 if (nested_exts[u].def->plugin->validate) {
1663 if (ext) {
1664 /* more extension instances with validate callback */
1665 LOGINT_RET(LYD_CTX(sibling));
1666 }
1667 ext = &nested_exts[u];
1668 }
1669 }
1670 if (!ext) {
1671 /* no extension instance with validate callback */
1672 LOGINT_RET(LYD_CTX(sibling));
1673 }
1674
1675 /* store for validation */
1676 ext_v = malloc(sizeof *ext_v);
1677 LY_CHECK_ERR_RET(!ext_v, LOGMEM(LYD_CTX(sibling)), LY_EMEM);
1678 ext_v->ext = ext;
1679 ext_v->sibling = sibling;
1680 LY_CHECK_RET(ly_set_add(ext_val, ext_v, 1, NULL));
1681
1682 return LY_SUCCESS;
1683}
1684
Michal Vasko135719f2022-08-25 12:18:17 +02001685LY_ERR
1686lyd_validate_node_ext(struct lyd_node *node, struct ly_set *ext_node)
1687{
1688 struct lyd_ctx_ext_node *ext_n;
1689 struct lysc_ext_instance *exts;
1690 LY_ARRAY_COUNT_TYPE u;
1691
1692 /* try to find a relevant extension instance with node callback */
1693 exts = node->schema->exts;
1694 LY_ARRAY_FOR(exts, u) {
1695 if (exts[u].def->plugin && exts[u].def->plugin->node) {
1696 /* store for validation */
1697 ext_n = malloc(sizeof *ext_n);
1698 LY_CHECK_ERR_RET(!ext_n, LOGMEM(LYD_CTX(node)), LY_EMEM);
1699 ext_n->ext = &exts[u];
1700 ext_n->node = node;
1701 LY_CHECK_RET(ly_set_add(ext_node, ext_n, 1, NULL));
1702 }
1703 }
1704
1705 return LY_SUCCESS;
1706}
1707
Michal Vaskoddd76592022-01-17 13:34:48 +01001708/**
Michal Vaskobb844672020-07-03 11:06:12 +02001709 * @brief Validate the whole data subtree.
1710 *
1711 * @param[in] root Subtree root.
Michal Vaskoe0665742021-02-11 11:08:44 +01001712 * @param[in,out] node_when Set for nodes with when conditions.
Michal Vasko32711382020-12-03 14:14:31 +01001713 * @param[in,out] node_types Set for unres node types.
1714 * @param[in,out] meta_types Set for unres metadata types.
Michal Vasko1a6e6902022-08-26 08:35:09 +02001715 * @param[in,out] ext_node Set with nodes with extensions to validate.
Michal Vaskoddd76592022-01-17 13:34:48 +01001716 * @param[in,out] ext_val Set for parsed extension data to validate.
Michal Vaskod027f382023-02-10 09:13:25 +01001717 * @param[in] val_opts Validation options.
Michal Vasko8104fd42020-07-13 11:09:51 +02001718 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +02001719 * @return LY_ERR value.
Radek Krejci7931b192020-06-25 17:05:03 +02001720 */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001721static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001722lyd_validate_subtree(struct lyd_node *root, struct ly_set *node_when, struct ly_set *node_types,
Michal Vaskod027f382023-02-10 09:13:25 +01001723 struct ly_set *meta_types, struct ly_set *ext_node, struct ly_set *ext_val, uint32_t val_opts,
Michal Vasko1a6e6902022-08-26 08:35:09 +02001724 struct lyd_node **diff)
Michal Vaskofea12c62020-03-30 11:00:15 +02001725{
Michal Vaskod027f382023-02-10 09:13:25 +01001726 LY_ERR r, rc = LY_SUCCESS;
Michal Vaskofea12c62020-03-30 11:00:15 +02001727 const struct lyd_meta *meta;
Michal Vasko193dacd2022-10-13 08:43:05 +02001728 const struct lysc_type *type;
Michal Vasko56daf732020-08-10 10:57:18 +02001729 struct lyd_node *node;
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001730 uint32_t impl_opts;
Michal Vaskofea12c62020-03-30 11:00:15 +02001731
Michal Vasko56daf732020-08-10 10:57:18 +02001732 LYD_TREE_DFS_BEGIN(root, node) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001733 if (node->flags & LYD_EXT) {
1734 /* validate using the extension instance callback */
1735 return lyd_validate_nested_ext(node, ext_val);
1736 }
1737
Michal Vasko5900da42021-08-04 11:02:43 +02001738 if (!node->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001739 /* do not validate opaque nodes */
aPiecek18a844e2021-08-10 11:06:24 +02001740 goto next_node;
Michal Vasko5900da42021-08-04 11:02:43 +02001741 }
1742
Michal Vasko0275cf62020-11-05 17:40:30 +01001743 LY_LIST_FOR(node->meta, meta) {
Michal Vaskofbd037c2022-11-08 10:34:20 +01001744 lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type);
Michal Vasko193dacd2022-10-13 08:43:05 +02001745 if (type->plugin->validate) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001746 /* metadata type resolution */
Michal Vaskod027f382023-02-10 09:13:25 +01001747 r = ly_set_add(meta_types, (void *)meta, 1, NULL);
1748 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskofea12c62020-03-30 11:00:15 +02001749 }
Michal Vasko0275cf62020-11-05 17:40:30 +01001750 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001751
Michal Vasko0275cf62020-11-05 17:40:30 +01001752 if ((node->schema->nodetype & LYD_NODE_TERM) && ((struct lysc_node_leaf *)node->schema)->type->plugin->validate) {
1753 /* node type resolution */
Michal Vaskod027f382023-02-10 09:13:25 +01001754 r = ly_set_add(node_types, (void *)node, 1, NULL);
1755 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vasko0275cf62020-11-05 17:40:30 +01001756 } else if (node->schema->nodetype & LYD_NODE_INNER) {
1757 /* new node validation, autodelete */
Michal Vaskod027f382023-02-10 09:13:25 +01001758 r = lyd_validate_new(lyd_node_child_p(node), node->schema, NULL, val_opts, diff);
1759 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskofea12c62020-03-30 11:00:15 +02001760
Michal Vasko0275cf62020-11-05 17:40:30 +01001761 /* add nested defaults */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001762 impl_opts = 0;
1763 if (val_opts & LYD_VALIDATE_NO_STATE) {
1764 impl_opts |= LYD_IMPLICIT_NO_STATE;
1765 }
1766 if (val_opts & LYD_VALIDATE_NO_DEFAULTS) {
1767 impl_opts |= LYD_IMPLICIT_NO_DEFAULTS;
1768 }
1769 r = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, NULL, NULL, NULL, impl_opts, diff);
Michal Vaskod027f382023-02-10 09:13:25 +01001770 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vasko0275cf62020-11-05 17:40:30 +01001771 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001772
Michal Vaskof4d67ea2021-03-31 13:53:21 +02001773 if (lysc_has_when(node->schema)) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001774 /* when evaluation */
Michal Vaskod027f382023-02-10 09:13:25 +01001775 r = ly_set_add(node_when, (void *)node, 1, NULL);
1776 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskofea12c62020-03-30 11:00:15 +02001777 }
1778
Michal Vasko1a6e6902022-08-26 08:35:09 +02001779 /* store for ext instance node validation, if needed */
Michal Vaskod027f382023-02-10 09:13:25 +01001780 r = lyd_validate_node_ext(node, ext_node);
1781 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vasko1a6e6902022-08-26 08:35:09 +02001782
aPiecek18a844e2021-08-10 11:06:24 +02001783next_node:
Michal Vasko56daf732020-08-10 10:57:18 +02001784 LYD_TREE_DFS_END(root, node);
Michal Vaskofea12c62020-03-30 11:00:15 +02001785 }
1786
Michal Vaskod027f382023-02-10 09:13:25 +01001787cleanup:
1788 return rc;
Michal Vaskofea12c62020-03-30 11:00:15 +02001789}
1790
Michal Vaskoe0665742021-02-11 11:08:44 +01001791LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001792lyd_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 +01001793 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 +02001794 struct ly_set *ext_node_p, struct ly_set *ext_val_p, struct lyd_node **diff)
Michal Vaskof03ed032020-03-04 13:31:44 +01001795{
Michal Vaskod027f382023-02-10 09:13:25 +01001796 LY_ERR r, rc = LY_SUCCESS;
Michal Vasko73e47212020-12-03 14:20:16 +01001797 struct lyd_node *first, *next, **first2, *iter;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001798 const struct lys_module *mod;
Michal Vasko135719f2022-08-25 12:18:17 +02001799 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_node = {0}, ext_val = {0};
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001800 uint32_t i = 0, impl_opts;
Michal Vaskof03ed032020-03-04 13:31:44 +01001801
Michal Vaskoe0665742021-02-11 11:08:44 +01001802 assert(tree && ctx);
Michal Vasko135719f2022-08-25 12:18:17 +02001803 assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) ||
1804 (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001805
1806 if (!node_when_p) {
1807 node_when_p = &node_when;
1808 node_types_p = &node_types;
1809 meta_types_p = &meta_types;
Michal Vasko135719f2022-08-25 12:18:17 +02001810 ext_node_p = &ext_node;
Michal Vaskoddd76592022-01-17 13:34:48 +01001811 ext_val_p = &ext_val;
Michal Vasko8104fd42020-07-13 11:09:51 +02001812 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001813
Michal Vaskob1b5c262020-03-05 14:29:47 +01001814 next = *tree;
1815 while (1) {
Radek Krejci7931b192020-06-25 17:05:03 +02001816 if (val_opts & LYD_VALIDATE_PRESENT) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001817 mod = lyd_data_next_module(&next, &first);
1818 } else {
Michal Vasko26e80012020-07-08 10:55:46 +02001819 mod = lyd_mod_next_module(next, module, ctx, &i, &first);
Michal Vaskof03ed032020-03-04 13:31:44 +01001820 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001821 if (!mod) {
1822 break;
1823 }
Michal Vasko7c4cf1e2020-06-22 10:04:30 +02001824 if (!first || (first == *tree)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001825 /* make sure first2 changes are carried to tree */
1826 first2 = tree;
1827 } else {
1828 first2 = &first;
1829 }
1830
1831 /* validate new top-level nodes of this module, autodelete */
Michal Vaskoa6139e02023-10-03 14:13:22 +02001832 r = lyd_validate_new(first2, *first2 ? lysc_data_parent((*first2)->schema) : NULL, mod, val_opts, diff);
Michal Vaskod027f382023-02-10 09:13:25 +01001833 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001834
Radek Krejci7be7b9f2021-02-24 11:46:27 +01001835 /* add all top-level defaults for this module, if going to validate subtree, do not add into unres sets
1836 * (lyd_validate_subtree() adds all the nodes in that case) */
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001837 impl_opts = 0;
1838 if (val_opts & LYD_VALIDATE_NO_STATE) {
1839 impl_opts |= LYD_IMPLICIT_NO_STATE;
1840 }
1841 if (val_opts & LYD_VALIDATE_NO_DEFAULTS) {
1842 impl_opts |= LYD_IMPLICIT_NO_DEFAULTS;
1843 }
Michal Vaskoa6139e02023-10-03 14:13:22 +02001844 r = lyd_new_implicit_r(lyd_parent(*first2), first2, NULL, mod, validate_subtree ? NULL : node_when_p,
Michal Vaskoaf5a8dd2023-03-02 11:25:02 +01001845 validate_subtree ? NULL : node_types_p, validate_subtree ? NULL : ext_node_p, impl_opts, diff);
Michal Vaskod027f382023-02-10 09:13:25 +01001846 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001847
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001848 /* our first module node pointer may no longer be the first */
Michal Vasko598063b2021-07-19 11:39:05 +02001849 first = *first2;
1850 lyd_first_module_sibling(&first, mod);
1851 if (!first || (first == *tree)) {
1852 first2 = tree;
1853 } else {
1854 first2 = &first;
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001855 }
1856
Michal Vaskoe0665742021-02-11 11:08:44 +01001857 if (validate_subtree) {
1858 /* process nested nodes */
1859 LY_LIST_FOR(*first2, iter) {
Michal Vasko0e72b7a2021-07-16 14:53:27 +02001860 if (lyd_owner_module(iter) != mod) {
1861 break;
1862 }
1863
Michal Vaskod027f382023-02-10 09:13:25 +01001864 r = lyd_validate_subtree(iter, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p,
1865 val_opts, diff);
1866 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001867 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001868 }
1869
1870 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vaskod027f382023-02-10 09:13:25 +01001871 r = lyd_validate_unres(first2, mod, LYD_TYPE_DATA_YANG, node_when_p, 0, node_types_p, meta_types_p,
Michal Vasko135719f2022-08-25 12:18:17 +02001872 ext_node_p, ext_val_p, val_opts, diff);
Michal Vaskod027f382023-02-10 09:13:25 +01001873 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001874
Michal Vasko6b14c7e2023-11-09 12:08:14 +01001875 if (!(val_opts & LYD_VALIDATE_NOT_FINAL)) {
1876 /* perform final validation that assumes the data tree is final */
1877 r = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0);
1878 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
1879 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001880 }
1881
Michal Vaskof03ed032020-03-04 13:31:44 +01001882cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001883 ly_set_erase(&node_when, NULL);
Michal Vasko32711382020-12-03 14:14:31 +01001884 ly_set_erase(&node_types, NULL);
1885 ly_set_erase(&meta_types, NULL);
Michal Vasko135719f2022-08-25 12:18:17 +02001886 ly_set_erase(&ext_node, free);
Michal Vaskoddd76592022-01-17 13:34:48 +01001887 ly_set_erase(&ext_val, free);
Michal Vaskod027f382023-02-10 09:13:25 +01001888 return rc;
Michal Vaskof03ed032020-03-04 13:31:44 +01001889}
Michal Vaskob1b5c262020-03-05 14:29:47 +01001890
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001891LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001892lyd_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 +01001893{
Michal Vaskoe0665742021-02-11 11:08:44 +01001894 LY_CHECK_ARG_RET(NULL, tree, *tree || ctx, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001895 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001896 if (!ctx) {
1897 ctx = LYD_CTX(*tree);
1898 }
1899 if (diff) {
1900 *diff = NULL;
1901 }
1902
Michal Vasko135719f2022-08-25 12:18:17 +02001903 return lyd_validate(tree, NULL, ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001904}
1905
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001906LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001907lyd_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 +01001908{
Michal Vasko6b14c7e2023-11-09 12:08:14 +01001909 LY_CHECK_ARG_RET(NULL, tree, module, !(val_opts & LYD_VALIDATE_PRESENT), LY_EINVAL);
1910 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module->ctx, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001911 if (diff) {
1912 *diff = NULL;
1913 }
1914
Michal Vasko6b14c7e2023-11-09 12:08:14 +01001915 return lyd_validate(tree, module, module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff);
1916}
1917
1918LIBYANG_API_DEF LY_ERR
1919lyd_validate_module_final(struct lyd_node *tree, const struct lys_module *module, uint32_t val_opts)
1920{
1921 LY_ERR r, rc = LY_SUCCESS;
1922 struct lyd_node *first;
1923 const struct lys_module *mod;
1924 uint32_t i = 0;
1925
1926 LY_CHECK_ARG_RET(NULL, module, !(val_opts & (LYD_VALIDATE_PRESENT | LYD_VALIDATE_NOT_FINAL)), LY_EINVAL);
1927 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(tree), module->ctx, LY_EINVAL);
1928
1929 /* module is unchanged but we need to get the first module data node */
1930 mod = lyd_mod_next_module(tree, module, module->ctx, &i, &first);
1931 assert(mod);
1932
1933 /* perform final validation that assumes the data tree is final */
1934 r = lyd_validate_final_r(first, NULL, NULL, mod, val_opts, 0, 0);
1935 LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup);
1936
1937cleanup:
1938 return rc;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001939}
Michal Vaskofea12c62020-03-30 11:00:15 +02001940
Michal Vaskobb844672020-07-03 11:06:12 +02001941/**
1942 * @brief Find nodes for merging an operation into data tree for validation.
1943 *
1944 * @param[in] op_tree Full operation data tree.
1945 * @param[in] op_node Operation node itself.
1946 * @param[in] tree Data tree to be merged into.
1947 * @param[out] op_subtree Operation subtree to merge.
Michal Vasko2f03d222020-12-09 18:15:51 +01001948 * @param[out] tree_sibling Data tree sibling to merge next to, is set if @p tree_parent is NULL.
1949 * @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 +02001950 */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001951static void
Michal Vaskobb844672020-07-03 11:06:12 +02001952lyd_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 +01001953 struct lyd_node **op_subtree, struct lyd_node **tree_sibling, struct lyd_node **tree_parent)
Michal Vaskofea12c62020-03-30 11:00:15 +02001954{
Michal Vaskocb7526d2020-03-30 15:08:26 +02001955 const struct lyd_node *tree_iter, *op_iter;
Michal Vaskob10c93b2022-12-14 12:16:27 +01001956 struct lyd_node *match = NULL;
Michal Vaskofea12c62020-03-30 11:00:15 +02001957 uint32_t i, cur_depth, op_depth;
Michal Vaskofea12c62020-03-30 11:00:15 +02001958
Michal Vasko2f03d222020-12-09 18:15:51 +01001959 *op_subtree = NULL;
1960 *tree_sibling = NULL;
1961 *tree_parent = NULL;
1962
Michal Vaskocb7526d2020-03-30 15:08:26 +02001963 /* learn op depth (top-level being depth 0) */
Michal Vaskofea12c62020-03-30 11:00:15 +02001964 op_depth = 0;
Michal Vasko9e685082021-01-29 14:49:09 +01001965 for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001966 ++op_depth;
1967 }
1968
1969 /* find where to merge op */
1970 tree_iter = tree;
1971 cur_depth = op_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001972 while (cur_depth && tree_iter) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001973 /* find op iter in tree */
1974 lyd_find_sibling_first(tree_iter, op_iter, &match);
1975 if (!match) {
1976 break;
1977 }
1978
1979 /* move tree_iter */
Radek Krejcia1c1e542020-09-29 16:06:52 +02001980 tree_iter = lyd_child(match);
Michal Vaskofea12c62020-03-30 11:00:15 +02001981
1982 /* move depth */
1983 --cur_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001984
1985 /* find next op parent */
1986 op_iter = op_node;
1987 for (i = 0; i < cur_depth; ++i) {
Michal Vasko9e685082021-01-29 14:49:09 +01001988 op_iter = lyd_parent(op_iter);
Michal Vasko2f03d222020-12-09 18:15:51 +01001989 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001990 }
1991
Michal Vasko2f03d222020-12-09 18:15:51 +01001992 assert(op_iter);
Michal Vaskobb844672020-07-03 11:06:12 +02001993 *op_subtree = (struct lyd_node *)op_iter;
Michal Vasko2f03d222020-12-09 18:15:51 +01001994 if (!tree || tree_iter) {
1995 /* there is no tree whatsoever or this is the last found sibling */
1996 *tree_sibling = (struct lyd_node *)tree_iter;
1997 } else {
1998 /* matching parent was found but it has no children to insert next to */
1999 assert(match);
2000 *tree_parent = match;
2001 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02002002}
2003
Michal Vaskoe0665742021-02-11 11:08:44 +01002004/**
2005 * @brief Validate an RPC/action request, reply, or notification.
2006 *
2007 * @param[in] op_tree Full operation data tree.
2008 * @param[in] op_node Operation node itself.
2009 * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
2010 * @param[in] int_opts Internal parser options.
Michal Vaskofbbea932022-06-07 11:00:55 +02002011 * @param[in] data_type Type of validated data.
Michal Vaskoe0665742021-02-11 11:08:44 +01002012 * @param[in] validate_subtree Whether subtree was already validated (as part of data parsing) or not (separate validation).
2013 * @param[in] node_when_p Set of nodes with when conditions, if NULL a local set is used.
2014 * @param[in] node_types_p Set of unres node types, if NULL a local set is used.
2015 * @param[in] meta_types_p Set of unres metadata types, if NULL a local set is used.
Michal Vasko135719f2022-08-25 12:18:17 +02002016 * @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 +01002017 * @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 +01002018 * @param[out] diff Optional diff with any changes made by the validation.
2019 * @return LY_SUCCESS on success.
2020 * @return LY_ERR error on error.
2021 */
2022static LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +02002023_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 +01002024 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 +02002025 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 +02002026{
Michal Vaskoe0665742021-02-11 11:08:44 +01002027 LY_ERR rc = LY_SUCCESS;
Michal Vaskofbbea932022-06-07 11:00:55 +02002028 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 +02002029 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 +02002030
Michal Vaskoe0665742021-02-11 11:08:44 +01002031 assert(op_tree && op_node);
Michal Vasko135719f2022-08-25 12:18:17 +02002032 assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) ||
2033 (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01002034
2035 if (!node_when_p) {
2036 node_when_p = &node_when;
2037 node_types_p = &node_types;
2038 meta_types_p = &meta_types;
Michal Vasko135719f2022-08-25 12:18:17 +02002039 ext_node_p = &ext_node;
Michal Vaskoddd76592022-01-17 13:34:48 +01002040 ext_val_p = &ext_val;
Michal Vaskoe0665742021-02-11 11:08:44 +01002041 }
2042
2043 /* merge op_tree into dep_tree */
2044 lyd_val_op_merge_find(op_tree, op_node, dep_tree, &op_subtree, &tree_sibling, &tree_parent);
Michal Vaskoc61dd062022-06-07 11:01:28 +02002045 op_sibling_before = op_subtree->prev->next ? op_subtree->prev : NULL;
2046 op_sibling_after = op_subtree->next;
Michal Vaskoe0665742021-02-11 11:08:44 +01002047 op_parent = lyd_parent(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02002048
Michal Vasko2e784f82024-01-11 09:51:22 +01002049 lyd_unlink(op_subtree);
aPiecek1462ab12024-02-07 09:13:29 +01002050 lyd_insert_node(tree_parent, &tree_sibling, op_subtree, LYD_INSERT_NODE_DEFAULT);
Michal Vaskoe0665742021-02-11 11:08:44 +01002051 if (!dep_tree) {
2052 dep_tree = tree_sibling;
2053 }
2054
Michal Vaskoe0665742021-02-11 11:08:44 +01002055 if (int_opts & LYD_INTOPT_REPLY) {
2056 /* add output children defaults */
Michal Vaskoddd76592022-01-17 13:34:48 +01002057 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 +02002058 ext_node_p, LYD_IMPLICIT_OUTPUT, diff);
Michal Vaskoe0665742021-02-11 11:08:44 +01002059 LY_CHECK_GOTO(rc, cleanup);
2060
2061 if (validate_subtree) {
2062 /* skip validating the operation itself, go to children directly */
2063 LY_LIST_FOR(lyd_child(op_node), child) {
Michal Vasko1a6e6902022-08-26 08:35:09 +02002064 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 +02002065 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01002066 }
2067 }
2068 } else {
2069 if (validate_subtree) {
2070 /* prevalidate whole operation subtree */
Michal Vasko1a6e6902022-08-26 08:35:09 +02002071 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 +02002072 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01002073 }
2074 }
2075
Michal Vasko906bafa2022-04-22 12:28:55 +02002076 /* finish incompletely validated terminal values/attributes and when conditions on the full tree,
2077 * account for unresolved 'when' that may appear in the non-validated dependency data tree */
Michal Vaskofbbea932022-06-07 11:00:55 +02002078 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 +02002079 node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01002080
2081 /* perform final validation of the operation/notification */
2082 lyd_validate_obsolete(op_node);
Michal Vaskod027f382023-02-10 09:13:25 +01002083 LY_CHECK_GOTO(rc = lyd_validate_must(op_node, 0, int_opts, LYXP_IGNORE_WHEN), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01002084
2085 /* final validation of all the descendants */
Michal Vasko906bafa2022-04-22 12:28:55 +02002086 rc = lyd_validate_final_r(lyd_child(op_node), op_node, op_node->schema, NULL, 0, int_opts, LYXP_IGNORE_WHEN);
2087 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01002088
2089cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01002090 /* restore operation tree */
Michal Vasko2e784f82024-01-11 09:51:22 +01002091 lyd_unlink(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02002092 if (op_sibling_before) {
aPiecek743184b2024-02-01 13:25:56 +01002093 lyd_insert_after_node(NULL, op_sibling_before, op_subtree);
Michal Vasko123f1c02023-08-15 13:14:46 +02002094 lyd_insert_hash(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02002095 } else if (op_sibling_after) {
2096 lyd_insert_before_node(op_sibling_after, op_subtree);
Michal Vasko123f1c02023-08-15 13:14:46 +02002097 lyd_insert_hash(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02002098 } else if (op_parent) {
aPiecek1462ab12024-02-07 09:13:29 +01002099 lyd_insert_node(op_parent, NULL, op_subtree, LYD_INSERT_NODE_DEFAULT);
Michal Vaskoe0665742021-02-11 11:08:44 +01002100 }
2101
2102 ly_set_erase(&node_when, NULL);
2103 ly_set_erase(&node_types, NULL);
2104 ly_set_erase(&meta_types, NULL);
Michal Vasko135719f2022-08-25 12:18:17 +02002105 ly_set_erase(&ext_node, free);
Michal Vaskoddd76592022-01-17 13:34:48 +01002106 ly_set_erase(&ext_val, free);
Michal Vaskoe0665742021-02-11 11:08:44 +01002107 return rc;
2108}
2109
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002110LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01002111lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type, struct lyd_node **diff)
2112{
2113 struct lyd_node *op_node;
2114 uint32_t int_opts;
Michal Vaskofbbea932022-06-07 11:00:55 +02002115 struct ly_set ext_val = {0};
2116 LY_ERR rc;
Michal Vaskoe0665742021-02-11 11:08:44 +01002117
Michal Vasko2da45692022-04-29 09:51:08 +02002118 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 +01002119 (data_type == LYD_TYPE_NOTIF_YANG) || (data_type == LYD_TYPE_REPLY_YANG), LY_EINVAL);
Michal Vasko8104fd42020-07-13 11:09:51 +02002120 if (diff) {
2121 *diff = NULL;
2122 }
Michal Vasko1e4c68e2021-02-18 15:03:01 +01002123 if (data_type == LYD_TYPE_RPC_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01002124 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01002125 } else if (data_type == LYD_TYPE_NOTIF_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01002126 int_opts = LYD_INTOPT_NOTIF;
2127 } else {
2128 int_opts = LYD_INTOPT_REPLY;
2129 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02002130
Michal Vasko2da45692022-04-29 09:51:08 +02002131 if (op_tree->schema && (op_tree->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF))) {
2132 /* we have the operation/notification, adjust the pointers */
2133 op_node = op_tree;
2134 while (op_tree->parent) {
2135 op_tree = lyd_parent(op_tree);
Michal Vaskocb7526d2020-03-30 15:08:26 +02002136 }
Michal Vasko2da45692022-04-29 09:51:08 +02002137 } else {
2138 /* find the operation/notification */
2139 while (op_tree->parent) {
2140 op_tree = lyd_parent(op_tree);
2141 }
2142 LYD_TREE_DFS_BEGIN(op_tree, op_node) {
2143 if (!op_node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02002144 return lyd_parse_opaq_error(op_node);
Michal Vaskofbbea932022-06-07 11:00:55 +02002145 } else if (op_node->flags & LYD_EXT) {
2146 /* fully validate the rest using the extension instance callback */
2147 LY_CHECK_RET(lyd_validate_nested_ext(op_node, &ext_val));
Michal Vasko135719f2022-08-25 12:18:17 +02002148 rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, NULL, 0, NULL, NULL, NULL,
2149 &ext_val, 0, diff);
Michal Vaskofbbea932022-06-07 11:00:55 +02002150 ly_set_erase(&ext_val, free);
2151 return rc;
Michal Vasko2da45692022-04-29 09:51:08 +02002152 }
2153
2154 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) &&
2155 (op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
2156 break;
2157 } else if ((int_opts & LYD_INTOPT_NOTIF) && (op_node->schema->nodetype == LYS_NOTIF)) {
2158 break;
2159 }
2160 LYD_TREE_DFS_END(op_tree, op_node);
2161 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02002162 }
Michal Vasko2da45692022-04-29 09:51:08 +02002163
Michal Vaskoe0665742021-02-11 11:08:44 +01002164 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) {
Michal Vasko9b232082022-06-07 10:59:31 +02002165 if (!op_node || !(op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002166 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No RPC/action to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02002167 return LY_EINVAL;
2168 }
2169 } else {
Michal Vasko9b232082022-06-07 10:59:31 +02002170 if (!op_node || (op_node->schema->nodetype != LYS_NOTIF)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02002171 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No notification to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02002172 return LY_EINVAL;
2173 }
2174 }
2175
Michal Vaskoe0665742021-02-11 11:08:44 +01002176 /* validate */
Michal Vasko135719f2022-08-25 12:18:17 +02002177 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 +02002178}