blob: 2d41d59509e2f0d608eb418bb1d56db8435f47e6 [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 Vaskoe78faec2021-04-08 17:24:43 +02006 * Copyright (c) 2019 - 2021 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.
119 * @param[out] disabled First when that evaluated false, if any.
120 * @return LY_SUCCESS on success.
121 * @return LY_EINCOMPLETE if a referenced node does not have its when evaluated.
122 * @return LY_ERR value on error.
Michal Vaskocde73ac2019-11-14 16:10:27 +0100123 */
124static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100125lyd_validate_node_when(const struct lyd_node *tree, const struct lyd_node *node, const struct lysc_node *schema,
126 const struct lysc_when **disabled)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100127{
Michal Vasko8104fd42020-07-13 11:09:51 +0200128 LY_ERR ret;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100129 const struct lyd_node *ctx_node;
130 struct lyxp_set xp_set;
Michal Vaskobd4db892020-11-23 16:58:20 +0100131 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100132
Michal Vaskobd4db892020-11-23 16:58:20 +0100133 assert(!node->schema || (node->schema == schema));
Michal Vaskocde73ac2019-11-14 16:10:27 +0100134
Michal Vaskobd4db892020-11-23 16:58:20 +0100135 *disabled = NULL;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100136
Michal Vaskobd4db892020-11-23 16:58:20 +0100137 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100138 const struct lysc_when *when;
139 struct lysc_when **when_list = lysc_node_when(schema);
140 LY_ARRAY_FOR(when_list, u) {
141 when = when_list[u];
Michal Vaskocde73ac2019-11-14 16:10:27 +0100142
Michal Vaskobd4db892020-11-23 16:58:20 +0100143 /* get context node */
144 if (when->context == schema) {
145 ctx_node = node;
146 } else {
147 assert((!when->context && !node->parent) || (when->context == node->parent->schema));
Michal Vasko9e685082021-01-29 14:49:09 +0100148 ctx_node = lyd_parent(node);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100149 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100150
151 /* evaluate when */
152 memset(&xp_set, 0, sizeof xp_set);
Radek Krejci8df109d2021-04-23 12:19:08 +0200153 ret = lyxp_eval(LYD_CTX(node), when->cond, schema->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
aPiecekfba75362021-10-07 12:39:48 +0200154 ctx_node, tree, NULL, &xp_set, LYXP_SCHEMA);
Michal Vaskobd4db892020-11-23 16:58:20 +0100155 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
156
157 /* return error or LY_EINCOMPLETE for dependant unresolved when */
158 LY_CHECK_RET(ret);
159
160 if (!xp_set.val.bln) {
161 /* false when */
162 *disabled = when;
163 return LY_SUCCESS;
Michal Vasko8104fd42020-07-13 11:09:51 +0200164 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100165 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100166
167 schema = schema->parent;
168 } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE)));
169
170 return LY_SUCCESS;
171}
172
173/**
174 * @brief Evaluate when conditions of collected unres nodes.
175 *
176 * @param[in,out] tree Data tree, is updated if some nodes are autodeleted.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100177 * @param[in] mod Module of the @p tree to take into consideration when deleting @p tree and moving it.
178 * If set, it is expected @p tree should point to the first node of @p mod. Otherwise it will simply be
179 * the first top-level sibling.
Michal Vaskobd4db892020-11-23 16:58:20 +0100180 * @param[in] node_when Set with nodes with "when" conditions.
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200181 * @param[in,out] node_types Set with nodes with unresolved types, remove any with false "when" parents.
Michal Vaskobd4db892020-11-23 16:58:20 +0100182 * @param[in,out] diff Validation diff.
183 * @return LY_SUCCESS on success.
184 * @return LY_ERR value on error.
185 */
186static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100187lyd_validate_unres_when(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when,
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200188 struct ly_set *node_types, struct lyd_node **diff)
Michal Vaskobd4db892020-11-23 16:58:20 +0100189{
190 LY_ERR ret;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200191 uint32_t i, idx;
Michal Vaskobd4db892020-11-23 16:58:20 +0100192 const struct lysc_when *disabled;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200193 struct lyd_node *node = NULL, *elem;
Michal Vaskobd4db892020-11-23 16:58:20 +0100194
195 if (!node_when->count) {
196 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100197 }
198
Michal Vaskobd4db892020-11-23 16:58:20 +0100199 i = node_when->count;
200 do {
201 --i;
202 node = node_when->dnodes[i];
Radek Krejciddace2c2021-01-08 11:30:56 +0100203 LOG_LOCSET(node->schema, node, NULL, NULL);
Michal Vaskobd4db892020-11-23 16:58:20 +0100204
205 /* evaluate all when expressions that affect this node's existence */
206 ret = lyd_validate_node_when(*tree, node, node->schema, &disabled);
207 if (!ret) {
208 if (disabled) {
209 /* when false */
210 if (node->flags & LYD_WHEN_TRUE) {
211 /* autodelete */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100212 lyd_del_move_root(tree, node, mod);
Michal Vaskobd4db892020-11-23 16:58:20 +0100213 if (diff) {
214 /* add into diff */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100215 ret = lyd_val_diff_add(node, LYD_DIFF_OP_DELETE, diff);
216 LY_CHECK_GOTO(ret, error);
Michal Vaskobd4db892020-11-23 16:58:20 +0100217 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200218
219 /* remove from node types set, if present */
Michal Vasko36ce6b22021-07-26 09:19:21 +0200220 if (node_types) {
221 LYD_TREE_DFS_BEGIN(node, elem) {
222 if (ly_set_contains(node_types, elem, &idx)) {
223 LY_CHECK_GOTO(ret = ly_set_rm_index(node_types, idx, NULL), error);
224 }
225 LYD_TREE_DFS_END(node, elem);
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200226 }
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200227 }
228
229 /* free */
Michal Vaskobd4db892020-11-23 16:58:20 +0100230 lyd_free_tree(node);
231 } else {
232 /* invalid data */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100233 LOGVAL(LYD_CTX(node), LY_VCODE_NOWHEN, disabled->cond->expr);
234 ret = LY_EVALID;
235 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100236 }
237 } else {
238 /* when true */
239 node->flags |= LYD_WHEN_TRUE;
240 }
241
242 /* remove this node from the set, its when was resolved */
243 ly_set_rm_index(node_when, i, NULL);
244 } else if (ret != LY_EINCOMPLETE) {
245 /* error */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100246 goto error;
Michal Vaskobd4db892020-11-23 16:58:20 +0100247 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100248
Radek Krejciddace2c2021-01-08 11:30:56 +0100249 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskobd4db892020-11-23 16:58:20 +0100250 } while (i);
251
252 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100253
254error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100255 LOG_LOCBACK(1, 1, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100256 return ret;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100257}
258
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200259struct node_ext {
260 struct lyd_node *node;
261 struct lysc_ext_instance *ext;
262};
263
264static LY_ERR
265node_ext_tovalidate_add(struct ly_set *node_exts, struct lysc_ext_instance *exts, struct lyd_node *node)
266{
267 LY_ERR ret = LY_SUCCESS;
268 struct lysc_ext_instance *ext;
269 struct node_ext *rec;
270
Radek Krejci3011b072021-04-13 20:25:34 +0200271 LY_ARRAY_FOR(exts, struct lysc_ext_instance, ext) {
Radek Krejci4a4d1e02021-04-09 14:04:40 +0200272 if (ext->def->plugin && ext->def->plugin->validate) {
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200273 rec = malloc(sizeof *rec);
274 LY_CHECK_ERR_RET(!rec, LOGMEM(LYD_CTX(node)), LY_EMEM);
275 rec->ext = ext;
276 rec->node = node;
277
278 ret = ly_set_add(node_exts, rec, 1, NULL);
279 if (ret) {
280 free(rec);
281 break;
282 }
283 }
284 }
285
286 return ret;
287}
288
Michal Vaskocde73ac2019-11-14 16:10:27 +0100289LY_ERR
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200290lysc_node_ext_tovalidate(struct ly_set *node_exts, struct lyd_node *node)
291{
292 const struct lysc_node *schema = node->schema;
293
294 if (!schema) {
295 /* nothing to do */
296 return LY_SUCCESS;
297 }
298
299 /* node's extensions */
300 LY_CHECK_RET(node_ext_tovalidate_add(node_exts, schema->exts, node));
301
302 if (schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
303 /* type's extensions */
304 LY_CHECK_RET(node_ext_tovalidate_add(node_exts, ((struct lysc_node_leaf *)schema)->type->exts, node));
305 }
306
307 return LY_SUCCESS;
308}
309
310LY_ERR
311lyd_validate_unres(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when, struct ly_set *node_exts,
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100312 struct ly_set *node_types, struct ly_set *meta_types, struct lyd_node **diff)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100313{
314 LY_ERR ret = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200315 uint32_t i;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100316
Michal Vaskob1b5c262020-03-05 14:29:47 +0100317 if (node_when) {
318 /* evaluate all when conditions */
319 uint32_t prev_count;
320 do {
321 prev_count = node_when->count;
Michal Vasko27d2b1b2021-07-19 15:20:02 +0200322 LY_CHECK_RET(lyd_validate_unres_when(tree, mod, node_when, node_types, diff));
Radek Krejci0f969882020-08-21 16:56:47 +0200323 /* there must have been some when conditions resolved */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100324 } while (prev_count > node_when->count);
Michal Vaskocde73ac2019-11-14 16:10:27 +0100325
Michal Vaskob1b5c262020-03-05 14:29:47 +0100326 /* there could have been no cyclic when dependencies, checked during compilation */
327 assert(!node_when->count);
328 }
329
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200330 if (node_exts && node_exts->count) {
331 i = node_exts->count;
332 do {
333 --i;
334
335 struct node_ext *item = node_exts->objs[i];
336
337 LOG_LOCSET(item->node->schema, item->node, NULL, NULL);
338 ret = item->ext->def->plugin->validate(item->ext, item->node);
339 LOG_LOCBACK(item->node->schema ? 1 : 0, 1, 0, 0);
340 LY_CHECK_RET(ret);
341
342 /* remove this node from the set */
343 ly_set_rm_index(node_exts, i, free);
344 } while (i);
345 }
346
Michal Vaskob1b5c262020-03-05 14:29:47 +0100347 if (node_types && node_types->count) {
348 /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200349 i = node_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100350 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200351 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100352
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100353 struct lyd_node_term *node = node_types->objs[i];
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200354 struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100355
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200356 /* resolve the value of the node */
Michal Vasko9e685082021-01-29 14:49:09 +0100357 LOG_LOCSET(node->schema, &node->node, NULL, NULL);
358 ret = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree);
Radek Krejciddace2c2021-01-08 11:30:56 +0100359 LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100360 LY_CHECK_RET(ret);
361
362 /* remove this node from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200363 ly_set_rm_index(node_types, i, NULL);
364 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100365 }
366
Michal Vasko9f96a052020-03-10 09:41:45 +0100367 if (meta_types && meta_types->count) {
368 /* ... and metadata values */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200369 i = meta_types->count;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100370 do {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200371 --i;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100372
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100373 struct lyd_meta *meta = meta_types->objs[i];
Radek Krejci1b2eef82021-02-17 11:17:27 +0100374 struct lysc_type *type = *(struct lysc_type **)meta->annotation->substmts[ANNOTATION_SUBSTMT_TYPE].storage;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100375
Michal Vasko9f96a052020-03-10 09:41:45 +0100376 /* validate and store the value of the metadata */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100377 ret = lyd_value_validate_incomplete(LYD_CTX(meta->parent), type, &meta->value, meta->parent, *tree);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100378 LY_CHECK_RET(ret);
379
380 /* remove this attr from the set */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200381 ly_set_rm_index(meta_types, i, NULL);
382 } while (i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100383 }
Michal Vaskocde73ac2019-11-14 16:10:27 +0100384
385 return ret;
386}
387
Michal Vaskobb844672020-07-03 11:06:12 +0200388/**
389 * @brief Validate instance duplication.
390 *
391 * @param[in] first First sibling to search in.
392 * @param[in] node Data node instance to check.
393 * @return LY_ERR value.
394 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100395static LY_ERR
396lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node)
Michal Vaskocde73ac2019-11-14 16:10:27 +0100397{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100398 struct lyd_node **match_p;
Radek Krejci857189e2020-09-01 13:26:36 +0200399 ly_bool fail = 0;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100400
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100401 assert(node->flags & LYD_NEW);
402
Michal Vaskod6c18af2021-02-12 12:07:31 +0100403 /* key-less list or non-configuration leaf-list */
Michal Vaskoe78faec2021-04-08 17:24:43 +0200404 if (lysc_is_dup_inst_list(node->schema)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100405 /* duplicate instances allowed */
406 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100407 }
408
Michal Vaskob1b5c262020-03-05 14:29:47 +0100409 /* find exactly the same next instance using hashes if possible */
410 if (node->parent && node->parent->children_ht) {
411 if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) {
412 fail = 1;
413 }
414 } else {
Michal Vaskod989ba02020-08-24 10:59:24 +0200415 for ( ; first; first = first->next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100416 if (first == node) {
417 continue;
418 }
419
420 if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) {
421 if (first->schema == node->schema) {
422 fail = 1;
423 break;
424 }
Michal Vasko8f359bf2020-07-28 10:41:15 +0200425 } else if (!lyd_compare_single(first, node, 0)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100426 fail = 1;
427 break;
428 }
429 }
430 }
431
432 if (fail) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100433 LOGVAL(node->schema->module->ctx, LY_VCODE_DUP, node->schema->name);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100434 return LY_EVALID;
435 }
436 return LY_SUCCESS;
Michal Vaskocde73ac2019-11-14 16:10:27 +0100437}
438
Michal Vaskobb844672020-07-03 11:06:12 +0200439/**
440 * @brief Validate multiple case data existence with possible autodelete.
441 *
442 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100443 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200444 * @param[in] choic Choice node whose cases to check.
Michal Vasko8104fd42020-07-13 11:09:51 +0200445 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200446 * @return LY_ERR value.
447 */
Michal Vaskocde73ac2019-11-14 16:10:27 +0100448static LY_ERR
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100449lyd_validate_cases(struct lyd_node **first, const struct lys_module *mod, const struct lysc_node_choice *choic,
450 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100451{
452 const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL;
453 struct lyd_node *match, *to_del;
Radek Krejci857189e2020-09-01 13:26:36 +0200454 ly_bool found;
Michal Vaskob1b5c262020-03-05 14:29:47 +0100455
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100456 LOG_LOCSET(&choic->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100457
Michal Vaskob1b5c262020-03-05 14:29:47 +0100458 LY_LIST_FOR((struct lysc_node *)choic->cases, scase) {
459 found = 0;
460 iter = NULL;
461 match = NULL;
462 while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) {
463 if (match->flags & LYD_NEW) {
464 /* a new case data found, nothing more to look for */
465 found = 2;
466 break;
467 } else {
468 /* and old case data found */
469 if (found == 0) {
470 found = 1;
471 }
472 }
473 }
474
475 if (found == 1) {
476 /* there should not be 2 old cases */
477 if (old_case) {
478 /* old data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100479 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, old_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100480 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100481 return LY_EVALID;
482 }
483
484 /* remember an old existing case */
485 old_case = scase;
486 } else if (found == 2) {
487 if (new_case) {
488 /* new data from 2 cases */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100489 LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, new_case->name, scase->name);
Radek Krejciddace2c2021-01-08 11:30:56 +0100490 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100491 return LY_EVALID;
492 }
493
494 /* remember a new existing case */
495 new_case = scase;
496 }
497 }
498
Radek Krejciddace2c2021-01-08 11:30:56 +0100499 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100500
Michal Vaskob1b5c262020-03-05 14:29:47 +0100501 if (old_case && new_case) {
502 /* auto-delete old case */
503 iter = NULL;
504 match = NULL;
505 to_del = NULL;
506 while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100507 lyd_del_move_root(first, to_del, mod);
508
Michal Vasko8104fd42020-07-13 11:09:51 +0200509 /* free previous node */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100510 lyd_free_tree(to_del);
Michal Vasko8104fd42020-07-13 11:09:51 +0200511 if (diff) {
512 /* add into diff */
513 LY_CHECK_RET(lyd_val_diff_add(match, LYD_DIFF_OP_DELETE, diff));
514 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100515 to_del = match;
516 }
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100517 lyd_del_move_root(first, to_del, mod);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100518 lyd_free_tree(to_del);
519 }
520
521 return LY_SUCCESS;
522}
523
Michal Vaskobb844672020-07-03 11:06:12 +0200524/**
525 * @brief Check whether a schema node can have some default values (true for NP containers as well).
526 *
527 * @param[in] schema Schema node to check.
528 * @return non-zero if yes,
529 * @return 0 otherwise.
530 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100531static int
532lyd_val_has_default(const struct lysc_node *schema)
533{
534 switch (schema->nodetype) {
535 case LYS_LEAF:
536 if (((struct lysc_node_leaf *)schema)->dflt) {
537 return 1;
538 }
539 break;
540 case LYS_LEAFLIST:
541 if (((struct lysc_node_leaflist *)schema)->dflts) {
542 return 1;
543 }
544 break;
545 case LYS_CONTAINER:
546 if (!(schema->flags & LYS_PRESENCE)) {
547 return 1;
548 }
549 break;
550 default:
551 break;
552 }
553
554 return 0;
555}
556
Michal Vaskobb844672020-07-03 11:06:12 +0200557/**
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100558 * @brief Properly delete a node as part of autodelete validation tasks.
559 *
560 * @param[in,out] first First sibling, is updated if needed.
561 * @param[in] node Node instance to delete.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100562 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100563 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
564 * @param[in,out] diff Validation diff.
565 */
566static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100567lyd_validate_autodel_node_del(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
568 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100569{
570 struct lyd_node *iter;
571
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100572 lyd_del_move_root(first, node, mod);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100573 if (node == *next_p) {
574 *next_p = (*next_p)->next;
575 }
576 if (diff) {
577 /* add into diff */
578 if ((node->schema->nodetype == LYS_CONTAINER) && !(node->schema->flags & LYS_PRESENCE)) {
579 /* we do not want to track NP container changes, but remember any removed children */
580 LY_LIST_FOR(lyd_child(node), iter) {
581 lyd_val_diff_add(iter, LYD_DIFF_OP_DELETE, diff);
582 }
583 } else {
584 lyd_val_diff_add(node, LYD_DIFF_OP_DELETE, diff);
585 }
586 }
587 lyd_free_tree(node);
588}
589
590/**
Michal Vaskobb844672020-07-03 11:06:12 +0200591 * @brief Autodelete old instances to prevent validation errors.
592 *
593 * @param[in,out] first First sibling to search in, is updated if needed.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100594 * @param[in] node New data node instance to check.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100595 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskobb844672020-07-03 11:06:12 +0200596 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
Michal Vasko8104fd42020-07-13 11:09:51 +0200597 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +0200598 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100599static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100600lyd_validate_autodel_dup(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
601 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100602{
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100603 struct lyd_node *match, *next;
604
605 assert(node->flags & LYD_NEW);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100606
607 if (lyd_val_has_default(node->schema)) {
608 assert(node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CONTAINER));
Michal Vasko4c583e82020-07-17 12:16:14 +0200609 LYD_LIST_FOR_INST_SAFE(*first, node->schema, next, match) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100610 if ((match->flags & LYD_DEFAULT) && !(match->flags & LYD_NEW)) {
611 /* default instance found, remove it */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100612 lyd_validate_autodel_node_del(first, match, mod, next_p, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100613
614 /* remove only a single container/leaf default instance, if there are more, it is an error */
615 if (node->schema->nodetype & (LYS_LEAF | LYS_CONTAINER)) {
616 break;
617 }
618 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100619 }
620 }
621}
622
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100623/**
624 * @brief Autodelete leftover default nodes of deleted cases (that have no existing explicit data).
625 *
626 * @param[in,out] first First sibling to search in, is updated if needed.
627 * @param[in] node Default data node instance to check.
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100628 * @param[in] mod Module of the siblings, NULL for nested siblings.
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100629 * @param[in,out] next_p Temporary LY_LIST_FOR_SAFE next pointer, is updated if needed.
630 * @param[in,out] diff Validation diff.
631 */
632static void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100633lyd_validate_autodel_case_dflt(struct lyd_node **first, struct lyd_node *node, const struct lys_module *mod,
634 struct lyd_node **next_p, struct lyd_node **diff)
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100635{
636 struct lysc_node_choice *choic;
637 struct lyd_node *iter = NULL;
638 const struct lysc_node *slast = NULL;
639
640 assert(node->flags & LYD_DEFAULT);
641
642 if (!node->schema->parent || (node->schema->parent->nodetype != LYS_CASE)) {
643 /* the default node is not a descendant of a case */
644 return;
645 }
646
647 choic = (struct lysc_node_choice *)node->schema->parent->parent;
648 assert(choic->nodetype == LYS_CHOICE);
649
650 if (choic->dflt && (choic->dflt == (struct lysc_node_case *)node->schema->parent)) {
651 /* data of a default case, keep them */
652 return;
653 }
654
655 /* try to find an explicit node of the case */
656 while ((iter = lys_getnext_data(iter, *first, &slast, node->schema->parent, NULL))) {
657 if (!(iter->flags & LYD_DEFAULT)) {
658 break;
659 }
660 }
661
662 if (!iter) {
663 /* there are only default nodes of the case meaning it does not exist and neither should any default nodes
664 * of the case, remove this one default node */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100665 lyd_validate_autodel_node_del(first, node, mod, next_p, diff);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100666 }
667}
668
Michal Vasko17f76642021-08-03 17:01:30 +0200669/**
670 * @brief Validate new siblings in choices, recursively for nested choices.
671 *
672 * @param[in,out] first First sibling.
673 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
674 * @param[in] mod Module of the siblings, NULL for nested siblings.
675 * @param[in,out] diff Validation diff.
676 * @return LY_ERR value.
677 */
678static LY_ERR
679lyd_validate_choice_r(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
Radek Krejci0f969882020-08-21 16:56:47 +0200680 struct lyd_node **diff)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100681{
Michal Vaskob1b5c262020-03-05 14:29:47 +0100682 const struct lysc_node *snode = NULL;
683
Michal Vaskob1b5c262020-03-05 14:29:47 +0100684 while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) {
685 /* check case duplicites */
686 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100687 LY_CHECK_RET(lyd_validate_cases(first, mod, (struct lysc_node_choice *)snode, diff));
Michal Vasko17f76642021-08-03 17:01:30 +0200688
689 /* check for nested choice */
690 LY_CHECK_RET(lyd_validate_choice_r(first, snode, mod, diff));
Michal Vaskob1b5c262020-03-05 14:29:47 +0100691 }
692 }
693
Michal Vasko17f76642021-08-03 17:01:30 +0200694 return LY_SUCCESS;
695}
696
697LY_ERR
698lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod,
699 struct lyd_node **diff)
700{
701 struct lyd_node *next, *node;
702
703 assert(first && (sparent || mod));
704
705 /* validate choices */
706 LY_CHECK_RET(lyd_validate_choice_r(first, sparent, mod, diff));
707
Michal Vaskob1b5c262020-03-05 14:29:47 +0100708 LY_LIST_FOR_SAFE(*first, next, node) {
Michal Vaskoc193ce92020-03-06 11:04:48 +0100709 if (mod && (lyd_owner_module(node) != mod)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100710 /* all top-level data from this module checked */
711 break;
712 }
713
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100714 if (!(node->flags & (LYD_NEW | LYD_DEFAULT))) {
715 /* check only new and default nodes */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100716 continue;
717 }
718
Radek Krejciddace2c2021-01-08 11:30:56 +0100719 LOG_LOCSET(node->schema, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100720
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100721 if (node->flags & LYD_NEW) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100722 LY_ERR ret;
723
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100724 /* remove old default(s) of the new node if it exists */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100725 lyd_validate_autodel_dup(first, node, mod, &next, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100726
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100727 /* then check new node instance duplicities */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100728 ret = lyd_validate_duplicates(*first, node);
Radek Krejciddace2c2021-01-08 11:30:56 +0100729 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0), ret);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100730
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100731 /* this node is valid */
732 node->flags &= ~LYD_NEW;
733 }
734
Michal Vasko0e6de512021-01-11 13:39:44 +0100735 LOG_LOCBACK(node->schema ? 1 : 0, 1, 0, 0);
736
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100737 if (node->flags & LYD_DEFAULT) {
738 /* remove leftover default nodes from a no-longer existing case */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100739 lyd_validate_autodel_case_dflt(first, node, mod, &next, diff);
Michal Vaskodcacf2f2020-11-18 18:18:15 +0100740 }
Michal Vaskob1b5c262020-03-05 14:29:47 +0100741 }
742
743 return LY_SUCCESS;
744}
745
Michal Vaskobb844672020-07-03 11:06:12 +0200746/**
Michal Vaskobd4db892020-11-23 16:58:20 +0100747 * @brief Evaluate any "when" conditions of a non-existent data node with existing parent.
748 *
749 * @param[in] first First data sibling of the non-existing node.
750 * @param[in] parent Data parent of the non-existing node.
751 * @param[in] snode Schema node of the non-existing node.
752 * @param[out] disabled First when that evaluated false, if any.
753 * @return LY_ERR value.
754 */
755static LY_ERR
756lyd_validate_dummy_when(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
757 const struct lysc_when **disabled)
758{
759 LY_ERR ret = LY_SUCCESS;
760 struct lyd_node *tree, *dummy = NULL;
761
762 /* find root */
763 if (parent) {
764 tree = (struct lyd_node *)parent;
765 while (tree->parent) {
766 tree = lyd_parent(tree);
767 }
768 tree = lyd_first_sibling(tree);
769 } else {
770 assert(!first || !first->prev->next);
771 tree = (struct lyd_node *)first;
772 }
773
774 /* create dummy opaque node */
Michal Vasko0ab974d2021-02-24 13:18:26 +0100775 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 +0100776 LY_CHECK_GOTO(ret, cleanup);
777
778 /* connect it if needed */
779 if (!parent) {
780 if (first) {
781 lyd_insert_sibling((struct lyd_node *)first, dummy, &tree);
782 } else {
783 assert(!tree);
784 tree = dummy;
785 }
786 }
787
788 /* evaluate all when */
789 ret = lyd_validate_node_when(tree, dummy, snode, disabled);
790 if (ret == LY_EINCOMPLETE) {
791 /* all other when must be resolved by now */
792 LOGINT(snode->module->ctx);
793 ret = LY_EINT;
794 goto cleanup;
795 } else if (ret) {
796 /* error */
797 goto cleanup;
798 }
799
800cleanup:
801 lyd_free_tree(dummy);
802 return ret;
803}
804
805/**
Michal Vaskobb844672020-07-03 11:06:12 +0200806 * @brief Validate mandatory node existence.
807 *
808 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100809 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200810 * @param[in] snode Schema node to validate.
811 * @return LY_ERR value.
812 */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100813static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100814lyd_validate_mandatory(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode)
Michal Vaskoa3881362020-01-21 15:57:35 +0100815{
Michal Vaskobd4db892020-11-23 16:58:20 +0100816 const struct lysc_when *disabled;
817
Michal Vaskoa3881362020-01-21 15:57:35 +0100818 if (snode->nodetype == LYS_CHOICE) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100819 /* some data of a choice case exist */
Michal Vaskob1b5c262020-03-05 14:29:47 +0100820 if (lys_getnext_data(NULL, first, NULL, snode, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100821 return LY_SUCCESS;
822 }
823 } else {
824 assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY));
Michal Vaskoa3881362020-01-21 15:57:35 +0100825
Michal Vaskob1b5c262020-03-05 14:29:47 +0100826 if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100827 /* data instance found */
828 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100829 }
830 }
831
Michal Vaskobd4db892020-11-23 16:58:20 +0100832 disabled = NULL;
833 if (lysc_has_when(snode)) {
834 /* if there are any when conditions, they must be true for a validation error */
835 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
836 }
837
838 if (!disabled) {
839 /* node instance not found */
Michal Vasko538b8952021-02-17 11:27:26 +0100840 if (snode->nodetype == LYS_CHOICE) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200841 LOGVAL_APPTAG(snode->module->ctx, "missing-choice", LY_VCODE_NOMAND_CHOIC, snode->name);
Michal Vasko538b8952021-02-17 11:27:26 +0100842 } else {
843 LOGVAL(snode->module->ctx, LY_VCODE_NOMAND, snode->name);
844 }
Michal Vaskobd4db892020-11-23 16:58:20 +0100845 return LY_EVALID;
846 }
847
848 return LY_SUCCESS;
Michal Vaskoa3881362020-01-21 15:57:35 +0100849}
850
Michal Vaskobb844672020-07-03 11:06:12 +0200851/**
852 * @brief Validate min/max-elements constraints, if any.
853 *
854 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +0100855 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +0200856 * @param[in] snode Schema node to validate.
857 * @param[in] min Minimum number of elements, 0 for no restriction.
858 * @param[in] max Max number of elements, 0 for no restriction.
859 * @return LY_ERR value.
860 */
Michal Vaskoa3881362020-01-21 15:57:35 +0100861static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +0100862lyd_validate_minmax(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode,
863 uint32_t min, uint32_t max)
Michal Vaskoa3881362020-01-21 15:57:35 +0100864{
Michal Vaskoacd83e72020-02-04 14:12:01 +0100865 uint32_t count = 0;
Michal Vasko4c583e82020-07-17 12:16:14 +0200866 struct lyd_node *iter;
Michal Vaskobd4db892020-11-23 16:58:20 +0100867 const struct lysc_when *disabled;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100868 ly_bool invalid_instance = 0;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100869
Michal Vasko9b368d32020-02-14 13:53:31 +0100870 assert(min || max);
871
Michal Vasko4c583e82020-07-17 12:16:14 +0200872 LYD_LIST_FOR_INST(first, snode, iter) {
873 ++count;
Michal Vasko9b368d32020-02-14 13:53:31 +0100874
Michal Vasko4c583e82020-07-17 12:16:14 +0200875 if (min && (count == min)) {
876 /* satisfied */
877 min = 0;
878 if (!max) {
879 /* nothing more to check */
Michal Vasko9b368d32020-02-14 13:53:31 +0100880 break;
881 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100882 }
Michal Vasko4c583e82020-07-17 12:16:14 +0200883 if (max && (count > max)) {
884 /* not satisifed */
Radek Krejciddace2c2021-01-08 11:30:56 +0100885 LOG_LOCSET(NULL, iter, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100886 invalid_instance = 1;
Michal Vasko4c583e82020-07-17 12:16:14 +0200887 break;
888 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100889 }
890
Michal Vasko9b368d32020-02-14 13:53:31 +0100891 if (min) {
892 assert(count < min);
Michal Vaskobd4db892020-11-23 16:58:20 +0100893
894 disabled = NULL;
895 if (lysc_has_when(snode)) {
896 /* if there are any when conditions, they must be true for a validation error */
897 LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled));
898 }
899
900 if (!disabled) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200901 LOGVAL_APPTAG(snode->module->ctx, "too-few-elements", LY_VCODE_NOMIN, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100902 goto failure;
Michal Vaskobd4db892020-11-23 16:58:20 +0100903 }
Michal Vaskoacd83e72020-02-04 14:12:01 +0100904 } else if (max && (count > max)) {
Michal Vaskoe9391c72021-10-05 10:04:56 +0200905 LOGVAL_APPTAG(snode->module->ctx, "too-many-elements", LY_VCODE_NOMAX, snode->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100906 goto failure;
Michal Vaskoacd83e72020-02-04 14:12:01 +0100907 }
908
Michal Vaskoa3881362020-01-21 15:57:35 +0100909 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100910
911failure:
Radek Krejciddace2c2021-01-08 11:30:56 +0100912 LOG_LOCBACK(0, invalid_instance, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100913 return LY_EVALID;
Michal Vaskoa3881362020-01-21 15:57:35 +0100914}
915
Michal Vaskobb844672020-07-03 11:06:12 +0200916/**
917 * @brief Find node referenced by a list unique statement.
918 *
919 * @param[in] uniq_leaf Unique leaf to find.
920 * @param[in] list List instance to use for the search.
921 * @return Found leaf,
922 * @return NULL if no leaf found.
923 */
Michal Vasko14654712020-02-06 08:35:21 +0100924static struct lyd_node *
Michal Vaskobb844672020-07-03 11:06:12 +0200925lyd_val_uniq_find_leaf(const struct lysc_node_leaf *uniq_leaf, const struct lyd_node *list)
Michal Vasko14654712020-02-06 08:35:21 +0100926{
Michal Vasko9b368d32020-02-14 13:53:31 +0100927 struct lyd_node *node;
928 const struct lysc_node *iter;
929 size_t depth = 0, i;
Michal Vasko14654712020-02-06 08:35:21 +0100930
Michal Vasko9b368d32020-02-14 13:53:31 +0100931 /* get leaf depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100932 for (iter = &uniq_leaf->node; iter && (iter != list->schema); iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +0200933 ++depth;
Michal Vasko14654712020-02-06 08:35:21 +0100934 }
Michal Vasko9b368d32020-02-14 13:53:31 +0100935
Michal Vaskobb844672020-07-03 11:06:12 +0200936 node = (struct lyd_node *)list;
Michal Vasko9b368d32020-02-14 13:53:31 +0100937 while (node && depth) {
938 /* find schema node with this depth */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100939 for (i = depth - 1, iter = &uniq_leaf->node; i; iter = lysc_data_parent(iter)) {
Michal Vasko62ed12d2020-05-21 10:08:25 +0200940 --i;
Michal Vasko9b368d32020-02-14 13:53:31 +0100941 }
942
943 /* find iter instance in children */
944 assert(iter->nodetype & (LYS_CONTAINER | LYS_LEAF));
Radek Krejcia1c1e542020-09-29 16:06:52 +0200945 lyd_find_sibling_val(lyd_child(node), iter, NULL, 0, &node);
Michal Vasko9b368d32020-02-14 13:53:31 +0100946 --depth;
947 }
948
Michal Vasko14654712020-02-06 08:35:21 +0100949 return node;
950}
951
Michal Vaskobb844672020-07-03 11:06:12 +0200952/**
953 * @brief Callback for comparing 2 list unique leaf values.
954 *
Michal Vasko62524a92021-02-26 10:08:50 +0100955 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200956 *
Michal Vaskobb844672020-07-03 11:06:12 +0200957 * @param[in] cb_data 0 to compare all uniques, n to compare only n-th unique.
Michal Vasko14654712020-02-06 08:35:21 +0100958 */
Radek Krejci857189e2020-09-01 13:26:36 +0200959static ly_bool
960lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *cb_data)
Michal Vasko14654712020-02-06 08:35:21 +0100961{
962 struct ly_ctx *ctx;
963 struct lysc_node_list *slist;
964 struct lyd_node *diter, *first, *second;
965 struct lyd_value *val1, *val2;
966 char *path1, *path2, *uniq_str, *ptr;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200967 LY_ARRAY_COUNT_TYPE u, v, action;
Michal Vasko14654712020-02-06 08:35:21 +0100968
969 assert(val1_p && val2_p);
970
971 first = *((struct lyd_node **)val1_p);
972 second = *((struct lyd_node **)val2_p);
Michal Vasko41e630c2021-07-23 12:47:18 +0200973 action = (uintptr_t)cb_data;
Michal Vasko14654712020-02-06 08:35:21 +0100974
975 assert(first && (first->schema->nodetype == LYS_LIST));
976 assert(second && (second->schema == first->schema));
977
978 ctx = first->schema->module->ctx;
979
980 slist = (struct lysc_node_list *)first->schema;
981
982 /* compare unique leaves */
983 if (action > 0) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200984 u = action - 1;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200985 if (u < LY_ARRAY_COUNT(slist->uniques)) {
Michal Vasko14654712020-02-06 08:35:21 +0100986 goto uniquecheck;
987 }
988 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200989 LY_ARRAY_FOR(slist->uniques, u) {
Michal Vasko14654712020-02-06 08:35:21 +0100990uniquecheck:
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200991 LY_ARRAY_FOR(slist->uniques[u], v) {
Michal Vasko14654712020-02-06 08:35:21 +0100992 /* first */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200993 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], first);
Michal Vasko14654712020-02-06 08:35:21 +0100994 if (diter) {
995 val1 = &((struct lyd_node_term *)diter)->value;
996 } else {
997 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200998 val1 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +0100999 }
1000
1001 /* second */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001002 diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], second);
Michal Vasko14654712020-02-06 08:35:21 +01001003 if (diter) {
1004 val2 = &((struct lyd_node_term *)diter)->value;
1005 } else {
1006 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001007 val2 = slist->uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001008 }
1009
1010 if (!val1 || !val2 || val1->realtype->plugin->compare(val1, val2)) {
1011 /* values differ or either one is not set */
1012 break;
1013 }
1014 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001015 if (v && (v == LY_ARRAY_COUNT(slist->uniques[u]))) {
Michal Vasko14654712020-02-06 08:35:21 +01001016 /* all unique leafs are the same in this set, create this nice error */
Radek Krejci635d2b82021-01-04 11:26:51 +01001017 path1 = lyd_path(first, LYD_PATH_STD, NULL, 0);
1018 path2 = lyd_path(second, LYD_PATH_STD, NULL, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001019
1020 /* use buffer to rebuild the unique string */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001021#define UNIQ_BUF_SIZE 1024
1022 uniq_str = malloc(UNIQ_BUF_SIZE);
Michal Vasko14654712020-02-06 08:35:21 +01001023 uniq_str[0] = '\0';
1024 ptr = uniq_str;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001025 LY_ARRAY_FOR(slist->uniques[u], v) {
1026 if (v) {
Michal Vasko14654712020-02-06 08:35:21 +01001027 strcpy(ptr, " ");
1028 ++ptr;
1029 }
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001030 ptr = lysc_path_until((struct lysc_node *)slist->uniques[u][v], &slist->node, LYSC_PATH_LOG,
Radek Krejcif13b87b2020-12-01 22:02:17 +01001031 ptr, UNIQ_BUF_SIZE - (ptr - uniq_str));
Michal Vasko14654712020-02-06 08:35:21 +01001032 if (!ptr) {
1033 /* path will be incomplete, whatever */
1034 break;
1035 }
1036
1037 ptr += strlen(ptr);
1038 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001039 LOG_LOCSET(NULL, second, NULL, NULL);
Michal Vaskoe9391c72021-10-05 10:04:56 +02001040 LOGVAL_APPTAG(ctx, "data-not-unique", LY_VCODE_NOUNIQ, uniq_str, path1, path2);
Radek Krejciddace2c2021-01-08 11:30:56 +01001041 LOG_LOCBACK(0, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001042
1043 free(path1);
1044 free(path2);
1045 free(uniq_str);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001046#undef UNIQ_BUF_SIZE
1047
Michal Vasko14654712020-02-06 08:35:21 +01001048 return 1;
1049 }
1050
1051 if (action > 0) {
1052 /* done */
1053 return 0;
1054 }
1055 }
1056
1057 return 0;
1058}
1059
Michal Vaskobb844672020-07-03 11:06:12 +02001060/**
1061 * @brief Validate list unique leaves.
1062 *
1063 * @param[in] first First sibling to search in.
1064 * @param[in] snode Schema node to validate.
1065 * @param[in] uniques List unique arrays to validate.
1066 * @return LY_ERR value.
1067 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001068static LY_ERR
Michal Vaskobb844672020-07-03 11:06:12 +02001069lyd_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 +01001070{
Michal Vaskob1b5c262020-03-05 14:29:47 +01001071 const struct lyd_node *diter;
Michal Vasko14654712020-02-06 08:35:21 +01001072 struct ly_set *set;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001073 LY_ARRAY_COUNT_TYPE u, v, x = 0;
Michal Vasko14654712020-02-06 08:35:21 +01001074 LY_ERR ret = LY_SUCCESS;
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001075 uint32_t hash, i, size = 0;
Radek Krejci813c02d2021-04-26 10:29:19 +02001076 size_t key_len;
1077 ly_bool dyn;
1078 const void *hash_key;
Michal Vasko41e630c2021-07-23 12:47:18 +02001079 void *cb_data;
Michal Vasko14654712020-02-06 08:35:21 +01001080 struct hash_table **uniqtables = NULL;
1081 struct lyd_value *val;
1082 struct ly_ctx *ctx = snode->module->ctx;
1083
1084 assert(uniques);
1085
1086 /* get all list instances */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001087 LY_CHECK_RET(ly_set_new(&set));
Michal Vaskob1b5c262020-03-05 14:29:47 +01001088 LY_LIST_FOR(first, diter) {
Michal Vasko9b368d32020-02-14 13:53:31 +01001089 if (diter->schema == snode) {
Radek Krejci3d92e442020-10-12 12:48:13 +02001090 ret = ly_set_add(set, (void *)diter, 1, NULL);
Michal Vaskob0099a92020-08-31 14:55:23 +02001091 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko9b368d32020-02-14 13:53:31 +01001092 }
1093 }
Michal Vasko14654712020-02-06 08:35:21 +01001094
1095 if (set->count == 2) {
1096 /* simple comparison */
1097 if (lyd_val_uniq_list_equal(&set->objs[0], &set->objs[1], 0, (void *)0)) {
1098 /* instance duplication */
1099 ret = LY_EVALID;
1100 goto cleanup;
1101 }
1102 } else if (set->count > 2) {
1103 /* use hashes for comparison */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001104 /* first, allocate the table, the size depends on number of items in the set,
1105 * the following code detects number of upper zero bits in the items' counter value ... */
1106 for (i = (sizeof set->count * CHAR_BIT) - 1; i > 0; i--) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001107 size = set->count << i;
1108 size = size >> i;
1109 if (size == set->count) {
Michal Vasko14654712020-02-06 08:35:21 +01001110 break;
1111 }
1112 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001113 LY_CHECK_ERR_GOTO(!i, LOGINT(ctx); ret = LY_EINT, cleanup);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001114 /* ... and then we convert it to the position of the highest non-zero bit ... */
1115 i = (sizeof set->count * CHAR_BIT) - i;
1116 /* ... 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 +02001117 size = 1 << i;
Michal Vasko14654712020-02-06 08:35:21 +01001118
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001119 uniqtables = malloc(LY_ARRAY_COUNT(uniques) * sizeof *uniqtables);
Michal Vasko14654712020-02-06 08:35:21 +01001120 LY_CHECK_ERR_GOTO(!uniqtables, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001121 x = LY_ARRAY_COUNT(uniques);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001122 for (v = 0; v < x; v++) {
Michal Vasko41e630c2021-07-23 12:47:18 +02001123 cb_data = (void *)(uintptr_t)(v + 1L);
1124 uniqtables[v] = lyht_new(size, sizeof(struct lyd_node *), lyd_val_uniq_list_equal, cb_data, 0);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001125 LY_CHECK_ERR_GOTO(!uniqtables[v], LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko14654712020-02-06 08:35:21 +01001126 }
1127
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001128 for (i = 0; i < set->count; i++) {
Michal Vasko14654712020-02-06 08:35:21 +01001129 /* loop for unique - get the hash for the instances */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001130 for (u = 0; u < x; u++) {
Michal Vasko14654712020-02-06 08:35:21 +01001131 val = NULL;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001132 for (v = hash = 0; v < LY_ARRAY_COUNT(uniques[u]); v++) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001133 diter = lyd_val_uniq_find_leaf(uniques[u][v], set->objs[i]);
Michal Vasko14654712020-02-06 08:35:21 +01001134 if (diter) {
1135 val = &((struct lyd_node_term *)diter)->value;
1136 } else {
1137 /* use default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001138 val = uniques[u][v]->dflt;
Michal Vasko14654712020-02-06 08:35:21 +01001139 }
1140 if (!val) {
1141 /* unique item not present nor has default value */
1142 break;
1143 }
1144
Radek Krejci813c02d2021-04-26 10:29:19 +02001145 /* get hash key */
Michal Vaskodcfac2c2021-05-10 11:36:37 +02001146 hash_key = val->realtype->plugin->print(NULL, val, LY_VALUE_LYB, NULL, &dyn, &key_len);
Radek Krejci813c02d2021-04-26 10:29:19 +02001147 hash = dict_hash_multi(hash, hash_key, key_len);
1148 if (dyn) {
1149 free((void *)hash_key);
Michal Vasko14654712020-02-06 08:35:21 +01001150 }
1151 }
1152 if (!val) {
1153 /* skip this list instance since its unique set is incomplete */
1154 continue;
1155 }
1156
1157 /* finish the hash value */
1158 hash = dict_hash_multi(hash, NULL, 0);
1159
1160 /* insert into the hashtable */
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001161 ret = lyht_insert(uniqtables[u], &set->objs[i], hash, NULL);
Michal Vasko14654712020-02-06 08:35:21 +01001162 if (ret == LY_EEXIST) {
1163 /* instance duplication */
1164 ret = LY_EVALID;
1165 }
1166 LY_CHECK_GOTO(ret != LY_SUCCESS, cleanup);
1167 }
1168 }
1169 }
1170
1171cleanup:
1172 ly_set_free(set, NULL);
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001173 for (v = 0; v < x; v++) {
1174 if (!uniqtables[v]) {
Michal Vasko14654712020-02-06 08:35:21 +01001175 /* failed when allocating uniquetables[j], following j are not allocated */
1176 break;
1177 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +02001178 lyht_free(uniqtables[v]);
Michal Vasko14654712020-02-06 08:35:21 +01001179 }
1180 free(uniqtables);
1181
1182 return ret;
Michal Vaskoa3881362020-01-21 15:57:35 +01001183}
1184
Michal Vaskobb844672020-07-03 11:06:12 +02001185/**
1186 * @brief Validate data siblings based on generic schema node restrictions, recursively for schema-only nodes.
1187 *
1188 * @param[in] first First sibling to search in.
Michal Vaskobd4db892020-11-23 16:58:20 +01001189 * @param[in] parent Data parent.
Michal Vaskobb844672020-07-03 11:06:12 +02001190 * @param[in] sparent Schema parent of the nodes to check.
1191 * @param[in] mod Module of the nodes to check.
1192 * @param[in] val_opts Validation options, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +01001193 * @param[in] int_opts Internal parser options.
Michal Vaskobb844672020-07-03 11:06:12 +02001194 * @return LY_ERR value.
1195 */
Michal Vaskoa3881362020-01-21 15:57:35 +01001196static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001197lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lyd_node *parent,
Michal Vaskoe0665742021-02-11 11:08:44 +01001198 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 +01001199{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001200 LY_ERR ret = LY_SUCCESS;
Michal Vasko6c16cda2021-02-04 11:05:52 +01001201 const struct lysc_node *snode = NULL, *scase;
Michal Vaskoa3881362020-01-21 15:57:35 +01001202 struct lysc_node_list *slist;
Michal Vaskod8958df2020-08-05 13:27:36 +02001203 struct lysc_node_leaflist *sllist;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001204 uint32_t getnext_opts;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001205
Michal Vaskoe0665742021-02-11 11:08:44 +01001206 getnext_opts = LYS_GETNEXT_WITHCHOICE | (int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001207
Michal Vaskoa3881362020-01-21 15:57:35 +01001208 /* disabled nodes are skipped by lys_getnext */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001209 while ((snode = lys_getnext(snode, sparent, mod, getnext_opts))) {
Radek Krejci7931b192020-06-25 17:05:03 +02001210 if ((val_opts & LYD_VALIDATE_NO_STATE) && (snode->flags & LYS_CONFIG_R)) {
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001211 continue;
1212 }
1213
Radek Krejciddace2c2021-01-08 11:30:56 +01001214 LOG_LOCSET(snode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001215
Michal Vaskoa3881362020-01-21 15:57:35 +01001216 /* check min-elements and max-elements */
Michal Vaskod8958df2020-08-05 13:27:36 +02001217 if (snode->nodetype == LYS_LIST) {
Michal Vaskoa3881362020-01-21 15:57:35 +01001218 slist = (struct lysc_node_list *)snode;
1219 if (slist->min || slist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001220 ret = lyd_validate_minmax(first, parent, snode, slist->min, slist->max);
1221 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001222 }
Michal Vaskod8958df2020-08-05 13:27:36 +02001223 } else if (snode->nodetype == LYS_LEAFLIST) {
1224 sllist = (struct lysc_node_leaflist *)snode;
1225 if (sllist->min || sllist->max) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001226 ret = lyd_validate_minmax(first, parent, snode, sllist->min, sllist->max);
1227 LY_CHECK_GOTO(ret, error);
Michal Vaskod8958df2020-08-05 13:27:36 +02001228 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001229
Michal Vaskoacd83e72020-02-04 14:12:01 +01001230 } else if (snode->flags & LYS_MAND_TRUE) {
Radek Krejcif6a11002020-08-21 13:29:07 +02001231 /* check generic mandatory existence */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001232 ret = lyd_validate_mandatory(first, parent, snode);
1233 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001234 }
1235
1236 /* check unique */
1237 if (snode->nodetype == LYS_LIST) {
1238 slist = (struct lysc_node_list *)snode;
1239 if (slist->uniques) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001240 ret = lyd_validate_unique(first, snode, (const struct lysc_node_leaf ***)slist->uniques);
1241 LY_CHECK_GOTO(ret, error);
Michal Vaskoa3881362020-01-21 15:57:35 +01001242 }
1243 }
1244
Michal Vasko6c16cda2021-02-04 11:05:52 +01001245 if (snode->nodetype == LYS_CHOICE) {
1246 /* find the existing case, if any */
1247 LY_LIST_FOR(lysc_node_child(snode), scase) {
1248 if (lys_getnext_data(NULL, first, NULL, scase, NULL)) {
1249 /* validate only this case */
Michal Vaskoe0665742021-02-11 11:08:44 +01001250 ret = lyd_validate_siblings_schema_r(first, parent, scase, mod, val_opts, int_opts);
Michal Vasko6c16cda2021-02-04 11:05:52 +01001251 LY_CHECK_GOTO(ret, error);
1252 break;
1253 }
1254 }
Michal Vaskoacd83e72020-02-04 14:12:01 +01001255 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001256
Radek Krejciddace2c2021-01-08 11:30:56 +01001257 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskocde73ac2019-11-14 16:10:27 +01001258 }
1259
Michal Vaskoacd83e72020-02-04 14:12:01 +01001260 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001261
1262error:
Radek Krejciddace2c2021-01-08 11:30:56 +01001263 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001264 return ret;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001265}
1266
Michal Vaskobb844672020-07-03 11:06:12 +02001267/**
1268 * @brief Validate obsolete nodes, only warnings are printed.
1269 *
1270 * @param[in] node Node to check.
1271 */
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001272static void
1273lyd_validate_obsolete(const struct lyd_node *node)
1274{
1275 const struct lysc_node *snode;
1276
1277 snode = node->schema;
1278 do {
1279 if (snode->flags & LYS_STATUS_OBSLT) {
1280 LOGWRN(snode->module->ctx, "Obsolete schema node \"%s\" instantiated in data.", snode->name);
1281 break;
1282 }
1283
1284 snode = snode->parent;
1285 } while (snode && (snode->nodetype & (LYS_CHOICE | LYS_CASE)));
1286}
1287
Michal Vaskobb844672020-07-03 11:06:12 +02001288/**
1289 * @brief Validate must conditions of a data node.
1290 *
1291 * @param[in] node Node to validate.
Michal Vaskoe0665742021-02-11 11:08:44 +01001292 * @param[in] int_opts Internal parser options.
Michal Vaskobb844672020-07-03 11:06:12 +02001293 * @return LY_ERR value.
1294 */
Michal Vaskocc048b22020-03-27 15:52:38 +01001295static LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01001296lyd_validate_must(const struct lyd_node *node, uint32_t int_opts)
Michal Vaskocc048b22020-03-27 15:52:38 +01001297{
Michal Vaskoa1db2342021-07-19 12:23:23 +02001298 LY_ERR ret;
Michal Vaskocc048b22020-03-27 15:52:38 +01001299 struct lyxp_set xp_set;
1300 struct lysc_must *musts;
1301 const struct lyd_node *tree;
Radek Krejci9a3823e2021-01-27 20:26:46 +01001302 const struct lysc_node *schema;
Michal Vaskoe9391c72021-10-05 10:04:56 +02001303 const char *emsg, *eapptag;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001304 LY_ARRAY_COUNT_TYPE u;
Michal Vaskocc048b22020-03-27 15:52:38 +01001305
Michal Vaskoe0665742021-02-11 11:08:44 +01001306 assert((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) != (LYD_INTOPT_RPC | LYD_INTOPT_REPLY));
1307 assert((int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) != (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY));
1308
Radek Krejci9a3823e2021-01-27 20:26:46 +01001309 if (node->schema->nodetype & (LYS_ACTION | LYS_RPC)) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001310 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001311 schema = &((struct lysc_node_action *)node->schema)->input.node;
Michal Vaskoe0665742021-02-11 11:08:44 +01001312 } else if (int_opts & LYD_INTOPT_REPLY) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001313 schema = &((struct lysc_node_action *)node->schema)->output.node;
Michal Vaskocb7526d2020-03-30 15:08:26 +02001314 } else {
Michal Vaskoa1db2342021-07-19 12:23:23 +02001315 LOGINT_RET(LYD_CTX(node));
Michal Vaskocb7526d2020-03-30 15:08:26 +02001316 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001317 } else {
1318 schema = node->schema;
Michal Vaskocc048b22020-03-27 15:52:38 +01001319 }
Radek Krejci9a3823e2021-01-27 20:26:46 +01001320 musts = lysc_node_musts(schema);
Michal Vaskocc048b22020-03-27 15:52:38 +01001321 if (!musts) {
1322 /* no must to evaluate */
1323 return LY_SUCCESS;
1324 }
1325
1326 /* find first top-level node */
Michal Vasko9e685082021-01-29 14:49:09 +01001327 for (tree = node; tree->parent; tree = lyd_parent(tree)) {}
Michal Vaskof9221e62021-02-04 12:10:14 +01001328 tree = lyd_first_sibling(tree);
Michal Vaskocc048b22020-03-27 15:52:38 +01001329
1330 LY_ARRAY_FOR(musts, u) {
1331 memset(&xp_set, 0, sizeof xp_set);
1332
1333 /* evaluate must */
Michal Vaskoa1db2342021-07-19 12:23:23 +02001334 ret = lyxp_eval(LYD_CTX(node), musts[u].cond, node->schema->module, LY_VALUE_SCHEMA_RESOLVED,
aPiecekfba75362021-10-07 12:39:48 +02001335 musts[u].prefixes, node, tree, NULL, &xp_set, LYXP_SCHEMA);
Michal Vaskoa1db2342021-07-19 12:23:23 +02001336 if (ret == LY_EINCOMPLETE) {
1337 LOGINT_RET(LYD_CTX(node));
1338 } else if (ret) {
1339 return ret;
1340 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001341
1342 /* check the result */
1343 lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN);
Michal Vasko004d3152020-06-11 19:59:22 +02001344 if (!xp_set.val.bln) {
Michal Vaskoe9391c72021-10-05 10:04:56 +02001345 /* use specific error information */
1346 emsg = musts[u].emsg;
1347 eapptag = musts[u].eapptag ? musts[u].eapptag : "must-violation";
1348 if (emsg) {
1349 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LYVE_DATA, "%s", emsg);
1350 } else {
1351 LOGVAL_APPTAG(LYD_CTX(node), eapptag, LY_VCODE_NOMUST, musts[u].cond->expr);
1352 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001353 return LY_EVALID;
1354 }
1355 }
1356
1357 return LY_SUCCESS;
1358}
1359
Michal Vaskoe0665742021-02-11 11:08:44 +01001360/**
1361 * @brief Perform all remaining validation tasks, the data tree must be final when calling this function.
1362 *
1363 * @param[in] first First sibling.
1364 * @param[in] parent Data parent.
1365 * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings.
1366 * @param[in] mod Module of the siblings, NULL for nested siblings.
1367 * @param[in] val_opts Validation options (@ref datavalidationoptions).
1368 * @param[in] int_opts Internal parser options.
1369 * @return LY_ERR value.
1370 */
1371static LY_ERR
Michal Vaskobd4db892020-11-23 16:58:20 +01001372lyd_validate_final_r(struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *sparent,
Michal Vaskoe0665742021-02-11 11:08:44 +01001373 const struct lys_module *mod, uint32_t val_opts, uint32_t int_opts)
Michal Vaskoacd83e72020-02-04 14:12:01 +01001374{
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001375 LY_ERR r;
1376 const char *innode;
Radek Krejci7f769d72020-07-11 23:13:56 +02001377 struct lyd_node *next = NULL, *node;
Michal Vaskoacd83e72020-02-04 14:12:01 +01001378
Michal Vasko14654712020-02-06 08:35:21 +01001379 /* validate all restrictions of nodes themselves */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001380 LY_LIST_FOR_SAFE(first, next, node) {
Michal Vasko19034e22021-07-19 12:24:14 +02001381 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001382 /* all top-level data from this module checked */
1383 break;
Michal Vaskof03ed032020-03-04 13:31:44 +01001384 }
1385
Radek Krejciddace2c2021-01-08 11:30:56 +01001386 LOG_LOCSET(node->schema, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001387
Michal Vaskoa8c61722020-03-27 16:59:32 +01001388 /* opaque data */
1389 if (!node->schema) {
Michal Vasko5900da42021-08-04 11:02:43 +02001390 LOGVAL(LYD_CTX(node), LYVE_DATA, "Invalid opaque node \"%s\" found.", ((struct lyd_node_opaq *)node)->name.name);
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001391 LOG_LOCBACK(1, 1, 0, 0);
Michal Vaskoa8c61722020-03-27 16:59:32 +01001392 return LY_EVALID;
1393 }
1394
Michal Vasko8d289f92021-12-02 10:11:00 +01001395 /* no state/input/output/op data */
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001396 innode = NULL;
Radek Krejci7931b192020-06-25 17:05:03 +02001397 if ((val_opts & LYD_VALIDATE_NO_STATE) && (node->schema->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001398 innode = "state";
Michal Vaskoe0665742021-02-11 11:08:44 +01001399 } else if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) && (node->schema->flags & LYS_IS_OUTPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001400 innode = "output";
Michal Vaskoe0665742021-02-11 11:08:44 +01001401 } else if ((int_opts & LYD_INTOPT_REPLY) && (node->schema->flags & LYS_IS_INPUT)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001402 innode = "input";
Michal Vasko8d289f92021-12-02 10:11:00 +01001403 } else if (!(int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_RPC)) {
1404 innode = "rpc";
1405 } else if (!(int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_ACTION)) {
1406 innode = "action";
1407 } else if (!(int_opts & LYD_INTOPT_NOTIF) && (node->schema->nodetype == LYS_NOTIF)) {
1408 innode = "notification";
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001409 }
1410 if (innode) {
1411 LOGVAL(LYD_CTX(node), LY_VCODE_UNEXPNODE, innode, node->schema->name);
1412 LOG_LOCBACK(1, 1, 0, 0);
1413 return LY_EVALID;
Michal Vasko5b37a352020-03-06 13:38:33 +01001414 }
1415
Michal Vaskoe75ecfd2020-03-06 14:12:28 +01001416 /* obsolete data */
1417 lyd_validate_obsolete(node);
1418
Michal Vaskocc048b22020-03-27 15:52:38 +01001419 /* node's musts */
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001420 if ((r = lyd_validate_must(node, int_opts))) {
1421 LOG_LOCBACK(1, 1, 0, 0);
1422 return r;
1423 }
Michal Vaskocc048b22020-03-27 15:52:38 +01001424
Michal Vasko53d97a12020-11-05 17:39:10 +01001425 /* node value was checked by plugins */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001426
Michal Vasko22e8f1f2021-12-02 09:26:06 +01001427 /* next iter */
Radek Krejciddace2c2021-01-08 11:30:56 +01001428 LOG_LOCBACK(1, 1, 0, 0);
Michal Vasko14654712020-02-06 08:35:21 +01001429 }
Michal Vaskocde73ac2019-11-14 16:10:27 +01001430
Michal Vasko14654712020-02-06 08:35:21 +01001431 /* validate schema-based restrictions */
Michal Vaskoe0665742021-02-11 11:08:44 +01001432 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 +01001433
Michal Vaskob1b5c262020-03-05 14:29:47 +01001434 LY_LIST_FOR(first, node) {
Michal Vasko19034e22021-07-19 12:24:14 +02001435 if (!node->parent && mod && (lyd_owner_module(node) != mod)) {
1436 /* all top-level data from this module checked */
1437 break;
1438 }
1439
Michal Vasko14654712020-02-06 08:35:21 +01001440 /* validate all children recursively */
Michal Vaskoe0665742021-02-11 11:08:44 +01001441 LY_CHECK_RET(lyd_validate_final_r(lyd_child(node), node, node->schema, NULL, val_opts, int_opts));
Michal Vaskocde73ac2019-11-14 16:10:27 +01001442
Michal Vaskob1b5c262020-03-05 14:29:47 +01001443 /* set default for containers */
aPiecekc5f36a72021-05-18 14:12:31 +02001444 if (node->schema && (node->schema->nodetype == LYS_CONTAINER) && !(node->schema->flags & LYS_PRESENCE)) {
Radek Krejcia1c1e542020-09-29 16:06:52 +02001445 LY_LIST_FOR(lyd_child(node), next) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001446 if (!(next->flags & LYD_DEFAULT)) {
1447 break;
1448 }
Michal Vaskoa3881362020-01-21 15:57:35 +01001449 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001450 if (!next) {
1451 node->flags |= LYD_DEFAULT;
1452 }
Michal Vasko9b368d32020-02-14 13:53:31 +01001453 }
1454 }
1455
1456 return LY_SUCCESS;
1457}
1458
Radek Krejci7931b192020-06-25 17:05:03 +02001459/**
Michal Vaskobb844672020-07-03 11:06:12 +02001460 * @brief Validate the whole data subtree.
1461 *
1462 * @param[in] root Subtree root.
Michal Vaskoe0665742021-02-11 11:08:44 +01001463 * @param[in,out] node_when Set for nodes with when conditions.
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001464 * @param[in,out] node_exts Set for nodes and extension instances with validation plugin callback.
Michal Vasko32711382020-12-03 14:14:31 +01001465 * @param[in,out] node_types Set for unres node types.
1466 * @param[in,out] meta_types Set for unres metadata types.
Michal Vasko29adfbe2020-12-08 17:12:03 +01001467 * @param[in] impl_opts Implicit options, see @ref implicitoptions.
Michal Vasko8104fd42020-07-13 11:09:51 +02001468 * @param[in,out] diff Validation diff.
Michal Vaskobb844672020-07-03 11:06:12 +02001469 * @return LY_ERR value.
Radek Krejci7931b192020-06-25 17:05:03 +02001470 */
Michal Vaskob1b5c262020-03-05 14:29:47 +01001471static LY_ERR
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001472lyd_validate_subtree(struct lyd_node *root, struct ly_set *node_when, struct ly_set *node_exts, struct ly_set *node_types,
Michal Vaskoe0665742021-02-11 11:08:44 +01001473 struct ly_set *meta_types, uint32_t impl_opts, struct lyd_node **diff)
Michal Vaskofea12c62020-03-30 11:00:15 +02001474{
1475 const struct lyd_meta *meta;
Michal Vasko56daf732020-08-10 10:57:18 +02001476 struct lyd_node *node;
Michal Vaskofea12c62020-03-30 11:00:15 +02001477
Michal Vasko56daf732020-08-10 10:57:18 +02001478 LYD_TREE_DFS_BEGIN(root, node) {
Michal Vasko5900da42021-08-04 11:02:43 +02001479 if (!node->schema) {
aPiecek18a844e2021-08-10 11:06:24 +02001480 goto next_node;
Michal Vasko5900da42021-08-04 11:02:43 +02001481 }
1482
Michal Vasko0275cf62020-11-05 17:40:30 +01001483 LY_LIST_FOR(node->meta, meta) {
Radek Krejci1b2eef82021-02-17 11:17:27 +01001484 if ((*(const struct lysc_type **)meta->annotation->substmts[ANNOTATION_SUBSTMT_TYPE].storage)->plugin->validate) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001485 /* metadata type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001486 LY_CHECK_RET(ly_set_add(meta_types, (void *)meta, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001487 }
Michal Vasko0275cf62020-11-05 17:40:30 +01001488 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001489
Michal Vasko0275cf62020-11-05 17:40:30 +01001490 if ((node->schema->nodetype & LYD_NODE_TERM) && ((struct lysc_node_leaf *)node->schema)->type->plugin->validate) {
1491 /* node type resolution */
Michal Vasko32711382020-12-03 14:14:31 +01001492 LY_CHECK_RET(ly_set_add(node_types, (void *)node, 1, NULL));
Michal Vasko0275cf62020-11-05 17:40:30 +01001493 } else if (node->schema->nodetype & LYD_NODE_INNER) {
1494 /* new node validation, autodelete */
Michal Vaskoe0665742021-02-11 11:08:44 +01001495 LY_CHECK_RET(lyd_validate_new(lyd_node_child_p(node), node->schema, NULL, diff));
Michal Vaskofea12c62020-03-30 11:00:15 +02001496
Michal Vasko0275cf62020-11-05 17:40:30 +01001497 /* add nested defaults */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001498 LY_CHECK_RET(lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, NULL, NULL, NULL, impl_opts, diff));
Michal Vasko0275cf62020-11-05 17:40:30 +01001499 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001500
Michal Vaskof4d67ea2021-03-31 13:53:21 +02001501 if (lysc_has_when(node->schema)) {
Michal Vasko0275cf62020-11-05 17:40:30 +01001502 /* when evaluation */
Michal Vasko32711382020-12-03 14:14:31 +01001503 LY_CHECK_RET(ly_set_add(node_when, (void *)node, 1, NULL));
Michal Vaskofea12c62020-03-30 11:00:15 +02001504 }
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001505 LY_CHECK_RET(lysc_node_ext_tovalidate(node_exts, node));
Michal Vaskofea12c62020-03-30 11:00:15 +02001506
aPiecek18a844e2021-08-10 11:06:24 +02001507next_node:
Michal Vasko56daf732020-08-10 10:57:18 +02001508 LYD_TREE_DFS_END(root, node);
Michal Vaskofea12c62020-03-30 11:00:15 +02001509 }
1510
1511 return LY_SUCCESS;
1512}
1513
Michal Vaskoe0665742021-02-11 11:08:44 +01001514LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001515lyd_validate(struct lyd_node **tree, const struct lys_module *module, const struct ly_ctx *ctx, uint32_t val_opts,
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001516 ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_exts_p,
1517 struct ly_set *node_types_p, struct ly_set *meta_types_p, struct lyd_node **diff)
Michal Vaskof03ed032020-03-04 13:31:44 +01001518{
1519 LY_ERR ret = LY_SUCCESS;
Michal Vasko73e47212020-12-03 14:20:16 +01001520 struct lyd_node *first, *next, **first2, *iter;
Michal Vaskob1b5c262020-03-05 14:29:47 +01001521 const struct lys_module *mod;
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001522 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, node_exts = {0};
Michal Vaskob1b5c262020-03-05 14:29:47 +01001523 uint32_t i = 0;
Michal Vaskof03ed032020-03-04 13:31:44 +01001524
Michal Vaskoe0665742021-02-11 11:08:44 +01001525 assert(tree && ctx);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001526 assert((node_when_p && node_exts_p && node_types_p && meta_types_p) ||
1527 (!node_when_p && !node_exts_p && !node_types_p && !meta_types_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001528
1529 if (!node_when_p) {
1530 node_when_p = &node_when;
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001531 node_exts_p = &node_exts;
Michal Vaskoe0665742021-02-11 11:08:44 +01001532 node_types_p = &node_types;
1533 meta_types_p = &meta_types;
Michal Vasko8104fd42020-07-13 11:09:51 +02001534 }
Michal Vaskof03ed032020-03-04 13:31:44 +01001535
Michal Vaskob1b5c262020-03-05 14:29:47 +01001536 next = *tree;
1537 while (1) {
Radek Krejci7931b192020-06-25 17:05:03 +02001538 if (val_opts & LYD_VALIDATE_PRESENT) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001539 mod = lyd_data_next_module(&next, &first);
1540 } else {
Michal Vasko26e80012020-07-08 10:55:46 +02001541 mod = lyd_mod_next_module(next, module, ctx, &i, &first);
Michal Vaskof03ed032020-03-04 13:31:44 +01001542 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001543 if (!mod) {
1544 break;
1545 }
Michal Vasko7c4cf1e2020-06-22 10:04:30 +02001546 if (!first || (first == *tree)) {
Michal Vaskob1b5c262020-03-05 14:29:47 +01001547 /* make sure first2 changes are carried to tree */
1548 first2 = tree;
1549 } else {
1550 first2 = &first;
1551 }
1552
1553 /* validate new top-level nodes of this module, autodelete */
Michal Vasko8104fd42020-07-13 11:09:51 +02001554 ret = lyd_validate_new(first2, NULL, mod, diff);
1555 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001556
Radek Krejci7be7b9f2021-02-24 11:46:27 +01001557 /* add all top-level defaults for this module, if going to validate subtree, do not add into unres sets
1558 * (lyd_validate_subtree() adds all the nodes in that case) */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001559 ret = lyd_new_implicit_r(NULL, first2, NULL, mod, validate_subtree ? NULL : node_when_p, validate_subtree ? NULL : node_exts_p,
Michal Vaskoc43c8ab2021-03-05 13:32:44 +01001560 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 +02001561 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001562
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001563 /* our first module node pointer may no longer be the first */
Michal Vasko598063b2021-07-19 11:39:05 +02001564 first = *first2;
1565 lyd_first_module_sibling(&first, mod);
1566 if (!first || (first == *tree)) {
1567 first2 = tree;
1568 } else {
1569 first2 = &first;
Michal Vaskod3bb12f2020-12-04 14:33:09 +01001570 }
1571
Michal Vaskoe0665742021-02-11 11:08:44 +01001572 if (validate_subtree) {
1573 /* process nested nodes */
1574 LY_LIST_FOR(*first2, iter) {
Michal Vasko0e72b7a2021-07-16 14:53:27 +02001575 if (lyd_owner_module(iter) != mod) {
1576 break;
1577 }
1578
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001579 ret = lyd_validate_subtree(iter, node_when_p, node_exts_p, node_types_p, meta_types_p,
Michal Vaskoe0665742021-02-11 11:08:44 +01001580 (val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, diff);
1581 LY_CHECK_GOTO(ret, cleanup);
1582 }
Michal Vaskob1b5c262020-03-05 14:29:47 +01001583 }
1584
1585 /* finish incompletely validated terminal values/attributes and when conditions */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001586 ret = lyd_validate_unres(first2, mod, node_when_p, node_exts_p, node_types_p, meta_types_p, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001587 LY_CHECK_GOTO(ret, cleanup);
1588
1589 /* perform final validation that assumes the data tree is final */
Michal Vaskobd4db892020-11-23 16:58:20 +01001590 ret = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0);
Michal Vasko8104fd42020-07-13 11:09:51 +02001591 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskof03ed032020-03-04 13:31:44 +01001592 }
1593
Michal Vaskof03ed032020-03-04 13:31:44 +01001594cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001595 ly_set_erase(&node_when, NULL);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001596 ly_set_erase(&node_exts, NULL);
Michal Vasko32711382020-12-03 14:14:31 +01001597 ly_set_erase(&node_types, NULL);
1598 ly_set_erase(&meta_types, NULL);
Michal Vaskof03ed032020-03-04 13:31:44 +01001599 return ret;
1600}
Michal Vaskob1b5c262020-03-05 14:29:47 +01001601
1602API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001603lyd_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 +01001604{
Michal Vaskoe0665742021-02-11 11:08:44 +01001605 LY_CHECK_ARG_RET(NULL, tree, *tree || ctx, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001606 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001607 if (!ctx) {
1608 ctx = LYD_CTX(*tree);
1609 }
1610 if (diff) {
1611 *diff = NULL;
1612 }
1613
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001614 return lyd_validate(tree, NULL, ctx, val_opts, 1, NULL, NULL, NULL, NULL, diff);
Michal Vaskob1b5c262020-03-05 14:29:47 +01001615}
1616
1617API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001618lyd_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 +01001619{
Michal Vaskoe0665742021-02-11 11:08:44 +01001620 LY_CHECK_ARG_RET(NULL, tree, *tree || module, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001621 LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module ? module->ctx : NULL, LY_EINVAL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001622 if (diff) {
1623 *diff = NULL;
1624 }
1625
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001626 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 +01001627}
Michal Vaskofea12c62020-03-30 11:00:15 +02001628
Michal Vaskobb844672020-07-03 11:06:12 +02001629/**
1630 * @brief Find nodes for merging an operation into data tree for validation.
1631 *
1632 * @param[in] op_tree Full operation data tree.
1633 * @param[in] op_node Operation node itself.
1634 * @param[in] tree Data tree to be merged into.
1635 * @param[out] op_subtree Operation subtree to merge.
Michal Vasko2f03d222020-12-09 18:15:51 +01001636 * @param[out] tree_sibling Data tree sibling to merge next to, is set if @p tree_parent is NULL.
1637 * @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 +02001638 */
Michal Vaskocb7526d2020-03-30 15:08:26 +02001639static void
Michal Vaskobb844672020-07-03 11:06:12 +02001640lyd_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 +01001641 struct lyd_node **op_subtree, struct lyd_node **tree_sibling, struct lyd_node **tree_parent)
Michal Vaskofea12c62020-03-30 11:00:15 +02001642{
Michal Vaskocb7526d2020-03-30 15:08:26 +02001643 const struct lyd_node *tree_iter, *op_iter;
1644 struct lyd_node *match;
Michal Vaskofea12c62020-03-30 11:00:15 +02001645 uint32_t i, cur_depth, op_depth;
Michal Vaskofea12c62020-03-30 11:00:15 +02001646
Michal Vasko2f03d222020-12-09 18:15:51 +01001647 *op_subtree = NULL;
1648 *tree_sibling = NULL;
1649 *tree_parent = NULL;
1650
Michal Vaskocb7526d2020-03-30 15:08:26 +02001651 /* learn op depth (top-level being depth 0) */
Michal Vaskofea12c62020-03-30 11:00:15 +02001652 op_depth = 0;
Michal Vasko9e685082021-01-29 14:49:09 +01001653 for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001654 ++op_depth;
1655 }
1656
1657 /* find where to merge op */
1658 tree_iter = tree;
1659 cur_depth = op_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001660 while (cur_depth && tree_iter) {
Michal Vaskofea12c62020-03-30 11:00:15 +02001661 /* find op iter in tree */
1662 lyd_find_sibling_first(tree_iter, op_iter, &match);
1663 if (!match) {
1664 break;
1665 }
1666
1667 /* move tree_iter */
Radek Krejcia1c1e542020-09-29 16:06:52 +02001668 tree_iter = lyd_child(match);
Michal Vaskofea12c62020-03-30 11:00:15 +02001669
1670 /* move depth */
1671 --cur_depth;
Michal Vasko2f03d222020-12-09 18:15:51 +01001672
1673 /* find next op parent */
1674 op_iter = op_node;
1675 for (i = 0; i < cur_depth; ++i) {
Michal Vasko9e685082021-01-29 14:49:09 +01001676 op_iter = lyd_parent(op_iter);
Michal Vasko2f03d222020-12-09 18:15:51 +01001677 }
Michal Vaskofea12c62020-03-30 11:00:15 +02001678 }
1679
Michal Vasko2f03d222020-12-09 18:15:51 +01001680 assert(op_iter);
Michal Vaskobb844672020-07-03 11:06:12 +02001681 *op_subtree = (struct lyd_node *)op_iter;
Michal Vasko2f03d222020-12-09 18:15:51 +01001682 if (!tree || tree_iter) {
1683 /* there is no tree whatsoever or this is the last found sibling */
1684 *tree_sibling = (struct lyd_node *)tree_iter;
1685 } else {
1686 /* matching parent was found but it has no children to insert next to */
1687 assert(match);
1688 *tree_parent = match;
1689 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001690}
1691
Michal Vaskoe0665742021-02-11 11:08:44 +01001692/**
1693 * @brief Validate an RPC/action request, reply, or notification.
1694 *
1695 * @param[in] op_tree Full operation data tree.
1696 * @param[in] op_node Operation node itself.
1697 * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
1698 * @param[in] int_opts Internal parser options.
1699 * @param[in] validate_subtree Whether subtree was already validated (as part of data parsing) or not (separate validation).
1700 * @param[in] node_when_p Set of nodes with when conditions, if NULL a local set is used.
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001701 * @param[in] node_exts Set of nodes with extension instances with validation plugin callback, if NULL a local set is used.
Michal Vaskoe0665742021-02-11 11:08:44 +01001702 * @param[in] node_types_p Set of unres node types, if NULL a local set is used.
1703 * @param[in] meta_types_p Set of unres metadata types, if NULL a local set is used.
1704 * @param[out] diff Optional diff with any changes made by the validation.
1705 * @return LY_SUCCESS on success.
1706 * @return LY_ERR error on error.
1707 */
1708static LY_ERR
1709_lyd_validate_op(struct lyd_node *op_tree, struct lyd_node *op_node, const struct lyd_node *dep_tree,
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001710 uint32_t int_opts, ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_exts_p,
1711 struct ly_set *node_types_p, struct ly_set *meta_types_p, struct lyd_node **diff)
Michal Vaskocb7526d2020-03-30 15:08:26 +02001712{
Michal Vaskoe0665742021-02-11 11:08:44 +01001713 LY_ERR rc = LY_SUCCESS;
1714 struct lyd_node *tree_sibling, *tree_parent, *op_subtree, *op_parent, *child;
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001715 struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, node_exts = {0};
Michal Vaskocb7526d2020-03-30 15:08:26 +02001716
Michal Vaskoe0665742021-02-11 11:08:44 +01001717 assert(op_tree && op_node);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001718 assert((node_when_p && node_exts_p && node_types_p && meta_types_p) ||
1719 (!node_when_p && !node_exts_p && !node_types_p && !meta_types_p));
Michal Vaskoe0665742021-02-11 11:08:44 +01001720
1721 if (!node_when_p) {
1722 node_when_p = &node_when;
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001723 node_exts_p = &node_exts;
Michal Vaskoe0665742021-02-11 11:08:44 +01001724 node_types_p = &node_types;
1725 meta_types_p = &meta_types;
1726 }
1727
1728 /* merge op_tree into dep_tree */
1729 lyd_val_op_merge_find(op_tree, op_node, dep_tree, &op_subtree, &tree_sibling, &tree_parent);
1730 op_parent = lyd_parent(op_subtree);
1731 lyd_unlink_tree(op_subtree);
Michal Vasko6ee6f432021-07-16 09:49:14 +02001732 lyd_insert_node(tree_parent, &tree_sibling, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001733 if (!dep_tree) {
1734 dep_tree = tree_sibling;
1735 }
1736
1737 LOG_LOCSET(NULL, op_node, NULL, NULL);
1738
1739 if (int_opts & LYD_INTOPT_REPLY) {
1740 /* add output children defaults */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001741 rc = lyd_new_implicit_r(op_node, lyd_node_child_p(op_node), NULL, NULL, node_when_p, node_exts_p, node_types_p,
Michal Vaskoe0665742021-02-11 11:08:44 +01001742 LYD_IMPLICIT_OUTPUT, diff);
1743 LY_CHECK_GOTO(rc, cleanup);
1744
1745 if (validate_subtree) {
1746 /* skip validating the operation itself, go to children directly */
1747 LY_LIST_FOR(lyd_child(op_node), child) {
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001748 rc = lyd_validate_subtree(child, node_when_p, node_exts_p, node_types_p, meta_types_p, 0, diff);
1749 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001750 }
1751 }
1752 } else {
1753 if (validate_subtree) {
1754 /* prevalidate whole operation subtree */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001755 rc = lyd_validate_subtree(op_node, node_when_p, node_exts_p, node_types_p, meta_types_p, 0, diff);
1756 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001757 }
1758 }
1759
1760 /* finish incompletely validated terminal values/attributes and when conditions on the full tree */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001761 LY_CHECK_GOTO(rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL,
1762 node_when_p, node_exts_p, node_types_p, meta_types_p, diff), cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001763
1764 /* perform final validation of the operation/notification */
1765 lyd_validate_obsolete(op_node);
1766 LY_CHECK_GOTO(rc = lyd_validate_must(op_node, int_opts), cleanup);
1767
1768 /* final validation of all the descendants */
1769 LY_CHECK_GOTO(rc = lyd_validate_final_r(lyd_child(op_node), op_node, op_node->schema, NULL, 0, int_opts), cleanup);
1770
1771cleanup:
1772 LOG_LOCBACK(0, 1, 0, 0);
1773 /* restore operation tree */
1774 lyd_unlink_tree(op_subtree);
1775 if (op_parent) {
Michal Vasko6ee6f432021-07-16 09:49:14 +02001776 lyd_insert_node(op_parent, NULL, op_subtree, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001777 }
1778
1779 ly_set_erase(&node_when, NULL);
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001780 ly_set_erase(&node_exts, NULL);
Michal Vaskoe0665742021-02-11 11:08:44 +01001781 ly_set_erase(&node_types, NULL);
1782 ly_set_erase(&meta_types, NULL);
1783 return rc;
1784}
1785
1786API LY_ERR
1787lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type, struct lyd_node **diff)
1788{
1789 struct lyd_node *op_node;
1790 uint32_t int_opts;
1791
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001792 LY_CHECK_ARG_RET(NULL, op_tree, !op_tree->parent, !dep_tree || !dep_tree->parent, (data_type == LYD_TYPE_RPC_YANG) ||
1793 (data_type == LYD_TYPE_NOTIF_YANG) || (data_type == LYD_TYPE_REPLY_YANG), LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +01001794 LY_CHECK_CTX_EQUAL_RET(LYD_CTX(op_tree), dep_tree ? LYD_CTX(dep_tree) : NULL, LY_EINVAL);
Michal Vasko8104fd42020-07-13 11:09:51 +02001795 if (diff) {
1796 *diff = NULL;
1797 }
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001798 if (data_type == LYD_TYPE_RPC_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001799 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001800 } else if (data_type == LYD_TYPE_NOTIF_YANG) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001801 int_opts = LYD_INTOPT_NOTIF;
1802 } else {
1803 int_opts = LYD_INTOPT_REPLY;
1804 }
Michal Vaskocb7526d2020-03-30 15:08:26 +02001805
1806 /* find the operation/notification */
Michal Vasko56daf732020-08-10 10:57:18 +02001807 LYD_TREE_DFS_BEGIN(op_tree, op_node) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001808 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) &&
1809 (op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskocb7526d2020-03-30 15:08:26 +02001810 break;
Michal Vaskoe0665742021-02-11 11:08:44 +01001811 } else if ((int_opts & LYD_INTOPT_NOTIF) && (op_node->schema->nodetype == LYS_NOTIF)) {
Michal Vaskocb7526d2020-03-30 15:08:26 +02001812 break;
1813 }
Michal Vasko56daf732020-08-10 10:57:18 +02001814 LYD_TREE_DFS_END(op_tree, op_node);
Michal Vaskocb7526d2020-03-30 15:08:26 +02001815 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001816 if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) {
Radek Krejci7931b192020-06-25 17:05:03 +02001817 if (!(op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001818 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No RPC/action to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02001819 return LY_EINVAL;
1820 }
1821 } else {
Radek Krejci7931b192020-06-25 17:05:03 +02001822 if (op_node->schema->nodetype != LYS_NOTIF) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001823 LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No notification to validate found.");
Michal Vaskocb7526d2020-03-30 15:08:26 +02001824 return LY_EINVAL;
1825 }
1826 }
1827
Michal Vaskoe0665742021-02-11 11:08:44 +01001828 /* validate */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001829 return _lyd_validate_op(op_tree, op_node, dep_tree, int_opts, 1, NULL, NULL, NULL, NULL, diff);
Michal Vaskofea12c62020-03-30 11:00:15 +02001830}