blob: 519df215f1a5a073e7c47204edad7c004354d72c [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 Vasko7b1ad1a2020-11-02 15:41:27 +010041#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020042#include "set.h"
43#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010044#include "tree_edit.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020045#include "tree_schema_internal.h"
46#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020047
Radek Krejcieccf6602021-02-05 19:42:54 +010048/**
49 * @brief information about YANG statements
50 */
51struct stmt_info_s stmt_attr_info[] = {
Radek Krejci6b88a462021-02-17 12:39:34 +010052 [LY_STMT_NONE] = {NULL, NULL, 0},
53 [LY_STMT_ACTION] = {"action", "name", STMT_FLAG_ID},
54 [LY_STMT_ANYDATA] = {"anydata", "name", STMT_FLAG_ID},
55 [LY_STMT_ANYXML] = {"anyxml", "name", STMT_FLAG_ID},
56 [LY_STMT_ARGUMENT] = {"argument", "name", STMT_FLAG_ID},
57 [LY_STMT_ARG_TEXT] = {"text", NULL, 0},
58 [LY_STMT_ARG_VALUE] = {"value", NULL, 0},
59 [LY_STMT_AUGMENT] = {"augment", "target-node", STMT_FLAG_ID},
60 [LY_STMT_BASE] = {"base", "name", STMT_FLAG_ID},
61 [LY_STMT_BELONGS_TO] = {"belongs-to", "module", STMT_FLAG_ID},
62 [LY_STMT_BIT] = {"bit", "name", STMT_FLAG_ID},
63 [LY_STMT_CASE] = {"case", "name", STMT_FLAG_ID},
64 [LY_STMT_CHOICE] = {"choice", "name", STMT_FLAG_ID},
65 [LY_STMT_CONFIG] = {"config", "value", STMT_FLAG_ID},
66 [LY_STMT_CONTACT] = {"contact", "text", STMT_FLAG_YIN},
67 [LY_STMT_CONTAINER] = {"container", "name", STMT_FLAG_ID},
68 [LY_STMT_DEFAULT] = {"default", "value", 0},
69 [LY_STMT_DESCRIPTION] = {"description", "text", STMT_FLAG_YIN},
70 [LY_STMT_DEVIATE] = {"deviate", "value", STMT_FLAG_ID},
71 [LY_STMT_DEVIATION] = {"deviation", "target-node", STMT_FLAG_ID},
72 [LY_STMT_ENUM] = {"enum", "name", STMT_FLAG_ID},
73 [LY_STMT_ERROR_APP_TAG] = {"error-app-tag", "value", 0},
74 [LY_STMT_ERROR_MESSAGE] = {"error-message", "value", STMT_FLAG_YIN},
75 [LY_STMT_EXTENSION] = {"extension", "name", STMT_FLAG_ID},
76 [LY_STMT_EXTENSION_INSTANCE] = {NULL, NULL, 0},
77 [LY_STMT_FEATURE] = {"feature", "name", STMT_FLAG_ID},
78 [LY_STMT_FRACTION_DIGITS] = {"fraction-digits", "value", STMT_FLAG_ID},
79 [LY_STMT_GROUPING] = {"grouping", "name", STMT_FLAG_ID},
80 [LY_STMT_IDENTITY] = {"identity", "name", STMT_FLAG_ID},
81 [LY_STMT_IF_FEATURE] = {"if-feature", "name", 0},
82 [LY_STMT_IMPORT] = {"import", "module", STMT_FLAG_ID},
83 [LY_STMT_INCLUDE] = {"include", "module", STMT_FLAG_ID},
84 [LY_STMT_INPUT] = {"input", NULL, 0},
85 [LY_STMT_KEY] = {"key", "value", 0},
86 [LY_STMT_LEAF] = {"leaf", "name", STMT_FLAG_ID},
87 [LY_STMT_LEAF_LIST] = {"leaf-list", "name", STMT_FLAG_ID},
88 [LY_STMT_LENGTH] = {"length", "value", 0},
89 [LY_STMT_LIST] = {"list", "name", STMT_FLAG_ID},
90 [LY_STMT_MANDATORY] = {"mandatory", "value", STMT_FLAG_ID},
91 [LY_STMT_MAX_ELEMENTS] = {"max-elements", "value", STMT_FLAG_ID},
92 [LY_STMT_MIN_ELEMENTS] = {"min-elements", "value", STMT_FLAG_ID},
93 [LY_STMT_MODIFIER] = {"modifier", "value", STMT_FLAG_ID},
94 [LY_STMT_MODULE] = {"module", "name", STMT_FLAG_ID},
95 [LY_STMT_MUST] = {"must", "condition", 0},
96 [LY_STMT_NAMESPACE] = {"namespace", "uri", 0},
97 [LY_STMT_NOTIFICATION] = {"notification", "name", STMT_FLAG_ID},
98 [LY_STMT_ORDERED_BY] = {"ordered-by", "value", STMT_FLAG_ID},
99 [LY_STMT_ORGANIZATION] = {"organization", "text", STMT_FLAG_YIN},
100 [LY_STMT_OUTPUT] = {"output", NULL, 0},
101 [LY_STMT_PATH] = {"path", "value", 0},
102 [LY_STMT_PATTERN] = {"pattern", "value", 0},
103 [LY_STMT_POSITION] = {"position", "value", STMT_FLAG_ID},
104 [LY_STMT_PREFIX] = {"prefix", "value", STMT_FLAG_ID},
105 [LY_STMT_PRESENCE] = {"presence", "value", 0},
106 [LY_STMT_RANGE] = {"range", "value", 0},
107 [LY_STMT_REFERENCE] = {"reference", "text", STMT_FLAG_YIN},
108 [LY_STMT_REFINE] = {"refine", "target-node", STMT_FLAG_ID},
109 [LY_STMT_REQUIRE_INSTANCE] = {"require-instance", "value", STMT_FLAG_ID},
110 [LY_STMT_REVISION] = {"revision", "date", STMT_FLAG_ID},
111 [LY_STMT_REVISION_DATE] = {"revision-date", "date", STMT_FLAG_ID},
112 [LY_STMT_RPC] = {"rpc", "name", STMT_FLAG_ID},
113 [LY_STMT_STATUS] = {"status", "value", STMT_FLAG_ID},
114 [LY_STMT_SUBMODULE] = {"submodule", "name", STMT_FLAG_ID},
115 [LY_STMT_SYNTAX_LEFT_BRACE] = {"{", NULL, 0},
116 [LY_STMT_SYNTAX_RIGHT_BRACE] = {"}", NULL, 0},
117 [LY_STMT_SYNTAX_SEMICOLON] = {";", NULL, 0},
118 [LY_STMT_TYPE] = {"type", "name", STMT_FLAG_ID},
119 [LY_STMT_TYPEDEF] = {"typedef", "name", STMT_FLAG_ID},
120 [LY_STMT_UNIQUE] = {"unique", "tag", 0},
121 [LY_STMT_UNITS] = {"units", "name", 0},
122 [LY_STMT_USES] = {"uses", "name", STMT_FLAG_ID},
123 [LY_STMT_VALUE] = {"value", "value", STMT_FLAG_ID},
124 [LY_STMT_WHEN] = {"when", "condition", 0},
125 [LY_STMT_YANG_VERSION] = {"yang-version", "value", STMT_FLAG_ID},
126 [LY_STMT_YIN_ELEMENT] = {"yin-element", "value", STMT_FLAG_ID},
Radek Krejcieccf6602021-02-05 19:42:54 +0100127};
128
Radek Krejcif8ca8192021-03-02 16:50:06 +0100129API const char *
130ly_stmt2str(enum ly_stmt stmt)
131{
Michal Vaskocc64aec2021-05-18 17:33:11 +0200132 if (stmt == LY_STMT_EXTENSION_INSTANCE) {
133 return "extension instance";
134 } else {
135 return stmt_attr_info[stmt].name;
136 }
Radek Krejcif8ca8192021-03-02 16:50:06 +0100137}
138
Radek Krejcieccf6602021-02-05 19:42:54 +0100139const char * const ly_devmod_list[] = {
140 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
141 [LYS_DEV_ADD] = "add",
142 [LYS_DEV_DELETE] = "delete",
143 [LYS_DEV_REPLACE] = "replace",
144};
145
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200146API LY_ERR
147lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
148{
Michal Vasko1d972ca2020-11-03 17:16:56 +0100149 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100150 const struct lysc_node_action *action;
151 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200152
153 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
154
155 LYSC_TREE_DFS_BEGIN(root, elem) {
156 /* schema node */
157 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
158
Radek Krejci2a9fc652021-01-22 17:44:34 +0100159 LY_LIST_FOR(lysc_node_actions(elem), action) {
160 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200161 /* action subtree */
162 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
163
Radek Krejci2a9fc652021-01-22 17:44:34 +0100164 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200165 }
166 }
167
Radek Krejci2a9fc652021-01-22 17:44:34 +0100168 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
169 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200170 /* notification subtree */
171 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
172
Radek Krejci2a9fc652021-01-22 17:44:34 +0100173 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200174 }
175 }
176
177 LYSC_TREE_DFS_END(root, elem);
178 }
179
180 return LY_SUCCESS;
181}
182
183API LY_ERR
184lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
185{
Michal Vasko2336cf52020-11-03 17:18:15 +0100186 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200187
188 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
189
190 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100191 LY_LIST_FOR(mod->compiled->data, root) {
192 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
193 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200194
195 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100196 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
197 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200198 }
199
200 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100201 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
202 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200203 }
204
205 return LY_SUCCESS;
206}
207
Radek Krejcib93bd412020-11-02 13:23:11 +0100208static void
209lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
210{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100211 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100212 if (first_case->child) {
213 /* there is something to return */
214 (*next) = first_case->child;
215 return;
216 }
217 }
218
219 /* no children in choice's cases, so go to the choice's sibling instead of into it */
220 (*last) = (*next);
221 (*next) = (*next)->next;
222}
223
Radek Krejci035dacf2021-02-12 18:25:53 +0100224/**
225 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
226 *
227 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
228 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
229 * extension instance.
230 *
231 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
232 * and function starts returning i) the first \p parent's child or ii) the first top level element specified in the
233 * given extension (if provided) or iii) the first top level element of the \p module.
234 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
235 * \p parent and \p module parameters.
236 *
237 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
238 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
239 * all the schema nodes are iteratively returned.
240 *
241 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
242 * @param[in] parent Parent of the subtree where the function starts processing.
243 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
244 * module must be specified.
245 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
246 * the \p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
247 * @param[in] options [ORed options](@ref sgetnextflags).
248 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
249 */
250static const struct lysc_node *
251lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
252 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100253{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100254 const struct lysc_node *next = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200255 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci035dacf2021-02-12 18:25:53 +0100256 struct lysc_node **data_p = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100257
Radek Krejci035dacf2021-02-12 18:25:53 +0100258 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100259
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200260next:
Radek Krejcia3045382018-11-22 14:30:31 +0100261 if (!last) {
262 /* first call */
263
264 /* get know where to start */
265 if (parent) {
266 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100267 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100268 } else {
269 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100270 if (ext) {
271 lysc_ext_substmt(ext, LY_STMT_CONTAINER /* matches all nodes */, (void **)&data_p, NULL);
272 next = last = data_p ? *data_p : NULL;
273 } else {
274 next = last = module->data;
275 }
Radek Krejcia3045382018-11-22 14:30:31 +0100276 }
277 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100278 /* try to get action or notification */
279 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100280 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100281 /* test if the next can be returned */
282 goto check;
283
Michal Vasko1bf09392020-03-27 12:38:10 +0100284 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100285 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100286 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100287 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100288 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100289 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200290 } else {
291 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100292 }
293
Radek Krejcia3045382018-11-22 14:30:31 +0100294repeat:
295 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100296 /* possibly go back to parent */
Radek Krejci035dacf2021-02-12 18:25:53 +0100297 data_p = NULL;
Michal Vasko69730152020-10-09 16:30:07 +0200298 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100299 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200300 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100301 } else if (!action_flag) {
302 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100303 if (ext) {
304 lysc_ext_substmt(ext, LY_STMT_RPC /* matches also actions */, (void **)&data_p, NULL);
305 next = data_p ? *data_p : NULL;
306 } else if (parent) {
307 next = (struct lysc_node *)lysc_node_actions(parent);
308 } else {
309 next = (struct lysc_node *)module->rpcs;
310 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100311 } else if (!notif_flag) {
312 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100313 if (ext) {
314 lysc_ext_substmt(ext, LY_STMT_NOTIFICATION, (void **)&data_p, NULL);
315 next = data_p ? *data_p : NULL;
316 } else if (parent) {
317 next = (struct lysc_node *)lysc_node_notifs(parent);
318 } else {
319 next = (struct lysc_node *)module->notifs;
320 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100321 } else {
322 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100323 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100324 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100325 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100326check:
Radek Krejcia3045382018-11-22 14:30:31 +0100327 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100328 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100329 case LYS_ACTION:
330 case LYS_NOTIF:
331 case LYS_LEAF:
332 case LYS_ANYXML:
333 case LYS_ANYDATA:
334 case LYS_LIST:
335 case LYS_LEAFLIST:
336 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200337 case LYS_CASE:
338 if (options & LYS_GETNEXT_WITHCASE) {
339 break;
340 } else {
341 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100342 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200343 }
344 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100345 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100346 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100347 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100348 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100349 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100350 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100351 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100352 next = next->next;
353 }
354 goto repeat;
355 }
356 break;
357 case LYS_CHOICE:
358 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200359 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100360 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100361 next = next->next;
362 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100363 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100364 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100365 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100366 /* go into */
367 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100368 }
Radek Krejcia3045382018-11-22 14:30:31 +0100369 }
370 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100371 case LYS_INPUT:
372 if (options & LYS_GETNEXT_OUTPUT) {
373 /* skip */
374 next = next->next;
375 } else {
376 /* go into */
377 next = lysc_node_child(next);
378 }
379 goto repeat;
380 case LYS_OUTPUT:
381 if (!(options & LYS_GETNEXT_OUTPUT)) {
382 /* skip */
383 next = next->next;
384 } else {
385 /* go into */
386 next = lysc_node_child(next);
387 }
388 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100389 default:
390 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100391 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100392 return NULL;
393 }
394
Radek Krejcia3045382018-11-22 14:30:31 +0100395 return next;
396}
397
398API const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100399lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
400{
401 return lys_getnext_(last, parent, module, NULL, options);
402}
403
404API const struct lysc_node *
405lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
406{
407 return lys_getnext_(last, parent, NULL, ext, options);
408}
409
Radek Krejcif16e2542021-02-17 15:39:23 +0100410const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100411lysc_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 +0100412 uint16_t nodetype, uint32_t options)
413{
414 const struct lysc_node *node = NULL;
415
416 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
417 if (!nodetype) {
418 nodetype = LYS_NODETYPE_MASK;
419 }
420
421 if (module && (module != ext->module)) {
422 return NULL;
423 }
424
425 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
426 if (!(node->nodetype & nodetype)) {
427 continue;
428 }
429
430 if (name_len) {
431 if (!ly_strncmp(node->name, name, name_len)) {
432 return node;
433 }
434 } else {
435 if (!strcmp(node->name, name)) {
436 return node;
437 }
438 }
439 }
440 return NULL;
441}
442
Radek Krejci035dacf2021-02-12 18:25:53 +0100443API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100444lys_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 +0200445 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100446{
447 const struct lysc_node *node = NULL;
448
449 LY_CHECK_ARG_RET(NULL, module, name, NULL);
450 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100451 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100452 }
453
454 while ((node = lys_getnext(node, parent, module->compiled, options))) {
455 if (!(node->nodetype & nodetype)) {
456 continue;
457 }
458 if (node->module != module) {
459 continue;
460 }
461
462 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200463 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100464 return node;
465 }
466 } else {
467 if (!strcmp(node->name, name)) {
468 return node;
469 }
470 }
471 }
472 return NULL;
473}
474
Michal Vasko519fd602020-05-26 12:17:39 +0200475API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100476lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
477 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200478{
479 LY_ERR ret = LY_SUCCESS;
480 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200481 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200482 uint32_t i;
483
Michal Vasko26512682021-01-11 11:35:40 +0100484 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200485 if (!(options & LYXP_SCNODE_ALL)) {
486 options = LYXP_SCNODE;
487 }
Michal Vasko26512682021-01-11 11:35:40 +0100488 if (!ctx) {
489 ctx = ctx_node->module->ctx;
490 }
Michal Vasko519fd602020-05-26 12:17:39 +0200491
492 memset(&xp_set, 0, sizeof xp_set);
493
494 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100495 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200496 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200497
498 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200499 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200500 LY_CHECK_GOTO(ret, cleanup);
501
502 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200503 ret = ly_set_new(set);
504 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200505
506 /* transform into ly_set */
507 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100508 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200509 (*set)->size = xp_set.used;
510
511 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200512 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200513 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200514 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200515 }
516 }
517
518cleanup:
519 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100520 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200521 return ret;
522}
523
Michal Vasko072de482020-08-05 13:27:21 +0200524API LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200525lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
526 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
527{
528 LY_ERR ret = LY_SUCCESS;
529 struct lyxp_set xp_set = {0};
530 uint32_t i;
531
532 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
533 if (!(options & LYXP_SCNODE_ALL)) {
534 options = LYXP_SCNODE;
535 }
536
537 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200538 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 +0200539 LY_CHECK_GOTO(ret, cleanup);
540
541 /* allocate return set */
542 ret = ly_set_new(set);
543 LY_CHECK_GOTO(ret, cleanup);
544
545 /* transform into ly_set */
546 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
547 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
548 (*set)->size = xp_set.used;
549
550 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200551 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
552 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
553 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100554 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200555 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
556 LY_CHECK_GOTO(ret, cleanup);
557 }
558 }
559
560cleanup:
561 lyxp_set_free_content(&xp_set);
562 if (ret) {
563 ly_set_free(*set, NULL);
564 *set = NULL;
565 }
566 return ret;
567}
568
569API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100570lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
571 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200572{
573 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200574 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200575 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200576 uint32_t i;
577
Michal Vasko26512682021-01-11 11:35:40 +0100578 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200579 if (!(options & LYXP_SCNODE_ALL)) {
580 options = LYXP_SCNODE;
581 }
Michal Vasko26512682021-01-11 11:35:40 +0100582 if (!ctx) {
583 ctx = ctx_node->module->ctx;
584 }
Michal Vasko072de482020-08-05 13:27:21 +0200585
Michal Vasko072de482020-08-05 13:27:21 +0200586 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100587 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200588 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200589
590 /* atomize expression */
Radek Krejci8df109d2021-04-23 12:19:08 +0200591 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200592 LY_CHECK_GOTO(ret, cleanup);
593
594 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200595 ret = ly_set_new(set);
596 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200597
598 /* transform into ly_set */
599 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100600 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200601 (*set)->size = xp_set.used;
602
603 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100604 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 +0200605 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200606 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200607 }
608 }
609
610cleanup:
611 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100612 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200613 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200614 ly_set_free(*set, NULL);
615 *set = NULL;
616 }
Michal Vasko072de482020-08-05 13:27:21 +0200617 return ret;
618}
619
Radek Krejcibc5644c2020-10-27 14:53:17 +0100620API LY_ERR
621lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
622{
623 LY_ERR ret = LY_SUCCESS;
624 LY_ARRAY_COUNT_TYPE u, v;
625
626 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
627
628 /* allocate return set */
629 LY_CHECK_RET(ly_set_new(set));
630
631 LY_ARRAY_FOR(path, u) {
632 /* add nodes from the path */
633 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
634 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
635 LY_ARRAY_FOR(path[u].predicates, v) {
636 /* add all the keys in a predicate */
637 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
638 }
639 }
640 }
641
642cleanup:
643 if (ret) {
644 ly_set_free(*set, NULL);
645 *set = NULL;
646 }
647 return ret;
648}
649
650API LY_ERR
651lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
652 struct ly_set **set)
653{
654 LY_ERR ret = LY_SUCCESS;
655 uint8_t oper;
656 struct lyxp_expr *expr = NULL;
657 struct ly_path *p = NULL;
658
659 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
660
661 if (!ctx) {
662 ctx = ctx_node->module->ctx;
663 }
664
665 /* parse */
666 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
667 LY_CHECK_GOTO(ret, cleanup);
668
669 /* compile */
670 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100671 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Radek Krejci8df109d2021-04-23 12:19:08 +0200672 LY_VALUE_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100673 LY_CHECK_GOTO(ret, cleanup);
674
675 /* resolve */
676 ret = lys_find_lypath_atoms(p, set);
677
678cleanup:
679 ly_path_free(ctx, p);
680 lyxp_expr_free(ctx, expr);
681 return ret;
682}
683
684API const struct lysc_node *
685lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
686{
687 const struct lysc_node *snode = NULL;
688 struct lyxp_expr *exp = NULL;
689 struct ly_path *p = NULL;
690 LY_ERR ret;
691 uint8_t oper;
692
693 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
694
695 if (!ctx) {
696 ctx = ctx_node->module->ctx;
697 }
698
699 /* parse */
700 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
701 LY_CHECK_GOTO(ret, cleanup);
702
703 /* compile */
704 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100705 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, exp, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Radek Krejci8df109d2021-04-23 12:19:08 +0200706 LY_VALUE_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100707 LY_CHECK_GOTO(ret, cleanup);
708
709 /* get last node */
710 snode = p[LY_ARRAY_COUNT(p) - 1].node;
711
712cleanup:
713 ly_path_free(ctx, p);
714 lyxp_expr_free(ctx, exp);
715 return snode;
716}
717
Michal Vasko14654712020-02-06 08:35:21 +0100718char *
719lysc_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 +0200720 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200721{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200722 const struct lysc_node *iter;
Radek Krejci327de162019-06-14 12:52:07 +0200723 char *path = NULL;
724 int len = 0;
725
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200726 if (buffer) {
727 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100728 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200729 }
730
Radek Krejci327de162019-06-14 12:52:07 +0200731 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200732 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200733 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100734 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200735 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100736 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200737
Michal Vasko721b6f62021-02-08 08:52:53 +0100738 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200739 /* schema-only node */
740 continue;
741 }
742
Michal Vasko11deea12020-08-05 13:54:50 +0200743 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200744 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100745 if (parent && (iter->parent == parent)) {
746 slash = "";
747 } else {
748 slash = "/";
749 }
Michal Vasko69730152020-10-09 16:30:07 +0200750 if (!iter->parent || (iter->parent->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200751 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200752 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100753 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200754 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100755 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200756 }
Radek Krejci327de162019-06-14 12:52:07 +0200757 } else {
758 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200759 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100760 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200761 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100762 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200763 }
Radek Krejci327de162019-06-14 12:52:07 +0200764 }
765 free(s);
766 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200767
Michal Vasko69730152020-10-09 16:30:07 +0200768 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200769 /* not enough space in buffer */
770 break;
771 }
Radek Krejci327de162019-06-14 12:52:07 +0200772 }
773
774 if (len < 0) {
775 free(path);
776 path = NULL;
777 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200778 if (buffer) {
779 strcpy(buffer, "/");
780 } else {
781 path = strdup("/");
782 }
Radek Krejci327de162019-06-14 12:52:07 +0200783 }
784 break;
785 }
786
Radek Krejci1c0c3442019-07-23 16:08:47 +0200787 if (buffer) {
788 return buffer;
789 } else {
790 return path;
791 }
Radek Krejci327de162019-06-14 12:52:07 +0200792}
793
Michal Vasko14654712020-02-06 08:35:21 +0100794API char *
795lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
796{
797 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
798}
799
Michal Vasko405cc9e2020-12-01 12:01:27 +0100800LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200801_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100802{
803 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko65333882021-06-10 14:12:16 +0200804 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100805
Michal Vasko405cc9e2020-12-01 12:01:27 +0100806 if (mod->implemented) {
807 /* mod is already implemented, set the features */
808 r = lys_set_features(mod->parsed, features);
809 if (r == LY_EEXIST) {
810 /* no changes */
811 return LY_SUCCESS;
812 } else if (r) {
813 /* error */
814 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200815 }
816
Michal Vasko01db7de2021-04-16 12:23:30 +0200817 if (mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE) {
818 /* just mark the module as changed */
819 mod->to_compile = 1;
820 return LY_SUCCESS;
821 } else {
822 /* full recompilation */
823 return lys_recompile(mod->ctx, 1);
824 }
Michal Vasko89b5c072020-10-06 13:52:44 +0200825 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100826
Michal Vasko65333882021-06-10 14:12:16 +0200827 /* implement */
828 ret = lys_implement(mod, features, unres);
829 if (ret == LY_ERECOMPILE) {
830 /* recompile */
831 LY_CHECK_GOTO(ret = lys_recompile(mod->ctx, 1), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100832
Michal Vasko65333882021-06-10 14:12:16 +0200833 /* reset unres, it is no longer valid after recompilation and recompilation has actually resolved it all */
834 lys_compile_unres_glob_erase(mod->ctx, unres, 1);
835 unres->full_compilation = 1;
836 } else if (ret) {
837 goto cleanup;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100838 }
Michal Vasko65333882021-06-10 14:12:16 +0200839
840 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
841 /* implement all the imports as well */
842 for (i = 0; i < unres->creating.count; ++i) {
843 mod = unres->creating.objs[i];
844 if (mod->implemented) {
845 continue;
846 }
847
848 ret = lys_implement(mod, NULL, unres);
849 if (ret == LY_ERECOMPILE) {
850 LY_CHECK_GOTO(ret = lys_recompile(mod->ctx, 1), cleanup);
851
852 lys_compile_unres_glob_erase(mod->ctx, unres, 1);
853 unres->full_compilation = 1;
854 } else if (ret) {
855 goto cleanup;
856 }
857 }
858 }
859
860 /* resolve unres */
861 LY_CHECK_GOTO(ret = lys_compile_unres_glob(mod->ctx, unres), cleanup);
862
863cleanup:
864 return ret;
865}
866
867API LY_ERR
868lys_set_implemented(struct lys_module *mod, const char **features)
869{
870 LY_ERR ret = LY_SUCCESS;
871 struct lys_glob_unres unres = {0};
872
873 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
874
875 /* implement */
876 ret = _lys_set_implemented(mod, features, &unres);
877 LY_CHECK_GOTO(ret, cleanup);
878
879cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +0100880 if (ret) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100881 lys_compile_unres_glob_revert(mod->ctx, &unres);
882 }
Michal Vasko65333882021-06-10 14:12:16 +0200883 lys_compile_unres_glob_erase(mod->ctx, &unres, 0);
Michal Vasko89b5c072020-10-06 13:52:44 +0200884 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200885}
886
Michal Vasko7c8439f2020-08-05 13:25:19 +0200887static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100888lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
Michal Vasko7c8439f2020-08-05 13:25:19 +0200889{
890 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200891 LY_ARRAY_COUNT_TYPE u, v;
892
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100893 pmod->parsing = 1;
894 LY_ARRAY_FOR(pmod->imports, u) {
895 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +0200896 if (!imp->module) {
Michal Vaskodd992582021-06-10 14:34:57 +0200897 LY_CHECK_RET(lys_parse_load(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL,
898 pctx->new_mods, &imp->module));
Michal Vasko7c8439f2020-08-05 13:25:19 +0200899 }
900 /* check for importing the same module twice */
901 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100902 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200903 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
904 }
905 }
906 }
Radek Krejci771928a2021-01-19 13:42:36 +0100907 LY_CHECK_RET(lysp_load_submodules(pctx, pmod));
908
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100909 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200910
911 return LY_SUCCESS;
912}
913
Michal Vasko3a41dff2020-07-15 14:30:28 +0200914LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +0200915lys_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 +0200916 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
Radek Krejci0f969882020-08-21 16:56:47 +0200917 void *check_data, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200918{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200919 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100920 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +0100921 struct lys_yang_parser_ctx *yangctx = NULL;
922 struct lys_yin_parser_ctx *yinctx = NULL;
923 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100924
Michal Vasko3a41dff2020-07-15 14:30:28 +0200925 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100926
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100927 switch (format) {
928 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +0200929 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100930 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100931 break;
932 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +0200933 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100934 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100935 break;
936 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +0200937 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +0200938 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100939 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200940 }
Radek Krejcif6923e82020-07-02 16:36:53 +0200941 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +0200942 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100943
944 /* make sure that the newest revision is at position 0 */
945 lysp_sort_revisions(submod->revs);
946
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100947 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +0100948 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100949 if (latest_sp) {
950 if (submod->revs) {
951 if (!latest_sp->revs) {
952 /* latest has no revision, so mod is anyway newer */
953 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +0200954 /* the latest_sp is zeroed later when the new module is being inserted into the context */
955 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
956 submod->latest_revision = latest_sp->latest_revision;
957 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100958 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +0200959 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100960 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200961 } else {
962 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100963 }
964 } else {
965 submod->latest_revision = 1;
966 }
967
Radek Krejcib3289d62019-09-18 12:21:39 +0200968 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200969 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +0200970 }
971
972 if (latest_sp) {
973 latest_sp->latest_revision = 0;
974 }
975
Michal Vasko7a0b0762020-09-02 16:37:01 +0200976 lys_parser_fill_filepath(ctx, in, &submod->filepath);
977
Michal Vasko7c8439f2020-08-05 13:25:19 +0200978 /* resolve imports and includes */
979 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod), error);
980
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100981 /* remap possibly changed and reallocated typedefs and groupings list back to the main context */
Michal Vaskob36053d2020-03-26 15:49:30 +0100982 memcpy(&main_ctx->tpdfs_nodes, &pctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
983 memcpy(&main_ctx->grps_nodes, &pctx->grps_nodes, sizeof main_ctx->grps_nodes);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100984
David Sedlák1b623122019-08-05 15:27:49 +0200985 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100986 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200987 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100988 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200989 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200990 *submodule = submod;
991 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +0200992
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100993error:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200994 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +0200995 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100996 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200997 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100998 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200999 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001000 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001001}
1002
Michal Vasko45b521c2020-11-04 17:14:39 +01001003/**
1004 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1005 *
1006 * @param[in] mod Parsed module to add to.
1007 * @return LY_SUCCESS on success.
1008 * @return LY_ERR on error.
1009 */
1010static LY_ERR
1011lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
1012{
1013 struct lysp_ext_instance *ext_p;
1014 struct lysp_stmt *stmt;
1015 struct lysp_import *imp;
1016
1017 /*
1018 * 1) edit-config's operation
1019 */
1020 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1021 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1022 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1023 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001024 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001025 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001026 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001027 ext_p->parent_stmt = LY_STMT_MODULE;
1028 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001029
1030 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1031 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1032 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1033 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001034 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001035 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001036 stmt->kw = LY_STMT_TYPE;
1037
1038 stmt->child = calloc(1, sizeof *stmt->child);
1039 stmt = stmt->child;
1040 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1041 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1042 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001043 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001044 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001045 stmt->kw = LY_STMT_ENUM;
1046
1047 stmt->next = calloc(1, sizeof *stmt->child);
1048 stmt = stmt->next;
1049 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1050 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1051 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001052 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001053 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001054 stmt->kw = LY_STMT_ENUM;
1055
1056 stmt->next = calloc(1, sizeof *stmt->child);
1057 stmt = stmt->next;
1058 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1059 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1060 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001061 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001062 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001063 stmt->kw = LY_STMT_ENUM;
1064
1065 stmt->next = calloc(1, sizeof *stmt->child);
1066 stmt = stmt->next;
1067 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1068 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1069 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001070 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001071 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001072 stmt->kw = LY_STMT_ENUM;
1073
1074 stmt->next = calloc(1, sizeof *stmt->child);
1075 stmt = stmt->next;
1076 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1077 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1078 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001079 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001080 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001081 stmt->kw = LY_STMT_ENUM;
1082
1083 /*
1084 * 2) filter's type
1085 */
1086 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1087 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1088 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1089 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001090 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001091 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001092 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001093 ext_p->parent_stmt = LY_STMT_MODULE;
1094 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001095
1096 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1097 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1098 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1099 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001100 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001101 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001102 stmt->kw = LY_STMT_TYPE;
1103
1104 stmt->child = calloc(1, sizeof *stmt->child);
1105 stmt = stmt->child;
1106 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1107 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1108 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001109 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001110 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001111 stmt->kw = LY_STMT_ENUM;
1112
1113 stmt->next = calloc(1, sizeof *stmt->child);
1114 stmt = stmt->next;
1115 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1116 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1117 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001118 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001119 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001120 stmt->kw = LY_STMT_ENUM;
1121
1122 /* if-feature for enum allowed only for YANG 1.1 modules */
1123 if (mod->version >= LYS_VERSION_1_1) {
1124 stmt->child = calloc(1, sizeof *stmt->child);
1125 stmt = stmt->child;
1126 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1127 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1128 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001129 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001130 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001131 stmt->kw = LY_STMT_IF_FEATURE;
1132 }
1133
1134 /*
1135 * 3) filter's select
1136 */
1137 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1138 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1139 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1140 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001141 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001142 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001143 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001144 ext_p->parent_stmt = LY_STMT_MODULE;
1145 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001146
1147 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1148 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1149 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1150 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001151 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001152 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001153 stmt->kw = LY_STMT_TYPE;
1154
1155 /* create new imports for the used prefixes */
1156 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1157
1158 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1159 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1160 imp->flags = LYS_INTERNAL;
1161
1162 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1163
1164 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1165 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1166 imp->flags = LYS_INTERNAL;
1167
1168 return LY_SUCCESS;
1169}
1170
1171/**
1172 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1173 *
1174 * @param[in] mod Parsed module to add to.
1175 * @return LY_SUCCESS on success.
1176 * @return LY_ERR on error.
1177 */
1178static LY_ERR
1179lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1180{
1181 struct lysp_ext_instance *ext_p;
1182 struct lysp_stmt *stmt;
1183 struct lysp_import *imp;
1184
1185 /* add new extension instance */
1186 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1187
1188 /* fill in the extension instance fields */
1189 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1190 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1191 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Radek Krejci8df109d2021-04-23 12:19:08 +02001192 ext_p->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001193 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001194 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001195 ext_p->parent_stmt = LY_STMT_MODULE;
1196 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001197
1198 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1199 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1200 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1201 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001202 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001203 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001204 stmt->kw = LY_STMT_TYPE;
1205
1206 /* create new import for the used prefix */
1207 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1208
1209 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1210 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1211 imp->flags = LYS_INTERNAL;
1212
1213 return LY_SUCCESS;
1214}
1215
Michal Vasko3a41dff2020-07-15 14:30:28 +02001216LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001217lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001218 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 +02001219 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001220{
Michal Vasko4e205e82021-06-08 14:01:47 +02001221 struct lys_module *mod = NULL, *latest, *mod_dup;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001222 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001223 LY_ERR ret;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001224 LY_ARRAY_COUNT_TYPE u;
Michal Vaskob36053d2020-03-26 15:49:30 +01001225 struct lys_yang_parser_ctx *yangctx = NULL;
1226 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001227 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001228 char *filename, *rev, *dot;
1229 size_t len;
Radek Krejci86d106e2018-10-18 09:53:19 +02001230
Michal Vaskodd992582021-06-10 14:34:57 +02001231 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001232
Michal Vasko7a0b0762020-09-02 16:37:01 +02001233 if (module) {
1234 *module = NULL;
1235 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001236
1237 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001238 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001239 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001240
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001241 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001242 switch (format) {
1243 case LYS_IN_YIN:
Michal Vaskodd992582021-06-10 14:34:57 +02001244 ret = yin_parse_module(&yinctx, in, mod, new_mods);
Michal Vaskob36053d2020-03-26 15:49:30 +01001245 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001246 break;
1247 case LYS_IN_YANG:
Michal Vaskodd992582021-06-10 14:34:57 +02001248 ret = yang_parse_module(&yangctx, in, mod, new_mods);
Michal Vaskob36053d2020-03-26 15:49:30 +01001249 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001250 break;
1251 default:
1252 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001253 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001254 break;
1255 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001256 LY_CHECK_GOTO(ret, free_mod_cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001257
1258 /* make sure that the newest revision is at position 0 */
1259 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001260 if (mod->parsed->revs) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001261 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), free_mod_cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001262 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001263
Radek Krejcib3289d62019-09-18 12:21:39 +02001264 /* decide the latest revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001265 latest = (struct lys_module *)ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001266 if (latest) {
1267 if (mod->revision) {
1268 if (!latest->revision) {
1269 /* latest has no revision, so mod is anyway newer */
1270 mod->latest_revision = latest->latest_revision;
1271 /* the latest is zeroed later when the new module is being inserted into the context */
1272 } else if (strcmp(mod->revision, latest->revision) > 0) {
1273 mod->latest_revision = latest->latest_revision;
1274 /* the latest is zeroed later when the new module is being inserted into the context */
1275 } else {
1276 latest = NULL;
1277 }
1278 } else {
1279 latest = NULL;
1280 }
1281 } else {
1282 mod->latest_revision = 1;
1283 }
1284
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001285 if (custom_check) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001286 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), free_mod_cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001287 }
1288
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001289 /* check whether it is not already in the context in the same revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001290 mod_dup = (struct lys_module *)ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001291 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001292 /* nothing to do */
1293 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1294 mod_dup->revision ? mod_dup->revision : "<none>");
1295 goto free_mod_cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001296 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001297
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001298 switch (in->type) {
1299 case LY_IN_FILEPATH:
1300 /* check that name and revision match filename */
1301 filename = strrchr(in->method.fpath.filepath, '/');
1302 if (!filename) {
1303 filename = in->method.fpath.filepath;
1304 } else {
1305 filename++;
1306 }
1307 rev = strchr(filename, '@');
1308 dot = strrchr(filename, '.');
1309
1310 /* name */
1311 len = strlen(mod->name);
1312 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001313 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001314 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1315 }
1316 if (rev) {
1317 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001318 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001319 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001320 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001321 }
1322 }
1323
1324 break;
1325 case LY_IN_FD:
1326 case LY_IN_FILE:
1327 case LY_IN_MEMORY:
1328 /* nothing special to do */
1329 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001330 case LY_IN_ERROR:
1331 LOGINT(ctx);
1332 ret = LY_EINT;
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001333 goto free_mod_cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001334 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001335 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001336
Michal Vasko7a0b0762020-09-02 16:37:01 +02001337 if (latest) {
1338 latest->latest_revision = 0;
1339 }
1340
Michal Vasko45b521c2020-11-04 17:14:39 +01001341 /* add internal data in case specific modules were parsed */
1342 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001343 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001344 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001345 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001346 }
1347
Michal Vasko405cc9e2020-12-01 12:01:27 +01001348 /* add the module into newly created module set, will also be freed from there on any error */
Michal Vaskodd992582021-06-10 14:34:57 +02001349 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), free_mod_cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001350
Michal Vasko7a0b0762020-09-02 16:37:01 +02001351 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001352 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001353 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001354 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001355
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001356 /* resolve includes and all imports */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001357 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001358
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001359 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001360 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001361 /* TODO groupings */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001362 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1363 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001364
1365 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001366 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001367
Michal Vasko05e32042021-04-23 13:40:56 +02001368 /* pre-compile identities of the module and any submodules */
1369 LY_CHECK_GOTO(ret = lys_identity_precompile(NULL, ctx, mod->parsed, mod->parsed->identities, &mod->identities), cleanup);
1370 LY_ARRAY_FOR(mod->parsed->includes, u) {
1371 submod = mod->parsed->includes[u].submodule;
1372 ret = lys_identity_precompile(NULL, ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
1373 LY_CHECK_GOTO(ret, cleanup);
1374 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001375
Michal Vasko405cc9e2020-12-01 12:01:27 +01001376 /* success */
1377 goto cleanup;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001378
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001379free_mod_cleanup:
Radek Krejci90ed21e2021-04-12 14:47:46 +02001380 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001381 if (ret) {
1382 mod = NULL;
1383 } else {
1384 /* return the existing module */
1385 assert(mod_dup);
1386 mod = mod_dup;
1387 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001388
Michal Vasko405cc9e2020-12-01 12:01:27 +01001389cleanup:
Michal Vasko7a0b0762020-09-02 16:37:01 +02001390 if (pctx) {
1391 ly_set_erase(&pctx->tpdfs_nodes, NULL);
1392 }
1393 if (format == LYS_IN_YANG) {
1394 yang_parser_ctx_free(yangctx);
1395 } else {
1396 yin_parser_ctx_free(yinctx);
1397 }
1398
Michal Vasko405cc9e2020-12-01 12:01:27 +01001399 if (!ret && module) {
1400 *module = mod;
1401 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001402 return ret;
1403}
1404
Radek Krejci545b4872020-11-15 10:15:12 +01001405static LYS_INFORMAT
1406lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1407{
1408 if (!format && (in->type == LY_IN_FILEPATH)) {
1409 /* unknown format - try to detect it from filename's suffix */
1410 const char *path = in->method.fpath.filepath;
1411 size_t len = strlen(path);
1412
1413 /* ignore trailing whitespaces */
1414 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1415
Radek Krejcif13b87b2020-12-01 22:02:17 +01001416 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1417 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001418 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001419 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1420 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001421 format = LYS_IN_YIN;
1422 } /* else still unknown */
1423 }
1424
1425 return format;
1426}
1427
Michal Vasko7a0b0762020-09-02 16:37:01 +02001428API LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001429lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const char **features, const struct lys_module **module)
Michal Vasko7a0b0762020-09-02 16:37:01 +02001430{
Michal Vasko65333882021-06-10 14:12:16 +02001431 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001432 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001433 struct lys_glob_unres unres = {0};
1434
Michal Vasko7a0b0762020-09-02 16:37:01 +02001435 if (module) {
1436 *module = NULL;
1437 }
Radek Krejci545b4872020-11-15 10:15:12 +01001438 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1439
1440 format = lys_parse_get_format(in, format);
1441 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001442
1443 /* remember input position */
1444 in->func_start = in->current;
1445
Michal Vasko4e205e82021-06-08 14:01:47 +02001446 /* parse */
Michal Vaskodd992582021-06-10 14:34:57 +02001447 ret = lys_parse_in(ctx, in, format, NULL, NULL, &unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001448 LY_CHECK_GOTO(ret, cleanup);
1449
1450 /* implement */
Michal Vasko65333882021-06-10 14:12:16 +02001451 ret = _lys_set_implemented(mod, features, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001452 LY_CHECK_GOTO(ret, cleanup);
1453
1454cleanup:
1455 if (ret) {
1456 lys_compile_unres_glob_revert(ctx, &unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001457 } else if (module) {
1458 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001459 }
1460 lys_compile_unres_glob_erase(ctx, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001461 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001462}
1463
Michal Vasko3a41dff2020-07-15 14:30:28 +02001464API LY_ERR
1465lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001466{
Radek Krejci0f969882020-08-21 16:56:47 +02001467 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001468 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001469
Michal Vasko3a41dff2020-07-15 14:30:28 +02001470 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001471
Michal Vasko3a41dff2020-07-15 14:30:28 +02001472 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 +02001473
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001474 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001475 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001476
Michal Vasko3a41dff2020-07-15 14:30:28 +02001477 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001478}
1479
Michal Vasko3a41dff2020-07-15 14:30:28 +02001480API LY_ERR
1481lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001482{
Radek Krejci0f969882020-08-21 16:56:47 +02001483 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001484 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001485
Michal Vasko3a41dff2020-07-15 14:30:28 +02001486 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001487
Michal Vasko3a41dff2020-07-15 14:30:28 +02001488 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 +02001489
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001490 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001491 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001492
Michal Vasko3a41dff2020-07-15 14:30:28 +02001493 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001494}
1495
Michal Vasko3a41dff2020-07-15 14:30:28 +02001496API LY_ERR
1497lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001498{
Radek Krejci0f969882020-08-21 16:56:47 +02001499 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001500 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001501
Michal Vasko3a41dff2020-07-15 14:30:28 +02001502 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001503
Michal Vasko3a41dff2020-07-15 14:30:28 +02001504 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001505 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001506
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001507 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001508 ly_in_free(in, 0);
1509
Michal Vasko3a41dff2020-07-15 14:30:28 +02001510 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001511}
1512
1513API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001514lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001515 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001516{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001517 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001518 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001519 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001520 char *wd, *wn = NULL;
1521 DIR *dir = NULL;
1522 struct dirent *file;
1523 char *match_name = NULL;
1524 LYS_INFORMAT format_aux, match_format = 0;
1525 struct ly_set *dirs;
1526 struct stat st;
1527
1528 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1529
1530 /* start to fill the dir fifo with the context's search path (if set)
1531 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001532 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001533
1534 len = strlen(name);
1535 if (cwd) {
1536 wd = get_current_dir_name();
1537 if (!wd) {
1538 LOGMEM(NULL);
1539 goto cleanup;
1540 } else {
1541 /* add implicit current working directory (./) to be searched,
1542 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001543 ret = ly_set_add(dirs, wd, 0, NULL);
1544 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001545 implicit_cwd = 1;
1546 }
1547 }
1548 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001549 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001550 /* check for duplicities with the implicit current working directory */
1551 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1552 implicit_cwd = 0;
1553 continue;
1554 }
1555 wd = strdup(searchpaths[i]);
1556 if (!wd) {
1557 LOGMEM(NULL);
1558 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001559 } else {
1560 ret = ly_set_add(dirs, wd, 0, NULL);
1561 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001562 }
1563 }
1564 }
1565 wd = NULL;
1566
1567 /* start searching */
1568 while (dirs->count) {
1569 free(wd);
1570 free(wn); wn = NULL;
1571
1572 dirs->count--;
1573 wd = (char *)dirs->objs[dirs->count];
1574 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001575 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001576
1577 if (dir) {
1578 closedir(dir);
1579 }
1580 dir = opendir(wd);
1581 dir_len = strlen(wd);
1582 if (!dir) {
1583 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1584 } else {
1585 while ((file = readdir(dir))) {
1586 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1587 /* skip . and .. */
1588 continue;
1589 }
1590 free(wn);
1591 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1592 LOGMEM(NULL);
1593 goto cleanup;
1594 }
1595 if (stat(wn, &st) == -1) {
1596 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001597 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001598 continue;
1599 }
1600 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1601 /* we have another subdirectory in searchpath to explore,
1602 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001603 ret = ly_set_add(dirs, wn, 0, NULL);
1604 LY_CHECK_GOTO(ret, cleanup);
1605
Radek Krejcid33273d2018-10-25 14:55:52 +02001606 /* continue with the next item in current directory */
1607 wn = NULL;
1608 continue;
1609 } else if (!S_ISREG(st.st_mode)) {
1610 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1611 continue;
1612 }
1613
1614 /* here we know that the item is a file which can contain a module */
1615 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001616 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001617 /* different filename than the module we search for */
1618 continue;
1619 }
1620
1621 /* get type according to filename suffix */
1622 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001623 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1624 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001625 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001626 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1627 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001628 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001629 } else {
1630 /* not supportde suffix/file format */
1631 continue;
1632 }
1633
1634 if (revision) {
1635 /* we look for the specific revision, try to get it from the filename */
1636 if (file->d_name[len] == '@') {
1637 /* check revision from the filename */
1638 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1639 /* another revision */
1640 continue;
1641 } else {
1642 /* exact revision */
1643 free(match_name);
1644 match_name = wn;
1645 wn = NULL;
1646 match_len = dir_len + 1 + len;
1647 match_format = format_aux;
1648 goto success;
1649 }
1650 } else {
1651 /* continue trying to find exact revision match, use this only if not found */
1652 free(match_name);
1653 match_name = wn;
1654 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001655 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001656 match_format = format_aux;
1657 continue;
1658 }
1659 } else {
1660 /* remember the revision and try to find the newest one */
1661 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001662 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01001663 lysp_check_date(NULL, &file->d_name[len + 1],
1664 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001665 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001666 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001667 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1668 continue;
1669 }
1670 free(match_name);
1671 }
1672
1673 match_name = wn;
1674 wn = NULL;
1675 match_len = dir_len + 1 + len;
1676 match_format = format_aux;
1677 continue;
1678 }
1679 }
1680 }
1681 }
1682
1683success:
1684 (*localfile) = match_name;
1685 match_name = NULL;
1686 if (format) {
1687 (*format) = match_format;
1688 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02001689 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02001690
1691cleanup:
1692 free(wn);
1693 free(wd);
1694 if (dir) {
1695 closedir(dir);
1696 }
1697 free(match_name);
1698 ly_set_free(dirs, free);
1699
1700 return ret;
1701}