blob: 398e3a1c24a01aa38b186ea03b44f2268a8ff882 [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
16
Radek Krejcica376bd2020-06-11 16:04:06 +020017#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020018
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <assert.h>
Radek Krejci545b4872020-11-15 10:15:12 +010020#include <ctype.h>
Radek Krejcid33273d2018-10-25 14:55:52 +020021#include <dirent.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020022#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdint.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020024#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include <stdlib.h>
26#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020027#include <sys/stat.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020028#include <unistd.h>
Radek Krejci3f5e3db2018-10-11 15:57:47 +020029
Radek Krejcica376bd2020-06-11 16:04:06 +020030#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020031#include "compat.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020032#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020033#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020035#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020037#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020038#include "parser_schema.h"
Michal Vasko40308e72020-10-20 16:38:40 +020039#include "path.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020040#include "schema_compile.h"
41#include "schema_compile_amend.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010042#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020043#include "set.h"
44#include "tree.h"
Radek Krejci47fab892020-11-05 17:02:41 +010045#include "tree_data.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
Michal Vaskof1ab44f2020-10-22 08:58:32 +020049API LY_ERR
50lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
51{
Michal Vasko1d972ca2020-11-03 17:16:56 +010052 struct lysc_node *elem, *elem2;
53 const struct lysc_action *acts;
54 const struct lysc_notif *notifs;
Michal Vaskof1ab44f2020-10-22 08:58:32 +020055 LY_ARRAY_COUNT_TYPE u;
56
57 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
58
59 LYSC_TREE_DFS_BEGIN(root, elem) {
60 /* schema node */
61 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
62
Michal Vasko1d972ca2020-11-03 17:16:56 +010063 acts = lysc_node_actions(elem);
64 LY_ARRAY_FOR(acts, u) {
65 LYSC_TREE_DFS_BEGIN(&acts[u], elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +020066 /* action subtree */
67 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
68
Michal Vasko1d972ca2020-11-03 17:16:56 +010069 LYSC_TREE_DFS_END(&acts[u], elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +020070 }
71 }
72
Michal Vasko1d972ca2020-11-03 17:16:56 +010073 notifs = lysc_node_notifs(elem);
74 LY_ARRAY_FOR(notifs, u) {
75 LYSC_TREE_DFS_BEGIN(&notifs[u], elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +020076 /* notification subtree */
77 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
78
Michal Vasko1d972ca2020-11-03 17:16:56 +010079 LYSC_TREE_DFS_END(&notifs[u], elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +020080 }
81 }
82
83 LYSC_TREE_DFS_END(root, elem);
84 }
85
86 return LY_SUCCESS;
87}
88
89API LY_ERR
90lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
91{
92 LY_ARRAY_COUNT_TYPE u;
Michal Vasko2336cf52020-11-03 17:18:15 +010093 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +020094
95 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
96
97 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +010098 LY_LIST_FOR(mod->compiled->data, root) {
99 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
100 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200101
102 /* RPCs */
103 LY_ARRAY_FOR(mod->compiled->rpcs, u) {
104 LY_CHECK_RET(lysc_tree_dfs_full((struct lysc_node *)&mod->compiled->rpcs[u], dfs_clb, data));
105 }
106
107 /* notifications */
108 LY_ARRAY_FOR(mod->compiled->notifs, u) {
109 LY_CHECK_RET(lysc_tree_dfs_full((struct lysc_node *)&mod->compiled->notifs[u], dfs_clb, data));
110 }
111
112 return LY_SUCCESS;
113}
114
Radek Krejcib93bd412020-11-02 13:23:11 +0100115static void
116lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
117{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100118 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100119 if (first_case->child) {
120 /* there is something to return */
121 (*next) = first_case->child;
122 return;
123 }
124 }
125
126 /* no children in choice's cases, so go to the choice's sibling instead of into it */
127 (*last) = (*next);
128 (*next) = (*next)->next;
129}
130
Radek Krejcia3045382018-11-22 14:30:31 +0100131API const struct lysc_node *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200132lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100133{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100134 const struct lysc_node *next = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +0100135 struct lysc_node **snode;
Radek Krejci857189e2020-09-01 13:26:36 +0200136 ly_bool action_flag = 0, notif_flag = 0;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100137 const struct lysc_action *actions;
138 const struct lysc_notif *notifs;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200139 LY_ARRAY_COUNT_TYPE u;
Radek Krejcia3045382018-11-22 14:30:31 +0100140
141 LY_CHECK_ARG_RET(NULL, parent || module, NULL);
142
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200143next:
Radek Krejcia3045382018-11-22 14:30:31 +0100144 if (!last) {
145 /* first call */
146
147 /* get know where to start */
148 if (parent) {
149 /* schema subtree */
Michal Vasko69730152020-10-09 16:30:07 +0200150 if ((parent->nodetype == LYS_CHOICE) && (options & LYS_GETNEXT_WITHCASE)) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200151 if (((struct lysc_node_choice *)parent)->cases) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100152 next = last = (const struct lysc_node *)((struct lysc_node_choice *)parent)->cases;
Radek Krejci056d0a82018-12-06 16:57:25 +0100153 }
Radek Krejci056d0a82018-12-06 16:57:25 +0100154 } else {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100155 snode = lysc_node_children_p(parent, (options & LYS_GETNEXT_OUTPUT) ? LYS_CONFIG_R : LYS_CONFIG_W);
Radek Krejci05b774b2019-02-25 13:26:18 +0100156 /* do not return anything if the node does not have any children */
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200157 if (snode && *snode) {
158 next = last = *snode;
Radek Krejci056d0a82018-12-06 16:57:25 +0100159 }
Radek Krejcia3045382018-11-22 14:30:31 +0100160 }
Radek Krejcia3045382018-11-22 14:30:31 +0100161 } else {
162 /* top level data */
163 next = last = module->data;
164 }
165 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100166 /* try to get action or notification */
167 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100168 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100169 /* test if the next can be returned */
170 goto check;
171
Michal Vasko1bf09392020-03-27 12:38:10 +0100172 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100173 action_flag = 1;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100174 if (last->parent) {
175 actions = lysc_node_actions(last->parent);
176 } else {
177 actions = module->rpcs;
178 }
179 LY_ARRAY_FOR(actions, u) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200180 if (&actions[u] == (struct lysc_action *)last) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100181 break;
182 }
183 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200184 if (u + 1 < LY_ARRAY_COUNT(actions)) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200185 next = (struct lysc_node *)(&actions[u + 1]);
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100186 }
187 goto repeat;
188 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100189 action_flag = notif_flag = 1;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100190 if (last->parent) {
191 notifs = lysc_node_notifs(last->parent);
192 } else {
193 notifs = module->notifs;
194 }
195 LY_ARRAY_FOR(notifs, u) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200196 if (&notifs[u] == (struct lysc_notif *)last) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100197 break;
198 }
199 }
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200200 if (u + 1 < LY_ARRAY_COUNT(notifs)) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200201 next = (struct lysc_node *)(&notifs[u + 1]);
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100202 }
203 goto repeat;
Michal Vasko20424b42020-08-31 12:29:38 +0200204 } else {
205 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100206 }
207
Radek Krejcia3045382018-11-22 14:30:31 +0100208repeat:
209 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100210 /* possibly go back to parent */
Michal Vasko69730152020-10-09 16:30:07 +0200211 if (last && (last->parent != parent)) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100212 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200213 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100214 } else if (!action_flag) {
215 action_flag = 1;
Michal Vasko22df3f02020-08-24 13:29:22 +0200216 next = parent ? (struct lysc_node *)lysc_node_actions(parent) : (struct lysc_node *)module->rpcs;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100217 } else if (!notif_flag) {
218 notif_flag = 1;
Michal Vasko22df3f02020-08-24 13:29:22 +0200219 next = parent ? (struct lysc_node *)lysc_node_notifs(parent) : (struct lysc_node *)module->notifs;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100220 } else {
221 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100222 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100223 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100224 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100225check:
Radek Krejcia3045382018-11-22 14:30:31 +0100226 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100227 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100228 case LYS_ACTION:
229 case LYS_NOTIF:
230 case LYS_LEAF:
231 case LYS_ANYXML:
232 case LYS_ANYDATA:
233 case LYS_LIST:
234 case LYS_LEAFLIST:
235 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200236 case LYS_CASE:
237 if (options & LYS_GETNEXT_WITHCASE) {
238 break;
239 } else {
240 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100241 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200242 }
243 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100244 case LYS_CONTAINER:
245 if (!(((struct lysc_node_container *)next)->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
246 if (((struct lysc_node_container *)next)->child) {
247 /* go into */
248 next = ((struct lysc_node_container *)next)->child;
249 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100250 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100251 next = next->next;
252 }
253 goto repeat;
254 }
255 break;
256 case LYS_CHOICE:
257 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200258 break;
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100259 } else if ((options & LYS_GETNEXT_NOCHOICE) || !((struct lysc_node_choice *)next)->cases) {
260 next = next->next;
261 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100262 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200263 next = (struct lysc_node *)((struct lysc_node_choice *)next)->cases;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100264 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100265 /* go into */
266 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100267 }
Radek Krejcia3045382018-11-22 14:30:31 +0100268 }
269 goto repeat;
270 default:
271 /* we should not be here */
Radek Krejcib07b5c92019-04-08 10:56:37 +0200272 LOGINT(module ? module->mod->ctx : parent->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100273 return NULL;
274 }
275
Radek Krejcia3045382018-11-22 14:30:31 +0100276 return next;
277}
278
279API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100280lys_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 +0200281 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100282{
283 const struct lysc_node *node = NULL;
284
285 LY_CHECK_ARG_RET(NULL, module, name, NULL);
286 if (!nodetype) {
287 nodetype = 0xffff;
288 }
289
290 while ((node = lys_getnext(node, parent, module->compiled, options))) {
291 if (!(node->nodetype & nodetype)) {
292 continue;
293 }
294 if (node->module != module) {
295 continue;
296 }
297
298 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200299 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100300 return node;
301 }
302 } else {
303 if (!strcmp(node->name, name)) {
304 return node;
305 }
306 }
307 }
308 return NULL;
309}
310
Michal Vasko519fd602020-05-26 12:17:39 +0200311API LY_ERR
Radek Krejcibed13942020-10-19 16:06:28 +0200312lys_find_xpath_atoms(const struct lysc_node *ctx_node, const char *xpath, uint32_t options, struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200313{
314 LY_ERR ret = LY_SUCCESS;
315 struct lyxp_set xp_set;
Radek Krejcif03a9e22020-09-18 20:09:31 +0200316 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200317 uint32_t i;
318
319 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
320 if (!(options & LYXP_SCNODE_ALL)) {
321 options = LYXP_SCNODE;
322 }
323
324 memset(&xp_set, 0, sizeof xp_set);
325
326 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200327 ret = lyxp_expr_parse(ctx_node->module->ctx, xpath, 0, 1, &exp);
328 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200329
330 /* atomize expression */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200331 ret = lyxp_atomize(exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200332 LY_CHECK_GOTO(ret, cleanup);
333
334 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200335 ret = ly_set_new(set);
336 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200337
338 /* transform into ly_set */
339 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
340 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx_node->module->ctx); ret = LY_EMEM, cleanup);
341 (*set)->size = xp_set.used;
342
343 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200344 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200345 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200346 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200347 }
348 }
349
350cleanup:
351 lyxp_set_free_content(&xp_set);
352 lyxp_expr_free(ctx_node->module->ctx, exp);
353 return ret;
354}
355
Michal Vasko072de482020-08-05 13:27:21 +0200356API LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200357lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
358 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
359{
360 LY_ERR ret = LY_SUCCESS;
361 struct lyxp_set xp_set = {0};
362 uint32_t i;
363
364 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
365 if (!(options & LYXP_SCNODE_ALL)) {
366 options = LYXP_SCNODE;
367 }
368
369 /* atomize expression */
370 ret = lyxp_atomize(expr, cur_mod, LY_PREF_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, &xp_set, options);
371 LY_CHECK_GOTO(ret, cleanup);
372
373 /* allocate return set */
374 ret = ly_set_new(set);
375 LY_CHECK_GOTO(ret, cleanup);
376
377 /* transform into ly_set */
378 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
379 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
380 (*set)->size = xp_set.used;
381
382 for (i = 0; i < xp_set.used; ++i) {
383 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx == 1)) {
384 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
385 LY_CHECK_GOTO(ret, cleanup);
386 }
387 }
388
389cleanup:
390 lyxp_set_free_content(&xp_set);
391 if (ret) {
392 ly_set_free(*set, NULL);
393 *set = NULL;
394 }
395 return ret;
396}
397
398API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200399lys_find_xpath(const struct lysc_node *ctx_node, const char *xpath, uint32_t options, struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200400{
401 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200402 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200403 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200404 uint32_t i;
405
406 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
407 if (!(options & LYXP_SCNODE_ALL)) {
408 options = LYXP_SCNODE;
409 }
410
Michal Vasko072de482020-08-05 13:27:21 +0200411 /* compile expression */
Radek Krejcif03a9e22020-09-18 20:09:31 +0200412 ret = lyxp_expr_parse(ctx_node->module->ctx, xpath, 0, 1, &exp);
413 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200414
415 /* atomize expression */
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200416 ret = lyxp_atomize(exp, NULL, LY_PREF_JSON, NULL, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200417 LY_CHECK_GOTO(ret, cleanup);
418
419 /* allocate return set */
Radek Krejciba03a5a2020-08-27 14:40:41 +0200420 ret = ly_set_new(set);
421 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200422
423 /* transform into ly_set */
424 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
425 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx_node->module->ctx); ret = LY_EMEM, cleanup);
426 (*set)->size = xp_set.used;
427
428 for (i = 0; i < xp_set.used; ++i) {
429 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx == 1)) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200430 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200431 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200432 }
433 }
434
435cleanup:
436 lyxp_set_free_content(&xp_set);
437 lyxp_expr_free(ctx_node->module->ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200438 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200439 ly_set_free(*set, NULL);
440 *set = NULL;
441 }
Michal Vasko072de482020-08-05 13:27:21 +0200442 return ret;
443}
444
Radek Krejcibc5644c2020-10-27 14:53:17 +0100445API LY_ERR
446lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
447{
448 LY_ERR ret = LY_SUCCESS;
449 LY_ARRAY_COUNT_TYPE u, v;
450
451 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
452
453 /* allocate return set */
454 LY_CHECK_RET(ly_set_new(set));
455
456 LY_ARRAY_FOR(path, u) {
457 /* add nodes from the path */
458 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
459 if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) {
460 LY_ARRAY_FOR(path[u].predicates, v) {
461 /* add all the keys in a predicate */
462 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
463 }
464 }
465 }
466
467cleanup:
468 if (ret) {
469 ly_set_free(*set, NULL);
470 *set = NULL;
471 }
472 return ret;
473}
474
475API LY_ERR
476lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
477 struct ly_set **set)
478{
479 LY_ERR ret = LY_SUCCESS;
480 uint8_t oper;
481 struct lyxp_expr *expr = NULL;
482 struct ly_path *p = NULL;
483
484 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
485
486 if (!ctx) {
487 ctx = ctx_node->module->ctx;
488 }
489
490 /* parse */
491 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr);
492 LY_CHECK_GOTO(ret, cleanup);
493
494 /* compile */
495 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
496 ret = ly_path_compile(ctx, NULL, ctx_node, expr, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
497 LY_PREF_JSON, NULL, &p);
498 LY_CHECK_GOTO(ret, cleanup);
499
500 /* resolve */
501 ret = lys_find_lypath_atoms(p, set);
502
503cleanup:
504 ly_path_free(ctx, p);
505 lyxp_expr_free(ctx, expr);
506 return ret;
507}
508
509API const struct lysc_node *
510lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
511{
512 const struct lysc_node *snode = NULL;
513 struct lyxp_expr *exp = NULL;
514 struct ly_path *p = NULL;
515 LY_ERR ret;
516 uint8_t oper;
517
518 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
519
520 if (!ctx) {
521 ctx = ctx_node->module->ctx;
522 }
523
524 /* parse */
525 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
526 LY_CHECK_GOTO(ret, cleanup);
527
528 /* compile */
529 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
530 ret = ly_path_compile(ctx, NULL, ctx_node, exp, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
531 LY_PREF_JSON, NULL, &p);
532 LY_CHECK_GOTO(ret, cleanup);
533
534 /* get last node */
535 snode = p[LY_ARRAY_COUNT(p) - 1].node;
536
537cleanup:
538 ly_path_free(ctx, p);
539 lyxp_expr_free(ctx, exp);
540 return snode;
541}
542
Michal Vasko14654712020-02-06 08:35:21 +0100543char *
544lysc_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 +0200545 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200546{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200547 const struct lysc_node *iter;
Radek Krejci327de162019-06-14 12:52:07 +0200548 char *path = NULL;
549 int len = 0;
550
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200551 LY_CHECK_ARG_RET(NULL, node, NULL);
552 if (buffer) {
553 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
554 }
555
Radek Krejci327de162019-06-14 12:52:07 +0200556 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200557 case LYSC_PATH_LOG:
Michal Vasko65de0402020-08-03 16:34:19 +0200558 case LYSC_PATH_DATA:
Michal Vasko90932a92020-02-12 14:33:03 +0100559 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Michal Vasko11deea12020-08-05 13:54:50 +0200560 char *s, *id;
Michal Vasko14654712020-02-06 08:35:21 +0100561 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200562
Michal Vasko65de0402020-08-03 16:34:19 +0200563 if ((pathtype == LYSC_PATH_DATA) && (iter->nodetype & (LYS_CHOICE | LYS_CASE))) {
564 /* schema-only node */
565 continue;
566 }
567
Michal Vasko11deea12020-08-05 13:54:50 +0200568 s = buffer ? strdup(buffer) : path;
Michal Vasko03ff5a72019-09-11 13:49:33 +0200569 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100570 if (parent && (iter->parent == parent)) {
571 slash = "";
572 } else {
573 slash = "/";
574 }
Michal Vasko69730152020-10-09 16:30:07 +0200575 if (!iter->parent || (iter->parent->module != iter->module)) {
Radek Krejci327de162019-06-14 12:52:07 +0200576 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200577 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100578 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200579 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100580 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200581 }
Radek Krejci327de162019-06-14 12:52:07 +0200582 } else {
583 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200584 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100585 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200586 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100587 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200588 }
Radek Krejci327de162019-06-14 12:52:07 +0200589 }
590 free(s);
591 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200592
Michal Vasko69730152020-10-09 16:30:07 +0200593 if (buffer && (buflen <= (size_t)len)) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200594 /* not enough space in buffer */
595 break;
596 }
Radek Krejci327de162019-06-14 12:52:07 +0200597 }
598
599 if (len < 0) {
600 free(path);
601 path = NULL;
602 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200603 if (buffer) {
604 strcpy(buffer, "/");
605 } else {
606 path = strdup("/");
607 }
Radek Krejci327de162019-06-14 12:52:07 +0200608 }
609 break;
610 }
611
Radek Krejci1c0c3442019-07-23 16:08:47 +0200612 if (buffer) {
613 return buffer;
614 } else {
615 return path;
616 }
Radek Krejci327de162019-06-14 12:52:07 +0200617}
618
Michal Vasko14654712020-02-06 08:35:21 +0100619API char *
620lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
621{
622 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
623}
624
Michal Vasko28d78432020-05-26 13:10:53 +0200625API LY_ERR
Radek Krejciaf9cd802020-10-06 21:59:47 +0200626lysc_set_private(const struct lysc_node *node, void *priv, void **prev_priv_p)
Radek Krejci19cf8052020-08-18 15:02:38 +0200627{
Radek Krejciaf9cd802020-10-06 21:59:47 +0200628 struct lysc_action *act;
629 struct lysc_notif *notif;
630
Radek Krejci19cf8052020-08-18 15:02:38 +0200631 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
632
Radek Krejciaf9cd802020-10-06 21:59:47 +0200633 switch (node->nodetype) {
634 case LYS_CONTAINER:
635 case LYS_CHOICE:
636 case LYS_CASE:
637 case LYS_LEAF:
638 case LYS_LEAFLIST:
639 case LYS_LIST:
640 case LYS_ANYXML:
641 case LYS_ANYDATA:
642 if (prev_priv_p) {
643 *prev_priv_p = node->priv;
644 }
645 ((struct lysc_node *)node)->priv = priv;
646 break;
647 case LYS_RPC:
648 case LYS_ACTION:
649 act = (struct lysc_action *)node;
650 if (prev_priv_p) {
651 *prev_priv_p = act->priv;
652 }
653 act->priv = priv;
654 break;
655 case LYS_NOTIF:
656 notif = (struct lysc_notif *)node;
657 if (prev_priv_p) {
658 *prev_priv_p = notif->priv;
659 }
660 notif->priv = priv;
661 break;
662 default:
663 return LY_EINVAL;
Radek Krejci19cf8052020-08-18 15:02:38 +0200664 }
Radek Krejci19cf8052020-08-18 15:02:38 +0200665
666 return LY_SUCCESS;
667}
668
Michal Vasko89b5c072020-10-06 13:52:44 +0200669API LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100670lys_set_implemented(struct lys_module *mod, const char **features)
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200671{
Michal Vasko916aefb2020-11-02 15:43:16 +0100672 LY_ERR ret = LY_SUCCESS;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200673 struct lys_module *m;
Michal Vasko89b5c072020-10-06 13:52:44 +0200674 uint32_t i, idx;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200675
676 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
677
678 if (mod->implemented) {
Michal Vasko89b5c072020-10-06 13:52:44 +0200679 /* mod is already implemented */
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200680 return LY_SUCCESS;
681 }
682
683 /* we have module from the current context */
684 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
685 if (m) {
Michal Vasko89b5c072020-10-06 13:52:44 +0200686 assert(m != mod);
687
688 /* check collision with other implemented revision */
689 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
690 mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
691 return LY_EDENIED;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200692 }
693
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100694 /* enable features */
695 LY_CHECK_RET(lys_enable_features(mod->parsed, features));
696
Michal Vasko89b5c072020-10-06 13:52:44 +0200697 /* add the module into newly implemented module set */
Radek Krejci3d92e442020-10-12 12:48:13 +0200698 LY_CHECK_RET(ly_set_add(&mod->ctx->implementing, mod, 1, NULL));
Michal Vasko89b5c072020-10-06 13:52:44 +0200699
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200700 /* mark the module implemented, check for collision was already done */
Michal Vasko89b5c072020-10-06 13:52:44 +0200701 mod->implemented = 1;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200702
703 /* compile the schema */
Michal Vasko89b5c072020-10-06 13:52:44 +0200704 ret = lys_compile(mod, 0);
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200705
Michal Vasko89b5c072020-10-06 13:52:44 +0200706 if (mod == mod->ctx->implementing.objs[0]) {
707 /* the first module being implemented, consolidate the set */
708 if (ret) {
709 /* failure, full compile revert */
710 for (i = 0; i < mod->ctx->list.count; ++i) {
711 m = mod->ctx->list.objs[i];
712 if (ly_set_contains(&mod->ctx->implementing, m, &idx)) {
713 assert(m->implemented);
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200714
Michal Vasko89b5c072020-10-06 13:52:44 +0200715 /* make the module correctly non-implemented again */
716 m->implemented = 0;
717 ly_set_rm_index(&mod->ctx->implementing, idx, NULL);
718 lys_precompile_augments_deviations_revert(mod->ctx, m);
719 }
Michal Vasko89b5c072020-10-06 13:52:44 +0200720 }
Michal Vasko916aefb2020-11-02 15:43:16 +0100721
722 /* recompile, do not overwrite return value */
723 lys_recompile(mod->ctx, NULL);
Michal Vasko89b5c072020-10-06 13:52:44 +0200724 }
725
726 ly_set_erase(&mod->ctx->implementing, NULL);
727 }
728 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200729}
730
Michal Vasko7c8439f2020-08-05 13:25:19 +0200731static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100732lys_resolve_import_include(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
Michal Vasko7c8439f2020-08-05 13:25:19 +0200733{
734 struct lysp_import *imp;
735 struct lysp_include *inc;
736 LY_ARRAY_COUNT_TYPE u, v;
737
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100738 pmod->parsing = 1;
739 LY_ARRAY_FOR(pmod->imports, u) {
740 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +0200741 if (!imp->module) {
Michal Vasko0550b762020-11-24 18:04:08 +0100742 LY_CHECK_RET(lysp_load_module(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, 0, NULL, &imp->module));
Michal Vasko7c8439f2020-08-05 13:25:19 +0200743 }
744 /* check for importing the same module twice */
745 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100746 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200747 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
748 }
749 }
750 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100751 LY_ARRAY_FOR(pmod->includes, u) {
752 inc = &pmod->includes[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +0200753 if (!inc->submodule) {
754 LY_CHECK_RET(lysp_load_submodule(pctx, inc));
755 }
756 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100757 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200758
759 return LY_SUCCESS;
760}
761
Michal Vasko3a41dff2020-07-15 14:30:28 +0200762LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +0200763lys_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 +0200764 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
Radek Krejci0f969882020-08-21 16:56:47 +0200765 void *check_data, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200766{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200767 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100768 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +0100769 struct lys_yang_parser_ctx *yangctx = NULL;
770 struct lys_yin_parser_ctx *yinctx = NULL;
771 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100772
Michal Vasko3a41dff2020-07-15 14:30:28 +0200773 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100774
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100775 switch (format) {
776 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +0200777 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100778 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100779 break;
780 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +0200781 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskob36053d2020-03-26 15:49:30 +0100782 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100783 break;
784 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +0200785 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +0200786 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100787 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200788 }
Radek Krejcif6923e82020-07-02 16:36:53 +0200789 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +0200790 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100791
792 /* make sure that the newest revision is at position 0 */
793 lysp_sort_revisions(submod->revs);
794
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100795 /* decide the latest revision */
Michal Vaskoc3781c32020-10-06 14:04:08 +0200796 latest_sp = ly_ctx_get_submodule(NULL, submod->mod, submod->name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100797 if (latest_sp) {
798 if (submod->revs) {
799 if (!latest_sp->revs) {
800 /* latest has no revision, so mod is anyway newer */
801 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +0200802 /* the latest_sp is zeroed later when the new module is being inserted into the context */
803 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
804 submod->latest_revision = latest_sp->latest_revision;
805 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100806 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +0200807 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100808 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200809 } else {
810 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100811 }
812 } else {
813 submod->latest_revision = 1;
814 }
815
Radek Krejcib3289d62019-09-18 12:21:39 +0200816 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200817 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +0200818 }
819
820 if (latest_sp) {
821 latest_sp->latest_revision = 0;
822 }
823
Michal Vasko7a0b0762020-09-02 16:37:01 +0200824 lys_parser_fill_filepath(ctx, in, &submod->filepath);
825
Michal Vasko7c8439f2020-08-05 13:25:19 +0200826 /* resolve imports and includes */
827 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, (struct lysp_module *)submod), error);
828
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100829 /* remap possibly changed and reallocated typedefs and groupings list back to the main context */
Michal Vaskob36053d2020-03-26 15:49:30 +0100830 memcpy(&main_ctx->tpdfs_nodes, &pctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
831 memcpy(&main_ctx->grps_nodes, &pctx->grps_nodes, sizeof main_ctx->grps_nodes);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100832
David Sedlák1b623122019-08-05 15:27:49 +0200833 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100834 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200835 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100836 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200837 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200838 *submodule = submod;
839 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +0200840
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100841error:
Michal Vasko5d24f6c2020-10-13 13:49:06 +0200842 lysp_module_free((struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +0200843 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100844 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200845 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100846 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200847 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200848 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200849}
850
Michal Vasko45b521c2020-11-04 17:14:39 +0100851/**
852 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
853 *
854 * @param[in] mod Parsed module to add to.
855 * @return LY_SUCCESS on success.
856 * @return LY_ERR on error.
857 */
858static LY_ERR
859lys_parsed_add_internal_ietf_netconf(struct lysp_module *mod)
860{
861 struct lysp_ext_instance *ext_p;
862 struct lysp_stmt *stmt;
863 struct lysp_import *imp;
864
865 /*
866 * 1) edit-config's operation
867 */
868 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
869 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
870 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
871 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &ext_p->argument));
872 ext_p->flags = LYS_INTERNAL;
873 ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
874 ext_p->insubstmt_index = 0;
875
876 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
877 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
878 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
879 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
880 stmt->kw = LY_STMT_TYPE;
881
882 stmt->child = calloc(1, sizeof *stmt->child);
883 stmt = stmt->child;
884 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
885 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
886 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
887 stmt->kw = LY_STMT_ENUM;
888
889 stmt->next = calloc(1, sizeof *stmt->child);
890 stmt = stmt->next;
891 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
892 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
893 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
894 stmt->kw = LY_STMT_ENUM;
895
896 stmt->next = calloc(1, sizeof *stmt->child);
897 stmt = stmt->next;
898 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
899 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
900 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
901 stmt->kw = LY_STMT_ENUM;
902
903 stmt->next = calloc(1, sizeof *stmt->child);
904 stmt = stmt->next;
905 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
906 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
907 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
908 stmt->kw = LY_STMT_ENUM;
909
910 stmt->next = calloc(1, sizeof *stmt->child);
911 stmt = stmt->next;
912 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
913 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
914 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
915 stmt->kw = LY_STMT_ENUM;
916
917 /*
918 * 2) filter's type
919 */
920 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
921 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
922 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
923 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &ext_p->argument));
924 ext_p->flags = LYS_INTERNAL;
925 ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
926 ext_p->insubstmt_index = 0;
927
928 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
929 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
930 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
931 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
932 stmt->kw = LY_STMT_TYPE;
933
934 stmt->child = calloc(1, sizeof *stmt->child);
935 stmt = stmt->child;
936 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
937 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
938 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
939 stmt->kw = LY_STMT_ENUM;
940
941 stmt->next = calloc(1, sizeof *stmt->child);
942 stmt = stmt->next;
943 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
944 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
945 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
946 stmt->kw = LY_STMT_ENUM;
947
948 /* if-feature for enum allowed only for YANG 1.1 modules */
949 if (mod->version >= LYS_VERSION_1_1) {
950 stmt->child = calloc(1, sizeof *stmt->child);
951 stmt = stmt->child;
952 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
953 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
954 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
955 stmt->kw = LY_STMT_IF_FEATURE;
956 }
957
958 /*
959 * 3) filter's select
960 */
961 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
962 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
963 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
964 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &ext_p->argument));
965 ext_p->flags = LYS_INTERNAL;
966 ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
967 ext_p->insubstmt_index = 0;
968
969 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
970 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
971 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
972 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
973 stmt->kw = LY_STMT_TYPE;
974
975 /* create new imports for the used prefixes */
976 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
977
978 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
979 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
980 imp->flags = LYS_INTERNAL;
981
982 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
983
984 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
985 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
986 imp->flags = LYS_INTERNAL;
987
988 return LY_SUCCESS;
989}
990
991/**
992 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
993 *
994 * @param[in] mod Parsed module to add to.
995 * @return LY_SUCCESS on success.
996 * @return LY_ERR on error.
997 */
998static LY_ERR
999lys_parsed_add_internal_ietf_netconf_with_defaults(struct lysp_module *mod)
1000{
1001 struct lysp_ext_instance *ext_p;
1002 struct lysp_stmt *stmt;
1003 struct lysp_import *imp;
1004
1005 /* add new extension instance */
1006 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, ext_p, LY_EMEM);
1007
1008 /* fill in the extension instance fields */
1009 LY_CHECK_ERR_RET(!ext_p, LOGMEM(mod->mod->ctx), LY_EMEM);
1010 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &ext_p->name));
1011 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &ext_p->argument));
1012 ext_p->flags = LYS_INTERNAL;
1013 ext_p->insubstmt = LYEXT_SUBSTMT_SELF;
1014 ext_p->insubstmt_index = 0;
1015
1016 ext_p->child = stmt = calloc(1, sizeof *ext_p->child);
1017 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1018 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1019 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
1020 stmt->kw = LY_STMT_TYPE;
1021
1022 /* create new import for the used prefix */
1023 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
1024
1025 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1026 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1027 imp->flags = LYS_INTERNAL;
1028
1029 return LY_SUCCESS;
1030}
1031
Michal Vasko3a41dff2020-07-15 14:30:28 +02001032LY_ERR
Michal Vasko7a0b0762020-09-02 16:37:01 +02001033lys_create_module(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, ly_bool implement,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001034 LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001035 void *check_data, const char **features, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001036{
Radek Krejci6d6e4e42018-10-29 13:28:19 +01001037 struct lys_module *mod = NULL, *latest, *mod_dup;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001038 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001039 LY_ERR ret;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001040 LY_ARRAY_COUNT_TYPE u;
Michal Vaskob36053d2020-03-26 15:49:30 +01001041 struct lys_yang_parser_ctx *yangctx = NULL;
1042 struct lys_yin_parser_ctx *yinctx = NULL;
Radek Krejcif6923e82020-07-02 16:36:53 +02001043 struct lys_parser_ctx *pctx = NULL;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001044 char *filename, *rev, *dot;
1045 size_t len;
Radek Krejci86d106e2018-10-18 09:53:19 +02001046
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001047 LY_CHECK_ARG_RET(ctx, ctx, in, !features || implement, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001048 if (module) {
1049 *module = NULL;
1050 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001051
1052 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001053 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001054 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001055
1056 switch (format) {
1057 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001058 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001059 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001060 break;
1061 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001062 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskob36053d2020-03-26 15:49:30 +01001063 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001064 break;
1065 default:
1066 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001067 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001068 break;
1069 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001070 LY_CHECK_GOTO(ret, error);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001071
1072 /* make sure that the newest revision is at position 0 */
1073 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001074 if (mod->parsed->revs) {
Radek Krejci011e4aa2020-09-04 15:22:31 +02001075 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), error);
Radek Krejci0af46292019-01-11 16:02:31 +01001076 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001077
Radek Krejcib3289d62019-09-18 12:21:39 +02001078 /* decide the latest revision */
Michal Vasko22df3f02020-08-24 13:29:22 +02001079 latest = (struct lys_module *)ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001080 if (latest) {
1081 if (mod->revision) {
1082 if (!latest->revision) {
1083 /* latest has no revision, so mod is anyway newer */
1084 mod->latest_revision = latest->latest_revision;
1085 /* the latest is zeroed later when the new module is being inserted into the context */
1086 } else if (strcmp(mod->revision, latest->revision) > 0) {
1087 mod->latest_revision = latest->latest_revision;
1088 /* the latest is zeroed later when the new module is being inserted into the context */
1089 } else {
1090 latest = NULL;
1091 }
1092 } else {
1093 latest = NULL;
1094 }
1095 } else {
1096 mod->latest_revision = 1;
1097 }
1098
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001099 if (custom_check) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001100 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), error);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001101 }
1102
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001103 /* check for duplicity in the context */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001104 if (implement && ly_ctx_get_module_implemented(ctx, mod->name)) {
1105 LOGERR(ctx, LY_EDENIED, "Module \"%s\" is already implemented in the context.", mod->name);
1106 ret = LY_EDENIED;
1107 goto error;
1108 }
Michal Vasko22df3f02020-08-24 13:29:22 +02001109 mod_dup = (struct lys_module *)ly_ctx_get_module(ctx, mod->name, mod->revision);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001110 if (mod_dup) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001111 if (mod->parsed->revs) {
1112 LOGERR(ctx, LY_EEXIST, "Module \"%s\" of revision \"%s\" is already present in the context.",
1113 mod->name, mod->parsed->revs[0].date);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001114 } else {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001115 LOGERR(ctx, LY_EEXIST, "Module \"%s\" with no revision is already present in the context.",
1116 mod->name);
Radek Krejcid33273d2018-10-25 14:55:52 +02001117 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001118 ret = LY_EEXIST;
1119 goto error;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001120 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001121
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001122 switch (in->type) {
1123 case LY_IN_FILEPATH:
1124 /* check that name and revision match filename */
1125 filename = strrchr(in->method.fpath.filepath, '/');
1126 if (!filename) {
1127 filename = in->method.fpath.filepath;
1128 } else {
1129 filename++;
1130 }
1131 rev = strchr(filename, '@');
1132 dot = strrchr(filename, '.');
1133
1134 /* name */
1135 len = strlen(mod->name);
1136 if (strncmp(filename, mod->name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001137 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001138 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1139 }
1140 if (rev) {
1141 len = dot - ++rev;
Michal Vasko69730152020-10-09 16:30:07 +02001142 if (!mod->parsed->revs || (len != 10) || strncmp(mod->parsed->revs[0].date, rev, len)) {
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001143 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +02001144 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001145 }
1146 }
1147
1148 break;
1149 case LY_IN_FD:
1150 case LY_IN_FILE:
1151 case LY_IN_MEMORY:
1152 /* nothing special to do */
1153 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001154 case LY_IN_ERROR:
1155 LOGINT(ctx);
1156 ret = LY_EINT;
1157 goto error;
Radek Krejci096235c2019-01-11 11:12:19 +01001158 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001159 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001160
Michal Vasko7a0b0762020-09-02 16:37:01 +02001161 if (latest) {
1162 latest->latest_revision = 0;
1163 }
1164
Michal Vasko45b521c2020-11-04 17:14:39 +01001165 /* add internal data in case specific modules were parsed */
1166 if (!strcmp(mod->name, "ietf-netconf")) {
1167 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf(mod->parsed), error);
1168 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
1169 LY_CHECK_GOTO(ret = lys_parsed_add_internal_ietf_netconf_with_defaults(mod->parsed), error);
1170 }
1171
Michal Vasko7a0b0762020-09-02 16:37:01 +02001172 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001173 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001174 LY_CHECK_GOTO(ret, error);
1175 ctx->module_set_id++;
1176
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001177 /* resolve includes and all imports */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001178 LY_CHECK_GOTO(ret = lys_resolve_import_include(pctx, mod->parsed), error_ctx);
1179
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001180 /* check name collisions */
1181 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), error_ctx);
1182 /* TODO groupings */
1183 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), error_ctx);
1184 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), error_ctx);
1185
1186 /* compile features */
1187 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), error_ctx);
1188
Michal Vasko89b5c072020-10-06 13:52:44 +02001189 if (!implement) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001190 /* pre-compile identities of the module */
1191 LY_CHECK_GOTO(ret = lys_identity_precompile(NULL, ctx, mod->parsed, mod->parsed->identities, &mod->identities), error);
1192
1193 /* pre-compile identities of any submodules */
Michal Vasko7a0b0762020-09-02 16:37:01 +02001194 LY_ARRAY_FOR(mod->parsed->includes, u) {
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001195 submod = mod->parsed->includes[u].submodule;
Michal Vasko5d24f6c2020-10-13 13:49:06 +02001196 ret = lys_identity_precompile(NULL, ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
1197 LY_CHECK_GOTO(ret, error);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001198 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001199 } else {
Michal Vasko89b5c072020-10-06 13:52:44 +02001200 /* implement (compile) */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001201 LY_CHECK_GOTO(ret = lys_set_implemented(mod, features), error_ctx);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001202 }
1203
1204 if (format == LYS_IN_YANG) {
1205 yang_parser_ctx_free(yangctx);
1206 } else {
1207 yin_parser_ctx_free(yinctx);
1208 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001209 if (module) {
1210 *module = mod;
1211 }
1212 return LY_SUCCESS;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001213
1214error_ctx:
1215 ly_set_rm(&ctx->list, mod, NULL);
1216error:
1217 lys_module_free(mod, NULL);
1218 if (pctx) {
1219 ly_set_erase(&pctx->tpdfs_nodes, NULL);
1220 }
1221 if (format == LYS_IN_YANG) {
1222 yang_parser_ctx_free(yangctx);
1223 } else {
1224 yin_parser_ctx_free(yinctx);
1225 }
1226
1227 return ret;
1228}
1229
Radek Krejci545b4872020-11-15 10:15:12 +01001230static LYS_INFORMAT
1231lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1232{
1233 if (!format && (in->type == LY_IN_FILEPATH)) {
1234 /* unknown format - try to detect it from filename's suffix */
1235 const char *path = in->method.fpath.filepath;
1236 size_t len = strlen(path);
1237
1238 /* ignore trailing whitespaces */
1239 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1240
1241 if ((len >= 5) && !strncmp(&path[len - 5], ".yang", 5)) {
1242 format = LYS_IN_YANG;
1243 } else if ((len >= 6) && !strncmp(&path[len - 4], ".yin", 4)) {
1244 format = LYS_IN_YIN;
1245 } /* else still unknown */
1246 }
1247
1248 return format;
1249}
1250
Michal Vasko7a0b0762020-09-02 16:37:01 +02001251API LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001252lys_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 +02001253{
1254 if (module) {
1255 *module = NULL;
1256 }
Radek Krejci545b4872020-11-15 10:15:12 +01001257 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1258
1259 format = lys_parse_get_format(in, format);
1260 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001261
1262 /* remember input position */
1263 in->func_start = in->current;
1264
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001265 return lys_create_module(ctx, in, format, 1, NULL, NULL, features, (struct lys_module **)module);
Radek Krejci86d106e2018-10-18 09:53:19 +02001266}
1267
Michal Vasko3a41dff2020-07-15 14:30:28 +02001268API LY_ERR
1269lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001270{
Radek Krejci0f969882020-08-21 16:56:47 +02001271 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001272 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001273
Michal Vasko3a41dff2020-07-15 14:30:28 +02001274 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001275
Michal Vasko3a41dff2020-07-15 14:30:28 +02001276 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 +02001277
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001278 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001279 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001280
Michal Vasko3a41dff2020-07-15 14:30:28 +02001281 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001282}
1283
Michal Vasko3a41dff2020-07-15 14:30:28 +02001284API LY_ERR
1285lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001286{
Radek Krejci0f969882020-08-21 16:56:47 +02001287 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001288 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001289
Michal Vasko3a41dff2020-07-15 14:30:28 +02001290 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001291
Michal Vasko3a41dff2020-07-15 14:30:28 +02001292 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 +02001293
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001294 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001295 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001296
Michal Vasko3a41dff2020-07-15 14:30:28 +02001297 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001298}
1299
Michal Vasko3a41dff2020-07-15 14:30:28 +02001300API LY_ERR
1301lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, const struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02001302{
Radek Krejci0f969882020-08-21 16:56:47 +02001303 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001304 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001305
Michal Vasko3a41dff2020-07-15 14:30:28 +02001306 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001307
Michal Vasko3a41dff2020-07-15 14:30:28 +02001308 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02001309 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001310
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001311 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001312 ly_in_free(in, 0);
1313
Michal Vasko3a41dff2020-07-15 14:30:28 +02001314 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02001315}
1316
1317API LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001318lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02001319 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02001320{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001321 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02001322 size_t len, flen, match_len = 0, dir_len;
Radek Krejci857189e2020-09-01 13:26:36 +02001323 ly_bool implicit_cwd = 0;
Radek Krejcid33273d2018-10-25 14:55:52 +02001324 char *wd, *wn = NULL;
1325 DIR *dir = NULL;
1326 struct dirent *file;
1327 char *match_name = NULL;
1328 LYS_INFORMAT format_aux, match_format = 0;
1329 struct ly_set *dirs;
1330 struct stat st;
1331
1332 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1333
1334 /* start to fill the dir fifo with the context's search path (if set)
1335 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001336 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02001337
1338 len = strlen(name);
1339 if (cwd) {
1340 wd = get_current_dir_name();
1341 if (!wd) {
1342 LOGMEM(NULL);
1343 goto cleanup;
1344 } else {
1345 /* add implicit current working directory (./) to be searched,
1346 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001347 ret = ly_set_add(dirs, wd, 0, NULL);
1348 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001349 implicit_cwd = 1;
1350 }
1351 }
1352 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02001353 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001354 /* check for duplicities with the implicit current working directory */
1355 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1356 implicit_cwd = 0;
1357 continue;
1358 }
1359 wd = strdup(searchpaths[i]);
1360 if (!wd) {
1361 LOGMEM(NULL);
1362 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02001363 } else {
1364 ret = ly_set_add(dirs, wd, 0, NULL);
1365 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02001366 }
1367 }
1368 }
1369 wd = NULL;
1370
1371 /* start searching */
1372 while (dirs->count) {
1373 free(wd);
1374 free(wn); wn = NULL;
1375
1376 dirs->count--;
1377 wd = (char *)dirs->objs[dirs->count];
1378 dirs->objs[dirs->count] = NULL;
1379 LOGVRB("Searching for \"%s\" in %s.", name, wd);
1380
1381 if (dir) {
1382 closedir(dir);
1383 }
1384 dir = opendir(wd);
1385 dir_len = strlen(wd);
1386 if (!dir) {
1387 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1388 } else {
1389 while ((file = readdir(dir))) {
1390 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1391 /* skip . and .. */
1392 continue;
1393 }
1394 free(wn);
1395 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1396 LOGMEM(NULL);
1397 goto cleanup;
1398 }
1399 if (stat(wn, &st) == -1) {
1400 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
Michal Vasko69730152020-10-09 16:30:07 +02001401 file->d_name, wd, strerror(errno));
Radek Krejcid33273d2018-10-25 14:55:52 +02001402 continue;
1403 }
1404 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1405 /* we have another subdirectory in searchpath to explore,
1406 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
Radek Krejciba03a5a2020-08-27 14:40:41 +02001407 ret = ly_set_add(dirs, wn, 0, NULL);
1408 LY_CHECK_GOTO(ret, cleanup);
1409
Radek Krejcid33273d2018-10-25 14:55:52 +02001410 /* continue with the next item in current directory */
1411 wn = NULL;
1412 continue;
1413 } else if (!S_ISREG(st.st_mode)) {
1414 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1415 continue;
1416 }
1417
1418 /* here we know that the item is a file which can contain a module */
1419 if (strncmp(name, file->d_name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +02001420 ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001421 /* different filename than the module we search for */
1422 continue;
1423 }
1424
1425 /* get type according to filename suffix */
1426 flen = strlen(file->d_name);
Radek Krejcied5acc52019-04-25 15:57:04 +02001427 if (!strcmp(&file->d_name[flen - 5], ".yang")) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001428 format_aux = LYS_IN_YANG;
Radek Krejci01a937f2020-11-15 10:14:12 +01001429 } else if (!strcmp(&file->d_name[flen - 4], ".yin")) {
1430 format_aux = LYS_IN_YIN;
Radek Krejcid33273d2018-10-25 14:55:52 +02001431 } else {
1432 /* not supportde suffix/file format */
1433 continue;
1434 }
1435
1436 if (revision) {
1437 /* we look for the specific revision, try to get it from the filename */
1438 if (file->d_name[len] == '@') {
1439 /* check revision from the filename */
1440 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1441 /* another revision */
1442 continue;
1443 } else {
1444 /* exact revision */
1445 free(match_name);
1446 match_name = wn;
1447 wn = NULL;
1448 match_len = dir_len + 1 + len;
1449 match_format = format_aux;
1450 goto success;
1451 }
1452 } else {
1453 /* continue trying to find exact revision match, use this only if not found */
1454 free(match_name);
1455 match_name = wn;
1456 wn = NULL;
Michal Vasko44f3d2c2020-08-24 09:49:38 +02001457 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02001458 match_format = format_aux;
1459 continue;
1460 }
1461 } else {
1462 /* remember the revision and try to find the newest one */
1463 if (match_name) {
Michal Vasko69730152020-10-09 16:30:07 +02001464 if ((file->d_name[len] != '@') ||
1465 lysp_check_date(NULL, &file->d_name[len + 1], flen - ((format_aux == LYS_IN_YANG) ? 5 : 4) - len - 1, NULL)) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001466 continue;
Michal Vasko69730152020-10-09 16:30:07 +02001467 } else if ((match_name[match_len] == '@') &&
Radek Krejcid33273d2018-10-25 14:55:52 +02001468 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1469 continue;
1470 }
1471 free(match_name);
1472 }
1473
1474 match_name = wn;
1475 wn = NULL;
1476 match_len = dir_len + 1 + len;
1477 match_format = format_aux;
1478 continue;
1479 }
1480 }
1481 }
1482 }
1483
1484success:
1485 (*localfile) = match_name;
1486 match_name = NULL;
1487 if (format) {
1488 (*format) = match_format;
1489 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02001490 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02001491
1492cleanup:
1493 free(wn);
1494 free(wd);
1495 if (dir) {
1496 closedir(dir);
1497 }
1498 free(match_name);
1499 ly_set_free(dirs, free);
1500
1501 return ret;
1502}