blob: 1fbe07b2fe450ab9ba739c95ae2b8feaecfe63a0 [file] [log] [blame]
Michal Vasko004d3152020-06-11 19:59:22 +02001/**
2 * @file path.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief Path functions
5 *
6 * Copyright (c) 2020 CESNET, z.s.p.o.
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 */
14#define _ISOC99_SOURCE /* strtoull */
15
16#include "path.h"
17
18#include <assert.h>
19#include <ctype.h>
20#include <stdlib.h>
Radek Krejciad97c5f2020-06-30 09:19:28 +020021#include <string.h>
Michal Vasko004d3152020-06-11 19:59:22 +020022
23#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020024#include "compat.h"
Michal Vasko004d3152020-06-11 19:59:22 +020025#include "log.h"
26#include "plugins_types.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020027#include "set.h"
Michal Vasko4c583e82020-07-17 12:16:14 +020028#include "tree.h"
Michal Vasko004d3152020-06-11 19:59:22 +020029#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010030#include "tree_edit.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020031#include "tree_schema.h"
Michal Vasko004d3152020-06-11 19:59:22 +020032#include "tree_schema_internal.h"
33#include "xpath.h"
34
Radek Krejcic0c66412020-08-21 13:53:50 +020035#define LOGVAL_P(CTX, CUR_NODE, CODE, ...) ly_vlog(CTX, (CUR_NODE) ? LY_VLOG_LYSC : LY_VLOG_NONE, CUR_NODE, CODE, ##__VA_ARGS__)
Michal Vasko6b26e742020-07-17 15:02:10 +020036
Michal Vasko004d3152020-06-11 19:59:22 +020037/**
38 * @brief Check predicate syntax.
39 *
40 * @param[in] ctx libyang context.
Michal Vasko6b26e742020-07-17 15:02:10 +020041 * @param[in] cur_node Current (original context) node.
Michal Vasko004d3152020-06-11 19:59:22 +020042 * @param[in] exp Parsed predicate.
43 * @param[in,out] tok_idx Index in @p exp, is adjusted.
44 * @param[in] prefix Prefix option.
45 * @param[in] pred Predicate option.
46 * @return LY_ERR value.
47 */
48static LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +020049ly_path_check_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lyxp_expr *exp,
Radek Krejci0f969882020-08-21 16:56:47 +020050 uint16_t *tok_idx, uint8_t prefix, uint8_t pred)
Michal Vasko004d3152020-06-11 19:59:22 +020051{
Radek Krejciba03a5a2020-08-27 14:40:41 +020052 LY_ERR ret = LY_SUCCESS;
Michal Vasko004d3152020-06-11 19:59:22 +020053 struct ly_set *set = NULL;
54 uint32_t i;
55 const char *name;
56 size_t name_len;
57
Radek Krejciddace2c2021-01-08 11:30:56 +010058 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +010059
Michal Vasko004d3152020-06-11 19:59:22 +020060 if (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1)) {
Radek Krejcif6a11002020-08-21 13:29:07 +020061 /* '[' */
62
Michal Vasko69730152020-10-09 16:30:07 +020063 if (((pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_KEYS)) &&
64 !lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NAMETEST)) {
Radek Krejciba03a5a2020-08-27 14:40:41 +020065 ret = ly_set_new(&set);
66 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +020067
68 do {
69 /* NameTest is always expected here */
Radek Krejciba03a5a2020-08-27 14:40:41 +020070 LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NAMETEST), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +020071
72 /* check prefix based on the options */
73 name = strnstr(exp->expr + exp->tok_pos[*tok_idx], ":", exp->tok_len[*tok_idx]);
74 if ((prefix == LY_PATH_PREFIX_MANDATORY) && !name) {
Radek Krejci2efc45b2020-12-22 16:25:44 +010075 LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", exp->tok_len[*tok_idx],
Michal Vasko69730152020-10-09 16:30:07 +020076 exp->expr + exp->tok_pos[*tok_idx]);
Radek Krejciba03a5a2020-08-27 14:40:41 +020077 goto token_error;
Michal Vasko8b06a5e2020-08-06 12:13:08 +020078 } else if ((prefix == LY_PATH_PREFIX_STRICT_INHERIT) && name) {
Radek Krejci2efc45b2020-12-22 16:25:44 +010079 LOGVAL(ctx, LYVE_XPATH, "Redundant prefix for \"%.*s\" in path.", exp->tok_len[*tok_idx],
Michal Vasko69730152020-10-09 16:30:07 +020080 exp->expr + exp->tok_pos[*tok_idx]);
Radek Krejciba03a5a2020-08-27 14:40:41 +020081 goto token_error;
Michal Vasko004d3152020-06-11 19:59:22 +020082 }
83 if (!name) {
84 name = exp->expr + exp->tok_pos[*tok_idx];
85 name_len = exp->tok_len[*tok_idx];
86 } else {
87 ++name;
88 name_len = exp->tok_len[*tok_idx] - (name - (exp->expr + exp->tok_pos[*tok_idx]));
89 }
90
91 /* check whether it was not already specified */
92 for (i = 0; i < set->count; ++i) {
93 /* all the keys must be from the same module so this comparison should be fine */
94 if (!strncmp(set->objs[i], name, name_len) && !isalpha(((char *)set->objs[i])[name_len])) {
Radek Krejci422afb12021-03-04 16:38:16 +010095 LOGVAL(ctx, LYVE_XPATH, "Duplicate predicate key \"%.*s\" in path.", (int)name_len, name);
Radek Krejciba03a5a2020-08-27 14:40:41 +020096 goto token_error;
Michal Vasko004d3152020-06-11 19:59:22 +020097 }
98 }
99
100 /* add it into the set */
Radek Krejci3d92e442020-10-12 12:48:13 +0200101 ret = ly_set_add(set, (void *)name, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200102 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200103
104 /* NameTest */
105 ++(*tok_idx);
106
107 /* '=' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200108 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200109
110 /* Literal */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200111 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_LITERAL), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200112
113 /* ']' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200114 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200115
Radek Krejci0f969882020-08-21 16:56:47 +0200116 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +0200117 } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1));
118
Michal Vasko004d3152020-06-11 19:59:22 +0200119 } else if ((pred == LY_PATH_PRED_SIMPLE) && !lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_DOT)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200120 /* '.' */
121
Michal Vasko004d3152020-06-11 19:59:22 +0200122 /* '=' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200123 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200124
125 /* Literal */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200126 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_LITERAL), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200127
128 /* ']' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200129 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200130
Michal Vasko004d3152020-06-11 19:59:22 +0200131 } else if ((pred == LY_PATH_PRED_SIMPLE) && !lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_NUMBER)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200132 /* Number */
Michal Vasko004d3152020-06-11 19:59:22 +0200133
134 /* ']' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200135 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200136
137 } else if ((pred == LY_PATH_PRED_LEAFREF) && !lyxp_check_token(NULL, exp, *tok_idx, LYXP_TOKEN_NAMETEST)) {
138 assert(prefix == LY_PATH_PREFIX_OPTIONAL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200139 ret = ly_set_new(&set);
140 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200141
142 do {
143 /* NameTest is always expected here */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200144 LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_NAMETEST), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200145
146 name = strnstr(exp->expr + exp->tok_pos[*tok_idx], ":", exp->tok_len[*tok_idx]);
147 if (!name) {
148 name = exp->expr + exp->tok_pos[*tok_idx];
149 name_len = exp->tok_len[*tok_idx];
150 } else {
151 ++name;
152 name_len = exp->tok_len[*tok_idx] - (name - (exp->expr + exp->tok_pos[*tok_idx]));
153 }
154
155 /* check whether it was not already specified */
156 for (i = 0; i < set->count; ++i) {
157 /* all the keys must be from the same module so this comparison should be fine */
158 if (!strncmp(set->objs[i], name, name_len) && !isalpha(((char *)set->objs[i])[name_len])) {
Radek Krejci422afb12021-03-04 16:38:16 +0100159 LOGVAL(ctx, LYVE_XPATH, "Duplicate predicate key \"%.*s\" in path.", (int)name_len, name);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200160 goto token_error;
Michal Vasko004d3152020-06-11 19:59:22 +0200161 }
162 }
163
164 /* add it into the set */
Radek Krejci3d92e442020-10-12 12:48:13 +0200165 ret = ly_set_add(set, (void *)name, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200166 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200167
168 /* NameTest */
169 ++(*tok_idx);
170
171 /* '=' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200172 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_EQUAL), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200173
174 /* FuncName */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200175 LY_CHECK_GOTO(lyxp_check_token(ctx, exp, *tok_idx, LYXP_TOKEN_FUNCNAME), token_error);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100176 if ((exp->tok_len[*tok_idx] != ly_strlen_const("current")) ||
177 strncmp(exp->expr + exp->tok_pos[*tok_idx], "current", ly_strlen_const("current"))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100178 LOGVAL(ctx, LYVE_XPATH, "Invalid function \"%.*s\" invocation in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200179 exp->tok_len[*tok_idx], exp->expr + exp->tok_pos[*tok_idx]);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200180 goto token_error;
Michal Vasko004d3152020-06-11 19:59:22 +0200181 }
182 ++(*tok_idx);
183
184 /* '(' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200185 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_PAR1), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200186
187 /* ')' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200188 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_PAR2), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200189
190 /* '/' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200191 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_PATH), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200192
193 /* '..' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200194 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_DDOT), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200195 do {
196 /* '/' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200197 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_OPER_PATH), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200198 } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_DDOT));
199
200 /* NameTest */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200201 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200202
203 /* '/' */
204 while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_OPER_PATH)) {
205 /* NameTest */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200206 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200207 }
208
209 /* ']' */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200210 LY_CHECK_GOTO(lyxp_next_token(ctx, exp, tok_idx, LYXP_TOKEN_BRACK2), token_error);
Michal Vasko004d3152020-06-11 19:59:22 +0200211
Radek Krejci0f969882020-08-21 16:56:47 +0200212 /* '[' */
Michal Vasko004d3152020-06-11 19:59:22 +0200213 } while (!lyxp_next_token(NULL, exp, tok_idx, LYXP_TOKEN_BRACK1));
214
215 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100216 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(exp->tokens[*tok_idx]), exp->expr + exp->tok_pos[*tok_idx]);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200217 goto token_error;
Michal Vasko004d3152020-06-11 19:59:22 +0200218 }
219 }
220
Radek Krejciba03a5a2020-08-27 14:40:41 +0200221cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100222 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200223 ly_set_free(set, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200224 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200225
Radek Krejciba03a5a2020-08-27 14:40:41 +0200226token_error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100227 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200228 ly_set_free(set, NULL);
229 return LY_EVALID;
230}
231
232LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +0200233ly_path_parse(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *str_path, size_t path_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200234 uint8_t begin, uint8_t lref, uint8_t prefix, uint8_t pred, struct lyxp_expr **expr)
Michal Vasko004d3152020-06-11 19:59:22 +0200235{
Radek Krejcif03a9e22020-09-18 20:09:31 +0200236 LY_ERR ret = LY_SUCCESS;
237 struct lyxp_expr *exp = NULL;
Michal Vasko8b06a5e2020-08-06 12:13:08 +0200238 uint16_t tok_idx, cur_len;
239 const char *cur_node, *prev_prefix = NULL, *ptr;
Michal Vasko004d3152020-06-11 19:59:22 +0200240
241 assert((begin == LY_PATH_BEGIN_ABSOLUTE) || (begin == LY_PATH_BEGIN_EITHER));
242 assert((lref == LY_PATH_LREF_TRUE) || (lref == LY_PATH_LREF_FALSE));
Michal Vasko69730152020-10-09 16:30:07 +0200243 assert((prefix == LY_PATH_PREFIX_OPTIONAL) || (prefix == LY_PATH_PREFIX_MANDATORY) ||
244 (prefix == LY_PATH_PREFIX_STRICT_INHERIT));
Michal Vasko004d3152020-06-11 19:59:22 +0200245 assert((pred == LY_PATH_PRED_KEYS) || (pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_LEAFREF));
246
Radek Krejciddace2c2021-01-08 11:30:56 +0100247 LOG_LOCSET(ctx_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100248
Michal Vasko004d3152020-06-11 19:59:22 +0200249 /* parse as a generic XPath expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200250 LY_CHECK_GOTO(ret = lyxp_expr_parse(ctx, str_path, path_len, 1, &exp), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200251 tok_idx = 0;
252
253 if (begin == LY_PATH_BEGIN_EITHER) {
254 /* is the path relative? */
255 if (lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_OPER_PATH)) {
Michal Vaskocb8c6d42020-10-16 11:58:30 +0200256 /* relative path check specific to leafref */
257 if (lref == LY_PATH_LREF_TRUE) {
258 /* mandatory '..' */
259 LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_DDOT), ret = LY_EVALID, error);
260
261 do {
262 /* '/' */
263 LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_OPER_PATH), ret = LY_EVALID, error);
264
265 /* optional '..' */
266 } while (!lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_DDOT));
Michal Vasko004d3152020-06-11 19:59:22 +0200267 }
268 }
269 } else {
270 /* '/' */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200271 LY_CHECK_ERR_GOTO(lyxp_next_token(ctx, exp, &tok_idx, LYXP_TOKEN_OPER_PATH), ret = LY_EVALID, error);
Michal Vasko004d3152020-06-11 19:59:22 +0200272 }
273
274 do {
275 /* NameTest */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200276 LY_CHECK_ERR_GOTO(lyxp_check_token(ctx, exp, tok_idx, LYXP_TOKEN_NAMETEST), ret = LY_EVALID, error);
Michal Vasko004d3152020-06-11 19:59:22 +0200277
278 /* check prefix based on the options */
Michal Vasko8b06a5e2020-08-06 12:13:08 +0200279 cur_node = exp->expr + exp->tok_pos[tok_idx];
280 cur_len = exp->tok_len[tok_idx];
281 if (prefix == LY_PATH_PREFIX_MANDATORY) {
282 if (!strnstr(cur_node, ":", cur_len)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100283 LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", cur_len, cur_node);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200284 ret = LY_EVALID;
Michal Vasko8b06a5e2020-08-06 12:13:08 +0200285 goto error;
286 }
287 } else if (prefix == LY_PATH_PREFIX_STRICT_INHERIT) {
288 if (!prev_prefix) {
289 /* the first node must have a prefix */
290 if (!strnstr(cur_node, ":", cur_len)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100291 LOGVAL(ctx, LYVE_XPATH, "Prefix missing for \"%.*s\" in path.", cur_len, cur_node);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200292 ret = LY_EVALID;
Michal Vasko8b06a5e2020-08-06 12:13:08 +0200293 goto error;
294 }
295
296 /* remember the first prefix */
297 prev_prefix = cur_node;
298 } else {
299 /* the prefix must be different, if any */
300 ptr = strnstr(cur_node, ":", cur_len);
301 if (ptr) {
302 if (!strncmp(prev_prefix, cur_node, ptr - cur_node) && (prev_prefix[ptr - cur_node] == ':')) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100303 LOGVAL(ctx, LYVE_XPATH, "Duplicate prefix for \"%.*s\" in path.", cur_len, cur_node);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200304 ret = LY_EVALID;
Michal Vasko8b06a5e2020-08-06 12:13:08 +0200305 goto error;
306 }
307
308 /* remember this next prefix */
309 prev_prefix = cur_node;
310 }
311 }
Michal Vasko004d3152020-06-11 19:59:22 +0200312 }
313
314 ++tok_idx;
315
316 /* Predicate* */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200317 LY_CHECK_GOTO(ret = ly_path_check_predicate(ctx, ctx_node, exp, &tok_idx, prefix, pred), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200318
Radek Krejci0f969882020-08-21 16:56:47 +0200319 /* '/' */
Michal Vasko004d3152020-06-11 19:59:22 +0200320 } while (!lyxp_next_token(NULL, exp, &tok_idx, LYXP_TOKEN_OPER_PATH));
321
322 /* trailing token check */
323 if (exp->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100324 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of path.", exp->expr + exp->tok_pos[tok_idx]);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200325 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +0200326 goto error;
327 }
328
329 *expr = exp;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100330
Radek Krejciddace2c2021-01-08 11:30:56 +0100331 LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200332 return LY_SUCCESS;
333
334error:
335 lyxp_expr_free(ctx, exp);
Radek Krejciddace2c2021-01-08 11:30:56 +0100336 LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200337 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200338}
339
340LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +0200341ly_path_parse_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const char *str_path,
Radek Krejci0f969882020-08-21 16:56:47 +0200342 size_t path_len, uint8_t prefix, uint8_t pred, struct lyxp_expr **expr)
Michal Vasko004d3152020-06-11 19:59:22 +0200343{
Radek Krejcif03a9e22020-09-18 20:09:31 +0200344 LY_ERR ret = LY_SUCCESS;
345 struct lyxp_expr *exp = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +0200346 uint16_t tok_idx;
347
348 assert((prefix == LY_PATH_PREFIX_OPTIONAL) || (prefix == LY_PATH_PREFIX_MANDATORY));
349 assert((pred == LY_PATH_PRED_KEYS) || (pred == LY_PATH_PRED_SIMPLE) || (pred == LY_PATH_PRED_LEAFREF));
350
Radek Krejciddace2c2021-01-08 11:30:56 +0100351 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100352
Michal Vasko004d3152020-06-11 19:59:22 +0200353 /* parse as a generic XPath expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200354 LY_CHECK_GOTO(ret = lyxp_expr_parse(ctx, str_path, path_len, 0, &exp), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200355 tok_idx = 0;
356
Radek Krejcif03a9e22020-09-18 20:09:31 +0200357 LY_CHECK_GOTO(ret = ly_path_check_predicate(ctx, cur_node, exp, &tok_idx, prefix, pred), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200358
359 /* trailing token check */
360 if (exp->used > tok_idx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100361 LOGVAL(ctx, LYVE_XPATH, "Unparsed characters \"%s\" left at the end of predicate.",
Michal Vasko69730152020-10-09 16:30:07 +0200362 exp->expr + exp->tok_pos[tok_idx]);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200363 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +0200364 goto error;
365 }
366
367 *expr = exp;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100368
Radek Krejciddace2c2021-01-08 11:30:56 +0100369 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200370 return LY_SUCCESS;
371
372error:
373 lyxp_expr_free(ctx, exp);
Radek Krejciddace2c2021-01-08 11:30:56 +0100374 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200375 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200376}
377
378/**
379 * @brief Parse prefix from a NameTest, if any, and node name, and return expected module of the node.
380 *
Michal Vasko00cbf532020-06-15 13:58:47 +0200381 * @param[in] ctx libyang context.
Michal Vasko6b26e742020-07-17 15:02:10 +0200382 * @param[in] cur_node Optional current (original context) node.
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200383 * @param[in] cur_mod Current module of the path (where the path is "instantiated"). Needed for ::LY_PREF_SCHEMA*.
384 * @param[in] prev_ctx_node Previous context node. Needed for ::LY_PREF_JSON.
Michal Vasko004d3152020-06-11 19:59:22 +0200385 * @param[in] expr Parsed path.
386 * @param[in] tok_idx Index in @p expr.
387 * @param[in] lref Lref option.
Michal Vasko004d3152020-06-11 19:59:22 +0200388 * @param[in] format Format of the path.
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200389 * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
Michal Vasko004d3152020-06-11 19:59:22 +0200390 * @param[out] mod Resolved module.
391 * @param[out] name Parsed node name.
392 * @param[out] name_len Length of @p name.
393 * @return LY_ERR value.
394 */
395static LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +0200396ly_path_compile_prefix(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200397 const struct lysc_node *prev_ctx_node, const struct lyxp_expr *expr, uint16_t tok_idx, uint8_t lref,
Radek Krejci8df109d2021-04-23 12:19:08 +0200398 LY_VALUE_FORMAT format, void *prefix_data, struct lys_glob_unres *unres, const struct lys_module **mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100399 const char **name, size_t *name_len)
Michal Vasko004d3152020-06-11 19:59:22 +0200400{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100401 LY_ERR ret;
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200402 const char *pref;
Michal Vasko004d3152020-06-11 19:59:22 +0200403 size_t len;
404
405 assert(expr->tokens[tok_idx] == LYXP_TOKEN_NAMETEST);
406
407 /* get prefix */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200408 if ((pref = strnstr(expr->expr + expr->tok_pos[tok_idx], ":", expr->tok_len[tok_idx]))) {
409 len = pref - (expr->expr + expr->tok_pos[tok_idx]);
410 pref = expr->expr + expr->tok_pos[tok_idx];
411 } else {
412 len = 0;
413 }
Michal Vasko004d3152020-06-11 19:59:22 +0200414
415 /* find next node module */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200416 if (pref) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100417 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100418
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200419 *mod = ly_resolve_prefix(ctx, pref, len, format, prefix_data);
Michal Vasko004d3152020-06-11 19:59:22 +0200420 if (!*mod) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100421 LOGVAL(ctx, LYVE_XPATH, "No module connected with the prefix \"%.*s\" found (prefix format %s).",
Radek Krejci422afb12021-03-04 16:38:16 +0100422 (int)len, pref, ly_format2str(format));
Michal Vasko825a0442021-04-16 16:11:53 +0200423 ret = LY_EVALID;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100424 goto error;
Michal Vasko004d3152020-06-11 19:59:22 +0200425 } else if (!(*mod)->implemented) {
426 if (lref == LY_PATH_LREF_FALSE) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100427 LOGVAL(ctx, LYVE_XPATH, "Not implemented module \"%s\" in path.", (*mod)->name);
Michal Vasko825a0442021-04-16 16:11:53 +0200428 ret = LY_EVALID;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100429 goto error;
Michal Vasko004d3152020-06-11 19:59:22 +0200430 }
Michal Vasko825a0442021-04-16 16:11:53 +0200431
Michal Vaskob3e22532021-02-03 10:50:04 +0100432 assert(unres);
Michal Vasko69827502021-04-22 09:15:23 +0200433 LY_CHECK_GOTO(ret = lys_set_implemented_r((struct lys_module *)*mod, NULL, unres), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200434 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100435
Radek Krejciddace2c2021-01-08 11:30:56 +0100436 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200437 } else {
438 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200439 case LY_VALUE_SCHEMA:
440 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200441 if (!cur_mod) {
442 LOGINT_RET(ctx);
443 }
444 /* use current module */
Michal Vasko004d3152020-06-11 19:59:22 +0200445 *mod = cur_mod;
446 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200447 case LY_VALUE_JSON:
Michal Vasko004d3152020-06-11 19:59:22 +0200448 if (!prev_ctx_node) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200449 LOGINT_RET(ctx);
Michal Vasko004d3152020-06-11 19:59:22 +0200450 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200451 /* inherit module of the previous node */
Michal Vasko004d3152020-06-11 19:59:22 +0200452 *mod = prev_ctx_node->module;
453 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200454 case LY_VALUE_XML:
Michal Vasko004d3152020-06-11 19:59:22 +0200455 /* not really defined */
Michal Vasko00cbf532020-06-15 13:58:47 +0200456 LOGINT_RET(ctx);
Michal Vasko004d3152020-06-11 19:59:22 +0200457 }
458 }
459
460 /* set name */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200461 if (pref) {
462 *name = pref + len + 1;
Michal Vasko004d3152020-06-11 19:59:22 +0200463 *name_len = expr->tok_len[tok_idx] - len - 1;
464 } else {
465 *name = expr->expr + expr->tok_pos[tok_idx];
466 *name_len = expr->tok_len[tok_idx];
467 }
468
469 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100470
471error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100472 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko825a0442021-04-16 16:11:53 +0200473 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200474}
475
476LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +0200477ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
Radek Krejci8df109d2021-04-23 12:19:08 +0200478 const struct lysc_node *ctx_node, const struct lyxp_expr *expr, uint16_t *tok_idx, LY_VALUE_FORMAT format,
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200479 void *prefix_data, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vasko004d3152020-06-11 19:59:22 +0200480{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100481 LY_ERR ret = LY_SUCCESS;
Michal Vasko004d3152020-06-11 19:59:22 +0200482 struct ly_path_predicate *p;
483 const struct lysc_node *key;
Radek Krejci2b18bf12020-11-06 11:20:20 +0100484 const struct lys_module *mod = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +0200485 const char *name;
486 size_t name_len, key_count;
487
Michal Vasko00cbf532020-06-15 13:58:47 +0200488 assert(ctx && ctx_node);
489
Radek Krejciddace2c2021-01-08 11:30:56 +0100490 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100491
Michal Vasko004d3152020-06-11 19:59:22 +0200492 *pred_type = 0;
493
Michal Vasko004d3152020-06-11 19:59:22 +0200494 if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200495 /* '[', no predicate */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100496 goto cleanup; /* LY_SUCCESS */
Michal Vasko004d3152020-06-11 19:59:22 +0200497 }
498
499 if (expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST) {
500 if (ctx_node->nodetype != LYS_LIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100501 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200502 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100503 ret = LY_EVALID;
504 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200505 } else if (ctx_node->flags & LYS_KEYLESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100506 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200507 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100508 ret = LY_EVALID;
509 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200510 }
511
512 do {
513 /* NameTest, find the key */
Michal Vasko6b26e742020-07-17 15:02:10 +0200514 LY_CHECK_RET(ly_path_compile_prefix(ctx, cur_node, cur_mod, ctx_node, expr, *tok_idx, LY_PATH_LREF_FALSE,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100515 format, prefix_data, NULL, &mod, &name, &name_len));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100516 key = lys_find_child(ctx_node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200517 if (!key) {
Radek Krejci422afb12021-03-04 16:38:16 +0100518 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100519 ret = LY_ENOTFOUND;
520 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200521 } else if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100522 LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.", lys_nodetype2str(key->nodetype),
523 key->name);
524 ret = LY_EVALID;
525 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200526 }
527 ++(*tok_idx);
528
Michal Vasko004d3152020-06-11 19:59:22 +0200529 if (!*pred_type) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200530 /* new predicate */
Michal Vasko004d3152020-06-11 19:59:22 +0200531 *pred_type = LY_PATH_PREDTYPE_LIST;
532 }
533 assert(*pred_type == LY_PATH_PREDTYPE_LIST);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100534 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200535 p->key = key;
536
537 /* '=' */
538 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
539 ++(*tok_idx);
540
541 /* Literal */
542 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100543 LOG_LOCSET(key, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100544 ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaf *)key)->type,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200545 expr->expr + expr->tok_pos[*tok_idx] + 1, expr->tok_len[*tok_idx] - 2, NULL, format, prefix_data,
Radek Krejci2efc45b2020-12-22 16:25:44 +0100546 LYD_HINT_DATA, key, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100547 LOG_LOCBACK(key ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100548 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200549 ++(*tok_idx);
550
Michal Vaskoae875662020-10-21 10:33:17 +0200551 /* "allocate" the type to avoid problems when freeing the value after the type was freed */
552 ++((struct lysc_type *)p->value.realtype)->refcount;
553
Michal Vasko004d3152020-06-11 19:59:22 +0200554 /* ']' */
555 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
556 ++(*tok_idx);
557
558 /* another predicate follows? */
559 } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
560
561 /* check that all keys were set */
562 key_count = 0;
Michal Vasko544e58a2021-01-28 14:33:41 +0100563 for (key = lysc_node_child(ctx_node); key && (key->flags & LYS_KEY); key = key->next) {
Michal Vasko004d3152020-06-11 19:59:22 +0200564 ++key_count;
565 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200566 if (LY_ARRAY_COUNT(*predicates) != key_count) {
Michal Vasko004d3152020-06-11 19:59:22 +0200567 /* names (keys) are unique - it was checked when parsing */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100568 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for a key of %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200569 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200570 ly_path_predicates_free(ctx, LY_PATH_PREDTYPE_LIST, *predicates);
Michal Vasko004d3152020-06-11 19:59:22 +0200571 *predicates = NULL;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100572 ret = LY_EVALID;
573 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200574 }
575
576 } else if (expr->tokens[*tok_idx] == LYXP_TOKEN_DOT) {
577 if (ctx_node->nodetype != LYS_LEAFLIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100578 LOGVAL(ctx, LYVE_XPATH, "Leaf-list predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200579 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100580 ret = LY_EVALID;
581 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200582 }
583 ++(*tok_idx);
584
585 /* new predicate */
586 *pred_type = LY_PATH_PREDTYPE_LEAFLIST;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100587 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200588
589 /* '=' */
590 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
591 ++(*tok_idx);
592
593 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL);
594 /* store the value */
Radek Krejciddace2c2021-01-08 11:30:56 +0100595 LOG_LOCSET(ctx_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100596 ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaflist *)ctx_node)->type,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200597 expr->expr + expr->tok_pos[*tok_idx] + 1, expr->tok_len[*tok_idx] - 2, NULL, format, prefix_data,
Radek Krejci2efc45b2020-12-22 16:25:44 +0100598 LYD_HINT_DATA, ctx_node, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100599 LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100600 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200601 ++(*tok_idx);
602
Michal Vaskoae875662020-10-21 10:33:17 +0200603 /* "allocate" the type to avoid problems when freeing the value after the type was freed */
604 ++((struct lysc_type *)p->value.realtype)->refcount;
605
Michal Vasko004d3152020-06-11 19:59:22 +0200606 /* ']' */
607 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
608 ++(*tok_idx);
609 } else {
610 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NUMBER);
611 if (!(ctx_node->nodetype & (LYS_LEAFLIST | LYS_LIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100612 ret = LY_EVALID;
613 LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200614 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100615 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200616 } else if (ctx_node->flags & LYS_CONFIG_W) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100617 ret = LY_EVALID;
618 LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for configuration %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200619 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100620 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200621 }
Michal Vasko004d3152020-06-11 19:59:22 +0200622
623 /* new predicate */
624 *pred_type = LY_PATH_PREDTYPE_POSITION;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100625 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200626
627 /* syntax was already checked */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100628 p->position = strtoull(expr->expr + expr->tok_pos[*tok_idx], (char **)&name, LY_BASE_DEC);
Michal Vasko00cbf532020-06-15 13:58:47 +0200629 ++(*tok_idx);
Michal Vasko004d3152020-06-11 19:59:22 +0200630
631 /* ']' */
632 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
633 ++(*tok_idx);
634 }
635
Radek Krejci2efc45b2020-12-22 16:25:44 +0100636cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100637 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100638 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200639}
640
641/**
642 * @brief Compile leafref predicate. Actually, it is only checked.
643 *
644 * @param[in] ctx_node Context node, node for which the predicate is defined.
645 * @param[in] cur_node Current (original context) node.
646 * @param[in] expr Parsed path.
647 * @param[in,out] tok_idx Index in @p expr, is adjusted for parsed tokens.
Michal Vasko004d3152020-06-11 19:59:22 +0200648 * @param[in] format Format of the path.
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200649 * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
Michal Vasko405cc9e2020-12-01 12:01:27 +0100650 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko004d3152020-06-11 19:59:22 +0200651 * @return LY_ERR value.
652 */
653static LY_ERR
654ly_path_compile_predicate_leafref(const struct lysc_node *ctx_node, const struct lysc_node *cur_node,
Radek Krejci8df109d2021-04-23 12:19:08 +0200655 const struct lyxp_expr *expr, uint16_t *tok_idx, LY_VALUE_FORMAT format, void *prefix_data,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100656 struct lys_glob_unres *unres)
Michal Vasko004d3152020-06-11 19:59:22 +0200657{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100658 LY_ERR ret = LY_SUCCESS;
Michal Vasko004d3152020-06-11 19:59:22 +0200659 const struct lysc_node *key, *node, *node2;
660 const struct lys_module *mod;
661 const char *name;
662 size_t name_len;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100663 struct ly_ctx *ctx = cur_node->module->ctx;
664
Radek Krejciddace2c2021-01-08 11:30:56 +0100665 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Michal Vasko004d3152020-06-11 19:59:22 +0200666
Michal Vasko004d3152020-06-11 19:59:22 +0200667 if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200668 /* '[', no predicate */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100669 goto cleanup; /* LY_SUCCESS */
Michal Vasko004d3152020-06-11 19:59:22 +0200670 }
671
672 if (ctx_node->nodetype != LYS_LIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100673 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200674 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100675 ret = LY_EVALID;
676 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200677 } else if (ctx_node->flags & LYS_KEYLESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100678 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200679 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100680 ret = LY_EVALID;
681 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200682 }
683
684 do {
685 /* NameTest, find the key */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100686 ret = ly_path_compile_prefix(ctx, cur_node, cur_node->module, ctx_node, expr, *tok_idx,
687 LY_PATH_LREF_TRUE, format, prefix_data, unres, &mod, &name, &name_len);
688 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100689 key = lys_find_child(ctx_node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200690 if (!key) {
Radek Krejci422afb12021-03-04 16:38:16 +0100691 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100692 ret = LY_EVALID;
693 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200694 } else if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100695 LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200696 lys_nodetype2str(key->nodetype), key->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100697 ret = LY_EVALID;
698 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200699 }
700 ++(*tok_idx);
701
702 /* we are not actually compiling, throw the key away */
703 (void)key;
704
705 /* '=' */
706 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
707 ++(*tok_idx);
708
709 /* FuncName */
710 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_FUNCNAME);
711 ++(*tok_idx);
712
713 /* evaluating from the "current()" node */
714 node = cur_node;
715
716 /* '(' */
717 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
718 ++(*tok_idx);
719
720 /* ')' */
721 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
722 ++(*tok_idx);
723
724 do {
725 /* '/' */
726 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
727 ++(*tok_idx);
728
729 /* go to parent */
730 if (!node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100731 LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
732 ret = LY_EVALID;
733 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200734 }
735 node = lysc_data_parent(node);
736
737 /* '..' */
738 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_DDOT);
739 ++(*tok_idx);
740 } while (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_DDOT);
741
742 do {
743 /* '/' */
744 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
745 ++(*tok_idx);
746
747 /* NameTest */
748 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100749 LY_CHECK_RET(ly_path_compile_prefix(ctx, cur_node, cur_node->module, node, expr, *tok_idx,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100750 LY_PATH_LREF_TRUE, format, prefix_data, unres, &mod, &name, &name_len));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100751 node2 = lys_find_child(node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200752 if (!node2) {
Radek Krejci422afb12021-03-04 16:38:16 +0100753 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100754 ret = LY_EVALID;
755 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200756 }
757 node = node2;
758 ++(*tok_idx);
759 } while ((*tok_idx + 1 < expr->used) && (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_NAMETEST));
760
761 /* check the last target node */
762 if (node->nodetype != LYS_LEAF) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100763 LOGVAL(ctx, LYVE_XPATH, "Leaf expected instead of %s \"%s\" in leafref predicate in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200764 lys_nodetype2str(node->nodetype), node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100765 ret = LY_EVALID;
766 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200767 }
768
769 /* we are not actually compiling, throw the rightside node away */
770 (void)node;
771
772 /* ']' */
773 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
774 ++(*tok_idx);
775
Radek Krejci0f969882020-08-21 16:56:47 +0200776 /* another predicate follows? */
Michal Vasko004d3152020-06-11 19:59:22 +0200777 } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
778
Radek Krejci2efc45b2020-12-22 16:25:44 +0100779cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100780 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100781 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200782}
783
784LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +0200785ly_path_compile(const struct ly_ctx *ctx, const struct lys_module *cur_mod, const struct lysc_node *ctx_node,
Radek Krejcid5d37432021-03-12 13:46:40 +0100786 const struct lysc_ext_instance *ext, const struct lyxp_expr *expr, uint8_t lref, uint8_t oper, uint8_t target,
Radek Krejci8df109d2021-04-23 12:19:08 +0200787 LY_VALUE_FORMAT format, void *prefix_data, struct lys_glob_unres *unres, struct ly_path **path)
Michal Vasko004d3152020-06-11 19:59:22 +0200788{
789 LY_ERR ret = LY_SUCCESS;
790 uint16_t tok_idx = 0;
Radek Krejci2b18bf12020-11-06 11:20:20 +0100791 const struct lys_module *mod = NULL;
Michal Vasko6b26e742020-07-17 15:02:10 +0200792 const struct lysc_node *node2, *cur_node, *op;
Michal Vasko00cbf532020-06-15 13:58:47 +0200793 struct ly_path *p = NULL;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200794 uint32_t getnext_opts;
Michal Vasko004d3152020-06-11 19:59:22 +0200795 const char *name;
796 size_t name_len;
797
Michal Vasko00cbf532020-06-15 13:58:47 +0200798 assert(ctx);
Michal Vasko6b26e742020-07-17 15:02:10 +0200799 assert((lref == LY_PATH_LREF_FALSE) || ctx_node);
Michal Vasko004d3152020-06-11 19:59:22 +0200800 assert((lref == LY_PATH_LREF_TRUE) || (lref == LY_PATH_LREF_FALSE));
Michal Vasko00cbf532020-06-15 13:58:47 +0200801 assert((oper == LY_PATH_OPER_INPUT) || (oper == LY_PATH_OPER_OUTPUT));
802 assert((target == LY_PATH_TARGET_SINGLE) || (target == LY_PATH_TARGET_MANY));
Michal Vasko004d3152020-06-11 19:59:22 +0200803
Michal Vasko6b26e742020-07-17 15:02:10 +0200804 /* find operation, if we are in any */
Radek Krejci1e008d22020-08-17 11:37:37 +0200805 for (op = ctx_node; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +0200806
Radek Krejci2efc45b2020-12-22 16:25:44 +0100807 *path = NULL;
808
Michal Vasko6b26e742020-07-17 15:02:10 +0200809 /* remember original context node */
810 cur_node = ctx_node;
Radek Krejciddace2c2021-01-08 11:30:56 +0100811 LOG_LOCINIT(cur_node, NULL, NULL, NULL);
Michal Vasko004d3152020-06-11 19:59:22 +0200812
Michal Vasko00cbf532020-06-15 13:58:47 +0200813 if (oper == LY_PATH_OPER_OUTPUT) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100814 getnext_opts = LYS_GETNEXT_OUTPUT;
Michal Vasko00cbf532020-06-15 13:58:47 +0200815 } else {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100816 getnext_opts = 0;
Michal Vasko00cbf532020-06-15 13:58:47 +0200817 }
818
Michal Vasko004d3152020-06-11 19:59:22 +0200819 if (expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH) {
820 /* absolute path */
821 ctx_node = NULL;
822
823 ++tok_idx;
824 } else {
825 /* relative path */
826 while ((lref == LY_PATH_LREF_TRUE) && (expr->tokens[tok_idx] == LYXP_TOKEN_DDOT)) {
827 if (!ctx_node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100828 LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
Michal Vasko14424ba2020-12-09 18:09:51 +0100829 ret = LY_EVALID;
830 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200831 }
832
833 /* get parent */
834 ctx_node = lysc_data_parent(ctx_node);
835
836 ++tok_idx;
837
838 assert(expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH);
839 ++tok_idx;
840 }
841
Michal Vasko00cbf532020-06-15 13:58:47 +0200842 /* we are not storing the parent */
843 (void)ctx_node;
Michal Vasko004d3152020-06-11 19:59:22 +0200844 }
845
846 do {
Michal Vasko00cbf532020-06-15 13:58:47 +0200847 /* check last compiled inner node, whether it is uniquely identified (even key-less list) */
Michal Vaskod456cf62020-11-23 16:48:43 +0100848 if (p && (lref == LY_PATH_LREF_FALSE) && (target == LY_PATH_TARGET_SINGLE) &&
849 (p->node->nodetype == LYS_LIST) && !p->predicates) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100850 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200851 lys_nodetype2str(p->node->nodetype), p->node->name);
Michal Vasko14424ba2020-12-09 18:09:51 +0100852 ret = LY_EVALID;
853 goto cleanup;
Michal Vasko00cbf532020-06-15 13:58:47 +0200854 }
855
Michal Vasko14424ba2020-12-09 18:09:51 +0100856 /* NameTest */
857 LY_CHECK_ERR_GOTO(lyxp_check_token(ctx, expr, tok_idx, LYXP_TOKEN_NAMETEST), ret = LY_EVALID, cleanup);
858
Michal Vasko004d3152020-06-11 19:59:22 +0200859 /* get module and node name */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200860 LY_CHECK_GOTO(ret = ly_path_compile_prefix(ctx, cur_node, cur_mod, ctx_node, expr, tok_idx, lref, format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100861 prefix_data, unres, &mod, &name, &name_len), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200862 ++tok_idx;
863
864 /* find the next node */
Radek Krejcid5d37432021-03-12 13:46:40 +0100865 if (!ctx_node && ext) {
866 node2 = lysc_ext_find_node(ext, mod, name, name_len, 0, getnext_opts);
867 } else {
868 node2 = lys_find_child(ctx_node, mod, name, name_len, 0, getnext_opts);
869 }
Radek Krejci25fe3dd2020-11-10 22:02:26 +0100870 if (!node2 || (op && (node2->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node2 != op))) {
Radek Krejci422afb12021-03-04 16:38:16 +0100871 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci8de005f2020-06-25 17:02:07 +0200872 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +0200873 goto cleanup;
874 }
875 ctx_node = node2;
876
877 /* new path segment */
Michal Vasko00cbf532020-06-15 13:58:47 +0200878 LY_ARRAY_NEW_GOTO(ctx, *path, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200879 p->node = ctx_node;
880
881 /* compile any predicates */
882 if (lref == LY_PATH_LREF_TRUE) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100883 ret = ly_path_compile_predicate_leafref(ctx_node, cur_node, expr, &tok_idx, format, prefix_data, unres);
Michal Vasko004d3152020-06-11 19:59:22 +0200884 } else {
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200885 ret = ly_path_compile_predicate(ctx, cur_node, cur_mod, ctx_node, expr, &tok_idx, format, prefix_data,
Michal Vasko69730152020-10-09 16:30:07 +0200886 &p->predicates, &p->pred_type);
Michal Vasko004d3152020-06-11 19:59:22 +0200887 }
888 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200889 } while (!lyxp_next_token(NULL, expr, &tok_idx, LYXP_TOKEN_OPER_PATH));
890
Michal Vasko14424ba2020-12-09 18:09:51 +0100891 /* check leftover tokens */
892 if (tok_idx < expr->used) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100893 LOGVAL(ctx, LY_VCODE_XP_INTOK, lyxp_print_token(expr->tokens[tok_idx]), &expr->expr[expr->tok_pos[tok_idx]]);
Michal Vasko14424ba2020-12-09 18:09:51 +0100894 ret = LY_EVALID;
895 goto cleanup;
896 }
897
Michal Vasko00cbf532020-06-15 13:58:47 +0200898 /* check last compiled node */
Michal Vasko69730152020-10-09 16:30:07 +0200899 if ((lref == LY_PATH_LREF_FALSE) && (target == LY_PATH_TARGET_SINGLE) &&
900 (p->node->nodetype & (LYS_LIST | LYS_LEAFLIST)) && !p->predicates) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100901 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200902 lys_nodetype2str(p->node->nodetype), p->node->name);
Michal Vasko14424ba2020-12-09 18:09:51 +0100903 ret = LY_EVALID;
904 goto cleanup;
Michal Vasko00cbf532020-06-15 13:58:47 +0200905 }
906
Michal Vasko004d3152020-06-11 19:59:22 +0200907cleanup:
908 if (ret) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200909 ly_path_free(ctx, *path);
Michal Vasko004d3152020-06-11 19:59:22 +0200910 *path = NULL;
911 }
Radek Krejciddace2c2021-01-08 11:30:56 +0100912 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200913 return ret;
914}
915
916LY_ERR
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200917ly_path_eval_partial(const struct ly_path *path, const struct lyd_node *start, LY_ARRAY_COUNT_TYPE *path_idx,
Radek Krejci0f969882020-08-21 16:56:47 +0200918 struct lyd_node **match)
Michal Vasko004d3152020-06-11 19:59:22 +0200919{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200920 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoacfc9282021-02-04 12:08:23 +0100921 struct lyd_node *prev_node = NULL, *node = NULL, *target;
Michal Vasko004d3152020-06-11 19:59:22 +0200922 uint64_t pos;
923
924 assert(path && start);
925
926 if (lysc_data_parent(path[0].node)) {
927 /* relative path, start from the parent children */
Radek Krejcia1c1e542020-09-29 16:06:52 +0200928 start = lyd_child(start);
Michal Vasko004d3152020-06-11 19:59:22 +0200929 } else {
930 /* absolute path, start from the first top-level sibling */
931 while (start->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +0100932 start = lyd_parent(start);
Michal Vasko004d3152020-06-11 19:59:22 +0200933 }
934 while (start->prev->next) {
935 start = start->prev;
936 }
937 }
938
939 LY_ARRAY_FOR(path, u) {
940 switch (path[u].pred_type) {
941 case LY_PATH_PREDTYPE_POSITION:
942 /* we cannot use hashes and want an instance on a specific position */
943 pos = 1;
Michal Vasko4c583e82020-07-17 12:16:14 +0200944 LYD_LIST_FOR_INST(start, path[u].node, node) {
Michal Vasko004d3152020-06-11 19:59:22 +0200945 if (pos == path[u].predicates[0].position) {
946 break;
947 }
948 ++pos;
949 }
950 break;
951 case LY_PATH_PREDTYPE_LEAFLIST:
952 /* we will use hashes to find one leaf-list instance */
953 LY_CHECK_RET(lyd_create_term2(path[u].node, &path[u].predicates[0].value, &target));
954 lyd_find_sibling_first(start, target, &node);
955 lyd_free_tree(target);
956 break;
957 case LY_PATH_PREDTYPE_LIST:
958 /* we will use hashes to find one list instance */
959 LY_CHECK_RET(lyd_create_list(path[u].node, path[u].predicates, &target));
960 lyd_find_sibling_first(start, target, &node);
961 lyd_free_tree(target);
962 break;
963 case LY_PATH_PREDTYPE_NONE:
964 /* we will use hashes to find one any/container/leaf instance */
965 lyd_find_sibling_val(start, path[u].node, NULL, 0, &node);
966 break;
967 }
968
969 if (!node) {
970 /* no matching nodes */
971 break;
972 }
973
Michal Vasko00cbf532020-06-15 13:58:47 +0200974 /* rememeber previous node */
975 prev_node = node;
976
Michal Vasko004d3152020-06-11 19:59:22 +0200977 /* next path segment, if any */
Radek Krejcia1c1e542020-09-29 16:06:52 +0200978 start = lyd_child(node);
Michal Vasko004d3152020-06-11 19:59:22 +0200979 }
980
Michal Vasko004d3152020-06-11 19:59:22 +0200981 if (node) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200982 /* we have found the full path */
983 if (path_idx) {
984 *path_idx = u;
985 }
986 if (match) {
987 *match = node;
988 }
Michal Vasko004d3152020-06-11 19:59:22 +0200989 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +0200990
991 } else if (prev_node) {
992 /* we have found only some partial match */
993 if (path_idx) {
994 *path_idx = u - 1;
995 }
996 if (match) {
997 *match = prev_node;
998 }
999 return LY_EINCOMPLETE;
1000 }
1001
1002 /* we have not found any nodes */
1003 if (path_idx) {
1004 *path_idx = 0;
1005 }
1006 if (match) {
1007 *match = NULL;
1008 }
1009 return LY_ENOTFOUND;
1010}
1011
1012LY_ERR
1013ly_path_eval(const struct ly_path *path, const struct lyd_node *start, struct lyd_node **match)
1014{
1015 LY_ERR ret;
1016 struct lyd_node *m;
1017
1018 ret = ly_path_eval_partial(path, start, NULL, &m);
1019
1020 if (ret == LY_SUCCESS) {
1021 /* last node was found */
1022 if (match) {
1023 *match = m;
1024 }
1025 return LY_SUCCESS;
1026 }
1027
1028 /* not a full match */
1029 if (match) {
1030 *match = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02001031 }
1032 return LY_ENOTFOUND;
1033}
1034
1035LY_ERR
1036ly_path_dup(const struct ly_ctx *ctx, const struct ly_path *path, struct ly_path **dup)
1037{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001038 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko004d3152020-06-11 19:59:22 +02001039
1040 if (!path) {
1041 return LY_SUCCESS;
1042 }
1043
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001044 LY_ARRAY_CREATE_RET(ctx, *dup, LY_ARRAY_COUNT(path), LY_EMEM);
Michal Vasko004d3152020-06-11 19:59:22 +02001045 LY_ARRAY_FOR(path, u) {
1046 LY_ARRAY_INCREMENT(*dup);
1047 (*dup)[u].node = path[u].node;
1048 if (path[u].predicates) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001049 LY_ARRAY_CREATE_RET(ctx, (*dup)[u].predicates, LY_ARRAY_COUNT(path[u].predicates), LY_EMEM);
Michal Vasko004d3152020-06-11 19:59:22 +02001050 (*dup)[u].pred_type = path[u].pred_type;
1051 LY_ARRAY_FOR(path[u].predicates, v) {
1052 struct ly_path_predicate *pred = &path[u].predicates[v];
1053
1054 LY_ARRAY_INCREMENT((*dup)[u].predicates);
1055 switch (path[u].pred_type) {
1056 case LY_PATH_PREDTYPE_POSITION:
1057 /* position-predicate */
1058 (*dup)[u].predicates[v].position = pred->position;
1059 break;
1060 case LY_PATH_PREDTYPE_LIST:
1061 case LY_PATH_PREDTYPE_LEAFLIST:
1062 /* key-predicate or leaf-list-predicate */
1063 (*dup)[u].predicates[v].key = pred->key;
Michal Vasko004d3152020-06-11 19:59:22 +02001064 pred->value.realtype->plugin->duplicate(ctx, &pred->value, &(*dup)[u].predicates[v].value);
Michal Vaskoae875662020-10-21 10:33:17 +02001065 ++((struct lysc_type *)pred->value.realtype)->refcount;
Michal Vasko004d3152020-06-11 19:59:22 +02001066 break;
1067 case LY_PATH_PREDTYPE_NONE:
1068 break;
1069 }
1070 }
1071 }
1072 }
1073
1074 return LY_SUCCESS;
1075}
1076
1077void
Michal Vaskof7e16e22020-10-21 09:24:39 +02001078ly_path_predicates_free(const struct ly_ctx *ctx, enum ly_path_pred_type pred_type, struct ly_path_predicate *predicates)
Michal Vasko004d3152020-06-11 19:59:22 +02001079{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001080 LY_ARRAY_COUNT_TYPE u;
Michal Vasko004d3152020-06-11 19:59:22 +02001081
1082 if (!predicates) {
1083 return;
1084 }
1085
1086 LY_ARRAY_FOR(predicates, u) {
1087 switch (pred_type) {
1088 case LY_PATH_PREDTYPE_POSITION:
1089 case LY_PATH_PREDTYPE_NONE:
1090 /* nothing to free */
1091 break;
1092 case LY_PATH_PREDTYPE_LIST:
Michal Vasko004d3152020-06-11 19:59:22 +02001093 case LY_PATH_PREDTYPE_LEAFLIST:
Michal Vaskoae875662020-10-21 10:33:17 +02001094 if (predicates[u].value.realtype) {
1095 predicates[u].value.realtype->plugin->free(ctx, &predicates[u].value);
1096 lysc_type_free((struct ly_ctx *)ctx, (struct lysc_type *)predicates[u].value.realtype);
1097 }
Michal Vasko004d3152020-06-11 19:59:22 +02001098 break;
1099 }
1100 }
1101 LY_ARRAY_FREE(predicates);
1102}
1103
1104void
1105ly_path_free(const struct ly_ctx *ctx, struct ly_path *path)
1106{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001107 LY_ARRAY_COUNT_TYPE u;
Michal Vasko004d3152020-06-11 19:59:22 +02001108
1109 LY_ARRAY_FOR(path, u) {
Michal Vaskof7e16e22020-10-21 09:24:39 +02001110 ly_path_predicates_free(ctx, path[u].pred_type, path[u].predicates);
Michal Vasko004d3152020-06-11 19:59:22 +02001111 }
1112 LY_ARRAY_FREE(path);
1113}