blob: b0be387dda2360d4d6af992716310e89fe209c8e [file] [log] [blame]
Radek Krejci3f5e3db2018-10-11 15:57:47 +02001/**
2 * @file tree_schema.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema tree implementation
5 *
6 * Copyright (c) 2015 - 2018 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 */
Radek Krejcib7db73a2018-10-24 14:18:40 +020014
Christian Hopps32874e12021-05-01 09:43:54 -040015#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejci535ea9f2020-05-29 16:01:05 +020016
Radek Krejcica376bd2020-06-11 16:04:06 +020017#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020018
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <assert.h>
Radek Krejci545b4872020-11-15 10:15:12 +010020#include <ctype.h>
Radek Krejcid33273d2018-10-25 14:55:52 +020021#include <dirent.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020022#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdint.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020024#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include <stdlib.h>
26#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020027#include <sys/stat.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020028#include <unistd.h>
Radek Krejci3f5e3db2018-10-11 15:57:47 +020029
Radek Krejcica376bd2020-06-11 16:04:06 +020030#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020031#include "compat.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020032#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020033#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020035#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020037#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020038#include "parser_schema.h"
Michal Vasko40308e72020-10-20 16:38:40 +020039#include "path.h"
Michal Vaskoc0c64ae2022-10-06 10:15:23 +020040#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020041#include "schema_compile.h"
Michal Vaskof4258e12021-06-15 12:11:42 +020042#include "schema_compile_amend.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010043#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020044#include "set.h"
45#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010046#include "tree_edit.h"
Michal Vaskoc636ea42022-09-16 10:20:31 +020047#include "tree_schema_free.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020048#include "tree_schema_internal.h"
49#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020050
Radek Krejcieccf6602021-02-05 19:42:54 +010051/**
52 * @brief information about YANG statements
53 */
54struct stmt_info_s stmt_attr_info[] = {
Radek Krejci6b88a462021-02-17 12:39:34 +010055 [LY_STMT_NONE] = {NULL, NULL, 0},
56 [LY_STMT_ACTION] = {"action", "name", STMT_FLAG_ID},
57 [LY_STMT_ANYDATA] = {"anydata", "name", STMT_FLAG_ID},
58 [LY_STMT_ANYXML] = {"anyxml", "name", STMT_FLAG_ID},
59 [LY_STMT_ARGUMENT] = {"argument", "name", STMT_FLAG_ID},
60 [LY_STMT_ARG_TEXT] = {"text", NULL, 0},
61 [LY_STMT_ARG_VALUE] = {"value", NULL, 0},
62 [LY_STMT_AUGMENT] = {"augment", "target-node", STMT_FLAG_ID},
63 [LY_STMT_BASE] = {"base", "name", STMT_FLAG_ID},
64 [LY_STMT_BELONGS_TO] = {"belongs-to", "module", STMT_FLAG_ID},
65 [LY_STMT_BIT] = {"bit", "name", STMT_FLAG_ID},
66 [LY_STMT_CASE] = {"case", "name", STMT_FLAG_ID},
67 [LY_STMT_CHOICE] = {"choice", "name", STMT_FLAG_ID},
68 [LY_STMT_CONFIG] = {"config", "value", STMT_FLAG_ID},
69 [LY_STMT_CONTACT] = {"contact", "text", STMT_FLAG_YIN},
70 [LY_STMT_CONTAINER] = {"container", "name", STMT_FLAG_ID},
71 [LY_STMT_DEFAULT] = {"default", "value", 0},
72 [LY_STMT_DESCRIPTION] = {"description", "text", STMT_FLAG_YIN},
73 [LY_STMT_DEVIATE] = {"deviate", "value", STMT_FLAG_ID},
74 [LY_STMT_DEVIATION] = {"deviation", "target-node", STMT_FLAG_ID},
75 [LY_STMT_ENUM] = {"enum", "name", STMT_FLAG_ID},
76 [LY_STMT_ERROR_APP_TAG] = {"error-app-tag", "value", 0},
77 [LY_STMT_ERROR_MESSAGE] = {"error-message", "value", STMT_FLAG_YIN},
78 [LY_STMT_EXTENSION] = {"extension", "name", STMT_FLAG_ID},
79 [LY_STMT_EXTENSION_INSTANCE] = {NULL, NULL, 0},
80 [LY_STMT_FEATURE] = {"feature", "name", STMT_FLAG_ID},
81 [LY_STMT_FRACTION_DIGITS] = {"fraction-digits", "value", STMT_FLAG_ID},
82 [LY_STMT_GROUPING] = {"grouping", "name", STMT_FLAG_ID},
83 [LY_STMT_IDENTITY] = {"identity", "name", STMT_FLAG_ID},
84 [LY_STMT_IF_FEATURE] = {"if-feature", "name", 0},
85 [LY_STMT_IMPORT] = {"import", "module", STMT_FLAG_ID},
86 [LY_STMT_INCLUDE] = {"include", "module", STMT_FLAG_ID},
87 [LY_STMT_INPUT] = {"input", NULL, 0},
88 [LY_STMT_KEY] = {"key", "value", 0},
89 [LY_STMT_LEAF] = {"leaf", "name", STMT_FLAG_ID},
90 [LY_STMT_LEAF_LIST] = {"leaf-list", "name", STMT_FLAG_ID},
91 [LY_STMT_LENGTH] = {"length", "value", 0},
92 [LY_STMT_LIST] = {"list", "name", STMT_FLAG_ID},
93 [LY_STMT_MANDATORY] = {"mandatory", "value", STMT_FLAG_ID},
94 [LY_STMT_MAX_ELEMENTS] = {"max-elements", "value", STMT_FLAG_ID},
95 [LY_STMT_MIN_ELEMENTS] = {"min-elements", "value", STMT_FLAG_ID},
96 [LY_STMT_MODIFIER] = {"modifier", "value", STMT_FLAG_ID},
97 [LY_STMT_MODULE] = {"module", "name", STMT_FLAG_ID},
98 [LY_STMT_MUST] = {"must", "condition", 0},
99 [LY_STMT_NAMESPACE] = {"namespace", "uri", 0},
100 [LY_STMT_NOTIFICATION] = {"notification", "name", STMT_FLAG_ID},
101 [LY_STMT_ORDERED_BY] = {"ordered-by", "value", STMT_FLAG_ID},
102 [LY_STMT_ORGANIZATION] = {"organization", "text", STMT_FLAG_YIN},
103 [LY_STMT_OUTPUT] = {"output", NULL, 0},
104 [LY_STMT_PATH] = {"path", "value", 0},
105 [LY_STMT_PATTERN] = {"pattern", "value", 0},
106 [LY_STMT_POSITION] = {"position", "value", STMT_FLAG_ID},
107 [LY_STMT_PREFIX] = {"prefix", "value", STMT_FLAG_ID},
108 [LY_STMT_PRESENCE] = {"presence", "value", 0},
109 [LY_STMT_RANGE] = {"range", "value", 0},
110 [LY_STMT_REFERENCE] = {"reference", "text", STMT_FLAG_YIN},
111 [LY_STMT_REFINE] = {"refine", "target-node", STMT_FLAG_ID},
112 [LY_STMT_REQUIRE_INSTANCE] = {"require-instance", "value", STMT_FLAG_ID},
113 [LY_STMT_REVISION] = {"revision", "date", STMT_FLAG_ID},
114 [LY_STMT_REVISION_DATE] = {"revision-date", "date", STMT_FLAG_ID},
115 [LY_STMT_RPC] = {"rpc", "name", STMT_FLAG_ID},
116 [LY_STMT_STATUS] = {"status", "value", STMT_FLAG_ID},
117 [LY_STMT_SUBMODULE] = {"submodule", "name", STMT_FLAG_ID},
118 [LY_STMT_SYNTAX_LEFT_BRACE] = {"{", NULL, 0},
119 [LY_STMT_SYNTAX_RIGHT_BRACE] = {"}", NULL, 0},
120 [LY_STMT_SYNTAX_SEMICOLON] = {";", NULL, 0},
121 [LY_STMT_TYPE] = {"type", "name", STMT_FLAG_ID},
122 [LY_STMT_TYPEDEF] = {"typedef", "name", STMT_FLAG_ID},
123 [LY_STMT_UNIQUE] = {"unique", "tag", 0},
124 [LY_STMT_UNITS] = {"units", "name", 0},
125 [LY_STMT_USES] = {"uses", "name", STMT_FLAG_ID},
126 [LY_STMT_VALUE] = {"value", "value", STMT_FLAG_ID},
127 [LY_STMT_WHEN] = {"when", "condition", 0},
128 [LY_STMT_YANG_VERSION] = {"yang-version", "value", STMT_FLAG_ID},
129 [LY_STMT_YIN_ELEMENT] = {"yin-element", "value", STMT_FLAG_ID},
Radek Krejcieccf6602021-02-05 19:42:54 +0100130};
131
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100132LIBYANG_API_DEF const char *
Radek Krejcif8ca8192021-03-02 16:50:06 +0100133ly_stmt2str(enum ly_stmt stmt)
134{
Michal Vaskocc64aec2021-05-18 17:33:11 +0200135 if (stmt == LY_STMT_EXTENSION_INSTANCE) {
136 return "extension instance";
137 } else {
138 return stmt_attr_info[stmt].name;
139 }
Radek Krejcif8ca8192021-03-02 16:50:06 +0100140}
141
Michal Vasko633ae8a2022-08-25 09:52:02 +0200142LIBYANG_API_DEF const char *
143ly_cardinality2str(enum ly_stmt_cardinality card)
144{
145 switch (card) {
146 case LY_STMT_CARD_OPT:
147 return "0..1";
148 case LY_STMT_CARD_MAND:
149 return "1";
150 case LY_STMT_CARD_SOME:
151 return "1..n";
152 case LY_STMT_CARD_ANY:
153 return "0..n";
154 }
155
156 return NULL;
157}
158
Radek Krejcieccf6602021-02-05 19:42:54 +0100159const char * const ly_devmod_list[] = {
160 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
161 [LYS_DEV_ADD] = "add",
162 [LYS_DEV_DELETE] = "delete",
163 [LYS_DEV_REPLACE] = "replace",
164};
165
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100166LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200167lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
168{
Michal Vasko1d972ca2020-11-03 17:16:56 +0100169 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100170 const struct lysc_node_action *action;
171 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200172
173 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
174
175 LYSC_TREE_DFS_BEGIN(root, elem) {
176 /* schema node */
177 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
178
Radek Krejci2a9fc652021-01-22 17:44:34 +0100179 LY_LIST_FOR(lysc_node_actions(elem), action) {
180 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200181 /* action subtree */
182 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
183
Radek Krejci2a9fc652021-01-22 17:44:34 +0100184 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200185 }
186 }
187
Radek Krejci2a9fc652021-01-22 17:44:34 +0100188 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
189 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200190 /* notification subtree */
191 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
192
Radek Krejci2a9fc652021-01-22 17:44:34 +0100193 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200194 }
195 }
196
197 LYSC_TREE_DFS_END(root, elem);
198 }
199
200 return LY_SUCCESS;
201}
202
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100203LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200204lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
205{
Michal Vasko2336cf52020-11-03 17:18:15 +0100206 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200207
208 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
209
210 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100211 LY_LIST_FOR(mod->compiled->data, root) {
212 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
213 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200214
215 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100216 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
217 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200218 }
219
220 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100221 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
222 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200223 }
224
225 return LY_SUCCESS;
226}
227
Radek Krejcib93bd412020-11-02 13:23:11 +0100228static void
229lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
230{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100231 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100232 if (first_case->child) {
233 /* there is something to return */
234 (*next) = first_case->child;
235 return;
236 }
237 }
238
239 /* no children in choice's cases, so go to the choice's sibling instead of into it */
240 (*last) = (*next);
241 (*next) = (*next)->next;
242}
243
Radek Krejci035dacf2021-02-12 18:25:53 +0100244/**
245 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
246 *
247 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
248 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
249 * extension instance.
250 *
251 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
252 * and function starts returning i) the first \p parent's child or ii) the first top level element specified in the
253 * given extension (if provided) or iii) the first top level element of the \p module.
254 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
255 * \p parent and \p module parameters.
256 *
257 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
258 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
259 * all the schema nodes are iteratively returned.
260 *
261 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
262 * @param[in] parent Parent of the subtree where the function starts processing.
263 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
264 * module must be specified.
265 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
266 * the \p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
267 * @param[in] options [ORed options](@ref sgetnextflags).
268 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
269 */
270static const struct lysc_node *
271lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
272 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100273{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100274 const struct lysc_node *next = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200275 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci035dacf2021-02-12 18:25:53 +0100276 struct lysc_node **data_p = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100277
Radek Krejci035dacf2021-02-12 18:25:53 +0100278 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100279
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200280next:
Radek Krejcia3045382018-11-22 14:30:31 +0100281 if (!last) {
282 /* first call */
283
284 /* get know where to start */
285 if (parent) {
286 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100287 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100288 } else {
289 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100290 if (ext) {
291 lysc_ext_substmt(ext, LY_STMT_CONTAINER /* matches all nodes */, (void **)&data_p, NULL);
292 next = last = data_p ? *data_p : NULL;
293 } else {
294 next = last = module->data;
295 }
Radek Krejcia3045382018-11-22 14:30:31 +0100296 }
297 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100298 /* try to get action or notification */
299 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100300 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100301 /* test if the next can be returned */
302 goto check;
303
Michal Vasko1bf09392020-03-27 12:38:10 +0100304 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100305 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100306 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100307 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100308 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100309 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200310 } else {
311 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100312 }
313
Radek Krejcia3045382018-11-22 14:30:31 +0100314repeat:
315 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100316 /* possibly go back to parent */
Radek Krejci035dacf2021-02-12 18:25:53 +0100317 data_p = NULL;
Michal Vasko69730152020-10-09 16:30:07 +0200318 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100319 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200320 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100321 } else if (!action_flag) {
322 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100323 if (ext) {
324 lysc_ext_substmt(ext, LY_STMT_RPC /* matches also actions */, (void **)&data_p, NULL);
325 next = data_p ? *data_p : NULL;
326 } else if (parent) {
327 next = (struct lysc_node *)lysc_node_actions(parent);
328 } else {
329 next = (struct lysc_node *)module->rpcs;
330 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100331 } else if (!notif_flag) {
332 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100333 if (ext) {
334 lysc_ext_substmt(ext, LY_STMT_NOTIFICATION, (void **)&data_p, NULL);
335 next = data_p ? *data_p : NULL;
336 } else if (parent) {
337 next = (struct lysc_node *)lysc_node_notifs(parent);
338 } else {
339 next = (struct lysc_node *)module->notifs;
340 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100341 } else {
342 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100343 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100344 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100345 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100346check:
Radek Krejcia3045382018-11-22 14:30:31 +0100347 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100348 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100349 case LYS_ACTION:
350 case LYS_NOTIF:
351 case LYS_LEAF:
352 case LYS_ANYXML:
353 case LYS_ANYDATA:
354 case LYS_LIST:
355 case LYS_LEAFLIST:
356 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200357 case LYS_CASE:
358 if (options & LYS_GETNEXT_WITHCASE) {
359 break;
360 } else {
361 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100362 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200363 }
364 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100365 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100366 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100367 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100368 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100369 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100370 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100371 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100372 next = next->next;
373 }
374 goto repeat;
375 }
376 break;
377 case LYS_CHOICE:
378 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200379 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100380 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100381 next = next->next;
382 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100383 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100384 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100385 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100386 /* go into */
387 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100388 }
Radek Krejcia3045382018-11-22 14:30:31 +0100389 }
390 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100391 case LYS_INPUT:
392 if (options & LYS_GETNEXT_OUTPUT) {
393 /* skip */
394 next = next->next;
395 } else {
396 /* go into */
397 next = lysc_node_child(next);
398 }
399 goto repeat;
400 case LYS_OUTPUT:
401 if (!(options & LYS_GETNEXT_OUTPUT)) {
402 /* skip */
403 next = next->next;
404 } else {
405 /* go into */
406 next = lysc_node_child(next);
407 }
408 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100409 default:
410 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100411 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100412 return NULL;
413 }
414
Radek Krejcia3045382018-11-22 14:30:31 +0100415 return next;
416}
417
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100418LIBYANG_API_DEF const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100419lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
420{
421 return lys_getnext_(last, parent, module, NULL, options);
422}
423
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100424LIBYANG_API_DEF const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100425lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
426{
427 return lys_getnext_(last, parent, NULL, ext, options);
428}
429
Radek Krejcif16e2542021-02-17 15:39:23 +0100430const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100431lysc_ext_find_node(const struct lysc_ext_instance *ext, const struct lys_module *module, const char *name, size_t name_len,
Radek Krejcif16e2542021-02-17 15:39:23 +0100432 uint16_t nodetype, uint32_t options)
433{
434 const struct lysc_node *node = NULL;
435
436 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
437 if (!nodetype) {
438 nodetype = LYS_NODETYPE_MASK;
439 }
440
441 if (module && (module != ext->module)) {
442 return NULL;
443 }
444
445 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
446 if (!(node->nodetype & nodetype)) {
447 continue;
448 }
449
450 if (name_len) {
451 if (!ly_strncmp(node->name, name, name_len)) {
452 return node;
453 }
454 } else {
455 if (!strcmp(node->name, name)) {
456 return node;
457 }
458 }
459 }
460 return NULL;
461}
462
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100463LIBYANG_API_DEF const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100464lys_find_child(const struct lysc_node *parent, const struct lys_module *module, const char *name, size_t name_len,
Radek Krejci1deb5be2020-08-26 16:43:36 +0200465 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100466{
467 const struct lysc_node *node = NULL;
468
469 LY_CHECK_ARG_RET(NULL, module, name, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100470 LY_CHECK_CTX_EQUAL_RET(parent ? parent->module->ctx : NULL, module->ctx, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100471 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100472 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100473 }
474
475 while ((node = lys_getnext(node, parent, module->compiled, options))) {
476 if (!(node->nodetype & nodetype)) {
477 continue;
478 }
479 if (node->module != module) {
480 continue;
481 }
482
483 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200484 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100485 return node;
486 }
487 } else {
488 if (!strcmp(node->name, name)) {
489 return node;
490 }
491 }
492 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100493
Radek Krejcia3045382018-11-22 14:30:31 +0100494 return NULL;
495}
496
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100497LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100498lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
499 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200500{
501 LY_ERR ret = LY_SUCCESS;
502 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200503 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200504 uint32_t i;
505
Michal Vasko26512682021-01-11 11:35:40 +0100506 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100507 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200508 if (!(options & LYXP_SCNODE_ALL)) {
Michal Vasko4ad69e72021-10-26 16:25:55 +0200509 options |= LYXP_SCNODE;
Michal Vasko519fd602020-05-26 12:17:39 +0200510 }
Michal Vasko26512682021-01-11 11:35:40 +0100511 if (!ctx) {
512 ctx = ctx_node->module->ctx;
513 }
Michal Vasko519fd602020-05-26 12:17:39 +0200514
515 memset(&xp_set, 0, sizeof xp_set);
516
517 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100518 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200519 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200520
521 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200522 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200523 LY_CHECK_GOTO(ret, cleanup);
524
525 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200526 ret = ly_set_new(set);
527 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200528
529 /* transform into ly_set */
530 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100531 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200532 (*set)->size = xp_set.used;
533
534 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200535 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200536 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200537 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200538 }
539 }
540
541cleanup:
542 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100543 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200544 return ret;
545}
546
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100547LIBYANG_API_DEF LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200548lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
549 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
550{
551 LY_ERR ret = LY_SUCCESS;
552 struct lyxp_set xp_set = {0};
553 uint32_t i;
554
555 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100556 LY_CHECK_CTX_EQUAL_RET(ctx_node ? ctx_node->module->ctx : NULL, cur_mod->ctx, LY_EINVAL);
Michal Vasko40308e72020-10-20 16:38:40 +0200557 if (!(options & LYXP_SCNODE_ALL)) {
558 options = LYXP_SCNODE;
559 }
560
561 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200562 ret = lyxp_atomize(cur_mod->ctx, expr, cur_mod, LY_VALUE_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, ctx_node,
563 &xp_set, options);
Michal Vasko40308e72020-10-20 16:38:40 +0200564 LY_CHECK_GOTO(ret, cleanup);
565
566 /* allocate return set */
567 ret = ly_set_new(set);
568 LY_CHECK_GOTO(ret, cleanup);
569
570 /* transform into ly_set */
571 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
572 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
573 (*set)->size = xp_set.used;
574
575 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200576 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
577 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
578 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100579 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200580 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
581 LY_CHECK_GOTO(ret, cleanup);
582 }
583 }
584
585cleanup:
586 lyxp_set_free_content(&xp_set);
587 if (ret) {
588 ly_set_free(*set, NULL);
589 *set = NULL;
590 }
591 return ret;
592}
593
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100594LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100595lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
596 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200597{
598 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200599 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200600 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200601 uint32_t i;
602
Michal Vasko26512682021-01-11 11:35:40 +0100603 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100604 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200605 if (!(options & LYXP_SCNODE_ALL)) {
606 options = LYXP_SCNODE;
607 }
Michal Vasko26512682021-01-11 11:35:40 +0100608 if (!ctx) {
609 ctx = ctx_node->module->ctx;
610 }
Michal Vasko072de482020-08-05 13:27:21 +0200611
Michal Vasko072de482020-08-05 13:27:21 +0200612 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100613 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200614 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200615
616 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200617 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200618 LY_CHECK_GOTO(ret, cleanup);
619
620 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200621 ret = ly_set_new(set);
622 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200623
624 /* transform into ly_set */
625 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100626 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200627 (*set)->size = xp_set.used;
628
629 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100630 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200631 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200632 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200633 }
634 }
635
636cleanup:
637 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100638 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200639 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200640 ly_set_free(*set, NULL);
641 *set = NULL;
642 }
Michal Vasko072de482020-08-05 13:27:21 +0200643 return ret;
644}
645
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100646LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100647lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
648{
649 LY_ERR ret = LY_SUCCESS;
650 LY_ARRAY_COUNT_TYPE u, v;
651
652 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
653
654 /* allocate return set */
655 LY_CHECK_RET(ly_set_new(set));
656
657 LY_ARRAY_FOR(path, u) {
658 /* add nodes from the path */
659 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
660 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
661 LY_ARRAY_FOR(path[u].predicates, v) {
662 /* add all the keys in a predicate */
663 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
664 }
665 }
666 }
667
668cleanup:
669 if (ret) {
670 ly_set_free(*set, NULL);
671 *set = NULL;
672 }
673 return ret;
674}
675
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100676LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100677lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
678 struct ly_set **set)
679{
680 LY_ERR ret = LY_SUCCESS;
681 uint8_t oper;
682 struct lyxp_expr *expr = NULL;
683 struct ly_path *p = NULL;
684
685 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100686 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100687
688 if (!ctx) {
689 ctx = ctx_node->module->ctx;
690 }
691
692 /* parse */
693 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
694 LY_CHECK_GOTO(ret, cleanup);
695
696 /* compile */
697 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200698 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100699 LY_CHECK_GOTO(ret, cleanup);
700
701 /* resolve */
702 ret = lys_find_lypath_atoms(p, set);
703
704cleanup:
705 ly_path_free(ctx, p);
706 lyxp_expr_free(ctx, expr);
707 return ret;
708}
709
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100710LIBYANG_API_DEF const struct lysc_node *
Radek Krejcibc5644c2020-10-27 14:53:17 +0100711lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
712{
713 const struct lysc_node *snode = NULL;
714 struct lyxp_expr *exp = NULL;
715 struct ly_path *p = NULL;
716 LY_ERR ret;
717 uint8_t oper;
718
719 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100720 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, NULL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100721
722 if (!ctx) {
723 ctx = ctx_node->module->ctx;
724 }
725
726 /* parse */
727 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
728 LY_CHECK_GOTO(ret, cleanup);
729
730 /* compile */
731 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200732 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, exp, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100733 LY_CHECK_GOTO(ret, cleanup);
734
735 /* get last node */
736 snode = p[LY_ARRAY_COUNT(p) - 1].node;
737
738cleanup:
739 ly_path_free(ctx, p);
740 lyxp_expr_free(ctx, exp);
741 return snode;
742}
743
Michal Vasko14654712020-02-06 08:35:21 +0100744char *
745lysc_path_until(const struct lysc_node *node, const struct lysc_node *parent, LYSC_PATH_TYPE pathtype, char *buffer,
Radek Krejci0f969882020-08-21 16:56:47 +0200746 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200747{
Michal Vaskobde22b62022-03-22 15:32:56 +0100748 const struct lysc_node *iter, *par, *key;
Radek Krejci327de162019-06-14 12:52:07 +0200749 char *path = NULL;
750 int len = 0;
Michal Vaskobde22b62022-03-22 15:32:56 +0100751 ly_bool skip_schema;
Radek Krejci327de162019-06-14 12:52:07 +0200752
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200753 if (buffer) {
754 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100755 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200756 }
757
Michal Vaskobde22b62022-03-22 15:32:56 +0100758 if ((pathtype == LYSC_PATH_DATA) || (pathtype == LYSC_PATH_DATA_PATTERN)) {
759 /* skip schema-only nodes */
760 skip_schema = 1;
761 } else {
762 skip_schema = 0;
763 }
Radek Krejci327de162019-06-14 12:52:07 +0200764
Michal Vaskobde22b62022-03-22 15:32:56 +0100765 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
766 char *s;
767 const char *slash;
Michal Vasko65de0402020-08-03 16:34:19 +0200768
Michal Vaskobde22b62022-03-22 15:32:56 +0100769 if (skip_schema && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
770 /* schema-only node */
771 continue;
772 }
Michal Vasko87dd1342021-08-23 16:17:55 +0200773
Michal Vaskobde22b62022-03-22 15:32:56 +0100774 if ((pathtype == LYSC_PATH_DATA_PATTERN) && (iter->nodetype == LYS_LIST)) {
775 key = NULL;
776 while ((key = lys_getnext(key, iter, NULL, 0)) && lysc_is_key(key)) {
777 s = buffer ? strdup(buffer) : path;
Michal Vasko87dd1342021-08-23 16:17:55 +0200778
Michal Vaskobde22b62022-03-22 15:32:56 +0100779 /* print key predicate */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200780 if (buffer) {
Michal Vaskobde22b62022-03-22 15:32:56 +0100781 len = snprintf(buffer, buflen, "[%s='%%s']%s", key->name, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200782 } else {
Michal Vaskobde22b62022-03-22 15:32:56 +0100783 len = asprintf(&path, "[%s='%%s']%s", key->name, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200784 }
Michal Vaskobde22b62022-03-22 15:32:56 +0100785 free(s);
Michal Vasko28d03812022-03-24 15:26:11 +0100786
787 if (buffer && (buflen <= (size_t)len)) {
788 /* not enough space in buffer */
789 break;
790 }
Radek Krejci1c0c3442019-07-23 16:08:47 +0200791 }
Radek Krejci327de162019-06-14 12:52:07 +0200792 }
793
Michal Vaskobde22b62022-03-22 15:32:56 +0100794 s = buffer ? strdup(buffer) : path;
795 if (parent && (iter->parent == parent)) {
796 slash = "";
797 } else {
798 slash = "/";
799 }
800
801 if (skip_schema) {
802 par = lysc_data_parent(iter);
803 } else {
804 par = iter->parent;
805 }
806
807 if (!par || (par->module != iter->module)) {
808 /* print prefix */
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200809 if (buffer) {
Michal Vaskobde22b62022-03-22 15:32:56 +0100810 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : "");
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200811 } else {
Michal Vaskobde22b62022-03-22 15:32:56 +0100812 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : "");
813 }
814 } else {
815 /* prefix is the same as in parent */
816 if (buffer) {
817 len = snprintf(buffer, buflen, "%s%s%s", slash, iter->name, s ? s : "");
818 } else {
819 len = asprintf(&path, "%s%s%s", slash, iter->name, s ? s : "");
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200820 }
Radek Krejci327de162019-06-14 12:52:07 +0200821 }
Michal Vaskobde22b62022-03-22 15:32:56 +0100822 free(s);
823
824 if (buffer && (buflen <= (size_t)len)) {
825 /* not enough space in buffer */
826 break;
827 }
828 }
829
830 if (len < 0) {
831 free(path);
832 path = NULL;
833 } else if (len == 0) {
834 if (buffer) {
835 strcpy(buffer, "/");
836 } else {
837 path = strdup("/");
838 }
Radek Krejci327de162019-06-14 12:52:07 +0200839 }
840
Radek Krejci1c0c3442019-07-23 16:08:47 +0200841 if (buffer) {
842 return buffer;
843 } else {
844 return path;
845 }
Radek Krejci327de162019-06-14 12:52:07 +0200846}
847
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100848LIBYANG_API_DEF char *
Michal Vasko14654712020-02-06 08:35:21 +0100849lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
850{
851 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
852}
853
Michal Vasko405cc9e2020-12-01 12:01:27 +0100854LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200855_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100856{
857 LY_ERR ret = LY_SUCCESS, r;
aPiecek6b3d5422021-07-30 15:55:43 +0200858 struct lys_module *mod_iter;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200859 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vasko65333882021-06-10 14:12:16 +0200860 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100861
Michal Vasko405cc9e2020-12-01 12:01:27 +0100862 if (mod->implemented) {
863 /* mod is already implemented, set the features */
864 r = lys_set_features(mod->parsed, features);
865 if (r == LY_EEXIST) {
866 /* no changes */
867 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200868 } else if (!r) {
869 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200870 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200871 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200872
873 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200874 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100875
Michal Vasko7213ac52021-06-15 11:52:13 +0200876 /* implement, ignore recompilation because it must always take place later */
877 r = lys_implement(mod, features, unres);
878 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200879
880 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
881 /* implement all the imports as well */
882 for (i = 0; i < unres->creating.count; ++i) {
883 mod = unres->creating.objs[i];
884 if (mod->implemented) {
885 continue;
886 }
887
Michal Vaskoc56d6372021-10-19 12:29:00 +0200888 imp_f = (mod->ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
889 r = lys_implement(mod, imp_f, unres);
Michal Vasko7213ac52021-06-15 11:52:13 +0200890 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200891 }
892 }
893
aPiecek6b3d5422021-07-30 15:55:43 +0200894 /* Try to find module with LYS_MOD_IMPORTED_REV flag. */
895 i = 0;
896 while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) {
Michal Vaskoe8b085b2021-09-02 08:20:08 +0200897 if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) {
898 LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing"
899 " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision,
900 mod_iter->revision);
aPiecek6b3d5422021-07-30 15:55:43 +0200901 break;
902 }
903 }
904
Michal Vasko65333882021-06-10 14:12:16 +0200905cleanup:
906 return ret;
907}
908
Michal Vaskof4258e12021-06-15 12:11:42 +0200909/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200910 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
911 * and if so, add it into its dep set.
912 *
913 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
914 * in the dep set are (re)compiled.
915 *
916 * The reason for recompilation is possible disabled nodes and updating
917 * leafref targets to point to the newly compiled modules. Using the import relation, the
918 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
919 * during the target module compilation.
920 *
921 * - every module must belong to exactly one dep set
922 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200923 *
924 * @param[in] mod Module to process.
925 * @param[in,out] ctx_set Set with all not-yet-processed modules.
926 * @param[in,out] dep_set Current dependency set to update.
Michal Vasko775fbd02021-07-28 08:25:29 +0200927 * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call.
Michal Vaskof4258e12021-06-15 12:11:42 +0200928 * @return LY_ERR value.
929 */
930static LY_ERR
Michal Vasko775fbd02021-07-28 08:25:29 +0200931lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set,
932 struct ly_set *aux_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200933{
934 struct lys_module *mod2;
935 struct lysp_import *imports;
936 uint32_t i;
937 LY_ARRAY_COUNT_TYPE u, v;
938 ly_bool found;
939
Michal Vasko0bccbf12021-11-22 09:59:57 +0100940 if (LYS_IS_SINGLE_DEP_SET(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200941 /* is already in a separate dep set */
Michal Vasko87cfdba2022-02-22 14:13:45 +0100942 if (!lys_has_dep_mods(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200943 /* break the dep set here, no modules depend on this one */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200944 return LY_SUCCESS;
945 }
Michal Vasko775fbd02021-07-28 08:25:29 +0200946
947 if (ly_set_contains(aux_set, mod, NULL)) {
948 /* it was traversed */
949 return LY_SUCCESS;
950 }
951
952 /* add a new auxiliary module */
953 LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL));
Michal Vasko7ee5be22021-06-16 17:03:34 +0200954 } else {
Michal Vasko709f9a52021-07-21 10:51:59 +0200955 if (!ly_set_contains(ctx_set, mod, &i)) {
956 /* it was already processed */
957 return LY_SUCCESS;
958 }
959
960 /* remove it from the set, we are processing it now */
961 ly_set_rm_index(ctx_set, i, NULL);
962
Michal Vasko7ee5be22021-06-16 17:03:34 +0200963 /* add a new dependent module into the dep set */
964 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200965 }
966
967 /* process imports of the module and submodules */
968 imports = mod->parsed->imports;
969 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200970 mod2 = imports[u].module;
Michal Vasko775fbd02021-07-28 08:25:29 +0200971 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200972 }
973 LY_ARRAY_FOR(mod->parsed->includes, v) {
974 imports = mod->parsed->includes[v].submodule->imports;
975 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200976 mod2 = imports[u].module;
Michal Vasko87cfdba2022-02-22 14:13:45 +0100977 if (LYS_IS_SINGLE_DEP_SET(mod2) && !lys_has_dep_mods(mod2)) {
978 /* break the dep set here, no modules depend on this one */
979 continue;
Michal Vasko709f9a52021-07-21 10:51:59 +0200980 }
981
Michal Vasko775fbd02021-07-28 08:25:29 +0200982 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(imports[u].module, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200983 }
984 }
985
986 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200987 for (i = 0; i < mod->ctx->list.count; ++i) {
988 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200989 found = 0;
990
991 imports = mod2->parsed->imports;
992 LY_ARRAY_FOR(imports, u) {
993 if (imports[u].module == mod) {
994 found = 1;
995 break;
996 }
997 }
998
999 if (!found) {
1000 LY_ARRAY_FOR(mod2->parsed->includes, v) {
1001 imports = mod2->parsed->includes[v].submodule->imports;
1002 LY_ARRAY_FOR(imports, u) {
1003 if (imports[u].module == mod) {
1004 found = 1;
1005 break;
1006 }
1007 }
1008
1009 if (found) {
1010 break;
1011 }
1012 }
1013 }
1014
1015 if (found) {
Michal Vasko775fbd02021-07-28 08:25:29 +02001016 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +02001017 }
1018 }
1019
1020 return LY_SUCCESS;
1021}
1022
Michal Vasko709f9a52021-07-21 10:51:59 +02001023/**
1024 * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets.
1025 *
1026 * @param[in,out] ctx_set Set with all not-yet-processed modules.
1027 * @param[in,out] main_set Set of dependency module sets.
1028 * @return LY_ERR value.
1029 */
1030static LY_ERR
1031lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set)
1032{
1033 LY_ERR ret = LY_SUCCESS;
1034 struct lys_module *m;
1035 uint32_t i = 0;
1036 struct ly_set *dep_set = NULL;
1037
1038 while (i < ctx_set->count) {
1039 m = ctx_set->objs[i];
Michal Vasko0bccbf12021-11-22 09:59:57 +01001040 if (LYS_IS_SINGLE_DEP_SET(m)) {
Michal Vasko709f9a52021-07-21 10:51:59 +02001041 /* remove it from the set, we are processing it now */
1042 ly_set_rm_index(ctx_set, i, NULL);
1043
1044 /* this module can be in a separate dep set (but there still may be modules importing this one
1045 * that depend on imports of this one in case it defines groupings) */
1046 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1047 LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup);
1048 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
1049 dep_set = NULL;
1050 } else {
1051 ++i;
1052 }
1053 }
1054
1055cleanup:
1056 ly_set_free(dep_set, NULL);
1057 return ret;
1058}
1059
Michal Vaskof4258e12021-06-15 12:11:42 +02001060LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +02001061lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +02001062{
1063 LY_ERR ret = LY_SUCCESS;
1064 struct lys_module *m;
Michal Vasko775fbd02021-07-28 08:25:29 +02001065 struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0};
Michal Vaskof4258e12021-06-15 12:11:42 +02001066 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +02001067 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +02001068
Michal Vasko22b26222021-07-30 11:16:47 +02001069 assert(!main_set->count);
1070
Michal Vaskof4258e12021-06-15 12:11:42 +02001071 /* start with a duplicate set of modules that we will remove from */
1072 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
1073
Michal Vasko709f9a52021-07-21 10:51:59 +02001074 /* first create all dep sets with single modules */
1075 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup);
1076
1077 if (mod && !ly_set_contains(ctx_set, mod, NULL)) {
1078 /* dep set for this module has already been created, nothing else to do */
1079 goto cleanup;
1080 }
1081
Michal Vaskof4258e12021-06-15 12:11:42 +02001082 while (ctx_set->count) {
1083 /* create new dep set */
1084 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1085
1086 if (mod) {
1087 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001088 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(mod, ctx_set, dep_set, &aux_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001089 } else {
1090 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001091 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(ctx_set->objs[0], ctx_set, dep_set, &aux_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001092 }
Michal Vasko775fbd02021-07-28 08:25:29 +02001093 ly_set_erase(&aux_set, NULL);
Michal Vasko7ee5be22021-06-16 17:03:34 +02001094 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001095
1096 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001097 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001098 for (i = 0; i < dep_set->count; ++i) {
1099 m = dep_set->objs[i];
1100 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001101 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +02001102 break;
1103 }
1104 }
1105
Michal Vasko7ee5be22021-06-16 17:03:34 +02001106 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001107 /* if there is, all the implemented modules need to be recompiled */
1108 for (i = 0; i < dep_set->count; ++i) {
1109 m = dep_set->objs[i];
1110 if (m->implemented) {
1111 m->to_compile = 1;
1112 }
1113 }
1114 }
1115
Michal Vasko7ee5be22021-06-16 17:03:34 +02001116 /* add the dep set into main set */
1117 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001118 dep_set = NULL;
1119
1120 if (mod) {
1121 /* we need dep set only for this module */
1122 break;
1123 }
1124 }
1125
Michal Vaskoe558f792021-07-28 08:20:15 +02001126#ifndef NDEBUG
1127 LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count);
1128 for (i = 0; i < main_set->count; ++i) {
1129 struct ly_set *iter_set = main_set->objs[i];
1130
1131 LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i);
1132 for (uint32_t j = 0; j < iter_set->count; ++j) {
1133 m = iter_set->objs[j];
1134 LOGDBG(LY_LDGDEPSETS, "\t%s", m->name);
1135 }
1136 }
1137#endif
1138
Michal Vaskof4258e12021-06-15 12:11:42 +02001139cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +02001140 assert(ret || main_set->objs);
Michal Vasko775fbd02021-07-28 08:25:29 +02001141 ly_set_erase(&aux_set, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001142 ly_set_free(dep_set, NULL);
1143 ly_set_free(ctx_set, NULL);
1144 return ret;
1145}
1146
1147void
1148lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1149{
1150 uint32_t i, j, idx, prev_lo;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001151 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vaskof4258e12021-06-15 12:11:42 +02001152 struct ly_set *dep_set;
Michal Vaskof4258e12021-06-15 12:11:42 +02001153 LY_ERR ret;
1154
1155 for (i = 0; i < unres->implementing.count; ++i) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001156 fctx.mod = unres->implementing.objs[i];
1157 assert(fctx.mod->implemented);
Michal Vaskof4258e12021-06-15 12:11:42 +02001158
1159 /* make the module correctly non-implemented again */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001160 fctx.mod->implemented = 0;
1161 lys_precompile_augments_deviations_revert(ctx, fctx.mod);
1162 lysc_module_free(&fctx, fctx.mod->compiled);
1163 fctx.mod->compiled = NULL;
Michal Vaskof4258e12021-06-15 12:11:42 +02001164
1165 /* should not be made implemented */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001166 fctx.mod->to_compile = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001167 }
1168
1169 for (i = 0; i < unres->creating.count; ++i) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001170 fctx.mod = unres->creating.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +02001171
Michal Vaskod297f2a2021-06-16 11:51:28 +02001172 /* remove the module from the context */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001173 ly_set_rm(&ctx->list, fctx.mod, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001174
Michal Vasko22b26222021-07-30 11:16:47 +02001175 /* remove it also from dep sets */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001176 for (j = 0; j < unres->dep_sets.count; ++j) {
1177 dep_set = unres->dep_sets.objs[j];
Michal Vaskoc636ea42022-09-16 10:20:31 +02001178 if (ly_set_contains(dep_set, fctx.mod, &idx)) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001179 ly_set_rm_index(dep_set, idx, NULL);
1180 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001181 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001182 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001183
1184 /* free the module */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001185 lys_module_free(&fctx, fctx.mod, 1);
Michal Vaskof4258e12021-06-15 12:11:42 +02001186 }
1187
Michal Vaskoc636ea42022-09-16 10:20:31 +02001188 /* remove the extensions as well */
1189 lysf_ctx_erase(&fctx);
1190
Michal Vaskof4258e12021-06-15 12:11:42 +02001191 if (unres->implementing.count) {
1192 /* recompile previous context because some implemented modules are no longer implemented,
1193 * we can reuse the current to_compile flags */
1194 prev_lo = ly_log_options(0);
Michal Vasko22b26222021-07-30 11:16:47 +02001195 ret = lys_compile_depset_all(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001196 ly_log_options(prev_lo);
1197 if (ret) {
1198 LOGINT(ctx);
1199 }
1200 }
1201}
1202
1203void
1204lys_unres_glob_erase(struct lys_glob_unres *unres)
1205{
1206 uint32_t i;
1207
1208 for (i = 0; i < unres->dep_sets.count; ++i) {
1209 ly_set_free(unres->dep_sets.objs[i], NULL);
1210 }
1211 ly_set_erase(&unres->dep_sets, NULL);
1212 ly_set_erase(&unres->implementing, NULL);
1213 ly_set_erase(&unres->creating, NULL);
1214
Michal Vaskoc130e162021-10-19 11:30:00 +02001215 assert(!unres->ds_unres.whens.count);
1216 assert(!unres->ds_unres.musts.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001217 assert(!unres->ds_unres.leafrefs.count);
aPiecekc6526b42021-07-12 15:21:39 +02001218 assert(!unres->ds_unres.disabled_leafrefs.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001219 assert(!unres->ds_unres.dflts.count);
1220 assert(!unres->ds_unres.disabled.count);
1221}
1222
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001223LIBYANG_API_DEF LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +02001224lys_set_implemented(struct lys_module *mod, const char **features)
1225{
1226 LY_ERR ret = LY_SUCCESS;
Michal Vasko22b26222021-07-30 11:16:47 +02001227 struct lys_glob_unres *unres = &mod->ctx->unres;
Michal Vasko65333882021-06-10 14:12:16 +02001228
1229 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1230
1231 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001232 ret = _lys_set_implemented(mod, features, unres);
Michal Vasko65333882021-06-10 14:12:16 +02001233 LY_CHECK_GOTO(ret, cleanup);
1234
Michal Vaskof4258e12021-06-15 12:11:42 +02001235 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1236 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001237 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001238
Michal Vasko709f9a52021-07-21 10:51:59 +02001239 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001240 LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup);
1241
1242 /* unres resolved */
1243 lys_unres_glob_erase(unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001244 }
1245
Michal Vasko65333882021-06-10 14:12:16 +02001246cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001247 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001248 lys_unres_glob_revert(mod->ctx, unres);
1249 lys_unres_glob_erase(unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001250 }
Michal Vasko89b5c072020-10-06 13:52:44 +02001251 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001252}
1253
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001254/**
1255 * @brief Resolve (find) all imported and included modules.
1256 *
1257 * @param[in] pctx Parser context.
1258 * @param[in] pmod Parsed module to resolve.
1259 * @param[out] new_mods Set with all the newly loaded modules.
1260 * @return LY_ERR value.
1261 */
Michal Vasko7c8439f2020-08-05 13:25:19 +02001262static LY_ERR
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001263lysp_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001264{
1265 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001266 LY_ARRAY_COUNT_TYPE u, v;
1267
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001268 pmod->parsing = 1;
1269 LY_ARRAY_FOR(pmod->imports, u) {
1270 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001271 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001272 LY_CHECK_RET(lys_parse_load(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, new_mods, &imp->module));
aPiecekd4911ee2021-07-30 07:40:24 +02001273
1274 if (!imp->rev[0]) {
1275 /* This module must be selected for the next similar
1276 * import without revision-date to avoid incorrect
1277 * derived identities in the ::lys_module.identities.
1278 */
1279 imp->module->latest_revision |= LYS_MOD_IMPORTED_REV;
1280 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001281 }
1282 /* check for importing the same module twice */
1283 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001284 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001285 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1286 }
1287 }
1288 }
aPiecekc3e26142021-06-22 14:25:49 +02001289 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001290
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001291 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001292
1293 return LY_SUCCESS;
1294}
1295
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001296/**
1297 * @brief Resolve (find) all extension instance records and finish their parsing.
1298 *
1299 * @param[in] pctx Parse context with all the parsed extension instances.
1300 * @return LY_ERR value.
1301 */
1302static LY_ERR
1303lysp_resolve_ext_instance_records(struct lys_parser_ctx *pctx)
1304{
1305 struct lysp_ext_instance *exts, *ext;
1306 const struct lys_module *mod;
1307 const char *ptr;
1308 uint32_t i;
1309 LY_ARRAY_COUNT_TYPE u;
1310
1311 for (i = 0; i < pctx->ext_inst.count; ++i) {
1312 exts = pctx->ext_inst.objs[i];
1313 LY_ARRAY_FOR(exts, u) {
1314 ext = &exts[u];
1315
1316 /* find the extension (definition) module */
1317 ptr = strchr(ext->name, ':');
1318 assert(ptr);
1319 mod = ly_resolve_prefix(PARSER_CTX(pctx), ext->name, ptr - ext->name, ext->format, ext->prefix_data);
1320 if (!mod) {
1321 LOGVAL(PARSER_CTX(pctx), LYVE_SYNTAX, "Unknown prefix \"%*.s\" used for an extension instance.",
1322 (int)(ptr - ext->name), ext->name);
1323 return LY_ENOTFOUND;
1324 }
1325
1326 /* find the extension record, if any */
1327 ++ptr;
1328 ext->record = lyplg_ext_record_find(mod->name, mod->revision, ptr);
1329 }
1330 }
1331
1332 return LY_SUCCESS;
1333}
1334
Michal Vasko3a41dff2020-07-15 14:30:28 +02001335LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001336lys_parse_submodule(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, struct lys_parser_ctx *main_ctx,
Michal Vasko22df3f02020-08-24 13:29:22 +02001337 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001338 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001339{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001340 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001341 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +01001342 struct lys_yang_parser_ctx *yangctx = NULL;
1343 struct lys_yin_parser_ctx *yinctx = NULL;
1344 struct lys_parser_ctx *pctx;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001345 struct lysf_ctx fctx = {.ctx = ctx};
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001346
Michal Vasko3a41dff2020-07-15 14:30:28 +02001347 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001348
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001349 switch (format) {
1350 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001351 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001352 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001353 break;
1354 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001355 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001356 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001357 break;
1358 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001359 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001360 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001361 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001362 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001363 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001364 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001365
1366 /* make sure that the newest revision is at position 0 */
1367 lysp_sort_revisions(submod->revs);
1368
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001369 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001370 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001371 if (latest_sp) {
1372 if (submod->revs) {
1373 if (!latest_sp->revs) {
1374 /* latest has no revision, so mod is anyway newer */
1375 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001376 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1377 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1378 submod->latest_revision = latest_sp->latest_revision;
1379 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001380 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001381 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001382 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001383 } else {
1384 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001385 }
1386 } else {
1387 submod->latest_revision = 1;
1388 }
1389
Radek Krejcib3289d62019-09-18 12:21:39 +02001390 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001391 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001392 }
1393
1394 if (latest_sp) {
1395 latest_sp->latest_revision = 0;
1396 }
1397
Michal Vasko7a0b0762020-09-02 16:37:01 +02001398 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1399
Michal Vasko7c8439f2020-08-05 13:25:19 +02001400 /* resolve imports and includes */
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001401 LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
1402
1403 /* resolve extension instance plugin records */
1404 LY_CHECK_GOTO(ret = lysp_resolve_ext_instance_records(pctx), error);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001405
David Sedlák1b623122019-08-05 15:27:49 +02001406 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001407 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001408 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001409 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001410 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001411 *submodule = submod;
1412 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001413
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001414error:
Radek Krejcic64661b2020-08-15 15:42:26 +02001415 if (!submod || !submod->name) {
1416 LOGERR(ctx, ret, "Parsing submodule failed.");
1417 } else {
1418 LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name);
1419 }
Michal Vaskoc636ea42022-09-16 10:20:31 +02001420 lysp_module_free(&fctx, (struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001421 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001422 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001423 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001424 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001425 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001426 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001427}
1428
Michal Vasko45b521c2020-11-04 17:14:39 +01001429/**
1430 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1431 *
1432 * @param[in] mod Parsed module to add to.
1433 * @return LY_SUCCESS on success.
1434 * @return LY_ERR on error.
1435 */
1436static LY_ERR
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001437lysp_add_internal_ietf_netconf(struct lysp_module *mod)
Michal Vasko45b521c2020-11-04 17:14:39 +01001438{
1439 struct lysp_ext_instance *ext_p;
1440 struct lysp_stmt *stmt;
1441 struct lysp_import *imp;
1442
1443 /*
1444 * 1) edit-config's operation
1445 */
1446 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1447 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1448 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1449 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001450 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001451 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001452 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001453 ext_p->parent_stmt = LY_STMT_MODULE;
1454 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001455
1456 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1457 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1458 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1459 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001460 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001461 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001462 stmt->kw = LY_STMT_TYPE;
1463
1464 stmt->child = calloc(1, sizeof *stmt->child);
1465 stmt = stmt->child;
1466 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1467 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1468 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001469 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001470 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001471 stmt->kw = LY_STMT_ENUM;
1472
1473 stmt->next = calloc(1, sizeof *stmt->child);
1474 stmt = stmt->next;
1475 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1476 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1477 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001478 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001479 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001480 stmt->kw = LY_STMT_ENUM;
1481
1482 stmt->next = calloc(1, sizeof *stmt->child);
1483 stmt = stmt->next;
1484 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1485 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1486 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001487 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001488 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001489 stmt->kw = LY_STMT_ENUM;
1490
1491 stmt->next = calloc(1, sizeof *stmt->child);
1492 stmt = stmt->next;
1493 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1494 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1495 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001496 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001497 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001498 stmt->kw = LY_STMT_ENUM;
1499
1500 stmt->next = calloc(1, sizeof *stmt->child);
1501 stmt = stmt->next;
1502 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1503 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1504 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001505 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001506 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001507 stmt->kw = LY_STMT_ENUM;
1508
1509 /*
1510 * 2) filter's type
1511 */
1512 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1513 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1514 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1515 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001516 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001517 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001518 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001519 ext_p->parent_stmt = LY_STMT_MODULE;
1520 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001521
1522 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1523 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1524 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1525 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001526 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001527 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001528 stmt->kw = LY_STMT_TYPE;
1529
1530 stmt->child = calloc(1, sizeof *stmt->child);
1531 stmt = stmt->child;
1532 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1533 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1534 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001535 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001536 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001537 stmt->kw = LY_STMT_ENUM;
1538
1539 stmt->next = calloc(1, sizeof *stmt->child);
1540 stmt = stmt->next;
1541 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1542 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1543 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001544 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001545 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001546 stmt->kw = LY_STMT_ENUM;
1547
1548 /* if-feature for enum allowed only for YANG 1.1 modules */
1549 if (mod->version >= LYS_VERSION_1_1) {
1550 stmt->child = calloc(1, sizeof *stmt->child);
1551 stmt = stmt->child;
1552 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1553 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1554 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001555 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001556 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001557 stmt->kw = LY_STMT_IF_FEATURE;
1558 }
1559
1560 /*
1561 * 3) filter's select
1562 */
1563 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1564 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1565 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1566 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001567 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001568 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001569 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001570 ext_p->parent_stmt = LY_STMT_MODULE;
1571 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001572
1573 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1574 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1575 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1576 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001577 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001578 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001579 stmt->kw = LY_STMT_TYPE;
1580
1581 /* create new imports for the used prefixes */
1582 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1583
1584 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1585 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1586 imp->flags = LYS_INTERNAL;
1587
1588 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1589
1590 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1591 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1592 imp->flags = LYS_INTERNAL;
1593
1594 return LY_SUCCESS;
1595}
1596
1597/**
1598 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1599 *
1600 * @param[in] mod Parsed module to add to.
1601 * @return LY_SUCCESS on success.
1602 * @return LY_ERR on error.
1603 */
1604static LY_ERR
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001605lysp_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
Michal Vasko45b521c2020-11-04 17:14:39 +01001606{
1607 struct lysp_ext_instance *ext_p;
1608 struct lysp_stmt *stmt;
1609 struct lysp_import *imp;
1610
1611 /* add new extension instance */
1612 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1613
1614 /* fill in the extension instance fields */
1615 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1616 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1617 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001618 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001619 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001620 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001621 ext_p->parent_stmt = LY_STMT_MODULE;
1622 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001623
1624 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1625 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1626 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1627 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001628 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001629 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001630 stmt->kw = LY_STMT_TYPE;
1631
1632 /* create new import for the used prefix */
1633 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1634
1635 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1636 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1637 imp->flags = LYS_INTERNAL;
1638
1639 return LY_SUCCESS;
1640}
1641
Michal Vasko3a41dff2020-07-15 14:30:28 +02001642LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001643lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001644 LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
Michal Vaskodd992582021-06-10 14:34:57 +02001645 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001646{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001647 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001648 LY_ERR ret;
Michal Vaskob36053d2020-03-26 15:49:30 +01001649 struct lys_yang_parser_ctx *yangctx = NULL;
1650 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001651 struct lys_parser_ctx *pctx = NULL;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001652 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vasko7a0b0762020-09-02 16:37:01 +02001653 char *filename, *rev, *dot;
1654 size_t len;
Radek Krejcic64661b2020-08-15 15:42:26 +02001655 ly_bool module_created = 0;
Radek Krejci86d106e2018-10-18 09:53:19 +02001656
Michal Vaskodd992582021-06-10 14:34:57 +02001657 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001658
Michal Vasko7a0b0762020-09-02 16:37:01 +02001659 if (module) {
1660 *module = NULL;
1661 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001662
1663 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001664 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001665 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001666
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001667 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001668 switch (format) {
1669 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001670 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001671 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001672 break;
1673 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001674 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001675 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001676 break;
1677 default:
1678 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001679 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001680 break;
1681 }
Radek Krejcic64661b2020-08-15 15:42:26 +02001682 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001683
1684 /* make sure that the newest revision is at position 0 */
1685 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001686 if (mod->parsed->revs) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001687 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001688 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001689
Radek Krejcib3289d62019-09-18 12:21:39 +02001690 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001691 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001692 if (latest) {
1693 if (mod->revision) {
1694 if (!latest->revision) {
1695 /* latest has no revision, so mod is anyway newer */
aPiecek8ca21bd2021-07-26 14:31:01 +02001696 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001697 /* the latest is zeroed later when the new module is being inserted into the context */
1698 } else if (strcmp(mod->revision, latest->revision) > 0) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001699 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001700 /* the latest is zeroed later when the new module is being inserted into the context */
1701 } else {
1702 latest = NULL;
1703 }
1704 } else {
1705 latest = NULL;
1706 }
1707 } else {
aPiecek8ca21bd2021-07-26 14:31:01 +02001708 mod->latest_revision = LYS_MOD_LATEST_REV;
Radek Krejcib3289d62019-09-18 12:21:39 +02001709 }
1710
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001711 if (custom_check) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001712 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001713 }
1714
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001715 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001716 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001717 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001718 /* nothing to do */
1719 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1720 mod_dup->revision ? mod_dup->revision : "<none>");
Radek Krejcic64661b2020-08-15 15:42:26 +02001721 goto cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001722 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001723
Michal Vaskob24145d2022-07-13 18:34:39 +02001724 /* check whether there is not a namespace collision */
1725 mod_dup = ly_ctx_get_module_latest_ns(ctx, mod->ns);
1726 if (mod_dup && (mod_dup->revision == mod->revision)) {
1727 LOGERR(ctx, LY_EINVAL, "Two different modules (\"%s\" and \"%s\") have the same namespace \"%s\".",
1728 mod_dup->name, mod->name, mod->ns);
1729 ret = LY_EINVAL;
1730 goto cleanup;
1731 }
1732
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001733 switch (in->type) {
1734 case LY_IN_FILEPATH:
1735 /* check that name and revision match filename */
1736 filename = strrchr(in->method.fpath.filepath, '/');
1737 if (!filename) {
1738 filename = in->method.fpath.filepath;
1739 } else {
1740 filename++;
1741 }
1742 rev = strchr(filename, '@');
1743 dot = strrchr(filename, '.');
1744
1745 /* name */
1746 len = strlen(mod->name);
1747 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001748 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001749 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1750 }
1751 if (rev) {
1752 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001753 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001754 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001755 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001756 }
1757 }
1758
1759 break;
1760 case LY_IN_FD:
1761 case LY_IN_FILE:
1762 case LY_IN_MEMORY:
1763 /* nothing special to do */
1764 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001765 case LY_IN_ERROR:
1766 LOGINT(ctx);
1767 ret = LY_EINT;
Radek Krejcic64661b2020-08-15 15:42:26 +02001768 goto cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001769 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001770 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001771
Michal Vasko7a0b0762020-09-02 16:37:01 +02001772 if (latest) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001773 latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001774 }
1775
Michal Vasko45b521c2020-11-04 17:14:39 +01001776 /* add internal data in case specific modules were parsed */
1777 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001778 LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001779 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001780 LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf_with_defaults(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001781 }
1782
Michal Vasko405cc9e2020-12-01 12:01:27 +01001783 /* add the module into newly created module set, will also be freed from there on any error */
Radek Krejcic64661b2020-08-15 15:42:26 +02001784 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup);
1785 module_created = 1;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001786
Michal Vasko7a0b0762020-09-02 16:37:01 +02001787 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001788 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001789 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001790 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001791
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001792 /* resolve includes and all imports */
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001793 LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
1794
1795 /* resolve extension instance plugin records */
1796 LY_CHECK_GOTO(ret = lysp_resolve_ext_instance_records(pctx), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001797
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001798 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001799 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001800 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001801 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1802 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001803
1804 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001805 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001806
aPiecek6b3d5422021-07-30 15:55:43 +02001807 /* compile identities */
1808 LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001809
Radek Krejcic64661b2020-08-15 15:42:26 +02001810cleanup:
Michal Vaskobe04af42021-07-16 10:48:43 +02001811 if (ret && (ret != LY_EEXIST)) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001812 if (mod && mod->name) {
1813 /* there are cases when path is not available for parsing error, so this additional
1814 * message tries to add information about the module where the error occurred */
1815 struct ly_err_item *e = ly_err_last(ctx);
Michal Vasko26bbb272022-08-02 14:54:33 +02001816
Radek Krejcic64661b2020-08-15 15:42:26 +02001817 if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) {
1818 LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name);
1819 }
1820 }
1821 }
1822 if (!module_created) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001823 fctx.mod = mod;
1824 lys_module_free(&fctx, mod, 0);
1825 lysf_ctx_erase(&fctx);
1826
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001827 mod = mod_dup;
1828 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001829
Michal Vasko7a0b0762020-09-02 16:37:01 +02001830 if (format == LYS_IN_YANG) {
1831 yang_parser_ctx_free(yangctx);
1832 } else {
1833 yin_parser_ctx_free(yinctx);
1834 }
1835
Michal Vasko405cc9e2020-12-01 12:01:27 +01001836 if (!ret && module) {
1837 *module = mod;
1838 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001839 return ret;
1840}
1841
Radek Krejci545b4872020-11-15 10:15:12 +01001842static LYS_INFORMAT
1843lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1844{
1845 if (!format && (in->type == LY_IN_FILEPATH)) {
1846 /* unknown format - try to detect it from filename's suffix */
1847 const char *path = in->method.fpath.filepath;
1848 size_t len = strlen(path);
1849
1850 /* ignore trailing whitespaces */
1851 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1852
Radek Krejcif13b87b2020-12-01 22:02:17 +01001853 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1854 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001855 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001856 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1857 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001858 format = LYS_IN_YIN;
1859 } /* else still unknown */
1860 }
1861
1862 return format;
1863}
1864
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001865LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001866lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const char **features, struct lys_module **module)
Michal Vasko7a0b0762020-09-02 16:37:01 +02001867{
Michal Vasko65333882021-06-10 14:12:16 +02001868 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001869 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001870
Michal Vasko7a0b0762020-09-02 16:37:01 +02001871 if (module) {
1872 *module = NULL;
1873 }
Radek Krejci545b4872020-11-15 10:15:12 +01001874 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1875
1876 format = lys_parse_get_format(in, format);
1877 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001878
1879 /* remember input position */
1880 in->func_start = in->current;
1881
Michal Vasko4e205e82021-06-08 14:01:47 +02001882 /* parse */
Michal Vasko22b26222021-07-30 11:16:47 +02001883 ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001884 LY_CHECK_GOTO(ret, cleanup);
1885
1886 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001887 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001888 LY_CHECK_GOTO(ret, cleanup);
1889
Michal Vaskof4258e12021-06-15 12:11:42 +02001890 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1891 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001892 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001893
Michal Vasko709f9a52021-07-21 10:51:59 +02001894 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001895 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
1896
1897 /* unres resolved */
1898 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001899 }
1900
Michal Vasko405cc9e2020-12-01 12:01:27 +01001901cleanup:
1902 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001903 lys_unres_glob_revert(ctx, &ctx->unres);
1904 lys_unres_glob_erase(&ctx->unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001905 } else if (module) {
1906 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001907 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001908 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001909}
1910
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001911LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001912lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001913{
Radek Krejci0f969882020-08-21 16:56:47 +02001914 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001915 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001916
Michal Vasko3a41dff2020-07-15 14:30:28 +02001917 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001918
Michal Vasko3a41dff2020-07-15 14:30:28 +02001919 LY_CHECK_ERR_RET(ret = ly_in_new_memory(data, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret);
Radek Krejci86d106e2018-10-18 09:53:19 +02001920
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001921 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001922 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001923
Michal Vasko3a41dff2020-07-15 14:30:28 +02001924 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001925}
1926
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001927LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001928lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001929{
Radek Krejci0f969882020-08-21 16:56:47 +02001930 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001931 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001932
Michal Vasko3a41dff2020-07-15 14:30:28 +02001933 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001934
Michal Vasko3a41dff2020-07-15 14:30:28 +02001935 LY_CHECK_ERR_RET(ret = ly_in_new_fd(fd, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret);
Radek Krejci86d106e2018-10-18 09:53:19 +02001936
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001937 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001938 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001939
Michal Vasko3a41dff2020-07-15 14:30:28 +02001940 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001941}
1942
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001943LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001944lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001945{
Radek Krejci0f969882020-08-21 16:56:47 +02001946 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001947 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001948
Michal Vasko3a41dff2020-07-15 14:30:28 +02001949 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001950
Michal Vasko3a41dff2020-07-15 14:30:28 +02001951 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001952 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001953
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001954 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001955 ly_in_free(in, 0);
1956
Michal Vasko3a41dff2020-07-15 14:30:28 +02001957 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001958}
1959
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001960LIBYANG_API_DEF LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001961lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001962 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001963{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001964 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001965 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001966 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001967 char *wd, *wn = NULL;
1968 DIR *dir = NULL;
1969 struct dirent *file;
1970 char *match_name = NULL;
1971 LYS_INFORMAT format_aux, match_format = 0;
1972 struct ly_set *dirs;
1973 struct stat st;
1974
1975 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1976
1977 /* start to fill the dir fifo with the context's search path (if set)
1978 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001979 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001980
1981 len = strlen(name);
1982 if (cwd) {
1983 wd = get_current_dir_name();
1984 if (!wd) {
1985 LOGMEM(NULL);
1986 goto cleanup;
1987 } else {
1988 /* add implicit current working directory (./) to be searched,
1989 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001990 ret = ly_set_add(dirs, wd, 0, NULL);
1991 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001992 implicit_cwd = 1;
1993 }
1994 }
1995 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001996 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001997 /* check for duplicities with the implicit current working directory */
1998 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1999 implicit_cwd = 0;
2000 continue;
2001 }
2002 wd = strdup(searchpaths[i]);
2003 if (!wd) {
2004 LOGMEM(NULL);
2005 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02002006 } else {
2007 ret = ly_set_add(dirs, wd, 0, NULL);
2008 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02002009 }
2010 }
2011 }
2012 wd = NULL;
2013
2014 /* start searching */
2015 while (dirs->count) {
2016 free(wd);
2017 free(wn); wn = NULL;
2018
2019 dirs->count--;
2020 wd = (char *)dirs->objs[dirs->count];
2021 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01002022 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02002023
2024 if (dir) {
2025 closedir(dir);
2026 }
2027 dir = opendir(wd);
2028 dir_len = strlen(wd);
2029 if (!dir) {
2030 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
2031 } else {
2032 while ((file = readdir(dir))) {
2033 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
2034 /* skip . and .. */
2035 continue;
2036 }
2037 free(wn);
2038 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
2039 LOGMEM(NULL);
2040 goto cleanup;
2041 }
2042 if (stat(wn, &st) == -1) {
2043 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02002044 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02002045 continue;
2046 }
2047 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
2048 /* we have another subdirectory in searchpath to explore,
2049 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02002050 ret = ly_set_add(dirs, wn, 0, NULL);
2051 LY_CHECK_GOTO(ret, cleanup);
2052
Radek Krejcid33273d2018-10-25 14:55:52 +02002053 /* continue with the next item in current directory */
2054 wn = NULL;
2055 continue;
2056 } else if (!S_ISREG(st.st_mode)) {
2057 /* not a regular file (note that we see the target of symlinks instead of symlinks */
2058 continue;
2059 }
2060
2061 /* here we know that the item is a file which can contain a module */
2062 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02002063 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002064 /* different filename than the module we search for */
2065 continue;
2066 }
2067
2068 /* get type according to filename suffix */
2069 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01002070 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
2071 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002072 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01002073 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
2074 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01002075 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02002076 } else {
2077 /* not supportde suffix/file format */
2078 continue;
2079 }
2080
2081 if (revision) {
2082 /* we look for the specific revision, try to get it from the filename */
2083 if (file->d_name[len] == '@') {
2084 /* check revision from the filename */
2085 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
2086 /* another revision */
2087 continue;
2088 } else {
2089 /* exact revision */
2090 free(match_name);
2091 match_name = wn;
2092 wn = NULL;
2093 match_len = dir_len + 1 + len;
2094 match_format = format_aux;
2095 goto success;
2096 }
2097 } else {
2098 /* continue trying to find exact revision match, use this only if not found */
2099 free(match_name);
2100 match_name = wn;
2101 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02002102 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02002103 match_format = format_aux;
2104 continue;
2105 }
2106 } else {
2107 /* remember the revision and try to find the newest one */
2108 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02002109 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01002110 lysp_check_date(NULL, &file->d_name[len + 1],
2111 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002112 continue;
Michal Vasko69730152020-10-09 16:30:07 +02002113 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02002114 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
2115 continue;
2116 }
2117 free(match_name);
2118 }
2119
2120 match_name = wn;
2121 wn = NULL;
2122 match_len = dir_len + 1 + len;
2123 match_format = format_aux;
2124 continue;
2125 }
2126 }
2127 }
2128 }
2129
2130success:
2131 (*localfile) = match_name;
2132 match_name = NULL;
2133 if (format) {
2134 (*format) = match_format;
2135 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002136 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02002137
2138cleanup:
2139 free(wn);
2140 free(wd);
2141 if (dir) {
2142 closedir(dir);
2143 }
2144 free(match_name);
2145 ly_set_free(dirs, free);
2146
2147 return ret;
2148}