blob: 67e4804dce9cf61594707406236720b528907bab [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
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Radek Krejcif8dc59a2020-11-25 13:47:44 +010016#define _POSIX_C_SOURCE 200809L /* strdup */
Radek Krejci535ea9f2020-05-29 16:01:05 +020017
Radek Krejcica376bd2020-06-11 16:04:06 +020018#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020019
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <assert.h>
Radek Krejci545b4872020-11-15 10:15:12 +010021#include <ctype.h>
Radek Krejcid33273d2018-10-25 14:55:52 +020022#include <dirent.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020023#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020024#include <stdint.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020025#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <stdlib.h>
27#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020028#include <sys/stat.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020029#include <unistd.h>
Radek Krejci3f5e3db2018-10-11 15:57:47 +020030
Radek Krejcica376bd2020-06-11 16:04:06 +020031#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020032#include "compat.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020033#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020034#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010035#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020036#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010037#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020038#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020039#include "parser_schema.h"
Michal Vasko40308e72020-10-20 16:38:40 +020040#include "path.h"
Radek Krejci6b88a462021-02-17 12:39:34 +010041#include "plugins_exts.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020042#include "schema_compile.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010043#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020044#include "set.h"
45#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010046#include "tree_edit.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020047#include "tree_schema_internal.h"
48#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020049
Radek Krejcieccf6602021-02-05 19:42:54 +010050/**
51 * @brief information about YANG statements
52 */
53struct stmt_info_s stmt_attr_info[] = {
Radek Krejci6b88a462021-02-17 12:39:34 +010054 [LY_STMT_NONE] = {NULL, NULL, 0},
55 [LY_STMT_ACTION] = {"action", "name", STMT_FLAG_ID},
56 [LY_STMT_ANYDATA] = {"anydata", "name", STMT_FLAG_ID},
57 [LY_STMT_ANYXML] = {"anyxml", "name", STMT_FLAG_ID},
58 [LY_STMT_ARGUMENT] = {"argument", "name", STMT_FLAG_ID},
59 [LY_STMT_ARG_TEXT] = {"text", NULL, 0},
60 [LY_STMT_ARG_VALUE] = {"value", NULL, 0},
61 [LY_STMT_AUGMENT] = {"augment", "target-node", STMT_FLAG_ID},
62 [LY_STMT_BASE] = {"base", "name", STMT_FLAG_ID},
63 [LY_STMT_BELONGS_TO] = {"belongs-to", "module", STMT_FLAG_ID},
64 [LY_STMT_BIT] = {"bit", "name", STMT_FLAG_ID},
65 [LY_STMT_CASE] = {"case", "name", STMT_FLAG_ID},
66 [LY_STMT_CHOICE] = {"choice", "name", STMT_FLAG_ID},
67 [LY_STMT_CONFIG] = {"config", "value", STMT_FLAG_ID},
68 [LY_STMT_CONTACT] = {"contact", "text", STMT_FLAG_YIN},
69 [LY_STMT_CONTAINER] = {"container", "name", STMT_FLAG_ID},
70 [LY_STMT_DEFAULT] = {"default", "value", 0},
71 [LY_STMT_DESCRIPTION] = {"description", "text", STMT_FLAG_YIN},
72 [LY_STMT_DEVIATE] = {"deviate", "value", STMT_FLAG_ID},
73 [LY_STMT_DEVIATION] = {"deviation", "target-node", STMT_FLAG_ID},
74 [LY_STMT_ENUM] = {"enum", "name", STMT_FLAG_ID},
75 [LY_STMT_ERROR_APP_TAG] = {"error-app-tag", "value", 0},
76 [LY_STMT_ERROR_MESSAGE] = {"error-message", "value", STMT_FLAG_YIN},
77 [LY_STMT_EXTENSION] = {"extension", "name", STMT_FLAG_ID},
78 [LY_STMT_EXTENSION_INSTANCE] = {NULL, NULL, 0},
79 [LY_STMT_FEATURE] = {"feature", "name", STMT_FLAG_ID},
80 [LY_STMT_FRACTION_DIGITS] = {"fraction-digits", "value", STMT_FLAG_ID},
81 [LY_STMT_GROUPING] = {"grouping", "name", STMT_FLAG_ID},
82 [LY_STMT_IDENTITY] = {"identity", "name", STMT_FLAG_ID},
83 [LY_STMT_IF_FEATURE] = {"if-feature", "name", 0},
84 [LY_STMT_IMPORT] = {"import", "module", STMT_FLAG_ID},
85 [LY_STMT_INCLUDE] = {"include", "module", STMT_FLAG_ID},
86 [LY_STMT_INPUT] = {"input", NULL, 0},
87 [LY_STMT_KEY] = {"key", "value", 0},
88 [LY_STMT_LEAF] = {"leaf", "name", STMT_FLAG_ID},
89 [LY_STMT_LEAF_LIST] = {"leaf-list", "name", STMT_FLAG_ID},
90 [LY_STMT_LENGTH] = {"length", "value", 0},
91 [LY_STMT_LIST] = {"list", "name", STMT_FLAG_ID},
92 [LY_STMT_MANDATORY] = {"mandatory", "value", STMT_FLAG_ID},
93 [LY_STMT_MAX_ELEMENTS] = {"max-elements", "value", STMT_FLAG_ID},
94 [LY_STMT_MIN_ELEMENTS] = {"min-elements", "value", STMT_FLAG_ID},
95 [LY_STMT_MODIFIER] = {"modifier", "value", STMT_FLAG_ID},
96 [LY_STMT_MODULE] = {"module", "name", STMT_FLAG_ID},
97 [LY_STMT_MUST] = {"must", "condition", 0},
98 [LY_STMT_NAMESPACE] = {"namespace", "uri", 0},
99 [LY_STMT_NOTIFICATION] = {"notification", "name", STMT_FLAG_ID},
100 [LY_STMT_ORDERED_BY] = {"ordered-by", "value", STMT_FLAG_ID},
101 [LY_STMT_ORGANIZATION] = {"organization", "text", STMT_FLAG_YIN},
102 [LY_STMT_OUTPUT] = {"output", NULL, 0},
103 [LY_STMT_PATH] = {"path", "value", 0},
104 [LY_STMT_PATTERN] = {"pattern", "value", 0},
105 [LY_STMT_POSITION] = {"position", "value", STMT_FLAG_ID},
106 [LY_STMT_PREFIX] = {"prefix", "value", STMT_FLAG_ID},
107 [LY_STMT_PRESENCE] = {"presence", "value", 0},
108 [LY_STMT_RANGE] = {"range", "value", 0},
109 [LY_STMT_REFERENCE] = {"reference", "text", STMT_FLAG_YIN},
110 [LY_STMT_REFINE] = {"refine", "target-node", STMT_FLAG_ID},
111 [LY_STMT_REQUIRE_INSTANCE] = {"require-instance", "value", STMT_FLAG_ID},
112 [LY_STMT_REVISION] = {"revision", "date", STMT_FLAG_ID},
113 [LY_STMT_REVISION_DATE] = {"revision-date", "date", STMT_FLAG_ID},
114 [LY_STMT_RPC] = {"rpc", "name", STMT_FLAG_ID},
115 [LY_STMT_STATUS] = {"status", "value", STMT_FLAG_ID},
116 [LY_STMT_SUBMODULE] = {"submodule", "name", STMT_FLAG_ID},
117 [LY_STMT_SYNTAX_LEFT_BRACE] = {"{", NULL, 0},
118 [LY_STMT_SYNTAX_RIGHT_BRACE] = {"}", NULL, 0},
119 [LY_STMT_SYNTAX_SEMICOLON] = {";", NULL, 0},
120 [LY_STMT_TYPE] = {"type", "name", STMT_FLAG_ID},
121 [LY_STMT_TYPEDEF] = {"typedef", "name", STMT_FLAG_ID},
122 [LY_STMT_UNIQUE] = {"unique", "tag", 0},
123 [LY_STMT_UNITS] = {"units", "name", 0},
124 [LY_STMT_USES] = {"uses", "name", STMT_FLAG_ID},
125 [LY_STMT_VALUE] = {"value", "value", STMT_FLAG_ID},
126 [LY_STMT_WHEN] = {"when", "condition", 0},
127 [LY_STMT_YANG_VERSION] = {"yang-version", "value", STMT_FLAG_ID},
128 [LY_STMT_YIN_ELEMENT] = {"yin-element", "value", STMT_FLAG_ID},
Radek Krejcieccf6602021-02-05 19:42:54 +0100129};
130
Radek Krejcif8ca8192021-03-02 16:50:06 +0100131API const char *
132ly_stmt2str(enum ly_stmt stmt)
133{
134 return stmt_attr_info[stmt].name;
135}
136
Radek Krejcieccf6602021-02-05 19:42:54 +0100137const char * const ly_devmod_list[] = {
138 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
139 [LYS_DEV_ADD] = "add",
140 [LYS_DEV_DELETE] = "delete",
141 [LYS_DEV_REPLACE] = "replace",
142};
143
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200144API LY_ERR
145lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
146{
Michal Vasko1d972ca2020-11-03 17:16:56 +0100147 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100148 const struct lysc_node_action *action;
149 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200150
151 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
152
153 LYSC_TREE_DFS_BEGIN(root, elem) {
154 /* schema node */
155 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
156
Radek Krejci2a9fc652021-01-22 17:44:34 +0100157 LY_LIST_FOR(lysc_node_actions(elem), action) {
158 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200159 /* action subtree */
160 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
161
Radek Krejci2a9fc652021-01-22 17:44:34 +0100162 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200163 }
164 }
165
Radek Krejci2a9fc652021-01-22 17:44:34 +0100166 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
167 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200168 /* notification subtree */
169 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
170
Radek Krejci2a9fc652021-01-22 17:44:34 +0100171 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200172 }
173 }
174
175 LYSC_TREE_DFS_END(root, elem);
176 }
177
178 return LY_SUCCESS;
179}
180
181API LY_ERR
182lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
183{
Michal Vasko2336cf52020-11-03 17:18:15 +0100184 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200185
186 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
187
188 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100189 LY_LIST_FOR(mod->compiled->data, root) {
190 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
191 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200192
193 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100194 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
195 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200196 }
197
198 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100199 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
200 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200201 }
202
203 return LY_SUCCESS;
204}
205
Radek Krejcib93bd412020-11-02 13:23:11 +0100206static void
207lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
208{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100209 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100210 if (first_case->child) {
211 /* there is something to return */
212 (*next) = first_case->child;
213 return;
214 }
215 }
216
217 /* no children in choice's cases, so go to the choice's sibling instead of into it */
218 (*last) = (*next);
219 (*next) = (*next)->next;
220}
221
Radek Krejci035dacf2021-02-12 18:25:53 +0100222/**
223 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
224 *
225 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
226 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
227 * extension instance.
228 *
229 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
230 * and function starts returning i) the first \p parent's child or ii) the first top level element specified in the
231 * given extension (if provided) or iii) the first top level element of the \p module.
232 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
233 * \p parent and \p module parameters.
234 *
235 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
236 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
237 * all the schema nodes are iteratively returned.
238 *
239 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
240 * @param[in] parent Parent of the subtree where the function starts processing.
241 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
242 * module must be specified.
243 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
244 * the \p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
245 * @param[in] options [ORed options](@ref sgetnextflags).
246 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
247 */
248static const struct lysc_node *
249lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
250 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100251{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100252 const struct lysc_node *next = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200253 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci035dacf2021-02-12 18:25:53 +0100254 struct lysc_node **data_p = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100255
Radek Krejci035dacf2021-02-12 18:25:53 +0100256 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100257
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200258next:
Radek Krejcia3045382018-11-22 14:30:31 +0100259 if (!last) {
260 /* first call */
261
262 /* get know where to start */
263 if (parent) {
264 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100265 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100266 } else {
267 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100268 if (ext) {
269 lysc_ext_substmt(ext, LY_STMT_CONTAINER /* matches all nodes */, (void **)&data_p, NULL);
270 next = last = data_p ? *data_p : NULL;
271 } else {
272 next = last = module->data;
273 }
Radek Krejcia3045382018-11-22 14:30:31 +0100274 }
275 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100276 /* try to get action or notification */
277 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100278 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100279 /* test if the next can be returned */
280 goto check;
281
Michal Vasko1bf09392020-03-27 12:38:10 +0100282 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100283 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100284 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100285 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100286 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100287 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200288 } else {
289 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100290 }
291
Radek Krejcia3045382018-11-22 14:30:31 +0100292repeat:
293 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100294 /* possibly go back to parent */
Radek Krejci035dacf2021-02-12 18:25:53 +0100295 data_p = NULL;
Michal Vasko69730152020-10-09 16:30:07 +0200296 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100297 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200298 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100299 } else if (!action_flag) {
300 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100301 if (ext) {
302 lysc_ext_substmt(ext, LY_STMT_RPC /* matches also actions */, (void **)&data_p, NULL);
303 next = data_p ? *data_p : NULL;
304 } else if (parent) {
305 next = (struct lysc_node *)lysc_node_actions(parent);
306 } else {
307 next = (struct lysc_node *)module->rpcs;
308 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100309 } else if (!notif_flag) {
310 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100311 if (ext) {
312 lysc_ext_substmt(ext, LY_STMT_NOTIFICATION, (void **)&data_p, NULL);
313 next = data_p ? *data_p : NULL;
314 } else if (parent) {
315 next = (struct lysc_node *)lysc_node_notifs(parent);
316 } else {
317 next = (struct lysc_node *)module->notifs;
318 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100319 } else {
320 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100321 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100322 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100323 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100324check:
Radek Krejcia3045382018-11-22 14:30:31 +0100325 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100326 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100327 case LYS_ACTION:
328 case LYS_NOTIF:
329 case LYS_LEAF:
330 case LYS_ANYXML:
331 case LYS_ANYDATA:
332 case LYS_LIST:
333 case LYS_LEAFLIST:
334 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200335 case LYS_CASE:
336 if (options & LYS_GETNEXT_WITHCASE) {
337 break;
338 } else {
339 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100340 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200341 }
342 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100343 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100344 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100345 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100346 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100347 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100348 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100349 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100350 next = next->next;
351 }
352 goto repeat;
353 }
354 break;
355 case LYS_CHOICE:
356 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200357 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100358 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100359 next = next->next;
360 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100361 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100362 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100363 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100364 /* go into */
365 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100366 }
Radek Krejcia3045382018-11-22 14:30:31 +0100367 }
368 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100369 case LYS_INPUT:
370 if (options & LYS_GETNEXT_OUTPUT) {
371 /* skip */
372 next = next->next;
373 } else {
374 /* go into */
375 next = lysc_node_child(next);
376 }
377 goto repeat;
378 case LYS_OUTPUT:
379 if (!(options & LYS_GETNEXT_OUTPUT)) {
380 /* skip */
381 next = next->next;
382 } else {
383 /* go into */
384 next = lysc_node_child(next);
385 }
386 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100387 default:
388 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100389 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100390 return NULL;
391 }
392
Radek Krejcia3045382018-11-22 14:30:31 +0100393 return next;
394}
395
396API const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100397lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
398{
399 return lys_getnext_(last, parent, module, NULL, options);
400}
401
402API const struct lysc_node *
403lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
404{
405 return lys_getnext_(last, parent, NULL, ext, options);
406}
407
Radek Krejcif16e2542021-02-17 15:39:23 +0100408const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100409lysc_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 +0100410 uint16_t nodetype, uint32_t options)
411{
412 const struct lysc_node *node = NULL;
413
414 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
415 if (!nodetype) {
416 nodetype = LYS_NODETYPE_MASK;
417 }
418
419 if (module && (module != ext->module)) {
420 return NULL;
421 }
422
423 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
424 if (!(node->nodetype & nodetype)) {
425 continue;
426 }
427
428 if (name_len) {
429 if (!ly_strncmp(node->name, name, name_len)) {
430 return node;
431 }
432 } else {
433 if (!strcmp(node->name, name)) {
434 return node;
435 }
436 }
437 }
438 return NULL;
439}
440
Radek Krejci035dacf2021-02-12 18:25:53 +0100441API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100442lys_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 +0200443 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100444{
445 const struct lysc_node *node = NULL;
446
447 LY_CHECK_ARG_RET(NULL, module, name, NULL);
448 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100449 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100450 }
451
452 while ((node = lys_getnext(node, parent, module->compiled, options))) {
453 if (!(node->nodetype & nodetype)) {
454 continue;
455 }
456 if (node->module != module) {
457 continue;
458 }
459
460 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200461 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100462 return node;
463 }
464 } else {
465 if (!strcmp(node->name, name)) {
466 return node;
467 }
468 }
469 }
470 return NULL;
471}
472
Michal Vasko519fd602020-05-26 12:17:39 +0200473API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100474lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
475 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200476{
477 LY_ERR ret = LY_SUCCESS;
478 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200479 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200480 uint32_t i;
481
Michal Vasko26512682021-01-11 11:35:40 +0100482 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200483 if (!(options & LYXP_SCNODE_ALL)) {
484 options = LYXP_SCNODE;
485 }
Michal Vasko26512682021-01-11 11:35:40 +0100486 if (!ctx) {
487 ctx = ctx_node->module->ctx;
488 }
Michal Vasko519fd602020-05-26 12:17:39 +0200489
490 memset(&xp_set, 0, sizeof xp_set);
491
492 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100493 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200494 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200495
496 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100497 ret = lyxp_atomize(ctx, exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200498 LY_CHECK_GOTO(ret, cleanup);
499
500 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200501 ret = ly_set_new(set);
502 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200503
504 /* transform into ly_set */
505 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100506 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200507 (*set)->size = xp_set.used;
508
509 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200510 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200511 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200512 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200513 }
514 }
515
516cleanup:
517 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100518 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200519 return ret;
520}
521
Michal Vasko072de482020-08-05 13:27:21 +0200522API LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200523lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
524 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
525{
526 LY_ERR ret = LY_SUCCESS;
527 struct lyxp_set xp_set = {0};
528 uint32_t i;
529
530 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
531 if (!(options & LYXP_SCNODE_ALL)) {
532 options = LYXP_SCNODE;
533 }
534
535 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100536 ret = lyxp_atomize(cur_mod->ctx, expr, cur_mod, LY_PREF_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, &xp_set, options);
Michal Vasko40308e72020-10-20 16:38:40 +0200537 LY_CHECK_GOTO(ret, cleanup);
538
539 /* allocate return set */
540 ret = ly_set_new(set);
541 LY_CHECK_GOTO(ret, cleanup);
542
543 /* transform into ly_set */
544 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
545 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
546 (*set)->size = xp_set.used;
547
548 for (i = 0; i < xp_set.used; ++i) {
Michal Vaskod97959c2020-12-10 12:18:28 +0100549 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM)) {
550 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM) ||
551 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200552 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
553 LY_CHECK_GOTO(ret, cleanup);
554 }
555 }
556
557cleanup:
558 lyxp_set_free_content(&xp_set);
559 if (ret) {
560 ly_set_free(*set, NULL);
561 *set = NULL;
562 }
563 return ret;
564}
565
566API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100567lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
568 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200569{
570 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200571 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200572 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200573 uint32_t i;
574
Michal Vasko26512682021-01-11 11:35:40 +0100575 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200576 if (!(options & LYXP_SCNODE_ALL)) {
577 options = LYXP_SCNODE;
578 }
Michal Vasko26512682021-01-11 11:35:40 +0100579 if (!ctx) {
580 ctx = ctx_node->module->ctx;
581 }
Michal Vasko072de482020-08-05 13:27:21 +0200582
Michal Vasko072de482020-08-05 13:27:21 +0200583 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100584 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200585 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200586
587 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100588 ret = lyxp_atomize(ctx, exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200589 LY_CHECK_GOTO(ret, cleanup);
590
591 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200592 ret = ly_set_new(set);
593 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200594
595 /* transform into ly_set */
596 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100597 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200598 (*set)->size = xp_set.used;
599
600 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100601 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 +0200602 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200603 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200604 }
605 }
606
607cleanup:
608 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100609 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200610 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200611 ly_set_free(*set, NULL);
612 *set = NULL;
613 }
Michal Vasko072de482020-08-05 13:27:21 +0200614 return ret;
615}
616
Radek Krejcibc5644c2020-10-27 14:53:17 +0100617API LY_ERR
618lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
619{
620 LY_ERR ret = LY_SUCCESS;
621 LY_ARRAY_COUNT_TYPE u, v;
622
623 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
624
625 /* allocate return set */
626 LY_CHECK_RET(ly_set_new(set));
627
628 LY_ARRAY_FOR(path, u) {
629 /* add nodes from the path */
630 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
631 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
632 LY_ARRAY_FOR(path[u].predicates, v) {
633 /* add all the keys in a predicate */
634 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
635 }
636 }
637 }
638
639cleanup:
640 if (ret) {
641 ly_set_free(*set, NULL);
642 *set = NULL;
643 }
644 return ret;
645}
646
647API LY_ERR
648lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
649 struct ly_set **set)
650{
651 LY_ERR ret = LY_SUCCESS;
652 uint8_t oper;
653 struct lyxp_expr *expr = NULL;
654 struct ly_path *p = NULL;
655
656 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
657
658 if (!ctx) {
659 ctx = ctx_node->module->ctx;
660 }
661
662 /* parse */
663 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
664 LY_CHECK_GOTO(ret, cleanup);
665
666 /* compile */
667 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100668 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100669 LY_PREF_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100670 LY_CHECK_GOTO(ret, cleanup);
671
672 /* resolve */
673 ret = lys_find_lypath_atoms(p, set);
674
675cleanup:
676 ly_path_free(ctx, p);
677 lyxp_expr_free(ctx, expr);
678 return ret;
679}
680
681API const struct lysc_node *
682lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
683{
684 const struct lysc_node *snode = NULL;
685 struct lyxp_expr *exp = NULL;
686 struct ly_path *p = NULL;
687 LY_ERR ret;
688 uint8_t oper;
689
690 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
691
692 if (!ctx) {
693 ctx = ctx_node->module->ctx;
694 }
695
696 /* parse */
697 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
698 LY_CHECK_GOTO(ret, cleanup);
699
700 /* compile */
701 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100702 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, exp, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100703 LY_PREF_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100704 LY_CHECK_GOTO(ret, cleanup);
705
706 /* get last node */
707 snode = p[LY_ARRAY_COUNT(p) - 1].node;
708
709cleanup:
710 ly_path_free(ctx, p);
711 lyxp_expr_free(ctx, exp);
712 return snode;
713}
714
Michal Vasko14654712020-02-06 08:35:21 +0100715char *
716lysc_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 +0200717 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200718{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200719 const struct lysc_node *iter;
Radek Krejci327de162019-06-14 12:52:07 +0200720 char *path = NULL;
721 int len = 0;
722
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200723 if (buffer) {
724 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100725 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200726 }
727
Radek Krejci327de162019-06-14 12:52:07 +0200728 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200729 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200730 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100731 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200732 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100733 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200734
Michal Vasko721b6f62021-02-08 08:52:53 +0100735 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200736 /* schema-only node */
737 continue;
738 }
739
Michal Vasko11deea12020-08-05 13:54:50 +0200740 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200741 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100742 if (parent && (iter->parent == parent)) {
743 slash = "";
744 } else {
745 slash = "/";
746 }
Michal Vasko69730152020-10-09 16:30:07 +0200747 if (!iter->parent || (iter->parent->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200748 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200749 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100750 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200751 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100752 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200753 }
Radek Krejci327de162019-06-14 12:52:07 +0200754 } else {
755 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200756 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100757 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200758 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100759 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200760 }
Radek Krejci327de162019-06-14 12:52:07 +0200761 }
762 free(s);
763 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200764
Michal Vasko69730152020-10-09 16:30:07 +0200765 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200766 /* not enough space in buffer */
767 break;
768 }
Radek Krejci327de162019-06-14 12:52:07 +0200769 }
770
771 if (len < 0) {
772 free(path);
773 path = NULL;
774 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200775 if (buffer) {
776 strcpy(buffer, "/");
777 } else {
778 path = strdup("/");
779 }
Radek Krejci327de162019-06-14 12:52:07 +0200780 }
781 break;
782 }
783
Radek Krejci1c0c3442019-07-23 16:08:47 +0200784 if (buffer) {
785 return buffer;
786 } else {
787 return path;
788 }
Radek Krejci327de162019-06-14 12:52:07 +0200789}
790
Michal Vasko14654712020-02-06 08:35:21 +0100791API char *
792lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
793{
794 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
795}
796
Michal Vasko405cc9e2020-12-01 12:01:27 +0100797LY_ERR
798lys_set_implemented_r(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200799{
800 struct lys_module *m;
801
Michal Vasko405cc9e2020-12-01 12:01:27 +0100802 assert(!mod->implemented);
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200803
804 /* we have module from the current context */
805 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
806 if (m) {
Michal Vasko89b5c072020-10-06 13:52:44 +0200807 assert(m != mod);
808
809 /* check collision with other implemented revision */
810 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
811 mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
812 return LY_EDENIED;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200813 }
814
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100815 /* enable features */
816 LY_CHECK_RET(lys_enable_features(mod->parsed, features));
817
Michal Vasko89b5c072020-10-06 13:52:44 +0200818 /* add the module into newly implemented module set */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100819 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
Michal Vasko89b5c072020-10-06 13:52:44 +0200820
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200821 /* mark the module implemented, check for collision was already done */
Michal Vasko89b5c072020-10-06 13:52:44 +0200822 mod->implemented = 1;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200823
824 /* compile the schema */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100825 return lys_compile(mod, 0, unres);
826}
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200827
Michal Vasko405cc9e2020-12-01 12:01:27 +0100828API LY_ERR
829lys_set_implemented(struct lys_module *mod, const char **features)
830{
831 LY_ERR ret = LY_SUCCESS, r;
832 struct lys_glob_unres unres = {0};
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200833
Michal Vasko405cc9e2020-12-01 12:01:27 +0100834 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
Michal Vasko916aefb2020-11-02 15:43:16 +0100835
Michal Vasko405cc9e2020-12-01 12:01:27 +0100836 if (mod->implemented) {
837 /* mod is already implemented, set the features */
838 r = lys_set_features(mod->parsed, features);
839 if (r == LY_EEXIST) {
840 /* no changes */
841 return LY_SUCCESS;
842 } else if (r) {
843 /* error */
844 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200845 }
846
Michal Vasko405cc9e2020-12-01 12:01:27 +0100847 /* full recompilation */
848 return lys_recompile(mod->ctx, 1);
Michal Vasko89b5c072020-10-06 13:52:44 +0200849 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100850
Michal Vasko405cc9e2020-12-01 12:01:27 +0100851 /* implement this module and any other required modules, recursively */
852 ret = lys_set_implemented_r(mod, features, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100853
854 /* the first module being implemented is finished, resolve global unres, consolidate the set */
855 if (!ret) {
856 ret = lys_compile_unres_glob(mod->ctx, &unres);
857 }
858 if (ret) {
859 /* failure, full compile revert */
860 lys_compile_unres_glob_revert(mod->ctx, &unres);
861 }
862
863 lys_compile_unres_glob_erase(mod->ctx, &unres);
Michal Vasko89b5c072020-10-06 13:52:44 +0200864 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200865}
866
Michal Vasko7c8439f2020-08-05 13:25:19 +0200867static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100868lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
Michal Vasko7c8439f2020-08-05 13:25:19 +0200869{
870 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200871 LY_ARRAY_COUNT_TYPE u, v;
872
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100873 pmod->parsing = 1;
874 LY_ARRAY_FOR(pmod->imports, u) {
875 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +0200876 if (!imp->module) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100877 LY_CHECK_RET(lysp_load_module(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, 0, NULL,
878 pctx->unres, &imp->module));
Michal Vasko7c8439f2020-08-05 13:25:19 +0200879 }
880 /* check for importing the same module twice */
881 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100882 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200883 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
884 }
885 }
886 }
Radek Krejci771928a2021-01-19 13:42:36 +0100887 LY_CHECK_RET(lysp_load_submodules(pctx, pmod));
888
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100889 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200890
891 return LY_SUCCESS;
892}
893
Michal Vasko3a41dff2020-07-15 14:30:28 +0200894LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +0200895lys_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 +0200896 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
Radek Krejci0f969882020-08-21 16:56:47 +0200897 void *check_data, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200898{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200899 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100900 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +0100901 struct lys_yang_parser_ctx *yangctx = NULL;
902 struct lys_yin_parser_ctx *yinctx = NULL;
903 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100904
Michal Vasko3a41dff2020-07-15 14:30:28 +0200905 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100906
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100907 switch (format) {
908 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +0200909 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100910 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100911 break;
912 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +0200913 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100914 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100915 break;
916 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +0200917 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +0200918 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100919 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200920 }
Radek Krejcif6923e82020-07-02 16:36:53 +0200921 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +0200922 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100923
924 /* make sure that the newest revision is at position 0 */
925 lysp_sort_revisions(submod->revs);
926
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100927 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +0100928 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100929 if (latest_sp) {
930 if (submod->revs) {
931 if (!latest_sp->revs) {
932 /* latest has no revision, so mod is anyway newer */
933 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +0200934 /* the latest_sp is zeroed later when the new module is being inserted into the context */
935 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
936 submod->latest_revision = latest_sp->latest_revision;
937 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100938 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +0200939 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100940 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200941 } else {
942 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100943 }
944 } else {
945 submod->latest_revision = 1;
946 }
947
Radek Krejcib3289d62019-09-18 12:21:39 +0200948 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200949 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +0200950 }
951
952 if (latest_sp) {
953 latest_sp->latest_revision = 0;
954 }
955
Michal Vasko7a0b0762020-09-02 16:37:01 +0200956 lys_parser_fill_filepath(ctx, in, &submod->filepath);
957
Michal Vasko7c8439f2020-08-05 13:25:19 +0200958 /* resolve imports and includes */
959 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod), error);
960
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100961 /* remap possibly changed and reallocated typedefs and groupings list back to the main context */
Michal Vaskob36053d2020-03-26 15:49:30 +0100962 memcpy(&main_ctx->tpdfs_nodes, &pctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
963 memcpy(&main_ctx->grps_nodes, &pctx->grps_nodes, sizeof main_ctx->grps_nodes);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100964
David Sedlák1b623122019-08-05 15:27:49 +0200965 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100966 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200967 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100968 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200969 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200970 *submodule = submod;
971 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +0200972
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100973error:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200974 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +0200975 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100976 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200977 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100978 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200979 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200980 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200981}
982
Michal Vasko45b521c2020-11-04 17:14:39 +0100983/**
984 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
985 *
986 * @param[in] mod Parsed module to add to.
987 * @return LY_SUCCESS on success.
988 * @return LY_ERR on error.
989 */
990static LY_ERR
991lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
992{
993 struct lysp_ext_instance *ext_p;
994 struct lysp_stmt *stmt;
995 struct lysp_import *imp;
996
997 /*
998 * 1) edit-config's operation
999 */
1000 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1001 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1002 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1003 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001004 ext_p->format = LY_PREF_SCHEMA;
1005 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001006 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001007 ext_p->parent_stmt = LY_STMT_MODULE;
1008 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001009
1010 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1011 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1012 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1013 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001014 stmt->format = LY_PREF_SCHEMA;
1015 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001016 stmt->kw = LY_STMT_TYPE;
1017
1018 stmt->child = calloc(1, sizeof *stmt->child);
1019 stmt = stmt->child;
1020 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1021 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1022 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001023 stmt->format = LY_PREF_SCHEMA;
1024 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001025 stmt->kw = LY_STMT_ENUM;
1026
1027 stmt->next = calloc(1, sizeof *stmt->child);
1028 stmt = stmt->next;
1029 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1030 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1031 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001032 stmt->format = LY_PREF_SCHEMA;
1033 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001034 stmt->kw = LY_STMT_ENUM;
1035
1036 stmt->next = calloc(1, sizeof *stmt->child);
1037 stmt = stmt->next;
1038 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1039 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1040 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001041 stmt->format = LY_PREF_SCHEMA;
1042 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001043 stmt->kw = LY_STMT_ENUM;
1044
1045 stmt->next = calloc(1, sizeof *stmt->child);
1046 stmt = stmt->next;
1047 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1048 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1049 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001050 stmt->format = LY_PREF_SCHEMA;
1051 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001052 stmt->kw = LY_STMT_ENUM;
1053
1054 stmt->next = calloc(1, sizeof *stmt->child);
1055 stmt = stmt->next;
1056 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1057 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1058 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001059 stmt->format = LY_PREF_SCHEMA;
1060 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001061 stmt->kw = LY_STMT_ENUM;
1062
1063 /*
1064 * 2) filter's type
1065 */
1066 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1067 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1068 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1069 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001070 ext_p->format = LY_PREF_SCHEMA;
1071 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001072 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001073 ext_p->parent_stmt = LY_STMT_MODULE;
1074 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001075
1076 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1077 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1078 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1079 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001080 stmt->format = LY_PREF_SCHEMA;
1081 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001082 stmt->kw = LY_STMT_TYPE;
1083
1084 stmt->child = calloc(1, sizeof *stmt->child);
1085 stmt = stmt->child;
1086 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1087 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1088 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001089 stmt->format = LY_PREF_SCHEMA;
1090 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001091 stmt->kw = LY_STMT_ENUM;
1092
1093 stmt->next = calloc(1, sizeof *stmt->child);
1094 stmt = stmt->next;
1095 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1096 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1097 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001098 stmt->format = LY_PREF_SCHEMA;
1099 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001100 stmt->kw = LY_STMT_ENUM;
1101
1102 /* if-feature for enum allowed only for YANG 1.1 modules */
1103 if (mod->version >= LYS_VERSION_1_1) {
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, "if-feature", 0, &stmt->stmt));
1108 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001109 stmt->format = LY_PREF_SCHEMA;
1110 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001111 stmt->kw = LY_STMT_IF_FEATURE;
1112 }
1113
1114 /*
1115 * 3) filter's select
1116 */
1117 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1118 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1119 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1120 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001121 ext_p->format = LY_PREF_SCHEMA;
1122 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001123 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001124 ext_p->parent_stmt = LY_STMT_MODULE;
1125 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001126
1127 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1128 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1129 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1130 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001131 stmt->format = LY_PREF_SCHEMA;
1132 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001133 stmt->kw = LY_STMT_TYPE;
1134
1135 /* create new imports for the used prefixes */
1136 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1137
1138 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1139 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1140 imp->flags = LYS_INTERNAL;
1141
1142 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1143
1144 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1145 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1146 imp->flags = LYS_INTERNAL;
1147
1148 return LY_SUCCESS;
1149}
1150
1151/**
1152 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1153 *
1154 * @param[in] mod Parsed module to add to.
1155 * @return LY_SUCCESS on success.
1156 * @return LY_ERR on error.
1157 */
1158static LY_ERR
1159lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1160{
1161 struct lysp_ext_instance *ext_p;
1162 struct lysp_stmt *stmt;
1163 struct lysp_import *imp;
1164
1165 /* add new extension instance */
1166 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1167
1168 /* fill in the extension instance fields */
1169 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1170 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1171 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001172 ext_p->format = LY_PREF_SCHEMA;
1173 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001174 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001175 ext_p->parent_stmt = LY_STMT_MODULE;
1176 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001177
1178 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1179 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1180 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1181 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001182 stmt->format = LY_PREF_SCHEMA;
1183 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001184 stmt->kw = LY_STMT_TYPE;
1185
1186 /* create new import for the used prefix */
1187 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1188
1189 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1190 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1191 imp->flags = LYS_INTERNAL;
1192
1193 return LY_SUCCESS;
1194}
1195
Michal Vasko3a41dff2020-07-15 14:30:28 +02001196LY_ERR
Michal Vasko34e334d2021-01-25 16:12:31 +01001197lys_create_module(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, ly_bool need_implemented,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001198 LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
Michal Vasko405cc9e2020-12-01 12:01:27 +01001199 void *check_data, const char **features, struct lys_glob_unres *unres, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001200{
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001201 struct lys_module *mod = NULL, *latest, *mod_dup, *mod_impl;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001202 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001203 LY_ERR ret;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001204 LY_ARRAY_COUNT_TYPE u;
Michal Vaskob36053d2020-03-26 15:49:30 +01001205 struct lys_yang_parser_ctx *yangctx = NULL;
1206 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001207 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001208 char *filename, *rev, *dot;
1209 size_t len;
Michal Vasko34e334d2021-01-25 16:12:31 +01001210 ly_bool implement;
Radek Krejci86d106e2018-10-18 09:53:19 +02001211
Michal Vasko34e334d2021-01-25 16:12:31 +01001212 assert(ctx && in && (!features || need_implemented) && unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001213
Michal Vasko7a0b0762020-09-02 16:37:01 +02001214 if (module) {
1215 *module = NULL;
1216 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001217
Michal Vasko34e334d2021-01-25 16:12:31 +01001218 if (ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
1219 implement = 1;
1220 } else {
1221 implement = need_implemented;
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001222 }
Michal Vasko34e334d2021-01-25 16:12:31 +01001223
Radek Krejci86d106e2018-10-18 09:53:19 +02001224 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001225 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001226 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001227
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001228 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001229 switch (format) {
1230 case LYS_IN_YIN:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001231 ret = yin_parse_module(&yinctx, in, mod, unres);
Michal Vaskob36053d2020-03-26 15:49:30 +01001232 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001233 break;
1234 case LYS_IN_YANG:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001235 ret = yang_parse_module(&yangctx, in, mod, unres);
Michal Vaskob36053d2020-03-26 15:49:30 +01001236 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001237 break;
1238 default:
1239 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001240 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001241 break;
1242 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001243 LY_CHECK_GOTO(ret, free_mod_cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001244
1245 /* make sure that the newest revision is at position 0 */
1246 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001247 if (mod->parsed->revs) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001248 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 +01001249 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001250
Radek Krejcib3289d62019-09-18 12:21:39 +02001251 /* decide the latest revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001252 latest = (struct lys_module *)ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001253 if (latest) {
1254 if (mod->revision) {
1255 if (!latest->revision) {
1256 /* latest has no revision, so mod is anyway newer */
1257 mod->latest_revision = latest->latest_revision;
1258 /* the latest is zeroed later when the new module is being inserted into the context */
1259 } else if (strcmp(mod->revision, latest->revision) > 0) {
1260 mod->latest_revision = latest->latest_revision;
1261 /* the latest is zeroed later when the new module is being inserted into the context */
1262 } else {
1263 latest = NULL;
1264 }
1265 } else {
1266 latest = NULL;
1267 }
1268 } else {
1269 mod->latest_revision = 1;
1270 }
1271
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001272 if (custom_check) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001273 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), free_mod_cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001274 }
1275
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001276 /* check whether it is not already in the context in the same revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001277 mod_dup = (struct lys_module *)ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001278 if (implement) {
1279 mod_impl = ly_ctx_get_module_implemented(ctx, mod->name);
1280 if (mod_impl && (mod_impl != mod_dup)) {
1281 LOGERR(ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in the context.", mod_impl->name,
1282 mod_impl->revision ? mod_impl->revision : "<none>");
1283 ret = LY_EDENIED;
1284 goto free_mod_cleanup;
Radek Krejcid33273d2018-10-25 14:55:52 +02001285 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001286 }
1287 if (mod_dup) {
1288 if (implement) {
1289 if (!mod_dup->implemented) {
1290 /* just implement it */
1291 LY_CHECK_GOTO(ret = lys_set_implemented_r(mod_dup, features, unres), free_mod_cleanup);
1292 goto free_mod_cleanup;
1293 }
1294
1295 /* nothing to do */
1296 LOGVRB("Module \"%s@%s\" is already implemented in the context.", mod_dup->name,
1297 mod_dup->revision ? mod_dup->revision : "<none>");
1298 goto free_mod_cleanup;
1299 }
1300
1301 /* nothing to do */
1302 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1303 mod_dup->revision ? mod_dup->revision : "<none>");
1304 goto free_mod_cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001305 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001306
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001307 switch (in->type) {
1308 case LY_IN_FILEPATH:
1309 /* check that name and revision match filename */
1310 filename = strrchr(in->method.fpath.filepath, '/');
1311 if (!filename) {
1312 filename = in->method.fpath.filepath;
1313 } else {
1314 filename++;
1315 }
1316 rev = strchr(filename, '@');
1317 dot = strrchr(filename, '.');
1318
1319 /* name */
1320 len = strlen(mod->name);
1321 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001322 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001323 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1324 }
1325 if (rev) {
1326 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001327 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001328 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001329 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001330 }
1331 }
1332
1333 break;
1334 case LY_IN_FD:
1335 case LY_IN_FILE:
1336 case LY_IN_MEMORY:
1337 /* nothing special to do */
1338 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001339 case LY_IN_ERROR:
1340 LOGINT(ctx);
1341 ret = LY_EINT;
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001342 goto free_mod_cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001343 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001344 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001345
Michal Vasko7a0b0762020-09-02 16:37:01 +02001346 if (latest) {
1347 latest->latest_revision = 0;
1348 }
1349
Michal Vasko45b521c2020-11-04 17:14:39 +01001350 /* add internal data in case specific modules were parsed */
1351 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001352 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001353 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001354 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001355 }
1356
Michal Vasko405cc9e2020-12-01 12:01:27 +01001357 /* add the module into newly created module set, will also be freed from there on any error */
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001358 LY_CHECK_GOTO(ret = ly_set_add(&unres->creating, mod, 1, NULL), free_mod_cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001359
Michal Vasko7a0b0762020-09-02 16:37:01 +02001360 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001361 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001362 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001363 ctx->module_set_id++;
1364
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001365 /* resolve includes and all imports */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001366 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001367
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001368 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001369 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001370 /* TODO groupings */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001371 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1372 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001373
1374 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001375 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001376
Michal Vasko89b5c072020-10-06 13:52:44 +02001377 if (!implement) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001378 /* pre-compile identities of the module */
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001379 LY_CHECK_GOTO(ret = lys_identity_precompile(NULL, ctx, mod->parsed, mod->parsed->identities, &mod->identities), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001380
1381 /* pre-compile identities of any submodules */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001382 LY_ARRAY_FOR(mod->parsed->includes, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001383 submod = mod->parsed->includes[u].submodule;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001384 ret = lys_identity_precompile(NULL, ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001385 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001386 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001387 } else {
Michal Vasko89b5c072020-10-06 13:52:44 +02001388 /* implement (compile) */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001389 LY_CHECK_GOTO(ret = lys_set_implemented_r(mod, features, unres), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001390 }
1391
Michal Vasko405cc9e2020-12-01 12:01:27 +01001392 /* success */
1393 goto cleanup;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001394
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001395free_mod_cleanup:
Michal Vasko7a0b0762020-09-02 16:37:01 +02001396 lys_module_free(mod, NULL);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001397 if (ret) {
1398 mod = NULL;
1399 } else {
1400 /* return the existing module */
1401 assert(mod_dup);
1402 mod = mod_dup;
1403 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001404
Michal Vasko405cc9e2020-12-01 12:01:27 +01001405cleanup:
Michal Vasko7a0b0762020-09-02 16:37:01 +02001406 if (pctx) {
1407 ly_set_erase(&pctx->tpdfs_nodes, NULL);
1408 }
1409 if (format == LYS_IN_YANG) {
1410 yang_parser_ctx_free(yangctx);
1411 } else {
1412 yin_parser_ctx_free(yinctx);
1413 }
1414
Michal Vasko405cc9e2020-12-01 12:01:27 +01001415 if (!ret && module) {
1416 *module = mod;
1417 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001418 return ret;
1419}
1420
Radek Krejci545b4872020-11-15 10:15:12 +01001421static LYS_INFORMAT
1422lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1423{
1424 if (!format && (in->type == LY_IN_FILEPATH)) {
1425 /* unknown format - try to detect it from filename's suffix */
1426 const char *path = in->method.fpath.filepath;
1427 size_t len = strlen(path);
1428
1429 /* ignore trailing whitespaces */
1430 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1431
Radek Krejcif13b87b2020-12-01 22:02:17 +01001432 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1433 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001434 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001435 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1436 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001437 format = LYS_IN_YIN;
1438 } /* else still unknown */
1439 }
1440
1441 return format;
1442}
1443
Michal Vasko7a0b0762020-09-02 16:37:01 +02001444API LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001445lys_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 +02001446{
Michal Vasko405cc9e2020-12-01 12:01:27 +01001447 LY_ERR ret;
1448 struct lys_glob_unres unres = {0};
1449
Michal Vasko7a0b0762020-09-02 16:37:01 +02001450 if (module) {
1451 *module = NULL;
1452 }
Radek Krejci545b4872020-11-15 10:15:12 +01001453 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1454
1455 format = lys_parse_get_format(in, format);
1456 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001457
1458 /* remember input position */
1459 in->func_start = in->current;
1460
Michal Vasko405cc9e2020-12-01 12:01:27 +01001461 ret = lys_create_module(ctx, in, format, 1, NULL, NULL, features, &unres, (struct lys_module **)module);
1462 LY_CHECK_GOTO(ret, cleanup);
1463
1464 /* resolve global unres */
1465 ret = lys_compile_unres_glob(ctx, &unres);
1466 LY_CHECK_GOTO(ret, cleanup);
1467
1468cleanup:
1469 if (ret) {
1470 lys_compile_unres_glob_revert(ctx, &unres);
1471 }
1472 lys_compile_unres_glob_erase(ctx, &unres);
1473 if (ret && module) {
1474 *module = NULL;
1475 }
1476 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001477}
1478
Michal Vasko3a41dff2020-07-15 14:30:28 +02001479API LY_ERR
1480lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001481{
Radek Krejci0f969882020-08-21 16:56:47 +02001482 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001483 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001484
Michal Vasko3a41dff2020-07-15 14:30:28 +02001485 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001486
Michal Vasko3a41dff2020-07-15 14:30:28 +02001487 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 +02001488
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001489 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001490 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001491
Michal Vasko3a41dff2020-07-15 14:30:28 +02001492 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001493}
1494
Michal Vasko3a41dff2020-07-15 14:30:28 +02001495API LY_ERR
1496lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001497{
Radek Krejci0f969882020-08-21 16:56:47 +02001498 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001499 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001500
Michal Vasko3a41dff2020-07-15 14:30:28 +02001501 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001502
Michal Vasko3a41dff2020-07-15 14:30:28 +02001503 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 +02001504
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001505 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001506 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001507
Michal Vasko3a41dff2020-07-15 14:30:28 +02001508 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001509}
1510
Michal Vasko3a41dff2020-07-15 14:30:28 +02001511API LY_ERR
1512lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001513{
Radek Krejci0f969882020-08-21 16:56:47 +02001514 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001515 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001516
Michal Vasko3a41dff2020-07-15 14:30:28 +02001517 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001518
Michal Vasko3a41dff2020-07-15 14:30:28 +02001519 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001520 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001521
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001522 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001523 ly_in_free(in, 0);
1524
Michal Vasko3a41dff2020-07-15 14:30:28 +02001525 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001526}
1527
1528API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001529lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001530 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001531{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001532 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001533 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001534 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001535 char *wd, *wn = NULL;
1536 DIR *dir = NULL;
1537 struct dirent *file;
1538 char *match_name = NULL;
1539 LYS_INFORMAT format_aux, match_format = 0;
1540 struct ly_set *dirs;
1541 struct stat st;
1542
1543 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1544
1545 /* start to fill the dir fifo with the context's search path (if set)
1546 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001547 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001548
1549 len = strlen(name);
1550 if (cwd) {
1551 wd = get_current_dir_name();
1552 if (!wd) {
1553 LOGMEM(NULL);
1554 goto cleanup;
1555 } else {
1556 /* add implicit current working directory (./) to be searched,
1557 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001558 ret = ly_set_add(dirs, wd, 0, NULL);
1559 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001560 implicit_cwd = 1;
1561 }
1562 }
1563 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001564 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001565 /* check for duplicities with the implicit current working directory */
1566 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1567 implicit_cwd = 0;
1568 continue;
1569 }
1570 wd = strdup(searchpaths[i]);
1571 if (!wd) {
1572 LOGMEM(NULL);
1573 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001574 } else {
1575 ret = ly_set_add(dirs, wd, 0, NULL);
1576 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001577 }
1578 }
1579 }
1580 wd = NULL;
1581
1582 /* start searching */
1583 while (dirs->count) {
1584 free(wd);
1585 free(wn); wn = NULL;
1586
1587 dirs->count--;
1588 wd = (char *)dirs->objs[dirs->count];
1589 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001590 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001591
1592 if (dir) {
1593 closedir(dir);
1594 }
1595 dir = opendir(wd);
1596 dir_len = strlen(wd);
1597 if (!dir) {
1598 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1599 } else {
1600 while ((file = readdir(dir))) {
1601 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1602 /* skip . and .. */
1603 continue;
1604 }
1605 free(wn);
1606 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1607 LOGMEM(NULL);
1608 goto cleanup;
1609 }
1610 if (stat(wn, &st) == -1) {
1611 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001612 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001613 continue;
1614 }
1615 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1616 /* we have another subdirectory in searchpath to explore,
1617 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001618 ret = ly_set_add(dirs, wn, 0, NULL);
1619 LY_CHECK_GOTO(ret, cleanup);
1620
Radek Krejcid33273d2018-10-25 14:55:52 +02001621 /* continue with the next item in current directory */
1622 wn = NULL;
1623 continue;
1624 } else if (!S_ISREG(st.st_mode)) {
1625 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1626 continue;
1627 }
1628
1629 /* here we know that the item is a file which can contain a module */
1630 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001631 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001632 /* different filename than the module we search for */
1633 continue;
1634 }
1635
1636 /* get type according to filename suffix */
1637 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001638 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1639 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001640 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001641 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1642 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001643 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001644 } else {
1645 /* not supportde suffix/file format */
1646 continue;
1647 }
1648
1649 if (revision) {
1650 /* we look for the specific revision, try to get it from the filename */
1651 if (file->d_name[len] == '@') {
1652 /* check revision from the filename */
1653 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1654 /* another revision */
1655 continue;
1656 } else {
1657 /* exact revision */
1658 free(match_name);
1659 match_name = wn;
1660 wn = NULL;
1661 match_len = dir_len + 1 + len;
1662 match_format = format_aux;
1663 goto success;
1664 }
1665 } else {
1666 /* continue trying to find exact revision match, use this only if not found */
1667 free(match_name);
1668 match_name = wn;
1669 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001670 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001671 match_format = format_aux;
1672 continue;
1673 }
1674 } else {
1675 /* remember the revision and try to find the newest one */
1676 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001677 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01001678 lysp_check_date(NULL, &file->d_name[len + 1],
1679 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001680 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001681 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001682 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1683 continue;
1684 }
1685 free(match_name);
1686 }
1687
1688 match_name = wn;
1689 wn = NULL;
1690 match_len = dir_len + 1 + len;
1691 match_format = format_aux;
1692 continue;
1693 }
1694 }
1695 }
1696 }
1697
1698success:
1699 (*localfile) = match_name;
1700 match_name = NULL;
1701 if (format) {
1702 (*format) = match_format;
1703 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02001704 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02001705
1706cleanup:
1707 free(wn);
1708 free(wd);
1709 if (dir) {
1710 closedir(dir);
1711 }
1712 free(match_name);
1713 ly_set_free(dirs, free);
1714
1715 return ret;
1716}