blob: 5f27502c43fc85c6fab6d5084dcfa69e614cfcae [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 Vasko1a7a7bd2020-10-16 14:39:15 +020040#include "schema_compile.h"
Michal Vaskof4258e12021-06-15 12:11:42 +020041#include "schema_compile_amend.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010042#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020043#include "set.h"
44#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010045#include "tree_edit.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020046#include "tree_schema_internal.h"
47#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020048
Radek Krejcieccf6602021-02-05 19:42:54 +010049/**
50 * @brief information about YANG statements
51 */
52struct stmt_info_s stmt_attr_info[] = {
Radek Krejci6b88a462021-02-17 12:39:34 +010053 [LY_STMT_NONE] = {NULL, NULL, 0},
54 [LY_STMT_ACTION] = {"action", "name", STMT_FLAG_ID},
55 [LY_STMT_ANYDATA] = {"anydata", "name", STMT_FLAG_ID},
56 [LY_STMT_ANYXML] = {"anyxml", "name", STMT_FLAG_ID},
57 [LY_STMT_ARGUMENT] = {"argument", "name", STMT_FLAG_ID},
58 [LY_STMT_ARG_TEXT] = {"text", NULL, 0},
59 [LY_STMT_ARG_VALUE] = {"value", NULL, 0},
60 [LY_STMT_AUGMENT] = {"augment", "target-node", STMT_FLAG_ID},
61 [LY_STMT_BASE] = {"base", "name", STMT_FLAG_ID},
62 [LY_STMT_BELONGS_TO] = {"belongs-to", "module", STMT_FLAG_ID},
63 [LY_STMT_BIT] = {"bit", "name", STMT_FLAG_ID},
64 [LY_STMT_CASE] = {"case", "name", STMT_FLAG_ID},
65 [LY_STMT_CHOICE] = {"choice", "name", STMT_FLAG_ID},
66 [LY_STMT_CONFIG] = {"config", "value", STMT_FLAG_ID},
67 [LY_STMT_CONTACT] = {"contact", "text", STMT_FLAG_YIN},
68 [LY_STMT_CONTAINER] = {"container", "name", STMT_FLAG_ID},
69 [LY_STMT_DEFAULT] = {"default", "value", 0},
70 [LY_STMT_DESCRIPTION] = {"description", "text", STMT_FLAG_YIN},
71 [LY_STMT_DEVIATE] = {"deviate", "value", STMT_FLAG_ID},
72 [LY_STMT_DEVIATION] = {"deviation", "target-node", STMT_FLAG_ID},
73 [LY_STMT_ENUM] = {"enum", "name", STMT_FLAG_ID},
74 [LY_STMT_ERROR_APP_TAG] = {"error-app-tag", "value", 0},
75 [LY_STMT_ERROR_MESSAGE] = {"error-message", "value", STMT_FLAG_YIN},
76 [LY_STMT_EXTENSION] = {"extension", "name", STMT_FLAG_ID},
77 [LY_STMT_EXTENSION_INSTANCE] = {NULL, NULL, 0},
78 [LY_STMT_FEATURE] = {"feature", "name", STMT_FLAG_ID},
79 [LY_STMT_FRACTION_DIGITS] = {"fraction-digits", "value", STMT_FLAG_ID},
80 [LY_STMT_GROUPING] = {"grouping", "name", STMT_FLAG_ID},
81 [LY_STMT_IDENTITY] = {"identity", "name", STMT_FLAG_ID},
82 [LY_STMT_IF_FEATURE] = {"if-feature", "name", 0},
83 [LY_STMT_IMPORT] = {"import", "module", STMT_FLAG_ID},
84 [LY_STMT_INCLUDE] = {"include", "module", STMT_FLAG_ID},
85 [LY_STMT_INPUT] = {"input", NULL, 0},
86 [LY_STMT_KEY] = {"key", "value", 0},
87 [LY_STMT_LEAF] = {"leaf", "name", STMT_FLAG_ID},
88 [LY_STMT_LEAF_LIST] = {"leaf-list", "name", STMT_FLAG_ID},
89 [LY_STMT_LENGTH] = {"length", "value", 0},
90 [LY_STMT_LIST] = {"list", "name", STMT_FLAG_ID},
91 [LY_STMT_MANDATORY] = {"mandatory", "value", STMT_FLAG_ID},
92 [LY_STMT_MAX_ELEMENTS] = {"max-elements", "value", STMT_FLAG_ID},
93 [LY_STMT_MIN_ELEMENTS] = {"min-elements", "value", STMT_FLAG_ID},
94 [LY_STMT_MODIFIER] = {"modifier", "value", STMT_FLAG_ID},
95 [LY_STMT_MODULE] = {"module", "name", STMT_FLAG_ID},
96 [LY_STMT_MUST] = {"must", "condition", 0},
97 [LY_STMT_NAMESPACE] = {"namespace", "uri", 0},
98 [LY_STMT_NOTIFICATION] = {"notification", "name", STMT_FLAG_ID},
99 [LY_STMT_ORDERED_BY] = {"ordered-by", "value", STMT_FLAG_ID},
100 [LY_STMT_ORGANIZATION] = {"organization", "text", STMT_FLAG_YIN},
101 [LY_STMT_OUTPUT] = {"output", NULL, 0},
102 [LY_STMT_PATH] = {"path", "value", 0},
103 [LY_STMT_PATTERN] = {"pattern", "value", 0},
104 [LY_STMT_POSITION] = {"position", "value", STMT_FLAG_ID},
105 [LY_STMT_PREFIX] = {"prefix", "value", STMT_FLAG_ID},
106 [LY_STMT_PRESENCE] = {"presence", "value", 0},
107 [LY_STMT_RANGE] = {"range", "value", 0},
108 [LY_STMT_REFERENCE] = {"reference", "text", STMT_FLAG_YIN},
109 [LY_STMT_REFINE] = {"refine", "target-node", STMT_FLAG_ID},
110 [LY_STMT_REQUIRE_INSTANCE] = {"require-instance", "value", STMT_FLAG_ID},
111 [LY_STMT_REVISION] = {"revision", "date", STMT_FLAG_ID},
112 [LY_STMT_REVISION_DATE] = {"revision-date", "date", STMT_FLAG_ID},
113 [LY_STMT_RPC] = {"rpc", "name", STMT_FLAG_ID},
114 [LY_STMT_STATUS] = {"status", "value", STMT_FLAG_ID},
115 [LY_STMT_SUBMODULE] = {"submodule", "name", STMT_FLAG_ID},
116 [LY_STMT_SYNTAX_LEFT_BRACE] = {"{", NULL, 0},
117 [LY_STMT_SYNTAX_RIGHT_BRACE] = {"}", NULL, 0},
118 [LY_STMT_SYNTAX_SEMICOLON] = {";", NULL, 0},
119 [LY_STMT_TYPE] = {"type", "name", STMT_FLAG_ID},
120 [LY_STMT_TYPEDEF] = {"typedef", "name", STMT_FLAG_ID},
121 [LY_STMT_UNIQUE] = {"unique", "tag", 0},
122 [LY_STMT_UNITS] = {"units", "name", 0},
123 [LY_STMT_USES] = {"uses", "name", STMT_FLAG_ID},
124 [LY_STMT_VALUE] = {"value", "value", STMT_FLAG_ID},
125 [LY_STMT_WHEN] = {"when", "condition", 0},
126 [LY_STMT_YANG_VERSION] = {"yang-version", "value", STMT_FLAG_ID},
127 [LY_STMT_YIN_ELEMENT] = {"yin-element", "value", STMT_FLAG_ID},
Radek Krejcieccf6602021-02-05 19:42:54 +0100128};
129
Radek Krejcif8ca8192021-03-02 16:50:06 +0100130API const char *
131ly_stmt2str(enum ly_stmt stmt)
132{
Michal Vaskocc64aec2021-05-18 17:33:11 +0200133 if (stmt == LY_STMT_EXTENSION_INSTANCE) {
134 return "extension instance";
135 } else {
136 return stmt_attr_info[stmt].name;
137 }
Radek Krejcif8ca8192021-03-02 16:50:06 +0100138}
139
Radek Krejcieccf6602021-02-05 19:42:54 +0100140const char * const ly_devmod_list[] = {
141 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
142 [LYS_DEV_ADD] = "add",
143 [LYS_DEV_DELETE] = "delete",
144 [LYS_DEV_REPLACE] = "replace",
145};
146
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200147API LY_ERR
148lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
149{
Michal Vasko1d972ca2020-11-03 17:16:56 +0100150 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100151 const struct lysc_node_action *action;
152 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200153
154 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
155
156 LYSC_TREE_DFS_BEGIN(root, elem) {
157 /* schema node */
158 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
159
Radek Krejci2a9fc652021-01-22 17:44:34 +0100160 LY_LIST_FOR(lysc_node_actions(elem), action) {
161 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200162 /* action subtree */
163 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
164
Radek Krejci2a9fc652021-01-22 17:44:34 +0100165 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200166 }
167 }
168
Radek Krejci2a9fc652021-01-22 17:44:34 +0100169 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
170 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200171 /* notification subtree */
172 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
173
Radek Krejci2a9fc652021-01-22 17:44:34 +0100174 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200175 }
176 }
177
178 LYSC_TREE_DFS_END(root, elem);
179 }
180
181 return LY_SUCCESS;
182}
183
184API LY_ERR
185lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
186{
Michal Vasko2336cf52020-11-03 17:18:15 +0100187 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200188
189 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
190
191 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100192 LY_LIST_FOR(mod->compiled->data, root) {
193 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
194 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200195
196 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100197 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
198 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200199 }
200
201 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100202 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
203 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200204 }
205
206 return LY_SUCCESS;
207}
208
Radek Krejcib93bd412020-11-02 13:23:11 +0100209static void
210lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
211{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100212 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100213 if (first_case->child) {
214 /* there is something to return */
215 (*next) = first_case->child;
216 return;
217 }
218 }
219
220 /* no children in choice's cases, so go to the choice's sibling instead of into it */
221 (*last) = (*next);
222 (*next) = (*next)->next;
223}
224
Radek Krejci035dacf2021-02-12 18:25:53 +0100225/**
226 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
227 *
228 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
229 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
230 * extension instance.
231 *
232 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
233 * and function starts returning i) the first \p parent's child or ii) the first top level element specified in the
234 * given extension (if provided) or iii) the first top level element of the \p module.
235 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
236 * \p parent and \p module parameters.
237 *
238 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
239 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
240 * all the schema nodes are iteratively returned.
241 *
242 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
243 * @param[in] parent Parent of the subtree where the function starts processing.
244 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
245 * module must be specified.
246 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
247 * the \p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
248 * @param[in] options [ORed options](@ref sgetnextflags).
249 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
250 */
251static const struct lysc_node *
252lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
253 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100254{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100255 const struct lysc_node *next = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200256 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci035dacf2021-02-12 18:25:53 +0100257 struct lysc_node **data_p = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100258
Radek Krejci035dacf2021-02-12 18:25:53 +0100259 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100260
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200261next:
Radek Krejcia3045382018-11-22 14:30:31 +0100262 if (!last) {
263 /* first call */
264
265 /* get know where to start */
266 if (parent) {
267 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100268 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100269 } else {
270 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100271 if (ext) {
272 lysc_ext_substmt(ext, LY_STMT_CONTAINER /* matches all nodes */, (void **)&data_p, NULL);
273 next = last = data_p ? *data_p : NULL;
274 } else {
275 next = last = module->data;
276 }
Radek Krejcia3045382018-11-22 14:30:31 +0100277 }
278 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100279 /* try to get action or notification */
280 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100281 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100282 /* test if the next can be returned */
283 goto check;
284
Michal Vasko1bf09392020-03-27 12:38:10 +0100285 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100286 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100287 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100288 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100289 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100290 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200291 } else {
292 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100293 }
294
Radek Krejcia3045382018-11-22 14:30:31 +0100295repeat:
296 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100297 /* possibly go back to parent */
Radek Krejci035dacf2021-02-12 18:25:53 +0100298 data_p = NULL;
Michal Vasko69730152020-10-09 16:30:07 +0200299 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100300 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200301 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100302 } else if (!action_flag) {
303 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100304 if (ext) {
305 lysc_ext_substmt(ext, LY_STMT_RPC /* matches also actions */, (void **)&data_p, NULL);
306 next = data_p ? *data_p : NULL;
307 } else if (parent) {
308 next = (struct lysc_node *)lysc_node_actions(parent);
309 } else {
310 next = (struct lysc_node *)module->rpcs;
311 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100312 } else if (!notif_flag) {
313 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100314 if (ext) {
315 lysc_ext_substmt(ext, LY_STMT_NOTIFICATION, (void **)&data_p, NULL);
316 next = data_p ? *data_p : NULL;
317 } else if (parent) {
318 next = (struct lysc_node *)lysc_node_notifs(parent);
319 } else {
320 next = (struct lysc_node *)module->notifs;
321 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100322 } else {
323 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100324 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100325 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100326 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100327check:
Radek Krejcia3045382018-11-22 14:30:31 +0100328 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100329 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100330 case LYS_ACTION:
331 case LYS_NOTIF:
332 case LYS_LEAF:
333 case LYS_ANYXML:
334 case LYS_ANYDATA:
335 case LYS_LIST:
336 case LYS_LEAFLIST:
337 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200338 case LYS_CASE:
339 if (options & LYS_GETNEXT_WITHCASE) {
340 break;
341 } else {
342 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100343 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200344 }
345 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100346 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100347 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100348 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100349 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100350 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100351 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100352 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100353 next = next->next;
354 }
355 goto repeat;
356 }
357 break;
358 case LYS_CHOICE:
359 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200360 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100361 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100362 next = next->next;
363 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100364 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100365 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100366 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100367 /* go into */
368 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100369 }
Radek Krejcia3045382018-11-22 14:30:31 +0100370 }
371 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100372 case LYS_INPUT:
373 if (options & LYS_GETNEXT_OUTPUT) {
374 /* skip */
375 next = next->next;
376 } else {
377 /* go into */
378 next = lysc_node_child(next);
379 }
380 goto repeat;
381 case LYS_OUTPUT:
382 if (!(options & LYS_GETNEXT_OUTPUT)) {
383 /* skip */
384 next = next->next;
385 } else {
386 /* go into */
387 next = lysc_node_child(next);
388 }
389 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100390 default:
391 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100392 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100393 return NULL;
394 }
395
Radek Krejcia3045382018-11-22 14:30:31 +0100396 return next;
397}
398
399API const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100400lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
401{
402 return lys_getnext_(last, parent, module, NULL, options);
403}
404
405API const struct lysc_node *
406lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
407{
408 return lys_getnext_(last, parent, NULL, ext, options);
409}
410
Radek Krejcif16e2542021-02-17 15:39:23 +0100411const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100412lysc_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 +0100413 uint16_t nodetype, uint32_t options)
414{
415 const struct lysc_node *node = NULL;
416
417 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
418 if (!nodetype) {
419 nodetype = LYS_NODETYPE_MASK;
420 }
421
422 if (module && (module != ext->module)) {
423 return NULL;
424 }
425
426 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
427 if (!(node->nodetype & nodetype)) {
428 continue;
429 }
430
431 if (name_len) {
432 if (!ly_strncmp(node->name, name, name_len)) {
433 return node;
434 }
435 } else {
436 if (!strcmp(node->name, name)) {
437 return node;
438 }
439 }
440 }
441 return NULL;
442}
443
Radek Krejci035dacf2021-02-12 18:25:53 +0100444API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100445lys_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 +0200446 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100447{
448 const struct lysc_node *node = NULL;
449
450 LY_CHECK_ARG_RET(NULL, module, name, NULL);
451 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100452 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100453 }
454
455 while ((node = lys_getnext(node, parent, module->compiled, options))) {
456 if (!(node->nodetype & nodetype)) {
457 continue;
458 }
459 if (node->module != module) {
460 continue;
461 }
462
463 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200464 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100465 return node;
466 }
467 } else {
468 if (!strcmp(node->name, name)) {
469 return node;
470 }
471 }
472 }
473 return NULL;
474}
475
Michal Vasko519fd602020-05-26 12:17:39 +0200476API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100477lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
478 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200479{
480 LY_ERR ret = LY_SUCCESS;
481 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200482 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200483 uint32_t i;
484
Michal Vasko26512682021-01-11 11:35:40 +0100485 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200486 if (!(options & LYXP_SCNODE_ALL)) {
487 options = LYXP_SCNODE;
488 }
Michal Vasko26512682021-01-11 11:35:40 +0100489 if (!ctx) {
490 ctx = ctx_node->module->ctx;
491 }
Michal Vasko519fd602020-05-26 12:17:39 +0200492
493 memset(&xp_set, 0, sizeof xp_set);
494
495 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100496 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200497 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200498
499 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200500 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200501 LY_CHECK_GOTO(ret, cleanup);
502
503 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200504 ret = ly_set_new(set);
505 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200506
507 /* transform into ly_set */
508 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100509 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200510 (*set)->size = xp_set.used;
511
512 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200513 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200514 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200515 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200516 }
517 }
518
519cleanup:
520 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100521 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200522 return ret;
523}
524
Michal Vasko072de482020-08-05 13:27:21 +0200525API LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200526lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
527 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
528{
529 LY_ERR ret = LY_SUCCESS;
530 struct lyxp_set xp_set = {0};
531 uint32_t i;
532
533 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
534 if (!(options & LYXP_SCNODE_ALL)) {
535 options = LYXP_SCNODE;
536 }
537
538 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200539 ret = lyxp_atomize(cur_mod->ctx, expr, cur_mod, LY_VALUE_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, &xp_set, options);
Michal Vasko40308e72020-10-20 16:38:40 +0200540 LY_CHECK_GOTO(ret, cleanup);
541
542 /* allocate return set */
543 ret = ly_set_new(set);
544 LY_CHECK_GOTO(ret, cleanup);
545
546 /* transform into ly_set */
547 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
548 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
549 (*set)->size = xp_set.used;
550
551 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200552 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
553 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
554 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100555 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200556 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
557 LY_CHECK_GOTO(ret, cleanup);
558 }
559 }
560
561cleanup:
562 lyxp_set_free_content(&xp_set);
563 if (ret) {
564 ly_set_free(*set, NULL);
565 *set = NULL;
566 }
567 return ret;
568}
569
570API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100571lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
572 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200573{
574 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200575 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200576 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200577 uint32_t i;
578
Michal Vasko26512682021-01-11 11:35:40 +0100579 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200580 if (!(options & LYXP_SCNODE_ALL)) {
581 options = LYXP_SCNODE;
582 }
Michal Vasko26512682021-01-11 11:35:40 +0100583 if (!ctx) {
584 ctx = ctx_node->module->ctx;
585 }
Michal Vasko072de482020-08-05 13:27:21 +0200586
Michal Vasko072de482020-08-05 13:27:21 +0200587 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100588 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200589 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200590
591 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200592 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200593 LY_CHECK_GOTO(ret, cleanup);
594
595 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200596 ret = ly_set_new(set);
597 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200598
599 /* transform into ly_set */
600 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100601 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200602 (*set)->size = xp_set.used;
603
604 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100605 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 +0200606 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200607 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200608 }
609 }
610
611cleanup:
612 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100613 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200614 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200615 ly_set_free(*set, NULL);
616 *set = NULL;
617 }
Michal Vasko072de482020-08-05 13:27:21 +0200618 return ret;
619}
620
Radek Krejcibc5644c2020-10-27 14:53:17 +0100621API LY_ERR
622lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
623{
624 LY_ERR ret = LY_SUCCESS;
625 LY_ARRAY_COUNT_TYPE u, v;
626
627 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
628
629 /* allocate return set */
630 LY_CHECK_RET(ly_set_new(set));
631
632 LY_ARRAY_FOR(path, u) {
633 /* add nodes from the path */
634 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
635 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
636 LY_ARRAY_FOR(path[u].predicates, v) {
637 /* add all the keys in a predicate */
638 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
639 }
640 }
641 }
642
643cleanup:
644 if (ret) {
645 ly_set_free(*set, NULL);
646 *set = NULL;
647 }
648 return ret;
649}
650
651API LY_ERR
652lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
653 struct ly_set **set)
654{
655 LY_ERR ret = LY_SUCCESS;
656 uint8_t oper;
657 struct lyxp_expr *expr = NULL;
658 struct ly_path *p = NULL;
659
660 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
661
662 if (!ctx) {
663 ctx = ctx_node->module->ctx;
664 }
665
666 /* parse */
667 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
668 LY_CHECK_GOTO(ret, cleanup);
669
670 /* compile */
671 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200672 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 +0100673 LY_CHECK_GOTO(ret, cleanup);
674
675 /* resolve */
676 ret = lys_find_lypath_atoms(p, set);
677
678cleanup:
679 ly_path_free(ctx, p);
680 lyxp_expr_free(ctx, expr);
681 return ret;
682}
683
684API const struct lysc_node *
685lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
686{
687 const struct lysc_node *snode = NULL;
688 struct lyxp_expr *exp = NULL;
689 struct ly_path *p = NULL;
690 LY_ERR ret;
691 uint8_t oper;
692
693 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
694
695 if (!ctx) {
696 ctx = ctx_node->module->ctx;
697 }
698
699 /* parse */
700 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
701 LY_CHECK_GOTO(ret, cleanup);
702
703 /* compile */
704 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200705 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 +0100706 LY_CHECK_GOTO(ret, cleanup);
707
708 /* get last node */
709 snode = p[LY_ARRAY_COUNT(p) - 1].node;
710
711cleanup:
712 ly_path_free(ctx, p);
713 lyxp_expr_free(ctx, exp);
714 return snode;
715}
716
Michal Vasko14654712020-02-06 08:35:21 +0100717char *
718lysc_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 +0200719 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200720{
Michal Vasko87dd1342021-08-23 16:17:55 +0200721 const struct lysc_node *iter, *par;
Radek Krejci327de162019-06-14 12:52:07 +0200722 char *path = NULL;
723 int len = 0;
724
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200725 if (buffer) {
726 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100727 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200728 }
729
Radek Krejci327de162019-06-14 12:52:07 +0200730 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200731 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200732 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100733 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200734 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100735 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200736
Michal Vasko721b6f62021-02-08 08:52:53 +0100737 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200738 /* schema-only node */
739 continue;
740 }
741
Michal Vasko11deea12020-08-05 13:54:50 +0200742 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200743 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100744 if (parent && (iter->parent == parent)) {
745 slash = "";
746 } else {
747 slash = "/";
748 }
Michal Vasko87dd1342021-08-23 16:17:55 +0200749
750 if (pathtype == LYSC_PATH_DATA) {
751 par = lysc_data_parent(iter);
752 } else {
753 par = iter->parent;
754 }
755
756 if (!par || (par->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200757 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200758 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100759 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200760 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100761 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200762 }
Radek Krejci327de162019-06-14 12:52:07 +0200763 } else {
764 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200765 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100766 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200767 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100768 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200769 }
Radek Krejci327de162019-06-14 12:52:07 +0200770 }
771 free(s);
772 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200773
Michal Vasko69730152020-10-09 16:30:07 +0200774 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200775 /* not enough space in buffer */
776 break;
777 }
Radek Krejci327de162019-06-14 12:52:07 +0200778 }
779
780 if (len < 0) {
781 free(path);
782 path = NULL;
783 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200784 if (buffer) {
785 strcpy(buffer, "/");
786 } else {
787 path = strdup("/");
788 }
Radek Krejci327de162019-06-14 12:52:07 +0200789 }
790 break;
791 }
792
Radek Krejci1c0c3442019-07-23 16:08:47 +0200793 if (buffer) {
794 return buffer;
795 } else {
796 return path;
797 }
Radek Krejci327de162019-06-14 12:52:07 +0200798}
799
Michal Vasko14654712020-02-06 08:35:21 +0100800API char *
801lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
802{
803 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
804}
805
Michal Vasko405cc9e2020-12-01 12:01:27 +0100806LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200807_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100808{
809 LY_ERR ret = LY_SUCCESS, r;
aPiecek6b3d5422021-07-30 15:55:43 +0200810 struct lys_module *mod_iter;
Michal Vasko65333882021-06-10 14:12:16 +0200811 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100812
Michal Vasko405cc9e2020-12-01 12:01:27 +0100813 if (mod->implemented) {
814 /* mod is already implemented, set the features */
815 r = lys_set_features(mod->parsed, features);
816 if (r == LY_EEXIST) {
817 /* no changes */
818 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200819 } else if (!r) {
820 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200821 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200822 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200823
824 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200825 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100826
Michal Vasko7213ac52021-06-15 11:52:13 +0200827 /* implement, ignore recompilation because it must always take place later */
828 r = lys_implement(mod, features, unres);
829 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200830
831 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
832 /* implement all the imports as well */
833 for (i = 0; i < unres->creating.count; ++i) {
834 mod = unres->creating.objs[i];
835 if (mod->implemented) {
836 continue;
837 }
838
Michal Vasko7213ac52021-06-15 11:52:13 +0200839 r = lys_implement(mod, NULL, unres);
840 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200841 }
842 }
843
aPiecek6b3d5422021-07-30 15:55:43 +0200844 /* Try to find module with LYS_MOD_IMPORTED_REV flag. */
845 i = 0;
846 while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) {
Michal Vaskoe8b085b2021-09-02 08:20:08 +0200847 if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) {
848 LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing"
849 " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision,
850 mod_iter->revision);
aPiecek6b3d5422021-07-30 15:55:43 +0200851 break;
852 }
853 }
854
Michal Vasko65333882021-06-10 14:12:16 +0200855cleanup:
856 return ret;
857}
858
Michal Vaskof4258e12021-06-15 12:11:42 +0200859/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200860 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
861 * and if so, add it into its dep set.
862 *
863 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
864 * in the dep set are (re)compiled.
865 *
866 * The reason for recompilation is possible disabled nodes and updating
867 * leafref targets to point to the newly compiled modules. Using the import relation, the
868 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
869 * during the target module compilation.
870 *
871 * - every module must belong to exactly one dep set
872 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200873 *
874 * @param[in] mod Module to process.
875 * @param[in,out] ctx_set Set with all not-yet-processed modules.
876 * @param[in,out] dep_set Current dependency set to update.
Michal Vasko775fbd02021-07-28 08:25:29 +0200877 * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call.
Michal Vaskof4258e12021-06-15 12:11:42 +0200878 * @return LY_ERR value.
879 */
880static LY_ERR
Michal Vasko775fbd02021-07-28 08:25:29 +0200881lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set,
882 struct ly_set *aux_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200883{
884 struct lys_module *mod2;
885 struct lysp_import *imports;
886 uint32_t i;
887 LY_ARRAY_COUNT_TYPE u, v;
888 ly_bool found;
889
Michal Vasko7ee5be22021-06-16 17:03:34 +0200890 if (!lys_has_compiled(mod) || (mod->compiled && !lys_has_recompiled(mod))) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200891 /* is already in a separate dep set */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200892 if (!lys_has_groupings(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200893 /* break the dep set here, no modules depend on this one */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200894 return LY_SUCCESS;
895 }
Michal Vasko775fbd02021-07-28 08:25:29 +0200896
897 if (ly_set_contains(aux_set, mod, NULL)) {
898 /* it was traversed */
899 return LY_SUCCESS;
900 }
901
902 /* add a new auxiliary module */
903 LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL));
Michal Vasko7ee5be22021-06-16 17:03:34 +0200904 } else {
Michal Vasko709f9a52021-07-21 10:51:59 +0200905 if (!ly_set_contains(ctx_set, mod, &i)) {
906 /* it was already processed */
907 return LY_SUCCESS;
908 }
909
910 /* remove it from the set, we are processing it now */
911 ly_set_rm_index(ctx_set, i, NULL);
912
Michal Vasko7ee5be22021-06-16 17:03:34 +0200913 /* add a new dependent module into the dep set */
914 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200915 }
916
917 /* process imports of the module and submodules */
918 imports = mod->parsed->imports;
919 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200920 mod2 = imports[u].module;
Michal Vasko775fbd02021-07-28 08:25:29 +0200921 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200922 }
923 LY_ARRAY_FOR(mod->parsed->includes, v) {
924 imports = mod->parsed->includes[v].submodule->imports;
925 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200926 mod2 = imports[u].module;
927 if (!lys_has_compiled(mod2) || (mod2->compiled && !lys_has_recompiled(mod2))) {
928 if (!lys_has_groupings(mod2)) {
929 /* break the dep set here, no modules depend on this one */
930 continue;
931 }
932 }
933
Michal Vasko775fbd02021-07-28 08:25:29 +0200934 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 +0200935 }
936 }
937
938 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200939 for (i = 0; i < mod->ctx->list.count; ++i) {
940 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200941 found = 0;
942
943 imports = mod2->parsed->imports;
944 LY_ARRAY_FOR(imports, u) {
945 if (imports[u].module == mod) {
946 found = 1;
947 break;
948 }
949 }
950
951 if (!found) {
952 LY_ARRAY_FOR(mod2->parsed->includes, v) {
953 imports = mod2->parsed->includes[v].submodule->imports;
954 LY_ARRAY_FOR(imports, u) {
955 if (imports[u].module == mod) {
956 found = 1;
957 break;
958 }
959 }
960
961 if (found) {
962 break;
963 }
964 }
965 }
966
967 if (found) {
Michal Vasko775fbd02021-07-28 08:25:29 +0200968 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200969 }
970 }
971
972 return LY_SUCCESS;
973}
974
Michal Vasko709f9a52021-07-21 10:51:59 +0200975/**
976 * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets.
977 *
978 * @param[in,out] ctx_set Set with all not-yet-processed modules.
979 * @param[in,out] main_set Set of dependency module sets.
980 * @return LY_ERR value.
981 */
982static LY_ERR
983lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set)
984{
985 LY_ERR ret = LY_SUCCESS;
986 struct lys_module *m;
987 uint32_t i = 0;
988 struct ly_set *dep_set = NULL;
989
990 while (i < ctx_set->count) {
991 m = ctx_set->objs[i];
992 if (!lys_has_compiled(m) || (m->compiled && !lys_has_recompiled(m))) {
993 /* remove it from the set, we are processing it now */
994 ly_set_rm_index(ctx_set, i, NULL);
995
996 /* this module can be in a separate dep set (but there still may be modules importing this one
997 * that depend on imports of this one in case it defines groupings) */
998 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
999 LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup);
1000 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
1001 dep_set = NULL;
1002 } else {
1003 ++i;
1004 }
1005 }
1006
1007cleanup:
1008 ly_set_free(dep_set, NULL);
1009 return ret;
1010}
1011
Michal Vaskof4258e12021-06-15 12:11:42 +02001012LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +02001013lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +02001014{
1015 LY_ERR ret = LY_SUCCESS;
1016 struct lys_module *m;
Michal Vasko775fbd02021-07-28 08:25:29 +02001017 struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0};
Michal Vaskof4258e12021-06-15 12:11:42 +02001018 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +02001019 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +02001020
Michal Vasko22b26222021-07-30 11:16:47 +02001021 assert(!main_set->count);
1022
Michal Vaskof4258e12021-06-15 12:11:42 +02001023 /* start with a duplicate set of modules that we will remove from */
1024 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
1025
Michal Vasko709f9a52021-07-21 10:51:59 +02001026 /* first create all dep sets with single modules */
1027 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup);
1028
1029 if (mod && !ly_set_contains(ctx_set, mod, NULL)) {
1030 /* dep set for this module has already been created, nothing else to do */
1031 goto cleanup;
1032 }
1033
Michal Vaskof4258e12021-06-15 12:11:42 +02001034 while (ctx_set->count) {
1035 /* create new dep set */
1036 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1037
1038 if (mod) {
1039 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001040 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 +02001041 } else {
1042 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001043 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 +02001044 }
Michal Vasko775fbd02021-07-28 08:25:29 +02001045 ly_set_erase(&aux_set, NULL);
Michal Vasko7ee5be22021-06-16 17:03:34 +02001046 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001047
1048 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001049 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001050 for (i = 0; i < dep_set->count; ++i) {
1051 m = dep_set->objs[i];
1052 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001053 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +02001054 break;
1055 }
1056 }
1057
Michal Vasko7ee5be22021-06-16 17:03:34 +02001058 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001059 /* if there is, all the implemented modules need to be recompiled */
1060 for (i = 0; i < dep_set->count; ++i) {
1061 m = dep_set->objs[i];
1062 if (m->implemented) {
1063 m->to_compile = 1;
1064 }
1065 }
1066 }
1067
Michal Vasko7ee5be22021-06-16 17:03:34 +02001068 /* add the dep set into main set */
1069 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001070 dep_set = NULL;
1071
1072 if (mod) {
1073 /* we need dep set only for this module */
1074 break;
1075 }
1076 }
1077
Michal Vaskoe558f792021-07-28 08:20:15 +02001078#ifndef NDEBUG
1079 LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count);
1080 for (i = 0; i < main_set->count; ++i) {
1081 struct ly_set *iter_set = main_set->objs[i];
1082
1083 LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i);
1084 for (uint32_t j = 0; j < iter_set->count; ++j) {
1085 m = iter_set->objs[j];
1086 LOGDBG(LY_LDGDEPSETS, "\t%s", m->name);
1087 }
1088 }
1089#endif
1090
Michal Vaskof4258e12021-06-15 12:11:42 +02001091cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +02001092 assert(ret || main_set->objs);
Michal Vasko775fbd02021-07-28 08:25:29 +02001093 ly_set_erase(&aux_set, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001094 ly_set_free(dep_set, NULL);
1095 ly_set_free(ctx_set, NULL);
1096 return ret;
1097}
1098
1099void
1100lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1101{
1102 uint32_t i, j, idx, prev_lo;
1103 struct ly_set *dep_set;
1104 struct lys_module *m;
1105 LY_ERR ret;
1106
1107 for (i = 0; i < unres->implementing.count; ++i) {
1108 m = unres->implementing.objs[i];
1109 assert(m->implemented);
1110
1111 /* make the module correctly non-implemented again */
1112 m->implemented = 0;
1113 lys_precompile_augments_deviations_revert(ctx, m);
1114 lysc_module_free(m->compiled);
1115 m->compiled = NULL;
1116
1117 /* should not be made implemented */
1118 m->to_compile = 0;
1119 }
1120
1121 for (i = 0; i < unres->creating.count; ++i) {
1122 m = unres->creating.objs[i];
1123
Michal Vaskod297f2a2021-06-16 11:51:28 +02001124 /* remove the module from the context */
Michal Vaskof4258e12021-06-15 12:11:42 +02001125 ly_set_rm(&ctx->list, m, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001126
Michal Vasko22b26222021-07-30 11:16:47 +02001127 /* remove it also from dep sets */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001128 for (j = 0; j < unres->dep_sets.count; ++j) {
1129 dep_set = unres->dep_sets.objs[j];
1130 if (ly_set_contains(dep_set, m, &idx)) {
1131 ly_set_rm_index(dep_set, idx, NULL);
1132 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001133 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001134 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001135
1136 /* free the module */
1137 lys_module_free(m);
Michal Vaskof4258e12021-06-15 12:11:42 +02001138 }
1139
1140 if (unres->implementing.count) {
1141 /* recompile previous context because some implemented modules are no longer implemented,
1142 * we can reuse the current to_compile flags */
1143 prev_lo = ly_log_options(0);
Michal Vasko22b26222021-07-30 11:16:47 +02001144 ret = lys_compile_depset_all(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001145 ly_log_options(prev_lo);
1146 if (ret) {
1147 LOGINT(ctx);
1148 }
1149 }
1150}
1151
1152void
1153lys_unres_glob_erase(struct lys_glob_unres *unres)
1154{
1155 uint32_t i;
1156
1157 for (i = 0; i < unres->dep_sets.count; ++i) {
1158 ly_set_free(unres->dep_sets.objs[i], NULL);
1159 }
1160 ly_set_erase(&unres->dep_sets, NULL);
1161 ly_set_erase(&unres->implementing, NULL);
1162 ly_set_erase(&unres->creating, NULL);
1163
Michal Vaskoc130e162021-10-19 11:30:00 +02001164 assert(!unres->ds_unres.whens.count);
1165 assert(!unres->ds_unres.musts.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001166 assert(!unres->ds_unres.leafrefs.count);
aPiecekc6526b42021-07-12 15:21:39 +02001167 assert(!unres->ds_unres.disabled_leafrefs.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001168 assert(!unres->ds_unres.dflts.count);
1169 assert(!unres->ds_unres.disabled.count);
1170}
1171
Michal Vasko65333882021-06-10 14:12:16 +02001172API LY_ERR
1173lys_set_implemented(struct lys_module *mod, const char **features)
1174{
1175 LY_ERR ret = LY_SUCCESS;
Michal Vasko22b26222021-07-30 11:16:47 +02001176 struct lys_glob_unres *unres = &mod->ctx->unres;
Michal Vasko65333882021-06-10 14:12:16 +02001177
1178 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1179
1180 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001181 ret = _lys_set_implemented(mod, features, unres);
Michal Vasko65333882021-06-10 14:12:16 +02001182 LY_CHECK_GOTO(ret, cleanup);
1183
Michal Vaskof4258e12021-06-15 12:11:42 +02001184 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1185 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001186 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001187
Michal Vasko709f9a52021-07-21 10:51:59 +02001188 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001189 LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup);
1190
1191 /* unres resolved */
1192 lys_unres_glob_erase(unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001193 }
1194
Michal Vasko65333882021-06-10 14:12:16 +02001195cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001196 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001197 lys_unres_glob_revert(mod->ctx, unres);
1198 lys_unres_glob_erase(unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001199 }
Michal Vasko89b5c072020-10-06 13:52:44 +02001200 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001201}
1202
Michal Vasko7c8439f2020-08-05 13:25:19 +02001203static LY_ERR
aPiecekc3e26142021-06-22 14:25:49 +02001204lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001205{
1206 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001207 LY_ARRAY_COUNT_TYPE u, v;
1208
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001209 pmod->parsing = 1;
1210 LY_ARRAY_FOR(pmod->imports, u) {
1211 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001212 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001213 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 +02001214
1215 if (!imp->rev[0]) {
1216 /* This module must be selected for the next similar
1217 * import without revision-date to avoid incorrect
1218 * derived identities in the ::lys_module.identities.
1219 */
1220 imp->module->latest_revision |= LYS_MOD_IMPORTED_REV;
1221 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001222 }
1223 /* check for importing the same module twice */
1224 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001225 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001226 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1227 }
1228 }
1229 }
aPiecekc3e26142021-06-22 14:25:49 +02001230 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001231
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001232 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001233
1234 return LY_SUCCESS;
1235}
1236
Michal Vasko3a41dff2020-07-15 14:30:28 +02001237LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001238lys_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 +02001239 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001240 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001241{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001242 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001243 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +01001244 struct lys_yang_parser_ctx *yangctx = NULL;
1245 struct lys_yin_parser_ctx *yinctx = NULL;
1246 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001247
Michal Vasko3a41dff2020-07-15 14:30:28 +02001248 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001249
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001250 switch (format) {
1251 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001252 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001253 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001254 break;
1255 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001256 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001257 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001258 break;
1259 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001260 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001261 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001262 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001263 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001264 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001265 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001266
1267 /* make sure that the newest revision is at position 0 */
1268 lysp_sort_revisions(submod->revs);
1269
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001270 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001271 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001272 if (latest_sp) {
1273 if (submod->revs) {
1274 if (!latest_sp->revs) {
1275 /* latest has no revision, so mod is anyway newer */
1276 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001277 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1278 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1279 submod->latest_revision = latest_sp->latest_revision;
1280 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001281 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001282 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001283 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001284 } else {
1285 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001286 }
1287 } else {
1288 submod->latest_revision = 1;
1289 }
1290
Radek Krejcib3289d62019-09-18 12:21:39 +02001291 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001292 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001293 }
1294
1295 if (latest_sp) {
1296 latest_sp->latest_revision = 0;
1297 }
1298
Michal Vasko7a0b0762020-09-02 16:37:01 +02001299 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1300
Michal Vasko7c8439f2020-08-05 13:25:19 +02001301 /* resolve imports and includes */
aPiecekc3e26142021-06-22 14:25:49 +02001302 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001303
David Sedlák1b623122019-08-05 15:27:49 +02001304 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001305 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001306 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001307 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001308 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001309 *submodule = submod;
1310 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001311
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001312error:
Radek Krejcic64661b2020-08-15 15:42:26 +02001313 if (!submod || !submod->name) {
1314 LOGERR(ctx, ret, "Parsing submodule failed.");
1315 } else {
1316 LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name);
1317 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001318 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001319 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001320 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001321 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001322 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001323 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001324 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001325}
1326
Michal Vasko45b521c2020-11-04 17:14:39 +01001327/**
1328 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1329 *
1330 * @param[in] mod Parsed module to add to.
1331 * @return LY_SUCCESS on success.
1332 * @return LY_ERR on error.
1333 */
1334static LY_ERR
1335lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
1336{
1337 struct lysp_ext_instance *ext_p;
1338 struct lysp_stmt *stmt;
1339 struct lysp_import *imp;
1340
1341 /*
1342 * 1) edit-config's operation
1343 */
1344 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1345 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1346 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1347 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001348 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001349 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001350 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001351 ext_p->parent_stmt = LY_STMT_MODULE;
1352 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001353
1354 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1355 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1356 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1357 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001358 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001359 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001360 stmt->kw = LY_STMT_TYPE;
1361
1362 stmt->child = calloc(1, sizeof *stmt->child);
1363 stmt = stmt->child;
1364 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1365 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1366 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001367 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001368 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001369 stmt->kw = LY_STMT_ENUM;
1370
1371 stmt->next = calloc(1, sizeof *stmt->child);
1372 stmt = stmt->next;
1373 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1374 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1375 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001376 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001377 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001378 stmt->kw = LY_STMT_ENUM;
1379
1380 stmt->next = calloc(1, sizeof *stmt->child);
1381 stmt = stmt->next;
1382 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1383 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1384 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001385 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001386 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001387 stmt->kw = LY_STMT_ENUM;
1388
1389 stmt->next = calloc(1, sizeof *stmt->child);
1390 stmt = stmt->next;
1391 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1392 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1393 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001394 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001395 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001396 stmt->kw = LY_STMT_ENUM;
1397
1398 stmt->next = calloc(1, sizeof *stmt->child);
1399 stmt = stmt->next;
1400 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1401 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1402 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001403 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001404 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001405 stmt->kw = LY_STMT_ENUM;
1406
1407 /*
1408 * 2) filter's type
1409 */
1410 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1411 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1412 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1413 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001414 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001415 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001416 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001417 ext_p->parent_stmt = LY_STMT_MODULE;
1418 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001419
1420 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1421 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1422 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1423 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001424 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001425 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001426 stmt->kw = LY_STMT_TYPE;
1427
1428 stmt->child = calloc(1, sizeof *stmt->child);
1429 stmt = stmt->child;
1430 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1431 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1432 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001433 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001434 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001435 stmt->kw = LY_STMT_ENUM;
1436
1437 stmt->next = calloc(1, sizeof *stmt->child);
1438 stmt = stmt->next;
1439 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1440 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1441 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001442 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001443 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001444 stmt->kw = LY_STMT_ENUM;
1445
1446 /* if-feature for enum allowed only for YANG 1.1 modules */
1447 if (mod->version >= LYS_VERSION_1_1) {
1448 stmt->child = calloc(1, sizeof *stmt->child);
1449 stmt = stmt->child;
1450 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1451 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1452 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001453 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001454 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001455 stmt->kw = LY_STMT_IF_FEATURE;
1456 }
1457
1458 /*
1459 * 3) filter's select
1460 */
1461 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1462 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1463 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1464 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001465 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001466 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001467 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001468 ext_p->parent_stmt = LY_STMT_MODULE;
1469 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001470
1471 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1472 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1473 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1474 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001475 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001476 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001477 stmt->kw = LY_STMT_TYPE;
1478
1479 /* create new imports for the used prefixes */
1480 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1481
1482 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1483 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1484 imp->flags = LYS_INTERNAL;
1485
1486 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1487
1488 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1489 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1490 imp->flags = LYS_INTERNAL;
1491
1492 return LY_SUCCESS;
1493}
1494
1495/**
1496 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1497 *
1498 * @param[in] mod Parsed module to add to.
1499 * @return LY_SUCCESS on success.
1500 * @return LY_ERR on error.
1501 */
1502static LY_ERR
1503lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1504{
1505 struct lysp_ext_instance *ext_p;
1506 struct lysp_stmt *stmt;
1507 struct lysp_import *imp;
1508
1509 /* add new extension instance */
1510 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1511
1512 /* fill in the extension instance fields */
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, "default", 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, "boolean", 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 /* create new import for the used prefix */
1531 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1532
1533 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1534 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1535 imp->flags = LYS_INTERNAL;
1536
1537 return LY_SUCCESS;
1538}
1539
Michal Vasko3a41dff2020-07-15 14:30:28 +02001540LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001541lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001542 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 +02001543 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001544{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001545 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001546 LY_ERR ret;
Michal Vaskob36053d2020-03-26 15:49:30 +01001547 struct lys_yang_parser_ctx *yangctx = NULL;
1548 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001549 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001550 char *filename, *rev, *dot;
1551 size_t len;
Radek Krejcic64661b2020-08-15 15:42:26 +02001552 ly_bool module_created = 0;
Radek Krejci86d106e2018-10-18 09:53:19 +02001553
Michal Vaskodd992582021-06-10 14:34:57 +02001554 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001555
Michal Vasko7a0b0762020-09-02 16:37:01 +02001556 if (module) {
1557 *module = NULL;
1558 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001559
1560 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001561 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001562 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001563
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001564 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001565 switch (format) {
1566 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001567 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001568 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001569 break;
1570 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001571 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001572 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001573 break;
1574 default:
1575 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001576 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001577 break;
1578 }
Radek Krejcic64661b2020-08-15 15:42:26 +02001579 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001580
1581 /* make sure that the newest revision is at position 0 */
1582 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001583 if (mod->parsed->revs) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001584 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001585 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001586
Radek Krejcib3289d62019-09-18 12:21:39 +02001587 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001588 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001589 if (latest) {
1590 if (mod->revision) {
1591 if (!latest->revision) {
1592 /* latest has no revision, so mod is anyway newer */
aPiecek8ca21bd2021-07-26 14:31:01 +02001593 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001594 /* the latest is zeroed later when the new module is being inserted into the context */
1595 } else if (strcmp(mod->revision, latest->revision) > 0) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001596 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001597 /* the latest is zeroed later when the new module is being inserted into the context */
1598 } else {
1599 latest = NULL;
1600 }
1601 } else {
1602 latest = NULL;
1603 }
1604 } else {
aPiecek8ca21bd2021-07-26 14:31:01 +02001605 mod->latest_revision = LYS_MOD_LATEST_REV;
Radek Krejcib3289d62019-09-18 12:21:39 +02001606 }
1607
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001608 if (custom_check) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001609 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001610 }
1611
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001612 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001613 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001614 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001615 /* nothing to do */
1616 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1617 mod_dup->revision ? mod_dup->revision : "<none>");
Radek Krejcic64661b2020-08-15 15:42:26 +02001618 goto cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001619 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001620
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001621 switch (in->type) {
1622 case LY_IN_FILEPATH:
1623 /* check that name and revision match filename */
1624 filename = strrchr(in->method.fpath.filepath, '/');
1625 if (!filename) {
1626 filename = in->method.fpath.filepath;
1627 } else {
1628 filename++;
1629 }
1630 rev = strchr(filename, '@');
1631 dot = strrchr(filename, '.');
1632
1633 /* name */
1634 len = strlen(mod->name);
1635 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001636 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001637 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1638 }
1639 if (rev) {
1640 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001641 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001642 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001643 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001644 }
1645 }
1646
1647 break;
1648 case LY_IN_FD:
1649 case LY_IN_FILE:
1650 case LY_IN_MEMORY:
1651 /* nothing special to do */
1652 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001653 case LY_IN_ERROR:
1654 LOGINT(ctx);
1655 ret = LY_EINT;
Radek Krejcic64661b2020-08-15 15:42:26 +02001656 goto cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001657 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001658 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001659
Michal Vasko7a0b0762020-09-02 16:37:01 +02001660 if (latest) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001661 latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001662 }
1663
Michal Vasko45b521c2020-11-04 17:14:39 +01001664 /* add internal data in case specific modules were parsed */
1665 if (!strcmp(mod->name, "ietf-netconf")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001666 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001667 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001668 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001669 }
1670
Michal Vasko405cc9e2020-12-01 12:01:27 +01001671 /* add the module into newly created module set, will also be freed from there on any error */
Radek Krejcic64661b2020-08-15 15:42:26 +02001672 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup);
1673 module_created = 1;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001674
Michal Vasko7a0b0762020-09-02 16:37:01 +02001675 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001676 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001677 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001678 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001679
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001680 /* resolve includes and all imports */
aPiecekc3e26142021-06-22 14:25:49 +02001681 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001682
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001683 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001684 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001685 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001686 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1687 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001688
1689 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001690 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001691
aPiecek6b3d5422021-07-30 15:55:43 +02001692 /* compile identities */
1693 LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001694
Michal Vasko405cc9e2020-12-01 12:01:27 +01001695 /* success */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001696
Radek Krejcic64661b2020-08-15 15:42:26 +02001697cleanup:
Michal Vaskobe04af42021-07-16 10:48:43 +02001698 if (ret && (ret != LY_EEXIST)) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001699 if (mod && mod->name) {
1700 /* there are cases when path is not available for parsing error, so this additional
1701 * message tries to add information about the module where the error occurred */
1702 struct ly_err_item *e = ly_err_last(ctx);
1703 if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) {
1704 LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name);
1705 }
1706 }
1707 }
1708 if (!module_created) {
1709 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001710 mod = mod_dup;
1711 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001712
Michal Vasko7a0b0762020-09-02 16:37:01 +02001713 if (format == LYS_IN_YANG) {
1714 yang_parser_ctx_free(yangctx);
1715 } else {
1716 yin_parser_ctx_free(yinctx);
1717 }
1718
Michal Vasko405cc9e2020-12-01 12:01:27 +01001719 if (!ret && module) {
1720 *module = mod;
1721 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001722 return ret;
1723}
1724
Radek Krejci545b4872020-11-15 10:15:12 +01001725static LYS_INFORMAT
1726lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1727{
1728 if (!format && (in->type == LY_IN_FILEPATH)) {
1729 /* unknown format - try to detect it from filename's suffix */
1730 const char *path = in->method.fpath.filepath;
1731 size_t len = strlen(path);
1732
1733 /* ignore trailing whitespaces */
1734 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1735
Radek Krejcif13b87b2020-12-01 22:02:17 +01001736 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1737 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001738 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001739 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1740 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001741 format = LYS_IN_YIN;
1742 } /* else still unknown */
1743 }
1744
1745 return format;
1746}
1747
Michal Vasko7a0b0762020-09-02 16:37:01 +02001748API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001749lys_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 +02001750{
Michal Vasko65333882021-06-10 14:12:16 +02001751 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001752 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001753
Michal Vasko7a0b0762020-09-02 16:37:01 +02001754 if (module) {
1755 *module = NULL;
1756 }
Radek Krejci545b4872020-11-15 10:15:12 +01001757 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1758
1759 format = lys_parse_get_format(in, format);
1760 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001761
1762 /* remember input position */
1763 in->func_start = in->current;
1764
Michal Vasko4e205e82021-06-08 14:01:47 +02001765 /* parse */
Michal Vasko22b26222021-07-30 11:16:47 +02001766 ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001767 LY_CHECK_GOTO(ret, cleanup);
1768
1769 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001770 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001771 LY_CHECK_GOTO(ret, cleanup);
1772
Michal Vaskof4258e12021-06-15 12:11:42 +02001773 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1774 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001775 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001776
Michal Vasko709f9a52021-07-21 10:51:59 +02001777 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001778 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
1779
1780 /* unres resolved */
1781 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001782 }
1783
Michal Vasko405cc9e2020-12-01 12:01:27 +01001784cleanup:
1785 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001786 lys_unres_glob_revert(ctx, &ctx->unres);
1787 lys_unres_glob_erase(&ctx->unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001788 } else if (module) {
1789 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001790 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001791 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001792}
1793
Michal Vasko3a41dff2020-07-15 14:30:28 +02001794API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001795lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001796{
Radek Krejci0f969882020-08-21 16:56:47 +02001797 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001798 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001799
Michal Vasko3a41dff2020-07-15 14:30:28 +02001800 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001801
Michal Vasko3a41dff2020-07-15 14:30:28 +02001802 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 +02001803
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001804 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001805 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001806
Michal Vasko3a41dff2020-07-15 14:30:28 +02001807 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001808}
1809
Michal Vasko3a41dff2020-07-15 14:30:28 +02001810API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001811lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001812{
Radek Krejci0f969882020-08-21 16:56:47 +02001813 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001814 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001815
Michal Vasko3a41dff2020-07-15 14:30:28 +02001816 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001817
Michal Vasko3a41dff2020-07-15 14:30:28 +02001818 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 +02001819
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001820 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001821 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001822
Michal Vasko3a41dff2020-07-15 14:30:28 +02001823 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001824}
1825
Michal Vasko3a41dff2020-07-15 14:30:28 +02001826API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001827lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001828{
Radek Krejci0f969882020-08-21 16:56:47 +02001829 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001830 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001831
Michal Vasko3a41dff2020-07-15 14:30:28 +02001832 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001833
Michal Vasko3a41dff2020-07-15 14:30:28 +02001834 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001835 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001836
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001837 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001838 ly_in_free(in, 0);
1839
Michal Vasko3a41dff2020-07-15 14:30:28 +02001840 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001841}
1842
1843API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001844lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001845 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001846{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001847 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001848 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001849 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001850 char *wd, *wn = NULL;
1851 DIR *dir = NULL;
1852 struct dirent *file;
1853 char *match_name = NULL;
1854 LYS_INFORMAT format_aux, match_format = 0;
1855 struct ly_set *dirs;
1856 struct stat st;
1857
1858 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1859
1860 /* start to fill the dir fifo with the context's search path (if set)
1861 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001862 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001863
1864 len = strlen(name);
1865 if (cwd) {
1866 wd = get_current_dir_name();
1867 if (!wd) {
1868 LOGMEM(NULL);
1869 goto cleanup;
1870 } else {
1871 /* add implicit current working directory (./) to be searched,
1872 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001873 ret = ly_set_add(dirs, wd, 0, NULL);
1874 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001875 implicit_cwd = 1;
1876 }
1877 }
1878 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001879 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001880 /* check for duplicities with the implicit current working directory */
1881 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1882 implicit_cwd = 0;
1883 continue;
1884 }
1885 wd = strdup(searchpaths[i]);
1886 if (!wd) {
1887 LOGMEM(NULL);
1888 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001889 } else {
1890 ret = ly_set_add(dirs, wd, 0, NULL);
1891 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001892 }
1893 }
1894 }
1895 wd = NULL;
1896
1897 /* start searching */
1898 while (dirs->count) {
1899 free(wd);
1900 free(wn); wn = NULL;
1901
1902 dirs->count--;
1903 wd = (char *)dirs->objs[dirs->count];
1904 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001905 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001906
1907 if (dir) {
1908 closedir(dir);
1909 }
1910 dir = opendir(wd);
1911 dir_len = strlen(wd);
1912 if (!dir) {
1913 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1914 } else {
1915 while ((file = readdir(dir))) {
1916 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1917 /* skip . and .. */
1918 continue;
1919 }
1920 free(wn);
1921 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1922 LOGMEM(NULL);
1923 goto cleanup;
1924 }
1925 if (stat(wn, &st) == -1) {
1926 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001927 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001928 continue;
1929 }
1930 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1931 /* we have another subdirectory in searchpath to explore,
1932 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001933 ret = ly_set_add(dirs, wn, 0, NULL);
1934 LY_CHECK_GOTO(ret, cleanup);
1935
Radek Krejcid33273d2018-10-25 14:55:52 +02001936 /* continue with the next item in current directory */
1937 wn = NULL;
1938 continue;
1939 } else if (!S_ISREG(st.st_mode)) {
1940 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1941 continue;
1942 }
1943
1944 /* here we know that the item is a file which can contain a module */
1945 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001946 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001947 /* different filename than the module we search for */
1948 continue;
1949 }
1950
1951 /* get type according to filename suffix */
1952 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001953 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1954 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001955 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001956 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1957 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001958 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001959 } else {
1960 /* not supportde suffix/file format */
1961 continue;
1962 }
1963
1964 if (revision) {
1965 /* we look for the specific revision, try to get it from the filename */
1966 if (file->d_name[len] == '@') {
1967 /* check revision from the filename */
1968 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1969 /* another revision */
1970 continue;
1971 } else {
1972 /* exact revision */
1973 free(match_name);
1974 match_name = wn;
1975 wn = NULL;
1976 match_len = dir_len + 1 + len;
1977 match_format = format_aux;
1978 goto success;
1979 }
1980 } else {
1981 /* continue trying to find exact revision match, use this only if not found */
1982 free(match_name);
1983 match_name = wn;
1984 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001985 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001986 match_format = format_aux;
1987 continue;
1988 }
1989 } else {
1990 /* remember the revision and try to find the newest one */
1991 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001992 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01001993 lysp_check_date(NULL, &file->d_name[len + 1],
1994 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001995 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001996 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001997 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1998 continue;
1999 }
2000 free(match_name);
2001 }
2002
2003 match_name = wn;
2004 wn = NULL;
2005 match_len = dir_len + 1 + len;
2006 match_format = format_aux;
2007 continue;
2008 }
2009 }
2010 }
2011 }
2012
2013success:
2014 (*localfile) = match_name;
2015 match_name = NULL;
2016 if (format) {
2017 (*format) = match_format;
2018 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002019 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02002020
2021cleanup:
2022 free(wn);
2023 free(wd);
2024 if (dir) {
2025 closedir(dir);
2026 }
2027 free(match_name);
2028 ly_set_free(dirs, free);
2029
2030 return ret;
2031}