blob: eec6e973baaa50f8eb82d78f817dd4cdf963818e [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 }
Michal Vaskoaac267d2022-01-17 13:34:48 +0100474
Radek Krejcia3045382018-11-22 14:30:31 +0100475 return NULL;
476}
477
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100478LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100479lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
480 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200481{
482 LY_ERR ret = LY_SUCCESS;
483 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200484 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200485 uint32_t i;
486
Michal Vasko26512682021-01-11 11:35:40 +0100487 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100488 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200489 if (!(options & LYXP_SCNODE_ALL)) {
Michal Vasko4ad69e72021-10-26 16:25:55 +0200490 options |= LYXP_SCNODE;
Michal Vasko519fd602020-05-26 12:17:39 +0200491 }
Michal Vasko26512682021-01-11 11:35:40 +0100492 if (!ctx) {
493 ctx = ctx_node->module->ctx;
494 }
Michal Vasko519fd602020-05-26 12:17:39 +0200495
496 memset(&xp_set, 0, sizeof xp_set);
497
498 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100499 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200500 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200501
502 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200503 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200504 LY_CHECK_GOTO(ret, cleanup);
505
506 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200507 ret = ly_set_new(set);
508 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200509
510 /* transform into ly_set */
511 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100512 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200513 (*set)->size = xp_set.used;
514
515 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200516 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200517 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200518 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200519 }
520 }
521
522cleanup:
523 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100524 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200525 return ret;
526}
527
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100528LIBYANG_API_DEF LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200529lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
530 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
531{
532 LY_ERR ret = LY_SUCCESS;
533 struct lyxp_set xp_set = {0};
534 uint32_t i;
535
536 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100537 LY_CHECK_CTX_EQUAL_RET(ctx_node ? ctx_node->module->ctx : NULL, cur_mod->ctx, LY_EINVAL);
Michal Vasko40308e72020-10-20 16:38:40 +0200538 if (!(options & LYXP_SCNODE_ALL)) {
539 options = LYXP_SCNODE;
540 }
541
542 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200543 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 +0200544 LY_CHECK_GOTO(ret, cleanup);
545
546 /* allocate return set */
547 ret = ly_set_new(set);
548 LY_CHECK_GOTO(ret, cleanup);
549
550 /* transform into ly_set */
551 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
552 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
553 (*set)->size = xp_set.used;
554
555 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200556 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
557 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
558 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100559 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200560 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
561 LY_CHECK_GOTO(ret, cleanup);
562 }
563 }
564
565cleanup:
566 lyxp_set_free_content(&xp_set);
567 if (ret) {
568 ly_set_free(*set, NULL);
569 *set = NULL;
570 }
571 return ret;
572}
573
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100574LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100575lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
576 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200577{
578 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200579 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200580 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200581 uint32_t i;
582
Michal Vasko26512682021-01-11 11:35:40 +0100583 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100584 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200585 if (!(options & LYXP_SCNODE_ALL)) {
586 options = LYXP_SCNODE;
587 }
Michal Vasko26512682021-01-11 11:35:40 +0100588 if (!ctx) {
589 ctx = ctx_node->module->ctx;
590 }
Michal Vasko072de482020-08-05 13:27:21 +0200591
Michal Vasko072de482020-08-05 13:27:21 +0200592 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100593 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200594 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200595
596 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200597 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200598 LY_CHECK_GOTO(ret, cleanup);
599
600 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200601 ret = ly_set_new(set);
602 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200603
604 /* transform into ly_set */
605 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100606 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200607 (*set)->size = xp_set.used;
608
609 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100610 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 +0200611 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200612 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200613 }
614 }
615
616cleanup:
617 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100618 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200619 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200620 ly_set_free(*set, NULL);
621 *set = NULL;
622 }
Michal Vasko072de482020-08-05 13:27:21 +0200623 return ret;
624}
625
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100626LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100627lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
628{
629 LY_ERR ret = LY_SUCCESS;
630 LY_ARRAY_COUNT_TYPE u, v;
631
632 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
633
634 /* allocate return set */
635 LY_CHECK_RET(ly_set_new(set));
636
637 LY_ARRAY_FOR(path, u) {
638 /* add nodes from the path */
639 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
640 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
641 LY_ARRAY_FOR(path[u].predicates, v) {
642 /* add all the keys in a predicate */
643 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
644 }
645 }
646 }
647
648cleanup:
649 if (ret) {
650 ly_set_free(*set, NULL);
651 *set = NULL;
652 }
653 return ret;
654}
655
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100656LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100657lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
658 struct ly_set **set)
659{
660 LY_ERR ret = LY_SUCCESS;
661 uint8_t oper;
662 struct lyxp_expr *expr = NULL;
663 struct ly_path *p = NULL;
664
665 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100666 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100667
668 if (!ctx) {
669 ctx = ctx_node->module->ctx;
670 }
671
672 /* parse */
673 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
674 LY_CHECK_GOTO(ret, cleanup);
675
676 /* compile */
677 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200678 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 +0100679 LY_CHECK_GOTO(ret, cleanup);
680
681 /* resolve */
682 ret = lys_find_lypath_atoms(p, set);
683
684cleanup:
685 ly_path_free(ctx, p);
686 lyxp_expr_free(ctx, expr);
687 return ret;
688}
689
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100690LIBYANG_API_DEF const struct lysc_node *
Radek Krejcibc5644c2020-10-27 14:53:17 +0100691lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
692{
693 const struct lysc_node *snode = NULL;
694 struct lyxp_expr *exp = NULL;
695 struct ly_path *p = NULL;
696 LY_ERR ret;
697 uint8_t oper;
698
699 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
Michal Vasko1d80a532021-11-24 10:41:05 +0100700 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, NULL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100701
702 if (!ctx) {
703 ctx = ctx_node->module->ctx;
704 }
705
706 /* parse */
707 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
708 LY_CHECK_GOTO(ret, cleanup);
709
710 /* compile */
711 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200712 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 +0100713 LY_CHECK_GOTO(ret, cleanup);
714
715 /* get last node */
716 snode = p[LY_ARRAY_COUNT(p) - 1].node;
717
718cleanup:
719 ly_path_free(ctx, p);
720 lyxp_expr_free(ctx, exp);
721 return snode;
722}
723
Michal Vasko14654712020-02-06 08:35:21 +0100724char *
725lysc_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 +0200726 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200727{
Michal Vasko87dd1342021-08-23 16:17:55 +0200728 const struct lysc_node *iter, *par;
Radek Krejci327de162019-06-14 12:52:07 +0200729 char *path = NULL;
730 int len = 0;
731
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200732 if (buffer) {
733 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100734 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200735 }
736
Radek Krejci327de162019-06-14 12:52:07 +0200737 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200738 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200739 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100740 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200741 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100742 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200743
Michal Vasko721b6f62021-02-08 08:52:53 +0100744 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200745 /* schema-only node */
746 continue;
747 }
748
Michal Vasko11deea12020-08-05 13:54:50 +0200749 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200750 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100751 if (parent && (iter->parent == parent)) {
752 slash = "";
753 } else {
754 slash = "/";
755 }
Michal Vasko87dd1342021-08-23 16:17:55 +0200756
757 if (pathtype == LYSC_PATH_DATA) {
758 par = lysc_data_parent(iter);
759 } else {
760 par = iter->parent;
761 }
762
763 if (!par || (par->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200764 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200765 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100766 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200767 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100768 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200769 }
Radek Krejci327de162019-06-14 12:52:07 +0200770 } else {
771 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200772 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100773 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200774 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100775 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200776 }
Radek Krejci327de162019-06-14 12:52:07 +0200777 }
778 free(s);
779 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200780
Michal Vasko69730152020-10-09 16:30:07 +0200781 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200782 /* not enough space in buffer */
783 break;
784 }
Radek Krejci327de162019-06-14 12:52:07 +0200785 }
786
787 if (len < 0) {
788 free(path);
789 path = NULL;
790 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200791 if (buffer) {
792 strcpy(buffer, "/");
793 } else {
794 path = strdup("/");
795 }
Radek Krejci327de162019-06-14 12:52:07 +0200796 }
797 break;
798 }
799
Radek Krejci1c0c3442019-07-23 16:08:47 +0200800 if (buffer) {
801 return buffer;
802 } else {
803 return path;
804 }
Radek Krejci327de162019-06-14 12:52:07 +0200805}
806
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100807LIBYANG_API_DEF char *
Michal Vasko14654712020-02-06 08:35:21 +0100808lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
809{
810 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
811}
812
Michal Vasko405cc9e2020-12-01 12:01:27 +0100813LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200814_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100815{
816 LY_ERR ret = LY_SUCCESS, r;
aPiecek6b3d5422021-07-30 15:55:43 +0200817 struct lys_module *mod_iter;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200818 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vasko65333882021-06-10 14:12:16 +0200819 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100820
Michal Vasko405cc9e2020-12-01 12:01:27 +0100821 if (mod->implemented) {
822 /* mod is already implemented, set the features */
823 r = lys_set_features(mod->parsed, features);
824 if (r == LY_EEXIST) {
825 /* no changes */
826 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200827 } else if (!r) {
828 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200829 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200830 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200831
832 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200833 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100834
Michal Vasko7213ac52021-06-15 11:52:13 +0200835 /* implement, ignore recompilation because it must always take place later */
836 r = lys_implement(mod, features, unres);
837 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200838
839 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
840 /* implement all the imports as well */
841 for (i = 0; i < unres->creating.count; ++i) {
842 mod = unres->creating.objs[i];
843 if (mod->implemented) {
844 continue;
845 }
846
Michal Vaskoc56d6372021-10-19 12:29:00 +0200847 imp_f = (mod->ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
848 r = lys_implement(mod, imp_f, unres);
Michal Vasko7213ac52021-06-15 11:52:13 +0200849 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200850 }
851 }
852
aPiecek6b3d5422021-07-30 15:55:43 +0200853 /* Try to find module with LYS_MOD_IMPORTED_REV flag. */
854 i = 0;
855 while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) {
Michal Vaskoe8b085b2021-09-02 08:20:08 +0200856 if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) {
857 LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing"
858 " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision,
859 mod_iter->revision);
aPiecek6b3d5422021-07-30 15:55:43 +0200860 break;
861 }
862 }
863
Michal Vasko65333882021-06-10 14:12:16 +0200864cleanup:
865 return ret;
866}
867
Michal Vaskof4258e12021-06-15 12:11:42 +0200868/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200869 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
870 * and if so, add it into its dep set.
871 *
872 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
873 * in the dep set are (re)compiled.
874 *
875 * The reason for recompilation is possible disabled nodes and updating
876 * leafref targets to point to the newly compiled modules. Using the import relation, the
877 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
878 * during the target module compilation.
879 *
880 * - every module must belong to exactly one dep set
881 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200882 *
883 * @param[in] mod Module to process.
884 * @param[in,out] ctx_set Set with all not-yet-processed modules.
885 * @param[in,out] dep_set Current dependency set to update.
Michal Vasko775fbd02021-07-28 08:25:29 +0200886 * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call.
Michal Vaskof4258e12021-06-15 12:11:42 +0200887 * @return LY_ERR value.
888 */
889static LY_ERR
Michal Vasko775fbd02021-07-28 08:25:29 +0200890lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set,
891 struct ly_set *aux_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200892{
893 struct lys_module *mod2;
894 struct lysp_import *imports;
895 uint32_t i;
896 LY_ARRAY_COUNT_TYPE u, v;
897 ly_bool found;
898
Michal Vaskof8b1b0d2021-11-22 09:59:57 +0100899 if (LYS_IS_SINGLE_DEP_SET(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200900 /* is already in a separate dep set */
Michal Vasko9e8d27f2022-02-22 14:13:45 +0100901 if (!lys_has_dep_mods(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200902 /* break the dep set here, no modules depend on this one */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200903 return LY_SUCCESS;
904 }
Michal Vasko775fbd02021-07-28 08:25:29 +0200905
906 if (ly_set_contains(aux_set, mod, NULL)) {
907 /* it was traversed */
908 return LY_SUCCESS;
909 }
910
911 /* add a new auxiliary module */
912 LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL));
Michal Vasko7ee5be22021-06-16 17:03:34 +0200913 } else {
Michal Vasko709f9a52021-07-21 10:51:59 +0200914 if (!ly_set_contains(ctx_set, mod, &i)) {
915 /* it was already processed */
916 return LY_SUCCESS;
917 }
918
919 /* remove it from the set, we are processing it now */
920 ly_set_rm_index(ctx_set, i, NULL);
921
Michal Vasko7ee5be22021-06-16 17:03:34 +0200922 /* add a new dependent module into the dep set */
923 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200924 }
925
926 /* process imports of the module and submodules */
927 imports = mod->parsed->imports;
928 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200929 mod2 = imports[u].module;
Michal Vasko775fbd02021-07-28 08:25:29 +0200930 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200931 }
932 LY_ARRAY_FOR(mod->parsed->includes, v) {
933 imports = mod->parsed->includes[v].submodule->imports;
934 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200935 mod2 = imports[u].module;
Michal Vasko9e8d27f2022-02-22 14:13:45 +0100936 if (LYS_IS_SINGLE_DEP_SET(mod2) && !lys_has_dep_mods(mod2)) {
937 /* break the dep set here, no modules depend on this one */
938 continue;
Michal Vasko709f9a52021-07-21 10:51:59 +0200939 }
940
Michal Vasko775fbd02021-07-28 08:25:29 +0200941 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 +0200942 }
943 }
944
945 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200946 for (i = 0; i < mod->ctx->list.count; ++i) {
947 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200948 found = 0;
949
950 imports = mod2->parsed->imports;
951 LY_ARRAY_FOR(imports, u) {
952 if (imports[u].module == mod) {
953 found = 1;
954 break;
955 }
956 }
957
958 if (!found) {
959 LY_ARRAY_FOR(mod2->parsed->includes, v) {
960 imports = mod2->parsed->includes[v].submodule->imports;
961 LY_ARRAY_FOR(imports, u) {
962 if (imports[u].module == mod) {
963 found = 1;
964 break;
965 }
966 }
967
968 if (found) {
969 break;
970 }
971 }
972 }
973
974 if (found) {
Michal Vasko775fbd02021-07-28 08:25:29 +0200975 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200976 }
977 }
978
979 return LY_SUCCESS;
980}
981
Michal Vasko709f9a52021-07-21 10:51:59 +0200982/**
983 * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets.
984 *
985 * @param[in,out] ctx_set Set with all not-yet-processed modules.
986 * @param[in,out] main_set Set of dependency module sets.
987 * @return LY_ERR value.
988 */
989static LY_ERR
990lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set)
991{
992 LY_ERR ret = LY_SUCCESS;
993 struct lys_module *m;
994 uint32_t i = 0;
995 struct ly_set *dep_set = NULL;
996
997 while (i < ctx_set->count) {
998 m = ctx_set->objs[i];
Michal Vaskof8b1b0d2021-11-22 09:59:57 +0100999 if (LYS_IS_SINGLE_DEP_SET(m)) {
Michal Vasko709f9a52021-07-21 10:51:59 +02001000 /* remove it from the set, we are processing it now */
1001 ly_set_rm_index(ctx_set, i, NULL);
1002
1003 /* this module can be in a separate dep set (but there still may be modules importing this one
1004 * that depend on imports of this one in case it defines groupings) */
1005 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1006 LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup);
1007 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
1008 dep_set = NULL;
1009 } else {
1010 ++i;
1011 }
1012 }
1013
1014cleanup:
1015 ly_set_free(dep_set, NULL);
1016 return ret;
1017}
1018
Michal Vaskof4258e12021-06-15 12:11:42 +02001019LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +02001020lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +02001021{
1022 LY_ERR ret = LY_SUCCESS;
1023 struct lys_module *m;
Michal Vasko775fbd02021-07-28 08:25:29 +02001024 struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0};
Michal Vaskof4258e12021-06-15 12:11:42 +02001025 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +02001026 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +02001027
Michal Vasko22b26222021-07-30 11:16:47 +02001028 assert(!main_set->count);
1029
Michal Vaskof4258e12021-06-15 12:11:42 +02001030 /* start with a duplicate set of modules that we will remove from */
1031 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
1032
Michal Vasko709f9a52021-07-21 10:51:59 +02001033 /* first create all dep sets with single modules */
1034 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup);
1035
1036 if (mod && !ly_set_contains(ctx_set, mod, NULL)) {
1037 /* dep set for this module has already been created, nothing else to do */
1038 goto cleanup;
1039 }
1040
Michal Vaskof4258e12021-06-15 12:11:42 +02001041 while (ctx_set->count) {
1042 /* create new dep set */
1043 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1044
1045 if (mod) {
1046 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001047 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 +02001048 } else {
1049 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001050 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 +02001051 }
Michal Vasko775fbd02021-07-28 08:25:29 +02001052 ly_set_erase(&aux_set, NULL);
Michal Vasko7ee5be22021-06-16 17:03:34 +02001053 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001054
1055 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001056 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001057 for (i = 0; i < dep_set->count; ++i) {
1058 m = dep_set->objs[i];
1059 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001060 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +02001061 break;
1062 }
1063 }
1064
Michal Vasko7ee5be22021-06-16 17:03:34 +02001065 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001066 /* if there is, all the implemented modules need to be recompiled */
1067 for (i = 0; i < dep_set->count; ++i) {
1068 m = dep_set->objs[i];
1069 if (m->implemented) {
1070 m->to_compile = 1;
1071 }
1072 }
1073 }
1074
Michal Vasko7ee5be22021-06-16 17:03:34 +02001075 /* add the dep set into main set */
1076 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001077 dep_set = NULL;
1078
1079 if (mod) {
1080 /* we need dep set only for this module */
1081 break;
1082 }
1083 }
1084
Michal Vaskoe558f792021-07-28 08:20:15 +02001085#ifndef NDEBUG
1086 LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count);
1087 for (i = 0; i < main_set->count; ++i) {
1088 struct ly_set *iter_set = main_set->objs[i];
1089
1090 LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i);
1091 for (uint32_t j = 0; j < iter_set->count; ++j) {
1092 m = iter_set->objs[j];
1093 LOGDBG(LY_LDGDEPSETS, "\t%s", m->name);
1094 }
1095 }
1096#endif
1097
Michal Vaskof4258e12021-06-15 12:11:42 +02001098cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +02001099 assert(ret || main_set->objs);
Michal Vasko775fbd02021-07-28 08:25:29 +02001100 ly_set_erase(&aux_set, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001101 ly_set_free(dep_set, NULL);
1102 ly_set_free(ctx_set, NULL);
1103 return ret;
1104}
1105
1106void
1107lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1108{
1109 uint32_t i, j, idx, prev_lo;
1110 struct ly_set *dep_set;
1111 struct lys_module *m;
1112 LY_ERR ret;
1113
1114 for (i = 0; i < unres->implementing.count; ++i) {
1115 m = unres->implementing.objs[i];
1116 assert(m->implemented);
1117
1118 /* make the module correctly non-implemented again */
1119 m->implemented = 0;
1120 lys_precompile_augments_deviations_revert(ctx, m);
1121 lysc_module_free(m->compiled);
1122 m->compiled = NULL;
1123
1124 /* should not be made implemented */
1125 m->to_compile = 0;
1126 }
1127
1128 for (i = 0; i < unres->creating.count; ++i) {
1129 m = unres->creating.objs[i];
1130
Michal Vaskod297f2a2021-06-16 11:51:28 +02001131 /* remove the module from the context */
Michal Vaskof4258e12021-06-15 12:11:42 +02001132 ly_set_rm(&ctx->list, m, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001133
Michal Vasko22b26222021-07-30 11:16:47 +02001134 /* remove it also from dep sets */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001135 for (j = 0; j < unres->dep_sets.count; ++j) {
1136 dep_set = unres->dep_sets.objs[j];
1137 if (ly_set_contains(dep_set, m, &idx)) {
1138 ly_set_rm_index(dep_set, idx, NULL);
1139 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001140 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001141 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001142
1143 /* free the module */
1144 lys_module_free(m);
Michal Vaskof4258e12021-06-15 12:11:42 +02001145 }
1146
1147 if (unres->implementing.count) {
1148 /* recompile previous context because some implemented modules are no longer implemented,
1149 * we can reuse the current to_compile flags */
1150 prev_lo = ly_log_options(0);
Michal Vasko22b26222021-07-30 11:16:47 +02001151 ret = lys_compile_depset_all(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001152 ly_log_options(prev_lo);
1153 if (ret) {
1154 LOGINT(ctx);
1155 }
1156 }
1157}
1158
1159void
1160lys_unres_glob_erase(struct lys_glob_unres *unres)
1161{
1162 uint32_t i;
1163
1164 for (i = 0; i < unres->dep_sets.count; ++i) {
1165 ly_set_free(unres->dep_sets.objs[i], NULL);
1166 }
1167 ly_set_erase(&unres->dep_sets, NULL);
1168 ly_set_erase(&unres->implementing, NULL);
1169 ly_set_erase(&unres->creating, NULL);
1170
Michal Vaskoc130e162021-10-19 11:30:00 +02001171 assert(!unres->ds_unres.whens.count);
1172 assert(!unres->ds_unres.musts.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001173 assert(!unres->ds_unres.leafrefs.count);
aPiecekc6526b42021-07-12 15:21:39 +02001174 assert(!unres->ds_unres.disabled_leafrefs.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001175 assert(!unres->ds_unres.dflts.count);
1176 assert(!unres->ds_unres.disabled.count);
1177}
1178
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001179LIBYANG_API_DEF LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +02001180lys_set_implemented(struct lys_module *mod, const char **features)
1181{
1182 LY_ERR ret = LY_SUCCESS;
Michal Vasko22b26222021-07-30 11:16:47 +02001183 struct lys_glob_unres *unres = &mod->ctx->unres;
Michal Vasko65333882021-06-10 14:12:16 +02001184
1185 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1186
1187 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001188 ret = _lys_set_implemented(mod, features, unres);
Michal Vasko65333882021-06-10 14:12:16 +02001189 LY_CHECK_GOTO(ret, cleanup);
1190
Michal Vaskof4258e12021-06-15 12:11:42 +02001191 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1192 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001193 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001194
Michal Vasko709f9a52021-07-21 10:51:59 +02001195 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001196 LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup);
1197
1198 /* unres resolved */
1199 lys_unres_glob_erase(unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001200 }
1201
Michal Vasko65333882021-06-10 14:12:16 +02001202cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001203 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001204 lys_unres_glob_revert(mod->ctx, unres);
1205 lys_unres_glob_erase(unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001206 }
Michal Vasko89b5c072020-10-06 13:52:44 +02001207 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001208}
1209
Michal Vasko7c8439f2020-08-05 13:25:19 +02001210static LY_ERR
aPiecekc3e26142021-06-22 14:25:49 +02001211lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001212{
1213 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001214 LY_ARRAY_COUNT_TYPE u, v;
1215
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001216 pmod->parsing = 1;
1217 LY_ARRAY_FOR(pmod->imports, u) {
1218 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001219 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001220 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 +02001221
1222 if (!imp->rev[0]) {
1223 /* This module must be selected for the next similar
1224 * import without revision-date to avoid incorrect
1225 * derived identities in the ::lys_module.identities.
1226 */
1227 imp->module->latest_revision |= LYS_MOD_IMPORTED_REV;
1228 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001229 }
1230 /* check for importing the same module twice */
1231 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001232 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001233 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1234 }
1235 }
1236 }
aPiecekc3e26142021-06-22 14:25:49 +02001237 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001238
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001239 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001240
1241 return LY_SUCCESS;
1242}
1243
Michal Vasko3a41dff2020-07-15 14:30:28 +02001244LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001245lys_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 +02001246 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001247 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001248{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001249 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001250 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +01001251 struct lys_yang_parser_ctx *yangctx = NULL;
1252 struct lys_yin_parser_ctx *yinctx = NULL;
1253 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001254
Michal Vasko3a41dff2020-07-15 14:30:28 +02001255 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001256
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001257 switch (format) {
1258 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001259 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001260 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001261 break;
1262 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001263 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001264 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001265 break;
1266 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001267 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001268 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001269 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001270 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001271 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001272 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001273
1274 /* make sure that the newest revision is at position 0 */
1275 lysp_sort_revisions(submod->revs);
1276
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001277 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001278 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001279 if (latest_sp) {
1280 if (submod->revs) {
1281 if (!latest_sp->revs) {
1282 /* latest has no revision, so mod is anyway newer */
1283 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001284 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1285 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1286 submod->latest_revision = latest_sp->latest_revision;
1287 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001288 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001289 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001290 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001291 } else {
1292 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001293 }
1294 } else {
1295 submod->latest_revision = 1;
1296 }
1297
Radek Krejcib3289d62019-09-18 12:21:39 +02001298 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001299 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001300 }
1301
1302 if (latest_sp) {
1303 latest_sp->latest_revision = 0;
1304 }
1305
Michal Vasko7a0b0762020-09-02 16:37:01 +02001306 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1307
Michal Vasko7c8439f2020-08-05 13:25:19 +02001308 /* resolve imports and includes */
aPiecekc3e26142021-06-22 14:25:49 +02001309 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
Michal Vasko7c8439f2020-08-05 13:25:19 +02001310
David Sedlák1b623122019-08-05 15:27:49 +02001311 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001312 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001313 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001314 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001315 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001316 *submodule = submod;
1317 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001318
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001319error:
Radek Krejcic64661b2020-08-15 15:42:26 +02001320 if (!submod || !submod->name) {
1321 LOGERR(ctx, ret, "Parsing submodule failed.");
1322 } else {
1323 LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name);
1324 }
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001325 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001326 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001327 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001328 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +01001329 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001330 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001331 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001332}
1333
Michal Vasko45b521c2020-11-04 17:14:39 +01001334/**
1335 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1336 *
1337 * @param[in] mod Parsed module to add to.
1338 * @return LY_SUCCESS on success.
1339 * @return LY_ERR on error.
1340 */
1341static LY_ERR
1342lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
1343{
1344 struct lysp_ext_instance *ext_p;
1345 struct lysp_stmt *stmt;
1346 struct lysp_import *imp;
1347
1348 /*
1349 * 1) edit-config's operation
1350 */
1351 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1352 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1353 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1354 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001355 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001356 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001357 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001358 ext_p->parent_stmt = LY_STMT_MODULE;
1359 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001360
1361 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1362 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1363 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1364 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001365 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001366 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001367 stmt->kw = LY_STMT_TYPE;
1368
1369 stmt->child = calloc(1, sizeof *stmt->child);
1370 stmt = stmt->child;
1371 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1372 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1373 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001374 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001375 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001376 stmt->kw = LY_STMT_ENUM;
1377
1378 stmt->next = calloc(1, sizeof *stmt->child);
1379 stmt = stmt->next;
1380 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1381 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1382 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001383 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001384 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001385 stmt->kw = LY_STMT_ENUM;
1386
1387 stmt->next = calloc(1, sizeof *stmt->child);
1388 stmt = stmt->next;
1389 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1390 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1391 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001392 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001393 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001394 stmt->kw = LY_STMT_ENUM;
1395
1396 stmt->next = calloc(1, sizeof *stmt->child);
1397 stmt = stmt->next;
1398 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1399 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1400 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001401 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001402 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001403 stmt->kw = LY_STMT_ENUM;
1404
1405 stmt->next = calloc(1, sizeof *stmt->child);
1406 stmt = stmt->next;
1407 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1408 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1409 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001410 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001411 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001412 stmt->kw = LY_STMT_ENUM;
1413
1414 /*
1415 * 2) filter's type
1416 */
1417 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1418 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1419 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1420 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001421 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001422 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001423 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001424 ext_p->parent_stmt = LY_STMT_MODULE;
1425 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001426
1427 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1428 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1429 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1430 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001431 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001432 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001433 stmt->kw = LY_STMT_TYPE;
1434
1435 stmt->child = calloc(1, sizeof *stmt->child);
1436 stmt = stmt->child;
1437 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1438 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1439 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001440 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001441 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001442 stmt->kw = LY_STMT_ENUM;
1443
1444 stmt->next = calloc(1, sizeof *stmt->child);
1445 stmt = stmt->next;
1446 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1447 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1448 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001449 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001450 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001451 stmt->kw = LY_STMT_ENUM;
1452
1453 /* if-feature for enum allowed only for YANG 1.1 modules */
1454 if (mod->version >= LYS_VERSION_1_1) {
1455 stmt->child = calloc(1, sizeof *stmt->child);
1456 stmt = stmt->child;
1457 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1458 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1459 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001460 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001461 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001462 stmt->kw = LY_STMT_IF_FEATURE;
1463 }
1464
1465 /*
1466 * 3) filter's select
1467 */
1468 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1469 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1470 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1471 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001472 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001473 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001474 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001475 ext_p->parent_stmt = LY_STMT_MODULE;
1476 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001477
1478 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1479 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1480 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1481 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001482 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001483 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001484 stmt->kw = LY_STMT_TYPE;
1485
1486 /* create new imports for the used prefixes */
1487 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1488
1489 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1490 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1491 imp->flags = LYS_INTERNAL;
1492
1493 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1494
1495 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1496 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1497 imp->flags = LYS_INTERNAL;
1498
1499 return LY_SUCCESS;
1500}
1501
1502/**
1503 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1504 *
1505 * @param[in] mod Parsed module to add to.
1506 * @return LY_SUCCESS on success.
1507 * @return LY_ERR on error.
1508 */
1509static LY_ERR
1510lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1511{
1512 struct lysp_ext_instance *ext_p;
1513 struct lysp_stmt *stmt;
1514 struct lysp_import *imp;
1515
1516 /* add new extension instance */
1517 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1518
1519 /* fill in the extension instance fields */
1520 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1521 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1522 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001523 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001524 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001525 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001526 ext_p->parent_stmt = LY_STMT_MODULE;
1527 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001528
1529 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1530 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1531 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1532 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001533 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001534 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001535 stmt->kw = LY_STMT_TYPE;
1536
1537 /* create new import for the used prefix */
1538 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1539
1540 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1541 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1542 imp->flags = LYS_INTERNAL;
1543
1544 return LY_SUCCESS;
1545}
1546
Michal Vasko3a41dff2020-07-15 14:30:28 +02001547LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001548lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001549 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 +02001550 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001551{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001552 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001553 LY_ERR ret;
Michal Vaskob36053d2020-03-26 15:49:30 +01001554 struct lys_yang_parser_ctx *yangctx = NULL;
1555 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001556 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001557 char *filename, *rev, *dot;
1558 size_t len;
Radek Krejcic64661b2020-08-15 15:42:26 +02001559 ly_bool module_created = 0;
Radek Krejci86d106e2018-10-18 09:53:19 +02001560
Michal Vaskodd992582021-06-10 14:34:57 +02001561 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001562
Michal Vasko7a0b0762020-09-02 16:37:01 +02001563 if (module) {
1564 *module = NULL;
1565 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001566
1567 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001568 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001569 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001570
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001571 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001572 switch (format) {
1573 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001574 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001575 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001576 break;
1577 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001578 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001579 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001580 break;
1581 default:
1582 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001583 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001584 break;
1585 }
Radek Krejcic64661b2020-08-15 15:42:26 +02001586 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001587
1588 /* make sure that the newest revision is at position 0 */
1589 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001590 if (mod->parsed->revs) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001591 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001592 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001593
Radek Krejcib3289d62019-09-18 12:21:39 +02001594 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001595 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001596 if (latest) {
1597 if (mod->revision) {
1598 if (!latest->revision) {
1599 /* latest has no revision, so mod is anyway newer */
aPiecek8ca21bd2021-07-26 14:31:01 +02001600 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001601 /* the latest is zeroed later when the new module is being inserted into the context */
1602 } else if (strcmp(mod->revision, latest->revision) > 0) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001603 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001604 /* the latest is zeroed later when the new module is being inserted into the context */
1605 } else {
1606 latest = NULL;
1607 }
1608 } else {
1609 latest = NULL;
1610 }
1611 } else {
aPiecek8ca21bd2021-07-26 14:31:01 +02001612 mod->latest_revision = LYS_MOD_LATEST_REV;
Radek Krejcib3289d62019-09-18 12:21:39 +02001613 }
1614
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001615 if (custom_check) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001616 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001617 }
1618
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001619 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001620 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001621 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001622 /* nothing to do */
1623 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1624 mod_dup->revision ? mod_dup->revision : "<none>");
Radek Krejcic64661b2020-08-15 15:42:26 +02001625 goto cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001626 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001627
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001628 switch (in->type) {
1629 case LY_IN_FILEPATH:
1630 /* check that name and revision match filename */
1631 filename = strrchr(in->method.fpath.filepath, '/');
1632 if (!filename) {
1633 filename = in->method.fpath.filepath;
1634 } else {
1635 filename++;
1636 }
1637 rev = strchr(filename, '@');
1638 dot = strrchr(filename, '.');
1639
1640 /* name */
1641 len = strlen(mod->name);
1642 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001643 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001644 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1645 }
1646 if (rev) {
1647 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001648 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001649 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001650 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001651 }
1652 }
1653
1654 break;
1655 case LY_IN_FD:
1656 case LY_IN_FILE:
1657 case LY_IN_MEMORY:
1658 /* nothing special to do */
1659 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001660 case LY_IN_ERROR:
1661 LOGINT(ctx);
1662 ret = LY_EINT;
Radek Krejcic64661b2020-08-15 15:42:26 +02001663 goto cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001664 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001665 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001666
Michal Vasko7a0b0762020-09-02 16:37:01 +02001667 if (latest) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001668 latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001669 }
1670
Michal Vasko45b521c2020-11-04 17:14:39 +01001671 /* add internal data in case specific modules were parsed */
1672 if (!strcmp(mod->name, "ietf-netconf")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001673 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001674 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001675 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001676 }
1677
Michal Vasko405cc9e2020-12-01 12:01:27 +01001678 /* add the module into newly created module set, will also be freed from there on any error */
Radek Krejcic64661b2020-08-15 15:42:26 +02001679 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup);
1680 module_created = 1;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001681
Michal Vasko7a0b0762020-09-02 16:37:01 +02001682 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001683 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001684 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001685 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001686
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001687 /* resolve includes and all imports */
aPiecekc3e26142021-06-22 14:25:49 +02001688 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001689
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001690 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001691 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001692 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001693 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1694 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001695
1696 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001697 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001698
aPiecek6b3d5422021-07-30 15:55:43 +02001699 /* compile identities */
1700 LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001701
Michal Vasko405cc9e2020-12-01 12:01:27 +01001702 /* success */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001703
Radek Krejcic64661b2020-08-15 15:42:26 +02001704cleanup:
Michal Vaskobe04af42021-07-16 10:48:43 +02001705 if (ret && (ret != LY_EEXIST)) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001706 if (mod && mod->name) {
1707 /* there are cases when path is not available for parsing error, so this additional
1708 * message tries to add information about the module where the error occurred */
1709 struct ly_err_item *e = ly_err_last(ctx);
1710 if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) {
1711 LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name);
1712 }
1713 }
1714 }
1715 if (!module_created) {
1716 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001717 mod = mod_dup;
1718 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001719
Michal Vasko7a0b0762020-09-02 16:37:01 +02001720 if (format == LYS_IN_YANG) {
1721 yang_parser_ctx_free(yangctx);
1722 } else {
1723 yin_parser_ctx_free(yinctx);
1724 }
1725
Michal Vasko405cc9e2020-12-01 12:01:27 +01001726 if (!ret && module) {
1727 *module = mod;
1728 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001729 return ret;
1730}
1731
Radek Krejci545b4872020-11-15 10:15:12 +01001732static LYS_INFORMAT
1733lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1734{
1735 if (!format && (in->type == LY_IN_FILEPATH)) {
1736 /* unknown format - try to detect it from filename's suffix */
1737 const char *path = in->method.fpath.filepath;
1738 size_t len = strlen(path);
1739
1740 /* ignore trailing whitespaces */
1741 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1742
Radek Krejcif13b87b2020-12-01 22:02:17 +01001743 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1744 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001745 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001746 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1747 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001748 format = LYS_IN_YIN;
1749 } /* else still unknown */
1750 }
1751
1752 return format;
1753}
1754
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001755LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001756lys_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 +02001757{
Michal Vasko65333882021-06-10 14:12:16 +02001758 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001759 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001760
Michal Vasko7a0b0762020-09-02 16:37:01 +02001761 if (module) {
1762 *module = NULL;
1763 }
Radek Krejci545b4872020-11-15 10:15:12 +01001764 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1765
1766 format = lys_parse_get_format(in, format);
1767 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001768
1769 /* remember input position */
1770 in->func_start = in->current;
1771
Michal Vasko4e205e82021-06-08 14:01:47 +02001772 /* parse */
Michal Vasko22b26222021-07-30 11:16:47 +02001773 ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001774 LY_CHECK_GOTO(ret, cleanup);
1775
1776 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001777 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001778 LY_CHECK_GOTO(ret, cleanup);
1779
Michal Vaskof4258e12021-06-15 12:11:42 +02001780 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1781 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001782 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001783
Michal Vasko709f9a52021-07-21 10:51:59 +02001784 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001785 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
1786
1787 /* unres resolved */
1788 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001789 }
1790
Michal Vasko405cc9e2020-12-01 12:01:27 +01001791cleanup:
1792 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001793 lys_unres_glob_revert(ctx, &ctx->unres);
1794 lys_unres_glob_erase(&ctx->unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001795 } else if (module) {
1796 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001797 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001798 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001799}
1800
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001801LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001802lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001803{
Radek Krejci0f969882020-08-21 16:56:47 +02001804 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001805 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001806
Michal Vasko3a41dff2020-07-15 14:30:28 +02001807 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001808
Michal Vasko3a41dff2020-07-15 14:30:28 +02001809 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 +02001810
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001811 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001812 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001813
Michal Vasko3a41dff2020-07-15 14:30:28 +02001814 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001815}
1816
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001817LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001818lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001819{
Radek Krejci0f969882020-08-21 16:56:47 +02001820 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001821 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001822
Michal Vasko3a41dff2020-07-15 14:30:28 +02001823 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001824
Michal Vasko3a41dff2020-07-15 14:30:28 +02001825 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 +02001826
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001827 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001828 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001829
Michal Vasko3a41dff2020-07-15 14:30:28 +02001830 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001831}
1832
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001833LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001834lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001835{
Radek Krejci0f969882020-08-21 16:56:47 +02001836 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001837 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001838
Michal Vasko3a41dff2020-07-15 14:30:28 +02001839 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001840
Michal Vasko3a41dff2020-07-15 14:30:28 +02001841 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001842 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001843
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001844 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001845 ly_in_free(in, 0);
1846
Michal Vasko3a41dff2020-07-15 14:30:28 +02001847 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001848}
1849
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001850LIBYANG_API_DEF LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001851lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001852 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001853{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001854 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001855 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001856 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001857 char *wd, *wn = NULL;
1858 DIR *dir = NULL;
1859 struct dirent *file;
1860 char *match_name = NULL;
1861 LYS_INFORMAT format_aux, match_format = 0;
1862 struct ly_set *dirs;
1863 struct stat st;
1864
1865 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1866
1867 /* start to fill the dir fifo with the context's search path (if set)
1868 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001869 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001870
1871 len = strlen(name);
1872 if (cwd) {
1873 wd = get_current_dir_name();
1874 if (!wd) {
1875 LOGMEM(NULL);
1876 goto cleanup;
1877 } else {
1878 /* add implicit current working directory (./) to be searched,
1879 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001880 ret = ly_set_add(dirs, wd, 0, NULL);
1881 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001882 implicit_cwd = 1;
1883 }
1884 }
1885 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001886 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001887 /* check for duplicities with the implicit current working directory */
1888 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1889 implicit_cwd = 0;
1890 continue;
1891 }
1892 wd = strdup(searchpaths[i]);
1893 if (!wd) {
1894 LOGMEM(NULL);
1895 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001896 } else {
1897 ret = ly_set_add(dirs, wd, 0, NULL);
1898 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001899 }
1900 }
1901 }
1902 wd = NULL;
1903
1904 /* start searching */
1905 while (dirs->count) {
1906 free(wd);
1907 free(wn); wn = NULL;
1908
1909 dirs->count--;
1910 wd = (char *)dirs->objs[dirs->count];
1911 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001912 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001913
1914 if (dir) {
1915 closedir(dir);
1916 }
1917 dir = opendir(wd);
1918 dir_len = strlen(wd);
1919 if (!dir) {
1920 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1921 } else {
1922 while ((file = readdir(dir))) {
1923 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1924 /* skip . and .. */
1925 continue;
1926 }
1927 free(wn);
1928 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1929 LOGMEM(NULL);
1930 goto cleanup;
1931 }
1932 if (stat(wn, &st) == -1) {
1933 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001934 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001935 continue;
1936 }
1937 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1938 /* we have another subdirectory in searchpath to explore,
1939 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001940 ret = ly_set_add(dirs, wn, 0, NULL);
1941 LY_CHECK_GOTO(ret, cleanup);
1942
Radek Krejcid33273d2018-10-25 14:55:52 +02001943 /* continue with the next item in current directory */
1944 wn = NULL;
1945 continue;
1946 } else if (!S_ISREG(st.st_mode)) {
1947 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1948 continue;
1949 }
1950
1951 /* here we know that the item is a file which can contain a module */
1952 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001953 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001954 /* different filename than the module we search for */
1955 continue;
1956 }
1957
1958 /* get type according to filename suffix */
1959 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001960 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1961 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001962 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001963 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1964 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001965 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001966 } else {
1967 /* not supportde suffix/file format */
1968 continue;
1969 }
1970
1971 if (revision) {
1972 /* we look for the specific revision, try to get it from the filename */
1973 if (file->d_name[len] == '@') {
1974 /* check revision from the filename */
1975 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1976 /* another revision */
1977 continue;
1978 } else {
1979 /* exact revision */
1980 free(match_name);
1981 match_name = wn;
1982 wn = NULL;
1983 match_len = dir_len + 1 + len;
1984 match_format = format_aux;
1985 goto success;
1986 }
1987 } else {
1988 /* continue trying to find exact revision match, use this only if not found */
1989 free(match_name);
1990 match_name = wn;
1991 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001992 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001993 match_format = format_aux;
1994 continue;
1995 }
1996 } else {
1997 /* remember the revision and try to find the newest one */
1998 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001999 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01002000 lysp_check_date(NULL, &file->d_name[len + 1],
2001 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002002 continue;
Michal Vasko69730152020-10-09 16:30:07 +02002003 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02002004 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
2005 continue;
2006 }
2007 free(match_name);
2008 }
2009
2010 match_name = wn;
2011 wn = NULL;
2012 match_len = dir_len + 1 + len;
2013 match_format = format_aux;
2014 continue;
2015 }
2016 }
2017 }
2018 }
2019
2020success:
2021 (*localfile) = match_name;
2022 match_name = NULL;
2023 if (format) {
2024 (*format) = match_format;
2025 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002026 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02002027
2028cleanup:
2029 free(wn);
2030 free(wd);
2031 if (dir) {
2032 closedir(dir);
2033 }
2034 free(match_name);
2035 ly_set_free(dirs, free);
2036
2037 return ret;
2038}