Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1 | /** |
| 2 | * @file validation.c |
| 3 | * @author Michal Vasko <mvasko@cesnet.cz> |
| 4 | * @brief Validation |
| 5 | * |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 6 | * Copyright (c) 2019 - 2023 CESNET, z.s.p.o. |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 7 | * |
| 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 Hopps | 32874e1 | 2021-05-01 09:43:54 -0400 | [diff] [blame] | 14 | #define _GNU_SOURCE /* asprintf, strdup */ |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 15 | |
Michal Vasko | fbed4ea | 2020-07-08 10:43:30 +0200 | [diff] [blame] | 16 | #include "validation.h" |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 17 | |
| 18 | #include <assert.h> |
Radek Krejci | 7711410 | 2021-03-10 15:21:57 +0100 | [diff] [blame] | 19 | #include <limits.h> |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 20 | #include <stdint.h> |
Michal Vasko | 52927e2 | 2020-03-16 17:26:14 +0100 | [diff] [blame] | 21 | #include <stdio.h> |
| 22 | #include <stdlib.h> |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 23 | #include <string.h> |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 24 | |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 25 | #include "compat.h" |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 26 | #include "diff.h" |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 27 | #include "hash_table.h" |
| 28 | #include "log.h" |
Michal Vasko | 8f702ee | 2024-02-20 15:44:24 +0100 | [diff] [blame] | 29 | #include "ly_common.h" |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 30 | #include "parser_data.h" |
Radek Krejci | 7711410 | 2021-03-10 15:21:57 +0100 | [diff] [blame] | 31 | #include "parser_internal.h" |
Radek Krejci | 1b2eef8 | 2021-02-17 11:17:27 +0100 | [diff] [blame] | 32 | #include "plugins_exts.h" |
Radek Krejci | f1ca0ac | 2021-04-12 16:00:06 +0200 | [diff] [blame] | 33 | #include "plugins_exts/metadata.h" |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 34 | #include "plugins_types.h" |
| 35 | #include "set.h" |
| 36 | #include "tree.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 37 | #include "tree_data.h" |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 38 | #include "tree_data_internal.h" |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 39 | #include "tree_schema.h" |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 40 | #include "tree_schema_internal.h" |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 41 | #include "xpath.h" |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 42 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 43 | /** |
| 44 | * @brief Check validation error taking into account multi-error validation. |
| 45 | * |
| 46 | * @param[in] r Local return value. |
| 47 | * @param[in] err_cmd Command to perform on any error. |
| 48 | * @param[in] val_opts Validation options. |
| 49 | * @param[in] label Label to go to on fatal error. |
| 50 | */ |
| 51 | #define LY_VAL_ERR_GOTO(r, err_cmd, val_opts, label) \ |
| 52 | if (r) { \ |
| 53 | err_cmd; \ |
| 54 | if ((r != LY_EVALID) || !(val_opts & LYD_VALIDATE_MULTI_ERROR)) { \ |
| 55 | goto label; \ |
| 56 | } \ |
| 57 | } |
| 58 | |
Michal Vasko | a6669ba | 2020-08-06 16:14:26 +0200 | [diff] [blame] | 59 | LY_ERR |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 60 | lyd_val_diff_add(const struct lyd_node *node, enum lyd_diff_op op, struct lyd_node **diff) |
| 61 | { |
| 62 | LY_ERR ret = LY_SUCCESS; |
| 63 | struct lyd_node *new_diff = NULL; |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 64 | const struct lyd_node *prev_inst; |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 65 | char *key = NULL, *value = NULL, *position = NULL; |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 66 | size_t buflen = 0, bufused = 0; |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 67 | uint32_t pos; |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 68 | |
| 69 | assert((op == LYD_DIFF_OP_DELETE) || (op == LYD_DIFF_OP_CREATE)); |
| 70 | |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 71 | if ((op == LYD_DIFF_OP_CREATE) && lysc_is_userordered(node->schema)) { |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 72 | if (lysc_is_dup_inst_list(node->schema)) { |
| 73 | pos = lyd_list_pos(node); |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 74 | |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 75 | /* generate position meta */ |
| 76 | if (pos > 1) { |
| 77 | if (asprintf(&position, "%" PRIu32, pos - 1) == -1) { |
| 78 | LOGMEM(LYD_CTX(node)); |
| 79 | ret = LY_EMEM; |
| 80 | goto cleanup; |
| 81 | } |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 82 | } else { |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 83 | position = strdup(""); |
| 84 | LY_CHECK_ERR_GOTO(!position, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup); |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 85 | } |
| 86 | } else { |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 87 | if (node->prev->next && (node->prev->schema == node->schema)) { |
| 88 | prev_inst = node->prev; |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 89 | } else { |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 90 | /* first instance */ |
| 91 | prev_inst = NULL; |
| 92 | } |
| 93 | |
| 94 | if (node->schema->nodetype == LYS_LIST) { |
| 95 | /* generate key meta */ |
| 96 | if (prev_inst) { |
| 97 | LY_CHECK_GOTO(ret = lyd_path_list_predicate(prev_inst, &key, &buflen, &bufused, 0), cleanup); |
| 98 | } else { |
| 99 | key = strdup(""); |
| 100 | LY_CHECK_ERR_GOTO(!key, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup); |
| 101 | } |
| 102 | } else { |
| 103 | /* generate value meta */ |
| 104 | if (prev_inst) { |
Radek Krejci | 6d5ba0c | 2021-04-26 07:49:59 +0200 | [diff] [blame] | 105 | value = strdup(lyd_get_value(prev_inst)); |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 106 | LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup); |
| 107 | } else { |
| 108 | value = strdup(""); |
| 109 | LY_CHECK_ERR_GOTO(!value, LOGMEM(LYD_CTX(node)); ret = LY_EMEM, cleanup); |
| 110 | } |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 111 | } |
| 112 | } |
| 113 | } |
| 114 | |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 115 | /* create new diff tree */ |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 116 | LY_CHECK_GOTO(ret = lyd_diff_add(node, op, NULL, NULL, key, value, position, NULL, NULL, &new_diff), cleanup); |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 117 | |
| 118 | /* merge into existing diff */ |
Michal Vasko | c0e58e8 | 2020-11-11 19:04:33 +0100 | [diff] [blame] | 119 | ret = lyd_diff_merge_all(diff, new_diff, 0); |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 120 | |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 121 | cleanup: |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 122 | lyd_free_tree(new_diff); |
Michal Vasko | 81bc551 | 2020-11-13 18:05:18 +0100 | [diff] [blame] | 123 | free(key); |
| 124 | free(value); |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 125 | free(position); |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 126 | return ret; |
| 127 | } |
| 128 | |
| 129 | /** |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 130 | * @brief Evaluate all relevant "when" conditions of a node. |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 131 | * |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 132 | * @param[in] tree Data tree. |
| 133 | * @param[in] node Node whose relevant when conditions will be evaluated. |
| 134 | * @param[in] schema Schema node of @p node. It may not be possible to use directly if @p node is opaque. |
Michal Vasko | 976ec43 | 2021-12-06 15:42:22 +0100 | [diff] [blame] | 135 | * @param[in] xpath_options Additional XPath options to use. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 136 | * @param[out] disabled First when that evaluated false, if any. |
| 137 | * @return LY_SUCCESS on success. |
| 138 | * @return LY_EINCOMPLETE if a referenced node does not have its when evaluated. |
| 139 | * @return LY_ERR value on error. |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 140 | */ |
| 141 | static LY_ERR |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 142 | lyd_validate_node_when(const struct lyd_node *tree, const struct lyd_node *node, const struct lysc_node *schema, |
Michal Vasko | 976ec43 | 2021-12-06 15:42:22 +0100 | [diff] [blame] | 143 | uint32_t xpath_options, const struct lysc_when **disabled) |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 144 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 145 | LY_ERR r; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 146 | const struct lyd_node *ctx_node; |
| 147 | struct lyxp_set xp_set; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 148 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 149 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 150 | assert(!node->schema || (node->schema == schema)); |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 151 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 152 | *disabled = NULL; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 153 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 154 | do { |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 155 | const struct lysc_when *when; |
| 156 | struct lysc_when **when_list = lysc_node_when(schema); |
Michal Vasko | 26bbb27 | 2022-08-02 14:54:33 +0200 | [diff] [blame] | 157 | |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 158 | LY_ARRAY_FOR(when_list, u) { |
| 159 | when = when_list[u]; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 160 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 161 | /* get context node */ |
| 162 | if (when->context == schema) { |
| 163 | ctx_node = node; |
| 164 | } else { |
| 165 | assert((!when->context && !node->parent) || (when->context == node->parent->schema)); |
Michal Vasko | 9e68508 | 2021-01-29 14:49:09 +0100 | [diff] [blame] | 166 | ctx_node = lyd_parent(node); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 167 | } |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 168 | |
| 169 | /* evaluate when */ |
| 170 | memset(&xp_set, 0, sizeof xp_set); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 171 | r = lyxp_eval(LYD_CTX(node), when->cond, schema->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes, |
Michal Vasko | a3e92bc | 2022-07-29 14:56:23 +0200 | [diff] [blame] | 172 | ctx_node, ctx_node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 173 | lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN); |
| 174 | |
| 175 | /* return error or LY_EINCOMPLETE for dependant unresolved when */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 176 | LY_CHECK_RET(r); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 177 | |
| 178 | if (!xp_set.val.bln) { |
| 179 | /* false when */ |
| 180 | *disabled = when; |
| 181 | return LY_SUCCESS; |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 182 | } |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 183 | } |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 184 | |
| 185 | schema = schema->parent; |
| 186 | } while (schema && (schema->nodetype & (LYS_CASE | LYS_CHOICE))); |
| 187 | |
| 188 | return LY_SUCCESS; |
| 189 | } |
| 190 | |
| 191 | /** |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 192 | * @brief Properly delete a node as part of auto-delete validation tasks. |
| 193 | * |
| 194 | * @param[in,out] first First sibling, is updated if needed. |
| 195 | * @param[in] del Node instance to delete. |
| 196 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
Michal Vasko | a7e92ec | 2023-11-21 09:18:39 +0100 | [diff] [blame] | 197 | * @param[in] np_cont_diff Whether to put NP container into diff or only its children. |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 198 | * @param[in,out] node Optional current iteration node, update it if it is deleted. |
| 199 | * @param[in,out] node_when Optional set with nodes with "when" conditions, may be removed from. |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 200 | * @param[in,out] node_types Optional set with unresolved type nodes, may be removed from. |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 201 | * @param[in,out] diff Validation diff. |
| 202 | * @return 1 if @p node auto-deleted and updated to its next sibling. |
| 203 | * @return 0 if @p node was not auto-deleted. |
| 204 | */ |
| 205 | static ly_bool |
| 206 | lyd_validate_autodel_node_del(struct lyd_node **first, struct lyd_node *del, const struct lys_module *mod, |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 207 | int np_cont_diff, struct lyd_node **node, struct ly_set *node_when, struct ly_set *node_types, struct lyd_node **diff) |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 208 | { |
| 209 | struct lyd_node *iter; |
| 210 | ly_bool node_autodel = 0; |
| 211 | uint32_t idx; |
| 212 | |
| 213 | /* update pointers */ |
| 214 | lyd_del_move_root(first, del, mod); |
| 215 | if (node && (del == *node)) { |
| 216 | *node = (*node)->next; |
| 217 | node_autodel = 1; |
| 218 | } |
| 219 | |
| 220 | if (diff) { |
| 221 | /* add into diff */ |
Michal Vasko | a7e92ec | 2023-11-21 09:18:39 +0100 | [diff] [blame] | 222 | if (!np_cont_diff && (del->schema->nodetype == LYS_CONTAINER) && !(del->schema->flags & LYS_PRESENCE)) { |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 223 | /* we do not want to track NP container changes, but remember any removed children */ |
| 224 | LY_LIST_FOR(lyd_child(del), iter) { |
| 225 | lyd_val_diff_add(iter, LYD_DIFF_OP_DELETE, diff); |
| 226 | } |
| 227 | } else { |
| 228 | lyd_val_diff_add(del, LYD_DIFF_OP_DELETE, diff); |
| 229 | } |
| 230 | } |
| 231 | |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 232 | if (node_when && node_when->count) { |
| 233 | /* remove nested from node_when set */ |
| 234 | LYD_TREE_DFS_BEGIN(del, iter) { |
| 235 | if ((del != iter) && ly_set_contains(node_when, iter, &idx)) { |
| 236 | ly_set_rm_index(node_when, idx, NULL); |
| 237 | } |
| 238 | LYD_TREE_DFS_END(del, iter); |
| 239 | } |
| 240 | } |
| 241 | |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 242 | if (node_types && node_types->count) { |
| 243 | /* remove from node_types set */ |
| 244 | LYD_TREE_DFS_BEGIN(del, iter) { |
| 245 | if (ly_set_contains(node_types, iter, &idx)) { |
| 246 | ly_set_rm_index(node_types, idx, NULL); |
| 247 | } |
| 248 | LYD_TREE_DFS_END(del, iter); |
| 249 | } |
| 250 | } |
| 251 | |
| 252 | /* free */ |
| 253 | lyd_free_tree(del); |
| 254 | |
| 255 | return node_autodel; |
| 256 | } |
| 257 | |
| 258 | /** |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 259 | * @brief Evaluate when conditions of collected unres nodes. |
| 260 | * |
| 261 | * @param[in,out] tree Data tree, is updated if some nodes are autodeleted. |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 262 | * @param[in] mod Module of the @p tree to take into consideration when deleting @p tree and moving it. |
| 263 | * If set, it is expected @p tree should point to the first node of @p mod. Otherwise it will simply be |
| 264 | * the first top-level sibling. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 265 | * @param[in] node_when Set with nodes with "when" conditions. |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 266 | * @param[in] val_opts Validation options. |
Michal Vasko | 976ec43 | 2021-12-06 15:42:22 +0100 | [diff] [blame] | 267 | * @param[in] xpath_options Additional XPath options to use. |
Michal Vasko | 27d2b1b | 2021-07-19 15:20:02 +0200 | [diff] [blame] | 268 | * @param[in,out] node_types Set with nodes with unresolved types, remove any with false "when" parents. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 269 | * @param[in,out] diff Validation diff. |
| 270 | * @return LY_SUCCESS on success. |
| 271 | * @return LY_ERR value on error. |
| 272 | */ |
| 273 | static LY_ERR |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 274 | lyd_validate_unres_when(struct lyd_node **tree, const struct lys_module *mod, struct ly_set *node_when, uint32_t val_opts, |
Michal Vasko | 976ec43 | 2021-12-06 15:42:22 +0100 | [diff] [blame] | 275 | uint32_t xpath_options, struct ly_set *node_types, struct lyd_node **diff) |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 276 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 277 | LY_ERR rc = LY_SUCCESS, r; |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 278 | uint32_t i, count; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 279 | const struct lysc_when *disabled; |
Michal Vasko | 64eb14a | 2023-11-20 13:49:47 +0100 | [diff] [blame] | 280 | struct lyd_node *node = NULL; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 281 | |
| 282 | if (!node_when->count) { |
| 283 | return LY_SUCCESS; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 284 | } |
| 285 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 286 | i = node_when->count; |
| 287 | do { |
| 288 | --i; |
| 289 | node = node_when->dnodes[i]; |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 290 | LOG_LOCSET(node->schema, node); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 291 | |
| 292 | /* evaluate all when expressions that affect this node's existence */ |
Michal Vasko | 6f0c5c7 | 2022-08-05 15:28:14 +0200 | [diff] [blame] | 293 | r = lyd_validate_node_when(*tree, node, node->schema, xpath_options, &disabled); |
| 294 | if (!r) { |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 295 | if (disabled) { |
| 296 | /* when false */ |
| 297 | if (node->flags & LYD_WHEN_TRUE) { |
| 298 | /* autodelete */ |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 299 | count = node_when->count; |
| 300 | lyd_validate_autodel_node_del(tree, node, mod, 1, NULL, node_when, node_types, diff); |
| 301 | if (count > node_when->count) { |
| 302 | /* nested nodes removed, we lost the index */ |
| 303 | ly_set_contains(node_when, node, &i); |
| 304 | } |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 305 | } else if (val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 306 | /* only a warning */ |
| 307 | LOGWRN(LYD_CTX(node), "When condition \"%s\" not satisfied.", disabled->cond->expr); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 308 | } else { |
| 309 | /* invalid data */ |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 310 | LOGVAL(LYD_CTX(node), LY_VCODE_NOWHEN, disabled->cond->expr); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 311 | r = LY_EVALID; |
| 312 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, error); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 313 | } |
| 314 | } else { |
| 315 | /* when true */ |
| 316 | node->flags |= LYD_WHEN_TRUE; |
| 317 | } |
| 318 | |
Michal Vasko | 413af59 | 2021-12-13 11:50:51 +0100 | [diff] [blame] | 319 | /* remove this node from the set keeping the order, its when was resolved */ |
| 320 | ly_set_rm_index_ordered(node_when, i, NULL); |
Michal Vasko | 6f0c5c7 | 2022-08-05 15:28:14 +0200 | [diff] [blame] | 321 | } else if (r != LY_EINCOMPLETE) { |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 322 | /* error */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 323 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, error); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 324 | } |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 325 | |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 326 | LOG_LOCBACK(1, 1); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 327 | } while (i); |
| 328 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 329 | return rc; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 330 | |
| 331 | error: |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 332 | LOG_LOCBACK(1, 1); |
Michal Vasko | 6f0c5c7 | 2022-08-05 15:28:14 +0200 | [diff] [blame] | 333 | return rc; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 334 | } |
| 335 | |
Radek Krejci | 4f2e3e5 | 2021-03-30 14:20:28 +0200 | [diff] [blame] | 336 | LY_ERR |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 337 | lyd_validate_unres(struct lyd_node **tree, const struct lys_module *mod, enum lyd_type data_type, struct ly_set *node_when, |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 338 | uint32_t when_xp_opts, struct ly_set *node_types, struct ly_set *meta_types, struct ly_set *ext_node, |
| 339 | struct ly_set *ext_val, uint32_t val_opts, struct lyd_node **diff) |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 340 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 341 | LY_ERR r, rc = LY_SUCCESS; |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 342 | uint32_t i; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 343 | |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 344 | if (ext_val && ext_val->count) { |
| 345 | /* first validate parsed extension data */ |
| 346 | i = ext_val->count; |
| 347 | do { |
| 348 | --i; |
| 349 | |
| 350 | struct lyd_ctx_ext_val *ext_v = ext_val->objs[i]; |
| 351 | |
| 352 | /* validate extension data */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 353 | r = ext_v->ext->def->plugin->validate(ext_v->ext, ext_v->sibling, *tree, data_type, val_opts, diff); |
| 354 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 355 | |
| 356 | /* remove this item from the set */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 357 | ly_set_rm_index(ext_val, i, free); |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 358 | } while (i); |
| 359 | } |
| 360 | |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 361 | if (ext_node && ext_node->count) { |
| 362 | /* validate data nodes with extension instances */ |
| 363 | i = ext_node->count; |
| 364 | do { |
| 365 | --i; |
| 366 | |
| 367 | struct lyd_ctx_ext_node *ext_n = ext_node->objs[i]; |
| 368 | |
| 369 | /* validate the node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 370 | r = ext_n->ext->def->plugin->node(ext_n->ext, ext_n->node, val_opts); |
| 371 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 372 | |
| 373 | /* remove this item from the set */ |
| 374 | ly_set_rm_index(ext_node, i, free); |
| 375 | } while (i); |
| 376 | } |
| 377 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 378 | if (node_when) { |
| 379 | /* evaluate all when conditions */ |
| 380 | uint32_t prev_count; |
Michal Vasko | 26bbb27 | 2022-08-02 14:54:33 +0200 | [diff] [blame] | 381 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 382 | do { |
| 383 | prev_count = node_when->count; |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 384 | r = lyd_validate_unres_when(tree, mod, node_when, val_opts, when_xp_opts, node_types, diff); |
| 385 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
| 386 | |
Radek Krejci | 0f96988 | 2020-08-21 16:56:47 +0200 | [diff] [blame] | 387 | /* there must have been some when conditions resolved */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 388 | } while (prev_count > node_when->count); |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 389 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 390 | /* there could have been no cyclic when dependencies, checked during compilation */ |
Michal Vasko | 0b877d5 | 2023-11-20 13:50:08 +0100 | [diff] [blame] | 391 | assert(!node_when->count || ((rc == LY_EVALID) && (val_opts & LYD_VALIDATE_MULTI_ERROR))); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 392 | } |
| 393 | |
| 394 | if (node_types && node_types->count) { |
| 395 | /* finish incompletely validated terminal values (traverse from the end for efficient set removal) */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 396 | i = node_types->count; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 397 | do { |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 398 | --i; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 399 | |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 400 | struct lyd_node_term *node = node_types->objs[i]; |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 401 | struct lysc_type *type = ((struct lysc_node_leaf *)node->schema)->type; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 402 | |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 403 | /* resolve the value of the node */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 404 | LOG_LOCSET(NULL, &node->node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 405 | r = lyd_value_validate_incomplete(LYD_CTX(node), type, &node->value, &node->node, *tree); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 406 | LOG_LOCBACK(0, 1); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 407 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 408 | |
| 409 | /* remove this node from the set */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 410 | ly_set_rm_index(node_types, i, NULL); |
| 411 | } while (i); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 412 | } |
| 413 | |
Michal Vasko | 9f96a05 | 2020-03-10 09:41:45 +0100 | [diff] [blame] | 414 | if (meta_types && meta_types->count) { |
| 415 | /* ... and metadata values */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 416 | i = meta_types->count; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 417 | do { |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 418 | --i; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 419 | |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 420 | struct lyd_meta *meta = meta_types->objs[i]; |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 421 | struct lysc_type *type; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 422 | |
Michal Vasko | 9f96a05 | 2020-03-10 09:41:45 +0100 | [diff] [blame] | 423 | /* validate and store the value of the metadata */ |
Michal Vasko | fbd037c | 2022-11-08 10:34:20 +0100 | [diff] [blame] | 424 | lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 425 | r = lyd_value_validate_incomplete(LYD_CTX(meta->parent), type, &meta->value, meta->parent, *tree); |
| 426 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 427 | |
| 428 | /* remove this attr from the set */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 429 | ly_set_rm_index(meta_types, i, NULL); |
| 430 | } while (i); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 431 | } |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 432 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 433 | cleanup: |
| 434 | return rc; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 435 | } |
| 436 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 437 | /** |
| 438 | * @brief Validate instance duplication. |
| 439 | * |
| 440 | * @param[in] first First sibling to search in. |
| 441 | * @param[in] node Data node instance to check. |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 442 | * @param[in] val_opts Validation options. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 443 | * @return LY_ERR value. |
| 444 | */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 445 | static LY_ERR |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 446 | lyd_validate_duplicates(const struct lyd_node *first, const struct lyd_node *node, uint32_t val_opts) |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 447 | { |
Michal Vasko | 04a89c2 | 2023-10-03 14:03:09 +0200 | [diff] [blame] | 448 | struct lyd_node **match_p, *match; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 449 | ly_bool fail = 0; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 450 | |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 451 | assert(node->flags & LYD_NEW); |
| 452 | |
Michal Vasko | d6c18af | 2021-02-12 12:07:31 +0100 | [diff] [blame] | 453 | /* key-less list or non-configuration leaf-list */ |
Michal Vasko | e78faec | 2021-04-08 17:24:43 +0200 | [diff] [blame] | 454 | if (lysc_is_dup_inst_list(node->schema)) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 455 | /* duplicate instances allowed */ |
| 456 | return LY_SUCCESS; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 457 | } |
| 458 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 459 | /* find exactly the same next instance using hashes if possible */ |
| 460 | if (node->parent && node->parent->children_ht) { |
Michal Vasko | 04a89c2 | 2023-10-03 14:03:09 +0200 | [diff] [blame] | 461 | lyd_find_sibling_first(first, node, &match); |
| 462 | assert(match); |
| 463 | |
| 464 | if (match != node) { |
| 465 | fail = 1; |
| 466 | } else if (!lyht_find_next(node->parent->children_ht, &node, node->hash, (void **)&match_p)) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 467 | fail = 1; |
| 468 | } |
| 469 | } else { |
Michal Vasko | d989ba0 | 2020-08-24 10:59:24 +0200 | [diff] [blame] | 470 | for ( ; first; first = first->next) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 471 | if (first == node) { |
| 472 | continue; |
| 473 | } |
| 474 | |
| 475 | if (node->schema->nodetype & (LYD_NODE_ANY | LYS_LEAF)) { |
| 476 | if (first->schema == node->schema) { |
| 477 | fail = 1; |
| 478 | break; |
| 479 | } |
Michal Vasko | 8f359bf | 2020-07-28 10:41:15 +0200 | [diff] [blame] | 480 | } else if (!lyd_compare_single(first, node, 0)) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 481 | fail = 1; |
| 482 | break; |
| 483 | } |
| 484 | } |
| 485 | } |
| 486 | |
| 487 | if (fail) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 488 | if ((node->schema->nodetype & (LYS_LIST | LYS_LEAFLIST)) && (val_opts & LYD_VALIDATE_OPERATIONAL)) { |
| 489 | /* only a warning */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 490 | LOG_LOCSET(NULL, node); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 491 | LOGWRN(node->schema->module->ctx, "Duplicate instance of \"%s\".", node->schema->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 492 | LOG_LOCBACK(0, 1); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 493 | } else { |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 494 | LOG_LOCSET(NULL, node); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 495 | LOGVAL(node->schema->module->ctx, LY_VCODE_DUP, node->schema->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 496 | LOG_LOCBACK(0, 1); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 497 | return LY_EVALID; |
| 498 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 499 | } |
| 500 | return LY_SUCCESS; |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 501 | } |
| 502 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 503 | /** |
| 504 | * @brief Validate multiple case data existence with possible autodelete. |
| 505 | * |
| 506 | * @param[in,out] first First sibling to search in, is updated if needed. |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 507 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 508 | * @param[in] choic Choice node whose cases to check. |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 509 | * @param[in,out] diff Validation diff. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 510 | * @return LY_ERR value. |
| 511 | */ |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 512 | static LY_ERR |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 513 | lyd_validate_cases(struct lyd_node **first, const struct lys_module *mod, const struct lysc_node_choice *choic, |
| 514 | struct lyd_node **diff) |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 515 | { |
| 516 | const struct lysc_node *scase, *iter, *old_case = NULL, *new_case = NULL; |
| 517 | struct lyd_node *match, *to_del; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 518 | ly_bool found; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 519 | |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 520 | LOG_LOCSET(&choic->node, NULL); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 521 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 522 | LY_LIST_FOR((struct lysc_node *)choic->cases, scase) { |
| 523 | found = 0; |
| 524 | iter = NULL; |
| 525 | match = NULL; |
| 526 | while ((match = lys_getnext_data(match, *first, &iter, scase, NULL))) { |
| 527 | if (match->flags & LYD_NEW) { |
| 528 | /* a new case data found, nothing more to look for */ |
| 529 | found = 2; |
| 530 | break; |
| 531 | } else { |
| 532 | /* and old case data found */ |
| 533 | if (found == 0) { |
| 534 | found = 1; |
| 535 | } |
| 536 | } |
| 537 | } |
| 538 | |
| 539 | if (found == 1) { |
| 540 | /* there should not be 2 old cases */ |
| 541 | if (old_case) { |
| 542 | /* old data from 2 cases */ |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 543 | LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, old_case->name, scase->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 544 | LOG_LOCBACK(1, 0); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 545 | return LY_EVALID; |
| 546 | } |
| 547 | |
| 548 | /* remember an old existing case */ |
| 549 | old_case = scase; |
| 550 | } else if (found == 2) { |
| 551 | if (new_case) { |
| 552 | /* new data from 2 cases */ |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 553 | LOGVAL(choic->module->ctx, LY_VCODE_DUPCASE, new_case->name, scase->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 554 | LOG_LOCBACK(1, 0); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 555 | return LY_EVALID; |
| 556 | } |
| 557 | |
| 558 | /* remember a new existing case */ |
| 559 | new_case = scase; |
| 560 | } |
| 561 | } |
| 562 | |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 563 | LOG_LOCBACK(1, 0); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 564 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 565 | if (old_case && new_case) { |
| 566 | /* auto-delete old case */ |
| 567 | iter = NULL; |
| 568 | match = NULL; |
| 569 | to_del = NULL; |
| 570 | while ((match = lys_getnext_data(match, *first, &iter, old_case, NULL))) { |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 571 | lyd_del_move_root(first, to_del, mod); |
| 572 | |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 573 | /* free previous node */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 574 | lyd_free_tree(to_del); |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 575 | if (diff) { |
| 576 | /* add into diff */ |
| 577 | LY_CHECK_RET(lyd_val_diff_add(match, LYD_DIFF_OP_DELETE, diff)); |
| 578 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 579 | to_del = match; |
| 580 | } |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 581 | lyd_del_move_root(first, to_del, mod); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 582 | lyd_free_tree(to_del); |
| 583 | } |
| 584 | |
| 585 | return LY_SUCCESS; |
| 586 | } |
| 587 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 588 | /** |
| 589 | * @brief Check whether a schema node can have some default values (true for NP containers as well). |
| 590 | * |
| 591 | * @param[in] schema Schema node to check. |
| 592 | * @return non-zero if yes, |
| 593 | * @return 0 otherwise. |
| 594 | */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 595 | static int |
| 596 | lyd_val_has_default(const struct lysc_node *schema) |
| 597 | { |
| 598 | switch (schema->nodetype) { |
| 599 | case LYS_LEAF: |
| 600 | if (((struct lysc_node_leaf *)schema)->dflt) { |
| 601 | return 1; |
| 602 | } |
| 603 | break; |
| 604 | case LYS_LEAFLIST: |
| 605 | if (((struct lysc_node_leaflist *)schema)->dflts) { |
| 606 | return 1; |
| 607 | } |
| 608 | break; |
| 609 | case LYS_CONTAINER: |
| 610 | if (!(schema->flags & LYS_PRESENCE)) { |
| 611 | return 1; |
| 612 | } |
| 613 | break; |
| 614 | default: |
| 615 | break; |
| 616 | } |
| 617 | |
| 618 | return 0; |
| 619 | } |
| 620 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 621 | /** |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 622 | * @brief Auto-delete leaf-list default instances to prevent validation errors. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 623 | * |
| 624 | * @param[in,out] first First sibling to search in, is updated if needed. |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 625 | * @param[in,out] node New data node instance to check, is updated if auto-deleted. |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 626 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 627 | * @param[in,out] diff Validation diff. |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 628 | * @return 1 if @p node auto-deleted and updated to its next sibling. |
| 629 | * @return 0 if @p node was not auto-deleted. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 630 | */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 631 | static ly_bool |
| 632 | lyd_validate_autodel_leaflist_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod, |
| 633 | struct lyd_node **diff) |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 634 | { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 635 | const struct lysc_node *schema; |
| 636 | struct lyd_node *iter, *next; |
| 637 | ly_bool found = 0, node_autodel = 0; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 638 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 639 | assert((*node)->flags & LYD_NEW); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 640 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 641 | schema = (*node)->schema; |
| 642 | assert(schema->nodetype == LYS_LEAFLIST); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 643 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 644 | /* check whether there is any explicit instance */ |
| 645 | LYD_LIST_FOR_INST(*first, schema, iter) { |
| 646 | if (!(iter->flags & LYD_DEFAULT)) { |
| 647 | found = 1; |
| 648 | break; |
| 649 | } |
| 650 | } |
| 651 | if (!found) { |
| 652 | /* no explicit instance, keep defaults as they are */ |
| 653 | return 0; |
| 654 | } |
| 655 | |
| 656 | LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) { |
| 657 | if (iter->flags & LYD_DEFAULT) { |
| 658 | /* default instance found, remove it */ |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 659 | if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, NULL, diff)) { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 660 | node_autodel = 1; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 661 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 662 | } |
| 663 | } |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 664 | |
| 665 | return node_autodel; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 666 | } |
| 667 | |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 668 | /** |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 669 | * @brief Auto-delete container or leaf default instances to prevent validation errors. |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 670 | * |
| 671 | * @param[in,out] first First sibling to search in, is updated if needed. |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 672 | * @param[in,out] node New data node instance to check, is updated if auto-deleted. |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 673 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 674 | * @param[in,out] diff Validation diff. |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 675 | * @return 1 if @p node auto-deleted and updated to its next sibling. |
| 676 | * @return 0 if @p node was not auto-deleted. |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 677 | */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 678 | static ly_bool |
| 679 | lyd_validate_autodel_cont_leaf_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod, |
| 680 | struct lyd_node **diff) |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 681 | { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 682 | const struct lysc_node *schema; |
| 683 | struct lyd_node *iter, *next; |
| 684 | ly_bool found = 0, node_autodel = 0; |
| 685 | |
| 686 | assert((*node)->flags & LYD_NEW); |
| 687 | |
| 688 | schema = (*node)->schema; |
| 689 | assert(schema->nodetype & (LYS_LEAF | LYS_CONTAINER)); |
| 690 | |
| 691 | /* check whether there is any explicit instance */ |
| 692 | LYD_LIST_FOR_INST(*first, schema, iter) { |
| 693 | if (!(iter->flags & LYD_DEFAULT)) { |
| 694 | found = 1; |
| 695 | break; |
| 696 | } |
| 697 | } |
| 698 | |
| 699 | if (found) { |
| 700 | /* remove all default instances */ |
| 701 | LYD_LIST_FOR_INST_SAFE(*first, schema, next, iter) { |
| 702 | if (iter->flags & LYD_DEFAULT) { |
| 703 | /* default instance, remove it */ |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 704 | if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, NULL, diff)) { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 705 | node_autodel = 1; |
| 706 | } |
| 707 | } |
| 708 | } |
| 709 | } else { |
| 710 | /* remove a single old default instance, if any */ |
| 711 | LYD_LIST_FOR_INST(*first, schema, iter) { |
| 712 | if ((iter->flags & LYD_DEFAULT) && !(iter->flags & LYD_NEW)) { |
| 713 | /* old default instance, remove it */ |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 714 | if (lyd_validate_autodel_node_del(first, iter, mod, 0, node, NULL, NULL, diff)) { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 715 | node_autodel = 1; |
| 716 | } |
| 717 | break; |
| 718 | } |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | return node_autodel; |
| 723 | } |
| 724 | |
| 725 | /** |
| 726 | * @brief Auto-delete leftover default nodes of deleted cases (that have no existing explicit data). |
| 727 | * |
| 728 | * @param[in,out] first First sibling to search in, is updated if needed. |
| 729 | * @param[in,out] node Default data node instance to check. |
| 730 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
| 731 | * @param[in,out] diff Validation diff. |
| 732 | * @return 1 if @p node auto-deleted and updated to its next sibling. |
| 733 | * @return 0 if @p node was not auto-deleted. |
| 734 | */ |
| 735 | static ly_bool |
| 736 | lyd_validate_autodel_case_dflt(struct lyd_node **first, struct lyd_node **node, const struct lys_module *mod, |
| 737 | struct lyd_node **diff) |
| 738 | { |
| 739 | const struct lysc_node *schema; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 740 | struct lysc_node_choice *choic; |
| 741 | struct lyd_node *iter = NULL; |
| 742 | const struct lysc_node *slast = NULL; |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 743 | ly_bool node_autodel = 0; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 744 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 745 | assert((*node)->flags & LYD_DEFAULT); |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 746 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 747 | schema = (*node)->schema; |
| 748 | |
| 749 | if (!schema->parent || (schema->parent->nodetype != LYS_CASE)) { |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 750 | /* the default node is not a descendant of a case */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 751 | return 0; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 752 | } |
| 753 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 754 | choic = (struct lysc_node_choice *)schema->parent->parent; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 755 | assert(choic->nodetype == LYS_CHOICE); |
| 756 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 757 | if (choic->dflt && (choic->dflt == (struct lysc_node_case *)schema->parent)) { |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 758 | /* data of a default case, keep them */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 759 | return 0; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 760 | } |
| 761 | |
| 762 | /* try to find an explicit node of the case */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 763 | while ((iter = lys_getnext_data(iter, *first, &slast, schema->parent, NULL))) { |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 764 | if (!(iter->flags & LYD_DEFAULT)) { |
| 765 | break; |
| 766 | } |
| 767 | } |
| 768 | |
| 769 | if (!iter) { |
| 770 | /* there are only default nodes of the case meaning it does not exist and neither should any default nodes |
| 771 | * of the case, remove this one default node */ |
Michal Vasko | 7a8029e | 2024-07-17 08:35:50 +0200 | [diff] [blame] | 772 | if (lyd_validate_autodel_node_del(first, *node, mod, 0, node, NULL, NULL, diff)) { |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 773 | node_autodel = 1; |
| 774 | } |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 775 | } |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 776 | |
| 777 | return node_autodel; |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 778 | } |
| 779 | |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 780 | /** |
| 781 | * @brief Validate new siblings in choices, recursively for nested choices. |
| 782 | * |
| 783 | * @param[in,out] first First sibling. |
| 784 | * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings. |
| 785 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 786 | * @param[in] val_opts Validation options. |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 787 | * @param[in,out] diff Validation diff. |
| 788 | * @return LY_ERR value. |
| 789 | */ |
| 790 | static LY_ERR |
| 791 | lyd_validate_choice_r(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod, |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 792 | uint32_t val_opts, struct lyd_node **diff) |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 793 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 794 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 795 | const struct lysc_node *snode = NULL; |
| 796 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 797 | while (*first && (snode = lys_getnext(snode, sparent, mod ? mod->compiled : NULL, LYS_GETNEXT_WITHCHOICE))) { |
| 798 | /* check case duplicites */ |
| 799 | if (snode->nodetype == LYS_CHOICE) { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 800 | r = lyd_validate_cases(first, mod, (struct lysc_node_choice *)snode, diff); |
| 801 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 802 | |
| 803 | /* check for nested choice */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 804 | r = lyd_validate_choice_r(first, snode, mod, val_opts, diff); |
| 805 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 806 | } |
| 807 | } |
| 808 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 809 | cleanup: |
| 810 | return rc; |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 811 | } |
| 812 | |
| 813 | LY_ERR |
| 814 | lyd_validate_new(struct lyd_node **first, const struct lysc_node *sparent, const struct lys_module *mod, |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 815 | uint32_t val_opts, struct lyd_node **diff) |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 816 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 817 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 818 | struct lyd_node *node; |
| 819 | const struct lysc_node *last_dflt_schema = NULL; |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 820 | |
| 821 | assert(first && (sparent || mod)); |
| 822 | |
| 823 | /* validate choices */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 824 | r = lyd_validate_choice_r(first, sparent, mod, val_opts, diff); |
| 825 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 17f7664 | 2021-08-03 17:01:30 +0200 | [diff] [blame] | 826 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 827 | node = *first; |
| 828 | while (node) { |
Michal Vasko | 6a6e308 | 2022-05-10 10:32:38 +0200 | [diff] [blame] | 829 | if (!node->schema || (mod && (lyd_owner_module(node) != mod))) { |
| 830 | /* opaque node or all top-level data from this module checked */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 831 | break; |
| 832 | } |
| 833 | |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 834 | if (!(node->flags & (LYD_NEW | LYD_DEFAULT))) { |
| 835 | /* check only new and default nodes */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 836 | node = node->next; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 837 | continue; |
| 838 | } |
| 839 | |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 840 | if (lyd_val_has_default(node->schema) && (node->schema != last_dflt_schema) && (node->flags & LYD_NEW)) { |
| 841 | /* remove old default(s) of the new node if an explicit instance exists */ |
| 842 | last_dflt_schema = node->schema; |
| 843 | if (node->schema->nodetype == LYS_LEAFLIST) { |
| 844 | if (lyd_validate_autodel_leaflist_dflt(first, &node, mod, diff)) { |
| 845 | continue; |
| 846 | } |
| 847 | } else { |
| 848 | if (lyd_validate_autodel_cont_leaf_dflt(first, &node, mod, diff)) { |
| 849 | continue; |
| 850 | } |
| 851 | } |
| 852 | } |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 853 | |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 854 | if (node->flags & LYD_NEW) { |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 855 | /* then check new node instance duplicities */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 856 | r = lyd_validate_duplicates(*first, node, val_opts); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 857 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 858 | |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 859 | /* this node is valid */ |
| 860 | node->flags &= ~LYD_NEW; |
| 861 | } |
| 862 | |
| 863 | if (node->flags & LYD_DEFAULT) { |
| 864 | /* remove leftover default nodes from a no-longer existing case */ |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 865 | if (lyd_validate_autodel_case_dflt(first, &node, mod, diff)) { |
| 866 | continue; |
| 867 | } |
Michal Vasko | dcacf2f | 2020-11-18 18:18:15 +0100 | [diff] [blame] | 868 | } |
Michal Vasko | 4226621 | 2022-12-01 08:33:11 +0100 | [diff] [blame] | 869 | |
| 870 | /* next iter */ |
| 871 | node = node->next; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 872 | } |
| 873 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 874 | cleanup: |
| 875 | return rc; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 876 | } |
| 877 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 878 | /** |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 879 | * @brief Evaluate any "when" conditions of a non-existent data node with existing parent. |
| 880 | * |
| 881 | * @param[in] first First data sibling of the non-existing node. |
| 882 | * @param[in] parent Data parent of the non-existing node. |
| 883 | * @param[in] snode Schema node of the non-existing node. |
| 884 | * @param[out] disabled First when that evaluated false, if any. |
| 885 | * @return LY_ERR value. |
| 886 | */ |
| 887 | static LY_ERR |
| 888 | lyd_validate_dummy_when(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode, |
| 889 | const struct lysc_when **disabled) |
| 890 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 891 | LY_ERR rc = LY_SUCCESS; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 892 | struct lyd_node *tree, *dummy = NULL; |
Michal Vasko | a27245c | 2022-05-02 09:01:35 +0200 | [diff] [blame] | 893 | uint32_t xp_opts; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 894 | |
| 895 | /* find root */ |
| 896 | if (parent) { |
| 897 | tree = (struct lyd_node *)parent; |
| 898 | while (tree->parent) { |
| 899 | tree = lyd_parent(tree); |
| 900 | } |
| 901 | tree = lyd_first_sibling(tree); |
| 902 | } else { |
Michal Vasko | bd99b5e | 2022-04-29 11:15:47 +0200 | [diff] [blame] | 903 | /* is the first sibling from the same module, but may not be the actual first */ |
| 904 | tree = lyd_first_sibling(first); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 905 | } |
| 906 | |
| 907 | /* create dummy opaque node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 908 | rc = lyd_new_opaq((struct lyd_node *)parent, snode->module->ctx, snode->name, NULL, NULL, snode->module->name, &dummy); |
| 909 | LY_CHECK_GOTO(rc, cleanup); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 910 | |
| 911 | /* connect it if needed */ |
| 912 | if (!parent) { |
| 913 | if (first) { |
| 914 | lyd_insert_sibling((struct lyd_node *)first, dummy, &tree); |
| 915 | } else { |
| 916 | assert(!tree); |
| 917 | tree = dummy; |
| 918 | } |
| 919 | } |
| 920 | |
Michal Vasko | a27245c | 2022-05-02 09:01:35 +0200 | [diff] [blame] | 921 | /* explicitly specified accesible tree */ |
| 922 | if (snode->flags & LYS_CONFIG_W) { |
| 923 | xp_opts = LYXP_ACCESS_TREE_CONFIG; |
| 924 | } else { |
| 925 | xp_opts = LYXP_ACCESS_TREE_ALL; |
| 926 | } |
| 927 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 928 | /* evaluate all when */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 929 | rc = lyd_validate_node_when(tree, dummy, snode, xp_opts, disabled); |
| 930 | if (rc == LY_EINCOMPLETE) { |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 931 | /* all other when must be resolved by now */ |
| 932 | LOGINT(snode->module->ctx); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 933 | rc = LY_EINT; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 934 | goto cleanup; |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 935 | } else if (rc) { |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 936 | /* error */ |
| 937 | goto cleanup; |
| 938 | } |
| 939 | |
| 940 | cleanup: |
| 941 | lyd_free_tree(dummy); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 942 | return rc; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 943 | } |
| 944 | |
| 945 | /** |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 946 | * @brief Validate mandatory node existence. |
| 947 | * |
| 948 | * @param[in] first First sibling to search in. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 949 | * @param[in] parent Data parent. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 950 | * @param[in] snode Schema node to validate. |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 951 | * @param[in] val_opts Validation options. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 952 | * @return LY_ERR value. |
| 953 | */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 954 | static LY_ERR |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 955 | lyd_validate_mandatory(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode, |
| 956 | uint32_t val_opts) |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 957 | { |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 958 | const struct lysc_when *disabled; |
| 959 | |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 960 | if (snode->nodetype == LYS_CHOICE) { |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 961 | /* some data of a choice case exist */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 962 | if (lys_getnext_data(NULL, first, NULL, snode, NULL)) { |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 963 | return LY_SUCCESS; |
| 964 | } |
| 965 | } else { |
| 966 | assert(snode->nodetype & (LYS_LEAF | LYS_CONTAINER | LYD_NODE_ANY)); |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 967 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 968 | if (!lyd_find_sibling_val(first, snode, NULL, 0, NULL)) { |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 969 | /* data instance found */ |
| 970 | return LY_SUCCESS; |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 971 | } |
| 972 | } |
| 973 | |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 974 | disabled = NULL; |
| 975 | if (lysc_has_when(snode)) { |
| 976 | /* if there are any when conditions, they must be true for a validation error */ |
| 977 | LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled)); |
| 978 | } |
| 979 | |
| 980 | if (!disabled) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 981 | if (val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 982 | /* only a warning */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 983 | LOG_LOCSET(parent ? NULL : snode, parent); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 984 | if (snode->nodetype == LYS_CHOICE) { |
| 985 | LOGWRN(snode->module->ctx, "Mandatory choice \"%s\" data do not exist.", snode->name); |
| 986 | } else { |
| 987 | LOGWRN(snode->module->ctx, "Mandatory node \"%s\" instance does not exist.", snode->name); |
| 988 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 989 | LOG_LOCBACK(parent ? 0 : 1, parent ? 1 : 0); |
Michal Vasko | 538b895 | 2021-02-17 11:27:26 +0100 | [diff] [blame] | 990 | } else { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 991 | /* node instance not found */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 992 | LOG_LOCSET(parent ? NULL : snode, parent); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 993 | if (snode->nodetype == LYS_CHOICE) { |
| 994 | LOGVAL_APPTAG(snode->module->ctx, "missing-choice", LY_VCODE_NOMAND_CHOIC, snode->name); |
| 995 | } else { |
| 996 | LOGVAL(snode->module->ctx, LY_VCODE_NOMAND, snode->name); |
| 997 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 998 | LOG_LOCBACK(parent ? 0 : 1, parent ? 1 : 0); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 999 | return LY_EVALID; |
Michal Vasko | 538b895 | 2021-02-17 11:27:26 +0100 | [diff] [blame] | 1000 | } |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1001 | } |
| 1002 | |
| 1003 | return LY_SUCCESS; |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1004 | } |
| 1005 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1006 | /** |
| 1007 | * @brief Validate min/max-elements constraints, if any. |
| 1008 | * |
| 1009 | * @param[in] first First sibling to search in. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1010 | * @param[in] parent Data parent. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1011 | * @param[in] snode Schema node to validate. |
| 1012 | * @param[in] min Minimum number of elements, 0 for no restriction. |
| 1013 | * @param[in] max Max number of elements, 0 for no restriction. |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1014 | * @param[in] val_opts Validation options. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1015 | * @return LY_ERR value. |
| 1016 | */ |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1017 | static LY_ERR |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1018 | lyd_validate_minmax(const struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *snode, |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1019 | uint32_t min, uint32_t max, uint32_t val_opts) |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1020 | { |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1021 | uint32_t count = 0; |
Michal Vasko | 4c583e8 | 2020-07-17 12:16:14 +0200 | [diff] [blame] | 1022 | struct lyd_node *iter; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1023 | const struct lysc_when *disabled; |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1024 | |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1025 | assert(min || max); |
| 1026 | |
Michal Vasko | 4c583e8 | 2020-07-17 12:16:14 +0200 | [diff] [blame] | 1027 | LYD_LIST_FOR_INST(first, snode, iter) { |
| 1028 | ++count; |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1029 | |
Michal Vasko | 4c583e8 | 2020-07-17 12:16:14 +0200 | [diff] [blame] | 1030 | if (min && (count == min)) { |
| 1031 | /* satisfied */ |
| 1032 | min = 0; |
| 1033 | if (!max) { |
| 1034 | /* nothing more to check */ |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1035 | break; |
| 1036 | } |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1037 | } |
Michal Vasko | 4c583e8 | 2020-07-17 12:16:14 +0200 | [diff] [blame] | 1038 | if (max && (count > max)) { |
| 1039 | /* not satisifed */ |
| 1040 | break; |
| 1041 | } |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1042 | } |
| 1043 | |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1044 | if (min) { |
| 1045 | assert(count < min); |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1046 | |
| 1047 | disabled = NULL; |
| 1048 | if (lysc_has_when(snode)) { |
| 1049 | /* if there are any when conditions, they must be true for a validation error */ |
| 1050 | LY_CHECK_RET(lyd_validate_dummy_when(first, parent, snode, &disabled)); |
| 1051 | } |
| 1052 | |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1053 | if (disabled) { |
| 1054 | /* satisfied */ |
| 1055 | min = 0; |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1056 | } |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1057 | } |
| 1058 | if (max && (count <= max)) { |
| 1059 | /* satisfied */ |
| 1060 | max = 0; |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1061 | } |
| 1062 | |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1063 | if (min) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1064 | if (val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 1065 | /* only a warning */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1066 | LOG_LOCSET(snode, NULL); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1067 | LOGWRN(snode->module->ctx, "Too few \"%s\" instances.", snode->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1068 | LOG_LOCBACK(1, 0); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1069 | } else { |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1070 | LOG_LOCSET(snode, NULL); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1071 | LOGVAL_APPTAG(snode->module->ctx, "too-few-elements", LY_VCODE_NOMIN, snode->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1072 | LOG_LOCBACK(1, 0); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1073 | return LY_EVALID; |
| 1074 | } |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1075 | } else if (max) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1076 | if (val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 1077 | /* only a warning */ |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1078 | LOG_LOCSET(NULL, iter); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1079 | LOGWRN(snode->module->ctx, "Too many \"%s\" instances.", snode->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1080 | LOG_LOCBACK(0, 1); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1081 | } else { |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1082 | LOG_LOCSET(NULL, iter); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1083 | LOGVAL_APPTAG(snode->module->ctx, "too-many-elements", LY_VCODE_NOMAX, snode->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1084 | LOG_LOCBACK(0, 1); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1085 | return LY_EVALID; |
| 1086 | } |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1087 | } |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1088 | return LY_SUCCESS; |
| 1089 | } |
| 1090 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1091 | /** |
| 1092 | * @brief Find node referenced by a list unique statement. |
| 1093 | * |
| 1094 | * @param[in] uniq_leaf Unique leaf to find. |
| 1095 | * @param[in] list List instance to use for the search. |
| 1096 | * @return Found leaf, |
| 1097 | * @return NULL if no leaf found. |
| 1098 | */ |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1099 | static struct lyd_node * |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1100 | lyd_val_uniq_find_leaf(const struct lysc_node_leaf *uniq_leaf, const struct lyd_node *list) |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1101 | { |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1102 | struct lyd_node *node; |
| 1103 | const struct lysc_node *iter; |
| 1104 | size_t depth = 0, i; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1105 | |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1106 | /* get leaf depth */ |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1107 | for (iter = &uniq_leaf->node; iter && (iter != list->schema); iter = lysc_data_parent(iter)) { |
Michal Vasko | 62ed12d | 2020-05-21 10:08:25 +0200 | [diff] [blame] | 1108 | ++depth; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1109 | } |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1110 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1111 | node = (struct lyd_node *)list; |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1112 | while (node && depth) { |
| 1113 | /* find schema node with this depth */ |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1114 | for (i = depth - 1, iter = &uniq_leaf->node; i; iter = lysc_data_parent(iter)) { |
Michal Vasko | 62ed12d | 2020-05-21 10:08:25 +0200 | [diff] [blame] | 1115 | --i; |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1116 | } |
| 1117 | |
| 1118 | /* find iter instance in children */ |
| 1119 | assert(iter->nodetype & (LYS_CONTAINER | LYS_LEAF)); |
Radek Krejci | a1c1e54 | 2020-09-29 16:06:52 +0200 | [diff] [blame] | 1120 | lyd_find_sibling_val(lyd_child(node), iter, NULL, 0, &node); |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1121 | --depth; |
| 1122 | } |
| 1123 | |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1124 | return node; |
| 1125 | } |
| 1126 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1127 | /** |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1128 | * @brief Unique list validation callback argument. |
| 1129 | */ |
| 1130 | struct lyd_val_uniq_arg { |
| 1131 | LY_ARRAY_COUNT_TYPE action; /**< Action to perform - 0 to compare all uniques, n to compare only n-th unique. */ |
| 1132 | uint32_t val_opts; /**< Validation options. */ |
| 1133 | }; |
| 1134 | |
| 1135 | /** |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1136 | * @brief Callback for comparing 2 list unique leaf values. |
| 1137 | * |
Michal Vasko | 62524a9 | 2021-02-26 10:08:50 +0100 | [diff] [blame] | 1138 | * Implementation of ::lyht_value_equal_cb. |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1139 | */ |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 1140 | static ly_bool |
| 1141 | lyd_val_uniq_list_equal(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *cb_data) |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1142 | { |
| 1143 | struct ly_ctx *ctx; |
| 1144 | struct lysc_node_list *slist; |
| 1145 | struct lyd_node *diter, *first, *second; |
| 1146 | struct lyd_value *val1, *val2; |
| 1147 | char *path1, *path2, *uniq_str, *ptr; |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1148 | LY_ARRAY_COUNT_TYPE u, v; |
| 1149 | struct lyd_val_uniq_arg *arg = cb_data; |
| 1150 | const uint32_t uniq_err_msg_size = 1024; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1151 | |
| 1152 | assert(val1_p && val2_p); |
| 1153 | |
| 1154 | first = *((struct lyd_node **)val1_p); |
| 1155 | second = *((struct lyd_node **)val2_p); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1156 | |
| 1157 | assert(first && (first->schema->nodetype == LYS_LIST)); |
| 1158 | assert(second && (second->schema == first->schema)); |
| 1159 | |
| 1160 | ctx = first->schema->module->ctx; |
| 1161 | |
| 1162 | slist = (struct lysc_node_list *)first->schema; |
| 1163 | |
| 1164 | /* compare unique leaves */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1165 | if (arg->action > 0) { |
| 1166 | u = arg->action - 1; |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1167 | if (u < LY_ARRAY_COUNT(slist->uniques)) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1168 | goto uniquecheck; |
| 1169 | } |
| 1170 | } |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1171 | LY_ARRAY_FOR(slist->uniques, u) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1172 | uniquecheck: |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1173 | LY_ARRAY_FOR(slist->uniques[u], v) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1174 | /* first */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1175 | diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], first); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1176 | if (diter) { |
| 1177 | val1 = &((struct lyd_node_term *)diter)->value; |
| 1178 | } else { |
| 1179 | /* use default value */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1180 | val1 = slist->uniques[u][v]->dflt; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1181 | } |
| 1182 | |
| 1183 | /* second */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1184 | diter = lyd_val_uniq_find_leaf(slist->uniques[u][v], second); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1185 | if (diter) { |
| 1186 | val2 = &((struct lyd_node_term *)diter)->value; |
| 1187 | } else { |
| 1188 | /* use default value */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1189 | val2 = slist->uniques[u][v]->dflt; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1190 | } |
| 1191 | |
aPiecek | 0a6705b | 2023-11-14 14:20:58 +0100 | [diff] [blame] | 1192 | if (!val1 || !val2 || val1->realtype->plugin->compare(ctx, val1, val2)) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1193 | /* values differ or either one is not set */ |
| 1194 | break; |
| 1195 | } |
| 1196 | } |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1197 | if (v && (v == LY_ARRAY_COUNT(slist->uniques[u]))) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1198 | /* all unique leaves are the same in this set, create this nice error */ |
Radek Krejci | 635d2b8 | 2021-01-04 11:26:51 +0100 | [diff] [blame] | 1199 | path1 = lyd_path(first, LYD_PATH_STD, NULL, 0); |
| 1200 | path2 = lyd_path(second, LYD_PATH_STD, NULL, 0); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1201 | |
| 1202 | /* use buffer to rebuild the unique string */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1203 | uniq_str = malloc(uniq_err_msg_size); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1204 | uniq_str[0] = '\0'; |
| 1205 | ptr = uniq_str; |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1206 | LY_ARRAY_FOR(slist->uniques[u], v) { |
| 1207 | if (v) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1208 | strcpy(ptr, " "); |
| 1209 | ++ptr; |
| 1210 | } |
Michal Vasko | 14ed9cd | 2021-01-28 14:16:25 +0100 | [diff] [blame] | 1211 | ptr = lysc_path_until((struct lysc_node *)slist->uniques[u][v], &slist->node, LYSC_PATH_LOG, |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1212 | ptr, uniq_err_msg_size - (ptr - uniq_str)); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1213 | if (!ptr) { |
| 1214 | /* path will be incomplete, whatever */ |
| 1215 | break; |
| 1216 | } |
| 1217 | |
| 1218 | ptr += strlen(ptr); |
| 1219 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1220 | LOG_LOCSET(NULL, second); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1221 | if (arg->val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 1222 | /* only a warning */ |
| 1223 | LOGWRN(ctx, "Unique data leaf(s) \"%s\" not satisfied in \"%s\" and \"%s\".", uniq_str, path1, path2); |
| 1224 | } else { |
| 1225 | LOGVAL_APPTAG(ctx, "data-not-unique", LY_VCODE_NOUNIQ, uniq_str, path1, path2); |
| 1226 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1227 | LOG_LOCBACK(0, 1); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1228 | |
| 1229 | free(path1); |
| 1230 | free(path2); |
| 1231 | free(uniq_str); |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 1232 | |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1233 | if (!(arg->val_opts & LYD_VALIDATE_OPERATIONAL)) { |
| 1234 | return 1; |
| 1235 | } |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1236 | } |
| 1237 | |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1238 | if (arg->action > 0) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1239 | /* done */ |
| 1240 | return 0; |
| 1241 | } |
| 1242 | } |
| 1243 | |
| 1244 | return 0; |
| 1245 | } |
| 1246 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1247 | /** |
| 1248 | * @brief Validate list unique leaves. |
| 1249 | * |
| 1250 | * @param[in] first First sibling to search in. |
| 1251 | * @param[in] snode Schema node to validate. |
| 1252 | * @param[in] uniques List unique arrays to validate. |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1253 | * @param[in] val_opts Validation options. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1254 | * @return LY_ERR value. |
| 1255 | */ |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1256 | static LY_ERR |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1257 | lyd_validate_unique(const struct lyd_node *first, const struct lysc_node *snode, const struct lysc_node_leaf ***uniques, |
| 1258 | uint32_t val_opts) |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1259 | { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1260 | const struct lyd_node *diter; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1261 | struct ly_set *set; |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1262 | LY_ARRAY_COUNT_TYPE u, v, x = 0; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1263 | LY_ERR ret = LY_SUCCESS; |
Michal Vasko | 626196f | 2022-08-05 12:49:52 +0200 | [diff] [blame] | 1264 | uint32_t hash, i; |
Radek Krejci | 813c02d | 2021-04-26 10:29:19 +0200 | [diff] [blame] | 1265 | size_t key_len; |
| 1266 | ly_bool dyn; |
| 1267 | const void *hash_key; |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1268 | struct lyd_val_uniq_arg arg, *args = NULL; |
Michal Vasko | 8efac24 | 2023-03-30 08:24:56 +0200 | [diff] [blame] | 1269 | struct ly_ht **uniqtables = NULL; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1270 | struct lyd_value *val; |
| 1271 | struct ly_ctx *ctx = snode->module->ctx; |
| 1272 | |
| 1273 | assert(uniques); |
| 1274 | |
| 1275 | /* get all list instances */ |
Radek Krejci | ba03a5a | 2020-08-27 14:40:41 +0200 | [diff] [blame] | 1276 | LY_CHECK_RET(ly_set_new(&set)); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1277 | LY_LIST_FOR(first, diter) { |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1278 | if (diter->schema == snode) { |
Radek Krejci | 3d92e44 | 2020-10-12 12:48:13 +0200 | [diff] [blame] | 1279 | ret = ly_set_add(set, (void *)diter, 1, NULL); |
Michal Vasko | b0099a9 | 2020-08-31 14:55:23 +0200 | [diff] [blame] | 1280 | LY_CHECK_GOTO(ret, cleanup); |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1281 | } |
| 1282 | } |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1283 | |
| 1284 | if (set->count == 2) { |
| 1285 | /* simple comparison */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1286 | arg.action = 0; |
| 1287 | arg.val_opts = val_opts; |
| 1288 | if (lyd_val_uniq_list_equal(&set->objs[0], &set->objs[1], 0, &arg)) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1289 | /* instance duplication */ |
| 1290 | ret = LY_EVALID; |
| 1291 | goto cleanup; |
| 1292 | } |
| 1293 | } else if (set->count > 2) { |
| 1294 | /* use hashes for comparison */ |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1295 | uniqtables = malloc(LY_ARRAY_COUNT(uniques) * sizeof *uniqtables); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1296 | args = malloc(LY_ARRAY_COUNT(uniques) * sizeof *args); |
| 1297 | LY_CHECK_ERR_GOTO(!uniqtables || !args, LOGMEM(ctx); ret = LY_EMEM, cleanup); |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1298 | x = LY_ARRAY_COUNT(uniques); |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1299 | for (v = 0; v < x; v++) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1300 | args[v].action = v + 1; |
| 1301 | args[v].val_opts = val_opts; |
Michal Vasko | 626196f | 2022-08-05 12:49:52 +0200 | [diff] [blame] | 1302 | uniqtables[v] = lyht_new(lyht_get_fixed_size(set->count), sizeof(struct lyd_node *), |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1303 | lyd_val_uniq_list_equal, &args[v], 0); |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1304 | LY_CHECK_ERR_GOTO(!uniqtables[v], LOGMEM(ctx); ret = LY_EMEM, cleanup); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1305 | } |
| 1306 | |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1307 | for (i = 0; i < set->count; i++) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1308 | /* loop for unique - get the hash for the instances */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1309 | for (u = 0; u < x; u++) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1310 | val = NULL; |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1311 | for (v = hash = 0; v < LY_ARRAY_COUNT(uniques[u]); v++) { |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1312 | diter = lyd_val_uniq_find_leaf(uniques[u][v], set->objs[i]); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1313 | if (diter) { |
| 1314 | val = &((struct lyd_node_term *)diter)->value; |
| 1315 | } else { |
| 1316 | /* use default value */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1317 | val = uniques[u][v]->dflt; |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1318 | } |
| 1319 | if (!val) { |
| 1320 | /* unique item not present nor has default value */ |
| 1321 | break; |
| 1322 | } |
| 1323 | |
Radek Krejci | 813c02d | 2021-04-26 10:29:19 +0200 | [diff] [blame] | 1324 | /* get hash key */ |
Michal Vasko | dcfac2c | 2021-05-10 11:36:37 +0200 | [diff] [blame] | 1325 | hash_key = val->realtype->plugin->print(NULL, val, LY_VALUE_LYB, NULL, &dyn, &key_len); |
Michal Vasko | ae130f5 | 2023-04-20 14:25:16 +0200 | [diff] [blame] | 1326 | hash = lyht_hash_multi(hash, hash_key, key_len); |
Radek Krejci | 813c02d | 2021-04-26 10:29:19 +0200 | [diff] [blame] | 1327 | if (dyn) { |
| 1328 | free((void *)hash_key); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1329 | } |
| 1330 | } |
| 1331 | if (!val) { |
| 1332 | /* skip this list instance since its unique set is incomplete */ |
| 1333 | continue; |
| 1334 | } |
| 1335 | |
| 1336 | /* finish the hash value */ |
Michal Vasko | ae130f5 | 2023-04-20 14:25:16 +0200 | [diff] [blame] | 1337 | hash = lyht_hash_multi(hash, NULL, 0); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1338 | |
| 1339 | /* insert into the hashtable */ |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1340 | ret = lyht_insert(uniqtables[u], &set->objs[i], hash, NULL); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1341 | if (ret == LY_EEXIST) { |
| 1342 | /* instance duplication */ |
| 1343 | ret = LY_EVALID; |
| 1344 | } |
| 1345 | LY_CHECK_GOTO(ret != LY_SUCCESS, cleanup); |
| 1346 | } |
| 1347 | } |
| 1348 | } |
| 1349 | |
| 1350 | cleanup: |
| 1351 | ly_set_free(set, NULL); |
Radek Krejci | 7eb54ba | 2020-05-18 16:30:04 +0200 | [diff] [blame] | 1352 | for (v = 0; v < x; v++) { |
| 1353 | if (!uniqtables[v]) { |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1354 | /* failed when allocating uniquetables[j], following j are not allocated */ |
| 1355 | break; |
| 1356 | } |
Michal Vasko | 77b7f90a | 2023-01-31 15:42:41 +0100 | [diff] [blame] | 1357 | lyht_free(uniqtables[v], NULL); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1358 | } |
| 1359 | free(uniqtables); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1360 | free(args); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1361 | |
| 1362 | return ret; |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1363 | } |
| 1364 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1365 | /** |
| 1366 | * @brief Validate data siblings based on generic schema node restrictions, recursively for schema-only nodes. |
| 1367 | * |
| 1368 | * @param[in] first First sibling to search in. |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1369 | * @param[in] parent Data parent. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1370 | * @param[in] sparent Schema parent of the nodes to check. |
| 1371 | * @param[in] mod Module of the nodes to check. |
| 1372 | * @param[in] val_opts Validation options, see @ref datavalidationoptions. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1373 | * @param[in] int_opts Internal parser options. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1374 | * @return LY_ERR value. |
| 1375 | */ |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1376 | static LY_ERR |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1377 | lyd_validate_siblings_schema_r(const struct lyd_node *first, const struct lyd_node *parent, |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1378 | const struct lysc_node *sparent, const struct lysc_module *mod, uint32_t val_opts, uint32_t int_opts) |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1379 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1380 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 6c16cda | 2021-02-04 11:05:52 +0100 | [diff] [blame] | 1381 | const struct lysc_node *snode = NULL, *scase; |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1382 | struct lysc_node_list *slist; |
Michal Vasko | d8958df | 2020-08-05 13:27:36 +0200 | [diff] [blame] | 1383 | struct lysc_node_leaflist *sllist; |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 1384 | uint32_t getnext_opts; |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1385 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1386 | getnext_opts = LYS_GETNEXT_WITHCHOICE | (int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0); |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1387 | |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1388 | /* disabled nodes are skipped by lys_getnext */ |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1389 | while ((snode = lys_getnext(snode, sparent, mod, getnext_opts))) { |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 1390 | if ((val_opts & LYD_VALIDATE_NO_STATE) && (snode->flags & LYS_CONFIG_R)) { |
Michal Vasko | e75ecfd | 2020-03-06 14:12:28 +0100 | [diff] [blame] | 1391 | continue; |
| 1392 | } |
| 1393 | |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1394 | /* check min-elements and max-elements */ |
Michal Vasko | d8958df | 2020-08-05 13:27:36 +0200 | [diff] [blame] | 1395 | if (snode->nodetype == LYS_LIST) { |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1396 | slist = (struct lysc_node_list *)snode; |
| 1397 | if (slist->min || slist->max) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1398 | r = lyd_validate_minmax(first, parent, snode, slist->min, slist->max, val_opts); |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1399 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1400 | } |
Michal Vasko | d8958df | 2020-08-05 13:27:36 +0200 | [diff] [blame] | 1401 | } else if (snode->nodetype == LYS_LEAFLIST) { |
| 1402 | sllist = (struct lysc_node_leaflist *)snode; |
| 1403 | if (sllist->min || sllist->max) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1404 | r = lyd_validate_minmax(first, parent, snode, sllist->min, sllist->max, val_opts); |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1405 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | d8958df | 2020-08-05 13:27:36 +0200 | [diff] [blame] | 1406 | } |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1407 | |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1408 | } else if (snode->flags & LYS_MAND_TRUE) { |
Radek Krejci | f6a1100 | 2020-08-21 13:29:07 +0200 | [diff] [blame] | 1409 | /* check generic mandatory existence */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1410 | r = lyd_validate_mandatory(first, parent, snode, val_opts); |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1411 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1412 | } |
| 1413 | |
| 1414 | /* check unique */ |
| 1415 | if (snode->nodetype == LYS_LIST) { |
| 1416 | slist = (struct lysc_node_list *)snode; |
| 1417 | if (slist->uniques) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1418 | r = lyd_validate_unique(first, snode, (const struct lysc_node_leaf ***)slist->uniques, val_opts); |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1419 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1420 | } |
| 1421 | } |
| 1422 | |
Michal Vasko | 6c16cda | 2021-02-04 11:05:52 +0100 | [diff] [blame] | 1423 | if (snode->nodetype == LYS_CHOICE) { |
| 1424 | /* find the existing case, if any */ |
| 1425 | LY_LIST_FOR(lysc_node_child(snode), scase) { |
| 1426 | if (lys_getnext_data(NULL, first, NULL, scase, NULL)) { |
| 1427 | /* validate only this case */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1428 | r = lyd_validate_siblings_schema_r(first, parent, scase, mod, val_opts, int_opts); |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1429 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 6c16cda | 2021-02-04 11:05:52 +0100 | [diff] [blame] | 1430 | break; |
| 1431 | } |
| 1432 | } |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1433 | } |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1434 | } |
| 1435 | |
Michal Vasko | 6727c68 | 2023-02-17 10:40:26 +0100 | [diff] [blame] | 1436 | cleanup: |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1437 | return rc; |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1438 | } |
| 1439 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1440 | /** |
| 1441 | * @brief Validate obsolete nodes, only warnings are printed. |
| 1442 | * |
| 1443 | * @param[in] node Node to check. |
| 1444 | */ |
Michal Vasko | e75ecfd | 2020-03-06 14:12:28 +0100 | [diff] [blame] | 1445 | static void |
| 1446 | lyd_validate_obsolete(const struct lyd_node *node) |
| 1447 | { |
| 1448 | const struct lysc_node *snode; |
| 1449 | |
| 1450 | snode = node->schema; |
| 1451 | do { |
| 1452 | if (snode->flags & LYS_STATUS_OBSLT) { |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1453 | LOG_LOCSET(NULL, node); |
Michal Vasko | e75ecfd | 2020-03-06 14:12:28 +0100 | [diff] [blame] | 1454 | LOGWRN(snode->module->ctx, "Obsolete schema node \"%s\" instantiated in data.", snode->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1455 | LOG_LOCBACK(0, 1); |
Michal Vasko | e75ecfd | 2020-03-06 14:12:28 +0100 | [diff] [blame] | 1456 | break; |
| 1457 | } |
| 1458 | |
| 1459 | snode = snode->parent; |
| 1460 | } while (snode && (snode->nodetype & (LYS_CHOICE | LYS_CASE))); |
| 1461 | } |
| 1462 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1463 | /** |
| 1464 | * @brief Validate must conditions of a data node. |
| 1465 | * |
| 1466 | * @param[in] node Node to validate. |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1467 | * @param[in] val_opts Validation options. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1468 | * @param[in] int_opts Internal parser options. |
Michal Vasko | 906bafa | 2022-04-22 12:28:55 +0200 | [diff] [blame] | 1469 | * @param[in] xpath_options Additional XPath options to use. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1470 | * @return LY_ERR value. |
| 1471 | */ |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1472 | static LY_ERR |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1473 | lyd_validate_must(const struct lyd_node *node, uint32_t val_opts, uint32_t int_opts, uint32_t xpath_options) |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1474 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1475 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1476 | struct lyxp_set xp_set; |
| 1477 | struct lysc_must *musts; |
| 1478 | const struct lyd_node *tree; |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1479 | const struct lysc_node *schema; |
Michal Vasko | e9391c7 | 2021-10-05 10:04:56 +0200 | [diff] [blame] | 1480 | const char *emsg, *eapptag; |
Michal Vasko | fd69e1d | 2020-07-03 11:57:17 +0200 | [diff] [blame] | 1481 | LY_ARRAY_COUNT_TYPE u; |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1482 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1483 | assert((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) != (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)); |
| 1484 | assert((int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) != (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)); |
| 1485 | |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1486 | if (node->schema->nodetype & (LYS_ACTION | LYS_RPC)) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1487 | if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) { |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1488 | schema = &((struct lysc_node_action *)node->schema)->input.node; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1489 | } else if (int_opts & LYD_INTOPT_REPLY) { |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1490 | schema = &((struct lysc_node_action *)node->schema)->output.node; |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1491 | } else { |
Michal Vasko | a1db234 | 2021-07-19 12:23:23 +0200 | [diff] [blame] | 1492 | LOGINT_RET(LYD_CTX(node)); |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1493 | } |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1494 | } else { |
| 1495 | schema = node->schema; |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1496 | } |
Radek Krejci | 9a3823e | 2021-01-27 20:26:46 +0100 | [diff] [blame] | 1497 | musts = lysc_node_musts(schema); |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1498 | if (!musts) { |
| 1499 | /* no must to evaluate */ |
| 1500 | return LY_SUCCESS; |
| 1501 | } |
| 1502 | |
| 1503 | /* find first top-level node */ |
Michal Vasko | 9e68508 | 2021-01-29 14:49:09 +0100 | [diff] [blame] | 1504 | for (tree = node; tree->parent; tree = lyd_parent(tree)) {} |
Michal Vasko | f9221e6 | 2021-02-04 12:10:14 +0100 | [diff] [blame] | 1505 | tree = lyd_first_sibling(tree); |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1506 | |
| 1507 | LY_ARRAY_FOR(musts, u) { |
| 1508 | memset(&xp_set, 0, sizeof xp_set); |
| 1509 | |
| 1510 | /* evaluate must */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1511 | r = lyxp_eval(LYD_CTX(node), musts[u].cond, node->schema->module, LY_VALUE_SCHEMA_RESOLVED, |
Michal Vasko | a3e92bc | 2022-07-29 14:56:23 +0200 | [diff] [blame] | 1512 | musts[u].prefixes, node, node, tree, NULL, &xp_set, LYXP_SCHEMA | xpath_options); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1513 | if (r == LY_EINCOMPLETE) { |
Michal Vasko | 2deae4c | 2023-11-08 11:36:59 +0100 | [diff] [blame] | 1514 | LOGERR(LYD_CTX(node), LY_EINCOMPLETE, |
| 1515 | "Must \"%s\" depends on a node with a when condition, which has not been evaluated.", musts[u].cond->expr); |
Michal Vasko | a1db234 | 2021-07-19 12:23:23 +0200 | [diff] [blame] | 1516 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1517 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1518 | |
| 1519 | /* check the result */ |
| 1520 | lyxp_set_cast(&xp_set, LYXP_SET_BOOLEAN); |
Michal Vasko | 004d315 | 2020-06-11 19:59:22 +0200 | [diff] [blame] | 1521 | if (!xp_set.val.bln) { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1522 | if (val_opts & LYD_VALIDATE_OPERATIONAL) { |
| 1523 | /* only a warning */ |
| 1524 | emsg = musts[u].emsg; |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1525 | LOG_LOCSET(NULL, node); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1526 | if (emsg) { |
| 1527 | LOGWRN(LYD_CTX(node), "%s", emsg); |
| 1528 | } else { |
| 1529 | LOGWRN(LYD_CTX(node), "Must condition \"%s\" not satisfied.", musts[u].cond->expr); |
| 1530 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1531 | LOG_LOCBACK(0, 1); |
Michal Vasko | e9391c7 | 2021-10-05 10:04:56 +0200 | [diff] [blame] | 1532 | } else { |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1533 | /* use specific error information */ |
| 1534 | emsg = musts[u].emsg; |
| 1535 | eapptag = musts[u].eapptag ? musts[u].eapptag : "must-violation"; |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1536 | LOG_LOCSET(NULL, node); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1537 | if (emsg) { |
| 1538 | LOGVAL_APPTAG(LYD_CTX(node), eapptag, LYVE_DATA, "%s", emsg); |
| 1539 | } else { |
| 1540 | LOGVAL_APPTAG(LYD_CTX(node), eapptag, LY_VCODE_NOMUST, musts[u].cond->expr); |
| 1541 | } |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1542 | LOG_LOCBACK(0, 1); |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1543 | r = LY_EVALID; |
| 1544 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | e9391c7 | 2021-10-05 10:04:56 +0200 | [diff] [blame] | 1545 | } |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1546 | } |
| 1547 | } |
| 1548 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1549 | cleanup: |
| 1550 | return rc; |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1551 | } |
| 1552 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1553 | /** |
| 1554 | * @brief Perform all remaining validation tasks, the data tree must be final when calling this function. |
| 1555 | * |
| 1556 | * @param[in] first First sibling. |
| 1557 | * @param[in] parent Data parent. |
| 1558 | * @param[in] sparent Schema parent of the siblings, NULL for top-level siblings. |
| 1559 | * @param[in] mod Module of the siblings, NULL for nested siblings. |
| 1560 | * @param[in] val_opts Validation options (@ref datavalidationoptions). |
| 1561 | * @param[in] int_opts Internal parser options. |
Michal Vasko | 906bafa | 2022-04-22 12:28:55 +0200 | [diff] [blame] | 1562 | * @param[in] must_xp_opts Additional XPath options to use for evaluating "must". |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1563 | * @return LY_ERR value. |
| 1564 | */ |
| 1565 | static LY_ERR |
Michal Vasko | bd4db89 | 2020-11-23 16:58:20 +0100 | [diff] [blame] | 1566 | lyd_validate_final_r(struct lyd_node *first, const struct lyd_node *parent, const struct lysc_node *sparent, |
Michal Vasko | 906bafa | 2022-04-22 12:28:55 +0200 | [diff] [blame] | 1567 | const struct lys_module *mod, uint32_t val_opts, uint32_t int_opts, uint32_t must_xp_opts) |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1568 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1569 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 22e8f1f | 2021-12-02 09:26:06 +0100 | [diff] [blame] | 1570 | const char *innode; |
Michal Vasko | b8093b9 | 2023-12-21 13:23:07 +0100 | [diff] [blame] | 1571 | struct lyd_node *node; |
Michal Vasko | acd83e7 | 2020-02-04 14:12:01 +0100 | [diff] [blame] | 1572 | |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1573 | /* validate all restrictions of nodes themselves */ |
Michal Vasko | b8093b9 | 2023-12-21 13:23:07 +0100 | [diff] [blame] | 1574 | LY_LIST_FOR(first, node) { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1575 | if (node->flags & LYD_EXT) { |
| 1576 | /* ext instance data should have already been validated */ |
| 1577 | continue; |
| 1578 | } |
| 1579 | |
Michal Vasko | a8c6172 | 2020-03-27 16:59:32 +0100 | [diff] [blame] | 1580 | /* opaque data */ |
| 1581 | if (!node->schema) { |
Michal Vasko | ac6f4be | 2022-05-02 10:16:50 +0200 | [diff] [blame] | 1582 | r = lyd_parse_opaq_error(node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1583 | goto next_iter; |
Michal Vasko | a8c6172 | 2020-03-27 16:59:32 +0100 | [diff] [blame] | 1584 | } |
| 1585 | |
Michal Vasko | 6344e7a | 2022-05-10 10:08:53 +0200 | [diff] [blame] | 1586 | if (!node->parent && mod && (lyd_owner_module(node) != mod)) { |
| 1587 | /* all top-level data from this module checked */ |
Michal Vasko | 6344e7a | 2022-05-10 10:08:53 +0200 | [diff] [blame] | 1588 | break; |
| 1589 | } |
| 1590 | |
Michal Vasko | 8d289f9 | 2021-12-02 10:11:00 +0100 | [diff] [blame] | 1591 | /* no state/input/output/op data */ |
Michal Vasko | 22e8f1f | 2021-12-02 09:26:06 +0100 | [diff] [blame] | 1592 | innode = NULL; |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 1593 | if ((val_opts & LYD_VALIDATE_NO_STATE) && (node->schema->flags & LYS_CONFIG_R)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1594 | innode = "state"; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1595 | } else if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION)) && (node->schema->flags & LYS_IS_OUTPUT)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1596 | innode = "output"; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1597 | } else if ((int_opts & LYD_INTOPT_REPLY) && (node->schema->flags & LYS_IS_INPUT)) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1598 | innode = "input"; |
Michal Vasko | 8d289f9 | 2021-12-02 10:11:00 +0100 | [diff] [blame] | 1599 | } else if (!(int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_RPC)) { |
| 1600 | innode = "rpc"; |
| 1601 | } else if (!(int_opts & (LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && (node->schema->nodetype == LYS_ACTION)) { |
| 1602 | innode = "action"; |
| 1603 | } else if (!(int_opts & LYD_INTOPT_NOTIF) && (node->schema->nodetype == LYS_NOTIF)) { |
| 1604 | innode = "notification"; |
Michal Vasko | 22e8f1f | 2021-12-02 09:26:06 +0100 | [diff] [blame] | 1605 | } |
| 1606 | if (innode) { |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1607 | LOG_LOCSET(NULL, node); |
Michal Vasko | 22e8f1f | 2021-12-02 09:26:06 +0100 | [diff] [blame] | 1608 | LOGVAL(LYD_CTX(node), LY_VCODE_UNEXPNODE, innode, node->schema->name); |
Michal Vasko | 7a26677 | 2024-01-23 11:02:38 +0100 | [diff] [blame] | 1609 | LOG_LOCBACK(0, 1); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1610 | r = LY_EVALID; |
| 1611 | goto next_iter; |
Michal Vasko | 5b37a35 | 2020-03-06 13:38:33 +0100 | [diff] [blame] | 1612 | } |
| 1613 | |
Michal Vasko | e75ecfd | 2020-03-06 14:12:28 +0100 | [diff] [blame] | 1614 | /* obsolete data */ |
| 1615 | lyd_validate_obsolete(node); |
| 1616 | |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1617 | /* node's musts */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1618 | if ((r = lyd_validate_must(node, val_opts, int_opts, must_xp_opts))) { |
| 1619 | goto next_iter; |
Michal Vasko | 22e8f1f | 2021-12-02 09:26:06 +0100 | [diff] [blame] | 1620 | } |
Michal Vasko | cc048b2 | 2020-03-27 15:52:38 +0100 | [diff] [blame] | 1621 | |
Michal Vasko | 53d97a1 | 2020-11-05 17:39:10 +0100 | [diff] [blame] | 1622 | /* node value was checked by plugins */ |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 1623 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1624 | next_iter: |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1625 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1626 | } |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1627 | |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1628 | /* validate schema-based restrictions */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1629 | r = lyd_validate_siblings_schema_r(first, parent, sparent, mod ? mod->compiled : NULL, val_opts, int_opts); |
| 1630 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1631 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1632 | LY_LIST_FOR(first, node) { |
Michal Vasko | dc9e27b | 2023-08-21 11:56:14 +0200 | [diff] [blame] | 1633 | if (!node->schema || (!node->parent && mod && (lyd_owner_module(node) != mod))) { |
| 1634 | /* only opaque data following or all top-level data from this module checked */ |
Michal Vasko | 19034e2 | 2021-07-19 12:24:14 +0200 | [diff] [blame] | 1635 | break; |
| 1636 | } |
| 1637 | |
Michal Vasko | 1465471 | 2020-02-06 08:35:21 +0100 | [diff] [blame] | 1638 | /* validate all children recursively */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1639 | r = lyd_validate_final_r(lyd_child(node), node, node->schema, NULL, val_opts, int_opts, must_xp_opts); |
| 1640 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | cde73ac | 2019-11-14 16:10:27 +0100 | [diff] [blame] | 1641 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1642 | /* set default for containers */ |
Michal Vasko | 4754d4a | 2022-12-01 10:11:21 +0100 | [diff] [blame] | 1643 | lyd_cont_set_dflt(node); |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1644 | } |
| 1645 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1646 | cleanup: |
| 1647 | return rc; |
Michal Vasko | 9b368d3 | 2020-02-14 13:53:31 +0100 | [diff] [blame] | 1648 | } |
| 1649 | |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 1650 | /** |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1651 | * @brief Validate extension instance data by storing it in its unres set. |
| 1652 | * |
| 1653 | * @param[in] sibling First sibling with ::LYD_EXT flag, all the following ones are expected to have it, too. |
| 1654 | * @param[in,out] ext_val Set with parsed extension instance data to validate. |
| 1655 | * @return LY_ERR value. |
| 1656 | */ |
| 1657 | static LY_ERR |
| 1658 | lyd_validate_nested_ext(struct lyd_node *sibling, struct ly_set *ext_val) |
| 1659 | { |
| 1660 | struct lyd_node *node; |
| 1661 | struct lyd_ctx_ext_val *ext_v; |
| 1662 | struct lysc_ext_instance *nested_exts, *ext = NULL; |
| 1663 | LY_ARRAY_COUNT_TYPE u; |
| 1664 | |
| 1665 | /* check of basic assumptions */ |
| 1666 | if (!sibling->parent || !sibling->parent->schema) { |
| 1667 | LOGINT_RET(LYD_CTX(sibling)); |
| 1668 | } |
| 1669 | LY_LIST_FOR(sibling, node) { |
| 1670 | if (!(node->flags & LYD_EXT)) { |
| 1671 | LOGINT_RET(LYD_CTX(sibling)); |
| 1672 | } |
| 1673 | } |
| 1674 | |
| 1675 | /* try to find the extension instance */ |
| 1676 | nested_exts = sibling->parent->schema->exts; |
| 1677 | LY_ARRAY_FOR(nested_exts, u) { |
| 1678 | if (nested_exts[u].def->plugin->validate) { |
| 1679 | if (ext) { |
| 1680 | /* more extension instances with validate callback */ |
| 1681 | LOGINT_RET(LYD_CTX(sibling)); |
| 1682 | } |
| 1683 | ext = &nested_exts[u]; |
| 1684 | } |
| 1685 | } |
| 1686 | if (!ext) { |
| 1687 | /* no extension instance with validate callback */ |
| 1688 | LOGINT_RET(LYD_CTX(sibling)); |
| 1689 | } |
| 1690 | |
| 1691 | /* store for validation */ |
| 1692 | ext_v = malloc(sizeof *ext_v); |
| 1693 | LY_CHECK_ERR_RET(!ext_v, LOGMEM(LYD_CTX(sibling)), LY_EMEM); |
| 1694 | ext_v->ext = ext; |
| 1695 | ext_v->sibling = sibling; |
| 1696 | LY_CHECK_RET(ly_set_add(ext_val, ext_v, 1, NULL)); |
| 1697 | |
| 1698 | return LY_SUCCESS; |
| 1699 | } |
| 1700 | |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1701 | LY_ERR |
| 1702 | lyd_validate_node_ext(struct lyd_node *node, struct ly_set *ext_node) |
| 1703 | { |
| 1704 | struct lyd_ctx_ext_node *ext_n; |
| 1705 | struct lysc_ext_instance *exts; |
| 1706 | LY_ARRAY_COUNT_TYPE u; |
| 1707 | |
| 1708 | /* try to find a relevant extension instance with node callback */ |
| 1709 | exts = node->schema->exts; |
| 1710 | LY_ARRAY_FOR(exts, u) { |
| 1711 | if (exts[u].def->plugin && exts[u].def->plugin->node) { |
| 1712 | /* store for validation */ |
| 1713 | ext_n = malloc(sizeof *ext_n); |
| 1714 | LY_CHECK_ERR_RET(!ext_n, LOGMEM(LYD_CTX(node)), LY_EMEM); |
| 1715 | ext_n->ext = &exts[u]; |
| 1716 | ext_n->node = node; |
| 1717 | LY_CHECK_RET(ly_set_add(ext_node, ext_n, 1, NULL)); |
| 1718 | } |
| 1719 | } |
| 1720 | |
| 1721 | return LY_SUCCESS; |
| 1722 | } |
| 1723 | |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1724 | /** |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1725 | * @brief Validate the whole data subtree. |
| 1726 | * |
| 1727 | * @param[in] root Subtree root. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1728 | * @param[in,out] node_when Set for nodes with when conditions. |
Michal Vasko | 3271138 | 2020-12-03 14:14:31 +0100 | [diff] [blame] | 1729 | * @param[in,out] node_types Set for unres node types. |
| 1730 | * @param[in,out] meta_types Set for unres metadata types. |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 1731 | * @param[in,out] ext_node Set with nodes with extensions to validate. |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1732 | * @param[in,out] ext_val Set for parsed extension data to validate. |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1733 | * @param[in] val_opts Validation options. |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 1734 | * @param[in,out] diff Validation diff. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1735 | * @return LY_ERR value. |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 1736 | */ |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1737 | static LY_ERR |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1738 | lyd_validate_subtree(struct lyd_node *root, struct ly_set *node_when, struct ly_set *node_types, |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1739 | struct ly_set *meta_types, struct ly_set *ext_node, struct ly_set *ext_val, uint32_t val_opts, |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 1740 | struct lyd_node **diff) |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1741 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1742 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1743 | const struct lyd_meta *meta; |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 1744 | const struct lysc_type *type; |
Michal Vasko | 56daf73 | 2020-08-10 10:57:18 +0200 | [diff] [blame] | 1745 | struct lyd_node *node; |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1746 | uint32_t impl_opts; |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1747 | |
Michal Vasko | 56daf73 | 2020-08-10 10:57:18 +0200 | [diff] [blame] | 1748 | LYD_TREE_DFS_BEGIN(root, node) { |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1749 | if (node->flags & LYD_EXT) { |
| 1750 | /* validate using the extension instance callback */ |
| 1751 | return lyd_validate_nested_ext(node, ext_val); |
| 1752 | } |
| 1753 | |
Michal Vasko | 5900da4 | 2021-08-04 11:02:43 +0200 | [diff] [blame] | 1754 | if (!node->schema) { |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1755 | /* do not validate opaque nodes */ |
aPiecek | 18a844e | 2021-08-10 11:06:24 +0200 | [diff] [blame] | 1756 | goto next_node; |
Michal Vasko | 5900da4 | 2021-08-04 11:02:43 +0200 | [diff] [blame] | 1757 | } |
| 1758 | |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1759 | LY_LIST_FOR(node->meta, meta) { |
Michal Vasko | fbd037c | 2022-11-08 10:34:20 +0100 | [diff] [blame] | 1760 | lyplg_ext_get_storage(meta->annotation, LY_STMT_TYPE, sizeof type, (const void **)&type); |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 1761 | if (type->plugin->validate) { |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1762 | /* metadata type resolution */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1763 | r = ly_set_add(meta_types, (void *)meta, 1, NULL); |
| 1764 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1765 | } |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1766 | } |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1767 | |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1768 | if ((node->schema->nodetype & LYD_NODE_TERM) && ((struct lysc_node_leaf *)node->schema)->type->plugin->validate) { |
| 1769 | /* node type resolution */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1770 | r = ly_set_add(node_types, (void *)node, 1, NULL); |
| 1771 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1772 | } else if (node->schema->nodetype & LYD_NODE_INNER) { |
| 1773 | /* new node validation, autodelete */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1774 | r = lyd_validate_new(lyd_node_child_p(node), node->schema, NULL, val_opts, diff); |
| 1775 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1776 | |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1777 | /* add nested defaults */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1778 | impl_opts = 0; |
| 1779 | if (val_opts & LYD_VALIDATE_NO_STATE) { |
| 1780 | impl_opts |= LYD_IMPLICIT_NO_STATE; |
| 1781 | } |
| 1782 | if (val_opts & LYD_VALIDATE_NO_DEFAULTS) { |
| 1783 | impl_opts |= LYD_IMPLICIT_NO_DEFAULTS; |
| 1784 | } |
Michal Vasko | 361391d | 2024-10-08 14:55:50 +0200 | [diff] [blame] | 1785 | r = lyd_new_implicit(node, lyd_node_child_p(node), NULL, NULL, NULL, NULL, NULL, impl_opts, diff); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1786 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1787 | } |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1788 | |
Michal Vasko | f4d67ea | 2021-03-31 13:53:21 +0200 | [diff] [blame] | 1789 | if (lysc_has_when(node->schema)) { |
Michal Vasko | 0275cf6 | 2020-11-05 17:40:30 +0100 | [diff] [blame] | 1790 | /* when evaluation */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1791 | r = ly_set_add(node_when, (void *)node, 1, NULL); |
| 1792 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1793 | } |
| 1794 | |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 1795 | /* store for ext instance node validation, if needed */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1796 | r = lyd_validate_node_ext(node, ext_node); |
| 1797 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 1798 | |
aPiecek | 18a844e | 2021-08-10 11:06:24 +0200 | [diff] [blame] | 1799 | next_node: |
Michal Vasko | 56daf73 | 2020-08-10 10:57:18 +0200 | [diff] [blame] | 1800 | LYD_TREE_DFS_END(root, node); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1801 | } |
| 1802 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1803 | cleanup: |
| 1804 | return rc; |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1805 | } |
| 1806 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1807 | LY_ERR |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 1808 | lyd_validate(struct lyd_node **tree, const struct lys_module *module, const struct ly_ctx *ctx, uint32_t val_opts, |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1809 | ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p, struct ly_set *meta_types_p, |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1810 | struct ly_set *ext_node_p, struct ly_set *ext_val_p, struct lyd_node **diff) |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1811 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1812 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 73e4721 | 2020-12-03 14:20:16 +0100 | [diff] [blame] | 1813 | struct lyd_node *first, *next, **first2, *iter; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1814 | const struct lys_module *mod; |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1815 | struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_node = {0}, ext_val = {0}; |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1816 | uint32_t i = 0, impl_opts; |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1817 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1818 | assert(tree && ctx); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1819 | assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) || |
| 1820 | (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p)); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1821 | |
| 1822 | if (!node_when_p) { |
| 1823 | node_when_p = &node_when; |
| 1824 | node_types_p = &node_types; |
| 1825 | meta_types_p = &meta_types; |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1826 | ext_node_p = &ext_node; |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1827 | ext_val_p = &ext_val; |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 1828 | } |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1829 | |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1830 | next = *tree; |
| 1831 | while (1) { |
Radek Krejci | 7931b19 | 2020-06-25 17:05:03 +0200 | [diff] [blame] | 1832 | if (val_opts & LYD_VALIDATE_PRESENT) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1833 | mod = lyd_data_next_module(&next, &first); |
| 1834 | } else { |
Michal Vasko | 26e8001 | 2020-07-08 10:55:46 +0200 | [diff] [blame] | 1835 | mod = lyd_mod_next_module(next, module, ctx, &i, &first); |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1836 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1837 | if (!mod) { |
| 1838 | break; |
| 1839 | } |
Michal Vasko | 7c4cf1e | 2020-06-22 10:04:30 +0200 | [diff] [blame] | 1840 | if (!first || (first == *tree)) { |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1841 | /* make sure first2 changes are carried to tree */ |
| 1842 | first2 = tree; |
| 1843 | } else { |
| 1844 | first2 = &first; |
| 1845 | } |
| 1846 | |
| 1847 | /* validate new top-level nodes of this module, autodelete */ |
Michal Vasko | a6139e0 | 2023-10-03 14:13:22 +0200 | [diff] [blame] | 1848 | r = lyd_validate_new(first2, *first2 ? lysc_data_parent((*first2)->schema) : NULL, mod, val_opts, diff); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1849 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1850 | |
Radek Krejci | 7be7b9f | 2021-02-24 11:46:27 +0100 | [diff] [blame] | 1851 | /* add all top-level defaults for this module, if going to validate subtree, do not add into unres sets |
| 1852 | * (lyd_validate_subtree() adds all the nodes in that case) */ |
Michal Vasko | af5a8dd | 2023-03-02 11:25:02 +0100 | [diff] [blame] | 1853 | impl_opts = 0; |
| 1854 | if (val_opts & LYD_VALIDATE_NO_STATE) { |
| 1855 | impl_opts |= LYD_IMPLICIT_NO_STATE; |
| 1856 | } |
| 1857 | if (val_opts & LYD_VALIDATE_NO_DEFAULTS) { |
| 1858 | impl_opts |= LYD_IMPLICIT_NO_DEFAULTS; |
| 1859 | } |
Michal Vasko | 361391d | 2024-10-08 14:55:50 +0200 | [diff] [blame] | 1860 | if (validate_subtree) { |
| 1861 | r = lyd_new_implicit(lyd_parent(*first2), first2, NULL, mod, NULL, NULL, NULL, impl_opts, diff); |
| 1862 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1863 | } else { |
| 1864 | /* descendants will not be validated, create them all */ |
| 1865 | r = lyd_new_implicit_r(lyd_parent(*first2), first2, NULL, mod, node_when_p, node_types_p, ext_node_p, |
| 1866 | impl_opts, diff); |
| 1867 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1868 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1869 | |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 1870 | /* our first module node pointer may no longer be the first */ |
Michal Vasko | 598063b | 2021-07-19 11:39:05 +0200 | [diff] [blame] | 1871 | first = *first2; |
| 1872 | lyd_first_module_sibling(&first, mod); |
| 1873 | if (!first || (first == *tree)) { |
| 1874 | first2 = tree; |
| 1875 | } else { |
| 1876 | first2 = &first; |
Michal Vasko | d3bb12f | 2020-12-04 14:33:09 +0100 | [diff] [blame] | 1877 | } |
| 1878 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1879 | if (validate_subtree) { |
| 1880 | /* process nested nodes */ |
| 1881 | LY_LIST_FOR(*first2, iter) { |
Michal Vasko | 0e72b7a | 2021-07-16 14:53:27 +0200 | [diff] [blame] | 1882 | if (lyd_owner_module(iter) != mod) { |
| 1883 | break; |
| 1884 | } |
| 1885 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1886 | r = lyd_validate_subtree(iter, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p, |
| 1887 | val_opts, diff); |
| 1888 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1889 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1890 | } |
| 1891 | |
| 1892 | /* finish incompletely validated terminal values/attributes and when conditions */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1893 | r = lyd_validate_unres(first2, mod, LYD_TYPE_DATA_YANG, node_when_p, 0, node_types_p, meta_types_p, |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1894 | ext_node_p, ext_val_p, val_opts, diff); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1895 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1896 | |
Michal Vasko | 6b14c7e | 2023-11-09 12:08:14 +0100 | [diff] [blame] | 1897 | if (!(val_opts & LYD_VALIDATE_NOT_FINAL)) { |
| 1898 | /* perform final validation that assumes the data tree is final */ |
| 1899 | r = lyd_validate_final_r(*first2, NULL, NULL, mod, val_opts, 0, 0); |
| 1900 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
| 1901 | } |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1902 | } |
| 1903 | |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1904 | cleanup: |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1905 | ly_set_erase(&node_when, NULL); |
Michal Vasko | 3271138 | 2020-12-03 14:14:31 +0100 | [diff] [blame] | 1906 | ly_set_erase(&node_types, NULL); |
| 1907 | ly_set_erase(&meta_types, NULL); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1908 | ly_set_erase(&ext_node, free); |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1909 | ly_set_erase(&ext_val, free); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1910 | return rc; |
Michal Vasko | f03ed03 | 2020-03-04 13:31:44 +0100 | [diff] [blame] | 1911 | } |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1912 | |
Jan Kundrát | c53a7ec | 2021-12-09 16:01:19 +0100 | [diff] [blame] | 1913 | LIBYANG_API_DEF LY_ERR |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 1914 | lyd_validate_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t val_opts, struct lyd_node **diff) |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1915 | { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1916 | LY_CHECK_ARG_RET(NULL, tree, *tree || ctx, LY_EINVAL); |
Michal Vasko | 892f5bf | 2021-11-24 10:41:05 +0100 | [diff] [blame] | 1917 | LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, ctx, LY_EINVAL); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1918 | if (!ctx) { |
| 1919 | ctx = LYD_CTX(*tree); |
| 1920 | } |
| 1921 | if (diff) { |
| 1922 | *diff = NULL; |
| 1923 | } |
| 1924 | |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1925 | return lyd_validate(tree, NULL, ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff); |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1926 | } |
| 1927 | |
Jan Kundrát | c53a7ec | 2021-12-09 16:01:19 +0100 | [diff] [blame] | 1928 | LIBYANG_API_DEF LY_ERR |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 1929 | lyd_validate_module(struct lyd_node **tree, const struct lys_module *module, uint32_t val_opts, struct lyd_node **diff) |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1930 | { |
Michal Vasko | 6b14c7e | 2023-11-09 12:08:14 +0100 | [diff] [blame] | 1931 | LY_CHECK_ARG_RET(NULL, tree, module, !(val_opts & LYD_VALIDATE_PRESENT), LY_EINVAL); |
| 1932 | LY_CHECK_CTX_EQUAL_RET(*tree ? LYD_CTX(*tree) : NULL, module->ctx, LY_EINVAL); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1933 | if (diff) { |
| 1934 | *diff = NULL; |
| 1935 | } |
| 1936 | |
Michal Vasko | 6b14c7e | 2023-11-09 12:08:14 +0100 | [diff] [blame] | 1937 | return lyd_validate(tree, module, module->ctx, val_opts, 1, NULL, NULL, NULL, NULL, NULL, diff); |
| 1938 | } |
| 1939 | |
| 1940 | LIBYANG_API_DEF LY_ERR |
| 1941 | lyd_validate_module_final(struct lyd_node *tree, const struct lys_module *module, uint32_t val_opts) |
| 1942 | { |
| 1943 | LY_ERR r, rc = LY_SUCCESS; |
| 1944 | struct lyd_node *first; |
| 1945 | const struct lys_module *mod; |
| 1946 | uint32_t i = 0; |
| 1947 | |
| 1948 | LY_CHECK_ARG_RET(NULL, module, !(val_opts & (LYD_VALIDATE_PRESENT | LYD_VALIDATE_NOT_FINAL)), LY_EINVAL); |
Michal Vasko | 506fab4 | 2024-05-27 08:32:49 +0200 | [diff] [blame] | 1949 | LY_CHECK_CTX_EQUAL_RET(tree ? LYD_CTX(tree) : NULL, module->ctx, LY_EINVAL); |
Michal Vasko | 6b14c7e | 2023-11-09 12:08:14 +0100 | [diff] [blame] | 1950 | |
| 1951 | /* module is unchanged but we need to get the first module data node */ |
| 1952 | mod = lyd_mod_next_module(tree, module, module->ctx, &i, &first); |
| 1953 | assert(mod); |
| 1954 | |
| 1955 | /* perform final validation that assumes the data tree is final */ |
| 1956 | r = lyd_validate_final_r(first, NULL, NULL, mod, val_opts, 0, 0); |
| 1957 | LY_VAL_ERR_GOTO(r, rc = r, val_opts, cleanup); |
| 1958 | |
| 1959 | cleanup: |
| 1960 | return rc; |
Michal Vasko | b1b5c26 | 2020-03-05 14:29:47 +0100 | [diff] [blame] | 1961 | } |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1962 | |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1963 | /** |
| 1964 | * @brief Find nodes for merging an operation into data tree for validation. |
| 1965 | * |
| 1966 | * @param[in] op_tree Full operation data tree. |
| 1967 | * @param[in] op_node Operation node itself. |
| 1968 | * @param[in] tree Data tree to be merged into. |
| 1969 | * @param[out] op_subtree Operation subtree to merge. |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 1970 | * @param[out] tree_sibling Data tree sibling to merge next to, is set if @p tree_parent is NULL. |
| 1971 | * @param[out] tree_parent Data tree parent to merge into, is set if @p tree_sibling is NULL. |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1972 | */ |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1973 | static void |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 1974 | lyd_val_op_merge_find(const struct lyd_node *op_tree, const struct lyd_node *op_node, const struct lyd_node *tree, |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 1975 | struct lyd_node **op_subtree, struct lyd_node **tree_sibling, struct lyd_node **tree_parent) |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1976 | { |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1977 | const struct lyd_node *tree_iter, *op_iter; |
Michal Vasko | b10c93b | 2022-12-14 12:16:27 +0100 | [diff] [blame] | 1978 | struct lyd_node *match = NULL; |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1979 | uint32_t i, cur_depth, op_depth; |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1980 | |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 1981 | *op_subtree = NULL; |
| 1982 | *tree_sibling = NULL; |
| 1983 | *tree_parent = NULL; |
| 1984 | |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 1985 | /* learn op depth (top-level being depth 0) */ |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1986 | op_depth = 0; |
Michal Vasko | 9e68508 | 2021-01-29 14:49:09 +0100 | [diff] [blame] | 1987 | for (op_iter = op_node; op_iter != op_tree; op_iter = lyd_parent(op_iter)) { |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1988 | ++op_depth; |
| 1989 | } |
| 1990 | |
| 1991 | /* find where to merge op */ |
| 1992 | tree_iter = tree; |
| 1993 | cur_depth = op_depth; |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 1994 | while (cur_depth && tree_iter) { |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 1995 | /* find op iter in tree */ |
| 1996 | lyd_find_sibling_first(tree_iter, op_iter, &match); |
| 1997 | if (!match) { |
| 1998 | break; |
| 1999 | } |
| 2000 | |
| 2001 | /* move tree_iter */ |
Radek Krejci | a1c1e54 | 2020-09-29 16:06:52 +0200 | [diff] [blame] | 2002 | tree_iter = lyd_child(match); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 2003 | |
| 2004 | /* move depth */ |
| 2005 | --cur_depth; |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 2006 | |
| 2007 | /* find next op parent */ |
| 2008 | op_iter = op_node; |
| 2009 | for (i = 0; i < cur_depth; ++i) { |
Michal Vasko | 9e68508 | 2021-01-29 14:49:09 +0100 | [diff] [blame] | 2010 | op_iter = lyd_parent(op_iter); |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 2011 | } |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 2012 | } |
| 2013 | |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 2014 | assert(op_iter); |
Michal Vasko | bb84467 | 2020-07-03 11:06:12 +0200 | [diff] [blame] | 2015 | *op_subtree = (struct lyd_node *)op_iter; |
Michal Vasko | 2f03d22 | 2020-12-09 18:15:51 +0100 | [diff] [blame] | 2016 | if (!tree || tree_iter) { |
| 2017 | /* there is no tree whatsoever or this is the last found sibling */ |
| 2018 | *tree_sibling = (struct lyd_node *)tree_iter; |
| 2019 | } else { |
| 2020 | /* matching parent was found but it has no children to insert next to */ |
| 2021 | assert(match); |
| 2022 | *tree_parent = match; |
| 2023 | } |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2024 | } |
| 2025 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2026 | /** |
| 2027 | * @brief Validate an RPC/action request, reply, or notification. |
| 2028 | * |
| 2029 | * @param[in] op_tree Full operation data tree. |
| 2030 | * @param[in] op_node Operation node itself. |
| 2031 | * @param[in] dep_tree Tree to be used for validating references from the operation subtree. |
| 2032 | * @param[in] int_opts Internal parser options. |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2033 | * @param[in] data_type Type of validated data. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2034 | * @param[in] validate_subtree Whether subtree was already validated (as part of data parsing) or not (separate validation). |
| 2035 | * @param[in] node_when_p Set of nodes with when conditions, if NULL a local set is used. |
| 2036 | * @param[in] node_types_p Set of unres node types, if NULL a local set is used. |
| 2037 | * @param[in] meta_types_p Set of unres metadata types, if NULL a local set is used. |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2038 | * @param[in] ext_node_p Set of unres nodes with extensions to validate, if NULL a local set is used. |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 2039 | * @param[in] ext_val_p Set of parsed extension data to validate, if NULL a local set is used. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2040 | * @param[out] diff Optional diff with any changes made by the validation. |
| 2041 | * @return LY_SUCCESS on success. |
| 2042 | * @return LY_ERR error on error. |
| 2043 | */ |
| 2044 | static LY_ERR |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2045 | _lyd_validate_op(struct lyd_node *op_tree, struct lyd_node *op_node, const struct lyd_node *dep_tree, enum lyd_type data_type, |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 2046 | uint32_t int_opts, ly_bool validate_subtree, struct ly_set *node_when_p, struct ly_set *node_types_p, |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2047 | struct ly_set *meta_types_p, struct ly_set *ext_node_p, struct ly_set *ext_val_p, struct lyd_node **diff) |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2048 | { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2049 | LY_ERR rc = LY_SUCCESS; |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2050 | struct lyd_node *tree_sibling, *tree_parent, *op_subtree, *op_parent, *op_sibling_before, *op_sibling_after, *child; |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2051 | struct ly_set node_types = {0}, meta_types = {0}, node_when = {0}, ext_node = {0}, ext_val = {0}; |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2052 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2053 | assert(op_tree && op_node); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2054 | assert((node_when_p && node_types_p && meta_types_p && ext_node_p && ext_val_p) || |
| 2055 | (!node_when_p && !node_types_p && !meta_types_p && !ext_node_p && !ext_val_p)); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2056 | |
| 2057 | if (!node_when_p) { |
| 2058 | node_when_p = &node_when; |
| 2059 | node_types_p = &node_types; |
| 2060 | meta_types_p = &meta_types; |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2061 | ext_node_p = &ext_node; |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 2062 | ext_val_p = &ext_val; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2063 | } |
| 2064 | |
| 2065 | /* merge op_tree into dep_tree */ |
| 2066 | lyd_val_op_merge_find(op_tree, op_node, dep_tree, &op_subtree, &tree_sibling, &tree_parent); |
Michal Vasko | c61dd06 | 2022-06-07 11:01:28 +0200 | [diff] [blame] | 2067 | op_sibling_before = op_subtree->prev->next ? op_subtree->prev : NULL; |
| 2068 | op_sibling_after = op_subtree->next; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2069 | op_parent = lyd_parent(op_subtree); |
Michal Vasko | c61dd06 | 2022-06-07 11:01:28 +0200 | [diff] [blame] | 2070 | |
Michal Vasko | 2e784f8 | 2024-01-11 09:51:22 +0100 | [diff] [blame] | 2071 | lyd_unlink(op_subtree); |
aPiecek | 1462ab1 | 2024-02-07 09:13:29 +0100 | [diff] [blame] | 2072 | lyd_insert_node(tree_parent, &tree_sibling, op_subtree, LYD_INSERT_NODE_DEFAULT); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2073 | if (!dep_tree) { |
| 2074 | dep_tree = tree_sibling; |
| 2075 | } |
| 2076 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2077 | if (int_opts & LYD_INTOPT_REPLY) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2078 | if (validate_subtree) { |
Michal Vasko | 361391d | 2024-10-08 14:55:50 +0200 | [diff] [blame] | 2079 | /* add output children defaults */ |
| 2080 | rc = lyd_new_implicit(op_node, lyd_node_child_p(op_node), NULL, NULL, node_when_p, node_types_p, |
| 2081 | ext_node_p, LYD_IMPLICIT_OUTPUT, diff); |
| 2082 | LY_CHECK_GOTO(rc, cleanup); |
| 2083 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2084 | /* skip validating the operation itself, go to children directly */ |
| 2085 | LY_LIST_FOR(lyd_child(op_node), child) { |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 2086 | rc = lyd_validate_subtree(child, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff); |
Radek Krejci | 4f2e3e5 | 2021-03-30 14:20:28 +0200 | [diff] [blame] | 2087 | LY_CHECK_GOTO(rc, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2088 | } |
Michal Vasko | 361391d | 2024-10-08 14:55:50 +0200 | [diff] [blame] | 2089 | } else { |
| 2090 | /* add output children defaults and their descendants */ |
| 2091 | rc = lyd_new_implicit_r(op_node, lyd_node_child_p(op_node), NULL, NULL, node_when_p, node_types_p, |
| 2092 | ext_node_p, LYD_IMPLICIT_OUTPUT, diff); |
| 2093 | LY_CHECK_GOTO(rc, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2094 | } |
| 2095 | } else { |
| 2096 | if (validate_subtree) { |
| 2097 | /* prevalidate whole operation subtree */ |
Michal Vasko | 1a6e690 | 2022-08-26 08:35:09 +0200 | [diff] [blame] | 2098 | rc = lyd_validate_subtree(op_node, node_when_p, node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff); |
Radek Krejci | 4f2e3e5 | 2021-03-30 14:20:28 +0200 | [diff] [blame] | 2099 | LY_CHECK_GOTO(rc, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2100 | } |
| 2101 | } |
| 2102 | |
Michal Vasko | 906bafa | 2022-04-22 12:28:55 +0200 | [diff] [blame] | 2103 | /* finish incompletely validated terminal values/attributes and when conditions on the full tree, |
| 2104 | * account for unresolved 'when' that may appear in the non-validated dependency data tree */ |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2105 | LY_CHECK_GOTO(rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, node_when_p, LYXP_IGNORE_WHEN, |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2106 | node_types_p, meta_types_p, ext_node_p, ext_val_p, 0, diff), cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2107 | |
| 2108 | /* perform final validation of the operation/notification */ |
| 2109 | lyd_validate_obsolete(op_node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 2110 | LY_CHECK_GOTO(rc = lyd_validate_must(op_node, 0, int_opts, LYXP_IGNORE_WHEN), cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2111 | |
| 2112 | /* final validation of all the descendants */ |
Michal Vasko | 906bafa | 2022-04-22 12:28:55 +0200 | [diff] [blame] | 2113 | rc = lyd_validate_final_r(lyd_child(op_node), op_node, op_node->schema, NULL, 0, int_opts, LYXP_IGNORE_WHEN); |
| 2114 | LY_CHECK_GOTO(rc, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2115 | |
| 2116 | cleanup: |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2117 | /* restore operation tree */ |
Michal Vasko | 2e784f8 | 2024-01-11 09:51:22 +0100 | [diff] [blame] | 2118 | lyd_unlink(op_subtree); |
Michal Vasko | c61dd06 | 2022-06-07 11:01:28 +0200 | [diff] [blame] | 2119 | if (op_sibling_before) { |
aPiecek | 743184b | 2024-02-01 13:25:56 +0100 | [diff] [blame] | 2120 | lyd_insert_after_node(NULL, op_sibling_before, op_subtree); |
Michal Vasko | 123f1c0 | 2023-08-15 13:14:46 +0200 | [diff] [blame] | 2121 | lyd_insert_hash(op_subtree); |
Michal Vasko | c61dd06 | 2022-06-07 11:01:28 +0200 | [diff] [blame] | 2122 | } else if (op_sibling_after) { |
| 2123 | lyd_insert_before_node(op_sibling_after, op_subtree); |
Michal Vasko | 123f1c0 | 2023-08-15 13:14:46 +0200 | [diff] [blame] | 2124 | lyd_insert_hash(op_subtree); |
Michal Vasko | c61dd06 | 2022-06-07 11:01:28 +0200 | [diff] [blame] | 2125 | } else if (op_parent) { |
aPiecek | 1462ab1 | 2024-02-07 09:13:29 +0100 | [diff] [blame] | 2126 | lyd_insert_node(op_parent, NULL, op_subtree, LYD_INSERT_NODE_DEFAULT); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2127 | } |
| 2128 | |
| 2129 | ly_set_erase(&node_when, NULL); |
| 2130 | ly_set_erase(&node_types, NULL); |
| 2131 | ly_set_erase(&meta_types, NULL); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2132 | ly_set_erase(&ext_node, free); |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 2133 | ly_set_erase(&ext_val, free); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2134 | return rc; |
| 2135 | } |
| 2136 | |
Jan Kundrát | c53a7ec | 2021-12-09 16:01:19 +0100 | [diff] [blame] | 2137 | LIBYANG_API_DEF LY_ERR |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2138 | lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type, struct lyd_node **diff) |
| 2139 | { |
| 2140 | struct lyd_node *op_node; |
| 2141 | uint32_t int_opts; |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2142 | struct ly_set ext_val = {0}; |
| 2143 | LY_ERR rc; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2144 | |
Michal Vasko | 2da4569 | 2022-04-29 09:51:08 +0200 | [diff] [blame] | 2145 | LY_CHECK_ARG_RET(NULL, op_tree, !dep_tree || !dep_tree->parent, (data_type == LYD_TYPE_RPC_YANG) || |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 2146 | (data_type == LYD_TYPE_NOTIF_YANG) || (data_type == LYD_TYPE_REPLY_YANG), LY_EINVAL); |
Michal Vasko | 8104fd4 | 2020-07-13 11:09:51 +0200 | [diff] [blame] | 2147 | if (diff) { |
| 2148 | *diff = NULL; |
| 2149 | } |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 2150 | if (data_type == LYD_TYPE_RPC_YANG) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2151 | int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION; |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 2152 | } else if (data_type == LYD_TYPE_NOTIF_YANG) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2153 | int_opts = LYD_INTOPT_NOTIF; |
| 2154 | } else { |
| 2155 | int_opts = LYD_INTOPT_REPLY; |
| 2156 | } |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2157 | |
Michal Vasko | 2da4569 | 2022-04-29 09:51:08 +0200 | [diff] [blame] | 2158 | if (op_tree->schema && (op_tree->schema->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF))) { |
| 2159 | /* we have the operation/notification, adjust the pointers */ |
| 2160 | op_node = op_tree; |
| 2161 | while (op_tree->parent) { |
| 2162 | op_tree = lyd_parent(op_tree); |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2163 | } |
Michal Vasko | 2da4569 | 2022-04-29 09:51:08 +0200 | [diff] [blame] | 2164 | } else { |
| 2165 | /* find the operation/notification */ |
| 2166 | while (op_tree->parent) { |
| 2167 | op_tree = lyd_parent(op_tree); |
| 2168 | } |
| 2169 | LYD_TREE_DFS_BEGIN(op_tree, op_node) { |
| 2170 | if (!op_node->schema) { |
Michal Vasko | ac6f4be | 2022-05-02 10:16:50 +0200 | [diff] [blame] | 2171 | return lyd_parse_opaq_error(op_node); |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2172 | } else if (op_node->flags & LYD_EXT) { |
| 2173 | /* fully validate the rest using the extension instance callback */ |
| 2174 | LY_CHECK_RET(lyd_validate_nested_ext(op_node, &ext_val)); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2175 | rc = lyd_validate_unres((struct lyd_node **)&dep_tree, NULL, data_type, NULL, 0, NULL, NULL, NULL, |
| 2176 | &ext_val, 0, diff); |
Michal Vasko | fbbea93 | 2022-06-07 11:00:55 +0200 | [diff] [blame] | 2177 | ly_set_erase(&ext_val, free); |
| 2178 | return rc; |
Michal Vasko | 2da4569 | 2022-04-29 09:51:08 +0200 | [diff] [blame] | 2179 | } |
| 2180 | |
| 2181 | if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) && |
| 2182 | (op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) { |
| 2183 | break; |
| 2184 | } else if ((int_opts & LYD_INTOPT_NOTIF) && (op_node->schema->nodetype == LYS_NOTIF)) { |
| 2185 | break; |
| 2186 | } |
| 2187 | LYD_TREE_DFS_END(op_tree, op_node); |
| 2188 | } |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2189 | } |
Michal Vasko | 2da4569 | 2022-04-29 09:51:08 +0200 | [diff] [blame] | 2190 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2191 | if (int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_REPLY)) { |
Michal Vasko | 9b23208 | 2022-06-07 10:59:31 +0200 | [diff] [blame] | 2192 | if (!op_node || !(op_node->schema->nodetype & (LYS_RPC | LYS_ACTION))) { |
Michal Vasko | b7be7a8 | 2020-08-20 09:09:04 +0200 | [diff] [blame] | 2193 | LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No RPC/action to validate found."); |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2194 | return LY_EINVAL; |
| 2195 | } |
| 2196 | } else { |
Michal Vasko | 9b23208 | 2022-06-07 10:59:31 +0200 | [diff] [blame] | 2197 | if (!op_node || (op_node->schema->nodetype != LYS_NOTIF)) { |
Michal Vasko | b7be7a8 | 2020-08-20 09:09:04 +0200 | [diff] [blame] | 2198 | LOGERR(LYD_CTX(op_tree), LY_EINVAL, "No notification to validate found."); |
Michal Vasko | cb7526d | 2020-03-30 15:08:26 +0200 | [diff] [blame] | 2199 | return LY_EINVAL; |
| 2200 | } |
| 2201 | } |
| 2202 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 2203 | /* validate */ |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 2204 | return _lyd_validate_op(op_tree, op_node, dep_tree, data_type, int_opts, 1, NULL, NULL, NULL, NULL, NULL, diff); |
Michal Vasko | fea12c6 | 2020-03-30 11:00:15 +0200 | [diff] [blame] | 2205 | } |