blob: 548ff4c754ae73d41570b31ea3cd4672519fd7fc [file] [log] [blame]
Michal Vaskocde73ac2019-11-14 16:10:27 +01001/**
2 * @file validation.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief Validation
5 *
Michal Vasko906bafa2022-04-22 12:28:55 +02006 * Copyright (c) 2019 - 2022 CESNET, z.s.p.o.
Michal Vaskocde73ac2019-11-14 16:10:27 +01007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Christian Hopps32874e12021-05-01 09:43:54 -040014#define _GNU_SOURCE /* asprintf, strdup */
Michal Vasko81bc5512020-11-13 18:05:18 +010015
Michal Vaskofbed4ea2020-07-08 10:43:30 +020016#include "validation.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010017
18#include <assert.h>
Radek Krejci77114102021-03-10 15:21:57 +010019#include <limits.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020020#include <stdint.h>
Michal Vasko52927e22020-03-16 17:26:14 +010021#include <stdio.h>
22#include <stdlib.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020023#include <string.h>
Michal Vaskocde73ac2019-11-14 16:10:27 +010024
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
Michal Vasko69730152020-10-09 16:30:07 +020026#include "compat.h"
Michal Vasko8104fd42020-07-13 11:09:51 +020027#include "diff.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "hash_table.h"
29#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020030#include "parser_data.h"
Radek Krejci77114102021-03-10 15:21:57 +010031#include "parser_internal.h"
Radek Krejci1b2eef82021-02-17 11:17:27 +010032#include "plugins_exts.h"
Radek Krejcif1ca0ac2021-04-12 16:00:06 +020033#include "plugins_exts/metadata.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020034#include "plugins_types.h"
35#include "set.h"
36#include "tree.h"
Radek Krejci47fab892020-11-05 17:02:41 +010037#include "tree_data.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010038#include "tree_data_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020039#include "tree_schema.h"
Michal Vasko14654712020-02-06 08:35:21 +010040#include "tree_schema_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020041#include "xpath.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010042
Michal Vaskoa6669ba2020-08-06 16:14:26 +020043LY_ERR
Michal Vasko8104fd42020-07-13 11:09:51 +020044lyd_val_diff_add(const struct lyd_node *node, enum lyd_diff_op op, struct lyd_node **diff)
45{
46 LY_ERR ret = LY_SUCCESS;
47 struct lyd_node *new_diff = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010048 const struct lyd_node *prev_inst;
Michal Vaskoe78faec2021-04-08 17:24:43 +020049 char *key = NULL, *value = NULL, *position = NULL;
Michal Vasko81bc5512020-11-13 18:05:18 +010050 size_t buflen = 0, bufused = 0;
Michal Vaskoe78faec2021-04-08 17:24:43 +020051 uint32_t pos;
Michal Vasko8104fd42020-07-13 11:09:51 +020052
53 assert((op == LYD_DIFF_OP_DELETE) || (op == LYD_DIFF_OP_CREATE));
54
Michal Vasko81bc5512020-11-13 18:05:18 +010055 if ((op == LYD_DIFF_OP_CREATE) && lysc_is_userordered(node->schema)) {
Michal Vaskoe78faec2021-04-08 17:24:43 +020056 if (lysc_is_dup_inst_list(node->schema)) {
57 pos = lyd_list_pos(node);
Michal Vasko81bc5512020-11-13 18:05:18 +010058
Michal Vaskoe78faec2021-04-08 17:24:43 +020059 /* generate position meta */
60 if (pos > 1) {
61 if (asprintf(&position, "%" PRIu32, pos - 1) == -1) {
62 LOGMEM(LYD_CTX(node));
63 ret = LY_EMEM;
64 goto cleanup;
65 }
Michal Vasko81bc5512020-11-13 18:05:18 +010066 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020067 position = strdup("");
68 LY_CHECK_ERR_GOTO(!position, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
Michal Vasko81bc5512020-11-13 18:05:18 +010069 }
70 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020071 if (node->prev->next && (node->prev->schema == node->schema)) {
72 prev_inst = node->prev;
Michal Vasko81bc5512020-11-13 18:05:18 +010073 } else {
Michal Vaskoe78faec2021-04-08 17:24:43 +020074 /* first instance */
75 prev_inst = NULL;
76 }
77
78 if (node->schema->nodetype == LYS_LIST) {
79 /* generate key meta */
80 if (prev_inst) {
81 LY_CHECK_GOTO(ret = lyd_path_list_predicate(prev_inst, &key, &buflen, &bufused, 0), cleanup);
82 } else {
83 key = strdup("");
84 LY_CHECK_ERR_GOTO(!key, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
85 }
86 } else {
87 /* generate value meta */
88 if (prev_inst) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +020089 value = strdup(lyd_get_value(prev_inst));
Michal Vaskoe78faec2021-04-08 17:24:43 +020090 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
91 } else {
92 value = strdup("");
93 LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup);
94 }
Michal Vasko81bc5512020-11-13 18:05:18 +010095 }
96 }
97 }
98
Michal Vasko8104fd42020-07-13 11:09:51 +020099 /* create new diff tree */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200100 LY_CHECK_GOTO(ret = lyd_diff_add(node, op, NULL, NULL, key, value, position, NULL, NULL, &new_diff), cleanup);
Michal Vasko8104fd42020-07-13 11:09:51 +0200101
102 /* merge into existing diff */
Michal Vaskoc0e58e82020-11-11 19:04:33 +0100103 ret = lyd_diff_merge_all(diff, new_diff, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +0200104
Michal Vasko81bc5512020-11-13 18:05:18 +0100105cleanup:
Michal Vasko8104fd42020-07-13 11:09:51 +0200106 lyd_free_tree(new_diff);
Michal Vasko81bc5512020-11-13 18:05:18 +0100107 free(key);
108 free(value);
Michal Vaskoe78faec2021-04-08 17:24:43 +0200109 free(position);
Michal Vasko8104fd42020-07-13 11:09:51 +0200110 return ret;
111}
112
113/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100114 * @brief Evaluate all relevant "when" conditions of a node.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100115 *
Michal Vaskobd4db892020-11-23 16:58:20 +0100116 * @param[in] tree Data tree.
117 * @param[in] node Node whose relevant when conditions will be evaluated.
118 * @param[in] schema Schema node of @p node. It may not be possible to use directly if @p node is opaque.
Michal Vasko976ec432021-12-06 15:42:22 +0100119 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobd4db892020-11-23 16:58:20 +0100120 * @param[out] disabled First when that evaluated false, if any.
121 * @return LY_SUCCESS on success.
122 * @return LY_EINCOMPLETE if a referenced node does not have its when evaluated.
123 * @return LY_ERR value on error.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100124 */
125static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100126lyd_validate_node_when(const struct lyd_node *tree, const struct lyd_node *node, const struct lysc_node *schema,
Michal Vasko976ec432021-12-06 15:42:22 +0100127 uint32_t xpath_options, const struct lysc_when **disabled)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100128{
Michal Vasko8104fd42020-07-13 11:09:51 +0200129 LY_ERR ret;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100130 const struct lyd_node *ctx_node;
131 struct lyxp_set xp_set;
Michal Vaskobd4db892020-11-23 16:58:20 +0100132 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100133
Michal Vaskobd4db892020-11-23 16:58:20 +0100134 assert(!node->schema || (node->schema == schema));
Michal Vaskocde73ac2019-11-14 16:10:27 +0100135
Michal Vaskobd4db892020-11-23 16:58:20 +0100136 *disabled = NULL;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100137
Michal Vaskobd4db892020-11-23 16:58:20 +0100138 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100139 const struct lysc_when *when;
140 struct lysc_when **when_list = lysc_node_when(schema);
141 LY_ARRAY_FOR(when_list, u) {
142 when = when_list[u];
Michal Vaskocde73ac2019-11-14 16:10:27 +0100143
Michal Vaskobd4db892020-11-23 16:58:20 +0100144 /* get context node */
145 if (when->context == schema) {
146 ctx_node = node;
147 } else {
148 assert((!when->context && !node->parent) || (when->context == node->parent->schema));
Michal Vasko9e685082021-01-29 14:49:09 +0100149 ctx_node = lyd_parent(node);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100150 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100151
152 /* evaluate when */
153 memset(&xp_set, 0, sizeof xp_set);
Radek Krejci8df109d2021-04-23 12:19:08 +0200154 ret = lyxp_eval(LYD_CTX(node), when->cond, schema->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200155 ctx_node, ctx_node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskobd4db892020-11-23 16:58:20 +0100156 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
157
158 /* return error or LY_EINCOMPLETE for dependant unresolved when */
159 LY_CHECK_RET(ret);
160
161 if (!xp_set.val.bln) {
162 /* false when */
163 *disabled = when;
164 return LY_SUCCESS;
Michal Vasko8104fd42020-07-13 11:09:51 +0200165 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100166 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100167
168 schema = schema->parent;
169 } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
170
171 return LY_SUCCESS;
172}
173
174/**
175 * @brief Evaluate when conditions of collected unres nodes.
176 *
177 * @param[in,out] tree Data tree, is updated if some nodes are autodeleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100178 * @param[in] mod Module of the @p tree to take into consideration when deleting @p tree and moving it.
179 * If set, it is expected @p tree should point to the first node of @p mod. Otherwise it will simply be
180 * the first top-level sibling.
Michal Vaskobd4db892020-11-23 16:58:20 +0100181 * @param[in] node_when Set with nodes with "when" conditions.
Michal Vasko976ec432021-12-06 15:42:22 +0100182 * @param[in] xpath_options Additional XPath options to use.
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200183 * @param[in,out] node_types Set with nodes with unresolved types, remove any with false "when" parents.
Michal Vaskobd4db892020-11-23 16:58:20 +0100184 * @param[in,out] diff Validation diff.
185 * @return LY_SUCCESS on success.
186 * @return LY_ERR value on error.
187 */
188static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100189lyd_validate_unres_when(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when,
Michal Vasko976ec432021-12-06 15:42:22 +0100190 uint32_t xpath_options, struct ly_set *node_types, struct lyd_node **diff)
Michal Vaskobd4db892020-11-23 16:58:20 +0100191{
192 LY_ERR ret;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200193 uint32_t i, idx;
Michal Vaskobd4db892020-11-23 16:58:20 +0100194 const struct lysc_when *disabled;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200195 struct lyd_node *node = NULL, *elem;
Michal Vaskobd4db892020-11-23 16:58:20 +0100196
197 if (!node_when->count) {
198 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100199 }
200
Michal Vaskobd4db892020-11-23 16:58:20 +0100201 i = node_when->count;
202 do {
203 --i;
204 node = node_when->dnodes[i];
Radek Krejciddace2c2021-01-08 11:30:56 +0100205 LOG_LOCSET(node->schema, node, NULL, NULL);
Michal Vaskobd4db892020-11-23 16:58:20 +0100206
207 /* evaluate all when expressions that affect this node's existence */
Michal Vasko976ec432021-12-06 15:42:22 +0100208 ret = lyd_validate_node_when(*tree, node, node->schema, xpath_options, &disabled);
Michal Vaskobd4db892020-11-23 16:58:20 +0100209 if (!ret) {
210 if (disabled) {
211 /* when false */
212 if (node->flags & LYD_WHEN_TRUE) {
213 /* autodelete */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100214 lyd_del_move_root(tree, node, mod);
Michal Vaskobd4db892020-11-23 16:58:20 +0100215 if (diff) {
216 /* add into diff */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100217 ret = lyd_val_diff_add(node, LYD_DIFF_OP_DELETE, diff);
218 LY_CHECK_GOTO(ret, error);
Michal Vaskobd4db892020-11-23 16:58:20 +0100219 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200220
221 /* remove from node types set, if present */
Michal Vasko36ce6b22021-07-26 09:19:21 +0200222 if (node_types) {
223 LYD_TREE_DFS_BEGIN(node, elem) {
224 if (ly_set_contains(node_types, elem, &idx)) {
225 LY_CHECK_GOTO(ret = ly_set_rm_index(node_types, idx, NULL), error);
226 }
227 LYD_TREE_DFS_END(node, elem);
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200228 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200229 }
230
231 /* free */
Michal Vaskobd4db892020-11-23 16:58:20 +0100232 lyd_free_tree(node);
233 } else {
234 /* invalid data */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100235 LOGVAL(LYD_CTX(node), LY_VCODE_NOWHEN, disabled->cond->expr);
236 ret = LY_EVALID;
237 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100238 }
239 } else {
240 /* when true */
241 node->flags |= LYD_WHEN_TRUE;
242 }
243
Michal Vasko413af592021-12-13 11:50:51 +0100244 /* remove this node from the set keeping the order, its when was resolved */
245 ly_set_rm_index_ordered(node_when, i, NULL);
Michal Vaskobd4db892020-11-23 16:58:20 +0100246 } else if (ret != LY_EINCOMPLETE) {
247 /* error */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100248 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100249 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100250
Radek Krejciddace2c2021-01-08 11:30:56 +0100251 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskobd4db892020-11-23 16:58:20 +0100252 } while (i);
253
254 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100255
256error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100257 LOG_LOCBACK(1, 1, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100258 return ret;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100259}
260
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200261LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +0200262lyd_validate_unres(struct lyd_node **tree, const struct lys_module *mod, enum lyd_type data_type, struct ly_set *node_when,
263 uint32_t when_xp_opts, struct ly_set *node_types, struct ly_set *meta_types, struct ly_set *ext_val,
264 uint32_t val_opts, struct lyd_node **diff)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100265{
266 LY_ERR ret = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200267 uint32_t i;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100268
Michal Vaskoddd76592022-01-17 13:34:48 +0100269 if (ext_val && ext_val->count) {
270 /* first validate parsed extension data */
271 i = ext_val->count;
272 do {
273 --i;
274
275 struct lyd_ctx_ext_val *ext_v = ext_val->objs[i];
276
277 /* validate extension data */
Michal Vaskofbbea932022-06-07 11:00:55 +0200278 ret = ext_v->ext->def->plugin->validate(ext_v->ext, ext_v->sibling, *tree, data_type, val_opts, diff);
Michal Vaskoddd76592022-01-17 13:34:48 +0100279 LY_CHECK_RET(ret);
280
281 /* remove this item from the set */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200282 ly_set_rm_index(ext_val, i, free);
Michal Vaskoddd76592022-01-17 13:34:48 +0100283 } while (i);
284 }
285
Michal Vaskob1b5c262020-03-05 14:29:47 +0100286 if (node_when) {
287 /* evaluate all when conditions */
288 uint32_t prev_count;
289 do {
290 prev_count = node_when->count;
Michal Vasko976ec432021-12-06 15:42:22 +0100291 LY_CHECK_RET(lyd_validate_unres_when(tree, mod, node_when, when_xp_opts, node_types, diff));
Radek Krejci0f969882020-08-21 16:56:47 +0200292 /* there must have been some when conditions resolved */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100293 } while (prev_count > node_when->count);
Michal Vaskocde73ac2019-11-14 16:10:27 +0100294
Michal Vaskob1b5c262020-03-05 14:29:47 +0100295 /* there could have been no cyclic when dependencies, checked during compilation */
296 assert(!node_when->count);
297 }
298
299 if (node_types && node_types->count) {
300 /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200301 i = node_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100302 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200303 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100304
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100305 struct lyd_node_term *node = node_types->objs[i];
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200306 struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100307
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200308 /* resolve the value of the node */
Michal Vasko9e685082021-01-29 14:49:09 +0100309 LOG_LOCSET(node->schema, &node->node, NULL, NULL);
310 ret = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree);
Radek Krejciddace2c2021-01-08 11:30:56 +0100311 LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100312 LY_CHECK_RET(ret);
313
314 /* remove this node from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200315 ly_set_rm_index(node_types, i, NULL);
316 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100317 }
318
Michal Vasko9f96a052020-03-10 09:41:45 +0100319 if (meta_types && meta_types->count) {
320 /* ... and metadata values */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200321 i = meta_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100322 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200323 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100324
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100325 struct lyd_meta *meta = meta_types->objs[i];
Radek Krejci1b2eef82021-02-17 11:17:27 +0100326 struct lysc_type *type = *(struct lysc_type **)meta->annotation->substmts[ANNOTATION_SUBSTMT_TYPE].storage;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100327
Michal Vasko9f96a052020-03-10 09:41:45 +0100328 /* validate and store the value of the metadata */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100329 ret = lyd_value_validate_incomplete(LYD_CTX(meta->parent), type, &meta->value, meta->parent, *tree);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100330 LY_CHECK_RET(ret);
331
332 /* remove this attr from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200333 ly_set_rm_index(meta_types, i, NULL);
334 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100335 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100336
337 return ret;
338}
339
Michal Vaskobb844672020-07-03 11:06:12 +0200340/**
341 * @brief Validate instance duplication.
342 *
343 * @param[in] first First sibling to search in.
344 * @param[in] node Data node instance to check.
345 * @return LY_ERR value.
346 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100347static LY_ERR
348lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100349{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100350 struct lyd_node **match_p;
Radek Krejci857189e2020-09-01 13:26:36 +0200351 ly_bool fail = 0;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100352
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100353 assert(node->flags & LYD_NEW);
354
Michal Vaskod6c18af2021-02-12 12:07:31 +0100355 /* key-less list or non-configuration leaf-list */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200356 if (lysc_is_dup_inst_list(node->schema)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100357 /* duplicate instances allowed */
358 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100359 }
360
Michal Vaskob1b5c262020-03-05 14:29:47 +0100361 /* find exactly the same next instance using hashes if possible */
362 if (node->parent && node->parent->children_ht) {
363 if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
364 fail = 1;
365 }
366 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200367 for ( ; first; first = first->next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100368 if (first == node) {
369 continue;
370 }
371
372 if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
373 if (first->schema == node->schema) {
374 fail = 1;
375 break;
376 }
Michal Vasko8f359bf2020-07-28 10:41:15 +0200377 } else if (!lyd_compare_single(first, node, 0)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100378 fail = 1;
379 break;
380 }
381 }
382 }
383
384 if (fail) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100385 LOGVAL(node->schema->module->ctx, LY_VCODE_DUP, node->schema->name);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100386 return LY_EVALID;
387 }
388 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100389}
390
Michal Vaskobb844672020-07-03 11:06:12 +0200391/**
392 * @brief Validate multiple case data existence with possible autodelete.
393 *
394 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100395 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200396 * @param[in] choic Choice node whose cases to check.
Michal Vasko8104fd42020-07-13 11:09:51 +0200397 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200398 * @return LY_ERR value.
399 */
Michal Vaskocde73ac2019-11-14 16:10:27 +0100400static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100401lyd_validate_cases(struct lyd_node **first, const struct lys_module *mod, const struct lysc_node_choice *choic,
402 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100403{
404 const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
405 struct lyd_node *match, *to_del;
Radek Krejci857189e2020-09-01 13:26:36 +0200406 ly_bool found;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100407
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100408 LOG_LOCSET(&choic->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100409
Michal Vaskob1b5c262020-03-05 14:29:47 +0100410 LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
411 found = 0;
412 iter = NULL;
413 match = NULL;
414 while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) {
415 if (match->flags & LYD_NEW) {
416 /* a new case data found, nothing more to look for */
417 found = 2;
418 break;
419 } else {
420 /* and old case data found */
421 if (found == 0) {
422 found = 1;
423 }
424 }
425 }
426
427 if (found == 1) {
428 /* there should not be 2 old cases */
429 if (old_case) {
430 /* old data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100431 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, old_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100432 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100433 return LY_EVALID;
434 }
435
436 /* remember an old existing case */
437 old_case = scase;
438 } else if (found == 2) {
439 if (new_case) {
440 /* new data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100441 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, new_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100442 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100443 return LY_EVALID;
444 }
445
446 /* remember a new existing case */
447 new_case = scase;
448 }
449 }
450
Radek Krejciddace2c2021-01-08 11:30:56 +0100451 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100452
Michal Vaskob1b5c262020-03-05 14:29:47 +0100453 if (old_case && new_case) {
454 /* auto-delete old case */
455 iter = NULL;
456 match = NULL;
457 to_del = NULL;
458 while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100459 lyd_del_move_root(first, to_del, mod);
460
Michal Vasko8104fd42020-07-13 11:09:51 +0200461 /* free previous node */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100462 lyd_free_tree(to_del);
Michal Vasko8104fd42020-07-13 11:09:51 +0200463 if (diff) {
464 /* add into diff */
465 LY_CHECK_RET(lyd_val_diff_add(match, LYD_DIFF_OP_DELETE, diff));
466 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100467 to_del = match;
468 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100469 lyd_del_move_root(first, to_del, mod);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100470 lyd_free_tree(to_del);
471 }
472
473 return LY_SUCCESS;
474}
475
Michal Vaskobb844672020-07-03 11:06:12 +0200476/**
477 * @brief Check whether a schema node can have some default values (true for NP containers as well).
478 *
479 * @param[in] schema Schema node to check.
480 * @return non-zero if yes,
481 * @return 0 otherwise.
482 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100483static int
484lyd_val_has_default(const struct lysc_node *schema)
485{
486 switch (schema->nodetype) {
487 case LYS_LEAF:
488 if (((struct lysc_node_leaf *)schema)->dflt) {
489 return 1;
490 }
491 break;
492 case LYS_LEAFLIST:
493 if (((struct lysc_node_leaflist *)schema)->dflts) {
494 return 1;
495 }
496 break;
497 case LYS_CONTAINER:
498 if (!(schema->flags & LYS_PRESENCE)) {
499 return 1;
500 }
501 break;
502 default:
503 break;
504 }
505
506 return 0;
507}
508
Michal Vaskobb844672020-07-03 11:06:12 +0200509/**
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100510 * @brief Properly delete a node as part of autodelete validation tasks.
511 *
512 * @param[in,out] first First sibling, is updated if needed.
513 * @param[in] node Node instance to delete.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100514 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100515 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
516 * @param[in,out] diff Validation diff.
517 */
518static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100519lyd_validate_autodel_node_del(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
520 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100521{
522 struct lyd_node *iter;
523
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100524 lyd_del_move_root(first, node, mod);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100525 if (node == *next_p) {
526 *next_p = (*next_p)->next;
527 }
528 if (diff) {
529 /* add into diff */
530 if ((node->schema->nodetype == LYS_CONTAINER) && !(node->schema->flags & LYS_PRESENCE)) {
531 /* we do not want to track NP container changes, but remember any removed children */
532 LY_LIST_FOR(lyd_child(node), iter) {
533 lyd_val_diff_add(iter, LYD_DIFF_OP_DELETE, diff);
534 }
535 } else {
536 lyd_val_diff_add(node, LYD_DIFF_OP_DELETE, diff);
537 }
538 }
539 lyd_free_tree(node);
540}
541
542/**
Michal Vaskobb844672020-07-03 11:06:12 +0200543 * @brief Autodelete old instances to prevent validation errors.
544 *
545 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100546 * @param[in] node New data node instance to check.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100547 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200548 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
Michal Vasko8104fd42020-07-13 11:09:51 +0200549 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200550 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100551static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100552lyd_validate_autodel_dup(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
553 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100554{
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100555 struct lyd_node *match, *next;
556
557 assert(node->flags & LYD_NEW);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100558
559 if (lyd_val_has_default(node->schema)) {
560 assert(node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CONTAINER));
Michal Vasko4c583e82020-07-17 12:16:14 +0200561 LYD_LIST_FOR_INST_SAFE(*first, node->schema, next, match) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100562 if ((match->flags & LYD_DEFAULT) && !(match->flags & LYD_NEW)) {
563 /* default instance found, remove it */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100564 lyd_validate_autodel_node_del(first, match, mod, next_p, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100565
566 /* remove only a single container/leaf default instance, if there are more, it is an error */
567 if (node->schema->nodetype & (LYS_LEAF | LYS_CONTAINER)) {
568 break;
569 }
570 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100571 }
572 }
573}
574
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100575/**
576 * @brief Autodelete leftover default nodes of deleted cases (that have no existing explicit data).
577 *
578 * @param[in,out] first First sibling to search in, is updated if needed.
579 * @param[in] node Default data node instance to check.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100580 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100581 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
582 * @param[in,out] diff Validation diff.
583 */
584static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100585lyd_validate_autodel_case_dflt(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
586 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100587{
588 struct lysc_node_choice *choic;
589 struct lyd_node *iter = NULL;
590 const struct lysc_node *slast = NULL;
591
592 assert(node->flags & LYD_DEFAULT);
593
594 if (!node->schema->parent || (node->schema->parent->nodetype != LYS_CASE)) {
595 /* the default node is not a descendant of a case */
596 return;
597 }
598
599 choic = (struct lysc_node_choice *)node->schema->parent->parent;
600 assert(choic->nodetype == LYS_CHOICE);
601
602 if (choic->dflt && (choic->dflt == (struct lysc_node_case *)node->schema->parent)) {
603 /* data of a default case, keep them */
604 return;
605 }
606
607 /* try to find an explicit node of the case */
608 while ((iter = lys_getnext_data(iter, *first, &slast, node->schema->parent, NULL))) {
609 if (!(iter->flags & LYD_DEFAULT)) {
610 break;
611 }
612 }
613
614 if (!iter) {
615 /* there are only default nodes of the case meaning it does not exist and neither should any default nodes
616 * of the case, remove this one default node */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100617 lyd_validate_autodel_node_del(first, node, mod, next_p, diff);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100618 }
619}
620
Michal Vasko17f76642021-08-03 17:01:30 +0200621/**
622 * @brief Validate new siblings in choices, recursively for nested choices.
623 *
624 * @param[in,out] first First sibling.
625 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
626 * @param[in] mod Module of the siblings, NULL for nested siblings.
627 * @param[in,out] diff Validation diff.
628 * @return LY_ERR value.
629 */
630static LY_ERR
631lyd_validate_choice_r(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
Radek Krejci0f969882020-08-21 16:56:47 +0200632 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100633{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100634 const struct lysc_node *snode = NULL;
635
Michal Vaskob1b5c262020-03-05 14:29:47 +0100636 while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
637 /* check case duplicites */
638 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100639 LY_CHECK_RET(lyd_validate_cases(first, mod, (struct lysc_node_choice *)snode, diff));
Michal Vasko17f76642021-08-03 17:01:30 +0200640
641 /* check for nested choice */
642 LY_CHECK_RET(lyd_validate_choice_r(first, snode, mod, diff));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100643 }
644 }
645
Michal Vasko17f76642021-08-03 17:01:30 +0200646 return LY_SUCCESS;
647}
648
649LY_ERR
650lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
651 struct lyd_node **diff)
652{
653 struct lyd_node *next, *node;
654
655 assert(first && (sparent || mod));
656
657 /* validate choices */
658 LY_CHECK_RET(lyd_validate_choice_r(first, sparent, mod, diff));
659
Michal Vaskob1b5c262020-03-05 14:29:47 +0100660 LY_LIST_FOR_SAFE(*first, next, node) {
Michal Vasko6a6e3082022-05-10 10:32:38 +0200661 if (!node->schema || (mod && (lyd_owner_module(node) != mod))) {
662 /* opaque node or all top-level data from this module checked */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100663 break;
664 }
665
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100666 if (!(node->flags & (LYD_NEW | LYD_DEFAULT))) {
667 /* check only new and default nodes */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100668 continue;
669 }
670
Radek Krejciddace2c2021-01-08 11:30:56 +0100671 LOG_LOCSET(node->schema, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100672
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100673 if (node->flags & LYD_NEW) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100674 LY_ERR ret;
675
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100676 /* remove old default(s) of the new node if it exists */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100677 lyd_validate_autodel_dup(first, node, mod, &next, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100678
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100679 /* then check new node instance duplicities */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100680 ret = lyd_validate_duplicates(*first, node);
Radek Krejciddace2c2021-01-08 11:30:56 +0100681 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0), ret);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100682
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100683 /* this node is valid */
684 node->flags &= ~LYD_NEW;
685 }
686
Michal Vasko0e6de512021-01-11 13:39:44 +0100687 LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0);
688
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100689 if (node->flags & LYD_DEFAULT) {
690 /* remove leftover default nodes from a no-longer existing case */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100691 lyd_validate_autodel_case_dflt(first, node, mod, &next, diff);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100692 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100693 }
694
695 return LY_SUCCESS;
696}
697
Michal Vaskobb844672020-07-03 11:06:12 +0200698/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100699 * @brief Evaluate any "when" conditions of a non-existent data node with existing parent.
700 *
701 * @param[in] first First data sibling of the non-existing node.
702 * @param[in] parent Data parent of the non-existing node.
703 * @param[in] snode Schema node of the non-existing node.
704 * @param[out] disabled First when that evaluated false, if any.
705 * @return LY_ERR value.
706 */
707static LY_ERR
708lyd_validate_dummy_when(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
709 const struct lysc_when **disabled)
710{
711 LY_ERR ret = LY_SUCCESS;
712 struct lyd_node *tree, *dummy = NULL;
Michal Vaskoa27245c2022-05-02 09:01:35 +0200713 uint32_t xp_opts;
Michal Vaskobd4db892020-11-23 16:58:20 +0100714
715 /* find root */
716 if (parent) {
717 tree = (struct lyd_node *)parent;
718 while (tree->parent) {
719 tree = lyd_parent(tree);
720 }
721 tree = lyd_first_sibling(tree);
722 } else {
Michal Vaskobd99b5e2022-04-29 11:15:47 +0200723 /* is the first sibling from the same module, but may not be the actual first */
724 tree = lyd_first_sibling(first);
Michal Vaskobd4db892020-11-23 16:58:20 +0100725 }
726
727 /* create dummy opaque node */
Michal Vasko0ab974d2021-02-24 13:18:26 +0100728 ret = lyd_new_opaq((struct lyd_node *)parent, snode->module->ctx, snode->name, NULL, NULL, snode->module->name, &dummy);
Michal Vaskobd4db892020-11-23 16:58:20 +0100729 LY_CHECK_GOTO(ret, cleanup);
730
731 /* connect it if needed */
732 if (!parent) {
733 if (first) {
734 lyd_insert_sibling((struct lyd_node *)first, dummy, &tree);
735 } else {
736 assert(!tree);
737 tree = dummy;
738 }
739 }
740
Michal Vaskoa27245c2022-05-02 09:01:35 +0200741 /* explicitly specified accesible tree */
742 if (snode->flags & LYS_CONFIG_W) {
743 xp_opts = LYXP_ACCESS_TREE_CONFIG;
744 } else {
745 xp_opts = LYXP_ACCESS_TREE_ALL;
746 }
747
Michal Vaskobd4db892020-11-23 16:58:20 +0100748 /* evaluate all when */
Michal Vaskoa27245c2022-05-02 09:01:35 +0200749 ret = lyd_validate_node_when(tree, dummy, snode, xp_opts, disabled);
Michal Vaskobd4db892020-11-23 16:58:20 +0100750 if (ret == LY_EINCOMPLETE) {
751 /* all other when must be resolved by now */
752 LOGINT(snode->module->ctx);
753 ret = LY_EINT;
754 goto cleanup;
755 } else if (ret) {
756 /* error */
757 goto cleanup;
758 }
759
760cleanup:
761 lyd_free_tree(dummy);
762 return ret;
763}
764
765/**
Michal Vaskobb844672020-07-03 11:06:12 +0200766 * @brief Validate mandatory node existence.
767 *
768 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100769 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200770 * @param[in] snode Schema node to validate.
771 * @return LY_ERR value.
772 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100773static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100774lyd_validate_mandatory(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode)
Michal Vaskoa3881362020-01-21 15:57:35 +0100775{
Michal Vaskobd4db892020-11-23 16:58:20 +0100776 const struct lysc_when *disabled;
777
Michal Vaskoa3881362020-01-21 15:57:35 +0100778 if (snode->nodetype == LYS_CHOICE) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100779 /* some data of a choice case exist */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100780 if (lys_getnext_data(NULL, first, NULL, snode, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100781 return LY_SUCCESS;
782 }
783 } else {
784 assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY));
Michal Vaskoa3881362020-01-21 15:57:35 +0100785
Michal Vaskob1b5c262020-03-05 14:29:47 +0100786 if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100787 /* data instance found */
788 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100789 }
790 }
791
Michal Vaskobd4db892020-11-23 16:58:20 +0100792 disabled = NULL;
793 if (lysc_has_when(snode)) {
794 /* if there are any when conditions, they must be true for a validation error */
795 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
796 }
797
798 if (!disabled) {
799 /* node instance not found */
Michal Vasko538b8952021-02-17 11:27:26 +0100800 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200801 LOGVAL_APPTAG(snode->module->ctx, "missing-choice", LY_VCODE_NOMAND_CHOIC, snode->name);
Michal Vasko538b8952021-02-17 11:27:26 +0100802 } else {
803 LOGVAL(snode->module->ctx, LY_VCODE_NOMAND, snode->name);
804 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100805 return LY_EVALID;
806 }
807
808 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100809}
810
Michal Vaskobb844672020-07-03 11:06:12 +0200811/**
812 * @brief Validate min/max-elements constraints, if any.
813 *
814 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100815 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200816 * @param[in] snode Schema node to validate.
817 * @param[in] min Minimum number of elements, 0 for no restriction.
818 * @param[in] max Max number of elements, 0 for no restriction.
819 * @return LY_ERR value.
820 */
Michal Vaskoa3881362020-01-21 15:57:35 +0100821static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100822lyd_validate_minmax(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
823 uint32_t min, uint32_t max)
Michal Vaskoa3881362020-01-21 15:57:35 +0100824{
Michal Vaskoacd83e72020-02-04 14:12:01 +0100825 uint32_t count = 0;
Michal Vasko4c583e82020-07-17 12:16:14 +0200826 struct lyd_node *iter;
Michal Vaskobd4db892020-11-23 16:58:20 +0100827 const struct lysc_when *disabled;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100828 ly_bool invalid_instance = 0;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100829
Michal Vasko9b368d32020-02-14 13:53:31 +0100830 assert(min || max);
831
Michal Vasko4c583e82020-07-17 12:16:14 +0200832 LYD_LIST_FOR_INST(first, snode, iter) {
833 ++count;
Michal Vasko9b368d32020-02-14 13:53:31 +0100834
Michal Vasko4c583e82020-07-17 12:16:14 +0200835 if (min && (count == min)) {
836 /* satisfied */
837 min = 0;
838 if (!max) {
839 /* nothing more to check */
Michal Vasko9b368d32020-02-14 13:53:31 +0100840 break;
841 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100842 }
Michal Vasko4c583e82020-07-17 12:16:14 +0200843 if (max && (count > max)) {
844 /* not satisifed */
Radek Krejciddace2c2021-01-08 11:30:56 +0100845 LOG_LOCSET(NULL, iter, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100846 invalid_instance = 1;
Michal Vasko4c583e82020-07-17 12:16:14 +0200847 break;
848 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100849 }
850
Michal Vasko9b368d32020-02-14 13:53:31 +0100851 if (min) {
852 assert(count < min);
Michal Vaskobd4db892020-11-23 16:58:20 +0100853
854 disabled = NULL;
855 if (lysc_has_when(snode)) {
856 /* if there are any when conditions, they must be true for a validation error */
857 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
858 }
859
860 if (!disabled) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200861 LOGVAL_APPTAG(snode->module->ctx, "too-few-elements", LY_VCODE_NOMIN, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100862 goto failure;
Michal Vaskobd4db892020-11-23 16:58:20 +0100863 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100864 } else if (max && (count > max)) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200865 LOGVAL_APPTAG(snode->module->ctx, "too-many-elements", LY_VCODE_NOMAX, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100866 goto failure;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100867 }
868
Michal Vaskoa3881362020-01-21 15:57:35 +0100869 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100870
871failure:
Radek Krejciddace2c2021-01-08 11:30:56 +0100872 LOG_LOCBACK(0, invalid_instance, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100873 return LY_EVALID;
Michal Vaskoa3881362020-01-21 15:57:35 +0100874}
875
Michal Vaskobb844672020-07-03 11:06:12 +0200876/**
877 * @brief Find node referenced by a list unique statement.
878 *
879 * @param[in] uniq_leaf Unique leaf to find.
880 * @param[in] list List instance to use for the search.
881 * @return Found leaf,
882 * @return NULL if no leaf found.
883 */
Michal Vasko14654712020-02-06 08:35:21 +0100884static struct lyd_node *
Michal Vaskobb844672020-07-03 11:06:12 +0200885lyd_val_uniq_find_leaf(const struct lysc_node_leaf *uniq_leaf, const struct lyd_node *list)
Michal Vasko14654712020-02-06 08:35:21 +0100886{
Michal Vasko9b368d32020-02-14 13:53:31 +0100887 struct lyd_node *node;
888 const struct lysc_node *iter;
889 size_t depth = 0, i;
Michal Vasko14654712020-02-06 08:35:21 +0100890
Michal Vasko9b368d32020-02-14 13:53:31 +0100891 /* get leaf depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100892 for (iter = &uniq_leaf->node; iter && (iter != list->schema); iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +0200893 ++depth;
Michal Vasko14654712020-02-06 08:35:21 +0100894 }
Michal Vasko9b368d32020-02-14 13:53:31 +0100895
Michal Vaskobb844672020-07-03 11:06:12 +0200896 node = (struct lyd_node *)list;
Michal Vasko9b368d32020-02-14 13:53:31 +0100897 while (node && depth) {
898 /* find schema node with this depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100899 for (i = depth - 1, iter = &uniq_leaf->node; i; iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +0200900 --i;
Michal Vasko9b368d32020-02-14 13:53:31 +0100901 }
902
903 /* find iter instance in children */
904 assert(iter->nodetype & (LYS_CONTAINER | LYS_LEAF));
Radek Krejcia1c1e542020-09-29 16:06:52 +0200905 lyd_find_sibling_val(lyd_child(node), iter, NULL, 0, &node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100906 --depth;
907 }
908
Michal Vasko14654712020-02-06 08:35:21 +0100909 return node;
910}
911
Michal Vaskobb844672020-07-03 11:06:12 +0200912/**
913 * @brief Callback for comparing 2 list unique leaf values.
914 *
Michal Vasko62524a92021-02-26 10:08:50 +0100915 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200916 *
Michal Vaskobb844672020-07-03 11:06:12 +0200917 * @param[in] cb_data 0 to compare all uniques, n to compare only n-th unique.
Michal Vasko14654712020-02-06 08:35:21 +0100918 */
Radek Krejci857189e2020-09-01 13:26:36 +0200919static ly_bool
920lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *cb_data)
Michal Vasko14654712020-02-06 08:35:21 +0100921{
922 struct ly_ctx *ctx;
923 struct lysc_node_list *slist;
924 struct lyd_node *diter, *first, *second;
925 struct lyd_value *val1, *val2;
926 char *path1, *path2, *uniq_str, *ptr;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200927 LY_ARRAY_COUNT_TYPE u, v, action;
Michal Vasko14654712020-02-06 08:35:21 +0100928
929 assert(val1_p && val2_p);
930
931 first = *((struct lyd_node **)val1_p);
932 second = *((struct lyd_node **)val2_p);
Michal Vasko41e630c2021-07-23 12:47:18 +0200933 action = (uintptr_t)cb_data;
Michal Vasko14654712020-02-06 08:35:21 +0100934
935 assert(first && (first->schema->nodetype == LYS_LIST));
936 assert(second && (second->schema == first->schema));
937
938 ctx = first->schema->module->ctx;
939
940 slist = (struct lysc_node_list *)first->schema;
941
942 /* compare unique leaves */
943 if (action > 0) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200944 u = action - 1;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200945 if (u < LY_ARRAY_COUNT(slist->uniques)) {
Michal Vasko14654712020-02-06 08:35:21 +0100946 goto uniquecheck;
947 }
948 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200949 LY_ARRAY_FOR(slist->uniques, u) {
Michal Vasko14654712020-02-06 08:35:21 +0100950uniquecheck:
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200951 LY_ARRAY_FOR(slist->uniques[u], v) {
Michal Vasko14654712020-02-06 08:35:21 +0100952 /* first */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200953 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], first);
Michal Vasko14654712020-02-06 08:35:21 +0100954 if (diter) {
955 val1 = &((struct lyd_node_term *)diter)->value;
956 } else {
957 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200958 val1 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +0100959 }
960
961 /* second */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200962 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], second);
Michal Vasko14654712020-02-06 08:35:21 +0100963 if (diter) {
964 val2 = &((struct lyd_node_term *)diter)->value;
965 } else {
966 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200967 val2 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +0100968 }
969
970 if (!val1 || !val2 || val1->realtype->plugin->compare(val1, val2)) {
971 /* values differ or either one is not set */
972 break;
973 }
974 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200975 if (v && (v == LY_ARRAY_COUNT(slist->uniques[u]))) {
Michal Vasko14654712020-02-06 08:35:21 +0100976 /* all unique leafs are the same in this set, create this nice error */
Radek Krejci635d2b82021-01-04 11:26:51 +0100977 path1 = lyd_path(first, LYD_PATH_STD, NULL, 0);
978 path2 = lyd_path(second, LYD_PATH_STD, NULL, 0);
Michal Vasko14654712020-02-06 08:35:21 +0100979
980 /* use buffer to rebuild the unique string */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100981#define UNIQ_BUF_SIZE 1024
982 uniq_str = malloc(UNIQ_BUF_SIZE);
Michal Vasko14654712020-02-06 08:35:21 +0100983 uniq_str[0] = '\0';
984 ptr = uniq_str;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200985 LY_ARRAY_FOR(slist->uniques[u], v) {
986 if (v) {
Michal Vasko14654712020-02-06 08:35:21 +0100987 strcpy(ptr, " ");
988 ++ptr;
989 }
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100990 ptr = lysc_path_until((struct lysc_node *)slist->uniques[u][v], &slist->node, LYSC_PATH_LOG,
Radek Krejcif13b87b2020-12-01 22:02:17 +0100991 ptr, UNIQ_BUF_SIZE - (ptr - uniq_str));
Michal Vasko14654712020-02-06 08:35:21 +0100992 if (!ptr) {
993 /* path will be incomplete, whatever */
994 break;
995 }
996
997 ptr += strlen(ptr);
998 }
Radek Krejciddace2c2021-01-08 11:30:56 +0100999 LOG_LOCSET(NULL, second, NULL, NULL);
Michal Vaskoe9391c72021-10-05 10:04:56 +02001000 LOGVAL_APPTAG(ctx, "data-not-unique", LY_VCODE_NOUNIQ, uniq_str, path1, path2);
Radek Krejciddace2c2021-01-08 11:30:56 +01001001 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001002
1003 free(path1);
1004 free(path2);
1005 free(uniq_str);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001006#undef UNIQ_BUF_SIZE
1007
Michal Vasko14654712020-02-06 08:35:21 +01001008 return 1;
1009 }
1010
1011 if (action > 0) {
1012 /* done */
1013 return 0;
1014 }
1015 }
1016
1017 return 0;
1018}
1019
Michal Vaskobb844672020-07-03 11:06:12 +02001020/**
1021 * @brief Validate list unique leaves.
1022 *
1023 * @param[in] first First sibling to search in.
1024 * @param[in] snode Schema node to validate.
1025 * @param[in] uniques List unique arrays to validate.
1026 * @return LY_ERR value.
1027 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001028static LY_ERR
Michal Vaskobb844672020-07-03 11:06:12 +02001029lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode, const struct lysc_node_leaf ***uniques)
Michal Vaskoa3881362020-01-21 15:57:35 +01001030{
Michal Vaskob1b5c262020-03-05 14:29:47 +01001031 const struct lyd_node *diter;
Michal Vasko14654712020-02-06 08:35:21 +01001032 struct ly_set *set;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001033 LY_ARRAY_COUNT_TYPE u, v, x = 0;
Michal Vasko14654712020-02-06 08:35:21 +01001034 LY_ERR ret = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001035 uint32_t hash, i, size = 0;
Radek Krejci813c02d2021-04-26 10:29:19 +02001036 size_t key_len;
1037 ly_bool dyn;
1038 const void *hash_key;
Michal Vasko41e630c2021-07-23 12:47:18 +02001039 void *cb_data;
Michal Vasko14654712020-02-06 08:35:21 +01001040 struct hash_table **uniqtables = NULL;
1041 struct lyd_value *val;
1042 struct ly_ctx *ctx = snode->module->ctx;
1043
1044 assert(uniques);
1045
1046 /* get all list instances */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001047 LY_CHECK_RET(ly_set_new(&set));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001048 LY_LIST_FOR(first, diter) {
Michal Vasko9b368d32020-02-14 13:53:31 +01001049 if (diter->schema == snode) {
Radek Krejci3d92e442020-10-12 12:48:13 +02001050 ret = ly_set_add(set, (void *)diter, 1, NULL);
Michal Vaskob0099a92020-08-31 14:55:23 +02001051 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko9b368d32020-02-14 13:53:31 +01001052 }
1053 }
Michal Vasko14654712020-02-06 08:35:21 +01001054
1055 if (set->count == 2) {
1056 /* simple comparison */
1057 if (lyd_val_uniq_list_equal(&set->objs[0], &set->objs[1], 0, (void *)0)) {
1058 /* instance duplication */
1059 ret = LY_EVALID;
1060 goto cleanup;
1061 }
1062 } else if (set->count > 2) {
1063 /* use hashes for comparison */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001064 /* first, allocate the table, the size depends on number of items in the set,
1065 * the following code detects number of upper zero bits in the items' counter value ... */
1066 for (i = (sizeof set->count * CHAR_BIT) - 1; i > 0; i--) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001067 size = set->count << i;
1068 size = size >> i;
1069 if (size == set->count) {
Michal Vasko14654712020-02-06 08:35:21 +01001070 break;
1071 }
1072 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001073 LY_CHECK_ERR_GOTO(!i, LOGINT(ctx); ret = LY_EINT, cleanup);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001074 /* ... and then we convert it to the position of the highest non-zero bit ... */
1075 i = (sizeof set->count * CHAR_BIT) - i;
1076 /* ... and by using it to shift 1 to the left we get the closest sufficient hash table size */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001077 size = 1 << i;
Michal Vasko14654712020-02-06 08:35:21 +01001078
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001079 uniqtables = malloc(LY_ARRAY_COUNT(uniques) * sizeof *uniqtables);
Michal Vasko14654712020-02-06 08:35:21 +01001080 LY_CHECK_ERR_GOTO(!uniqtables, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001081 x = LY_ARRAY_COUNT(uniques);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001082 for (v = 0; v < x; v++) {
Michal Vasko41e630c2021-07-23 12:47:18 +02001083 cb_data = (void *)(uintptr_t)(v + 1L);
1084 uniqtables[v] = lyht_new(size, sizeof(struct lyd_node *), lyd_val_uniq_list_equal, cb_data, 0);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001085 LY_CHECK_ERR_GOTO(!uniqtables[v], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001086 }
1087
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001088 for (i = 0; i < set->count; i++) {
Michal Vasko14654712020-02-06 08:35:21 +01001089 /* loop for unique - get the hash for the instances */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001090 for (u = 0; u < x; u++) {
Michal Vasko14654712020-02-06 08:35:21 +01001091 val = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001092 for (v = hash = 0; v < LY_ARRAY_COUNT(uniques[u]); v++) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001093 diter = lyd_val_uniq_find_leaf(uniques[u][v], set->objs[i]);
Michal Vasko14654712020-02-06 08:35:21 +01001094 if (diter) {
1095 val = &((struct lyd_node_term *)diter)->value;
1096 } else {
1097 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001098 val = uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001099 }
1100 if (!val) {
1101 /* unique item not present nor has default value */
1102 break;
1103 }
1104
Radek Krejci813c02d2021-04-26 10:29:19 +02001105 /* get hash key */
Michal Vaskodcfac2c2021-05-10 11:36:37 +02001106 hash_key = val->realtype->plugin->print(NULL, val, LY_VALUE_LYB, NULL, &dyn, &key_len);
Radek Krejci813c02d2021-04-26 10:29:19 +02001107 hash = dict_hash_multi(hash, hash_key, key_len);
1108 if (dyn) {
1109 free((void *)hash_key);
Michal Vasko14654712020-02-06 08:35:21 +01001110 }
1111 }
1112 if (!val) {
1113 /* skip this list instance since its unique set is incomplete */
1114 continue;
1115 }
1116
1117 /* finish the hash value */
1118 hash = dict_hash_multi(hash, NULL, 0);
1119
1120 /* insert into the hashtable */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001121 ret = lyht_insert(uniqtables[u], &set->objs[i], hash, NULL);
Michal Vasko14654712020-02-06 08:35:21 +01001122 if (ret == LY_EEXIST) {
1123 /* instance duplication */
1124 ret = LY_EVALID;
1125 }
1126 LY_CHECK_GOTO(ret != LY_SUCCESS, cleanup);
1127 }
1128 }
1129 }
1130
1131cleanup:
1132 ly_set_free(set, NULL);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001133 for (v = 0; v < x; v++) {
1134 if (!uniqtables[v]) {
Michal Vasko14654712020-02-06 08:35:21 +01001135 /* failed when allocating uniquetables[j], following j are not allocated */
1136 break;
1137 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001138 lyht_free(uniqtables[v]);
Michal Vasko14654712020-02-06 08:35:21 +01001139 }
1140 free(uniqtables);
1141
1142 return ret;
Michal Vaskoa3881362020-01-21 15:57:35 +01001143}
1144
Michal Vaskobb844672020-07-03 11:06:12 +02001145/**
1146 * @brief Validate data siblings based on generic schema node restrictions, recursively for schema-only nodes.
1147 *
1148 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +01001149 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +02001150 * @param[in] sparent Schema parent of the nodes to check.
1151 * @param[in] mod Module of the nodes to check.
1152 * @param[in] val_opts Validation options, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +01001153 * @param[in] int_opts Internal parser options.
Michal Vaskobb844672020-07-03 11:06:12 +02001154 * @return LY_ERR value.
1155 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001156static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001157lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lyd_node *parent,
Michal Vaskoe0665742021-02-11 11:08:44 +01001158 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 +01001159{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001160 LY_ERR ret = LY_SUCCESS;
Michal Vasko6c16cda2021-02-04 11:05:52 +01001161 const struct lysc_node *snode = NULL, *scase;
Michal Vaskoa3881362020-01-21 15:57:35 +01001162 struct lysc_node_list *slist;
Michal Vaskod8958df2020-08-05 13:27:36 +02001163 struct lysc_node_leaflist *sllist;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001164 uint32_t getnext_opts;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001165
Michal Vaskoe0665742021-02-11 11:08:44 +01001166 getnext_opts = LYS_GETNEXT_WITHCHOICE | (int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001167
Michal Vaskoa3881362020-01-21 15:57:35 +01001168 /* disabled nodes are skipped by lys_getnext */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001169 while ((snode = lys_getnext(snode, sparent, mod, getnext_opts))) {
Radek Krejci7931b192020-06-25 17:05:03 +02001170 if ((val_opts & LYD_VALIDATE_NO_STATE) && (snode->flags & LYS_CONFIG_R)) {
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001171 continue;
1172 }
1173
Radek Krejciddace2c2021-01-08 11:30:56 +01001174 LOG_LOCSET(snode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001175
Michal Vaskoa3881362020-01-21 15:57:35 +01001176 /* check min-elements and max-elements */
Michal Vaskod8958df2020-08-05 13:27:36 +02001177 if (snode->nodetype == LYS_LIST) {
Michal Vaskoa3881362020-01-21 15:57:35 +01001178 slist = (struct lysc_node_list *)snode;
1179 if (slist->min || slist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001180 ret = lyd_validate_minmax(first, parent, snode, slist->min, slist->max);
1181 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001182 }
Michal Vaskod8958df2020-08-05 13:27:36 +02001183 } else if (snode->nodetype == LYS_LEAFLIST) {
1184 sllist = (struct lysc_node_leaflist *)snode;
1185 if (sllist->min || sllist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001186 ret = lyd_validate_minmax(first, parent, snode, sllist->min, sllist->max);
1187 LY_CHECK_GOTO(ret, error);
Michal Vaskod8958df2020-08-05 13:27:36 +02001188 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001189
Michal Vaskoacd83e72020-02-04 14:12:01 +01001190 } else if (snode->flags & LYS_MAND_TRUE) {
Radek Krejcif6a11002020-08-21 13:29:07 +02001191 /* check generic mandatory existence */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001192 ret = lyd_validate_mandatory(first, parent, snode);
1193 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001194 }
1195
1196 /* check unique */
1197 if (snode->nodetype == LYS_LIST) {
1198 slist = (struct lysc_node_list *)snode;
1199 if (slist->uniques) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001200 ret = lyd_validate_unique(first, snode, (const struct lysc_node_leaf ***)slist->uniques);
1201 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001202 }
1203 }
1204
Michal Vasko6c16cda2021-02-04 11:05:52 +01001205 if (snode->nodetype == LYS_CHOICE) {
1206 /* find the existing case, if any */
1207 LY_LIST_FOR(lysc_node_child(snode), scase) {
1208 if (lys_getnext_data(NULL, first, NULL, scase, NULL)) {
1209 /* validate only this case */
Michal Vaskoe0665742021-02-11 11:08:44 +01001210 ret = lyd_validate_siblings_schema_r(first, parent, scase, mod, val_opts, int_opts);
Michal Vasko6c16cda2021-02-04 11:05:52 +01001211 LY_CHECK_GOTO(ret, error);
1212 break;
1213 }
1214 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001215 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001216
Radek Krejciddace2c2021-01-08 11:30:56 +01001217 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001218 }
1219
Michal Vaskoacd83e72020-02-04 14:12:01 +01001220 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001221
1222error:
Radek Krejciddace2c2021-01-08 11:30:56 +01001223 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001224 return ret;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001225}
1226
Michal Vaskobb844672020-07-03 11:06:12 +02001227/**
1228 * @brief Validate obsolete nodes, only warnings are printed.
1229 *
1230 * @param[in] node Node to check.
1231 */
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001232static void
1233lyd_validate_obsolete(const struct lyd_node *node)
1234{
1235 const struct lysc_node *snode;
1236
1237 snode = node->schema;
1238 do {
1239 if (snode->flags & LYS_STATUS_OBSLT) {
1240 LOGWRN(snode->module->ctx, "Obsolete schema node \"%s\" instantiated in data.", snode->name);
1241 break;
1242 }
1243
1244 snode = snode->parent;
1245 } while (snode && (snode->nodetype & (LYS_CHOICE | LYS_CASE)));
1246}
1247
Michal Vaskobb844672020-07-03 11:06:12 +02001248/**
1249 * @brief Validate must conditions of a data node.
1250 *
1251 * @param[in] node Node to validate.
Michal Vaskoe0665742021-02-11 11:08:44 +01001252 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001253 * @param[in] xpath_options Additional XPath options to use.
Michal Vaskobb844672020-07-03 11:06:12 +02001254 * @return LY_ERR value.
1255 */
Michal Vaskocc048b22020-03-27 15:52:38 +01001256static LY_ERR
Michal Vasko906bafa2022-04-22 12:28:55 +02001257lyd_validate_must(const struct lyd_node *node, uint32_t int_opts, uint32_t xpath_options)
Michal Vaskocc048b22020-03-27 15:52:38 +01001258{
Michal Vaskoa1db2342021-07-19 12:23:23 +02001259 LY_ERR ret;
Michal Vaskocc048b22020-03-27 15:52:38 +01001260 struct lyxp_set xp_set;
1261 struct lysc_must *musts;
1262 const struct lyd_node *tree;
Radek Krejci9a3823e2021-01-27 20:26:46 +01001263 const struct lysc_node *schema;
Michal Vaskoe9391c72021-10-05 10:04:56 +02001264 const char *emsg, *eapptag;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001265 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocc048b22020-03-27 15:52:38 +01001266
Michal Vaskoe0665742021-02-11 11:08:44 +01001267 assert((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) != (LYD_INTOPT_RPC | LYD_INTOPT_REPLY));
1268 assert((int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) != (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY));
1269
Radek Krejci9a3823e2021-01-27 20:26:46 +01001270 if (node->schema->nodetype & (LYS_ACTION | LYS_RPC)) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001271 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001272 schema = &((struct lysc_node_action *)node->schema)->input.node;
Michal Vaskoe0665742021-02-11 11:08:44 +01001273 } else if (int_opts & LYD_INTOPT_REPLY) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001274 schema = &((struct lysc_node_action *)node->schema)->output.node;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001275 } else {
Michal Vaskoa1db2342021-07-19 12:23:23 +02001276 LOGINT_RET(LYD_CTX(node));
Michal Vaskocb7526d2020-03-30 15:08:26 +02001277 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001278 } else {
1279 schema = node->schema;
Michal Vaskocc048b22020-03-27 15:52:38 +01001280 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001281 musts = lysc_node_musts(schema);
Michal Vaskocc048b22020-03-27 15:52:38 +01001282 if (!musts) {
1283 /* no must to evaluate */
1284 return LY_SUCCESS;
1285 }
1286
1287 /* find first top-level node */
Michal Vasko9e685082021-01-29 14:49:09 +01001288 for (tree = node; tree->parent; tree = lyd_parent(tree)) {}
Michal Vaskof9221e62021-02-04 12:10:14 +01001289 tree = lyd_first_sibling(tree);
Michal Vaskocc048b22020-03-27 15:52:38 +01001290
1291 LY_ARRAY_FOR(musts, u) {
1292 memset(&xp_set, 0, sizeof xp_set);
1293
1294 /* evaluate must */
Michal Vaskoa1db2342021-07-19 12:23:23 +02001295 ret = lyxp_eval(LYD_CTX(node), musts[u].cond, node->schema->module, LY_VALUE_SCHEMA_RESOLVED,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +02001296 musts[u].prefixes, node, node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options);
Michal Vaskoa1db2342021-07-19 12:23:23 +02001297 if (ret == LY_EINCOMPLETE) {
1298 LOGINT_RET(LYD_CTX(node));
1299 } else if (ret) {
1300 return ret;
1301 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001302
1303 /* check the result */
1304 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02001305 if (!xp_set.val.bln) {
Michal Vaskoe9391c72021-10-05 10:04:56 +02001306 /* use specific error information */
1307 emsg = musts[u].emsg;
1308 eapptag = musts[u].eapptag ? musts[u].eapptag : "must-violation";
1309 if (emsg) {
1310 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LYVE_DATA, "%s", emsg);
1311 } else {
1312 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LY_VCODE_NOMUST, musts[u].cond->expr);
1313 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001314 return LY_EVALID;
1315 }
1316 }
1317
1318 return LY_SUCCESS;
1319}
1320
Michal Vaskoe0665742021-02-11 11:08:44 +01001321/**
1322 * @brief Perform all remaining validation tasks, the data tree must be final when calling this function.
1323 *
1324 * @param[in] first First sibling.
1325 * @param[in] parent Data parent.
1326 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
1327 * @param[in] mod Module of the siblings, NULL for nested siblings.
1328 * @param[in] val_opts Validation options (@ref datavalidationoptions).
1329 * @param[in] int_opts Internal parser options.
Michal Vasko906bafa2022-04-22 12:28:55 +02001330 * @param[in] must_xp_opts Additional XPath options to use for evaluating "must".
Michal Vaskoe0665742021-02-11 11:08:44 +01001331 * @return LY_ERR value.
1332 */
1333static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001334lyd_validate_final_r(struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *sparent,
Michal Vasko906bafa2022-04-22 12:28:55 +02001335 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 +01001336{
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001337 LY_ERR r;
1338 const char *innode;
Radek Krejci7f769d72020-07-11 23:13:56 +02001339 struct lyd_node *next = NULL, *node;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001340
Michal Vasko14654712020-02-06 08:35:21 +01001341 /* validate all restrictions of nodes themselves */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001342 LY_LIST_FOR_SAFE(first, next, node) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001343 if (node->flags & LYD_EXT) {
1344 /* ext instance data should have already been validated */
1345 continue;
1346 }
1347
Radek Krejciddace2c2021-01-08 11:30:56 +01001348 LOG_LOCSET(node->schema, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001349
Michal Vaskoa8c61722020-03-27 16:59:32 +01001350 /* opaque data */
1351 if (!node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001352 r = lyd_parse_opaq_error(node);
Michal Vasko6344e7a2022-05-10 10:08:53 +02001353 LOG_LOCBACK(0, 1, 0, 0);
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001354 return r;
Michal Vaskoa8c61722020-03-27 16:59:32 +01001355 }
1356
Michal Vasko6344e7a2022-05-10 10:08:53 +02001357 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1358 /* all top-level data from this module checked */
1359 LOG_LOCBACK(1, 1, 0, 0);
1360 break;
1361 }
1362
Michal Vasko8d289f92021-12-02 10:11:00 +01001363 /* no state/input/output/op data */
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001364 innode = NULL;
Radek Krejci7931b192020-06-25 17:05:03 +02001365 if ((val_opts & LYD_VALIDATE_NO_STATE) && (node->schema->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001366 innode = "state";
Michal Vaskoe0665742021-02-11 11:08:44 +01001367 } else if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) && (node->schema->flags & LYS_IS_OUTPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001368 innode = "output";
Michal Vaskoe0665742021-02-11 11:08:44 +01001369 } else if ((int_opts & LYD_INTOPT_REPLY) && (node->schema->flags & LYS_IS_INPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001370 innode = "input";
Michal Vasko8d289f92021-12-02 10:11:00 +01001371 } else if (!(int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_RPC)) {
1372 innode = "rpc";
1373 } else if (!(int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_ACTION)) {
1374 innode = "action";
1375 } else if (!(int_opts & LYD_INTOPT_NOTIF) && (node->schema->nodetype == LYS_NOTIF)) {
1376 innode = "notification";
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001377 }
1378 if (innode) {
1379 LOGVAL(LYD_CTX(node), LY_VCODE_UNEXPNODE, innode, node->schema->name);
1380 LOG_LOCBACK(1, 1, 0, 0);
1381 return LY_EVALID;
Michal Vasko5b37a352020-03-06 13:38:33 +01001382 }
1383
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001384 /* obsolete data */
1385 lyd_validate_obsolete(node);
1386
Michal Vaskocc048b22020-03-27 15:52:38 +01001387 /* node's musts */
Michal Vasko906bafa2022-04-22 12:28:55 +02001388 if ((r = lyd_validate_must(node, int_opts, must_xp_opts))) {
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001389 LOG_LOCBACK(1, 1, 0, 0);
1390 return r;
1391 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001392
Michal Vasko53d97a12020-11-05 17:39:10 +01001393 /* node value was checked by plugins */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001394
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001395 /* next iter */
Radek Krejciddace2c2021-01-08 11:30:56 +01001396 LOG_LOCBACK(1, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001397 }
Michal Vaskocde73ac2019-11-14 16:10:27 +01001398
Michal Vasko14654712020-02-06 08:35:21 +01001399 /* validate schema-based restrictions */
Michal Vaskoe0665742021-02-11 11:08:44 +01001400 LY_CHECK_RET(lyd_validate_siblings_schema_r(first, parent, sparent, mod ? mod->compiled : NULL, val_opts, int_opts));
Michal Vasko14654712020-02-06 08:35:21 +01001401
Michal Vaskob1b5c262020-03-05 14:29:47 +01001402 LY_LIST_FOR(first, node) {
Michal Vasko19034e22021-07-19 12:24:14 +02001403 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1404 /* all top-level data from this module checked */
1405 break;
1406 }
1407
Michal Vasko14654712020-02-06 08:35:21 +01001408 /* validate all children recursively */
Michal Vasko906bafa2022-04-22 12:28:55 +02001409 LY_CHECK_RET(lyd_validate_final_r(lyd_child(node), node, node->schema, NULL, val_opts, int_opts, must_xp_opts));
Michal Vaskocde73ac2019-11-14 16:10:27 +01001410
Michal Vaskob1b5c262020-03-05 14:29:47 +01001411 /* set default for containers */
aPiecekc5f36a72021-05-18 14:12:31 +02001412 if (node->schema && (node->schema->nodetype == LYS_CONTAINER) && !(node->schema->flags & LYS_PRESENCE)) {
Radek Krejcia1c1e542020-09-29 16:06:52 +02001413 LY_LIST_FOR(lyd_child(node), next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001414 if (!(next->flags & LYD_DEFAULT)) {
1415 break;
1416 }
Michal Vaskoa3881362020-01-21 15:57:35 +01001417 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001418 if (!next) {
1419 node->flags |= LYD_DEFAULT;
1420 }
Michal Vasko9b368d32020-02-14 13:53:31 +01001421 }
1422 }
1423
1424 return LY_SUCCESS;
1425}
1426
Radek Krejci7931b192020-06-25 17:05:03 +02001427/**
Michal Vaskoddd76592022-01-17 13:34:48 +01001428 * @brief Validate extension instance data by storing it in its unres set.
1429 *
1430 * @param[in] sibling First sibling with ::LYD_EXT flag, all the following ones are expected to have it, too.
1431 * @param[in,out] ext_val Set with parsed extension instance data to validate.
1432 * @return LY_ERR value.
1433 */
1434static LY_ERR
1435lyd_validate_nested_ext(struct lyd_node *sibling, struct ly_set *ext_val)
1436{
1437 struct lyd_node *node;
1438 struct lyd_ctx_ext_val *ext_v;
1439 struct lysc_ext_instance *nested_exts, *ext = NULL;
1440 LY_ARRAY_COUNT_TYPE u;
1441
1442 /* check of basic assumptions */
1443 if (!sibling->parent || !sibling->parent->schema) {
1444 LOGINT_RET(LYD_CTX(sibling));
1445 }
1446 LY_LIST_FOR(sibling, node) {
1447 if (!(node->flags & LYD_EXT)) {
1448 LOGINT_RET(LYD_CTX(sibling));
1449 }
1450 }
1451
1452 /* try to find the extension instance */
1453 nested_exts = sibling->parent->schema->exts;
1454 LY_ARRAY_FOR(nested_exts, u) {
1455 if (nested_exts[u].def->plugin->validate) {
1456 if (ext) {
1457 /* more extension instances with validate callback */
1458 LOGINT_RET(LYD_CTX(sibling));
1459 }
1460 ext = &nested_exts[u];
1461 }
1462 }
1463 if (!ext) {
1464 /* no extension instance with validate callback */
1465 LOGINT_RET(LYD_CTX(sibling));
1466 }
1467
1468 /* store for validation */
1469 ext_v = malloc(sizeof *ext_v);
1470 LY_CHECK_ERR_RET(!ext_v, LOGMEM(LYD_CTX(sibling)), LY_EMEM);
1471 ext_v->ext = ext;
1472 ext_v->sibling = sibling;
1473 LY_CHECK_RET(ly_set_add(ext_val, ext_v, 1, NULL));
1474
1475 return LY_SUCCESS;
1476}
1477
1478/**
Michal Vaskobb844672020-07-03 11:06:12 +02001479 * @brief Validate the whole data subtree.
1480 *
1481 * @param[in] root Subtree root.
Michal Vaskoe0665742021-02-11 11:08:44 +01001482 * @param[in,out] node_when Set for nodes with when conditions.
Michal Vasko32711382020-12-03 14:14:31 +01001483 * @param[in,out] node_types Set for unres node types.
1484 * @param[in,out] meta_types Set for unres metadata types.
Michal Vaskoddd76592022-01-17 13:34:48 +01001485 * @param[in,out] ext_val Set for parsed extension data to validate.
Michal Vasko29adfbe2020-12-08 17:12:03 +01001486 * @param[in] impl_opts Implicit options, see @ref implicitoptions.
Michal Vasko8104fd42020-07-13 11:09:51 +02001487 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +02001488 * @return LY_ERR value.
Radek Krejci7931b192020-06-25 17:05:03 +02001489 */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001490static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +01001491lyd_validate_subtree(struct lyd_node *root, struct ly_set *node_when, struct ly_set *node_types,
1492 struct ly_set *meta_types, struct ly_set *ext_val, uint32_t impl_opts, struct lyd_node **diff)
Michal Vaskofea12c62020-03-30 11:00:15 +02001493{
1494 const struct lyd_meta *meta;
Michal Vasko56daf732020-08-10 10:57:18 +02001495 struct lyd_node *node;
Michal Vaskofea12c62020-03-30 11:00:15 +02001496
Michal Vasko56daf732020-08-10 10:57:18 +02001497 LYD_TREE_DFS_BEGIN(root, node) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001498 if (node->flags & LYD_EXT) {
1499 /* validate using the extension instance callback */
1500 return lyd_validate_nested_ext(node, ext_val);
1501 }
1502
Michal Vasko5900da42021-08-04 11:02:43 +02001503 if (!node->schema) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001504 /* do not validate opaque nodes */
aPiecek18a844e2021-08-10 11:06:24 +02001505 goto next_node;
Michal Vasko5900da42021-08-04 11:02:43 +02001506 }
1507
Michal Vasko0275cf62020-11-05 17:40:30 +01001508 LY_LIST_FOR(node->meta, meta) {
Radek Krejci1b2eef82021-02-17 11:17:27 +01001509 if ((*(const struct lysc_type **)meta->annotation->substmts[ANNOTATION_SUBSTMT_TYPE].storage)->plugin->validate) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001510 /* metadata type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001511 LY_CHECK_RET(ly_set_add(meta_types, (void *)meta, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001512 }
Michal Vasko0275cf62020-11-05 17:40:30 +01001513 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001514
Michal Vasko0275cf62020-11-05 17:40:30 +01001515 if ((node->schema->nodetype & LYD_NODE_TERM) && ((struct lysc_node_leaf *)node->schema)->type->plugin->validate) {
1516 /* node type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001517 LY_CHECK_RET(ly_set_add(node_types, (void *)node, 1, NULL));
Michal Vasko0275cf62020-11-05 17:40:30 +01001518 } else if (node->schema->nodetype & LYD_NODE_INNER) {
1519 /* new node validation, autodelete */
Michal Vaskoe0665742021-02-11 11:08:44 +01001520 LY_CHECK_RET(lyd_validate_new(lyd_node_child_p(node), node->schema, NULL, diff));
Michal Vaskofea12c62020-03-30 11:00:15 +02001521
Michal Vasko0275cf62020-11-05 17:40:30 +01001522 /* add nested defaults */
Michal Vaskoddd76592022-01-17 13:34:48 +01001523 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, NULL, NULL, impl_opts, diff));
Michal Vasko0275cf62020-11-05 17:40:30 +01001524 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001525
Michal Vaskof4d67ea2021-03-31 13:53:21 +02001526 if (lysc_has_when(node->schema)) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001527 /* when evaluation */
Michal Vasko32711382020-12-03 14:14:31 +01001528 LY_CHECK_RET(ly_set_add(node_when, (void *)node, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001529 }
1530
aPiecek18a844e2021-08-10 11:06:24 +02001531next_node:
Michal Vasko56daf732020-08-10 10:57:18 +02001532 LYD_TREE_DFS_END(root, node);
Michal Vaskofea12c62020-03-30 11:00:15 +02001533 }
1534
1535 return LY_SUCCESS;
1536}
1537
Michal Vaskoe0665742021-02-11 11:08:44 +01001538LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001539lyd_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 +01001540 ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p, struct ly_set *meta_types_p,
1541 struct ly_set *ext_val_p, struct lyd_node **diff)
Michal Vaskof03ed032020-03-04 13:31:44 +01001542{
1543 LY_ERR ret = LY_SUCCESS;
Michal Vasko73e47212020-12-03 14:20:16 +01001544 struct lyd_node *first, *next, **first2, *iter;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001545 const struct lys_module *mod;
Michal Vaskoddd76592022-01-17 13:34:48 +01001546 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_val = {0};
Michal Vaskob1b5c262020-03-05 14:29:47 +01001547 uint32_t i = 0;
Michal Vaskof03ed032020-03-04 13:31:44 +01001548
Michal Vaskoe0665742021-02-11 11:08:44 +01001549 assert(tree && ctx);
Michal Vaskoddd76592022-01-17 13:34:48 +01001550 assert((node_when_p && node_types_p && meta_types_p && ext_val_p) ||
1551 (!node_when_p && !node_types_p && !meta_types_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001552
1553 if (!node_when_p) {
1554 node_when_p = &node_when;
1555 node_types_p = &node_types;
1556 meta_types_p = &meta_types;
Michal Vaskoddd76592022-01-17 13:34:48 +01001557 ext_val_p = &ext_val;
Michal Vasko8104fd42020-07-13 11:09:51 +02001558 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001559
Michal Vaskob1b5c262020-03-05 14:29:47 +01001560 next = *tree;
1561 while (1) {
Radek Krejci7931b192020-06-25 17:05:03 +02001562 if (val_opts & LYD_VALIDATE_PRESENT) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001563 mod = lyd_data_next_module(&next, &first);
1564 } else {
Michal Vasko26e80012020-07-08 10:55:46 +02001565 mod = lyd_mod_next_module(next, module, ctx, &i, &first);
Michal Vaskof03ed032020-03-04 13:31:44 +01001566 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001567 if (!mod) {
1568 break;
1569 }
Michal Vasko7c4cf1e2020-06-22 10:04:30 +02001570 if (!first || (first == *tree)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001571 /* make sure first2 changes are carried to tree */
1572 first2 = tree;
1573 } else {
1574 first2 = &first;
1575 }
1576
1577 /* validate new top-level nodes of this module, autodelete */
Michal Vasko8104fd42020-07-13 11:09:51 +02001578 ret = lyd_validate_new(first2, NULL, mod, diff);
1579 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001580
Radek Krejci7be7b9f2021-02-24 11:46:27 +01001581 /* add all top-level defaults for this module, if going to validate subtree, do not add into unres sets
1582 * (lyd_validate_subtree() adds all the nodes in that case) */
Michal Vaskoddd76592022-01-17 13:34:48 +01001583 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, validate_subtree ? NULL : node_when_p,
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001584 validate_subtree ? NULL : node_types_p, (val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, diff);
Michal Vasko8104fd42020-07-13 11:09:51 +02001585 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001586
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001587 /* our first module node pointer may no longer be the first */
Michal Vasko598063b2021-07-19 11:39:05 +02001588 first = *first2;
1589 lyd_first_module_sibling(&first, mod);
1590 if (!first || (first == *tree)) {
1591 first2 = tree;
1592 } else {
1593 first2 = &first;
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001594 }
1595
Michal Vaskoe0665742021-02-11 11:08:44 +01001596 if (validate_subtree) {
1597 /* process nested nodes */
1598 LY_LIST_FOR(*first2, iter) {
Michal Vasko0e72b7a2021-07-16 14:53:27 +02001599 if (lyd_owner_module(iter) != mod) {
1600 break;
1601 }
1602
Michal Vaskoddd76592022-01-17 13:34:48 +01001603 ret = lyd_validate_subtree(iter, node_when_p, node_types_p, meta_types_p, ext_val_p,
Michal Vaskoe0665742021-02-11 11:08:44 +01001604 (val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, diff);
1605 LY_CHECK_GOTO(ret, cleanup);
1606 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001607 }
1608
1609 /* finish incompletely validated terminal values/attributes and when conditions */
Michal Vaskofbbea932022-06-07 11:00:55 +02001610 ret = lyd_validate_unres(first2, mod, LYD_TYPE_DATA_YANG, node_when_p, 0, node_types_p, meta_types_p, ext_val_p,
1611 val_opts, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001612 LY_CHECK_GOTO(ret, cleanup);
1613
1614 /* perform final validation that assumes the data tree is final */
Michal Vasko906bafa2022-04-22 12:28:55 +02001615 ret = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +02001616 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskof03ed032020-03-04 13:31:44 +01001617 }
1618
Michal Vaskof03ed032020-03-04 13:31:44 +01001619cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001620 ly_set_erase(&node_when, NULL);
Michal Vasko32711382020-12-03 14:14:31 +01001621 ly_set_erase(&node_types, NULL);
1622 ly_set_erase(&meta_types, NULL);
Michal Vaskoddd76592022-01-17 13:34:48 +01001623 ly_set_erase(&ext_val, free);
Michal Vaskof03ed032020-03-04 13:31:44 +01001624 return ret;
1625}
Michal Vaskob1b5c262020-03-05 14:29:47 +01001626
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001627LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001628lyd_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 +01001629{
Michal Vaskoe0665742021-02-11 11:08:44 +01001630 LY_CHECK_ARG_RET(NULL, tree, *tree || ctx, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001631 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001632 if (!ctx) {
1633 ctx = LYD_CTX(*tree);
1634 }
1635 if (diff) {
1636 *diff = NULL;
1637 }
1638
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001639 return lyd_validate(tree, NULL, ctx, val_opts, 1, NULL, NULL, NULL, NULL, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001640}
1641
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001642LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001643lyd_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 +01001644{
Michal Vaskoe0665742021-02-11 11:08:44 +01001645 LY_CHECK_ARG_RET(NULL, tree, *tree || module, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001646 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module ? module->ctx : NULL, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001647 if (diff) {
1648 *diff = NULL;
1649 }
1650
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001651 return lyd_validate(tree, module, (*tree) ? LYD_CTX(*tree) : module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001652}
Michal Vaskofea12c62020-03-30 11:00:15 +02001653
Michal Vaskobb844672020-07-03 11:06:12 +02001654/**
1655 * @brief Find nodes for merging an operation into data tree for validation.
1656 *
1657 * @param[in] op_tree Full operation data tree.
1658 * @param[in] op_node Operation node itself.
1659 * @param[in] tree Data tree to be merged into.
1660 * @param[out] op_subtree Operation subtree to merge.
Michal Vasko2f03d222020-12-09 18:15:51 +01001661 * @param[out] tree_sibling Data tree sibling to merge next to, is set if @p tree_parent is NULL.
1662 * @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 +02001663 */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001664static void
Michal Vaskobb844672020-07-03 11:06:12 +02001665lyd_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 +01001666 struct lyd_node **op_subtree, struct lyd_node **tree_sibling, struct lyd_node **tree_parent)
Michal Vaskofea12c62020-03-30 11:00:15 +02001667{
Michal Vaskocb7526d2020-03-30 15:08:26 +02001668 const struct lyd_node *tree_iter, *op_iter;
1669 struct lyd_node *match;
Michal Vaskofea12c62020-03-30 11:00:15 +02001670 uint32_t i, cur_depth, op_depth;
Michal Vaskofea12c62020-03-30 11:00:15 +02001671
Michal Vasko2f03d222020-12-09 18:15:51 +01001672 *op_subtree = NULL;
1673 *tree_sibling = NULL;
1674 *tree_parent = NULL;
1675
Michal Vaskocb7526d2020-03-30 15:08:26 +02001676 /* learn op depth (top-level being depth 0) */
Michal Vaskofea12c62020-03-30 11:00:15 +02001677 op_depth = 0;
Michal Vasko9e685082021-01-29 14:49:09 +01001678 for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001679 ++op_depth;
1680 }
1681
1682 /* find where to merge op */
1683 tree_iter = tree;
1684 cur_depth = op_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001685 while (cur_depth && tree_iter) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001686 /* find op iter in tree */
1687 lyd_find_sibling_first(tree_iter, op_iter, &match);
1688 if (!match) {
1689 break;
1690 }
1691
1692 /* move tree_iter */
Radek Krejcia1c1e542020-09-29 16:06:52 +02001693 tree_iter = lyd_child(match);
Michal Vaskofea12c62020-03-30 11:00:15 +02001694
1695 /* move depth */
1696 --cur_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001697
1698 /* find next op parent */
1699 op_iter = op_node;
1700 for (i = 0; i < cur_depth; ++i) {
Michal Vasko9e685082021-01-29 14:49:09 +01001701 op_iter = lyd_parent(op_iter);
Michal Vasko2f03d222020-12-09 18:15:51 +01001702 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001703 }
1704
Michal Vasko2f03d222020-12-09 18:15:51 +01001705 assert(op_iter);
Michal Vaskobb844672020-07-03 11:06:12 +02001706 *op_subtree = (struct lyd_node *)op_iter;
Michal Vasko2f03d222020-12-09 18:15:51 +01001707 if (!tree || tree_iter) {
1708 /* there is no tree whatsoever or this is the last found sibling */
1709 *tree_sibling = (struct lyd_node *)tree_iter;
1710 } else {
1711 /* matching parent was found but it has no children to insert next to */
1712 assert(match);
1713 *tree_parent = match;
1714 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001715}
1716
Michal Vaskoe0665742021-02-11 11:08:44 +01001717/**
1718 * @brief Validate an RPC/action request, reply, or notification.
1719 *
1720 * @param[in] op_tree Full operation data tree.
1721 * @param[in] op_node Operation node itself.
1722 * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
1723 * @param[in] int_opts Internal parser options.
Michal Vaskofbbea932022-06-07 11:00:55 +02001724 * @param[in] data_type Type of validated data.
Michal Vaskoe0665742021-02-11 11:08:44 +01001725 * @param[in] validate_subtree Whether subtree was already validated (as part of data parsing) or not (separate validation).
1726 * @param[in] node_when_p Set of nodes with when conditions, if NULL a local set is used.
1727 * @param[in] node_types_p Set of unres node types, if NULL a local set is used.
1728 * @param[in] meta_types_p Set of unres metadata types, if NULL a local set is used.
Michal Vaskoddd76592022-01-17 13:34:48 +01001729 * @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 +01001730 * @param[out] diff Optional diff with any changes made by the validation.
1731 * @return LY_SUCCESS on success.
1732 * @return LY_ERR error on error.
1733 */
1734static LY_ERR
Michal Vaskofbbea932022-06-07 11:00:55 +02001735_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 +01001736 uint32_t int_opts, ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p,
1737 struct ly_set *meta_types_p, struct ly_set *ext_val_p, struct lyd_node **diff)
Michal Vaskocb7526d2020-03-30 15:08:26 +02001738{
Michal Vaskoe0665742021-02-11 11:08:44 +01001739 LY_ERR rc = LY_SUCCESS;
Michal Vaskofbbea932022-06-07 11:00:55 +02001740 struct lyd_node *tree_sibling, *tree_parent, *op_subtree, *op_parent, *op_sibling_before, *op_sibling_after, *child;
Michal Vaskoddd76592022-01-17 13:34:48 +01001741 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_val = {0};
Michal Vaskocb7526d2020-03-30 15:08:26 +02001742
Michal Vaskoe0665742021-02-11 11:08:44 +01001743 assert(op_tree && op_node);
Michal Vaskoddd76592022-01-17 13:34:48 +01001744 assert((node_when_p && node_types_p && meta_types_p && ext_val_p) ||
1745 (!node_when_p && !node_types_p && !meta_types_p && !ext_val_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001746
1747 if (!node_when_p) {
1748 node_when_p = &node_when;
1749 node_types_p = &node_types;
1750 meta_types_p = &meta_types;
Michal Vaskoddd76592022-01-17 13:34:48 +01001751 ext_val_p = &ext_val;
Michal Vaskoe0665742021-02-11 11:08:44 +01001752 }
1753
1754 /* merge op_tree into dep_tree */
1755 lyd_val_op_merge_find(op_tree, op_node, dep_tree, &op_subtree, &tree_sibling, &tree_parent);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001756 op_sibling_before = op_subtree->prev->next ? op_subtree->prev : NULL;
1757 op_sibling_after = op_subtree->next;
Michal Vaskoe0665742021-02-11 11:08:44 +01001758 op_parent = lyd_parent(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001759
Michal Vaskoe0665742021-02-11 11:08:44 +01001760 lyd_unlink_tree(op_subtree);
Michal Vasko6ee6f432021-07-16 09:49:14 +02001761 lyd_insert_node(tree_parent, &tree_sibling, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001762 if (!dep_tree) {
1763 dep_tree = tree_sibling;
1764 }
1765
1766 LOG_LOCSET(NULL, op_node, NULL, NULL);
1767
1768 if (int_opts & LYD_INTOPT_REPLY) {
1769 /* add output children defaults */
Michal Vaskoddd76592022-01-17 13:34:48 +01001770 rc = lyd_new_implicit_r(op_node, lyd_node_child_p(op_node), NULL, NULL, node_when_p, node_types_p,
Michal Vaskoe0665742021-02-11 11:08:44 +01001771 LYD_IMPLICIT_OUTPUT, diff);
1772 LY_CHECK_GOTO(rc, cleanup);
1773
1774 if (validate_subtree) {
1775 /* skip validating the operation itself, go to children directly */
1776 LY_LIST_FOR(lyd_child(op_node), child) {
Michal Vaskoddd76592022-01-17 13:34:48 +01001777 rc = lyd_validate_subtree(child, node_when_p, node_types_p, meta_types_p, ext_val_p, 0, diff);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001778 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001779 }
1780 }
1781 } else {
1782 if (validate_subtree) {
1783 /* prevalidate whole operation subtree */
Michal Vaskoddd76592022-01-17 13:34:48 +01001784 rc = lyd_validate_subtree(op_node, node_when_p, node_types_p, meta_types_p, ext_val_p, 0, diff);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001785 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001786 }
1787 }
1788
Michal Vasko906bafa2022-04-22 12:28:55 +02001789 /* finish incompletely validated terminal values/attributes and when conditions on the full tree,
1790 * account for unresolved 'when' that may appear in the non-validated dependency data tree */
Michal Vaskofbbea932022-06-07 11:00:55 +02001791 LY_CHECK_GOTO(rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, node_when_p, LYXP_IGNORE_WHEN,
Michal Vasko906bafa2022-04-22 12:28:55 +02001792 node_types_p, meta_types_p, ext_val_p, 0, diff), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001793
1794 /* perform final validation of the operation/notification */
1795 lyd_validate_obsolete(op_node);
Michal Vasko906bafa2022-04-22 12:28:55 +02001796 LY_CHECK_GOTO(rc = lyd_validate_must(op_node, int_opts, LYXP_IGNORE_WHEN), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001797
1798 /* final validation of all the descendants */
Michal Vasko906bafa2022-04-22 12:28:55 +02001799 rc = lyd_validate_final_r(lyd_child(op_node), op_node, op_node->schema, NULL, 0, int_opts, LYXP_IGNORE_WHEN);
1800 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001801
1802cleanup:
1803 LOG_LOCBACK(0, 1, 0, 0);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001804
Michal Vaskoe0665742021-02-11 11:08:44 +01001805 /* restore operation tree */
1806 lyd_unlink_tree(op_subtree);
Michal Vaskoc61dd062022-06-07 11:01:28 +02001807 if (op_sibling_before) {
1808 lyd_insert_after_node(op_sibling_before, op_subtree);
1809 } else if (op_sibling_after) {
1810 lyd_insert_before_node(op_sibling_after, op_subtree);
1811 } else if (op_parent) {
Michal Vasko6ee6f432021-07-16 09:49:14 +02001812 lyd_insert_node(op_parent, NULL, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001813 }
1814
1815 ly_set_erase(&node_when, NULL);
1816 ly_set_erase(&node_types, NULL);
1817 ly_set_erase(&meta_types, NULL);
Michal Vaskoddd76592022-01-17 13:34:48 +01001818 ly_set_erase(&ext_val, free);
Michal Vaskoe0665742021-02-11 11:08:44 +01001819 return rc;
1820}
1821
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001822LIBYANG_API_DEF LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01001823lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type, struct lyd_node **diff)
1824{
1825 struct lyd_node *op_node;
1826 uint32_t int_opts;
Michal Vaskofbbea932022-06-07 11:00:55 +02001827 struct ly_set ext_val = {0};
1828 LY_ERR rc;
Michal Vaskoe0665742021-02-11 11:08:44 +01001829
Michal Vasko2da45692022-04-29 09:51:08 +02001830 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 +01001831 (data_type == LYD_TYPE_NOTIF_YANG) || (data_type == LYD_TYPE_REPLY_YANG), LY_EINVAL);
Michal Vasko8104fd42020-07-13 11:09:51 +02001832 if (diff) {
1833 *diff = NULL;
1834 }
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001835 if (data_type == LYD_TYPE_RPC_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001836 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001837 } else if (data_type == LYD_TYPE_NOTIF_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001838 int_opts = LYD_INTOPT_NOTIF;
1839 } else {
1840 int_opts = LYD_INTOPT_REPLY;
1841 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001842
Michal Vasko2da45692022-04-29 09:51:08 +02001843 if (op_tree->schema && (op_tree->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF))) {
1844 /* we have the operation/notification, adjust the pointers */
1845 op_node = op_tree;
1846 while (op_tree->parent) {
1847 op_tree = lyd_parent(op_tree);
Michal Vaskocb7526d2020-03-30 15:08:26 +02001848 }
Michal Vasko2da45692022-04-29 09:51:08 +02001849 } else {
1850 /* find the operation/notification */
1851 while (op_tree->parent) {
1852 op_tree = lyd_parent(op_tree);
1853 }
1854 LYD_TREE_DFS_BEGIN(op_tree, op_node) {
1855 if (!op_node->schema) {
Michal Vaskoac6f4be2022-05-02 10:16:50 +02001856 return lyd_parse_opaq_error(op_node);
Michal Vaskofbbea932022-06-07 11:00:55 +02001857 } else if (op_node->flags & LYD_EXT) {
1858 /* fully validate the rest using the extension instance callback */
1859 LY_CHECK_RET(lyd_validate_nested_ext(op_node, &ext_val));
1860 rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, NULL, 0, NULL, NULL, &ext_val,
1861 0, diff);
1862 ly_set_erase(&ext_val, free);
1863 return rc;
Michal Vasko2da45692022-04-29 09:51:08 +02001864 }
1865
1866 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) &&
1867 (op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
1868 break;
1869 } else if ((int_opts & LYD_INTOPT_NOTIF) && (op_node->schema->nodetype == LYS_NOTIF)) {
1870 break;
1871 }
1872 LYD_TREE_DFS_END(op_tree, op_node);
1873 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001874 }
Michal Vasko2da45692022-04-29 09:51:08 +02001875
Michal Vaskoe0665742021-02-11 11:08:44 +01001876 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) {
Michal Vasko9b232082022-06-07 10:59:31 +02001877 if (!op_node || !(op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001878 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No RPC/action to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02001879 return LY_EINVAL;
1880 }
1881 } else {
Michal Vasko9b232082022-06-07 10:59:31 +02001882 if (!op_node || (op_node->schema->nodetype != LYS_NOTIF)) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001883 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No notification to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02001884 return LY_EINVAL;
1885 }
1886 }
1887
Michal Vaskoe0665742021-02-11 11:08:44 +01001888 /* validate */
Michal Vaskofbbea932022-06-07 11:00:55 +02001889 return _lyd_validate_op(op_tree, op_node, dep_tree, data_type, int_opts, 1, NULL, NULL, NULL, NULL, diff);
Michal Vaskofea12c62020-03-30 11:00:15 +02001890}