blob: 076fa370b7586dde974dc544b31d52e09183e153 [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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100130LIBYANG_API_DEF const char *
Radek Krejcif8ca8192021-03-02 16:50:06 +0100131ly_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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100147LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200148lysc_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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100184LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200185lysc_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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100399LIBYANG_API_DEF 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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100405LIBYANG_API_DEF const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100406lys_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
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100444LIBYANG_API_DEF 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);
Michal Vasko1d80a532021-11-24 10:41:05 +0100451 LY_CHECK_CTX_EQUAL_RET(parent ? parent->module->ctx : NULL, module->ctx, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100452 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100453 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100454 }
455
456 while ((node = lys_getnext(node, parent, module->compiled, options))) {
457 if (!(node->nodetype & nodetype)) {
458 continue;
459 }
460 if (node->module != module) {
461 continue;
462 }
463
464 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200465 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100466 return node;
467 }
468 } else {
469 if (!strcmp(node->name, name)) {
470 return node;
471 }
472 }
473 }
474 return NULL;
475}
476
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100477LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100478lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
479 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200480{
481 LY_ERR ret = LY_SUCCESS;
482 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200483 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200484 uint32_t i;
485
Michal Vasko26512682021-01-11 11:35:40 +0100486 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100487 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200488 if (!(options & LYXP_SCNODE_ALL)) {
Michal Vasko4ad69e72021-10-26 16:25:55 +0200489 options |= LYXP_SCNODE;
Michal Vasko519fd602020-05-26 12:17:39 +0200490 }
Michal Vasko26512682021-01-11 11:35:40 +0100491 if (!ctx) {
492 ctx = ctx_node->module->ctx;
493 }
Michal Vasko519fd602020-05-26 12:17:39 +0200494
495 memset(&xp_set, 0, sizeof xp_set);
496
497 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100498 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200499 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200500
501 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200502 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200503 LY_CHECK_GOTO(ret, cleanup);
504
505 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200506 ret = ly_set_new(set);
507 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200508
509 /* transform into ly_set */
510 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100511 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200512 (*set)->size = xp_set.used;
513
514 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200515 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200516 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200517 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200518 }
519 }
520
521cleanup:
522 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100523 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200524 return ret;
525}
526
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100527LIBYANG_API_DEF LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200528lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
529 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
530{
531 LY_ERR ret = LY_SUCCESS;
532 struct lyxp_set xp_set = {0};
533 uint32_t i;
534
535 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100536 LY_CHECK_CTX_EQUAL_RET(ctx_node ? ctx_node->module->ctx : NULL, cur_mod->ctx, LY_EINVAL);
Michal Vasko40308e72020-10-20 16:38:40 +0200537 if (!(options & LYXP_SCNODE_ALL)) {
538 options = LYXP_SCNODE;
539 }
540
541 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200542 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 +0200543 LY_CHECK_GOTO(ret, cleanup);
544
545 /* allocate return set */
546 ret = ly_set_new(set);
547 LY_CHECK_GOTO(ret, cleanup);
548
549 /* transform into ly_set */
550 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
551 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
552 (*set)->size = xp_set.used;
553
554 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200555 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
556 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
557 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100558 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200559 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
560 LY_CHECK_GOTO(ret, cleanup);
561 }
562 }
563
564cleanup:
565 lyxp_set_free_content(&xp_set);
566 if (ret) {
567 ly_set_free(*set, NULL);
568 *set = NULL;
569 }
570 return ret;
571}
572
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100573LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100574lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
575 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200576{
577 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200578 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200579 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200580 uint32_t i;
581
Michal Vasko26512682021-01-11 11:35:40 +0100582 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100583 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200584 if (!(options & LYXP_SCNODE_ALL)) {
585 options = LYXP_SCNODE;
586 }
Michal Vasko26512682021-01-11 11:35:40 +0100587 if (!ctx) {
588 ctx = ctx_node->module->ctx;
589 }
Michal Vasko072de482020-08-05 13:27:21 +0200590
Michal Vasko072de482020-08-05 13:27:21 +0200591 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100592 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200593 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200594
595 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200596 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200597 LY_CHECK_GOTO(ret, cleanup);
598
599 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200600 ret = ly_set_new(set);
601 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200602
603 /* transform into ly_set */
604 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100605 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200606 (*set)->size = xp_set.used;
607
608 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100609 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 +0200610 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200611 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200612 }
613 }
614
615cleanup:
616 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100617 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200618 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200619 ly_set_free(*set, NULL);
620 *set = NULL;
621 }
Michal Vasko072de482020-08-05 13:27:21 +0200622 return ret;
623}
624
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100625LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100626lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
627{
628 LY_ERR ret = LY_SUCCESS;
629 LY_ARRAY_COUNT_TYPE u, v;
630
631 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
632
633 /* allocate return set */
634 LY_CHECK_RET(ly_set_new(set));
635
636 LY_ARRAY_FOR(path, u) {
637 /* add nodes from the path */
638 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
639 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
640 LY_ARRAY_FOR(path[u].predicates, v) {
641 /* add all the keys in a predicate */
642 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
643 }
644 }
645 }
646
647cleanup:
648 if (ret) {
649 ly_set_free(*set, NULL);
650 *set = NULL;
651 }
652 return ret;
653}
654
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100655LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100656lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
657 struct ly_set **set)
658{
659 LY_ERR ret = LY_SUCCESS;
660 uint8_t oper;
661 struct lyxp_expr *expr = NULL;
662 struct ly_path *p = NULL;
663
664 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100665 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100666
667 if (!ctx) {
668 ctx = ctx_node->module->ctx;
669 }
670
671 /* parse */
672 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
673 LY_CHECK_GOTO(ret, cleanup);
674
675 /* compile */
676 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200677 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 +0100678 LY_CHECK_GOTO(ret, cleanup);
679
680 /* resolve */
681 ret = lys_find_lypath_atoms(p, set);
682
683cleanup:
684 ly_path_free(ctx, p);
685 lyxp_expr_free(ctx, expr);
686 return ret;
687}
688
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100689LIBYANG_API_DEF const struct lysc_node *
Radek Krejcibc5644c2020-10-27 14:53:17 +0100690lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
691{
692 const struct lysc_node *snode = NULL;
693 struct lyxp_expr *exp = NULL;
694 struct ly_path *p = NULL;
695 LY_ERR ret;
696 uint8_t oper;
697
698 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100699 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, NULL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100700
701 if (!ctx) {
702 ctx = ctx_node->module->ctx;
703 }
704
705 /* parse */
706 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
707 LY_CHECK_GOTO(ret, cleanup);
708
709 /* compile */
710 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200711 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 +0100712 LY_CHECK_GOTO(ret, cleanup);
713
714 /* get last node */
715 snode = p[LY_ARRAY_COUNT(p) - 1].node;
716
717cleanup:
718 ly_path_free(ctx, p);
719 lyxp_expr_free(ctx, exp);
720 return snode;
721}
722
Michal Vasko14654712020-02-06 08:35:21 +0100723char *
724lysc_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 +0200725 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200726{
Michal Vasko87dd1342021-08-23 16:17:55 +0200727 const struct lysc_node *iter, *par;
Radek Krejci327de162019-06-14 12:52:07 +0200728 char *path = NULL;
729 int len = 0;
730
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200731 if (buffer) {
732 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100733 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200734 }
735
Radek Krejci327de162019-06-14 12:52:07 +0200736 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200737 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200738 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100739 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200740 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100741 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200742
Michal Vasko721b6f62021-02-08 08:52:53 +0100743 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200744 /* schema-only node */
745 continue;
746 }
747
Michal Vasko11deea12020-08-05 13:54:50 +0200748 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200749 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100750 if (parent && (iter->parent == parent)) {
751 slash = "";
752 } else {
753 slash = "/";
754 }
Michal Vasko87dd1342021-08-23 16:17:55 +0200755
756 if (pathtype == LYSC_PATH_DATA) {
757 par = lysc_data_parent(iter);
758 } else {
759 par = iter->parent;
760 }
761
762 if (!par || (par->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200763 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200764 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100765 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200766 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100767 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200768 }
Radek Krejci327de162019-06-14 12:52:07 +0200769 } else {
770 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200771 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100772 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200773 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100774 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200775 }
Radek Krejci327de162019-06-14 12:52:07 +0200776 }
777 free(s);
778 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200779
Michal Vasko69730152020-10-09 16:30:07 +0200780 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200781 /* not enough space in buffer */
782 break;
783 }
Radek Krejci327de162019-06-14 12:52:07 +0200784 }
785
786 if (len < 0) {
787 free(path);
788 path = NULL;
789 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200790 if (buffer) {
791 strcpy(buffer, "/");
792 } else {
793 path = strdup("/");
794 }
Radek Krejci327de162019-06-14 12:52:07 +0200795 }
796 break;
797 }
798
Radek Krejci1c0c3442019-07-23 16:08:47 +0200799 if (buffer) {
800 return buffer;
801 } else {
802 return path;
803 }
Radek Krejci327de162019-06-14 12:52:07 +0200804}
805
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100806LIBYANG_API_DEF char *
Michal Vasko14654712020-02-06 08:35:21 +0100807lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
808{
809 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
810}
811
Michal Vasko405cc9e2020-12-01 12:01:27 +0100812LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200813_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100814{
815 LY_ERR ret = LY_SUCCESS, r;
aPiecek6b3d5422021-07-30 15:55:43 +0200816 struct lys_module *mod_iter;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200817 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vasko65333882021-06-10 14:12:16 +0200818 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100819
Michal Vasko405cc9e2020-12-01 12:01:27 +0100820 if (mod->implemented) {
821 /* mod is already implemented, set the features */
822 r = lys_set_features(mod->parsed, features);
823 if (r == LY_EEXIST) {
824 /* no changes */
825 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200826 } else if (!r) {
827 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200828 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200829 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200830
831 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200832 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100833
Michal Vasko7213ac52021-06-15 11:52:13 +0200834 /* implement, ignore recompilation because it must always take place later */
835 r = lys_implement(mod, features, unres);
836 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200837
838 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
839 /* implement all the imports as well */
840 for (i = 0; i < unres->creating.count; ++i) {
841 mod = unres->creating.objs[i];
842 if (mod->implemented) {
843 continue;
844 }
845
Michal Vaskoc56d6372021-10-19 12:29:00 +0200846 imp_f = (mod->ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
847 r = lys_implement(mod, imp_f, unres);
Michal Vasko7213ac52021-06-15 11:52:13 +0200848 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200849 }
850 }
851
aPiecek6b3d5422021-07-30 15:55:43 +0200852 /* Try to find module with LYS_MOD_IMPORTED_REV flag. */
853 i = 0;
854 while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) {
Michal Vaskoe8b085b2021-09-02 08:20:08 +0200855 if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) {
856 LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing"
857 " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision,
858 mod_iter->revision);
aPiecek6b3d5422021-07-30 15:55:43 +0200859 break;
860 }
861 }
862
Michal Vasko65333882021-06-10 14:12:16 +0200863cleanup:
864 return ret;
865}
866
Michal Vaskof4258e12021-06-15 12:11:42 +0200867/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200868 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
869 * and if so, add it into its dep set.
870 *
871 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
872 * in the dep set are (re)compiled.
873 *
874 * The reason for recompilation is possible disabled nodes and updating
875 * leafref targets to point to the newly compiled modules. Using the import relation, the
876 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
877 * during the target module compilation.
878 *
879 * - every module must belong to exactly one dep set
880 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200881 *
882 * @param[in] mod Module to process.
883 * @param[in,out] ctx_set Set with all not-yet-processed modules.
884 * @param[in,out] dep_set Current dependency set to update.
Michal Vasko775fbd02021-07-28 08:25:29 +0200885 * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call.
Michal Vaskof4258e12021-06-15 12:11:42 +0200886 * @return LY_ERR value.
887 */
888static LY_ERR
Michal Vasko775fbd02021-07-28 08:25:29 +0200889lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set,
890 struct ly_set *aux_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200891{
892 struct lys_module *mod2;
893 struct lysp_import *imports;
894 uint32_t i;
895 LY_ARRAY_COUNT_TYPE u, v;
896 ly_bool found;
897
Michal Vaskof8b1b0d2021-11-22 09:59:57 +0100898 if (LYS_IS_SINGLE_DEP_SET(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200899 /* is already in a separate dep set */
Michal Vaskof8b1b0d2021-11-22 09:59:57 +0100900 if (!lys_has_groupings(mod) && !mod->parsed->features) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200901 /* break the dep set here, no modules depend on this one */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200902 return LY_SUCCESS;
903 }
Michal Vasko775fbd02021-07-28 08:25:29 +0200904
905 if (ly_set_contains(aux_set, mod, NULL)) {
906 /* it was traversed */
907 return LY_SUCCESS;
908 }
909
910 /* add a new auxiliary module */
911 LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL));
Michal Vasko7ee5be22021-06-16 17:03:34 +0200912 } else {
Michal Vasko709f9a52021-07-21 10:51:59 +0200913 if (!ly_set_contains(ctx_set, mod, &i)) {
914 /* it was already processed */
915 return LY_SUCCESS;
916 }
917
918 /* remove it from the set, we are processing it now */
919 ly_set_rm_index(ctx_set, i, NULL);
920
Michal Vasko7ee5be22021-06-16 17:03:34 +0200921 /* add a new dependent module into the dep set */
922 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200923 }
924
925 /* process imports of the module and submodules */
926 imports = mod->parsed->imports;
927 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200928 mod2 = imports[u].module;
Michal Vasko775fbd02021-07-28 08:25:29 +0200929 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200930 }
931 LY_ARRAY_FOR(mod->parsed->includes, v) {
932 imports = mod->parsed->includes[v].submodule->imports;
933 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200934 mod2 = imports[u].module;
Michal Vaskof8b1b0d2021-11-22 09:59:57 +0100935 if (LYS_IS_SINGLE_DEP_SET(mod2)) {
936 if (!lys_has_groupings(mod2) && !mod2->parsed->features) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200937 /* break the dep set here, no modules depend on this one */
938 continue;
939 }
940 }
941
Michal Vasko775fbd02021-07-28 08:25:29 +0200942 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 +0200943 }
944 }
945
946 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200947 for (i = 0; i < mod->ctx->list.count; ++i) {
948 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200949 found = 0;
950
951 imports = mod2->parsed->imports;
952 LY_ARRAY_FOR(imports, u) {
953 if (imports[u].module == mod) {
954 found = 1;
955 break;
956 }
957 }
958
959 if (!found) {
960 LY_ARRAY_FOR(mod2->parsed->includes, v) {
961 imports = mod2->parsed->includes[v].submodule->imports;
962 LY_ARRAY_FOR(imports, u) {
963 if (imports[u].module == mod) {
964 found = 1;
965 break;
966 }
967 }
968
969 if (found) {
970 break;
971 }
972 }
973 }
974
975 if (found) {
Michal Vasko775fbd02021-07-28 08:25:29 +0200976 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200977 }
978 }
979
980 return LY_SUCCESS;
981}
982
Michal Vasko709f9a52021-07-21 10:51:59 +0200983/**
984 * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets.
985 *
986 * @param[in,out] ctx_set Set with all not-yet-processed modules.
987 * @param[in,out] main_set Set of dependency module sets.
988 * @return LY_ERR value.
989 */
990static LY_ERR
991lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set)
992{
993 LY_ERR ret = LY_SUCCESS;
994 struct lys_module *m;
995 uint32_t i = 0;
996 struct ly_set *dep_set = NULL;
997
998 while (i < ctx_set->count) {
999 m = ctx_set->objs[i];
Michal Vaskof8b1b0d2021-11-22 09:59:57 +01001000 if (LYS_IS_SINGLE_DEP_SET(m)) {
Michal Vasko709f9a52021-07-21 10:51:59 +02001001 /* remove it from the set, we are processing it now */
1002 ly_set_rm_index(ctx_set, i, NULL);
1003
1004 /* this module can be in a separate dep set (but there still may be modules importing this one
1005 * that depend on imports of this one in case it defines groupings) */
1006 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1007 LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup);
1008 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
1009 dep_set = NULL;
1010 } else {
1011 ++i;
1012 }
1013 }
1014
1015cleanup:
1016 ly_set_free(dep_set, NULL);
1017 return ret;
1018}
1019
Michal Vaskof4258e12021-06-15 12:11:42 +02001020LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +02001021lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +02001022{
1023 LY_ERR ret = LY_SUCCESS;
1024 struct lys_module *m;
Michal Vasko775fbd02021-07-28 08:25:29 +02001025 struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0};
Michal Vaskof4258e12021-06-15 12:11:42 +02001026 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +02001027 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +02001028
Michal Vasko22b26222021-07-30 11:16:47 +02001029 assert(!main_set->count);
1030
Michal Vaskof4258e12021-06-15 12:11:42 +02001031 /* start with a duplicate set of modules that we will remove from */
1032 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
1033
Michal Vasko709f9a52021-07-21 10:51:59 +02001034 /* first create all dep sets with single modules */
1035 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup);
1036
1037 if (mod && !ly_set_contains(ctx_set, mod, NULL)) {
1038 /* dep set for this module has already been created, nothing else to do */
1039 goto cleanup;
1040 }
1041
Michal Vaskof4258e12021-06-15 12:11:42 +02001042 while (ctx_set->count) {
1043 /* create new dep set */
1044 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1045
1046 if (mod) {
1047 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001048 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 +02001049 } else {
1050 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001051 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 +02001052 }
Michal Vasko775fbd02021-07-28 08:25:29 +02001053 ly_set_erase(&aux_set, NULL);
Michal Vasko7ee5be22021-06-16 17:03:34 +02001054 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001055
1056 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001057 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001058 for (i = 0; i < dep_set->count; ++i) {
1059 m = dep_set->objs[i];
1060 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001061 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +02001062 break;
1063 }
1064 }
1065
Michal Vasko7ee5be22021-06-16 17:03:34 +02001066 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001067 /* if there is, all the implemented modules need to be recompiled */
1068 for (i = 0; i < dep_set->count; ++i) {
1069 m = dep_set->objs[i];
1070 if (m->implemented) {
1071 m->to_compile = 1;
1072 }
1073 }
1074 }
1075
Michal Vasko7ee5be22021-06-16 17:03:34 +02001076 /* add the dep set into main set */
1077 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001078 dep_set = NULL;
1079
1080 if (mod) {
1081 /* we need dep set only for this module */
1082 break;
1083 }
1084 }
1085
Michal Vaskoe558f792021-07-28 08:20:15 +02001086#ifndef NDEBUG
1087 LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count);
1088 for (i = 0; i < main_set->count; ++i) {
1089 struct ly_set *iter_set = main_set->objs[i];
1090
1091 LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i);
1092 for (uint32_t j = 0; j < iter_set->count; ++j) {
1093 m = iter_set->objs[j];
1094 LOGDBG(LY_LDGDEPSETS, "\t%s", m->name);
1095 }
1096 }
1097#endif
1098
Michal Vaskof4258e12021-06-15 12:11:42 +02001099cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +02001100 assert(ret || main_set->objs);
Michal Vasko775fbd02021-07-28 08:25:29 +02001101 ly_set_erase(&aux_set, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001102 ly_set_free(dep_set, NULL);
1103 ly_set_free(ctx_set, NULL);
1104 return ret;
1105}
1106
1107void
1108lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1109{
1110 uint32_t i, j, idx, prev_lo;
1111 struct ly_set *dep_set;
1112 struct lys_module *m;
1113 LY_ERR ret;
1114
1115 for (i = 0; i < unres->implementing.count; ++i) {
1116 m = unres->implementing.objs[i];
1117 assert(m->implemented);
1118
1119 /* make the module correctly non-implemented again */
1120 m->implemented = 0;
1121 lys_precompile_augments_deviations_revert(ctx, m);
1122 lysc_module_free(m->compiled);
1123 m->compiled = NULL;
1124
1125 /* should not be made implemented */
1126 m->to_compile = 0;
1127 }
1128
1129 for (i = 0; i < unres->creating.count; ++i) {
1130 m = unres->creating.objs[i];
1131
Michal Vaskod297f2a2021-06-16 11:51:28 +02001132 /* remove the module from the context */
Michal Vaskof4258e12021-06-15 12:11:42 +02001133 ly_set_rm(&ctx->list, m, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001134
Michal Vasko22b26222021-07-30 11:16:47 +02001135 /* remove it also from dep sets */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001136 for (j = 0; j < unres->dep_sets.count; ++j) {
1137 dep_set = unres->dep_sets.objs[j];
1138 if (ly_set_contains(dep_set, m, &idx)) {
1139 ly_set_rm_index(dep_set, idx, NULL);
1140 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001141 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001142 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001143
1144 /* free the module */
1145 lys_module_free(m);
Michal Vaskof4258e12021-06-15 12:11:42 +02001146 }
1147
1148 if (unres->implementing.count) {
1149 /* recompile previous context because some implemented modules are no longer implemented,
1150 * we can reuse the current to_compile flags */
1151 prev_lo = ly_log_options(0);
Michal Vasko22b26222021-07-30 11:16:47 +02001152 ret = lys_compile_depset_all(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001153 ly_log_options(prev_lo);
1154 if (ret) {
1155 LOGINT(ctx);
1156 }
1157 }
1158}
1159
1160void
1161lys_unres_glob_erase(struct lys_glob_unres *unres)
1162{
1163 uint32_t i;
1164
1165 for (i = 0; i < unres->dep_sets.count; ++i) {
1166 ly_set_free(unres->dep_sets.objs[i], NULL);
1167 }
1168 ly_set_erase(&unres->dep_sets, NULL);
1169 ly_set_erase(&unres->implementing, NULL);
1170 ly_set_erase(&unres->creating, NULL);
1171
Michal Vaskoc130e162021-10-19 11:30:00 +02001172 assert(!unres->ds_unres.whens.count);
1173 assert(!unres->ds_unres.musts.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001174 assert(!unres->ds_unres.leafrefs.count);
aPiecekc6526b42021-07-12 15:21:39 +02001175 assert(!unres->ds_unres.disabled_leafrefs.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001176 assert(!unres->ds_unres.dflts.count);
1177 assert(!unres->ds_unres.disabled.count);
1178}
1179
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001180LIBYANG_API_DEF LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +02001181lys_set_implemented(struct lys_module *mod, const char **features)
1182{
1183 LY_ERR ret = LY_SUCCESS;
Michal Vasko22b26222021-07-30 11:16:47 +02001184 struct lys_glob_unres *unres = &mod->ctx->unres;
Michal Vasko65333882021-06-10 14:12:16 +02001185
1186 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1187
1188 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001189 ret = _lys_set_implemented(mod, features, unres);
Michal Vasko65333882021-06-10 14:12:16 +02001190 LY_CHECK_GOTO(ret, cleanup);
1191
Michal Vaskof4258e12021-06-15 12:11:42 +02001192 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1193 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001194 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001195
Michal Vasko709f9a52021-07-21 10:51:59 +02001196 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001197 LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup);
1198
1199 /* unres resolved */
1200 lys_unres_glob_erase(unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001201 }
1202
Michal Vasko65333882021-06-10 14:12:16 +02001203cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001204 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001205 lys_unres_glob_revert(mod->ctx, unres);
1206 lys_unres_glob_erase(unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001207 }
Michal Vasko89b5c072020-10-06 13:52:44 +02001208 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001209}
1210
Michal Vasko7c8439f2020-08-05 13:25:19 +02001211static LY_ERR
aPiecekc3e26142021-06-22 14:25:49 +02001212lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001213{
1214 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001215 LY_ARRAY_COUNT_TYPE u, v;
1216
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001217 pmod->parsing = 1;
1218 LY_ARRAY_FOR(pmod->imports, u) {
1219 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001220 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001221 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 +02001222
1223 if (!imp->rev[0]) {
1224 /* This module must be selected for the next similar
1225 * import without revision-date to avoid incorrect
1226 * derived identities in the ::lys_module.identities.
1227 */
1228 imp->module->latest_revision |= LYS_MOD_IMPORTED_REV;
1229 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001230 }
1231 /* check for importing the same module twice */
1232 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001233 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001234 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1235 }
1236 }
1237 }
aPiecekc3e26142021-06-22 14:25:49 +02001238 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001239
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001240 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001241
1242 return LY_SUCCESS;
1243}
1244
Michal Vasko3a41dff2020-07-15 14:30:28 +02001245LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001246lys_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 +02001247 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001248 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001249{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001250 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001251 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +01001252 struct lys_yang_parser_ctx *yangctx = NULL;
1253 struct lys_yin_parser_ctx *yinctx = NULL;
1254 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001255
Michal Vasko3a41dff2020-07-15 14:30:28 +02001256 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001257
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001258 switch (format) {
1259 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001260 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001261 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001262 break;
1263 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001264 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001265 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001266 break;
1267 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001268 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001269 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001270 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001271 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001272 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001273 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001274
1275 /* make sure that the newest revision is at position 0 */
1276 lysp_sort_revisions(submod->revs);
1277
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001278 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001279 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001280 if (latest_sp) {
1281 if (submod->revs) {
1282 if (!latest_sp->revs) {
1283 /* latest has no revision, so mod is anyway newer */
1284 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001285 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1286 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1287 submod->latest_revision = latest_sp->latest_revision;
1288 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001289 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001290 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001291 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001292 } else {
1293 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001294 }
1295 } else {
1296 submod->latest_revision = 1;
1297 }
1298
Radek Krejcib3289d62019-09-18 12:21:39 +02001299 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001300 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001301 }
1302
1303 if (latest_sp) {
1304 latest_sp->latest_revision = 0;
1305 }
1306
Michal Vasko7a0b0762020-09-02 16:37:01 +02001307 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1308
Michal Vasko7c8439f2020-08-05 13:25:19 +02001309 /* resolve imports and includes */
aPiecekc3e26142021-06-22 14:25:49 +02001310 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001311
David Sedlák1b623122019-08-05 15:27:49 +02001312 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001313 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001314 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001315 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001316 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001317 *submodule = submod;
1318 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001319
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001320error:
Radek Krejcic64661b2020-08-15 15:42:26 +02001321 if (!submod || !submod->name) {
1322 LOGERR(ctx, ret, "Parsing submodule failed.");
1323 } else {
1324 LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name);
1325 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001326 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001327 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001328 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001329 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001330 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001331 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001332 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001333}
1334
Michal Vasko45b521c2020-11-04 17:14:39 +01001335/**
1336 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1337 *
1338 * @param[in] mod Parsed module to add to.
1339 * @return LY_SUCCESS on success.
1340 * @return LY_ERR on error.
1341 */
1342static LY_ERR
1343lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
1344{
1345 struct lysp_ext_instance *ext_p;
1346 struct lysp_stmt *stmt;
1347 struct lysp_import *imp;
1348
1349 /*
1350 * 1) edit-config's operation
1351 */
1352 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1353 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1354 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1355 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001356 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001357 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001358 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001359 ext_p->parent_stmt = LY_STMT_MODULE;
1360 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001361
1362 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1363 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1364 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1365 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001366 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001367 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001368 stmt->kw = LY_STMT_TYPE;
1369
1370 stmt->child = calloc(1, sizeof *stmt->child);
1371 stmt = stmt->child;
1372 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1373 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1374 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001375 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001376 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001377 stmt->kw = LY_STMT_ENUM;
1378
1379 stmt->next = calloc(1, sizeof *stmt->child);
1380 stmt = stmt->next;
1381 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1382 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1383 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001384 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001385 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001386 stmt->kw = LY_STMT_ENUM;
1387
1388 stmt->next = calloc(1, sizeof *stmt->child);
1389 stmt = stmt->next;
1390 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1391 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1392 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001393 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001394 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001395 stmt->kw = LY_STMT_ENUM;
1396
1397 stmt->next = calloc(1, sizeof *stmt->child);
1398 stmt = stmt->next;
1399 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1400 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1401 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001402 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001403 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001404 stmt->kw = LY_STMT_ENUM;
1405
1406 stmt->next = calloc(1, sizeof *stmt->child);
1407 stmt = stmt->next;
1408 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1409 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1410 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001411 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001412 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001413 stmt->kw = LY_STMT_ENUM;
1414
1415 /*
1416 * 2) filter's type
1417 */
1418 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1419 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1420 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1421 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001422 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001423 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001424 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001425 ext_p->parent_stmt = LY_STMT_MODULE;
1426 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001427
1428 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1429 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1430 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1431 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001432 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001433 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001434 stmt->kw = LY_STMT_TYPE;
1435
1436 stmt->child = calloc(1, sizeof *stmt->child);
1437 stmt = stmt->child;
1438 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1439 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1440 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001441 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001442 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001443 stmt->kw = LY_STMT_ENUM;
1444
1445 stmt->next = calloc(1, sizeof *stmt->child);
1446 stmt = stmt->next;
1447 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1448 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1449 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001450 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001451 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001452 stmt->kw = LY_STMT_ENUM;
1453
1454 /* if-feature for enum allowed only for YANG 1.1 modules */
1455 if (mod->version >= LYS_VERSION_1_1) {
1456 stmt->child = calloc(1, sizeof *stmt->child);
1457 stmt = stmt->child;
1458 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1459 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1460 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001461 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001462 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001463 stmt->kw = LY_STMT_IF_FEATURE;
1464 }
1465
1466 /*
1467 * 3) filter's select
1468 */
1469 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1470 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1471 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1472 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001473 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001474 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001475 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001476 ext_p->parent_stmt = LY_STMT_MODULE;
1477 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001478
1479 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1480 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1481 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1482 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001483 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001484 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001485 stmt->kw = LY_STMT_TYPE;
1486
1487 /* create new imports for the used prefixes */
1488 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1489
1490 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1491 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1492 imp->flags = LYS_INTERNAL;
1493
1494 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1495
1496 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1497 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1498 imp->flags = LYS_INTERNAL;
1499
1500 return LY_SUCCESS;
1501}
1502
1503/**
1504 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1505 *
1506 * @param[in] mod Parsed module to add to.
1507 * @return LY_SUCCESS on success.
1508 * @return LY_ERR on error.
1509 */
1510static LY_ERR
1511lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1512{
1513 struct lysp_ext_instance *ext_p;
1514 struct lysp_stmt *stmt;
1515 struct lysp_import *imp;
1516
1517 /* add new extension instance */
1518 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1519
1520 /* fill in the extension instance fields */
1521 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1522 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1523 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001524 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001525 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001526 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001527 ext_p->parent_stmt = LY_STMT_MODULE;
1528 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001529
1530 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1531 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1532 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1533 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001534 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001535 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001536 stmt->kw = LY_STMT_TYPE;
1537
1538 /* create new import for the used prefix */
1539 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1540
1541 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1542 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1543 imp->flags = LYS_INTERNAL;
1544
1545 return LY_SUCCESS;
1546}
1547
Michal Vasko3a41dff2020-07-15 14:30:28 +02001548LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001549lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001550 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 +02001551 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001552{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001553 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001554 LY_ERR ret;
Michal Vaskob36053d2020-03-26 15:49:30 +01001555 struct lys_yang_parser_ctx *yangctx = NULL;
1556 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001557 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001558 char *filename, *rev, *dot;
1559 size_t len;
Radek Krejcic64661b2020-08-15 15:42:26 +02001560 ly_bool module_created = 0;
Radek Krejci86d106e2018-10-18 09:53:19 +02001561
Michal Vaskodd992582021-06-10 14:34:57 +02001562 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001563
Michal Vasko7a0b0762020-09-02 16:37:01 +02001564 if (module) {
1565 *module = NULL;
1566 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001567
1568 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001569 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001570 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001571
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001572 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001573 switch (format) {
1574 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001575 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001576 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001577 break;
1578 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001579 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001580 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001581 break;
1582 default:
1583 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001584 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001585 break;
1586 }
Radek Krejcic64661b2020-08-15 15:42:26 +02001587 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001588
1589 /* make sure that the newest revision is at position 0 */
1590 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001591 if (mod->parsed->revs) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001592 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001593 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001594
Radek Krejcib3289d62019-09-18 12:21:39 +02001595 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001596 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001597 if (latest) {
1598 if (mod->revision) {
1599 if (!latest->revision) {
1600 /* latest has no revision, so mod is anyway newer */
aPiecek8ca21bd2021-07-26 14:31:01 +02001601 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001602 /* the latest is zeroed later when the new module is being inserted into the context */
1603 } else if (strcmp(mod->revision, latest->revision) > 0) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001604 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001605 /* the latest is zeroed later when the new module is being inserted into the context */
1606 } else {
1607 latest = NULL;
1608 }
1609 } else {
1610 latest = NULL;
1611 }
1612 } else {
aPiecek8ca21bd2021-07-26 14:31:01 +02001613 mod->latest_revision = LYS_MOD_LATEST_REV;
Radek Krejcib3289d62019-09-18 12:21:39 +02001614 }
1615
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001616 if (custom_check) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001617 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001618 }
1619
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001620 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001621 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001622 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001623 /* nothing to do */
1624 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1625 mod_dup->revision ? mod_dup->revision : "<none>");
Radek Krejcic64661b2020-08-15 15:42:26 +02001626 goto cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001627 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001628
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001629 switch (in->type) {
1630 case LY_IN_FILEPATH:
1631 /* check that name and revision match filename */
1632 filename = strrchr(in->method.fpath.filepath, '/');
1633 if (!filename) {
1634 filename = in->method.fpath.filepath;
1635 } else {
1636 filename++;
1637 }
1638 rev = strchr(filename, '@');
1639 dot = strrchr(filename, '.');
1640
1641 /* name */
1642 len = strlen(mod->name);
1643 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001644 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001645 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1646 }
1647 if (rev) {
1648 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001649 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001650 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001651 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001652 }
1653 }
1654
1655 break;
1656 case LY_IN_FD:
1657 case LY_IN_FILE:
1658 case LY_IN_MEMORY:
1659 /* nothing special to do */
1660 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001661 case LY_IN_ERROR:
1662 LOGINT(ctx);
1663 ret = LY_EINT;
Radek Krejcic64661b2020-08-15 15:42:26 +02001664 goto cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001665 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001666 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001667
Michal Vasko7a0b0762020-09-02 16:37:01 +02001668 if (latest) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001669 latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001670 }
1671
Michal Vasko45b521c2020-11-04 17:14:39 +01001672 /* add internal data in case specific modules were parsed */
1673 if (!strcmp(mod->name, "ietf-netconf")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001674 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001675 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001676 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001677 }
1678
Michal Vasko405cc9e2020-12-01 12:01:27 +01001679 /* add the module into newly created module set, will also be freed from there on any error */
Radek Krejcic64661b2020-08-15 15:42:26 +02001680 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup);
1681 module_created = 1;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001682
Michal Vasko7a0b0762020-09-02 16:37:01 +02001683 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001684 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001685 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001686 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001687
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001688 /* resolve includes and all imports */
aPiecekc3e26142021-06-22 14:25:49 +02001689 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001690
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001691 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001692 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001693 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001694 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1695 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001696
1697 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001698 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001699
aPiecek6b3d5422021-07-30 15:55:43 +02001700 /* compile identities */
1701 LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001702
Michal Vasko405cc9e2020-12-01 12:01:27 +01001703 /* success */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001704
Radek Krejcic64661b2020-08-15 15:42:26 +02001705cleanup:
Michal Vaskobe04af42021-07-16 10:48:43 +02001706 if (ret && (ret != LY_EEXIST)) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001707 if (mod && mod->name) {
1708 /* there are cases when path is not available for parsing error, so this additional
1709 * message tries to add information about the module where the error occurred */
1710 struct ly_err_item *e = ly_err_last(ctx);
1711 if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) {
1712 LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name);
1713 }
1714 }
1715 }
1716 if (!module_created) {
1717 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001718 mod = mod_dup;
1719 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001720
Michal Vasko7a0b0762020-09-02 16:37:01 +02001721 if (format == LYS_IN_YANG) {
1722 yang_parser_ctx_free(yangctx);
1723 } else {
1724 yin_parser_ctx_free(yinctx);
1725 }
1726
Michal Vasko405cc9e2020-12-01 12:01:27 +01001727 if (!ret && module) {
1728 *module = mod;
1729 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001730 return ret;
1731}
1732
Radek Krejci545b4872020-11-15 10:15:12 +01001733static LYS_INFORMAT
1734lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1735{
1736 if (!format && (in->type == LY_IN_FILEPATH)) {
1737 /* unknown format - try to detect it from filename's suffix */
1738 const char *path = in->method.fpath.filepath;
1739 size_t len = strlen(path);
1740
1741 /* ignore trailing whitespaces */
1742 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1743
Radek Krejcif13b87b2020-12-01 22:02:17 +01001744 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1745 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001746 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001747 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1748 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001749 format = LYS_IN_YIN;
1750 } /* else still unknown */
1751 }
1752
1753 return format;
1754}
1755
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001756LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001757lys_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 +02001758{
Michal Vasko65333882021-06-10 14:12:16 +02001759 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001760 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001761
Michal Vasko7a0b0762020-09-02 16:37:01 +02001762 if (module) {
1763 *module = NULL;
1764 }
Radek Krejci545b4872020-11-15 10:15:12 +01001765 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1766
1767 format = lys_parse_get_format(in, format);
1768 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001769
1770 /* remember input position */
1771 in->func_start = in->current;
1772
Michal Vasko4e205e82021-06-08 14:01:47 +02001773 /* parse */
Michal Vasko22b26222021-07-30 11:16:47 +02001774 ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001775 LY_CHECK_GOTO(ret, cleanup);
1776
1777 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001778 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001779 LY_CHECK_GOTO(ret, cleanup);
1780
Michal Vaskof4258e12021-06-15 12:11:42 +02001781 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1782 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001783 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001784
Michal Vasko709f9a52021-07-21 10:51:59 +02001785 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001786 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
1787
1788 /* unres resolved */
1789 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001790 }
1791
Michal Vasko405cc9e2020-12-01 12:01:27 +01001792cleanup:
1793 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001794 lys_unres_glob_revert(ctx, &ctx->unres);
1795 lys_unres_glob_erase(&ctx->unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001796 } else if (module) {
1797 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001798 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001799 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001800}
1801
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001802LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001803lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001804{
Radek Krejci0f969882020-08-21 16:56:47 +02001805 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001806 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001807
Michal Vasko3a41dff2020-07-15 14:30:28 +02001808 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001809
Michal Vasko3a41dff2020-07-15 14:30:28 +02001810 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 +02001811
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001812 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001813 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001814
Michal Vasko3a41dff2020-07-15 14:30:28 +02001815 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001816}
1817
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001818LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001819lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001820{
Radek Krejci0f969882020-08-21 16:56:47 +02001821 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001822 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001823
Michal Vasko3a41dff2020-07-15 14:30:28 +02001824 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001825
Michal Vasko3a41dff2020-07-15 14:30:28 +02001826 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 +02001827
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001828 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001829 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001830
Michal Vasko3a41dff2020-07-15 14:30:28 +02001831 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001832}
1833
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001834LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001835lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001836{
Radek Krejci0f969882020-08-21 16:56:47 +02001837 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001838 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001839
Michal Vasko3a41dff2020-07-15 14:30:28 +02001840 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001841
Michal Vasko3a41dff2020-07-15 14:30:28 +02001842 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001843 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001844
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001845 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001846 ly_in_free(in, 0);
1847
Michal Vasko3a41dff2020-07-15 14:30:28 +02001848 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001849}
1850
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001851LIBYANG_API_DEF LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001852lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001853 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001854{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001855 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001856 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001857 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001858 char *wd, *wn = NULL;
1859 DIR *dir = NULL;
1860 struct dirent *file;
1861 char *match_name = NULL;
1862 LYS_INFORMAT format_aux, match_format = 0;
1863 struct ly_set *dirs;
1864 struct stat st;
1865
1866 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1867
1868 /* start to fill the dir fifo with the context's search path (if set)
1869 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001870 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001871
1872 len = strlen(name);
1873 if (cwd) {
1874 wd = get_current_dir_name();
1875 if (!wd) {
1876 LOGMEM(NULL);
1877 goto cleanup;
1878 } else {
1879 /* add implicit current working directory (./) to be searched,
1880 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001881 ret = ly_set_add(dirs, wd, 0, NULL);
1882 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001883 implicit_cwd = 1;
1884 }
1885 }
1886 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001887 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001888 /* check for duplicities with the implicit current working directory */
1889 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1890 implicit_cwd = 0;
1891 continue;
1892 }
1893 wd = strdup(searchpaths[i]);
1894 if (!wd) {
1895 LOGMEM(NULL);
1896 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001897 } else {
1898 ret = ly_set_add(dirs, wd, 0, NULL);
1899 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001900 }
1901 }
1902 }
1903 wd = NULL;
1904
1905 /* start searching */
1906 while (dirs->count) {
1907 free(wd);
1908 free(wn); wn = NULL;
1909
1910 dirs->count--;
1911 wd = (char *)dirs->objs[dirs->count];
1912 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001913 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001914
1915 if (dir) {
1916 closedir(dir);
1917 }
1918 dir = opendir(wd);
1919 dir_len = strlen(wd);
1920 if (!dir) {
1921 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1922 } else {
1923 while ((file = readdir(dir))) {
1924 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1925 /* skip . and .. */
1926 continue;
1927 }
1928 free(wn);
1929 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1930 LOGMEM(NULL);
1931 goto cleanup;
1932 }
1933 if (stat(wn, &st) == -1) {
1934 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001935 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001936 continue;
1937 }
1938 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1939 /* we have another subdirectory in searchpath to explore,
1940 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001941 ret = ly_set_add(dirs, wn, 0, NULL);
1942 LY_CHECK_GOTO(ret, cleanup);
1943
Radek Krejcid33273d2018-10-25 14:55:52 +02001944 /* continue with the next item in current directory */
1945 wn = NULL;
1946 continue;
1947 } else if (!S_ISREG(st.st_mode)) {
1948 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1949 continue;
1950 }
1951
1952 /* here we know that the item is a file which can contain a module */
1953 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001954 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001955 /* different filename than the module we search for */
1956 continue;
1957 }
1958
1959 /* get type according to filename suffix */
1960 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001961 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1962 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001963 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001964 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1965 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001966 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001967 } else {
1968 /* not supportde suffix/file format */
1969 continue;
1970 }
1971
1972 if (revision) {
1973 /* we look for the specific revision, try to get it from the filename */
1974 if (file->d_name[len] == '@') {
1975 /* check revision from the filename */
1976 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1977 /* another revision */
1978 continue;
1979 } else {
1980 /* exact revision */
1981 free(match_name);
1982 match_name = wn;
1983 wn = NULL;
1984 match_len = dir_len + 1 + len;
1985 match_format = format_aux;
1986 goto success;
1987 }
1988 } else {
1989 /* continue trying to find exact revision match, use this only if not found */
1990 free(match_name);
1991 match_name = wn;
1992 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001993 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001994 match_format = format_aux;
1995 continue;
1996 }
1997 } else {
1998 /* remember the revision and try to find the newest one */
1999 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02002000 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01002001 lysp_check_date(NULL, &file->d_name[len + 1],
2002 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002003 continue;
Michal Vasko69730152020-10-09 16:30:07 +02002004 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02002005 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
2006 continue;
2007 }
2008 free(match_name);
2009 }
2010
2011 match_name = wn;
2012 wn = NULL;
2013 match_len = dir_len + 1 + len;
2014 match_format = format_aux;
2015 continue;
2016 }
2017 }
2018 }
2019 }
2020
2021success:
2022 (*localfile) = match_name;
2023 match_name = NULL;
2024 if (format) {
2025 (*format) = match_format;
2026 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002027 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02002028
2029cleanup:
2030 free(wn);
2031 free(wd);
2032 if (dir) {
2033 closedir(dir);
2034 }
2035 free(match_name);
2036 ly_set_free(dirs, free);
2037
2038 return ret;
2039}