blob: b5bf8eb860b1d8bab0d58316b6a828f4a4129093 [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 Vaskoed725d72021-06-23 12:03:45 +0200672 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, oper, LY_PATH_TARGET_MANY, 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 Vaskoed725d72021-06-23 12:03:45 +0200705 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, exp, oper, LY_PATH_TARGET_MANY, 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 Vasko03ff5a72019-09-11 13:49:33 +0200721 const struct lysc_node *iter;
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 Vasko69730152020-10-09 16:30:07 +0200749 if (!iter->parent || (iter->parent->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200750 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200751 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100752 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200753 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100754 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200755 }
Radek Krejci327de162019-06-14 12:52:07 +0200756 } else {
757 /* prefix is the same as in parent */
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", slash, 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", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200762 }
Radek Krejci327de162019-06-14 12:52:07 +0200763 }
764 free(s);
765 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200766
Michal Vasko69730152020-10-09 16:30:07 +0200767 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200768 /* not enough space in buffer */
769 break;
770 }
Radek Krejci327de162019-06-14 12:52:07 +0200771 }
772
773 if (len < 0) {
774 free(path);
775 path = NULL;
776 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200777 if (buffer) {
778 strcpy(buffer, "/");
779 } else {
780 path = strdup("/");
781 }
Radek Krejci327de162019-06-14 12:52:07 +0200782 }
783 break;
784 }
785
Radek Krejci1c0c3442019-07-23 16:08:47 +0200786 if (buffer) {
787 return buffer;
788 } else {
789 return path;
790 }
Radek Krejci327de162019-06-14 12:52:07 +0200791}
792
Michal Vasko14654712020-02-06 08:35:21 +0100793API char *
794lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
795{
796 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
797}
798
Michal Vasko405cc9e2020-12-01 12:01:27 +0100799LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200800_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100801{
802 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko65333882021-06-10 14:12:16 +0200803 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100804
Michal Vasko405cc9e2020-12-01 12:01:27 +0100805 if (mod->implemented) {
806 /* mod is already implemented, set the features */
807 r = lys_set_features(mod->parsed, features);
808 if (r == LY_EEXIST) {
809 /* no changes */
810 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200811 } else if (!r) {
812 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200813 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200814 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200815
816 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200817 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100818
Michal Vasko7213ac52021-06-15 11:52:13 +0200819 /* implement, ignore recompilation because it must always take place later */
820 r = lys_implement(mod, features, unres);
821 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200822
823 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
824 /* implement all the imports as well */
825 for (i = 0; i < unres->creating.count; ++i) {
826 mod = unres->creating.objs[i];
827 if (mod->implemented) {
828 continue;
829 }
830
Michal Vasko7213ac52021-06-15 11:52:13 +0200831 r = lys_implement(mod, NULL, unres);
832 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200833 }
834 }
835
Michal Vasko65333882021-06-10 14:12:16 +0200836cleanup:
837 return ret;
838}
839
Michal Vaskof4258e12021-06-15 12:11:42 +0200840/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200841 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
842 * and if so, add it into its dep set.
843 *
844 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
845 * in the dep set are (re)compiled.
846 *
847 * The reason for recompilation is possible disabled nodes and updating
848 * leafref targets to point to the newly compiled modules. Using the import relation, the
849 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
850 * during the target module compilation.
851 *
852 * - every module must belong to exactly one dep set
853 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200854 *
855 * @param[in] mod Module to process.
856 * @param[in,out] ctx_set Set with all not-yet-processed modules.
857 * @param[in,out] dep_set Current dependency set to update.
Michal Vaskof4258e12021-06-15 12:11:42 +0200858 * @return LY_ERR value.
859 */
860static LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +0200861lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200862{
863 struct lys_module *mod2;
864 struct lysp_import *imports;
865 uint32_t i;
866 LY_ARRAY_COUNT_TYPE u, v;
867 ly_bool found;
868
Michal Vaskof4258e12021-06-15 12:11:42 +0200869 if (!ly_set_contains(ctx_set, mod, &i)) {
870 /* it was already processed */
871 return LY_SUCCESS;
872 }
873
874 /* remove it from the set, we are processing it now */
875 ly_set_rm_index(ctx_set, i, NULL);
876
Michal Vasko7ee5be22021-06-16 17:03:34 +0200877 if (!lys_has_compiled(mod) || (mod->compiled && !lys_has_recompiled(mod))) {
878 if (!dep_set->count) {
879 /* add a new dependent module into the dep set */
880 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200881 }
Michal Vasko7ee5be22021-06-16 17:03:34 +0200882
883 if (!lys_has_groupings(mod)) {
884 /* break the dep set here, nothing to compile or recompile and no groupings, no modules will depend
885 * on this one */
886 return LY_SUCCESS;
887 }
888 } else {
889 /* add a new dependent module into the dep set */
890 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200891 }
892
893 /* process imports of the module and submodules */
894 imports = mod->parsed->imports;
895 LY_ARRAY_FOR(imports, u) {
Michal Vasko50bc09a2021-06-17 17:31:56 +0200896 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(imports[u].module, ctx_set, dep_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200897 }
898 LY_ARRAY_FOR(mod->parsed->includes, v) {
899 imports = mod->parsed->includes[v].submodule->imports;
900 LY_ARRAY_FOR(imports, u) {
Michal Vasko50bc09a2021-06-17 17:31:56 +0200901 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(imports[u].module, ctx_set, dep_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200902 }
903 }
904
905 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200906 for (i = 0; i < mod->ctx->list.count; ++i) {
907 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200908 found = 0;
909
910 imports = mod2->parsed->imports;
911 LY_ARRAY_FOR(imports, u) {
912 if (imports[u].module == mod) {
913 found = 1;
914 break;
915 }
916 }
917
918 if (!found) {
919 LY_ARRAY_FOR(mod2->parsed->includes, v) {
920 imports = mod2->parsed->includes[v].submodule->imports;
921 LY_ARRAY_FOR(imports, u) {
922 if (imports[u].module == mod) {
923 found = 1;
924 break;
925 }
926 }
927
928 if (found) {
929 break;
930 }
931 }
932 }
933
934 if (found) {
Michal Vasko50bc09a2021-06-17 17:31:56 +0200935 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200936 }
937 }
938
939 return LY_SUCCESS;
940}
941
942LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +0200943lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +0200944{
945 LY_ERR ret = LY_SUCCESS;
946 struct lys_module *m;
947 struct ly_set *dep_set = NULL, *ctx_set = NULL;
948 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +0200949 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +0200950
951 /* start with a duplicate set of modules that we will remove from */
952 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
953
954 while (ctx_set->count) {
955 /* create new dep set */
956 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
957
958 if (mod) {
959 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko50bc09a2021-06-17 17:31:56 +0200960 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(mod, ctx_set, dep_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200961 } else {
962 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko50bc09a2021-06-17 17:31:56 +0200963 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(ctx_set->objs[0], ctx_set, dep_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200964 }
Michal Vasko7ee5be22021-06-16 17:03:34 +0200965 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +0200966
967 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200968 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +0200969 for (i = 0; i < dep_set->count; ++i) {
970 m = dep_set->objs[i];
971 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +0200972 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +0200973 break;
974 }
975 }
976
Michal Vasko7ee5be22021-06-16 17:03:34 +0200977 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +0200978 /* if there is, all the implemented modules need to be recompiled */
979 for (i = 0; i < dep_set->count; ++i) {
980 m = dep_set->objs[i];
981 if (m->implemented) {
982 m->to_compile = 1;
983 }
984 }
985 }
986
Michal Vasko7ee5be22021-06-16 17:03:34 +0200987 /* add the dep set into main set */
988 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200989 dep_set = NULL;
990
991 if (mod) {
992 /* we need dep set only for this module */
993 break;
994 }
995 }
996
997cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +0200998 assert(ret || main_set->objs);
Michal Vaskof4258e12021-06-15 12:11:42 +0200999 ly_set_free(dep_set, NULL);
1000 ly_set_free(ctx_set, NULL);
1001 return ret;
1002}
1003
1004void
1005lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1006{
1007 uint32_t i, j, idx, prev_lo;
1008 struct ly_set *dep_set;
1009 struct lys_module *m;
1010 LY_ERR ret;
1011
1012 for (i = 0; i < unres->implementing.count; ++i) {
1013 m = unres->implementing.objs[i];
1014 assert(m->implemented);
1015
1016 /* make the module correctly non-implemented again */
1017 m->implemented = 0;
1018 lys_precompile_augments_deviations_revert(ctx, m);
1019 lysc_module_free(m->compiled);
1020 m->compiled = NULL;
1021
1022 /* should not be made implemented */
1023 m->to_compile = 0;
1024 }
1025
1026 for (i = 0; i < unres->creating.count; ++i) {
1027 m = unres->creating.objs[i];
1028
Michal Vaskod297f2a2021-06-16 11:51:28 +02001029 /* remove the module from the context */
Michal Vaskof4258e12021-06-15 12:11:42 +02001030 ly_set_rm(&ctx->list, m, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001031
Michal Vasko7ee5be22021-06-16 17:03:34 +02001032 /* remove it also from dep sets (it may not be there if we have created only a single dep set for the main module) */
1033 for (j = 0; j < unres->dep_sets.count; ++j) {
1034 dep_set = unres->dep_sets.objs[j];
1035 if (ly_set_contains(dep_set, m, &idx)) {
1036 ly_set_rm_index(dep_set, idx, NULL);
1037 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001038 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001039 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001040
1041 /* free the module */
1042 lys_module_free(m);
Michal Vaskof4258e12021-06-15 12:11:42 +02001043 }
1044
1045 if (unres->implementing.count) {
1046 /* recompile previous context because some implemented modules are no longer implemented,
1047 * we can reuse the current to_compile flags */
1048 prev_lo = ly_log_options(0);
1049 ret = ly_ctx_compile(ctx);
1050 ly_log_options(prev_lo);
1051 if (ret) {
1052 LOGINT(ctx);
1053 }
1054 }
1055}
1056
1057void
1058lys_unres_glob_erase(struct lys_glob_unres *unres)
1059{
1060 uint32_t i;
1061
1062 for (i = 0; i < unres->dep_sets.count; ++i) {
1063 ly_set_free(unres->dep_sets.objs[i], NULL);
1064 }
1065 ly_set_erase(&unres->dep_sets, NULL);
1066 ly_set_erase(&unres->implementing, NULL);
1067 ly_set_erase(&unres->creating, NULL);
1068
1069 assert(!unres->ds_unres.xpath.count);
1070 assert(!unres->ds_unres.leafrefs.count);
1071 assert(!unres->ds_unres.dflts.count);
1072 assert(!unres->ds_unres.disabled.count);
1073}
1074
Michal Vasko65333882021-06-10 14:12:16 +02001075API LY_ERR
1076lys_set_implemented(struct lys_module *mod, const char **features)
1077{
1078 LY_ERR ret = LY_SUCCESS;
1079 struct lys_glob_unres unres = {0};
1080
1081 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1082
1083 /* implement */
1084 ret = _lys_set_implemented(mod, features, &unres);
1085 LY_CHECK_GOTO(ret, cleanup);
1086
Michal Vaskof4258e12021-06-15 12:11:42 +02001087 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1088 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko50bc09a2021-06-17 17:31:56 +02001089 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001090
1091 /* (re)compile the whole dep set */
1092 LY_CHECK_GOTO(ret = lys_compile_dep_set_r(mod->ctx, unres.dep_sets.objs[0], &unres), cleanup);
1093 }
1094
Michal Vasko65333882021-06-10 14:12:16 +02001095cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001096 if (ret) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001097 lys_unres_glob_revert(mod->ctx, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001098 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001099 lys_unres_glob_erase(&unres);
Michal Vasko89b5c072020-10-06 13:52:44 +02001100 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001101}
1102
Michal Vasko7c8439f2020-08-05 13:25:19 +02001103static LY_ERR
aPiecekc3e26142021-06-22 14:25:49 +02001104lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001105{
1106 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001107 LY_ARRAY_COUNT_TYPE u, v;
1108
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001109 pmod->parsing = 1;
1110 LY_ARRAY_FOR(pmod->imports, u) {
1111 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001112 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001113 LY_CHECK_RET(lys_parse_load(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, new_mods, &imp->module));
Michal Vasko7c8439f2020-08-05 13:25:19 +02001114 }
1115 /* check for importing the same module twice */
1116 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001117 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001118 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1119 }
1120 }
1121 }
aPiecekc3e26142021-06-22 14:25:49 +02001122 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001123
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001124 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001125
1126 return LY_SUCCESS;
1127}
1128
Michal Vasko3a41dff2020-07-15 14:30:28 +02001129LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001130lys_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 +02001131 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001132 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001133{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001134 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001135 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +01001136 struct lys_yang_parser_ctx *yangctx = NULL;
1137 struct lys_yin_parser_ctx *yinctx = NULL;
1138 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001139
Michal Vasko3a41dff2020-07-15 14:30:28 +02001140 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001141
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001142 switch (format) {
1143 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001144 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001145 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001146 break;
1147 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001148 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001149 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001150 break;
1151 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001152 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001153 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001154 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001155 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001156 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001157 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001158
1159 /* make sure that the newest revision is at position 0 */
1160 lysp_sort_revisions(submod->revs);
1161
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001162 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001163 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001164 if (latest_sp) {
1165 if (submod->revs) {
1166 if (!latest_sp->revs) {
1167 /* latest has no revision, so mod is anyway newer */
1168 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001169 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1170 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1171 submod->latest_revision = latest_sp->latest_revision;
1172 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001173 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001174 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001175 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001176 } else {
1177 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001178 }
1179 } else {
1180 submod->latest_revision = 1;
1181 }
1182
Radek Krejcib3289d62019-09-18 12:21:39 +02001183 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001184 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001185 }
1186
1187 if (latest_sp) {
1188 latest_sp->latest_revision = 0;
1189 }
1190
Michal Vasko7a0b0762020-09-02 16:37:01 +02001191 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1192
Michal Vasko7c8439f2020-08-05 13:25:19 +02001193 /* resolve imports and includes */
aPiecekc3e26142021-06-22 14:25:49 +02001194 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001195
David Sedlák1b623122019-08-05 15:27:49 +02001196 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001197 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001198 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001199 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001200 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001201 *submodule = submod;
1202 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001203
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001204error:
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001205 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001206 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001207 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001208 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001209 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001210 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001211 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001212}
1213
Michal Vasko45b521c2020-11-04 17:14:39 +01001214/**
1215 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1216 *
1217 * @param[in] mod Parsed module to add to.
1218 * @return LY_SUCCESS on success.
1219 * @return LY_ERR on error.
1220 */
1221static LY_ERR
1222lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
1223{
1224 struct lysp_ext_instance *ext_p;
1225 struct lysp_stmt *stmt;
1226 struct lysp_import *imp;
1227
1228 /*
1229 * 1) edit-config's operation
1230 */
1231 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1232 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1233 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1234 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001235 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001236 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001237 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001238 ext_p->parent_stmt = LY_STMT_MODULE;
1239 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001240
1241 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1242 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1243 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1244 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001245 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001246 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001247 stmt->kw = LY_STMT_TYPE;
1248
1249 stmt->child = calloc(1, sizeof *stmt->child);
1250 stmt = stmt->child;
1251 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1252 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1253 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001254 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001255 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001256 stmt->kw = LY_STMT_ENUM;
1257
1258 stmt->next = calloc(1, sizeof *stmt->child);
1259 stmt = stmt->next;
1260 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1261 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1262 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001263 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001264 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001265 stmt->kw = LY_STMT_ENUM;
1266
1267 stmt->next = calloc(1, sizeof *stmt->child);
1268 stmt = stmt->next;
1269 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1270 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1271 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001272 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001273 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001274 stmt->kw = LY_STMT_ENUM;
1275
1276 stmt->next = calloc(1, sizeof *stmt->child);
1277 stmt = stmt->next;
1278 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1279 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1280 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001281 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001282 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001283 stmt->kw = LY_STMT_ENUM;
1284
1285 stmt->next = calloc(1, sizeof *stmt->child);
1286 stmt = stmt->next;
1287 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1288 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1289 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001290 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001291 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001292 stmt->kw = LY_STMT_ENUM;
1293
1294 /*
1295 * 2) filter's type
1296 */
1297 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1298 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1299 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1300 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001301 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001302 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001303 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001304 ext_p->parent_stmt = LY_STMT_MODULE;
1305 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001306
1307 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1308 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1309 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1310 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001311 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001312 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001313 stmt->kw = LY_STMT_TYPE;
1314
1315 stmt->child = calloc(1, sizeof *stmt->child);
1316 stmt = stmt->child;
1317 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1318 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1319 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001320 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001321 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001322 stmt->kw = LY_STMT_ENUM;
1323
1324 stmt->next = calloc(1, sizeof *stmt->child);
1325 stmt = stmt->next;
1326 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1327 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1328 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001329 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001330 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001331 stmt->kw = LY_STMT_ENUM;
1332
1333 /* if-feature for enum allowed only for YANG 1.1 modules */
1334 if (mod->version >= LYS_VERSION_1_1) {
1335 stmt->child = calloc(1, sizeof *stmt->child);
1336 stmt = stmt->child;
1337 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1338 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1339 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001340 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001341 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001342 stmt->kw = LY_STMT_IF_FEATURE;
1343 }
1344
1345 /*
1346 * 3) filter's select
1347 */
1348 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1349 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1350 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1351 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001352 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001353 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001354 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001355 ext_p->parent_stmt = LY_STMT_MODULE;
1356 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001357
1358 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1359 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1360 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1361 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001362 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001363 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001364 stmt->kw = LY_STMT_TYPE;
1365
1366 /* create new imports for the used prefixes */
1367 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1368
1369 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1370 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1371 imp->flags = LYS_INTERNAL;
1372
1373 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1374
1375 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1376 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1377 imp->flags = LYS_INTERNAL;
1378
1379 return LY_SUCCESS;
1380}
1381
1382/**
1383 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1384 *
1385 * @param[in] mod Parsed module to add to.
1386 * @return LY_SUCCESS on success.
1387 * @return LY_ERR on error.
1388 */
1389static LY_ERR
1390lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1391{
1392 struct lysp_ext_instance *ext_p;
1393 struct lysp_stmt *stmt;
1394 struct lysp_import *imp;
1395
1396 /* add new extension instance */
1397 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1398
1399 /* fill in the extension instance fields */
1400 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1401 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1402 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001403 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001404 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001405 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001406 ext_p->parent_stmt = LY_STMT_MODULE;
1407 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001408
1409 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1410 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1411 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1412 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001413 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001414 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001415 stmt->kw = LY_STMT_TYPE;
1416
1417 /* create new import for the used prefix */
1418 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1419
1420 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1421 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1422 imp->flags = LYS_INTERNAL;
1423
1424 return LY_SUCCESS;
1425}
1426
Michal Vasko3a41dff2020-07-15 14:30:28 +02001427LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001428lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001429 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 +02001430 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001431{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001432 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001433 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001434 LY_ERR ret;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001435 LY_ARRAY_COUNT_TYPE u;
Michal Vaskob36053d2020-03-26 15:49:30 +01001436 struct lys_yang_parser_ctx *yangctx = NULL;
1437 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001438 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001439 char *filename, *rev, *dot;
1440 size_t len;
Radek Krejci86d106e2018-10-18 09:53:19 +02001441
Michal Vaskodd992582021-06-10 14:34:57 +02001442 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001443
Michal Vasko7a0b0762020-09-02 16:37:01 +02001444 if (module) {
1445 *module = NULL;
1446 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001447
1448 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001449 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001450 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001451
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001452 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001453 switch (format) {
1454 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001455 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001456 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001457 break;
1458 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001459 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001460 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001461 break;
1462 default:
1463 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001464 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001465 break;
1466 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001467 LY_CHECK_GOTO(ret, free_mod_cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001468
1469 /* make sure that the newest revision is at position 0 */
1470 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001471 if (mod->parsed->revs) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001472 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), free_mod_cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001473 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001474
Radek Krejcib3289d62019-09-18 12:21:39 +02001475 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001476 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001477 if (latest) {
1478 if (mod->revision) {
1479 if (!latest->revision) {
1480 /* latest has no revision, so mod is anyway newer */
1481 mod->latest_revision = latest->latest_revision;
1482 /* the latest is zeroed later when the new module is being inserted into the context */
1483 } else if (strcmp(mod->revision, latest->revision) > 0) {
1484 mod->latest_revision = latest->latest_revision;
1485 /* the latest is zeroed later when the new module is being inserted into the context */
1486 } else {
1487 latest = NULL;
1488 }
1489 } else {
1490 latest = NULL;
1491 }
1492 } else {
1493 mod->latest_revision = 1;
1494 }
1495
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001496 if (custom_check) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001497 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), free_mod_cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001498 }
1499
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001500 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001501 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001502 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001503 /* nothing to do */
1504 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1505 mod_dup->revision ? mod_dup->revision : "<none>");
1506 goto free_mod_cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001507 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001508
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001509 switch (in->type) {
1510 case LY_IN_FILEPATH:
1511 /* check that name and revision match filename */
1512 filename = strrchr(in->method.fpath.filepath, '/');
1513 if (!filename) {
1514 filename = in->method.fpath.filepath;
1515 } else {
1516 filename++;
1517 }
1518 rev = strchr(filename, '@');
1519 dot = strrchr(filename, '.');
1520
1521 /* name */
1522 len = strlen(mod->name);
1523 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001524 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001525 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1526 }
1527 if (rev) {
1528 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001529 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001530 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001531 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001532 }
1533 }
1534
1535 break;
1536 case LY_IN_FD:
1537 case LY_IN_FILE:
1538 case LY_IN_MEMORY:
1539 /* nothing special to do */
1540 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001541 case LY_IN_ERROR:
1542 LOGINT(ctx);
1543 ret = LY_EINT;
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001544 goto free_mod_cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001545 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001546 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001547
Michal Vasko7a0b0762020-09-02 16:37:01 +02001548 if (latest) {
1549 latest->latest_revision = 0;
1550 }
1551
Michal Vasko45b521c2020-11-04 17:14:39 +01001552 /* add internal data in case specific modules were parsed */
1553 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001554 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001555 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001556 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001557 }
1558
Michal Vasko405cc9e2020-12-01 12:01:27 +01001559 /* add the module into newly created module set, will also be freed from there on any error */
Michal Vaskodd992582021-06-10 14:34:57 +02001560 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), free_mod_cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001561
Michal Vasko7a0b0762020-09-02 16:37:01 +02001562 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001563 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001564 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001565 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001566
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001567 /* resolve includes and all imports */
aPiecekc3e26142021-06-22 14:25:49 +02001568 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001569
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001570 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001571 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001572 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001573 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1574 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001575
1576 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001577 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001578
Michal Vasko05e32042021-04-23 13:40:56 +02001579 /* pre-compile identities of the module and any submodules */
1580 LY_CHECK_GOTO(ret = lys_identity_precompile(NULL, ctx, mod->parsed, mod->parsed->identities, &mod->identities), cleanup);
1581 LY_ARRAY_FOR(mod->parsed->includes, u) {
1582 submod = mod->parsed->includes[u].submodule;
1583 ret = lys_identity_precompile(NULL, ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
1584 LY_CHECK_GOTO(ret, cleanup);
1585 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001586
Michal Vasko405cc9e2020-12-01 12:01:27 +01001587 /* success */
1588 goto cleanup;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001589
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001590free_mod_cleanup:
Radek Krejci90ed21e2021-04-12 14:47:46 +02001591 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001592 if (ret) {
1593 mod = NULL;
1594 } else {
1595 /* return the existing module */
1596 assert(mod_dup);
1597 mod = mod_dup;
1598 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001599
Michal Vasko405cc9e2020-12-01 12:01:27 +01001600cleanup:
Michal Vasko7a0b0762020-09-02 16:37:01 +02001601 if (format == LYS_IN_YANG) {
1602 yang_parser_ctx_free(yangctx);
1603 } else {
1604 yin_parser_ctx_free(yinctx);
1605 }
1606
Michal Vasko405cc9e2020-12-01 12:01:27 +01001607 if (!ret && module) {
1608 *module = mod;
1609 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001610 return ret;
1611}
1612
Radek Krejci545b4872020-11-15 10:15:12 +01001613static LYS_INFORMAT
1614lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1615{
1616 if (!format && (in->type == LY_IN_FILEPATH)) {
1617 /* unknown format - try to detect it from filename's suffix */
1618 const char *path = in->method.fpath.filepath;
1619 size_t len = strlen(path);
1620
1621 /* ignore trailing whitespaces */
1622 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1623
Radek Krejcif13b87b2020-12-01 22:02:17 +01001624 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1625 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001626 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001627 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1628 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001629 format = LYS_IN_YIN;
1630 } /* else still unknown */
1631 }
1632
1633 return format;
1634}
1635
Michal Vasko7a0b0762020-09-02 16:37:01 +02001636API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001637lys_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 +02001638{
Michal Vasko65333882021-06-10 14:12:16 +02001639 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001640 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001641 struct lys_glob_unres unres = {0};
1642
Michal Vasko7a0b0762020-09-02 16:37:01 +02001643 if (module) {
1644 *module = NULL;
1645 }
Radek Krejci545b4872020-11-15 10:15:12 +01001646 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1647
1648 format = lys_parse_get_format(in, format);
1649 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001650
1651 /* remember input position */
1652 in->func_start = in->current;
1653
Michal Vasko4e205e82021-06-08 14:01:47 +02001654 /* parse */
Michal Vaskodd992582021-06-10 14:34:57 +02001655 ret = lys_parse_in(ctx, in, format, NULL, NULL, &unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001656 LY_CHECK_GOTO(ret, cleanup);
1657
1658 /* implement */
Michal Vasko65333882021-06-10 14:12:16 +02001659 ret = _lys_set_implemented(mod, features, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001660 LY_CHECK_GOTO(ret, cleanup);
1661
Michal Vaskof4258e12021-06-15 12:11:42 +02001662 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1663 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko50bc09a2021-06-17 17:31:56 +02001664 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001665
1666 /* (re)compile the whole dep set */
1667 LY_CHECK_GOTO(ret = lys_compile_dep_set_r(ctx, unres.dep_sets.objs[0], &unres), cleanup);
1668 }
1669
Michal Vasko405cc9e2020-12-01 12:01:27 +01001670cleanup:
1671 if (ret) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001672 lys_unres_glob_revert(ctx, &unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001673 } else if (module) {
1674 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001675 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001676 lys_unres_glob_erase(&unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001677 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001678}
1679
Michal Vasko3a41dff2020-07-15 14:30:28 +02001680API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001681lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001682{
Radek Krejci0f969882020-08-21 16:56:47 +02001683 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001684 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001685
Michal Vasko3a41dff2020-07-15 14:30:28 +02001686 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001687
Michal Vasko3a41dff2020-07-15 14:30:28 +02001688 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 +02001689
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001690 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001691 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001692
Michal Vasko3a41dff2020-07-15 14:30:28 +02001693 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001694}
1695
Michal Vasko3a41dff2020-07-15 14:30:28 +02001696API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001697lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001698{
Radek Krejci0f969882020-08-21 16:56:47 +02001699 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001700 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001701
Michal Vasko3a41dff2020-07-15 14:30:28 +02001702 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001703
Michal Vasko3a41dff2020-07-15 14:30:28 +02001704 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 +02001705
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001706 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001707 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001708
Michal Vasko3a41dff2020-07-15 14:30:28 +02001709 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001710}
1711
Michal Vasko3a41dff2020-07-15 14:30:28 +02001712API LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001713lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001714{
Radek Krejci0f969882020-08-21 16:56:47 +02001715 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001716 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001717
Michal Vasko3a41dff2020-07-15 14:30:28 +02001718 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001719
Michal Vasko3a41dff2020-07-15 14:30:28 +02001720 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001721 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001722
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001723 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001724 ly_in_free(in, 0);
1725
Michal Vasko3a41dff2020-07-15 14:30:28 +02001726 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001727}
1728
1729API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001730lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001731 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001732{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001733 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001734 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001735 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001736 char *wd, *wn = NULL;
1737 DIR *dir = NULL;
1738 struct dirent *file;
1739 char *match_name = NULL;
1740 LYS_INFORMAT format_aux, match_format = 0;
1741 struct ly_set *dirs;
1742 struct stat st;
1743
1744 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1745
1746 /* start to fill the dir fifo with the context's search path (if set)
1747 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001748 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001749
1750 len = strlen(name);
1751 if (cwd) {
1752 wd = get_current_dir_name();
1753 if (!wd) {
1754 LOGMEM(NULL);
1755 goto cleanup;
1756 } else {
1757 /* add implicit current working directory (./) to be searched,
1758 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001759 ret = ly_set_add(dirs, wd, 0, NULL);
1760 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001761 implicit_cwd = 1;
1762 }
1763 }
1764 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001765 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001766 /* check for duplicities with the implicit current working directory */
1767 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1768 implicit_cwd = 0;
1769 continue;
1770 }
1771 wd = strdup(searchpaths[i]);
1772 if (!wd) {
1773 LOGMEM(NULL);
1774 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001775 } else {
1776 ret = ly_set_add(dirs, wd, 0, NULL);
1777 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001778 }
1779 }
1780 }
1781 wd = NULL;
1782
1783 /* start searching */
1784 while (dirs->count) {
1785 free(wd);
1786 free(wn); wn = NULL;
1787
1788 dirs->count--;
1789 wd = (char *)dirs->objs[dirs->count];
1790 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001791 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001792
1793 if (dir) {
1794 closedir(dir);
1795 }
1796 dir = opendir(wd);
1797 dir_len = strlen(wd);
1798 if (!dir) {
1799 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1800 } else {
1801 while ((file = readdir(dir))) {
1802 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1803 /* skip . and .. */
1804 continue;
1805 }
1806 free(wn);
1807 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1808 LOGMEM(NULL);
1809 goto cleanup;
1810 }
1811 if (stat(wn, &st) == -1) {
1812 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001813 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001814 continue;
1815 }
1816 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1817 /* we have another subdirectory in searchpath to explore,
1818 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001819 ret = ly_set_add(dirs, wn, 0, NULL);
1820 LY_CHECK_GOTO(ret, cleanup);
1821
Radek Krejcid33273d2018-10-25 14:55:52 +02001822 /* continue with the next item in current directory */
1823 wn = NULL;
1824 continue;
1825 } else if (!S_ISREG(st.st_mode)) {
1826 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1827 continue;
1828 }
1829
1830 /* here we know that the item is a file which can contain a module */
1831 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001832 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001833 /* different filename than the module we search for */
1834 continue;
1835 }
1836
1837 /* get type according to filename suffix */
1838 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001839 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1840 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001841 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001842 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1843 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001844 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001845 } else {
1846 /* not supportde suffix/file format */
1847 continue;
1848 }
1849
1850 if (revision) {
1851 /* we look for the specific revision, try to get it from the filename */
1852 if (file->d_name[len] == '@') {
1853 /* check revision from the filename */
1854 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1855 /* another revision */
1856 continue;
1857 } else {
1858 /* exact revision */
1859 free(match_name);
1860 match_name = wn;
1861 wn = NULL;
1862 match_len = dir_len + 1 + len;
1863 match_format = format_aux;
1864 goto success;
1865 }
1866 } else {
1867 /* continue trying to find exact revision match, use this only if not found */
1868 free(match_name);
1869 match_name = wn;
1870 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001871 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001872 match_format = format_aux;
1873 continue;
1874 }
1875 } else {
1876 /* remember the revision and try to find the newest one */
1877 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001878 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01001879 lysp_check_date(NULL, &file->d_name[len + 1],
1880 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001881 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001882 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001883 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1884 continue;
1885 }
1886 free(match_name);
1887 }
1888
1889 match_name = wn;
1890 wn = NULL;
1891 match_len = dir_len + 1 + len;
1892 match_format = format_aux;
1893 continue;
1894 }
1895 }
1896 }
1897 }
1898
1899success:
1900 (*localfile) = match_name;
1901 match_name = NULL;
1902 if (format) {
1903 (*format) = match_format;
1904 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02001905 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02001906
1907cleanup:
1908 free(wn);
1909 free(wd);
1910 if (dir) {
1911 closedir(dir);
1912 }
1913 free(match_name);
1914 ly_set_free(dirs, free);
1915
1916 return ret;
1917}