blob: d63ab0628a6c1e210b11f4d66b9a3a64b8dfc633 [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 Krejcid33273d2018-10-25 14:55:52 +020020#include <dirent.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020021#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdint.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020023#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020024#include <stdlib.h>
25#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020026#include <sys/stat.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020027#include <unistd.h>
Radek Krejci3f5e3db2018-10-11 15:57:47 +020028
Radek Krejcica376bd2020-06-11 16:04:06 +020029#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020030#include "compat.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020031#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020032#include "dict.h"
33#include "log.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020034#include "parser.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020035#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020036#include "parser_schema.h"
37#include "set.h"
38#include "tree.h"
39#include "tree_schema_internal.h"
40#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020041
Radek Krejcia3045382018-11-22 14:30:31 +010042API const struct lysc_node *
43lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, int options)
44{
Radek Krejci6eeb58f2019-02-22 16:29:37 +010045 const struct lysc_node *next = NULL;
Radek Krejcia3045382018-11-22 14:30:31 +010046 struct lysc_node **snode;
Radek Krejci6eeb58f2019-02-22 16:29:37 +010047 int action_flag = 0, notif_flag = 0;
48 const struct lysc_action *actions;
49 const struct lysc_notif *notifs;
Radek Krejci7eb54ba2020-05-18 16:30:04 +020050 LY_ARRAY_SIZE_TYPE u;
Radek Krejcia3045382018-11-22 14:30:31 +010051
52 LY_CHECK_ARG_RET(NULL, parent || module, NULL);
53
Radek Krejcid5a2b9d2019-04-12 10:39:30 +020054next:
Radek Krejcia3045382018-11-22 14:30:31 +010055 if (!last) {
56 /* first call */
57
58 /* get know where to start */
59 if (parent) {
60 /* schema subtree */
Radek Krejci056d0a82018-12-06 16:57:25 +010061 if (parent->nodetype == LYS_CHOICE && (options & LYS_GETNEXT_WITHCASE)) {
Radek Krejcid5a2b9d2019-04-12 10:39:30 +020062 if (((struct lysc_node_choice*)parent)->cases) {
63 next = last = (const struct lysc_node*)&((struct lysc_node_choice*)parent)->cases[0];
Radek Krejci056d0a82018-12-06 16:57:25 +010064 }
Radek Krejci056d0a82018-12-06 16:57:25 +010065 } else {
Radek Krejci6eeb58f2019-02-22 16:29:37 +010066 snode = lysc_node_children_p(parent, (options & LYS_GETNEXT_OUTPUT) ? LYS_CONFIG_R : LYS_CONFIG_W);
Radek Krejci05b774b2019-02-25 13:26:18 +010067 /* do not return anything if the node does not have any children */
Radek Krejcid5a2b9d2019-04-12 10:39:30 +020068 if (snode && *snode) {
69 next = last = *snode;
Radek Krejci056d0a82018-12-06 16:57:25 +010070 }
Radek Krejcia3045382018-11-22 14:30:31 +010071 }
Radek Krejcia3045382018-11-22 14:30:31 +010072 } else {
73 /* top level data */
74 next = last = module->data;
75 }
76 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +010077 /* try to get action or notification */
78 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +010079 }
Radek Krejci05b774b2019-02-25 13:26:18 +010080 /* test if the next can be returned */
81 goto check;
82
Michal Vasko1bf09392020-03-27 12:38:10 +010083 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +010084 action_flag = 1;
Radek Krejci6eeb58f2019-02-22 16:29:37 +010085 if (last->parent) {
86 actions = lysc_node_actions(last->parent);
87 } else {
88 actions = module->rpcs;
89 }
90 LY_ARRAY_FOR(actions, u) {
91 if (&actions[u] == (struct lysc_action*)last) {
92 break;
93 }
94 }
95 if (u + 1 < LY_ARRAY_SIZE(actions)) {
96 next = (struct lysc_node*)(&actions[u + 1]);
97 }
98 goto repeat;
99 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100100 action_flag = notif_flag = 1;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100101 if (last->parent) {
102 notifs = lysc_node_notifs(last->parent);
103 } else {
104 notifs = module->notifs;
105 }
106 LY_ARRAY_FOR(notifs, u) {
107 if (&notifs[u] == (struct lysc_notif*)last) {
108 break;
109 }
110 }
111 if (u + 1 < LY_ARRAY_SIZE(notifs)) {
112 next = (struct lysc_node*)(&notifs[u + 1]);
113 }
114 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100115 }
116
117 next = last->next;
118repeat:
Radek Krejci01342af2019-01-03 15:18:08 +0100119 if (next && parent && parent->nodetype == LYS_CASE && next->parent != parent) {
120 /* inside case (as an explicit parent, not when diving into it from choice),
121 * limit the list of children only to the specific case */
122 next = NULL;
123 }
Radek Krejcia3045382018-11-22 14:30:31 +0100124 if (!next) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100125 /* possibly go back to parent */
Radek Krejci05b774b2019-02-25 13:26:18 +0100126 if (last && last->parent != parent) {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100127 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200128 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100129 } else if (!action_flag) {
130 action_flag = 1;
131 next = parent ? (struct lysc_node*)lysc_node_actions(parent) : (struct lysc_node*)module->rpcs;
132 } else if (!notif_flag) {
133 notif_flag = 1;
134 next = parent ? (struct lysc_node*)lysc_node_notifs(parent) : (struct lysc_node*)module->notifs;
135 } else {
136 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100137 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100138 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100139 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100140check:
Radek Krejcia3045382018-11-22 14:30:31 +0100141 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100142 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100143 case LYS_ACTION:
144 case LYS_NOTIF:
145 case LYS_LEAF:
146 case LYS_ANYXML:
147 case LYS_ANYDATA:
148 case LYS_LIST:
149 case LYS_LEAFLIST:
Radek Krejcia9026eb2018-12-12 16:04:47 +0100150 case LYS_CASE:
Radek Krejcia3045382018-11-22 14:30:31 +0100151 break;
152 case LYS_CONTAINER:
153 if (!(((struct lysc_node_container *)next)->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
154 if (((struct lysc_node_container *)next)->child) {
155 /* go into */
156 next = ((struct lysc_node_container *)next)->child;
157 } else {
158 next = next->next;
159 }
160 goto repeat;
161 }
162 break;
163 case LYS_CHOICE:
164 if (options & LYS_GETNEXT_WITHCHOICE) {
165 return next;
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100166 } else if ((options & LYS_GETNEXT_NOCHOICE) || !((struct lysc_node_choice *)next)->cases) {
167 next = next->next;
168 } else {
Radek Krejcia3045382018-11-22 14:30:31 +0100169 /* go into */
Radek Krejcia9026eb2018-12-12 16:04:47 +0100170 if (options & LYS_GETNEXT_WITHCASE) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100171 next = (struct lysc_node*)((struct lysc_node_choice *)next)->cases;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100172 } else {
173 next = ((struct lysc_node_choice *)next)->cases->child;
174 }
Radek Krejcia3045382018-11-22 14:30:31 +0100175 }
176 goto repeat;
177 default:
178 /* we should not be here */
Radek Krejcib07b5c92019-04-08 10:56:37 +0200179 LOGINT(module ? module->mod->ctx : parent->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100180 return NULL;
181 }
182
183 if (!(options & LYS_GETNEXT_NOSTATECHECK)) {
184 /* check if the node is disabled by if-feature */
Radek Krejcifab954b2019-09-11 11:25:14 +0200185 if (lysc_node_is_disabled(next, 0)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100186 next = next->next;
187 goto repeat;
188 }
189 }
190 return next;
191}
192
193API const struct lysc_node *
Radek Krejci09e8d0a2019-11-17 12:14:15 +0800194lys_find_node(struct ly_ctx *ctx, const struct lysc_node *context_node, const char *qpath)
195{
196 const char *id = qpath;
197 const char *prefix, *name;
198 size_t prefix_len, name_len;
199 unsigned int u;
200 const struct lysc_node *node = context_node;
201 struct lys_module *mod = NULL;
202
203 LY_CHECK_ARG_RET(ctx, qpath, NULL);
204
205 while(*id) {
206 if (id[0] == '/') {
207 ++id;
208 }
209 /* precess ".." in relative paths */
210 while (!strncmp("../", id, 3)) {
211 id += 3;
212 if (!node) {
213 LOGERR(ctx, LY_EINVAL, "Invalid qpath \"%s\" - too many \"..\" in the path.", qpath);
214 return NULL;
215 }
216 node = node->parent;
217 }
218
219 if (ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len) != LY_SUCCESS) {
220 LOGERR(ctx, LY_EINVAL, "Invalid qpath \"%s\" - invalid nodeid \"%.*s\".", qpath, id- qpath, qpath);
221 return NULL;
222 }
223 if (prefix) {
224 if (context_node) {
225 mod = lys_module_find_prefix(context_node->module, prefix, prefix_len);
226 } else {
227 for (u = 0; u < ctx->list.count; ++u) {
228 if (!ly_strncmp(((struct lys_module *)ctx->list.objs[u])->name, prefix, prefix_len)) {
229 struct lys_module *m = (struct lys_module *)ctx->list.objs[u];
230 if (mod) {
231 if (m->implemented) {
232 mod = m;
233 break;
234 } else if (m->latest_revision) {
235 mod = m;
236 }
237 } else {
238 mod = m;
239 }
240 }
241 }
242 }
243 }
244 if (!mod) {
245 LOGERR(ctx, LY_EINVAL, "Invalid qpath - unable to find module connected with the prefix of the node \"%.*s\".",
246 id - qpath, qpath);
247 return NULL;
248 }
249
250 node = lys_find_child(node, mod, name, name_len, 0, LYS_GETNEXT_NOSTATECHECK);
251 if (!node) {
252 LOGERR(ctx, LY_EINVAL, "Invalid qpath - unable to find \"%.*s\".", id - qpath, qpath);
253 return NULL;
254 }
255 }
256
257 return node;
258}
259
260API const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100261lys_find_child(const struct lysc_node *parent, const struct lys_module *module, const char *name, size_t name_len,
262 uint16_t nodetype, int options)
Radek Krejcia3045382018-11-22 14:30:31 +0100263{
264 const struct lysc_node *node = NULL;
265
266 LY_CHECK_ARG_RET(NULL, module, name, NULL);
267 if (!nodetype) {
268 nodetype = 0xffff;
269 }
270
271 while ((node = lys_getnext(node, parent, module->compiled, options))) {
272 if (!(node->nodetype & nodetype)) {
273 continue;
274 }
275 if (node->module != module) {
276 continue;
277 }
278
279 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200280 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100281 return node;
282 }
283 } else {
284 if (!strcmp(node->name, name)) {
285 return node;
286 }
287 }
288 }
289 return NULL;
290}
291
Michal Vasko519fd602020-05-26 12:17:39 +0200292API LY_ERR
293lys_atomize_xpath(const struct lysc_node *ctx_node, const char *xpath, int options, struct ly_set **set)
294{
295 LY_ERR ret = LY_SUCCESS;
296 struct lyxp_set xp_set;
297 struct lyxp_expr *exp;
298 uint32_t i;
299
300 LY_CHECK_ARG_RET(NULL, ctx_node, xpath, set, LY_EINVAL);
301 if (!(options & LYXP_SCNODE_ALL)) {
302 options = LYXP_SCNODE;
303 }
304
305 memset(&xp_set, 0, sizeof xp_set);
306
307 /* compile expression */
Michal Vasko004d3152020-06-11 19:59:22 +0200308 exp = lyxp_expr_parse(ctx_node->module->ctx, xpath, 0, 1);
Michal Vasko519fd602020-05-26 12:17:39 +0200309 LY_CHECK_ERR_GOTO(!exp, ret = LY_EINVAL, cleanup);
310
311 /* atomize expression */
312 ret = lyxp_atomize(exp, LYD_JSON, ctx_node->module, ctx_node, LYXP_NODE_ELEM, &xp_set, options);
313 LY_CHECK_GOTO(ret, cleanup);
314
315 /* allocate return set */
316 *set = ly_set_new();
317 LY_CHECK_ERR_GOTO(!*set, LOGMEM(ctx_node->module->ctx); ret = LY_EMEM, cleanup);
318
319 /* transform into ly_set */
320 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
321 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx_node->module->ctx); ret = LY_EMEM, cleanup);
322 (*set)->size = xp_set.used;
323
324 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200325 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko519fd602020-05-26 12:17:39 +0200326 ly_set_add(*set, xp_set.val.scnodes[i].scnode, LY_SET_OPT_USEASLIST);
327 }
328 }
329
330cleanup:
331 lyxp_set_free_content(&xp_set);
332 lyxp_expr_free(ctx_node->module->ctx, exp);
333 return ret;
334}
335
Michal Vasko14654712020-02-06 08:35:21 +0100336char *
337lysc_path_until(const struct lysc_node *node, const struct lysc_node *parent, LYSC_PATH_TYPE pathtype, char *buffer,
338 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200339{
Michal Vasko03ff5a72019-09-11 13:49:33 +0200340 const struct lysc_node *iter;
Radek Krejci327de162019-06-14 12:52:07 +0200341 char *path = NULL;
342 int len = 0;
343
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200344 LY_CHECK_ARG_RET(NULL, node, NULL);
345 if (buffer) {
346 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
347 }
348
Radek Krejci327de162019-06-14 12:52:07 +0200349 switch (pathtype) {
Michal Vasko03ff5a72019-09-11 13:49:33 +0200350 case LYSC_PATH_LOG:
Michal Vasko90932a92020-02-12 14:33:03 +0100351 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
Radek Krejci1c0c3442019-07-23 16:08:47 +0200352 char *s = buffer ? strdup(buffer) : path;
Radek Krejci327de162019-06-14 12:52:07 +0200353 char *id;
Michal Vasko14654712020-02-06 08:35:21 +0100354 const char *slash;
Radek Krejci327de162019-06-14 12:52:07 +0200355
Michal Vasko03ff5a72019-09-11 13:49:33 +0200356 id = strdup(iter->name);
Michal Vasko14654712020-02-06 08:35:21 +0100357 if (parent && (iter->parent == parent)) {
358 slash = "";
359 } else {
360 slash = "/";
361 }
Radek Krejci327de162019-06-14 12:52:07 +0200362 if (!iter->parent || iter->parent->module != iter->module) {
363 /* print prefix */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200364 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100365 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200366 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100367 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200368 }
Radek Krejci327de162019-06-14 12:52:07 +0200369 } else {
370 /* prefix is the same as in parent */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200371 if (buffer) {
Michal Vasko14654712020-02-06 08:35:21 +0100372 len = snprintf(buffer, buflen, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200373 } else {
Michal Vasko14654712020-02-06 08:35:21 +0100374 len = asprintf(&path, "%s%s%s", slash, id, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200375 }
Radek Krejci327de162019-06-14 12:52:07 +0200376 }
377 free(s);
378 free(id);
Radek Krejci1c0c3442019-07-23 16:08:47 +0200379
380 if (buffer && buflen <= (size_t)len) {
381 /* not enough space in buffer */
382 break;
383 }
Radek Krejci327de162019-06-14 12:52:07 +0200384 }
385
386 if (len < 0) {
387 free(path);
388 path = NULL;
389 } else if (len == 0) {
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200390 if (buffer) {
391 strcpy(buffer, "/");
392 } else {
393 path = strdup("/");
394 }
Radek Krejci327de162019-06-14 12:52:07 +0200395 }
396 break;
397 }
398
Radek Krejci1c0c3442019-07-23 16:08:47 +0200399 if (buffer) {
400 return buffer;
401 } else {
402 return path;
403 }
Radek Krejci327de162019-06-14 12:52:07 +0200404}
405
Michal Vasko14654712020-02-06 08:35:21 +0100406API char *
407lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
408{
409 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
410}
411
Michal Vasko28d78432020-05-26 13:10:53 +0200412API LY_ERR
Radek Krejci19a96102018-11-15 13:38:09 +0100413lysc_feature_value(const struct lysc_feature *feature)
Radek Krejci6f7feb62018-10-12 15:23:02 +0200414{
Michal Vasko28d78432020-05-26 13:10:53 +0200415 LY_CHECK_ARG_RET(NULL, feature, LY_EINVAL);
416 return feature->flags & LYS_FENABLED ? LY_SUCCESS : LY_ENOT;
Radek Krejci151a5b72018-10-19 14:21:44 +0200417}
418
Radek Krejci693262f2019-04-29 15:23:20 +0200419uint8_t
420lysc_iff_getop(uint8_t *list, int pos)
Radek Krejci151a5b72018-10-19 14:21:44 +0200421{
422 uint8_t *item;
423 uint8_t mask = 3, result;
424
425 assert(pos >= 0);
426
427 item = &list[pos / 4];
428 result = (*item) & (mask << 2 * (pos % 4));
429 return result >> 2 * (pos % 4);
430}
431
Michal Vasko28d78432020-05-26 13:10:53 +0200432static LY_ERR
Radek Krejci151a5b72018-10-19 14:21:44 +0200433lysc_iffeature_value_(const struct lysc_iffeature *iff, int *index_e, int *index_f)
434{
435 uint8_t op;
Michal Vasko28d78432020-05-26 13:10:53 +0200436 LY_ERR a, b;
Radek Krejci151a5b72018-10-19 14:21:44 +0200437
Radek Krejci693262f2019-04-29 15:23:20 +0200438 op = lysc_iff_getop(iff->expr, *index_e);
Radek Krejci151a5b72018-10-19 14:21:44 +0200439 (*index_e)++;
440
441 switch (op) {
442 case LYS_IFF_F:
443 /* resolve feature */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200444 return lysc_feature_value(iff->features[(*index_f)++]);
Radek Krejci151a5b72018-10-19 14:21:44 +0200445 case LYS_IFF_NOT:
446 /* invert result */
Michal Vasko28d78432020-05-26 13:10:53 +0200447 return lysc_iffeature_value_(iff, index_e, index_f) == LY_SUCCESS ? LY_ENOT : LY_SUCCESS;
Radek Krejci151a5b72018-10-19 14:21:44 +0200448 case LYS_IFF_AND:
449 case LYS_IFF_OR:
450 a = lysc_iffeature_value_(iff, index_e, index_f);
451 b = lysc_iffeature_value_(iff, index_e, index_f);
452 if (op == LYS_IFF_AND) {
Michal Vasko28d78432020-05-26 13:10:53 +0200453 if ((a == LY_SUCCESS) && (b == LY_SUCCESS)) {
454 return LY_SUCCESS;
455 } else {
456 return LY_ENOT;
457 }
Radek Krejci151a5b72018-10-19 14:21:44 +0200458 } else { /* LYS_IFF_OR */
Michal Vasko28d78432020-05-26 13:10:53 +0200459 if ((a == LY_SUCCESS) || (b == LY_SUCCESS)) {
460 return LY_SUCCESS;
461 } else {
462 return LY_ENOT;
463 }
Radek Krejci151a5b72018-10-19 14:21:44 +0200464 }
465 }
466
467 return 0;
468}
469
Michal Vasko28d78432020-05-26 13:10:53 +0200470API LY_ERR
Radek Krejci151a5b72018-10-19 14:21:44 +0200471lysc_iffeature_value(const struct lysc_iffeature *iff)
472{
473 int index_e = 0, index_f = 0;
474
475 LY_CHECK_ARG_RET(NULL, iff, -1);
476
477 if (iff->expr) {
478 return lysc_iffeature_value_(iff, &index_e, &index_f);
479 }
480 return 0;
481}
482
Radek Krejci151a5b72018-10-19 14:21:44 +0200483/**
484 * @brief Enable/Disable the specified feature in the module.
485 *
486 * If the feature is already set to the desired value, LY_SUCCESS is returned.
487 * By changing the feature, also all the feature which depends on it via their
488 * if-feature statements are again evaluated (disabled if a if-feature statemen
489 * evaluates to false).
490 *
Radek Krejci0af46292019-01-11 16:02:31 +0100491 * @param[in] mod Module where to set (search for) the feature.
Radek Krejci151a5b72018-10-19 14:21:44 +0200492 * @param[in] name Name of the feature to set. Asterisk ('*') can be used to
493 * set all the features in the module.
494 * @param[in] value Desired value of the feature: 1 (enable) or 0 (disable).
495 * @return LY_ERR value.
496 */
497static LY_ERR
Radek Krejci0af46292019-01-11 16:02:31 +0100498lys_feature_change(const struct lys_module *mod, const char *name, int value)
Radek Krejci151a5b72018-10-19 14:21:44 +0200499{
500 int all = 0;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200501 LY_ARRAY_SIZE_TYPE u, disabled_count;
502 uint32_t changed_count;
Radek Krejci151a5b72018-10-19 14:21:44 +0200503 struct lysc_feature *f, **df;
504 struct lysc_iffeature *iff;
505 struct ly_set *changed;
Radek Krejci0af46292019-01-11 16:02:31 +0100506 struct ly_ctx *ctx = mod->ctx; /* shortcut */
Radek Krejci151a5b72018-10-19 14:21:44 +0200507
Radek Krejci6e67c402019-05-02 09:55:39 +0200508 if (!strcmp(name, "*")) {
509 /* enable all */
510 all = 1;
511 }
512
Radek Krejci0af46292019-01-11 16:02:31 +0100513 if (!mod->compiled) {
514 LOGERR(ctx, LY_EINVAL, "Module \"%s\" is not implemented so all its features are permanently disabled without a chance to change it.",
515 mod->name);
516 return LY_EINVAL;
517 }
518 if (!mod->compiled->features) {
Radek Krejci6e67c402019-05-02 09:55:39 +0200519 if (all) {
520 /* no feature to enable */
521 return LY_SUCCESS;
522 }
Radek Krejci0af46292019-01-11 16:02:31 +0100523 LOGERR(ctx, LY_EINVAL, "Unable to switch feature since the module \"%s\" has no features.", mod->name);
Radek Krejci151a5b72018-10-19 14:21:44 +0200524 return LY_EINVAL;
525 }
526
Radek Krejci151a5b72018-10-19 14:21:44 +0200527 changed = ly_set_new();
Radek Krejcica3db002018-11-01 10:31:01 +0100528 changed_count = 0;
Radek Krejci151a5b72018-10-19 14:21:44 +0200529
Radek Krejcica3db002018-11-01 10:31:01 +0100530run:
Radek Krejci0af46292019-01-11 16:02:31 +0100531 for (disabled_count = u = 0; u < LY_ARRAY_SIZE(mod->compiled->features); ++u) {
532 f = &mod->compiled->features[u];
Radek Krejci151a5b72018-10-19 14:21:44 +0200533 if (all || !strcmp(f->name, name)) {
534 if ((value && (f->flags & LYS_FENABLED)) || (!value && !(f->flags & LYS_FENABLED))) {
535 if (all) {
536 /* skip already set features */
537 continue;
538 } else {
539 /* feature already set correctly */
540 ly_set_free(changed, NULL);
541 return LY_SUCCESS;
542 }
543 }
544
545 if (value) { /* enable */
546 /* check referenced features if they are enabled */
547 LY_ARRAY_FOR(f->iffeatures, struct lysc_iffeature, iff) {
Michal Vasko28d78432020-05-26 13:10:53 +0200548 if (lysc_iffeature_value(iff) == LY_ENOT) {
Radek Krejci151a5b72018-10-19 14:21:44 +0200549 if (all) {
Radek Krejcica3db002018-11-01 10:31:01 +0100550 ++disabled_count;
Radek Krejci151a5b72018-10-19 14:21:44 +0200551 goto next;
552 } else {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100553 LOGERR(ctx, LY_EDENIED,
Radek Krejci151a5b72018-10-19 14:21:44 +0200554 "Feature \"%s\" cannot be enabled since it is disabled by its if-feature condition(s).",
555 f->name);
556 ly_set_free(changed, NULL);
557 return LY_EDENIED;
558 }
559 }
560 }
561 /* enable the feature */
562 f->flags |= LYS_FENABLED;
563 } else { /* disable */
564 /* disable the feature */
565 f->flags &= ~LYS_FENABLED;
566 }
567
568 /* remember the changed feature */
569 ly_set_add(changed, f, LY_SET_OPT_USEASLIST);
570
571 if (!all) {
572 /* stop in case changing a single feature */
573 break;
574 }
575 }
576next:
577 ;
578 }
579
580 if (!all && !changed->count) {
Radek Krejci0af46292019-01-11 16:02:31 +0100581 LOGERR(ctx, LY_EINVAL, "Feature \"%s\" not found in module \"%s\".", name, mod->name);
Radek Krejci151a5b72018-10-19 14:21:44 +0200582 ly_set_free(changed, NULL);
583 return LY_EINVAL;
584 }
585
Radek Krejcica3db002018-11-01 10:31:01 +0100586 if (value && all && disabled_count) {
587 if (changed_count == changed->count) {
588 /* no change in last run -> not able to enable all ... */
589 /* ... print errors */
Radek Krejci0af46292019-01-11 16:02:31 +0100590 for (u = 0; disabled_count && u < LY_ARRAY_SIZE(mod->compiled->features); ++u) {
591 if (!(mod->compiled->features[u].flags & LYS_FENABLED)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100592 LOGERR(ctx, LY_EDENIED,
Radek Krejcica3db002018-11-01 10:31:01 +0100593 "Feature \"%s\" cannot be enabled since it is disabled by its if-feature condition(s).",
Radek Krejci0af46292019-01-11 16:02:31 +0100594 mod->compiled->features[u].name);
Radek Krejcica3db002018-11-01 10:31:01 +0100595 --disabled_count;
596 }
597 }
598 /* ... restore the original state */
599 for (u = 0; u < changed->count; ++u) {
600 f = changed->objs[u];
601 /* re-disable the feature */
602 f->flags &= ~LYS_FENABLED;
603 }
604
605 ly_set_free(changed, NULL);
606 return LY_EDENIED;
607 } else {
608 /* we did some change in last run, try it again */
609 changed_count = changed->count;
610 goto run;
611 }
612 }
613
Radek Krejci151a5b72018-10-19 14:21:44 +0200614 /* reflect change(s) in the dependent features */
615 for (u = 0; u < changed->count; ++u) {
616 /* If a dependent feature is enabled, it can be now changed by the change (to false) of the value of
617 * its if-feature statements. The reverse logic, automatically enable feature when its feature is enabled
618 * is not done - by default, features are disabled and must be explicitely enabled. */
619 f = changed->objs[u];
620 LY_ARRAY_FOR(f->depfeatures, struct lysc_feature*, df) {
621 if (!((*df)->flags & LYS_FENABLED)) {
622 /* not enabled, nothing to do */
623 continue;
624 }
625 /* check the feature's if-features which could change by the previous change of our feature */
626 LY_ARRAY_FOR((*df)->iffeatures, struct lysc_iffeature, iff) {
Michal Vasko28d78432020-05-26 13:10:53 +0200627 if (lysc_iffeature_value(iff) == LY_ENOT) {
Radek Krejci151a5b72018-10-19 14:21:44 +0200628 /* the feature must be disabled now */
629 (*df)->flags &= ~LYS_FENABLED;
630 /* add the feature into the list of changed features */
631 ly_set_add(changed, *df, LY_SET_OPT_USEASLIST);
632 break;
633 }
634 }
635 }
636 }
637
638 ly_set_free(changed, NULL);
639 return LY_SUCCESS;
640}
641
642API LY_ERR
Radek Krejcied5acc52019-04-25 15:57:04 +0200643lys_feature_enable(const struct lys_module *module, const char *feature)
Radek Krejci151a5b72018-10-19 14:21:44 +0200644{
Radek Krejci0af46292019-01-11 16:02:31 +0100645 LY_CHECK_ARG_RET(NULL, module, feature, LY_EINVAL);
Radek Krejci151a5b72018-10-19 14:21:44 +0200646
Radek Krejcied5acc52019-04-25 15:57:04 +0200647 return lys_feature_change((struct lys_module*)module, feature, 1);
Radek Krejci151a5b72018-10-19 14:21:44 +0200648}
649
650API LY_ERR
Radek Krejcied5acc52019-04-25 15:57:04 +0200651lys_feature_disable(const struct lys_module *module, const char *feature)
Radek Krejci151a5b72018-10-19 14:21:44 +0200652{
Radek Krejci0af46292019-01-11 16:02:31 +0100653 LY_CHECK_ARG_RET(NULL, module, feature, LY_EINVAL);
Radek Krejci151a5b72018-10-19 14:21:44 +0200654
Radek Krejcied5acc52019-04-25 15:57:04 +0200655 return lys_feature_change((struct lys_module*)module, feature, 0);
Radek Krejci151a5b72018-10-19 14:21:44 +0200656}
657
658API int
659lys_feature_value(const struct lys_module *module, const char *feature)
660{
661 struct lysc_feature *f;
662 struct lysc_module *mod;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200663 LY_ARRAY_SIZE_TYPE u;
Radek Krejci151a5b72018-10-19 14:21:44 +0200664
665 LY_CHECK_ARG_RET(NULL, module, module->compiled, feature, -1);
666 mod = module->compiled;
667
668 /* search for the specified feature */
669 for (u = 0; u < LY_ARRAY_SIZE(mod->features); ++u) {
Radek Krejci2c4e7172018-10-19 15:56:26 +0200670 f = &mod->features[u];
Radek Krejci151a5b72018-10-19 14:21:44 +0200671 if (!strcmp(f->name, feature)) {
672 if (f->flags & LYS_FENABLED) {
673 return 1;
674 } else {
675 return 0;
676 }
677 }
678 }
679
680 /* feature definition not found */
681 return -1;
682}
683
Michal Vaskoc193ce92020-03-06 11:04:48 +0100684API const struct lysc_node *
Radek Krejcifab954b2019-09-11 11:25:14 +0200685lysc_node_is_disabled(const struct lysc_node *node, int recursive)
Radek Krejcia3045382018-11-22 14:30:31 +0100686{
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200687 LY_ARRAY_SIZE_TYPE u;
Radek Krejcia3045382018-11-22 14:30:31 +0100688
689 LY_CHECK_ARG_RET(NULL, node, NULL);
690
Michal Vaskoc193ce92020-03-06 11:04:48 +0100691 do {
Radek Krejci056d0a82018-12-06 16:57:25 +0100692 if (node->iffeatures) {
Radek Krejcia3045382018-11-22 14:30:31 +0100693 /* check local if-features */
Radek Krejci056d0a82018-12-06 16:57:25 +0100694 LY_ARRAY_FOR(node->iffeatures, u) {
Michal Vasko28d78432020-05-26 13:10:53 +0200695 if (lysc_iffeature_value(&node->iffeatures[u]) == LY_ENOT) {
Michal Vaskoc193ce92020-03-06 11:04:48 +0100696 return node;
Radek Krejcia3045382018-11-22 14:30:31 +0100697 }
698 }
699 }
700
701 if (!recursive) {
702 return NULL;
703 }
704
Michal Vaskoc193ce92020-03-06 11:04:48 +0100705 /* go through schema-only parents */
Radek Krejcia3045382018-11-22 14:30:31 +0100706 node = node->parent;
Michal Vaskoc193ce92020-03-06 11:04:48 +0100707 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
708
Radek Krejcia3045382018-11-22 14:30:31 +0100709 return NULL;
710}
711
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200712LY_ERR
713lys_set_implemented_internal(struct lys_module *mod, uint8_t value)
714{
715 struct lys_module *m;
716
717 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
718
719 if (mod->implemented) {
720 return LY_SUCCESS;
721 }
722
723 /* we have module from the current context */
724 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
725 if (m) {
726 if (m != mod) {
727 /* check collision with other implemented revision */
728 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s\" is present in the context in other implemented revision (%s).",
729 mod->name, mod->revision ? mod->revision : "module without revision");
730 return LY_EDENIED;
731 } else {
732 /* mod is already implemented */
733 return LY_SUCCESS;
734 }
735 }
736
737 /* mark the module implemented, check for collision was already done */
738 mod->implemented = value;
739
740 /* compile the schema */
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200741 LY_CHECK_RET(lys_compile(&mod, LYSC_OPT_INTERNAL));
Radek Krejci77a8bcd2019-09-11 11:20:02 +0200742
743 return LY_SUCCESS;
744}
745
746API LY_ERR
747lys_set_implemented(struct lys_module *mod)
748{
749 return lys_set_implemented_internal(mod, 1);
750}
751
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100752struct lysp_submodule *
Radek Krejcie7b95092019-05-15 11:03:07 +0200753lys_parse_mem_submodule(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_parser_ctx *main_ctx,
Michal Vaskob36053d2020-03-26 15:49:30 +0100754 LY_ERR (*custom_check)(const struct ly_ctx*, struct lysp_module*, struct lysp_submodule*, void*), void *check_data)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200755{
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100756 LY_ERR ret = LY_EINVAL;
757 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskob36053d2020-03-26 15:49:30 +0100758 struct lys_yang_parser_ctx *yangctx = NULL;
759 struct lys_yin_parser_ctx *yinctx = NULL;
760 struct lys_parser_ctx *pctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100761
762 LY_CHECK_ARG_RET(ctx, ctx, data, NULL);
763
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100764 switch (format) {
765 case LYS_IN_YIN:
Michal Vaskob36053d2020-03-26 15:49:30 +0100766 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, data, &submod);
767 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100768 break;
769 case LYS_IN_YANG:
Michal Vaskob36053d2020-03-26 15:49:30 +0100770 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, data, &submod);
771 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100772 break;
773 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +0200774 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100775 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200776 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100777 LY_CHECK_RET(ret, NULL);
778
779 /* make sure that the newest revision is at position 0 */
780 lysp_sort_revisions(submod->revs);
781
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100782 /* decide the latest revision */
Michal Vaskob36053d2020-03-26 15:49:30 +0100783 latest_sp = ly_ctx_get_submodule(PARSER_CTX(pctx), submod->belongsto, submod->name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100784 if (latest_sp) {
785 if (submod->revs) {
786 if (!latest_sp->revs) {
787 /* latest has no revision, so mod is anyway newer */
788 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +0200789 /* the latest_sp is zeroed later when the new module is being inserted into the context */
790 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
791 submod->latest_revision = latest_sp->latest_revision;
792 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100793 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +0200794 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100795 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200796 } else {
797 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100798 }
799 } else {
800 submod->latest_revision = 1;
801 }
802
Radek Krejcib3289d62019-09-18 12:21:39 +0200803 if (custom_check) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100804 LY_CHECK_GOTO(custom_check(PARSER_CTX(pctx), NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +0200805 }
806
807 if (latest_sp) {
808 latest_sp->latest_revision = 0;
809 }
810
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100811 /* remap possibly changed and reallocated typedefs and groupings list back to the main context */
Michal Vaskob36053d2020-03-26 15:49:30 +0100812 memcpy(&main_ctx->tpdfs_nodes, &pctx->tpdfs_nodes, sizeof main_ctx->tpdfs_nodes);
813 memcpy(&main_ctx->grps_nodes, &pctx->grps_nodes, sizeof main_ctx->grps_nodes);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100814
David Sedlák1b623122019-08-05 15:27:49 +0200815 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100816 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200817 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100818 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200819 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100820 return submod;
David Sedlák1b623122019-08-05 15:27:49 +0200821
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100822error:
823 lysp_submodule_free(ctx, submod);
David Sedlák1b623122019-08-05 15:27:49 +0200824 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100825 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200826 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100827 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200828 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100829 return NULL;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200830}
831
Radek Krejcid33273d2018-10-25 14:55:52 +0200832struct lys_module *
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100833lys_parse_mem_module(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, int implement,
Michal Vaskob36053d2020-03-26 15:49:30 +0100834 LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100835 void *check_data)
Radek Krejci86d106e2018-10-18 09:53:19 +0200836{
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100837 struct lys_module *mod = NULL, *latest, *mod_dup;
Radek Krejci086c7132018-10-26 15:29:04 +0200838 struct lysp_import *imp;
839 struct lysp_include *inc;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100840 LY_ERR ret = LY_EINVAL;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200841 LY_ARRAY_SIZE_TYPE u, v;
Michal Vaskob36053d2020-03-26 15:49:30 +0100842 struct lys_yang_parser_ctx *yangctx = NULL;
843 struct lys_yin_parser_ctx *yinctx = NULL;
844 struct lys_parser_ctx *pctx;
Radek Krejci86d106e2018-10-18 09:53:19 +0200845
846 LY_CHECK_ARG_RET(ctx, ctx, data, NULL);
847
848 mod = calloc(1, sizeof *mod);
849 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100850 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +0200851
852 switch (format) {
853 case LYS_IN_YIN:
Michal Vaskob36053d2020-03-26 15:49:30 +0100854 ret = yin_parse_module(&yinctx, data, mod);
855 pctx = (struct lys_parser_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +0200856 break;
857 case LYS_IN_YANG:
Michal Vaskob36053d2020-03-26 15:49:30 +0100858 ret = yang_parse_module(&yangctx, data, mod);
859 pctx = (struct lys_parser_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +0200860 break;
861 default:
862 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
863 break;
864 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100865 LY_CHECK_ERR_RET(ret, lys_module_free(mod, NULL), NULL);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200866
867 /* make sure that the newest revision is at position 0 */
868 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +0100869 if (mod->parsed->revs) {
870 mod->revision = lydict_insert(ctx, mod->parsed->revs[0].date, 0);
871 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200872
Radek Krejcib3289d62019-09-18 12:21:39 +0200873 /* decide the latest revision */
874 latest = (struct lys_module*)ly_ctx_get_module_latest(ctx, mod->name);
875 if (latest) {
876 if (mod->revision) {
877 if (!latest->revision) {
878 /* latest has no revision, so mod is anyway newer */
879 mod->latest_revision = latest->latest_revision;
880 /* the latest is zeroed later when the new module is being inserted into the context */
881 } else if (strcmp(mod->revision, latest->revision) > 0) {
882 mod->latest_revision = latest->latest_revision;
883 /* the latest is zeroed later when the new module is being inserted into the context */
884 } else {
885 latest = NULL;
886 }
887 } else {
888 latest = NULL;
889 }
890 } else {
891 mod->latest_revision = 1;
892 }
893
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100894 if (custom_check) {
895 LY_CHECK_GOTO(custom_check(ctx, mod->parsed, NULL, check_data), error);
896 }
897
Radek Krejci86d106e2018-10-18 09:53:19 +0200898 if (implement) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200899 /* mark the loaded module implemented */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100900 if (ly_ctx_get_module_implemented(ctx, mod->name)) {
901 LOGERR(ctx, LY_EDENIED, "Module \"%s\" is already implemented in the context.", mod->name);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100902 goto error;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200903 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100904 mod->implemented = 1;
Radek Krejci86d106e2018-10-18 09:53:19 +0200905 }
906
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100907 /* check for duplicity in the context */
Radek Krejci0af46292019-01-11 16:02:31 +0100908 mod_dup = (struct lys_module*)ly_ctx_get_module(ctx, mod->name, mod->revision);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100909 if (mod_dup) {
910 if (mod_dup->parsed) {
911 /* error */
Radek Krejcid33273d2018-10-25 14:55:52 +0200912 if (mod->parsed->revs) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100913 LOGERR(ctx, LY_EEXIST, "Module \"%s\" of revision \"%s\" is already present in the context.",
914 mod->name, mod->parsed->revs[0].date);
Radek Krejcid33273d2018-10-25 14:55:52 +0200915 } else {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100916 LOGERR(ctx, LY_EEXIST, "Module \"%s\" with no revision is already present in the context.",
917 mod->name);
Radek Krejcid33273d2018-10-25 14:55:52 +0200918 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100919 goto error;
920 } else {
921 /* add the parsed data to the currently compiled-only module in the context */
922 mod_dup->parsed = mod->parsed;
923 mod_dup->parsed->mod = mod_dup;
924 mod->parsed = NULL;
925 lys_module_free(mod, NULL);
926 mod = mod_dup;
927 goto finish_parsing;
Radek Krejcid33273d2018-10-25 14:55:52 +0200928 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100929 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200930
Radek Krejci0af46292019-01-11 16:02:31 +0100931 if (!mod->implemented) {
Michal Vasko5fe75f12020-03-02 13:52:37 +0100932 /* pre-compile features of the module */
Radek Krejci327de162019-06-14 12:52:07 +0200933 LY_CHECK_GOTO(lys_feature_precompile(NULL, ctx, mod, mod->parsed->features, &mod->off_features), error);
Radek Krejci0af46292019-01-11 16:02:31 +0100934 }
935
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100936 if (latest) {
Radek Krejcib3289d62019-09-18 12:21:39 +0200937 latest->latest_revision = 0;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100938 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200939
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100940 /* add into context */
941 ly_set_add(&ctx->list, mod, LY_SET_OPT_USEASLIST);
Radek Krejcid33273d2018-10-25 14:55:52 +0200942
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100943finish_parsing:
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100944 /* resolve imports */
945 mod->parsed->parsing = 1;
946 LY_ARRAY_FOR(mod->parsed->imports, u) {
947 imp = &mod->parsed->imports[u];
948 if (!imp->module && lysp_load_module(ctx, imp->name, imp->rev[0] ? imp->rev : NULL, 0, 0, &imp->module)) {
949 goto error_ctx;
Radek Krejci086c7132018-10-26 15:29:04 +0200950 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100951 /* check for importing the same module twice */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200952 for (v = 0; v < u; ++v) {
953 if (imp->module == mod->parsed->imports[v].module) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100954 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Single revision of the module \"%s\" referred twice.", imp->name);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100955 goto error_ctx;
Radek Krejci086c7132018-10-26 15:29:04 +0200956 }
957 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200958 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100959 LY_ARRAY_FOR(mod->parsed->includes, u) {
960 inc = &mod->parsed->includes[u];
Michal Vaskob36053d2020-03-26 15:49:30 +0100961 if (!inc->submodule && lysp_load_submodule(pctx, mod->parsed, inc)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100962 goto error_ctx;
963 }
Radek Krejci0af46292019-01-11 16:02:31 +0100964 if (!mod->implemented) {
Michal Vasko5fe75f12020-03-02 13:52:37 +0100965 /* pre-compile features of the submodule */
Radek Krejci327de162019-06-14 12:52:07 +0200966 LY_CHECK_GOTO(lys_feature_precompile(NULL, ctx, mod, inc->submodule->features, &mod->off_features), error);
Radek Krejci0af46292019-01-11 16:02:31 +0100967 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100968 }
969 mod->parsed->parsing = 0;
970
Radek Krejci7fc68292019-06-12 13:51:09 +0200971 /* check name collisions - typedefs and TODO groupings */
Michal Vaskob36053d2020-03-26 15:49:30 +0100972 LY_CHECK_GOTO(lysp_check_typedefs(pctx, mod->parsed), error_ctx);
Radek Krejcid33273d2018-10-25 14:55:52 +0200973
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 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200979 return mod;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100980
981error_ctx:
982 ly_set_rm(&ctx->list, mod, NULL);
983error:
984 lys_module_free(mod, NULL);
Michal Vaskob36053d2020-03-26 15:49:30 +0100985 ly_set_erase(&pctx->tpdfs_nodes, NULL);
David Sedlák1b623122019-08-05 15:27:49 +0200986 if (format == LYS_IN_YANG) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100987 yang_parser_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +0200988 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100989 yin_parser_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +0200990 }
991
Radek Krejcibbe09a92018-11-08 09:36:54 +0100992 return NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +0200993}
994
Radek Krejcid14e9692018-11-01 11:00:37 +0100995API struct lys_module *
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200996lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format)
Radek Krejci86d106e2018-10-18 09:53:19 +0200997{
Radek Krejci096235c2019-01-11 11:12:19 +0100998 struct lys_module *mod;
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200999 char *filename, *rev, *dot;
1000 size_t len;
Radek Krejci096235c2019-01-11 11:12:19 +01001001
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001002 LY_CHECK_ARG_RET(NULL, ctx, in, format > LYS_IN_UNKNOWN, NULL);
1003
1004 mod = lys_parse_mem_module(ctx, in->current, format, 1, NULL, NULL);
Radek Krejci096235c2019-01-11 11:12:19 +01001005 LY_CHECK_RET(!mod, NULL);
1006
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001007 switch (in->type) {
1008 case LY_IN_FILEPATH:
1009 /* check that name and revision match filename */
1010 filename = strrchr(in->method.fpath.filepath, '/');
1011 if (!filename) {
1012 filename = in->method.fpath.filepath;
1013 } else {
1014 filename++;
1015 }
1016 rev = strchr(filename, '@');
1017 dot = strrchr(filename, '.');
1018
1019 /* name */
1020 len = strlen(mod->name);
1021 if (strncmp(filename, mod->name, len) ||
1022 ((rev && rev != &filename[len]) || (!rev && dot != &filename[len]))) {
1023 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name);
1024 }
1025 if (rev) {
1026 len = dot - ++rev;
1027 if (!mod->parsed->revs || len != 10 || strncmp(mod->parsed->revs[0].date, rev, len)) {
1028 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
1029 mod->parsed->revs ? mod->parsed->revs[0].date : "none");
1030 }
1031 }
1032
1033 break;
1034 case LY_IN_FD:
1035 case LY_IN_FILE:
1036 case LY_IN_MEMORY:
1037 /* nothing special to do */
1038 break;
1039 default:
1040 LOGINT(ctx);
1041 break;
Radek Krejci096235c2019-01-11 11:12:19 +01001042 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001043
1044 lys_parser_fill_filepath(ctx, in, &mod->filepath);
1045 lys_compile(&mod, 0);
1046
Radek Krejci096235c2019-01-11 11:12:19 +01001047 return mod;
Radek Krejci86d106e2018-10-18 09:53:19 +02001048}
1049
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001050API struct lys_module *
1051lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format)
Radek Krejci86d106e2018-10-18 09:53:19 +02001052{
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001053 LY_ERR ret;
1054 struct ly_in *in = NULL;
1055 struct lys_module *result = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001056
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001057 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, NULL);
Radek Krejci65639b92018-11-27 10:51:37 +01001058
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001059 LY_CHECK_ERR_RET(ret = ly_in_new_memory(data, &in), LOGERR(ctx, ret, "Unable to create input handler."), NULL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001060
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001061 result = lys_parse(ctx, in, format);
1062 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001063
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001064 return result;
1065}
1066
Radek Krejcid14e9692018-11-01 11:00:37 +01001067API struct lys_module *
Radek Krejci86d106e2018-10-18 09:53:19 +02001068lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format)
1069{
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001070 LY_ERR ret;
1071 struct ly_in *in = NULL;
1072 struct lys_module *result = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001073
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001074 LY_CHECK_ARG_RET(ctx, fd != -1, format != LYS_IN_UNKNOWN, NULL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001075
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001076 LY_CHECK_ERR_RET(ret = ly_in_new_fd(fd, &in), LOGERR(ctx, ret, "Unable to create input handler."), NULL);
Radek Krejci86d106e2018-10-18 09:53:19 +02001077
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001078 result = lys_parse(ctx, in, format);
1079 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001080
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001081 return result;
Radek Krejci86d106e2018-10-18 09:53:19 +02001082}
1083
Radek Krejcid14e9692018-11-01 11:00:37 +01001084API struct lys_module *
Radek Krejcid33273d2018-10-25 14:55:52 +02001085lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format)
1086{
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001087 LY_ERR ret;
1088 struct ly_in *in = NULL;
1089 struct lys_module *result = NULL;
1090
1091 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, NULL);
1092
1093 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in), LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), NULL);
1094
1095 result = lys_parse(ctx, in, format);
1096 ly_in_free(in, 0);
1097
1098 return result;
Radek Krejcid33273d2018-10-25 14:55:52 +02001099}
1100
1101API LY_ERR
1102lys_search_localfile(const char * const *searchpaths, int cwd, const char *name, const char *revision,
1103 char **localfile, LYS_INFORMAT *format)
1104{
1105 size_t len, flen, match_len = 0, dir_len;
1106 int i, implicit_cwd = 0, ret = EXIT_FAILURE;
1107 char *wd, *wn = NULL;
1108 DIR *dir = NULL;
1109 struct dirent *file;
1110 char *match_name = NULL;
1111 LYS_INFORMAT format_aux, match_format = 0;
1112 struct ly_set *dirs;
1113 struct stat st;
1114
1115 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
1116
1117 /* start to fill the dir fifo with the context's search path (if set)
1118 * and the current working directory */
1119 dirs = ly_set_new();
1120 if (!dirs) {
1121 LOGMEM(NULL);
1122 return EXIT_FAILURE;
1123 }
1124
1125 len = strlen(name);
1126 if (cwd) {
1127 wd = get_current_dir_name();
1128 if (!wd) {
1129 LOGMEM(NULL);
1130 goto cleanup;
1131 } else {
1132 /* add implicit current working directory (./) to be searched,
1133 * this directory is not searched recursively */
1134 if (ly_set_add(dirs, wd, 0) == -1) {
1135 goto cleanup;
1136 }
1137 implicit_cwd = 1;
1138 }
1139 }
1140 if (searchpaths) {
1141 for (i = 0; searchpaths[i]; i++) {
1142 /* check for duplicities with the implicit current working directory */
1143 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
1144 implicit_cwd = 0;
1145 continue;
1146 }
1147 wd = strdup(searchpaths[i]);
1148 if (!wd) {
1149 LOGMEM(NULL);
1150 goto cleanup;
1151 } else if (ly_set_add(dirs, wd, 0) == -1) {
1152 goto cleanup;
1153 }
1154 }
1155 }
1156 wd = NULL;
1157
1158 /* start searching */
1159 while (dirs->count) {
1160 free(wd);
1161 free(wn); wn = NULL;
1162
1163 dirs->count--;
1164 wd = (char *)dirs->objs[dirs->count];
1165 dirs->objs[dirs->count] = NULL;
1166 LOGVRB("Searching for \"%s\" in %s.", name, wd);
1167
1168 if (dir) {
1169 closedir(dir);
1170 }
1171 dir = opendir(wd);
1172 dir_len = strlen(wd);
1173 if (!dir) {
1174 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
1175 } else {
1176 while ((file = readdir(dir))) {
1177 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
1178 /* skip . and .. */
1179 continue;
1180 }
1181 free(wn);
1182 if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) {
1183 LOGMEM(NULL);
1184 goto cleanup;
1185 }
1186 if (stat(wn, &st) == -1) {
1187 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
1188 file->d_name, wd, strerror(errno));
1189 continue;
1190 }
1191 if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) {
1192 /* we have another subdirectory in searchpath to explore,
1193 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
1194 if (ly_set_add(dirs, wn, 0) == -1) {
1195 goto cleanup;
1196 }
1197 /* continue with the next item in current directory */
1198 wn = NULL;
1199 continue;
1200 } else if (!S_ISREG(st.st_mode)) {
1201 /* not a regular file (note that we see the target of symlinks instead of symlinks */
1202 continue;
1203 }
1204
1205 /* here we know that the item is a file which can contain a module */
1206 if (strncmp(name, file->d_name, len) ||
1207 (file->d_name[len] != '.' && file->d_name[len] != '@')) {
1208 /* different filename than the module we search for */
1209 continue;
1210 }
1211
1212 /* get type according to filename suffix */
1213 flen = strlen(file->d_name);
Radek Krejcied5acc52019-04-25 15:57:04 +02001214 if (!strcmp(&file->d_name[flen - 5], ".yang")) {
Radek Krejcid33273d2018-10-25 14:55:52 +02001215 format_aux = LYS_IN_YANG;
Radek Krejcied5acc52019-04-25 15:57:04 +02001216 /* TODO YIN parser
1217 } else if (!strcmp(&file->d_name[flen - 4], ".yin")) {
1218 format_aux = LYS_IN_YIN;
1219 */
Radek Krejcid33273d2018-10-25 14:55:52 +02001220 } else {
1221 /* not supportde suffix/file format */
1222 continue;
1223 }
1224
1225 if (revision) {
1226 /* we look for the specific revision, try to get it from the filename */
1227 if (file->d_name[len] == '@') {
1228 /* check revision from the filename */
1229 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
1230 /* another revision */
1231 continue;
1232 } else {
1233 /* exact revision */
1234 free(match_name);
1235 match_name = wn;
1236 wn = NULL;
1237 match_len = dir_len + 1 + len;
1238 match_format = format_aux;
1239 goto success;
1240 }
1241 } else {
1242 /* continue trying to find exact revision match, use this only if not found */
1243 free(match_name);
1244 match_name = wn;
1245 wn = NULL;
1246 match_len = dir_len + 1 +len;
1247 match_format = format_aux;
1248 continue;
1249 }
1250 } else {
1251 /* remember the revision and try to find the newest one */
1252 if (match_name) {
1253 if (file->d_name[len] != '@' ||
1254 lysp_check_date(NULL, &file->d_name[len + 1], flen - (format_aux == LYS_IN_YANG ? 5 : 4) - len - 1, NULL)) {
1255 continue;
1256 } else if (match_name[match_len] == '@' &&
1257 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
1258 continue;
1259 }
1260 free(match_name);
1261 }
1262
1263 match_name = wn;
1264 wn = NULL;
1265 match_len = dir_len + 1 + len;
1266 match_format = format_aux;
1267 continue;
1268 }
1269 }
1270 }
1271 }
1272
1273success:
1274 (*localfile) = match_name;
1275 match_name = NULL;
1276 if (format) {
1277 (*format) = match_format;
1278 }
1279 ret = EXIT_SUCCESS;
1280
1281cleanup:
1282 free(wn);
1283 free(wd);
1284 if (dir) {
1285 closedir(dir);
1286 }
1287 free(match_name);
1288 ly_set_free(dirs, free);
1289
1290 return ret;
1291}
1292