blob: 209e4605cd9cac26ea85df15fed4f0bbc8dade0c [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,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100398 LY_PREFIX_FORMAT format, void *prefix_data, struct lys_glob_unres *unres, const struct lys_module **mod,
399 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 Krejci2efc45b2020-12-22 16:25:44 +0100417 ret = LY_EVALID;
418
Radek Krejciddace2c2021-01-08 11:30:56 +0100419 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100420
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200421 *mod = ly_resolve_prefix(ctx, pref, len, format, prefix_data);
Michal Vasko004d3152020-06-11 19:59:22 +0200422 if (!*mod) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100423 LOGVAL(ctx, LYVE_XPATH, "No module connected with the prefix \"%.*s\" found (prefix format %s).",
Radek Krejci422afb12021-03-04 16:38:16 +0100424 (int)len, pref, ly_format2str(format));
Radek Krejci2efc45b2020-12-22 16:25:44 +0100425 goto error;
Michal Vasko004d3152020-06-11 19:59:22 +0200426 } else if (!(*mod)->implemented) {
427 if (lref == LY_PATH_LREF_FALSE) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100428 LOGVAL(ctx, LYVE_XPATH, "Not implemented module \"%s\" in path.", (*mod)->name);
429 goto error;
Michal Vasko004d3152020-06-11 19:59:22 +0200430 }
Michal Vaskob3e22532021-02-03 10:50:04 +0100431 assert(unres);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100432 LY_CHECK_GOTO(ret = lys_set_implemented_r((struct lys_module *)*mod, NULL, unres), error);
Michal Vasko004d3152020-06-11 19:59:22 +0200433 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100434
Radek Krejciddace2c2021-01-08 11:30:56 +0100435 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200436 } else {
437 switch (format) {
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200438 case LY_PREF_SCHEMA:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200439 case LY_PREF_SCHEMA_RESOLVED:
440 if (!cur_mod) {
441 LOGINT_RET(ctx);
442 }
443 /* use current module */
Michal Vasko004d3152020-06-11 19:59:22 +0200444 *mod = cur_mod;
445 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200446 case LY_PREF_JSON:
Michal Vasko004d3152020-06-11 19:59:22 +0200447 if (!prev_ctx_node) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200448 LOGINT_RET(ctx);
Michal Vasko004d3152020-06-11 19:59:22 +0200449 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200450 /* inherit module of the previous node */
Michal Vasko004d3152020-06-11 19:59:22 +0200451 *mod = prev_ctx_node->module;
452 break;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200453 case LY_PREF_XML:
Michal Vasko004d3152020-06-11 19:59:22 +0200454 /* not really defined */
Michal Vasko00cbf532020-06-15 13:58:47 +0200455 LOGINT_RET(ctx);
Michal Vasko004d3152020-06-11 19:59:22 +0200456 }
457 }
458
459 /* set name */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200460 if (pref) {
461 *name = pref + len + 1;
Michal Vasko004d3152020-06-11 19:59:22 +0200462 *name_len = expr->tok_len[tok_idx] - len - 1;
463 } else {
464 *name = expr->expr + expr->tok_pos[tok_idx];
465 *name_len = expr->tok_len[tok_idx];
466 }
467
468 return LY_SUCCESS;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100469
470error:
Radek Krejciddace2c2021-01-08 11:30:56 +0100471 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100472 return LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +0200473}
474
475LY_ERR
Michal Vasko6b26e742020-07-17 15:02:10 +0200476ly_path_compile_predicate(const struct ly_ctx *ctx, const struct lysc_node *cur_node, const struct lys_module *cur_mod,
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200477 const struct lysc_node *ctx_node, const struct lyxp_expr *expr, uint16_t *tok_idx, LY_PREFIX_FORMAT format,
478 void *prefix_data, struct ly_path_predicate **predicates, enum ly_path_pred_type *pred_type)
Michal Vasko004d3152020-06-11 19:59:22 +0200479{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100480 LY_ERR ret = LY_SUCCESS;
Michal Vasko004d3152020-06-11 19:59:22 +0200481 struct ly_path_predicate *p;
482 const struct lysc_node *key;
Radek Krejci2b18bf12020-11-06 11:20:20 +0100483 const struct lys_module *mod = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +0200484 const char *name;
485 size_t name_len, key_count;
486
Michal Vasko00cbf532020-06-15 13:58:47 +0200487 assert(ctx && ctx_node);
488
Radek Krejciddace2c2021-01-08 11:30:56 +0100489 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100490
Michal Vasko004d3152020-06-11 19:59:22 +0200491 *pred_type = 0;
492
Michal Vasko004d3152020-06-11 19:59:22 +0200493 if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200494 /* '[', no predicate */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100495 goto cleanup; /* LY_SUCCESS */
Michal Vasko004d3152020-06-11 19:59:22 +0200496 }
497
498 if (expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST) {
499 if (ctx_node->nodetype != LYS_LIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100500 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200501 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100502 ret = LY_EVALID;
503 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200504 } else if (ctx_node->flags & LYS_KEYLESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100505 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200506 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100507 ret = LY_EVALID;
508 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200509 }
510
511 do {
512 /* NameTest, find the key */
Michal Vasko6b26e742020-07-17 15:02:10 +0200513 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 +0100514 format, prefix_data, NULL, &mod, &name, &name_len));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100515 key = lys_find_child(ctx_node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200516 if (!key) {
Radek Krejci422afb12021-03-04 16:38:16 +0100517 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100518 ret = LY_ENOTFOUND;
519 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200520 } else if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100521 LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.", lys_nodetype2str(key->nodetype),
522 key->name);
523 ret = LY_EVALID;
524 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200525 }
526 ++(*tok_idx);
527
Michal Vasko004d3152020-06-11 19:59:22 +0200528 if (!*pred_type) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200529 /* new predicate */
Michal Vasko004d3152020-06-11 19:59:22 +0200530 *pred_type = LY_PATH_PREDTYPE_LIST;
531 }
532 assert(*pred_type == LY_PATH_PREDTYPE_LIST);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100533 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200534 p->key = key;
535
536 /* '=' */
537 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
538 ++(*tok_idx);
539
540 /* Literal */
541 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100542 LOG_LOCSET(key, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100543 ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaf *)key)->type,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200544 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 +0100545 LYD_HINT_DATA, key, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100546 LOG_LOCBACK(key ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100547 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200548 ++(*tok_idx);
549
Michal Vaskoae875662020-10-21 10:33:17 +0200550 /* "allocate" the type to avoid problems when freeing the value after the type was freed */
551 ++((struct lysc_type *)p->value.realtype)->refcount;
552
Michal Vasko004d3152020-06-11 19:59:22 +0200553 /* ']' */
554 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
555 ++(*tok_idx);
556
557 /* another predicate follows? */
558 } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
559
560 /* check that all keys were set */
561 key_count = 0;
Michal Vasko544e58a2021-01-28 14:33:41 +0100562 for (key = lysc_node_child(ctx_node); key && (key->flags & LYS_KEY); key = key->next) {
Michal Vasko004d3152020-06-11 19:59:22 +0200563 ++key_count;
564 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200565 if (LY_ARRAY_COUNT(*predicates) != key_count) {
Michal Vasko004d3152020-06-11 19:59:22 +0200566 /* names (keys) are unique - it was checked when parsing */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100567 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for a key of %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200568 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Michal Vaskof7e16e22020-10-21 09:24:39 +0200569 ly_path_predicates_free(ctx, LY_PATH_PREDTYPE_LIST, *predicates);
Michal Vasko004d3152020-06-11 19:59:22 +0200570 *predicates = NULL;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100571 ret = LY_EVALID;
572 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200573 }
574
575 } else if (expr->tokens[*tok_idx] == LYXP_TOKEN_DOT) {
576 if (ctx_node->nodetype != LYS_LEAFLIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100577 LOGVAL(ctx, LYVE_XPATH, "Leaf-list predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200578 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100579 ret = LY_EVALID;
580 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200581 }
582 ++(*tok_idx);
583
584 /* new predicate */
585 *pred_type = LY_PATH_PREDTYPE_LEAFLIST;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100586 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200587
588 /* '=' */
589 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
590 ++(*tok_idx);
591
592 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_LITERAL);
593 /* store the value */
Radek Krejciddace2c2021-01-08 11:30:56 +0100594 LOG_LOCSET(ctx_node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100595 ret = lyd_value_store(ctx, &p->value, ((struct lysc_node_leaflist *)ctx_node)->type,
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200596 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 +0100597 LYD_HINT_DATA, ctx_node, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +0100598 LOG_LOCBACK(ctx_node ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100599 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200600 ++(*tok_idx);
601
Michal Vaskoae875662020-10-21 10:33:17 +0200602 /* "allocate" the type to avoid problems when freeing the value after the type was freed */
603 ++((struct lysc_type *)p->value.realtype)->refcount;
604
Michal Vasko004d3152020-06-11 19:59:22 +0200605 /* ']' */
606 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
607 ++(*tok_idx);
608 } else {
609 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NUMBER);
610 if (!(ctx_node->nodetype & (LYS_LEAFLIST | LYS_LIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100611 ret = LY_EVALID;
612 LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200613 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100614 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200615 } else if (ctx_node->flags & LYS_CONFIG_W) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100616 ret = LY_EVALID;
617 LOGVAL(ctx, LYVE_XPATH, "Positional predicate defined for configuration %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200618 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100619 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200620 }
Michal Vasko004d3152020-06-11 19:59:22 +0200621
622 /* new predicate */
623 *pred_type = LY_PATH_PREDTYPE_POSITION;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100624 LY_ARRAY_NEW_GOTO(ctx, *predicates, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200625
626 /* syntax was already checked */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100627 p->position = strtoull(expr->expr + expr->tok_pos[*tok_idx], (char **)&name, LY_BASE_DEC);
Michal Vasko00cbf532020-06-15 13:58:47 +0200628 ++(*tok_idx);
Michal Vasko004d3152020-06-11 19:59:22 +0200629
630 /* ']' */
631 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
632 ++(*tok_idx);
633 }
634
Radek Krejci2efc45b2020-12-22 16:25:44 +0100635cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100636 LOG_LOCBACK(cur_node ? 1 : 0, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100637 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200638}
639
640/**
641 * @brief Compile leafref predicate. Actually, it is only checked.
642 *
643 * @param[in] ctx_node Context node, node for which the predicate is defined.
644 * @param[in] cur_node Current (original context) node.
645 * @param[in] expr Parsed path.
646 * @param[in,out] tok_idx Index in @p expr, is adjusted for parsed tokens.
Michal Vasko004d3152020-06-11 19:59:22 +0200647 * @param[in] format Format of the path.
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200648 * @param[in] prefix_data Format-specific data for resolving any prefixes (see ::ly_resolve_prefix).
Michal Vasko405cc9e2020-12-01 12:01:27 +0100649 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko004d3152020-06-11 19:59:22 +0200650 * @return LY_ERR value.
651 */
652static LY_ERR
653ly_path_compile_predicate_leafref(const struct lysc_node *ctx_node, const struct lysc_node *cur_node,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100654 const struct lyxp_expr *expr, uint16_t *tok_idx, LY_PREFIX_FORMAT format, void *prefix_data,
655 struct lys_glob_unres *unres)
Michal Vasko004d3152020-06-11 19:59:22 +0200656{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100657 LY_ERR ret = LY_SUCCESS;
Michal Vasko004d3152020-06-11 19:59:22 +0200658 const struct lysc_node *key, *node, *node2;
659 const struct lys_module *mod;
660 const char *name;
661 size_t name_len;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100662 struct ly_ctx *ctx = cur_node->module->ctx;
663
Radek Krejciddace2c2021-01-08 11:30:56 +0100664 LOG_LOCSET(cur_node, NULL, NULL, NULL);
Michal Vasko004d3152020-06-11 19:59:22 +0200665
Michal Vasko004d3152020-06-11 19:59:22 +0200666 if (lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1)) {
Radek Krejcif6a11002020-08-21 13:29:07 +0200667 /* '[', no predicate */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100668 goto cleanup; /* LY_SUCCESS */
Michal Vasko004d3152020-06-11 19:59:22 +0200669 }
670
671 if (ctx_node->nodetype != LYS_LIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100672 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200673 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100674 ret = LY_EVALID;
675 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200676 } else if (ctx_node->flags & LYS_KEYLESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100677 LOGVAL(ctx, LYVE_XPATH, "List predicate defined for keyless %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200678 lys_nodetype2str(ctx_node->nodetype), ctx_node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100679 ret = LY_EVALID;
680 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200681 }
682
683 do {
684 /* NameTest, find the key */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100685 ret = ly_path_compile_prefix(ctx, cur_node, cur_node->module, ctx_node, expr, *tok_idx,
686 LY_PATH_LREF_TRUE, format, prefix_data, unres, &mod, &name, &name_len);
687 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100688 key = lys_find_child(ctx_node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200689 if (!key) {
Radek Krejci422afb12021-03-04 16:38:16 +0100690 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100691 ret = LY_EVALID;
692 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200693 } else if ((key->nodetype != LYS_LEAF) || !(key->flags & LYS_KEY)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100694 LOGVAL(ctx, LYVE_XPATH, "Key expected instead of %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200695 lys_nodetype2str(key->nodetype), key->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100696 ret = LY_EVALID;
697 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200698 }
699 ++(*tok_idx);
700
701 /* we are not actually compiling, throw the key away */
702 (void)key;
703
704 /* '=' */
705 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_EQUAL);
706 ++(*tok_idx);
707
708 /* FuncName */
709 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_FUNCNAME);
710 ++(*tok_idx);
711
712 /* evaluating from the "current()" node */
713 node = cur_node;
714
715 /* '(' */
716 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR1);
717 ++(*tok_idx);
718
719 /* ')' */
720 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_PAR2);
721 ++(*tok_idx);
722
723 do {
724 /* '/' */
725 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
726 ++(*tok_idx);
727
728 /* go to parent */
729 if (!node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100730 LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
731 ret = LY_EVALID;
732 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200733 }
734 node = lysc_data_parent(node);
735
736 /* '..' */
737 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_DDOT);
738 ++(*tok_idx);
739 } while (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_DDOT);
740
741 do {
742 /* '/' */
743 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_OPER_PATH);
744 ++(*tok_idx);
745
746 /* NameTest */
747 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_NAMETEST);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100748 LY_CHECK_RET(ly_path_compile_prefix(ctx, cur_node, cur_node->module, node, expr, *tok_idx,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100749 LY_PATH_LREF_TRUE, format, prefix_data, unres, &mod, &name, &name_len));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100750 node2 = lys_find_child(node, mod, name, name_len, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200751 if (!node2) {
Radek Krejci422afb12021-03-04 16:38:16 +0100752 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100753 ret = LY_EVALID;
754 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200755 }
756 node = node2;
757 ++(*tok_idx);
758 } while ((*tok_idx + 1 < expr->used) && (expr->tokens[*tok_idx + 1] == LYXP_TOKEN_NAMETEST));
759
760 /* check the last target node */
761 if (node->nodetype != LYS_LEAF) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100762 LOGVAL(ctx, LYVE_XPATH, "Leaf expected instead of %s \"%s\" in leafref predicate in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200763 lys_nodetype2str(node->nodetype), node->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100764 ret = LY_EVALID;
765 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200766 }
767
768 /* we are not actually compiling, throw the rightside node away */
769 (void)node;
770
771 /* ']' */
772 assert(expr->tokens[*tok_idx] == LYXP_TOKEN_BRACK2);
773 ++(*tok_idx);
774
Radek Krejci0f969882020-08-21 16:56:47 +0200775 /* another predicate follows? */
Michal Vasko004d3152020-06-11 19:59:22 +0200776 } while (!lyxp_next_token(NULL, expr, tok_idx, LYXP_TOKEN_BRACK1));
777
Radek Krejci2efc45b2020-12-22 16:25:44 +0100778cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100779 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100780 return ret;
Michal Vasko004d3152020-06-11 19:59:22 +0200781}
782
783LY_ERR
Michal Vasko00cbf532020-06-15 13:58:47 +0200784ly_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 +0100785 const struct lysc_ext_instance *ext, const struct lyxp_expr *expr, uint8_t lref, uint8_t oper, uint8_t target,
786 LY_PREFIX_FORMAT format, void *prefix_data, struct lys_glob_unres *unres, struct ly_path **path)
Michal Vasko004d3152020-06-11 19:59:22 +0200787{
788 LY_ERR ret = LY_SUCCESS;
789 uint16_t tok_idx = 0;
Radek Krejci2b18bf12020-11-06 11:20:20 +0100790 const struct lys_module *mod = NULL;
Michal Vasko6b26e742020-07-17 15:02:10 +0200791 const struct lysc_node *node2, *cur_node, *op;
Michal Vasko00cbf532020-06-15 13:58:47 +0200792 struct ly_path *p = NULL;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200793 uint32_t getnext_opts;
Michal Vasko004d3152020-06-11 19:59:22 +0200794 const char *name;
795 size_t name_len;
796
Michal Vasko00cbf532020-06-15 13:58:47 +0200797 assert(ctx);
Michal Vasko6b26e742020-07-17 15:02:10 +0200798 assert((lref == LY_PATH_LREF_FALSE) || ctx_node);
Michal Vasko004d3152020-06-11 19:59:22 +0200799 assert((lref == LY_PATH_LREF_TRUE) || (lref == LY_PATH_LREF_FALSE));
Michal Vasko00cbf532020-06-15 13:58:47 +0200800 assert((oper == LY_PATH_OPER_INPUT) || (oper == LY_PATH_OPER_OUTPUT));
801 assert((target == LY_PATH_TARGET_SINGLE) || (target == LY_PATH_TARGET_MANY));
Michal Vasko004d3152020-06-11 19:59:22 +0200802
Michal Vasko6b26e742020-07-17 15:02:10 +0200803 /* find operation, if we are in any */
Radek Krejci1e008d22020-08-17 11:37:37 +0200804 for (op = ctx_node; op && !(op->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)); op = op->parent) {}
Michal Vasko6b26e742020-07-17 15:02:10 +0200805
Radek Krejci2efc45b2020-12-22 16:25:44 +0100806 *path = NULL;
807
Michal Vasko6b26e742020-07-17 15:02:10 +0200808 /* remember original context node */
809 cur_node = ctx_node;
Radek Krejciddace2c2021-01-08 11:30:56 +0100810 LOG_LOCINIT(cur_node, NULL, NULL, NULL);
Michal Vasko004d3152020-06-11 19:59:22 +0200811
Michal Vasko00cbf532020-06-15 13:58:47 +0200812 if (oper == LY_PATH_OPER_OUTPUT) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100813 getnext_opts = LYS_GETNEXT_OUTPUT;
Michal Vasko00cbf532020-06-15 13:58:47 +0200814 } else {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100815 getnext_opts = 0;
Michal Vasko00cbf532020-06-15 13:58:47 +0200816 }
817
Michal Vasko004d3152020-06-11 19:59:22 +0200818 if (expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH) {
819 /* absolute path */
820 ctx_node = NULL;
821
822 ++tok_idx;
823 } else {
824 /* relative path */
825 while ((lref == LY_PATH_LREF_TRUE) && (expr->tokens[tok_idx] == LYXP_TOKEN_DDOT)) {
826 if (!ctx_node) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100827 LOGVAL(ctx, LYVE_XPATH, "Too many parent references in path.");
Michal Vasko14424ba2020-12-09 18:09:51 +0100828 ret = LY_EVALID;
829 goto cleanup;
Michal Vasko004d3152020-06-11 19:59:22 +0200830 }
831
832 /* get parent */
833 ctx_node = lysc_data_parent(ctx_node);
834
835 ++tok_idx;
836
837 assert(expr->tokens[tok_idx] == LYXP_TOKEN_OPER_PATH);
838 ++tok_idx;
839 }
840
Michal Vasko00cbf532020-06-15 13:58:47 +0200841 /* we are not storing the parent */
842 (void)ctx_node;
Michal Vasko004d3152020-06-11 19:59:22 +0200843 }
844
845 do {
Michal Vasko00cbf532020-06-15 13:58:47 +0200846 /* check last compiled inner node, whether it is uniquely identified (even key-less list) */
Michal Vaskod456cf62020-11-23 16:48:43 +0100847 if (p && (lref == LY_PATH_LREF_FALSE) && (target == LY_PATH_TARGET_SINGLE) &&
848 (p->node->nodetype == LYS_LIST) && !p->predicates) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100849 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200850 lys_nodetype2str(p->node->nodetype), p->node->name);
Michal Vasko14424ba2020-12-09 18:09:51 +0100851 ret = LY_EVALID;
852 goto cleanup;
Michal Vasko00cbf532020-06-15 13:58:47 +0200853 }
854
Michal Vasko14424ba2020-12-09 18:09:51 +0100855 /* NameTest */
856 LY_CHECK_ERR_GOTO(lyxp_check_token(ctx, expr, tok_idx, LYXP_TOKEN_NAMETEST), ret = LY_EVALID, cleanup);
857
Michal Vasko004d3152020-06-11 19:59:22 +0200858 /* get module and node name */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200859 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 +0100860 prefix_data, unres, &mod, &name, &name_len), cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200861 ++tok_idx;
862
863 /* find the next node */
Radek Krejcid5d37432021-03-12 13:46:40 +0100864 if (!ctx_node && ext) {
865 node2 = lysc_ext_find_node(ext, mod, name, name_len, 0, getnext_opts);
866 } else {
867 node2 = lys_find_child(ctx_node, mod, name, name_len, 0, getnext_opts);
868 }
Radek Krejci25fe3dd2020-11-10 22:02:26 +0100869 if (!node2 || (op && (node2->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) && (node2 != op))) {
Radek Krejci422afb12021-03-04 16:38:16 +0100870 LOGVAL(ctx, LYVE_XPATH, "Not found node \"%.*s\" in path.", (int)name_len, name);
Radek Krejci8de005f2020-06-25 17:02:07 +0200871 ret = LY_EVALID;
Michal Vasko004d3152020-06-11 19:59:22 +0200872 goto cleanup;
873 }
874 ctx_node = node2;
875
876 /* new path segment */
Michal Vasko00cbf532020-06-15 13:58:47 +0200877 LY_ARRAY_NEW_GOTO(ctx, *path, p, ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200878 p->node = ctx_node;
879
880 /* compile any predicates */
881 if (lref == LY_PATH_LREF_TRUE) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100882 ret = ly_path_compile_predicate_leafref(ctx_node, cur_node, expr, &tok_idx, format, prefix_data, unres);
Michal Vasko004d3152020-06-11 19:59:22 +0200883 } else {
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200884 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 +0200885 &p->predicates, &p->pred_type);
Michal Vasko004d3152020-06-11 19:59:22 +0200886 }
887 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko004d3152020-06-11 19:59:22 +0200888 } while (!lyxp_next_token(NULL, expr, &tok_idx, LYXP_TOKEN_OPER_PATH));
889
Michal Vasko14424ba2020-12-09 18:09:51 +0100890 /* check leftover tokens */
891 if (tok_idx < expr->used) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100892 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 +0100893 ret = LY_EVALID;
894 goto cleanup;
895 }
896
Michal Vasko00cbf532020-06-15 13:58:47 +0200897 /* check last compiled node */
Michal Vasko69730152020-10-09 16:30:07 +0200898 if ((lref == LY_PATH_LREF_FALSE) && (target == LY_PATH_TARGET_SINGLE) &&
899 (p->node->nodetype & (LYS_LIST | LYS_LEAFLIST)) && !p->predicates) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100900 LOGVAL(ctx, LYVE_XPATH, "Predicate missing for %s \"%s\" in path.",
Michal Vasko69730152020-10-09 16:30:07 +0200901 lys_nodetype2str(p->node->nodetype), p->node->name);
Michal Vasko14424ba2020-12-09 18:09:51 +0100902 ret = LY_EVALID;
903 goto cleanup;
Michal Vasko00cbf532020-06-15 13:58:47 +0200904 }
905
Michal Vasko004d3152020-06-11 19:59:22 +0200906cleanup:
907 if (ret) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200908 ly_path_free(ctx, *path);
Michal Vasko004d3152020-06-11 19:59:22 +0200909 *path = NULL;
910 }
Radek Krejciddace2c2021-01-08 11:30:56 +0100911 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko004d3152020-06-11 19:59:22 +0200912 return ret;
913}
914
915LY_ERR
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200916ly_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 +0200917 struct lyd_node **match)
Michal Vasko004d3152020-06-11 19:59:22 +0200918{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200919 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoacfc9282021-02-04 12:08:23 +0100920 struct lyd_node *prev_node = NULL, *node = NULL, *target;
Michal Vasko004d3152020-06-11 19:59:22 +0200921 uint64_t pos;
922
923 assert(path && start);
924
925 if (lysc_data_parent(path[0].node)) {
926 /* relative path, start from the parent children */
Radek Krejcia1c1e542020-09-29 16:06:52 +0200927 start = lyd_child(start);
Michal Vasko004d3152020-06-11 19:59:22 +0200928 } else {
929 /* absolute path, start from the first top-level sibling */
930 while (start->parent) {
Michal Vasko9e685082021-01-29 14:49:09 +0100931 start = lyd_parent(start);
Michal Vasko004d3152020-06-11 19:59:22 +0200932 }
933 while (start->prev->next) {
934 start = start->prev;
935 }
936 }
937
938 LY_ARRAY_FOR(path, u) {
939 switch (path[u].pred_type) {
940 case LY_PATH_PREDTYPE_POSITION:
941 /* we cannot use hashes and want an instance on a specific position */
942 pos = 1;
Michal Vasko4c583e82020-07-17 12:16:14 +0200943 LYD_LIST_FOR_INST(start, path[u].node, node) {
Michal Vasko004d3152020-06-11 19:59:22 +0200944 if (pos == path[u].predicates[0].position) {
945 break;
946 }
947 ++pos;
948 }
949 break;
950 case LY_PATH_PREDTYPE_LEAFLIST:
951 /* we will use hashes to find one leaf-list instance */
952 LY_CHECK_RET(lyd_create_term2(path[u].node, &path[u].predicates[0].value, &target));
953 lyd_find_sibling_first(start, target, &node);
954 lyd_free_tree(target);
955 break;
956 case LY_PATH_PREDTYPE_LIST:
957 /* we will use hashes to find one list instance */
958 LY_CHECK_RET(lyd_create_list(path[u].node, path[u].predicates, &target));
959 lyd_find_sibling_first(start, target, &node);
960 lyd_free_tree(target);
961 break;
962 case LY_PATH_PREDTYPE_NONE:
963 /* we will use hashes to find one any/container/leaf instance */
964 lyd_find_sibling_val(start, path[u].node, NULL, 0, &node);
965 break;
966 }
967
968 if (!node) {
969 /* no matching nodes */
970 break;
971 }
972
Michal Vasko00cbf532020-06-15 13:58:47 +0200973 /* rememeber previous node */
974 prev_node = node;
975
Michal Vasko004d3152020-06-11 19:59:22 +0200976 /* next path segment, if any */
Radek Krejcia1c1e542020-09-29 16:06:52 +0200977 start = lyd_child(node);
Michal Vasko004d3152020-06-11 19:59:22 +0200978 }
979
Michal Vasko004d3152020-06-11 19:59:22 +0200980 if (node) {
Michal Vasko00cbf532020-06-15 13:58:47 +0200981 /* we have found the full path */
982 if (path_idx) {
983 *path_idx = u;
984 }
985 if (match) {
986 *match = node;
987 }
Michal Vasko004d3152020-06-11 19:59:22 +0200988 return LY_SUCCESS;
Michal Vasko00cbf532020-06-15 13:58:47 +0200989
990 } else if (prev_node) {
991 /* we have found only some partial match */
992 if (path_idx) {
993 *path_idx = u - 1;
994 }
995 if (match) {
996 *match = prev_node;
997 }
998 return LY_EINCOMPLETE;
999 }
1000
1001 /* we have not found any nodes */
1002 if (path_idx) {
1003 *path_idx = 0;
1004 }
1005 if (match) {
1006 *match = NULL;
1007 }
1008 return LY_ENOTFOUND;
1009}
1010
1011LY_ERR
1012ly_path_eval(const struct ly_path *path, const struct lyd_node *start, struct lyd_node **match)
1013{
1014 LY_ERR ret;
1015 struct lyd_node *m;
1016
1017 ret = ly_path_eval_partial(path, start, NULL, &m);
1018
1019 if (ret == LY_SUCCESS) {
1020 /* last node was found */
1021 if (match) {
1022 *match = m;
1023 }
1024 return LY_SUCCESS;
1025 }
1026
1027 /* not a full match */
1028 if (match) {
1029 *match = NULL;
Michal Vasko004d3152020-06-11 19:59:22 +02001030 }
1031 return LY_ENOTFOUND;
1032}
1033
1034LY_ERR
1035ly_path_dup(const struct ly_ctx *ctx, const struct ly_path *path, struct ly_path **dup)
1036{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001037 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko004d3152020-06-11 19:59:22 +02001038
1039 if (!path) {
1040 return LY_SUCCESS;
1041 }
1042
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001043 LY_ARRAY_CREATE_RET(ctx, *dup, LY_ARRAY_COUNT(path), LY_EMEM);
Michal Vasko004d3152020-06-11 19:59:22 +02001044 LY_ARRAY_FOR(path, u) {
1045 LY_ARRAY_INCREMENT(*dup);
1046 (*dup)[u].node = path[u].node;
1047 if (path[u].predicates) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001048 LY_ARRAY_CREATE_RET(ctx, (*dup)[u].predicates, LY_ARRAY_COUNT(path[u].predicates), LY_EMEM);
Michal Vasko004d3152020-06-11 19:59:22 +02001049 (*dup)[u].pred_type = path[u].pred_type;
1050 LY_ARRAY_FOR(path[u].predicates, v) {
1051 struct ly_path_predicate *pred = &path[u].predicates[v];
1052
1053 LY_ARRAY_INCREMENT((*dup)[u].predicates);
1054 switch (path[u].pred_type) {
1055 case LY_PATH_PREDTYPE_POSITION:
1056 /* position-predicate */
1057 (*dup)[u].predicates[v].position = pred->position;
1058 break;
1059 case LY_PATH_PREDTYPE_LIST:
1060 case LY_PATH_PREDTYPE_LEAFLIST:
1061 /* key-predicate or leaf-list-predicate */
1062 (*dup)[u].predicates[v].key = pred->key;
Michal Vasko004d3152020-06-11 19:59:22 +02001063 pred->value.realtype->plugin->duplicate(ctx, &pred->value, &(*dup)[u].predicates[v].value);
Michal Vaskoae875662020-10-21 10:33:17 +02001064 ++((struct lysc_type *)pred->value.realtype)->refcount;
Michal Vasko004d3152020-06-11 19:59:22 +02001065 break;
1066 case LY_PATH_PREDTYPE_NONE:
1067 break;
1068 }
1069 }
1070 }
1071 }
1072
1073 return LY_SUCCESS;
1074}
1075
1076void
Michal Vaskof7e16e22020-10-21 09:24:39 +02001077ly_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 +02001078{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001079 LY_ARRAY_COUNT_TYPE u;
Michal Vasko004d3152020-06-11 19:59:22 +02001080
1081 if (!predicates) {
1082 return;
1083 }
1084
1085 LY_ARRAY_FOR(predicates, u) {
1086 switch (pred_type) {
1087 case LY_PATH_PREDTYPE_POSITION:
1088 case LY_PATH_PREDTYPE_NONE:
1089 /* nothing to free */
1090 break;
1091 case LY_PATH_PREDTYPE_LIST:
Michal Vasko004d3152020-06-11 19:59:22 +02001092 case LY_PATH_PREDTYPE_LEAFLIST:
Michal Vaskoae875662020-10-21 10:33:17 +02001093 if (predicates[u].value.realtype) {
1094 predicates[u].value.realtype->plugin->free(ctx, &predicates[u].value);
1095 lysc_type_free((struct ly_ctx *)ctx, (struct lysc_type *)predicates[u].value.realtype);
1096 }
Michal Vasko004d3152020-06-11 19:59:22 +02001097 break;
1098 }
1099 }
1100 LY_ARRAY_FREE(predicates);
1101}
1102
1103void
1104ly_path_free(const struct ly_ctx *ctx, struct ly_path *path)
1105{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001106 LY_ARRAY_COUNT_TYPE u;
Michal Vasko004d3152020-06-11 19:59:22 +02001107
1108 LY_ARRAY_FOR(path, u) {
Michal Vaskof7e16e22020-10-21 09:24:39 +02001109 ly_path_predicates_free(ctx, path[u].pred_type, path[u].predicates);
Michal Vasko004d3152020-06-11 19:59:22 +02001110 }
1111 LY_ARRAY_FREE(path);
1112}