blob: 97bbe2a2196457f8ed4c259e1dffd0947a825e31 [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"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020041#include "schema_compile.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010042#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020043#include "set.h"
44#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010045#include "tree_edit.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020046#include "tree_schema_internal.h"
47#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020048
Radek Krejcieccf6602021-02-05 19:42:54 +010049/**
50 * @brief information about YANG statements
51 */
52struct stmt_info_s stmt_attr_info[] = {
Radek Krejci6b88a462021-02-17 12:39:34 +010053 [LY_STMT_NONE] = {NULL, NULL, 0},
54 [LY_STMT_ACTION] = {"action", "name", STMT_FLAG_ID},
55 [LY_STMT_ANYDATA] = {"anydata", "name", STMT_FLAG_ID},
56 [LY_STMT_ANYXML] = {"anyxml", "name", STMT_FLAG_ID},
57 [LY_STMT_ARGUMENT] = {"argument", "name", STMT_FLAG_ID},
58 [LY_STMT_ARG_TEXT] = {"text", NULL, 0},
59 [LY_STMT_ARG_VALUE] = {"value", NULL, 0},
60 [LY_STMT_AUGMENT] = {"augment", "target-node", STMT_FLAG_ID},
61 [LY_STMT_BASE] = {"base", "name", STMT_FLAG_ID},
62 [LY_STMT_BELONGS_TO] = {"belongs-to", "module", STMT_FLAG_ID},
63 [LY_STMT_BIT] = {"bit", "name", STMT_FLAG_ID},
64 [LY_STMT_CASE] = {"case", "name", STMT_FLAG_ID},
65 [LY_STMT_CHOICE] = {"choice", "name", STMT_FLAG_ID},
66 [LY_STMT_CONFIG] = {"config", "value", STMT_FLAG_ID},
67 [LY_STMT_CONTACT] = {"contact", "text", STMT_FLAG_YIN},
68 [LY_STMT_CONTAINER] = {"container", "name", STMT_FLAG_ID},
69 [LY_STMT_DEFAULT] = {"default", "value", 0},
70 [LY_STMT_DESCRIPTION] = {"description", "text", STMT_FLAG_YIN},
71 [LY_STMT_DEVIATE] = {"deviate", "value", STMT_FLAG_ID},
72 [LY_STMT_DEVIATION] = {"deviation", "target-node", STMT_FLAG_ID},
73 [LY_STMT_ENUM] = {"enum", "name", STMT_FLAG_ID},
74 [LY_STMT_ERROR_APP_TAG] = {"error-app-tag", "value", 0},
75 [LY_STMT_ERROR_MESSAGE] = {"error-message", "value", STMT_FLAG_YIN},
76 [LY_STMT_EXTENSION] = {"extension", "name", STMT_FLAG_ID},
77 [LY_STMT_EXTENSION_INSTANCE] = {NULL, NULL, 0},
78 [LY_STMT_FEATURE] = {"feature", "name", STMT_FLAG_ID},
79 [LY_STMT_FRACTION_DIGITS] = {"fraction-digits", "value", STMT_FLAG_ID},
80 [LY_STMT_GROUPING] = {"grouping", "name", STMT_FLAG_ID},
81 [LY_STMT_IDENTITY] = {"identity", "name", STMT_FLAG_ID},
82 [LY_STMT_IF_FEATURE] = {"if-feature", "name", 0},
83 [LY_STMT_IMPORT] = {"import", "module", STMT_FLAG_ID},
84 [LY_STMT_INCLUDE] = {"include", "module", STMT_FLAG_ID},
85 [LY_STMT_INPUT] = {"input", NULL, 0},
86 [LY_STMT_KEY] = {"key", "value", 0},
87 [LY_STMT_LEAF] = {"leaf", "name", STMT_FLAG_ID},
88 [LY_STMT_LEAF_LIST] = {"leaf-list", "name", STMT_FLAG_ID},
89 [LY_STMT_LENGTH] = {"length", "value", 0},
90 [LY_STMT_LIST] = {"list", "name", STMT_FLAG_ID},
91 [LY_STMT_MANDATORY] = {"mandatory", "value", STMT_FLAG_ID},
92 [LY_STMT_MAX_ELEMENTS] = {"max-elements", "value", STMT_FLAG_ID},
93 [LY_STMT_MIN_ELEMENTS] = {"min-elements", "value", STMT_FLAG_ID},
94 [LY_STMT_MODIFIER] = {"modifier", "value", STMT_FLAG_ID},
95 [LY_STMT_MODULE] = {"module", "name", STMT_FLAG_ID},
96 [LY_STMT_MUST] = {"must", "condition", 0},
97 [LY_STMT_NAMESPACE] = {"namespace", "uri", 0},
98 [LY_STMT_NOTIFICATION] = {"notification", "name", STMT_FLAG_ID},
99 [LY_STMT_ORDERED_BY] = {"ordered-by", "value", STMT_FLAG_ID},
100 [LY_STMT_ORGANIZATION] = {"organization", "text", STMT_FLAG_YIN},
101 [LY_STMT_OUTPUT] = {"output", NULL, 0},
102 [LY_STMT_PATH] = {"path", "value", 0},
103 [LY_STMT_PATTERN] = {"pattern", "value", 0},
104 [LY_STMT_POSITION] = {"position", "value", STMT_FLAG_ID},
105 [LY_STMT_PREFIX] = {"prefix", "value", STMT_FLAG_ID},
106 [LY_STMT_PRESENCE] = {"presence", "value", 0},
107 [LY_STMT_RANGE] = {"range", "value", 0},
108 [LY_STMT_REFERENCE] = {"reference", "text", STMT_FLAG_YIN},
109 [LY_STMT_REFINE] = {"refine", "target-node", STMT_FLAG_ID},
110 [LY_STMT_REQUIRE_INSTANCE] = {"require-instance", "value", STMT_FLAG_ID},
111 [LY_STMT_REVISION] = {"revision", "date", STMT_FLAG_ID},
112 [LY_STMT_REVISION_DATE] = {"revision-date", "date", STMT_FLAG_ID},
113 [LY_STMT_RPC] = {"rpc", "name", STMT_FLAG_ID},
114 [LY_STMT_STATUS] = {"status", "value", STMT_FLAG_ID},
115 [LY_STMT_SUBMODULE] = {"submodule", "name", STMT_FLAG_ID},
116 [LY_STMT_SYNTAX_LEFT_BRACE] = {"{", NULL, 0},
117 [LY_STMT_SYNTAX_RIGHT_BRACE] = {"}", NULL, 0},
118 [LY_STMT_SYNTAX_SEMICOLON] = {";", NULL, 0},
119 [LY_STMT_TYPE] = {"type", "name", STMT_FLAG_ID},
120 [LY_STMT_TYPEDEF] = {"typedef", "name", STMT_FLAG_ID},
121 [LY_STMT_UNIQUE] = {"unique", "tag", 0},
122 [LY_STMT_UNITS] = {"units", "name", 0},
123 [LY_STMT_USES] = {"uses", "name", STMT_FLAG_ID},
124 [LY_STMT_VALUE] = {"value", "value", STMT_FLAG_ID},
125 [LY_STMT_WHEN] = {"when", "condition", 0},
126 [LY_STMT_YANG_VERSION] = {"yang-version", "value", STMT_FLAG_ID},
127 [LY_STMT_YIN_ELEMENT] = {"yin-element", "value", STMT_FLAG_ID},
Radek Krejcieccf6602021-02-05 19:42:54 +0100128};
129
Radek Krejcif8ca8192021-03-02 16:50:06 +0100130API const char *
131ly_stmt2str(enum ly_stmt stmt)
132{
133 return stmt_attr_info[stmt].name;
134}
135
Radek Krejcieccf6602021-02-05 19:42:54 +0100136const char * const ly_devmod_list[] = {
137 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
138 [LYS_DEV_ADD] = "add",
139 [LYS_DEV_DELETE] = "delete",
140 [LYS_DEV_REPLACE] = "replace",
141};
142
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200143API LY_ERR
144lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
145{
Michal Vasko1d972ca2020-11-03 17:16:56 +0100146 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100147 const struct lysc_node_action *action;
148 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200149
150 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
151
152 LYSC_TREE_DFS_BEGIN(root, elem) {
153 /* schema node */
154 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
155
Radek Krejci2a9fc652021-01-22 17:44:34 +0100156 LY_LIST_FOR(lysc_node_actions(elem), action) {
157 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200158 /* action subtree */
159 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
160
Radek Krejci2a9fc652021-01-22 17:44:34 +0100161 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200162 }
163 }
164
Radek Krejci2a9fc652021-01-22 17:44:34 +0100165 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
166 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200167 /* notification subtree */
168 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
169
Radek Krejci2a9fc652021-01-22 17:44:34 +0100170 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200171 }
172 }
173
174 LYSC_TREE_DFS_END(root, elem);
175 }
176
177 return LY_SUCCESS;
178}
179
180API LY_ERR
181lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
182{
Michal Vasko2336cf52020-11-03 17:18:15 +0100183 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200184
185 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
186
187 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100188 LY_LIST_FOR(mod->compiled->data, root) {
189 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
190 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200191
192 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100193 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
194 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200195 }
196
197 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100198 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
199 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200200 }
201
202 return LY_SUCCESS;
203}
204
Radek Krejcib93bd412020-11-02 13:23:11 +0100205static void
206lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
207{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100208 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100209 if (first_case->child) {
210 /* there is something to return */
211 (*next) = first_case->child;
212 return;
213 }
214 }
215
216 /* no children in choice's cases, so go to the choice's sibling instead of into it */
217 (*last) = (*next);
218 (*next) = (*next)->next;
219}
220
Radek Krejci035dacf2021-02-12 18:25:53 +0100221/**
222 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
223 *
224 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
225 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
226 * extension instance.
227 *
228 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the \p last parameter is usually NULL
229 * and function starts returning i) the first \p parent's child or ii) the first top level element specified in the
230 * given extension (if provided) or iii) the first top level element of the \p module.
231 * Consequent calls suppose to provide the previously returned node as the \p last parameter and still the same
232 * \p parent and \p module parameters.
233 *
234 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
235 * data nodes in a data tree. By setting some \p options the behavior can be modified to the extent that
236 * all the schema nodes are iteratively returned.
237 *
238 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
239 * @param[in] parent Parent of the subtree where the function starts processing.
240 * @param[in] module In case of iterating on top level elements, the \p parent is NULL and
241 * module must be specified.
242 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
243 * the \p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
244 * @param[in] options [ORed options](@ref sgetnextflags).
245 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
246 */
247static const struct lysc_node *
248lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
249 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100250{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100251 const struct lysc_node *next = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200252 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci035dacf2021-02-12 18:25:53 +0100253 struct lysc_node **data_p = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100254
Radek Krejci035dacf2021-02-12 18:25:53 +0100255 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100256
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200257next:
Radek Krejcia3045382018-11-22 14:30:31 +0100258 if (!last) {
259 /* first call */
260
261 /* get know where to start */
262 if (parent) {
263 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100264 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100265 } else {
266 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100267 if (ext) {
268 lysc_ext_substmt(ext, LY_STMT_CONTAINER /* matches all nodes */, (void **)&data_p, NULL);
269 next = last = data_p ? *data_p : NULL;
270 } else {
271 next = last = module->data;
272 }
Radek Krejcia3045382018-11-22 14:30:31 +0100273 }
274 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100275 /* try to get action or notification */
276 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100277 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100278 /* test if the next can be returned */
279 goto check;
280
Michal Vasko1bf09392020-03-27 12:38:10 +0100281 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100282 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100283 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100284 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100285 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100286 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200287 } else {
288 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100289 }
290
Radek Krejcia3045382018-11-22 14:30:31 +0100291repeat:
292 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100293 /* possibly go back to parent */
Radek Krejci035dacf2021-02-12 18:25:53 +0100294 data_p = NULL;
Michal Vasko69730152020-10-09 16:30:07 +0200295 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100296 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200297 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100298 } else if (!action_flag) {
299 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100300 if (ext) {
301 lysc_ext_substmt(ext, LY_STMT_RPC /* matches also actions */, (void **)&data_p, NULL);
302 next = data_p ? *data_p : NULL;
303 } else if (parent) {
304 next = (struct lysc_node *)lysc_node_actions(parent);
305 } else {
306 next = (struct lysc_node *)module->rpcs;
307 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100308 } else if (!notif_flag) {
309 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100310 if (ext) {
311 lysc_ext_substmt(ext, LY_STMT_NOTIFICATION, (void **)&data_p, NULL);
312 next = data_p ? *data_p : NULL;
313 } else if (parent) {
314 next = (struct lysc_node *)lysc_node_notifs(parent);
315 } else {
316 next = (struct lysc_node *)module->notifs;
317 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100318 } else {
319 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100320 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100321 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100322 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100323check:
Radek Krejcia3045382018-11-22 14:30:31 +0100324 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100325 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100326 case LYS_ACTION:
327 case LYS_NOTIF:
328 case LYS_LEAF:
329 case LYS_ANYXML:
330 case LYS_ANYDATA:
331 case LYS_LIST:
332 case LYS_LEAFLIST:
333 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200334 case LYS_CASE:
335 if (options & LYS_GETNEXT_WITHCASE) {
336 break;
337 } else {
338 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100339 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200340 }
341 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100342 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100343 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100344 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100345 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100346 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100347 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100348 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100349 next = next->next;
350 }
351 goto repeat;
352 }
353 break;
354 case LYS_CHOICE:
355 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200356 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100357 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100358 next = next->next;
359 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100360 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100361 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100362 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100363 /* go into */
364 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100365 }
Radek Krejcia3045382018-11-22 14:30:31 +0100366 }
367 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100368 case LYS_INPUT:
369 if (options & LYS_GETNEXT_OUTPUT) {
370 /* skip */
371 next = next->next;
372 } else {
373 /* go into */
374 next = lysc_node_child(next);
375 }
376 goto repeat;
377 case LYS_OUTPUT:
378 if (!(options & LYS_GETNEXT_OUTPUT)) {
379 /* skip */
380 next = next->next;
381 } else {
382 /* go into */
383 next = lysc_node_child(next);
384 }
385 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100386 default:
387 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100388 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100389 return NULL;
390 }
391
Radek Krejcia3045382018-11-22 14:30:31 +0100392 return next;
393}
394
395API const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100396lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
397{
398 return lys_getnext_(last, parent, module, NULL, options);
399}
400
401API const struct lysc_node *
402lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
403{
404 return lys_getnext_(last, parent, NULL, ext, options);
405}
406
Radek Krejcif16e2542021-02-17 15:39:23 +0100407const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100408lysc_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 +0100409 uint16_t nodetype, uint32_t options)
410{
411 const struct lysc_node *node = NULL;
412
413 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
414 if (!nodetype) {
415 nodetype = LYS_NODETYPE_MASK;
416 }
417
418 if (module && (module != ext->module)) {
419 return NULL;
420 }
421
422 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
423 if (!(node->nodetype & nodetype)) {
424 continue;
425 }
426
427 if (name_len) {
428 if (!ly_strncmp(node->name, name, name_len)) {
429 return node;
430 }
431 } else {
432 if (!strcmp(node->name, name)) {
433 return node;
434 }
435 }
436 }
437 return NULL;
438}
439
Radek Krejci035dacf2021-02-12 18:25:53 +0100440API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100441lys_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 +0200442 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100443{
444 const struct lysc_node *node = NULL;
445
446 LY_CHECK_ARG_RET(NULL, module, name, NULL);
447 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100448 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100449 }
450
451 while ((node = lys_getnext(node, parent, module->compiled, options))) {
452 if (!(node->nodetype & nodetype)) {
453 continue;
454 }
455 if (node->module != module) {
456 continue;
457 }
458
459 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200460 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100461 return node;
462 }
463 } else {
464 if (!strcmp(node->name, name)) {
465 return node;
466 }
467 }
468 }
469 return NULL;
470}
471
Michal Vasko519fd602020-05-26 12:17:39 +0200472API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100473lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
474 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200475{
476 LY_ERR ret = LY_SUCCESS;
477 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200478 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200479 uint32_t i;
480
Michal Vasko26512682021-01-11 11:35:40 +0100481 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200482 if (!(options & LYXP_SCNODE_ALL)) {
483 options = LYXP_SCNODE;
484 }
Michal Vasko26512682021-01-11 11:35:40 +0100485 if (!ctx) {
486 ctx = ctx_node->module->ctx;
487 }
Michal Vasko519fd602020-05-26 12:17:39 +0200488
489 memset(&xp_set, 0, sizeof xp_set);
490
491 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100492 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200493 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200494
495 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100496 ret = lyxp_atomize(ctx, exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200497 LY_CHECK_GOTO(ret, cleanup);
498
499 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200500 ret = ly_set_new(set);
501 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200502
503 /* transform into ly_set */
504 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100505 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200506 (*set)->size = xp_set.used;
507
508 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200509 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200510 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200511 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200512 }
513 }
514
515cleanup:
516 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100517 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200518 return ret;
519}
520
Michal Vasko072de482020-08-05 13:27:21 +0200521API LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200522lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
523 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
524{
525 LY_ERR ret = LY_SUCCESS;
526 struct lyxp_set xp_set = {0};
527 uint32_t i;
528
529 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
530 if (!(options & LYXP_SCNODE_ALL)) {
531 options = LYXP_SCNODE;
532 }
533
534 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100535 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 +0200536 LY_CHECK_GOTO(ret, cleanup);
537
538 /* allocate return set */
539 ret = ly_set_new(set);
540 LY_CHECK_GOTO(ret, cleanup);
541
542 /* transform into ly_set */
543 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
544 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
545 (*set)->size = xp_set.used;
546
547 for (i = 0; i < xp_set.used; ++i) {
Michal Vaskod97959c2020-12-10 12:18:28 +0100548 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM)) {
549 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM) ||
550 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200551 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
552 LY_CHECK_GOTO(ret, cleanup);
553 }
554 }
555
556cleanup:
557 lyxp_set_free_content(&xp_set);
558 if (ret) {
559 ly_set_free(*set, NULL);
560 *set = NULL;
561 }
562 return ret;
563}
564
565API LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100566lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
567 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200568{
569 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200570 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200571 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200572 uint32_t i;
573
Michal Vasko26512682021-01-11 11:35:40 +0100574 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200575 if (!(options & LYXP_SCNODE_ALL)) {
576 options = LYXP_SCNODE;
577 }
Michal Vasko26512682021-01-11 11:35:40 +0100578 if (!ctx) {
579 ctx = ctx_node->module->ctx;
580 }
Michal Vasko072de482020-08-05 13:27:21 +0200581
Michal Vasko072de482020-08-05 13:27:21 +0200582 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100583 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200584 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200585
586 /* atomize expression */
Michal Vasko400e9672021-01-11 13:39:17 +0100587 ret = lyxp_atomize(ctx, exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200588 LY_CHECK_GOTO(ret, cleanup);
589
590 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200591 ret = ly_set_new(set);
592 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200593
594 /* transform into ly_set */
595 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100596 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200597 (*set)->size = xp_set.used;
598
599 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100600 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 +0200601 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200602 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200603 }
604 }
605
606cleanup:
607 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100608 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200609 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200610 ly_set_free(*set, NULL);
611 *set = NULL;
612 }
Michal Vasko072de482020-08-05 13:27:21 +0200613 return ret;
614}
615
Radek Krejcibc5644c2020-10-27 14:53:17 +0100616API LY_ERR
617lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
618{
619 LY_ERR ret = LY_SUCCESS;
620 LY_ARRAY_COUNT_TYPE u, v;
621
622 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
623
624 /* allocate return set */
625 LY_CHECK_RET(ly_set_new(set));
626
627 LY_ARRAY_FOR(path, u) {
628 /* add nodes from the path */
629 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
630 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
631 LY_ARRAY_FOR(path[u].predicates, v) {
632 /* add all the keys in a predicate */
633 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
634 }
635 }
636 }
637
638cleanup:
639 if (ret) {
640 ly_set_free(*set, NULL);
641 *set = NULL;
642 }
643 return ret;
644}
645
646API LY_ERR
647lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
648 struct ly_set **set)
649{
650 LY_ERR ret = LY_SUCCESS;
651 uint8_t oper;
652 struct lyxp_expr *expr = NULL;
653 struct ly_path *p = NULL;
654
655 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
656
657 if (!ctx) {
658 ctx = ctx_node->module->ctx;
659 }
660
661 /* parse */
662 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
663 LY_CHECK_GOTO(ret, cleanup);
664
665 /* compile */
666 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100667 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 +0100668 LY_PREF_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100669 LY_CHECK_GOTO(ret, cleanup);
670
671 /* resolve */
672 ret = lys_find_lypath_atoms(p, set);
673
674cleanup:
675 ly_path_free(ctx, p);
676 lyxp_expr_free(ctx, expr);
677 return ret;
678}
679
680API const struct lysc_node *
681lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
682{
683 const struct lysc_node *snode = NULL;
684 struct lyxp_expr *exp = NULL;
685 struct ly_path *p = NULL;
686 LY_ERR ret;
687 uint8_t oper;
688
689 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
690
691 if (!ctx) {
692 ctx = ctx_node->module->ctx;
693 }
694
695 /* parse */
696 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
697 LY_CHECK_GOTO(ret, cleanup);
698
699 /* compile */
700 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Radek Krejcid5d37432021-03-12 13:46:40 +0100701 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 +0100702 LY_PREF_JSON, NULL, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100703 LY_CHECK_GOTO(ret, cleanup);
704
705 /* get last node */
706 snode = p[LY_ARRAY_COUNT(p) - 1].node;
707
708cleanup:
709 ly_path_free(ctx, p);
710 lyxp_expr_free(ctx, exp);
711 return snode;
712}
713
Michal Vasko14654712020-02-06 08:35:21 +0100714char *
715lysc_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 +0200716 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200717{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200718 const struct lysc_node *iter;
Radek Krejci327de162019-06-14 12:52:07 +0200719 char *path = NULL;
720 int len = 0;
721
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200722 if (buffer) {
723 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100724 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200725 }
726
Radek Krejci327de162019-06-14 12:52:07 +0200727 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200728 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200729 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100730 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200731 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100732 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200733
Michal Vasko721b6f62021-02-08 08:52:53 +0100734 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
Michal Vasko65de0402020-08-03 16:34:19 +0200735 /* schema-only node */
736 continue;
737 }
738
Michal Vasko11deea12020-08-05 13:54:50 +0200739 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200740 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100741 if (parent && (iter->parent == parent)) {
742 slash = "";
743 } else {
744 slash = "/";
745 }
Michal Vasko69730152020-10-09 16:30:07 +0200746 if (!iter->parent || (iter->parent->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200747 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200748 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100749 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200750 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100751 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200752 }
Radek Krejci327de162019-06-14 12:52:07 +0200753 } else {
754 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200755 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100756 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200757 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100758 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200759 }
Radek Krejci327de162019-06-14 12:52:07 +0200760 }
761 free(s);
762 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200763
Michal Vasko69730152020-10-09 16:30:07 +0200764 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200765 /* not enough space in buffer */
766 break;
767 }
Radek Krejci327de162019-06-14 12:52:07 +0200768 }
769
770 if (len < 0) {
771 free(path);
772 path = NULL;
773 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200774 if (buffer) {
775 strcpy(buffer, "/");
776 } else {
777 path = strdup("/");
778 }
Radek Krejci327de162019-06-14 12:52:07 +0200779 }
780 break;
781 }
782
Radek Krejci1c0c3442019-07-23 16:08:47 +0200783 if (buffer) {
784 return buffer;
785 } else {
786 return path;
787 }
Radek Krejci327de162019-06-14 12:52:07 +0200788}
789
Michal Vasko14654712020-02-06 08:35:21 +0100790API char *
791lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
792{
793 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
794}
795
Michal Vasko405cc9e2020-12-01 12:01:27 +0100796LY_ERR
797lys_set_implemented_r(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200798{
799 struct lys_module *m;
800
Michal Vasko405cc9e2020-12-01 12:01:27 +0100801 assert(!mod->implemented);
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200802
803 /* we have module from the current context */
804 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
805 if (m) {
Michal Vasko89b5c072020-10-06 13:52:44 +0200806 assert(m != mod);
807
808 /* check collision with other implemented revision */
809 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
810 mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
811 return LY_EDENIED;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200812 }
813
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100814 /* enable features */
815 LY_CHECK_RET(lys_enable_features(mod->parsed, features));
816
Michal Vasko89b5c072020-10-06 13:52:44 +0200817 /* add the module into newly implemented module set */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100818 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
Michal Vasko89b5c072020-10-06 13:52:44 +0200819
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200820 /* mark the module implemented, check for collision was already done */
Michal Vasko89b5c072020-10-06 13:52:44 +0200821 mod->implemented = 1;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200822
823 /* compile the schema */
Michal Vasko405cc9e2020-12-01 12:01:27 +0100824 return lys_compile(mod, 0, unres);
825}
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200826
Michal Vasko405cc9e2020-12-01 12:01:27 +0100827API LY_ERR
828lys_set_implemented(struct lys_module *mod, const char **features)
829{
830 LY_ERR ret = LY_SUCCESS, r;
831 struct lys_glob_unres unres = {0};
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200832
Michal Vasko405cc9e2020-12-01 12:01:27 +0100833 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
Michal Vasko916aefb2020-11-02 15:43:16 +0100834
Michal Vasko405cc9e2020-12-01 12:01:27 +0100835 if (mod->implemented) {
836 /* mod is already implemented, set the features */
837 r = lys_set_features(mod->parsed, features);
838 if (r == LY_EEXIST) {
839 /* no changes */
840 return LY_SUCCESS;
841 } else if (r) {
842 /* error */
843 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200844 }
845
Michal Vasko405cc9e2020-12-01 12:01:27 +0100846 /* full recompilation */
847 return lys_recompile(mod->ctx, 1);
Michal Vasko89b5c072020-10-06 13:52:44 +0200848 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100849
Michal Vasko405cc9e2020-12-01 12:01:27 +0100850 /* implement this module and any other required modules, recursively */
851 ret = lys_set_implemented_r(mod, features, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100852
853 /* the first module being implemented is finished, resolve global unres, consolidate the set */
854 if (!ret) {
855 ret = lys_compile_unres_glob(mod->ctx, &unres);
856 }
857 if (ret) {
858 /* failure, full compile revert */
859 lys_compile_unres_glob_revert(mod->ctx, &unres);
860 }
861
862 lys_compile_unres_glob_erase(mod->ctx, &unres);
Michal Vasko89b5c072020-10-06 13:52:44 +0200863 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200864}
865
Michal Vasko7c8439f2020-08-05 13:25:19 +0200866static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100867lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
Michal Vasko7c8439f2020-08-05 13:25:19 +0200868{
869 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200870 LY_ARRAY_COUNT_TYPE u, v;
871
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100872 pmod->parsing = 1;
873 LY_ARRAY_FOR(pmod->imports, u) {
874 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +0200875 if (!imp->module) {
Michal Vasko18a86e52021-04-16 11:50:13 +0200876 LY_CHECK_RET(lys_load_module(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, 0, NULL,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100877 pctx->unres, &imp->module));
Michal Vasko7c8439f2020-08-05 13:25:19 +0200878 }
879 /* check for importing the same module twice */
880 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100881 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200882 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
883 }
884 }
885 }
Radek Krejci771928a2021-01-19 13:42:36 +0100886 LY_CHECK_RET(lysp_load_submodules(pctx, pmod));
887
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100888 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200889
890 return LY_SUCCESS;
891}
892
Michal Vasko3a41dff2020-07-15 14:30:28 +0200893LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +0200894lys_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 +0200895 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
Radek Krejci0f969882020-08-21 16:56:47 +0200896 void *check_data, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200897{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200898 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100899 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +0100900 struct lys_yang_parser_ctx *yangctx = NULL;
901 struct lys_yin_parser_ctx *yinctx = NULL;
902 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100903
Michal Vasko3a41dff2020-07-15 14:30:28 +0200904 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100905
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100906 switch (format) {
907 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +0200908 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100909 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100910 break;
911 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +0200912 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100913 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100914 break;
915 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +0200916 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +0200917 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100918 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200919 }
Radek Krejcif6923e82020-07-02 16:36:53 +0200920 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +0200921 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100922
923 /* make sure that the newest revision is at position 0 */
924 lysp_sort_revisions(submod->revs);
925
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100926 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +0100927 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100928 if (latest_sp) {
929 if (submod->revs) {
930 if (!latest_sp->revs) {
931 /* latest has no revision, so mod is anyway newer */
932 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +0200933 /* the latest_sp is zeroed later when the new module is being inserted into the context */
934 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
935 submod->latest_revision = latest_sp->latest_revision;
936 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100937 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +0200938 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100939 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200940 } else {
941 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100942 }
943 } else {
944 submod->latest_revision = 1;
945 }
946
Radek Krejcib3289d62019-09-18 12:21:39 +0200947 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200948 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +0200949 }
950
951 if (latest_sp) {
952 latest_sp->latest_revision = 0;
953 }
954
Michal Vasko7a0b0762020-09-02 16:37:01 +0200955 lys_parser_fill_filepath(ctx, in, &submod->filepath);
956
Michal Vasko7c8439f2020-08-05 13:25:19 +0200957 /* resolve imports and includes */
958 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod), error);
959
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100960 /* remap possibly changed and reallocated typedefs and groupings list back to the main context */
Michal Vaskob36053d2020-03-26 15:49:30 +0100961 memcpy(&main_ctx->tpdfs_nodes, &pctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
962 memcpy(&main_ctx->grps_nodes, &pctx->grps_nodes, sizeof main_ctx->grps_nodes);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100963
David Sedlák1b623122019-08-05 15:27:49 +0200964 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100965 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200966 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100967 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200968 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200969 *submodule = submod;
970 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +0200971
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100972error:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200973 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +0200974 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100975 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200976 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100977 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200978 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200979 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200980}
981
Michal Vasko45b521c2020-11-04 17:14:39 +0100982/**
983 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
984 *
985 * @param[in] mod Parsed module to add to.
986 * @return LY_SUCCESS on success.
987 * @return LY_ERR on error.
988 */
989static LY_ERR
990lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
991{
992 struct lysp_ext_instance *ext_p;
993 struct lysp_stmt *stmt;
994 struct lysp_import *imp;
995
996 /*
997 * 1) edit-config's operation
998 */
999 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1000 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1001 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1002 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001003 ext_p->format = LY_PREF_SCHEMA;
1004 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001005 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001006 ext_p->parent_stmt = LY_STMT_MODULE;
1007 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001008
1009 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1010 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1011 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1012 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001013 stmt->format = LY_PREF_SCHEMA;
1014 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001015 stmt->kw = LY_STMT_TYPE;
1016
1017 stmt->child = calloc(1, sizeof *stmt->child);
1018 stmt = stmt->child;
1019 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1020 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1021 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001022 stmt->format = LY_PREF_SCHEMA;
1023 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001024 stmt->kw = LY_STMT_ENUM;
1025
1026 stmt->next = calloc(1, sizeof *stmt->child);
1027 stmt = stmt->next;
1028 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1029 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1030 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001031 stmt->format = LY_PREF_SCHEMA;
1032 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001033 stmt->kw = LY_STMT_ENUM;
1034
1035 stmt->next = calloc(1, sizeof *stmt->child);
1036 stmt = stmt->next;
1037 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1038 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1039 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001040 stmt->format = LY_PREF_SCHEMA;
1041 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001042 stmt->kw = LY_STMT_ENUM;
1043
1044 stmt->next = calloc(1, sizeof *stmt->child);
1045 stmt = stmt->next;
1046 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1047 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1048 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001049 stmt->format = LY_PREF_SCHEMA;
1050 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001051 stmt->kw = LY_STMT_ENUM;
1052
1053 stmt->next = calloc(1, sizeof *stmt->child);
1054 stmt = stmt->next;
1055 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1056 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1057 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001058 stmt->format = LY_PREF_SCHEMA;
1059 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001060 stmt->kw = LY_STMT_ENUM;
1061
1062 /*
1063 * 2) filter's type
1064 */
1065 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1066 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1067 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1068 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001069 ext_p->format = LY_PREF_SCHEMA;
1070 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001071 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001072 ext_p->parent_stmt = LY_STMT_MODULE;
1073 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001074
1075 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1076 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1077 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1078 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001079 stmt->format = LY_PREF_SCHEMA;
1080 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001081 stmt->kw = LY_STMT_TYPE;
1082
1083 stmt->child = calloc(1, sizeof *stmt->child);
1084 stmt = stmt->child;
1085 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1086 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1087 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001088 stmt->format = LY_PREF_SCHEMA;
1089 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001090 stmt->kw = LY_STMT_ENUM;
1091
1092 stmt->next = calloc(1, sizeof *stmt->child);
1093 stmt = stmt->next;
1094 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1095 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1096 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001097 stmt->format = LY_PREF_SCHEMA;
1098 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001099 stmt->kw = LY_STMT_ENUM;
1100
1101 /* if-feature for enum allowed only for YANG 1.1 modules */
1102 if (mod->version >= LYS_VERSION_1_1) {
1103 stmt->child = calloc(1, sizeof *stmt->child);
1104 stmt = stmt->child;
1105 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1106 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1107 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001108 stmt->format = LY_PREF_SCHEMA;
1109 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001110 stmt->kw = LY_STMT_IF_FEATURE;
1111 }
1112
1113 /*
1114 * 3) filter's select
1115 */
1116 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1117 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1118 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1119 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001120 ext_p->format = LY_PREF_SCHEMA;
1121 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001122 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001123 ext_p->parent_stmt = LY_STMT_MODULE;
1124 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001125
1126 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1127 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1128 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1129 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001130 stmt->format = LY_PREF_SCHEMA;
1131 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001132 stmt->kw = LY_STMT_TYPE;
1133
1134 /* create new imports for the used prefixes */
1135 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1136
1137 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1138 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1139 imp->flags = LYS_INTERNAL;
1140
1141 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1142
1143 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1144 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1145 imp->flags = LYS_INTERNAL;
1146
1147 return LY_SUCCESS;
1148}
1149
1150/**
1151 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1152 *
1153 * @param[in] mod Parsed module to add to.
1154 * @return LY_SUCCESS on success.
1155 * @return LY_ERR on error.
1156 */
1157static LY_ERR
1158lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1159{
1160 struct lysp_ext_instance *ext_p;
1161 struct lysp_stmt *stmt;
1162 struct lysp_import *imp;
1163
1164 /* add new extension instance */
1165 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1166
1167 /* fill in the extension instance fields */
1168 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1169 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1170 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001171 ext_p->format = LY_PREF_SCHEMA;
1172 ext_p->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001173 ext_p->flags = LYS_INTERNAL;
Radek Krejciab430862021-03-02 20:13:40 +01001174 ext_p->parent_stmt = LY_STMT_MODULE;
1175 ext_p->parent_stmt_index = 0;
Michal Vasko45b521c2020-11-04 17:14:39 +01001176
1177 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1178 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1179 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1180 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Michal Vaskofc2cd072021-02-24 13:17:17 +01001181 stmt->format = LY_PREF_SCHEMA;
1182 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001183 stmt->kw = LY_STMT_TYPE;
1184
1185 /* create new import for the used prefix */
1186 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1187
1188 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1189 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1190 imp->flags = LYS_INTERNAL;
1191
1192 return LY_SUCCESS;
1193}
1194
Michal Vasko3a41dff2020-07-15 14:30:28 +02001195LY_ERR
Michal Vasko34e334d2021-01-25 16:12:31 +01001196lys_create_module(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, ly_bool need_implemented,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001197 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 +01001198 void *check_data, const char **features, struct lys_glob_unres *unres, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001199{
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001200 struct lys_module *mod = NULL, *latest, *mod_dup, *mod_impl;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001201 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001202 LY_ERR ret;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001203 LY_ARRAY_COUNT_TYPE u;
Michal Vaskob36053d2020-03-26 15:49:30 +01001204 struct lys_yang_parser_ctx *yangctx = NULL;
1205 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001206 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001207 char *filename, *rev, *dot;
1208 size_t len;
Michal Vasko34e334d2021-01-25 16:12:31 +01001209 ly_bool implement;
Radek Krejci86d106e2018-10-18 09:53:19 +02001210
Michal Vasko34e334d2021-01-25 16:12:31 +01001211 assert(ctx && in && (!features || need_implemented) && unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001212
Michal Vasko7a0b0762020-09-02 16:37:01 +02001213 if (module) {
1214 *module = NULL;
1215 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001216
Michal Vasko34e334d2021-01-25 16:12:31 +01001217 if (ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
1218 implement = 1;
1219 } else {
1220 implement = need_implemented;
Radek Krejci00a3e8a2021-01-27 08:24:49 +01001221 }
Michal Vasko34e334d2021-01-25 16:12:31 +01001222
Radek Krejci86d106e2018-10-18 09:53:19 +02001223 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001224 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001225 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001226
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001227 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001228 switch (format) {
1229 case LYS_IN_YIN:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001230 ret = yin_parse_module(&yinctx, in, mod, unres);
Michal Vaskob36053d2020-03-26 15:49:30 +01001231 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001232 break;
1233 case LYS_IN_YANG:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001234 ret = yang_parse_module(&yangctx, in, mod, unres);
Michal Vaskob36053d2020-03-26 15:49:30 +01001235 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001236 break;
1237 default:
1238 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001239 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001240 break;
1241 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001242 LY_CHECK_GOTO(ret, free_mod_cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001243
1244 /* make sure that the newest revision is at position 0 */
1245 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001246 if (mod->parsed->revs) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001247 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 +01001248 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001249
Radek Krejcib3289d62019-09-18 12:21:39 +02001250 /* decide the latest revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001251 latest = (struct lys_module *)ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001252 if (latest) {
1253 if (mod->revision) {
1254 if (!latest->revision) {
1255 /* latest has no revision, so mod is anyway newer */
1256 mod->latest_revision = latest->latest_revision;
1257 /* the latest is zeroed later when the new module is being inserted into the context */
1258 } else if (strcmp(mod->revision, latest->revision) > 0) {
1259 mod->latest_revision = latest->latest_revision;
1260 /* the latest is zeroed later when the new module is being inserted into the context */
1261 } else {
1262 latest = NULL;
1263 }
1264 } else {
1265 latest = NULL;
1266 }
1267 } else {
1268 mod->latest_revision = 1;
1269 }
1270
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001271 if (custom_check) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001272 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), free_mod_cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001273 }
1274
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001275 /* check whether it is not already in the context in the same revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001276 mod_dup = (struct lys_module *)ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001277 if (implement) {
1278 mod_impl = ly_ctx_get_module_implemented(ctx, mod->name);
1279 if (mod_impl && (mod_impl != mod_dup)) {
1280 LOGERR(ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in the context.", mod_impl->name,
1281 mod_impl->revision ? mod_impl->revision : "<none>");
1282 ret = LY_EDENIED;
1283 goto free_mod_cleanup;
Radek Krejcid33273d2018-10-25 14:55:52 +02001284 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001285 }
1286 if (mod_dup) {
1287 if (implement) {
1288 if (!mod_dup->implemented) {
1289 /* just implement it */
1290 LY_CHECK_GOTO(ret = lys_set_implemented_r(mod_dup, features, unres), free_mod_cleanup);
1291 goto free_mod_cleanup;
1292 }
1293
1294 /* nothing to do */
1295 LOGVRB("Module \"%s@%s\" is already implemented in the context.", mod_dup->name,
1296 mod_dup->revision ? mod_dup->revision : "<none>");
1297 goto free_mod_cleanup;
1298 }
1299
1300 /* nothing to do */
1301 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1302 mod_dup->revision ? mod_dup->revision : "<none>");
1303 goto free_mod_cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001304 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001305
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001306 switch (in->type) {
1307 case LY_IN_FILEPATH:
1308 /* check that name and revision match filename */
1309 filename = strrchr(in->method.fpath.filepath, '/');
1310 if (!filename) {
1311 filename = in->method.fpath.filepath;
1312 } else {
1313 filename++;
1314 }
1315 rev = strchr(filename, '@');
1316 dot = strrchr(filename, '.');
1317
1318 /* name */
1319 len = strlen(mod->name);
1320 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001321 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001322 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1323 }
1324 if (rev) {
1325 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001326 if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001327 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001328 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001329 }
1330 }
1331
1332 break;
1333 case LY_IN_FD:
1334 case LY_IN_FILE:
1335 case LY_IN_MEMORY:
1336 /* nothing special to do */
1337 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001338 case LY_IN_ERROR:
1339 LOGINT(ctx);
1340 ret = LY_EINT;
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001341 goto free_mod_cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001342 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001343 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001344
Michal Vasko7a0b0762020-09-02 16:37:01 +02001345 if (latest) {
1346 latest->latest_revision = 0;
1347 }
1348
Michal Vasko45b521c2020-11-04 17:14:39 +01001349 /* add internal data in case specific modules were parsed */
1350 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001351 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001352 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001353 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), free_mod_cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001354 }
1355
Michal Vasko405cc9e2020-12-01 12:01:27 +01001356 /* add the module into newly created module set, will also be freed from there on any error */
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001357 LY_CHECK_GOTO(ret = ly_set_add(&unres->creating, mod, 1, NULL), free_mod_cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001358
Michal Vasko7a0b0762020-09-02 16:37:01 +02001359 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001360 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001361 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001362 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001363
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001364 /* resolve includes and all imports */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001365 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001366
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001367 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001368 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001369 /* TODO groupings */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001370 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1371 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001372
1373 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001374 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001375
Michal Vasko89b5c072020-10-06 13:52:44 +02001376 if (!implement) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001377 /* pre-compile identities of the module */
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001378 LY_CHECK_GOTO(ret = lys_identity_precompile(NULL, ctx, mod->parsed, mod->parsed->identities, &mod->identities), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001379
1380 /* pre-compile identities of any submodules */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001381 LY_ARRAY_FOR(mod->parsed->includes, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001382 submod = mod->parsed->includes[u].submodule;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001383 ret = lys_identity_precompile(NULL, ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001384 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001385 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001386 } else {
Michal Vasko89b5c072020-10-06 13:52:44 +02001387 /* implement (compile) */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001388 LY_CHECK_GOTO(ret = lys_set_implemented_r(mod, features, unres), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001389 }
1390
Michal Vasko405cc9e2020-12-01 12:01:27 +01001391 /* success */
1392 goto cleanup;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001393
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001394free_mod_cleanup:
Radek Krejci90ed21e2021-04-12 14:47:46 +02001395 lys_module_free(mod);
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001396 if (ret) {
1397 mod = NULL;
1398 } else {
1399 /* return the existing module */
1400 assert(mod_dup);
1401 mod = mod_dup;
1402 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001403
Michal Vasko405cc9e2020-12-01 12:01:27 +01001404cleanup:
Michal Vasko7a0b0762020-09-02 16:37:01 +02001405 if (pctx) {
1406 ly_set_erase(&pctx->tpdfs_nodes, NULL);
1407 }
1408 if (format == LYS_IN_YANG) {
1409 yang_parser_ctx_free(yangctx);
1410 } else {
1411 yin_parser_ctx_free(yinctx);
1412 }
1413
Michal Vasko405cc9e2020-12-01 12:01:27 +01001414 if (!ret && module) {
1415 *module = mod;
1416 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001417 return ret;
1418}
1419
Radek Krejci545b4872020-11-15 10:15:12 +01001420static LYS_INFORMAT
1421lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1422{
1423 if (!format && (in->type == LY_IN_FILEPATH)) {
1424 /* unknown format - try to detect it from filename's suffix */
1425 const char *path = in->method.fpath.filepath;
1426 size_t len = strlen(path);
1427
1428 /* ignore trailing whitespaces */
1429 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1430
Radek Krejcif13b87b2020-12-01 22:02:17 +01001431 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1432 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001433 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001434 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1435 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001436 format = LYS_IN_YIN;
1437 } /* else still unknown */
1438 }
1439
1440 return format;
1441}
1442
Michal Vasko7a0b0762020-09-02 16:37:01 +02001443API LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001444lys_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 +02001445{
Michal Vasko405cc9e2020-12-01 12:01:27 +01001446 LY_ERR ret;
1447 struct lys_glob_unres unres = {0};
1448
Michal Vasko7a0b0762020-09-02 16:37:01 +02001449 if (module) {
1450 *module = NULL;
1451 }
Radek Krejci545b4872020-11-15 10:15:12 +01001452 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1453
1454 format = lys_parse_get_format(in, format);
1455 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001456
1457 /* remember input position */
1458 in->func_start = in->current;
1459
Michal Vasko405cc9e2020-12-01 12:01:27 +01001460 ret = lys_create_module(ctx, in, format, 1, NULL, NULL, features, &unres, (struct lys_module **)module);
1461 LY_CHECK_GOTO(ret, cleanup);
1462
1463 /* resolve global unres */
1464 ret = lys_compile_unres_glob(ctx, &unres);
1465 LY_CHECK_GOTO(ret, cleanup);
1466
1467cleanup:
1468 if (ret) {
1469 lys_compile_unres_glob_revert(ctx, &unres);
1470 }
1471 lys_compile_unres_glob_erase(ctx, &unres);
1472 if (ret && module) {
1473 *module = NULL;
1474 }
1475 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001476}
1477
Michal Vasko3a41dff2020-07-15 14:30:28 +02001478API LY_ERR
1479lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001480{
Radek Krejci0f969882020-08-21 16:56:47 +02001481 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001482 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001483
Michal Vasko3a41dff2020-07-15 14:30:28 +02001484 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001485
Michal Vasko3a41dff2020-07-15 14:30:28 +02001486 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 +02001487
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001488 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001489 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001490
Michal Vasko3a41dff2020-07-15 14:30:28 +02001491 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001492}
1493
Michal Vasko3a41dff2020-07-15 14:30:28 +02001494API LY_ERR
1495lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001496{
Radek Krejci0f969882020-08-21 16:56:47 +02001497 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001498 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001499
Michal Vasko3a41dff2020-07-15 14:30:28 +02001500 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001501
Michal Vasko3a41dff2020-07-15 14:30:28 +02001502 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 +02001503
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001504 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001505 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001506
Michal Vasko3a41dff2020-07-15 14:30:28 +02001507 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001508}
1509
Michal Vasko3a41dff2020-07-15 14:30:28 +02001510API LY_ERR
1511lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001512{
Radek Krejci0f969882020-08-21 16:56:47 +02001513 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001514 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001515
Michal Vasko3a41dff2020-07-15 14:30:28 +02001516 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001517
Michal Vasko3a41dff2020-07-15 14:30:28 +02001518 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001519 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001520
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001521 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001522 ly_in_free(in, 0);
1523
Michal Vasko3a41dff2020-07-15 14:30:28 +02001524 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001525}
1526
1527API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001528lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001529 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001530{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001531 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001532 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001533 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001534 char *wd, *wn = NULL;
1535 DIR *dir = NULL;
1536 struct dirent *file;
1537 char *match_name = NULL;
1538 LYS_INFORMAT format_aux, match_format = 0;
1539 struct ly_set *dirs;
1540 struct stat st;
1541
1542 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1543
1544 /* start to fill the dir fifo with the context's search path (if set)
1545 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001546 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001547
1548 len = strlen(name);
1549 if (cwd) {
1550 wd = get_current_dir_name();
1551 if (!wd) {
1552 LOGMEM(NULL);
1553 goto cleanup;
1554 } else {
1555 /* add implicit current working directory (./) to be searched,
1556 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001557 ret = ly_set_add(dirs, wd, 0, NULL);
1558 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001559 implicit_cwd = 1;
1560 }
1561 }
1562 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001563 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001564 /* check for duplicities with the implicit current working directory */
1565 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1566 implicit_cwd = 0;
1567 continue;
1568 }
1569 wd = strdup(searchpaths[i]);
1570 if (!wd) {
1571 LOGMEM(NULL);
1572 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001573 } else {
1574 ret = ly_set_add(dirs, wd, 0, NULL);
1575 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001576 }
1577 }
1578 }
1579 wd = NULL;
1580
1581 /* start searching */
1582 while (dirs->count) {
1583 free(wd);
1584 free(wn); wn = NULL;
1585
1586 dirs->count--;
1587 wd = (char *)dirs->objs[dirs->count];
1588 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01001589 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02001590
1591 if (dir) {
1592 closedir(dir);
1593 }
1594 dir = opendir(wd);
1595 dir_len = strlen(wd);
1596 if (!dir) {
1597 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1598 } else {
1599 while ((file = readdir(dir))) {
1600 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1601 /* skip . and .. */
1602 continue;
1603 }
1604 free(wn);
1605 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1606 LOGMEM(NULL);
1607 goto cleanup;
1608 }
1609 if (stat(wn, &st) == -1) {
1610 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001611 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001612 continue;
1613 }
1614 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1615 /* we have another subdirectory in searchpath to explore,
1616 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001617 ret = ly_set_add(dirs, wn, 0, NULL);
1618 LY_CHECK_GOTO(ret, cleanup);
1619
Radek Krejcid33273d2018-10-25 14:55:52 +02001620 /* continue with the next item in current directory */
1621 wn = NULL;
1622 continue;
1623 } else if (!S_ISREG(st.st_mode)) {
1624 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1625 continue;
1626 }
1627
1628 /* here we know that the item is a file which can contain a module */
1629 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001630 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001631 /* different filename than the module we search for */
1632 continue;
1633 }
1634
1635 /* get type according to filename suffix */
1636 flen = strlen(file->d_name);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001637 if ((flen >= LY_YANG_SUFFIX_LEN + 1) &&
1638 !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001639 format_aux = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001640 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) &&
1641 !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
Radek Krejci01a937f2020-11-15 10:14:12 +01001642 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001643 } else {
1644 /* not supportde suffix/file format */
1645 continue;
1646 }
1647
1648 if (revision) {
1649 /* we look for the specific revision, try to get it from the filename */
1650 if (file->d_name[len] == '@') {
1651 /* check revision from the filename */
1652 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1653 /* another revision */
1654 continue;
1655 } else {
1656 /* exact revision */
1657 free(match_name);
1658 match_name = wn;
1659 wn = NULL;
1660 match_len = dir_len + 1 + len;
1661 match_format = format_aux;
1662 goto success;
1663 }
1664 } else {
1665 /* continue trying to find exact revision match, use this only if not found */
1666 free(match_name);
1667 match_name = wn;
1668 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001669 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001670 match_format = format_aux;
1671 continue;
1672 }
1673 } else {
1674 /* remember the revision and try to find the newest one */
1675 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001676 if ((file->d_name[len] != '@') ||
Radek Krejcif13b87b2020-12-01 22:02:17 +01001677 lysp_check_date(NULL, &file->d_name[len + 1],
1678 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001679 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001680 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001681 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1682 continue;
1683 }
1684 free(match_name);
1685 }
1686
1687 match_name = wn;
1688 wn = NULL;
1689 match_len = dir_len + 1 + len;
1690 match_format = format_aux;
1691 continue;
1692 }
1693 }
1694 }
1695 }
1696
1697success:
1698 (*localfile) = match_name;
1699 match_name = NULL;
1700 if (format) {
1701 (*format) = match_format;
1702 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02001703 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02001704
1705cleanup:
1706 free(wn);
1707 free(wd);
1708 if (dir) {
1709 closedir(dir);
1710 }
1711 free(match_name);
1712 ly_set_free(dirs, free);
1713
1714 return ret;
1715}