blob: b19990f23f3377613589ac1f26f46ac6e2ec5ddb [file] [log] [blame]
Radek Krejci86d106e2018-10-18 09:53:19 +02001/**
2 * @file tree_schema_helpers.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Radek Krejcie7b95092019-05-15 11:03:07 +02004 * @brief Parsing and validation helper functions for schema trees
Radek Krejci86d106e2018-10-18 09:53:19 +02005 *
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 Krejci9ed7a192018-10-31 16:23:51 +010014#include "common.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020015
Radek Krejcie7b95092019-05-15 11:03:07 +020016#include <assert.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020017#include <ctype.h>
Radek Krejci9ed7a192018-10-31 16:23:51 +010018#include <errno.h>
19#include <fcntl.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020020#include <limits.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020021#include <stdint.h>
Radek Krejci9ed7a192018-10-31 16:23:51 +010022#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <string.h>
Radek Krejci9ed7a192018-10-31 16:23:51 +010024#include <unistd.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020025#include <time.h>
26
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include "context.h"
28#include "dict.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020029#include "hash_table.h"
30#include "log.h"
Radek Krejci0935f412019-08-20 16:15:18 +020031#include "plugins_exts.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020032#include "set.h"
33#include "tree.h"
34#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020035#include "tree_schema_internal.h"
36
Radek Krejci85747952019-06-07 16:43:43 +020037LY_ERR
Radek Krejci95710c92019-02-11 15:49:55 +010038lys_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *context_node,
Radek Krejci6eeb58f2019-02-22 16:29:37 +010039 const struct lys_module *context_module, int nodetype, int implement,
40 const struct lysc_node **target, uint16_t *result_flag)
Radek Krejci9bb94eb2018-12-04 16:48:35 +010041{
42 LY_ERR ret = LY_EVALID;
43 const char *name, *prefix, *id;
Radek Krejci9bb94eb2018-12-04 16:48:35 +010044 size_t name_len, prefix_len;
Radek Krejci7af64242019-02-18 13:07:53 +010045 const struct lys_module *mod;
Radek Krejci95710c92019-02-11 15:49:55 +010046 const char *nodeid_type;
Radek Krejci6eeb58f2019-02-22 16:29:37 +010047 int getnext_extra_flag = 0;
Radek Krejci05b774b2019-02-25 13:26:18 +010048 int current_nodetype = 0;
Radek Krejci9bb94eb2018-12-04 16:48:35 +010049
50 assert(nodeid);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010051 assert(target);
Radek Krejci6eeb58f2019-02-22 16:29:37 +010052 assert(result_flag);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010053 *target = NULL;
Radek Krejci6eeb58f2019-02-22 16:29:37 +010054 *result_flag = 0;
Radek Krejci9bb94eb2018-12-04 16:48:35 +010055
56 id = nodeid;
Radek Krejci95710c92019-02-11 15:49:55 +010057
58 if (context_node) {
59 /* descendant-schema-nodeid */
60 nodeid_type = "descendant";
Radek Krejci3641f562019-02-13 15:38:40 +010061
62 if (*id == '/') {
63 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
64 "Invalid descendant-schema-nodeid value \"%.*s\" - absolute-schema-nodeid used.",
65 nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
66 return LY_EVALID;
67 }
Radek Krejci95710c92019-02-11 15:49:55 +010068 } else {
69 /* absolute-schema-nodeid */
70 nodeid_type = "absolute";
Radek Krejci95710c92019-02-11 15:49:55 +010071
72 if (*id != '/') {
73 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
74 "Invalid absolute-schema-nodeid value \"%.*s\" - missing starting \"/\".",
Radek Krejci3641f562019-02-13 15:38:40 +010075 nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
Radek Krejci95710c92019-02-11 15:49:55 +010076 return LY_EVALID;
77 }
78 ++id;
79 }
80
Radek Krejcib4a4a272019-06-10 12:44:52 +020081 while (*id && (ret = ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len)) == LY_SUCCESS) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +010082 if (prefix) {
Radek Krejci95710c92019-02-11 15:49:55 +010083 mod = lys_module_find_prefix(context_module, prefix, prefix_len);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010084 if (!mod) {
85 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci95710c92019-02-11 15:49:55 +010086 "Invalid %s-schema-nodeid value \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
87 nodeid_type, id - nodeid, nodeid, prefix_len, prefix, context_module->name);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010088 return LY_ENOTFOUND;
89 }
90 } else {
Radek Krejci95710c92019-02-11 15:49:55 +010091 mod = context_module;
92 }
93 if (implement && !mod->implemented) {
94 /* make the module implemented */
Michal Vasko294b76d2019-12-16 10:37:54 +010095 ret = lys_set_implemented_internal((struct lys_module*)mod, 2);
96 LY_CHECK_RET(ret);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010097 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +010098 if (context_node && context_node->nodetype == LYS_ACTION) {
99 /* move through input/output manually */
Radek Krejci7f9b6512019-09-18 13:11:09 +0200100 if (!ly_strncmp("input", name, name_len)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100101 (*result_flag) |= LYSC_OPT_RPC_INPUT;
Radek Krejci7f9b6512019-09-18 13:11:09 +0200102 } else if (!ly_strncmp("output", name, name_len)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100103 (*result_flag) |= LYSC_OPT_RPC_OUTPUT;
104 getnext_extra_flag = LYS_GETNEXT_OUTPUT;
Radek Krejci05b774b2019-02-25 13:26:18 +0100105 } else {
106 goto getnext;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100107 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100108 current_nodetype = LYS_INOUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100109 } else {
Radek Krejci05b774b2019-02-25 13:26:18 +0100110getnext:
Michal Vaskoe444f752020-02-10 12:20:06 +0100111 context_node = lys_find_child(context_node, mod, name, name_len, 0,
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100112 getnext_extra_flag | LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE | LYS_GETNEXT_WITHCASE);
113 if (!context_node) {
114 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
115 "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid);
116 return LY_ENOTFOUND;
117 }
118 getnext_extra_flag = 0;
Radek Krejci05b774b2019-02-25 13:26:18 +0100119 current_nodetype = context_node->nodetype;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100120
Radek Krejci05b774b2019-02-25 13:26:18 +0100121 if (current_nodetype == LYS_NOTIF) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100122 (*result_flag) |= LYSC_OPT_NOTIFICATION;
123 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100124 }
Radek Krejci01342af2019-01-03 15:18:08 +0100125 if (!*id || (nodeid_len && ((size_t)(id - nodeid) >= nodeid_len))) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100126 break;
127 }
Radek Krejci01342af2019-01-03 15:18:08 +0100128 if (*id != '/') {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100129 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci95710c92019-02-11 15:49:55 +0100130 "Invalid %s-schema-nodeid value \"%.*s\" - missing \"/\" as node-identifier separator.",
131 nodeid_type, id - nodeid + 1, nodeid);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100132 return LY_EVALID;
133 }
134 ++id;
135 }
136
137 if (ret == LY_SUCCESS) {
Radek Krejci7af64242019-02-18 13:07:53 +0100138 *target = context_node;
Radek Krejci05b774b2019-02-25 13:26:18 +0100139 if (nodetype & LYS_INOUT) {
140 /* instead of input/output nodes, the RPC/action node is actually returned */
141 }
142 if (nodetype && !(current_nodetype & nodetype)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100143 return LY_EDENIED;
144 }
Radek Krejci95710c92019-02-11 15:49:55 +0100145 } else {
146 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
147 "Invalid %s-schema-nodeid value \"%.*s\" - unexpected end of expression.",
Radek Krejci3641f562019-02-13 15:38:40 +0100148 nodeid_type, nodeid_len ? nodeid_len : strlen(nodeid), nodeid);
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100149 }
150
151 return ret;
152}
153
154LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200155lysp_check_prefix(struct lys_parser_ctx *ctx, struct lysp_import *imports, const char *module_prefix, const char **value)
Radek Krejci86d106e2018-10-18 09:53:19 +0200156{
157 struct lysp_import *i;
158
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100159 if (module_prefix && &module_prefix != value && !strcmp(module_prefix, *value)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100160 LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used as module prefix.", *value);
Radek Krejci86d106e2018-10-18 09:53:19 +0200161 return LY_EEXIST;
162 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100163 LY_ARRAY_FOR(imports, struct lysp_import, i) {
164 if (i->prefix && &i->prefix != value && !strcmp(i->prefix, *value)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100165 LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used to import \"%s\" module.", *value, i->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100166 return LY_EEXIST;
Radek Krejci86d106e2018-10-18 09:53:19 +0200167 }
168 }
169 return LY_SUCCESS;
170}
171
172LY_ERR
Radek Krejci4f28eda2018-11-12 11:46:16 +0100173lysc_check_status(struct lysc_ctx *ctx,
174 uint16_t flags1, void *mod1, const char *name1,
175 uint16_t flags2, void *mod2, const char *name2)
176{
177 uint16_t flg1, flg2;
178
179 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
180 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
181
182 if ((flg1 < flg2) && (mod1 == mod2)) {
183 if (ctx) {
184 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
185 "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
186 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
187 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
188 }
189 return LY_EVALID;
190 }
191
192 return LY_SUCCESS;
193}
194
195LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200196lysp_check_date(struct lys_parser_ctx *ctx, const char *date, int date_len, const char *stmt)
Radek Krejci86d106e2018-10-18 09:53:19 +0200197{
198 int i;
199 struct tm tm, tm_;
200 char *r;
201
Michal Vaskob36053d2020-03-26 15:49:30 +0100202 LY_CHECK_ARG_RET(ctx ? PARSER_CTX(ctx) : NULL, date, LY_EINVAL);
203 LY_CHECK_ERR_RET(date_len != LY_REV_SIZE - 1, LOGARG(ctx ? PARSER_CTX(ctx) : NULL, date_len), LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +0200204
205 /* check format */
206 for (i = 0; i < date_len; i++) {
207 if (i == 4 || i == 7) {
208 if (date[i] != '-') {
209 goto error;
210 }
211 } else if (!isdigit(date[i])) {
212 goto error;
213 }
214 }
215
216 /* check content, e.g. 2018-02-31 */
217 memset(&tm, 0, sizeof tm);
218 r = strptime(date, "%Y-%m-%d", &tm);
219 if (!r || r != &date[LY_REV_SIZE - 1]) {
220 goto error;
221 }
222 memcpy(&tm_, &tm, sizeof tm);
223 mktime(&tm_); /* mktime modifies tm_ if it refers invalid date */
224 if (tm.tm_mday != tm_.tm_mday) { /* e.g 2018-02-29 -> 2018-03-01 */
225 /* checking days is enough, since other errors
226 * have been checked by strptime() */
227 goto error;
228 }
229
230 return LY_SUCCESS;
231
232error:
Radek Krejcid33273d2018-10-25 14:55:52 +0200233 if (stmt) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100234 if (ctx) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100235 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, date_len, date, stmt);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100236 } else {
237 LOGVAL(NULL, LY_VLOG_NONE, NULL, LY_VCODE_INVAL, date_len, date, stmt);
238 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200239 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200240 return LY_EINVAL;
241}
242
243void
244lysp_sort_revisions(struct lysp_revision *revs)
245{
246 uint8_t i, r;
247 struct lysp_revision rev;
248
249 for (i = 1, r = 0; revs && i < LY_ARRAY_SIZE(revs); i++) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200250 if (strcmp(revs[i].date, revs[r].date) > 0) {
Radek Krejci86d106e2018-10-18 09:53:19 +0200251 r = i;
252 }
253 }
254
255 if (r) {
256 /* the newest revision is not on position 0, switch them */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200257 memcpy(&rev, &revs[0], sizeof rev);
258 memcpy(&revs[0], &revs[r], sizeof rev);
259 memcpy(&revs[r], &rev, sizeof rev);
Radek Krejci86d106e2018-10-18 09:53:19 +0200260 }
261}
Radek Krejci151a5b72018-10-19 14:21:44 +0200262
Radek Krejcibbe09a92018-11-08 09:36:54 +0100263static const struct lysp_tpdf *
264lysp_type_match(const char *name, struct lysp_node *node)
265{
Radek Krejci0fb28562018-12-13 15:17:37 +0100266 const struct lysp_tpdf *typedefs;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100267 unsigned int u;
268
Radek Krejci0fb28562018-12-13 15:17:37 +0100269 typedefs = lysp_node_typedefs(node);
270 LY_ARRAY_FOR(typedefs, u) {
271 if (!strcmp(name, typedefs[u].name)) {
272 /* match */
273 return &typedefs[u];
Radek Krejcibbe09a92018-11-08 09:36:54 +0100274 }
275 }
276
277 return NULL;
278}
279
Radek Krejci4f28eda2018-11-12 11:46:16 +0100280static LY_DATA_TYPE
281lysp_type_str2builtin(const char *name, size_t len)
282{
283 if (len >= 4) { /* otherwise it does not match any built-in type */
284 if (name[0] == 'b') {
285 if (name[1] == 'i') {
286 if (len == 6 && !strncmp(&name[2], "nary", 4)) {
287 return LY_TYPE_BINARY;
288 } else if (len == 4 && !strncmp(&name[2], "ts", 2)) {
289 return LY_TYPE_BITS;
290 }
291 } else if (len == 7 && !strncmp(&name[1], "oolean", 6)) {
292 return LY_TYPE_BOOL;
293 }
294 } else if (name[0] == 'd') {
295 if (len == 9 && !strncmp(&name[1], "ecimal64", 8)) {
296 return LY_TYPE_DEC64;
297 }
298 } else if (name[0] == 'e') {
299 if (len == 5 && !strncmp(&name[1], "mpty", 4)) {
300 return LY_TYPE_EMPTY;
301 } else if (len == 11 && !strncmp(&name[1], "numeration", 10)) {
302 return LY_TYPE_ENUM;
303 }
304 } else if (name[0] == 'i') {
305 if (name[1] == 'n') {
306 if (len == 4 && !strncmp(&name[2], "t8", 2)) {
307 return LY_TYPE_INT8;
308 } else if (len == 5) {
309 if (!strncmp(&name[2], "t16", 3)) {
310 return LY_TYPE_INT16;
311 } else if (!strncmp(&name[2], "t32", 3)) {
312 return LY_TYPE_INT32;
313 } else if (!strncmp(&name[2], "t64", 3)) {
314 return LY_TYPE_INT64;
315 }
316 } else if (len == 19 && !strncmp(&name[2], "stance-identifier", 17)) {
317 return LY_TYPE_INST;
318 }
319 } else if (len == 11 && !strncmp(&name[1], "dentityref", 10)) {
320 return LY_TYPE_IDENT;
321 }
322 } else if (name[0] == 'l') {
323 if (len == 7 && !strncmp(&name[1], "eafref", 6)) {
324 return LY_TYPE_LEAFREF;
325 }
326 } else if (name[0] == 's') {
327 if (len == 6 && !strncmp(&name[1], "tring", 5)) {
328 return LY_TYPE_STRING;
329 }
330 } else if (name[0] == 'u') {
331 if (name[1] == 'n') {
332 if (len == 5 && !strncmp(&name[2], "ion", 3)) {
333 return LY_TYPE_UNION;
334 }
335 } else if (name[1] == 'i' && name[2] == 'n' && name[3] == 't') {
336 if (len == 5 && name[4] == '8') {
337 return LY_TYPE_UINT8;
338 } else if (len == 6) {
339 if (!strncmp(&name[4], "16", 2)) {
340 return LY_TYPE_UINT16;
341 } else if (!strncmp(&name[4], "32", 2)) {
342 return LY_TYPE_UINT32;
343 } else if (!strncmp(&name[4], "64", 2)) {
344 return LY_TYPE_UINT64;
345 }
346 }
347 }
348 }
349 }
350
351 return LY_TYPE_UNKNOWN;
352}
353
Radek Krejcibbe09a92018-11-08 09:36:54 +0100354LY_ERR
355lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module,
Radek Krejci4f28eda2018-11-12 11:46:16 +0100356 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100357{
358 const char *str, *name;
359 struct lysp_tpdf *typedefs;
360 unsigned int u, v;
361
362 assert(id);
363 assert(start_module);
364 assert(tpdf);
365 assert(node);
366 assert(module);
367
Radek Krejci4f28eda2018-11-12 11:46:16 +0100368 *node = NULL;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100369 str = strchr(id, ':');
370 if (str) {
371 *module = lysp_module_find_prefix(start_module, id, str - id);
372 name = str + 1;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100373 *type = LY_TYPE_UNKNOWN;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100374 } else {
375 *module = start_module;
376 name = id;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100377
378 /* check for built-in types */
379 *type = lysp_type_str2builtin(name, strlen(name));
380 if (*type) {
381 *tpdf = NULL;
382 return LY_SUCCESS;
383 }
Radek Krejcibbe09a92018-11-08 09:36:54 +0100384 }
385 LY_CHECK_RET(!(*module), LY_ENOTFOUND);
386
387 if (start_node && *module == start_module) {
388 /* search typedefs in parent's nodes */
389 *node = start_node;
390 while (*node) {
391 *tpdf = lysp_type_match(name, *node);
392 if (*tpdf) {
393 /* match */
394 return LY_SUCCESS;
395 }
396 *node = (*node)->parent;
397 }
398 }
399
400 /* search in top-level typedefs */
401 if ((*module)->typedefs) {
402 LY_ARRAY_FOR((*module)->typedefs, u) {
403 if (!strcmp(name, (*module)->typedefs[u].name)) {
404 /* match */
405 *tpdf = &(*module)->typedefs[u];
406 return LY_SUCCESS;
407 }
408 }
409 }
410
411 /* search in submodules' typedefs */
412 LY_ARRAY_FOR((*module)->includes, u) {
413 typedefs = (*module)->includes[u].submodule->typedefs;
Radek Krejci76b3e962018-12-14 17:01:25 +0100414 LY_ARRAY_FOR(typedefs, v) {
415 if (!strcmp(name, typedefs[v].name)) {
416 /* match */
417 *tpdf = &typedefs[v];
418 return LY_SUCCESS;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100419 }
420 }
421 }
422
423 return LY_ENOTFOUND;
424}
425
David Sedlák6544c182019-07-12 13:17:33 +0200426LY_ERR
David Sedlák07869a52019-07-12 14:28:19 +0200427lysp_check_enum_name(struct lys_parser_ctx *ctx, const char *name, size_t name_len)
David Sedlák6544c182019-07-12 13:17:33 +0200428{
429 if (!name_len) {
430 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not be zero-length.");
431 return LY_EVALID;
432 } else if (isspace(name[0]) || isspace(name[name_len - 1])) {
433 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not have any leading or trailing whitespaces (\"%.*s\").",
434 name_len, name);
435 return LY_EVALID;
436 } else {
437 for (size_t u = 0; u < name_len; ++u) {
438 if (iscntrl(name[u])) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100439 LOGWRN(PARSER_CTX(ctx), "Control characters in enum name should be avoided (\"%.*s\", character number %d).",
David Sedlák6544c182019-07-12 13:17:33 +0200440 name_len, name, u + 1);
441 break;
442 }
443 }
444 }
445
446 return LY_SUCCESS;
447}
448
Michal Vaskob36053d2020-03-26 15:49:30 +0100449/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100450 * @brief Check name of a new type to avoid name collisions.
451 *
452 * @param[in] ctx Parser context, module where the type is being defined is taken from here.
453 * @param[in] node Schema node where the type is being defined, NULL in case of a top-level typedef.
454 * @param[in] tpdf Typedef definition to check.
455 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
456 * typedefs are checked, caller is supposed to free the table.
457 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
458 * typedefs are checked, caller is supposed to free the table.
459 * @return LY_EEXIST in case of collision, LY_SUCCESS otherwise.
460 */
461static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200462lysp_check_typedef(struct lys_parser_ctx *ctx, struct lysp_node *node, const struct lysp_tpdf *tpdf,
Radek Krejcibbe09a92018-11-08 09:36:54 +0100463 struct hash_table *tpdfs_global, struct hash_table *tpdfs_scoped)
464{
465 struct lysp_node *parent;
466 uint32_t hash;
467 size_t name_len;
468 const char *name;
469 unsigned int u;
Radek Krejci0fb28562018-12-13 15:17:37 +0100470 const struct lysp_tpdf *typedefs;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100471
472 assert(ctx);
473 assert(tpdf);
474
475 name = tpdf->name;
476 name_len = strlen(name);
477
Radek Krejci4f28eda2018-11-12 11:46:16 +0100478 if (lysp_type_str2builtin(name, name_len)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100479 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with a built-in type.", name);
Radek Krejci4f28eda2018-11-12 11:46:16 +0100480 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100481 }
482
483 /* check locally scoped typedefs (avoid name shadowing) */
484 if (node) {
Radek Krejci0fb28562018-12-13 15:17:37 +0100485 typedefs = lysp_node_typedefs(node);
486 LY_ARRAY_FOR(typedefs, u) {
487 if (&typedefs[u] == tpdf) {
488 break;
489 }
490 if (!strcmp(name, typedefs[u].name)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100491 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with sibling type.", name);
Radek Krejci0fb28562018-12-13 15:17:37 +0100492 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100493 }
494 }
495 /* search typedefs in parent's nodes */
Radek Krejci87e78ca2019-05-02 09:51:29 +0200496 for (parent = node->parent; parent; parent = parent->parent) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100497 if (lysp_type_match(name, parent)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100498 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with another scoped type.", name);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100499 return LY_EEXIST;
500 }
501 }
502 }
503
504 /* check collision with the top-level typedefs */
505 hash = dict_hash(name, name_len);
506 if (node) {
507 lyht_insert(tpdfs_scoped, &name, hash, NULL);
508 if (!lyht_find(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100509 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - scoped type collide with a top-level type.", name);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100510 return LY_EEXIST;
511 }
512 } else {
513 if (lyht_insert(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100514 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with another top-level type.", name);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100515 return LY_EEXIST;
516 }
Radek Krejci3b1f9292018-11-08 10:58:35 +0100517 /* it is not necessary to test collision with the scoped types - in lysp_check_typedefs, all the
518 * top-level typedefs are inserted into the tables before the scoped typedefs, so the collision
519 * is detected in the first branch few lines above */
Radek Krejcibbe09a92018-11-08 09:36:54 +0100520 }
521
522 return LY_SUCCESS;
523}
524
525static int
526lysp_id_cmp(void *val1, void *val2, int UNUSED(mod), void *UNUSED(cb_data))
527{
528 return !strcmp(val1, val2);
529}
530
531LY_ERR
David Sedlákd2ebe572019-07-22 12:53:14 +0200532lysp_parse_finalize_reallocated(struct lys_parser_ctx *ctx, struct lysp_grp *groupings, struct lysp_augment *augments,
533 struct lysp_action *actions, struct lysp_notif *notifs)
534{
535 unsigned int u, v;
536 struct lysp_node *child;
537
538 /* finalize parent pointers to the reallocated items */
539
540 /* gropings */
541 LY_ARRAY_FOR(groupings, u) {
542 LY_LIST_FOR(groupings[u].data, child) {
543 child->parent = (struct lysp_node*)&groupings[u];
544 }
545 LY_ARRAY_FOR(groupings[u].actions, v) {
546 groupings[u].actions[v].parent = (struct lysp_node*)&groupings[u];
547 }
548 LY_ARRAY_FOR(groupings[u].notifs, v) {
549 groupings[u].notifs[v].parent = (struct lysp_node*)&groupings[u];
550 }
551 LY_ARRAY_FOR(groupings[u].groupings, v) {
552 groupings[u].groupings[v].parent = (struct lysp_node*)&groupings[u];
553 }
554 if (groupings[u].typedefs) {
555 ly_set_add(&ctx->tpdfs_nodes, &groupings[u], 0);
556 }
557 }
558
559 /* augments */
560 LY_ARRAY_FOR(augments, u) {
561 LY_LIST_FOR(augments[u].child, child) {
562 child->parent = (struct lysp_node*)&augments[u];
563 }
564 LY_ARRAY_FOR(augments[u].actions, v) {
565 augments[u].actions[v].parent = (struct lysp_node*)&augments[u];
566 }
567 LY_ARRAY_FOR(augments[u].notifs, v) {
568 augments[u].notifs[v].parent = (struct lysp_node*)&augments[u];
569 }
570 }
571
572 /* actions */
573 LY_ARRAY_FOR(actions, u) {
574 if (actions[u].input.parent) {
575 actions[u].input.parent = (struct lysp_node*)&actions[u];
576 LY_LIST_FOR(actions[u].input.data, child) {
577 child->parent = (struct lysp_node*)&actions[u].input;
578 }
579 LY_ARRAY_FOR(actions[u].input.groupings, v) {
580 actions[u].input.groupings[v].parent = (struct lysp_node*)&actions[u].input;
581 }
582 if (actions[u].input.typedefs) {
583 ly_set_add(&ctx->tpdfs_nodes, &actions[u].input, 0);
584 }
585 }
586 if (actions[u].output.parent) {
587 actions[u].output.parent = (struct lysp_node*)&actions[u];
588 LY_LIST_FOR(actions[u].output.data, child) {
589 child->parent = (struct lysp_node*)&actions[u].output;
590 }
591 LY_ARRAY_FOR(actions[u].output.groupings, v) {
592 actions[u].output.groupings[v].parent = (struct lysp_node*)&actions[u].output;
593 }
594 if (actions[u].output.typedefs) {
595 ly_set_add(&ctx->tpdfs_nodes, &actions[u].output, 0);
596 }
597 }
598 LY_ARRAY_FOR(actions[u].groupings, v) {
599 actions[u].groupings[v].parent = (struct lysp_node*)&actions[u];
600 }
601 if (actions[u].typedefs) {
602 ly_set_add(&ctx->tpdfs_nodes, &actions[u], 0);
603 }
604 }
605
606 /* notifications */
607 LY_ARRAY_FOR(notifs, u) {
608 LY_LIST_FOR(notifs[u].data, child) {
609 child->parent = (struct lysp_node*)&notifs[u];
610 }
611 LY_ARRAY_FOR(notifs[u].groupings, v) {
612 notifs[u].groupings[v].parent = (struct lysp_node*)&notifs[u];
613 }
614 if (notifs[u].typedefs) {
615 ly_set_add(&ctx->tpdfs_nodes, &notifs[u], 0);
616 }
617 }
618
619 return LY_SUCCESS;
620}
621
622LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200623lysp_check_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100624{
625 struct hash_table *ids_global;
626 struct hash_table *ids_scoped;
Radek Krejci0fb28562018-12-13 15:17:37 +0100627 const struct lysp_tpdf *typedefs;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100628 unsigned int i, u;
629 LY_ERR ret = LY_EVALID;
630
631 /* check name collisions - typedefs and groupings */
632 ids_global = lyht_new(8, sizeof(char*), lysp_id_cmp, NULL, 1);
633 ids_scoped = lyht_new(8, sizeof(char*), lysp_id_cmp, NULL, 1);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100634 LY_ARRAY_FOR(mod->typedefs, i) {
635 if (lysp_check_typedef(ctx, NULL, &mod->typedefs[i], ids_global, ids_scoped)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100636 goto cleanup;
637 }
638 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100639 LY_ARRAY_FOR(mod->includes, i) {
640 LY_ARRAY_FOR(mod->includes[i].submodule->typedefs, u) {
641 if (lysp_check_typedef(ctx, NULL, &mod->includes[i].submodule->typedefs[u], ids_global, ids_scoped)) {
Radek Krejci3b1f9292018-11-08 10:58:35 +0100642 goto cleanup;
643 }
644 }
645 }
Radek Krejcibbe09a92018-11-08 09:36:54 +0100646 for (u = 0; u < ctx->tpdfs_nodes.count; ++u) {
Radek Krejci0fb28562018-12-13 15:17:37 +0100647 typedefs = lysp_node_typedefs((struct lysp_node *)ctx->tpdfs_nodes.objs[u]);
648 LY_ARRAY_FOR(typedefs, i) {
649 if (lysp_check_typedef(ctx, (struct lysp_node *)ctx->tpdfs_nodes.objs[u], &typedefs[i], ids_global, ids_scoped)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100650 goto cleanup;
651 }
652 }
653 }
654 ret = LY_SUCCESS;
655cleanup:
656 lyht_free(ids_global);
657 lyht_free(ids_scoped);
658 ly_set_erase(&ctx->tpdfs_nodes, NULL);
659
660 return ret;
661}
662
Radek Krejci9ed7a192018-10-31 16:23:51 +0100663struct lysp_load_module_check_data {
664 const char *name;
665 const char *revision;
666 const char *path;
667 const char* submoduleof;
668};
669
670static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100671lysp_load_module_check(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data)
Radek Krejci9ed7a192018-10-31 16:23:51 +0100672{
673 struct lysp_load_module_check_data *info = data;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100674 const char *filename, *dot, *rev, *name;
Radek Krejcib3289d62019-09-18 12:21:39 +0200675 uint8_t latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100676 size_t len;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100677 struct lysp_revision *revs;
678
679 name = mod ? mod->mod->name : submod->name;
680 revs = mod ? mod->revs : submod->revs;
Radek Krejcib3289d62019-09-18 12:21:39 +0200681 latest_revision = mod ? mod->mod->latest_revision : submod->latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100682
683 if (info->name) {
684 /* check name of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100685 if (strcmp(info->name, name)) {
686 LOGERR(ctx, LY_EINVAL, "Unexpected module \"%s\" parsed instead of \"%s\").", name, info->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100687 return LY_EINVAL;
688 }
689 }
690 if (info->revision) {
691 /* check revision of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100692 if (!revs || strcmp(info->revision, revs[0].date)) {
693 LOGERR(ctx, LY_EINVAL, "Module \"%s\" parsed with the wrong revision (\"%s\" instead \"%s\").", name,
Radek Krejcib07b5c92019-04-08 10:56:37 +0200694 revs ? revs[0].date : "none", info->revision);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100695 return LY_EINVAL;
696 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200697 } else if (!latest_revision) {
698 /* do not log, we just need to drop the schema and use the latest revision from the context */
699 return LY_EEXIST;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100700 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100701 if (submod) {
702 assert(info->submoduleof);
703
Radek Krejci9ed7a192018-10-31 16:23:51 +0100704 /* check that the submodule belongs-to our module */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100705 if (strcmp(info->submoduleof, submod->belongsto)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100706 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Included \"%s\" submodule from \"%s\" belongs-to a different module \"%s\".",
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100707 submod->name, info->submoduleof, submod->belongsto);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100708 return LY_EVALID;
709 }
710 /* check circular dependency */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100711 if (submod->parsing) {
712 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (include) for module \"%s\".", submod->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100713 return LY_EVALID;
714 }
715 }
716 if (info->path) {
717 /* check that name and revision match filename */
718 filename = strrchr(info->path, '/');
719 if (!filename) {
720 filename = info->path;
721 } else {
722 filename++;
723 }
724 /* name */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100725 len = strlen(name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100726 rev = strchr(filename, '@');
727 dot = strrchr(info->path, '.');
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100728 if (strncmp(filename, name, len) ||
Radek Krejci9ed7a192018-10-31 16:23:51 +0100729 ((rev && rev != &filename[len]) || (!rev && dot != &filename[len]))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100730 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100731 }
732 /* revision */
733 if (rev) {
734 len = dot - ++rev;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100735 if (!revs || len != 10 || strncmp(revs[0].date, rev, len)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100736 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100737 revs ? revs[0].date : "none");
Radek Krejci9ed7a192018-10-31 16:23:51 +0100738 }
739 }
740 }
741 return LY_SUCCESS;
742}
743
744LY_ERR
fredgancd485b82019-10-18 15:00:17 +0800745lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, int implement,
Radek Krejci78f06822019-10-30 12:54:05 +0100746 struct lys_parser_ctx *main_ctx, const char *main_name, int required, void **result)
Radek Krejci9ed7a192018-10-31 16:23:51 +0100747{
748 int fd;
749 char *filepath = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100750 const char **fp;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100751 LYS_INFORMAT format;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100752 void *mod = NULL;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100753 LY_ERR ret = LY_SUCCESS;
754 struct lysp_load_module_check_data check_data = {0};
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100755 char rpath[PATH_MAX];
Radek Krejci9ed7a192018-10-31 16:23:51 +0100756
757 LY_CHECK_RET(lys_search_localfile(ly_ctx_get_searchdirs(ctx), !(ctx->flags & LY_CTX_DISABLE_SEARCHDIR_CWD), name, revision,
758 &filepath, &format));
Radek Krejci78f06822019-10-30 12:54:05 +0100759 LY_CHECK_ERR_RET(!filepath, if (required) {LOGERR(ctx, LY_ENOTFOUND, "Data model \"%s%s%s\" not found in local searchdirs.",
760 name, revision ? "@" : "", revision ? revision : "");}, LY_ENOTFOUND);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100761
762 LOGVRB("Loading schema from \"%s\" file.", filepath);
763
764 /* open the file */
765 fd = open(filepath, O_RDONLY);
766 LY_CHECK_ERR_GOTO(fd < 0, LOGERR(ctx, LY_ESYS, "Unable to open data model file \"%s\" (%s).",
767 filepath, strerror(errno)); ret = LY_ESYS, cleanup);
768
769 check_data.name = name;
770 check_data.revision = revision;
771 check_data.path = filepath;
fredgancd485b82019-10-18 15:00:17 +0800772 check_data.submoduleof = main_name;
Radek Krejci3b1f9292018-11-08 10:58:35 +0100773 mod = lys_parse_fd_(ctx, fd, format, implement, main_ctx,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100774 lysp_load_module_check, &check_data);
775 close(fd);
776 LY_CHECK_ERR_GOTO(!mod, ly_errcode(ctx), cleanup);
777
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100778 if (main_ctx) {
779 fp = &((struct lysp_submodule*)mod)->filepath;
780 } else {
781 fp = &((struct lys_module*)mod)->filepath;
782 }
783 if (!(*fp)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100784 if (realpath(filepath, rpath) != NULL) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100785 (*fp) = lydict_insert(ctx, rpath, 0);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100786 } else {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100787 (*fp) = lydict_insert(ctx, filepath, 0);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100788 }
789 }
790
791 *result = mod;
792
793 /* success */
794cleanup:
795 free(filepath);
796 return ret;
797}
798
Radek Krejcid33273d2018-10-25 14:55:52 +0200799LY_ERR
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100800lysp_load_module(struct ly_ctx *ctx, const char *name, const char *revision, int implement, int require_parsed, struct lys_module **mod)
Radek Krejci086c7132018-10-26 15:29:04 +0200801{
Radek Krejci9ed7a192018-10-31 16:23:51 +0100802 const char *module_data = NULL;
Radek Krejci086c7132018-10-26 15:29:04 +0200803 LYS_INFORMAT format = LYS_IN_UNKNOWN;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100804 void (*module_data_free)(void *module_data, void *user_data) = NULL;
805 struct lysp_load_module_check_data check_data = {0};
Radek Krejcib3289d62019-09-18 12:21:39 +0200806 struct lys_module *m = NULL;
Radek Krejci086c7132018-10-26 15:29:04 +0200807
Radek Krejci0af46292019-01-11 16:02:31 +0100808 assert(mod);
809
810 if (!*mod) {
811 /* try to get the module from the context */
812 if (revision) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200813 /* get the specific revision */
Radek Krejci0af46292019-01-11 16:02:31 +0100814 *mod = (struct lys_module*)ly_ctx_get_module(ctx, name, revision);
Radek Krejcied5acc52019-04-25 15:57:04 +0200815 } else if (implement) {
816 /* prefer the implemented module instead of the latest one */
817 *mod = (struct lys_module*)ly_ctx_get_module_implemented(ctx, name);
818 if (!*mod) {
819 /* there is no implemented module in the context, try to get the latest revision module */
820 goto latest_in_the_context;
821 }
Radek Krejci0af46292019-01-11 16:02:31 +0100822 } else {
Radek Krejcied5acc52019-04-25 15:57:04 +0200823 /* get the requested module of the latest revision in the context */
824latest_in_the_context:
Radek Krejci0af46292019-01-11 16:02:31 +0100825 *mod = (struct lys_module*)ly_ctx_get_module_latest(ctx, name);
Radek Krejcib3289d62019-09-18 12:21:39 +0200826 if (*mod && (*mod)->latest_revision == 1) {
827 /* let us now search with callback and searchpaths to check if there is newer revision outside the context */
828 m = *mod;
829 *mod = NULL;
830 }
Radek Krejci0af46292019-01-11 16:02:31 +0100831 }
Radek Krejci086c7132018-10-26 15:29:04 +0200832 }
833
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100834 if (!(*mod) || (require_parsed && !(*mod)->parsed)) {
835 (*mod) = NULL;
836
Radek Krejci086c7132018-10-26 15:29:04 +0200837 /* check collision with other implemented revision */
838 if (implement && ly_ctx_get_module_implemented(ctx, name)) {
839 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
840 "Module \"%s\" is already present in other implemented revision.", name);
841 return LY_EDENIED;
842 }
843
Radek Krejci9ed7a192018-10-31 16:23:51 +0100844 /* module not present in the context, get the input data and parse it */
Radek Krejci086c7132018-10-26 15:29:04 +0200845 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
846search_clb:
847 if (ctx->imp_clb) {
848 if (ctx->imp_clb(name, revision, NULL, NULL, ctx->imp_clb_data,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100849 &format, &module_data, &module_data_free) == LY_SUCCESS) {
850 check_data.name = name;
851 check_data.revision = revision;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100852 *mod = lys_parse_mem_module(ctx, module_data, format, implement,
853 lysp_load_module_check, &check_data);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100854 if (module_data_free) {
855 module_data_free((void*)module_data, ctx->imp_clb_data);
856 }
Radek Krejci096235c2019-01-11 11:12:19 +0100857 if (*mod && implement && lys_compile(*mod, 0)) {
858 ly_set_rm(&ctx->list, *mod, NULL);
859 lys_module_free(*mod, NULL);
860 *mod = NULL;
861 }
Radek Krejci086c7132018-10-26 15:29:04 +0200862 }
863 }
864 if (!(*mod) && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
865 goto search_file;
866 }
867 } else {
868search_file:
869 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
870 /* module was not received from the callback or there is no callback set */
Radek Krejci78f06822019-10-30 12:54:05 +0100871 lys_module_localfile(ctx, name, revision, implement, NULL, NULL, m ? 0 : 1, (void **)mod);
Radek Krejci086c7132018-10-26 15:29:04 +0200872 }
873 if (!(*mod) && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
874 goto search_clb;
875 }
876 }
Radek Krejci9ed7a192018-10-31 16:23:51 +0100877
Radek Krejcib3289d62019-09-18 12:21:39 +0200878 /* update the latest_revision flag - here we have selected the latest available schema,
879 * consider that even the callback provides correct latest revision */
880 if (!(*mod) && m) {
Radek Krejci78f06822019-10-30 12:54:05 +0100881 LOGVRB("Newer revision than %s-%s not found, using this as the latest revision.", m->name, m->revision);
Radek Krejcib3289d62019-09-18 12:21:39 +0200882 m->latest_revision = 2;
883 *mod = m;
884 } else if ((*mod) && !revision && ((*mod)->latest_revision == 1)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100885 (*mod)->latest_revision = 2;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100886 }
Radek Krejci086c7132018-10-26 15:29:04 +0200887 } else {
888 /* we have module from the current context */
Radek Krejci0af46292019-01-11 16:02:31 +0100889 if (implement) {
890 m = ly_ctx_get_module_implemented(ctx, name);
891 if (m && m != *mod) {
892 /* check collision with other implemented revision */
893 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
894 "Module \"%s\" is already present in other implemented revision.", name);
895 *mod = NULL;
896 return LY_EDENIED;
897 }
Radek Krejci086c7132018-10-26 15:29:04 +0200898 }
899
900 /* circular check */
Radek Krejcif8f882a2018-10-31 14:51:15 +0100901 if ((*mod)->parsed && (*mod)->parsed->parsing) {
Radek Krejci086c7132018-10-26 15:29:04 +0200902 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (import) for module \"%s\".", name);
903 *mod = NULL;
904 return LY_EVALID;
905 }
906 }
907 if (!(*mod)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100908 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "%s \"%s\" module failed.", implement ? "Loading" : "Importing", name);
Radek Krejci086c7132018-10-26 15:29:04 +0200909 return LY_EVALID;
910 }
911
912 if (implement) {
913 /* mark the module implemented, check for collision was already done */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100914 (*mod)->implemented = 1;
Radek Krejci086c7132018-10-26 15:29:04 +0200915 }
Radek Krejci086c7132018-10-26 15:29:04 +0200916
917 return LY_SUCCESS;
918}
919
920LY_ERR
David Sedlák4a650532019-07-10 11:55:18 +0200921lysp_check_stringchar(struct lys_parser_ctx *ctx, unsigned int c)
922{
923 if (!is_yangutf8char(c)) {
924 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, c);
925 return LY_EVALID;
926 }
927 return LY_SUCCESS;
928}
929
930LY_ERR
931lysp_check_identifierchar(struct lys_parser_ctx *ctx, unsigned int c, int first, int *prefix)
932{
933 if (first || (prefix && (*prefix) == 1)) {
934 if (!is_yangidentstartchar(c)) {
935 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '%c'.", c);
936 return LY_EVALID;
937 }
938 if (prefix) {
939 if (first) {
940 (*prefix) = 0;
941 } else {
942 (*prefix) = 2;
943 }
944 }
945 } else if (c == ':' && prefix && (*prefix) == 0) {
946 (*prefix) = 1;
947 } else if (!is_yangidentchar(c)) {
948 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier character '%c'.", c);
949 return LY_EVALID;
950 }
951
952 return LY_SUCCESS;
953}
954
955LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100956lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_module *mod, struct lysp_include *inc)
Radek Krejcid33273d2018-10-25 14:55:52 +0200957{
Michal Vaskob36053d2020-03-26 15:49:30 +0100958 struct ly_ctx *ctx = (struct ly_ctx *)(PARSER_CTX(pctx));
Radek Krejci3eb299d2019-04-08 15:07:44 +0200959 struct lysp_submodule *submod = NULL;
Radek Krejcid33273d2018-10-25 14:55:52 +0200960 const char *submodule_data = NULL;
961 LYS_INFORMAT format = LYS_IN_UNKNOWN;
962 void (*submodule_data_free)(void *module_data, void *user_data) = NULL;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100963 struct lysp_load_module_check_data check_data = {0};
Radek Krejcid33273d2018-10-25 14:55:52 +0200964
Radek Krejcibbe09a92018-11-08 09:36:54 +0100965 /* submodule not present in the context, get the input data and parse it */
Michal Vaskob36053d2020-03-26 15:49:30 +0100966 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcid33273d2018-10-25 14:55:52 +0200967search_clb:
Michal Vaskob36053d2020-03-26 15:49:30 +0100968 if (ctx->imp_clb) {
969 if (ctx->imp_clb(mod->mod->name, NULL, inc->name, inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data,
Radek Krejcibbe09a92018-11-08 09:36:54 +0100970 &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) {
971 check_data.name = inc->name;
972 check_data.revision = inc->rev[0] ? inc->rev : NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100973 check_data.submoduleof = mod->mod->name;
Michal Vaskob36053d2020-03-26 15:49:30 +0100974 submod = lys_parse_mem_submodule(ctx, submodule_data, format, pctx,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100975 lysp_load_module_check, &check_data);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100976 if (submodule_data_free) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100977 submodule_data_free((void*)submodule_data, ctx->imp_clb_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200978 }
979 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200980 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100981 if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100982 goto search_file;
Radek Krejcid33273d2018-10-25 14:55:52 +0200983 }
Radek Krejci2d31ea72018-10-25 15:46:42 +0200984 } else {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100985search_file:
Michal Vaskob36053d2020-03-26 15:49:30 +0100986 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100987 /* submodule was not received from the callback or there is no callback set */
Michal Vaskob36053d2020-03-26 15:49:30 +0100988 lys_module_localfile(ctx, inc->name, inc->rev[0] ? inc->rev : NULL, 0, pctx, mod->mod->name, 1, (void**)&submod);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100989 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100990 if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100991 goto search_clb;
992 }
993 }
994 if (submod) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100995 if (!inc->rev[0] && (submod->latest_revision == 1)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100996 /* update the latest_revision flag - here we have selected the latest available schema,
997 * consider that even the callback provides correct latest revision */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100998 submod->latest_revision = 2;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100999 }
1000
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001001 inc->submodule = submod;
Radek Krejcid33273d2018-10-25 14:55:52 +02001002 }
1003 if (!inc->submodule) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001004 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.",
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001005 inc->name, mod->mod->name);
Radek Krejcid33273d2018-10-25 14:55:52 +02001006 return LY_EVALID;
1007 }
1008
1009 return LY_SUCCESS;
1010}
1011
Radek Krejci01342af2019-01-03 15:18:08 +01001012#define FIND_MODULE(TYPE, MOD) \
Radek Krejcice8c1592018-10-29 15:35:51 +01001013 TYPE *imp; \
Radek Krejci7f9b6512019-09-18 13:11:09 +02001014 if (!ly_strncmp((MOD)->mod->prefix, prefix, len)) { \
Radek Krejcice8c1592018-10-29 15:35:51 +01001015 /* it is the prefix of the module itself */ \
Radek Krejci0af46292019-01-11 16:02:31 +01001016 m = ly_ctx_get_module((MOD)->mod->ctx, (MOD)->mod->name, (MOD)->mod->revision); \
Radek Krejcice8c1592018-10-29 15:35:51 +01001017 } \
1018 /* search in imports */ \
Radek Krejcibbe09a92018-11-08 09:36:54 +01001019 if (!m) { \
1020 LY_ARRAY_FOR((MOD)->imports, TYPE, imp) { \
Radek Krejci7f9b6512019-09-18 13:11:09 +02001021 if (!ly_strncmp(imp->prefix, prefix, len)) { \
Radek Krejcibbe09a92018-11-08 09:36:54 +01001022 m = imp->module; \
1023 break; \
1024 } \
Radek Krejcice8c1592018-10-29 15:35:51 +01001025 } \
Radek Krejcibbe09a92018-11-08 09:36:54 +01001026 }
Radek Krejcice8c1592018-10-29 15:35:51 +01001027
Radek Krejcibbe09a92018-11-08 09:36:54 +01001028struct lysc_module *
Radek Krejcia3045382018-11-22 14:30:31 +01001029lysc_module_find_prefix(const struct lysc_module *mod, const char *prefix, size_t len)
Radek Krejci151a5b72018-10-19 14:21:44 +02001030{
Radek Krejcibbe09a92018-11-08 09:36:54 +01001031 const struct lys_module *m = NULL;
1032
Radek Krejci01342af2019-01-03 15:18:08 +01001033 FIND_MODULE(struct lysc_import, mod);
Radek Krejcibbe09a92018-11-08 09:36:54 +01001034 return m ? m->compiled : NULL;
Radek Krejcice8c1592018-10-29 15:35:51 +01001035}
Radek Krejci151a5b72018-10-19 14:21:44 +02001036
Radek Krejcibbe09a92018-11-08 09:36:54 +01001037struct lysp_module *
Radek Krejcia3045382018-11-22 14:30:31 +01001038lysp_module_find_prefix(const struct lysp_module *mod, const char *prefix, size_t len)
Radek Krejcice8c1592018-10-29 15:35:51 +01001039{
Radek Krejcibbe09a92018-11-08 09:36:54 +01001040 const struct lys_module *m = NULL;
1041
Radek Krejci01342af2019-01-03 15:18:08 +01001042 FIND_MODULE(struct lysp_import, mod);
Radek Krejcibbe09a92018-11-08 09:36:54 +01001043 return m ? m->parsed : NULL;
Radek Krejcice8c1592018-10-29 15:35:51 +01001044}
Radek Krejci151a5b72018-10-19 14:21:44 +02001045
Radek Krejcice8c1592018-10-29 15:35:51 +01001046struct lys_module *
Radek Krejcia3045382018-11-22 14:30:31 +01001047lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len)
Radek Krejcice8c1592018-10-29 15:35:51 +01001048{
Radek Krejcibbe09a92018-11-08 09:36:54 +01001049 const struct lys_module *m = NULL;
1050
Michal Vasko88a163b2019-12-18 12:11:44 +01001051 if (!prefix || (!strncmp(prefix, mod->prefix, len) && !mod->prefix[len])) {
1052 return (struct lys_module *)mod;
Radek Krejci73dead22019-07-11 16:46:16 +02001053 }
Radek Krejcice8c1592018-10-29 15:35:51 +01001054 if (mod->compiled) {
Radek Krejci01342af2019-01-03 15:18:08 +01001055 FIND_MODULE(struct lysc_import, mod->compiled);
Radek Krejcice8c1592018-10-29 15:35:51 +01001056 } else {
Radek Krejci01342af2019-01-03 15:18:08 +01001057 FIND_MODULE(struct lysp_import, mod->parsed);
Radek Krejcibbe09a92018-11-08 09:36:54 +01001058 }
1059 return (struct lys_module*)m;
1060}
1061
Radek Krejcia3045382018-11-22 14:30:31 +01001062const char *
Radek Krejci693262f2019-04-29 15:23:20 +02001063lys_prefix_find_module(const struct lys_module *mod, const struct lys_module *import)
1064{
1065 unsigned int u;
1066
1067 if (import == mod) {
1068 return mod->prefix;
1069 }
1070
1071 if (mod->parsed) {
1072 LY_ARRAY_FOR(mod->parsed->imports, u) {
1073 if (mod->parsed->imports[u].module == import) {
1074 return mod->parsed->imports[u].prefix;
1075 }
1076 }
1077 } else {
1078 /* we don't have original information about the import's prefix,
1079 * so the prefix of the import module itself is returned instead */
1080 return import->prefix;
1081 }
1082
1083 return NULL;
1084}
1085
Radek Krejci0935f412019-08-20 16:15:18 +02001086API const char *
Radek Krejcia3045382018-11-22 14:30:31 +01001087lys_nodetype2str(uint16_t nodetype)
1088{
1089 switch(nodetype) {
1090 case LYS_CONTAINER:
1091 return "container";
1092 case LYS_CHOICE:
1093 return "choice";
1094 case LYS_LEAF:
1095 return "leaf";
1096 case LYS_LEAFLIST:
1097 return "leaf-list";
1098 case LYS_LIST:
1099 return "list";
1100 case LYS_ANYXML:
1101 return "anyxml";
1102 case LYS_ANYDATA:
1103 return "anydata";
Radek Krejcif12a1f02019-02-11 16:42:08 +01001104 case LYS_CASE:
1105 return "case";
Radek Krejcif538ce52019-03-05 10:46:14 +01001106 case LYS_ACTION:
1107 return "RPC/action";
1108 case LYS_NOTIF:
Michal Vaskoa3881362020-01-21 15:57:35 +01001109 return "notification";
Radek Krejcifc81ea82019-04-18 13:27:22 +02001110 case LYS_USES:
1111 return "uses";
Radek Krejcia3045382018-11-22 14:30:31 +01001112 default:
1113 return "unknown";
1114 }
1115}
1116
Radek Krejci693262f2019-04-29 15:23:20 +02001117const char *
1118lys_datatype2str(LY_DATA_TYPE basetype)
1119{
1120 switch(basetype) {
1121 case LY_TYPE_BINARY:
1122 return "binary";
1123 case LY_TYPE_UINT8:
1124 return "uint8";
1125 case LY_TYPE_UINT16:
1126 return "uint16";
1127 case LY_TYPE_UINT32:
1128 return "uint32";
1129 case LY_TYPE_UINT64:
1130 return "uint64";
1131 case LY_TYPE_STRING:
1132 return "string";
1133 case LY_TYPE_BITS:
1134 return "bits";
1135 case LY_TYPE_BOOL:
1136 return "boolean";
1137 case LY_TYPE_DEC64:
1138 return "decimal64";
1139 case LY_TYPE_EMPTY:
1140 return "empty";
1141 case LY_TYPE_ENUM:
1142 return "enumeration";
1143 case LY_TYPE_IDENT:
1144 return "identityref";
1145 case LY_TYPE_INST:
1146 return "instance-identifier";
1147 case LY_TYPE_LEAFREF:
1148 return "leafref";
1149 case LY_TYPE_UNION:
1150 return "union";
1151 case LY_TYPE_INT8:
1152 return "int8";
1153 case LY_TYPE_INT16:
1154 return "int16";
1155 case LY_TYPE_INT32:
1156 return "int32";
1157 case LY_TYPE_INT64:
1158 return "int64";
1159 default:
1160 return "unknown";
1161 }
1162}
1163
Radek Krejci056d0a82018-12-06 16:57:25 +01001164API const struct lysp_tpdf *
1165lysp_node_typedefs(const struct lysp_node *node)
1166{
Radek Krejci0fb28562018-12-13 15:17:37 +01001167 switch (node->nodetype) {
1168 case LYS_CONTAINER:
1169 return ((struct lysp_node_container*)node)->typedefs;
1170 case LYS_LIST:
1171 return ((struct lysp_node_list*)node)->typedefs;
1172 case LYS_GROUPING:
1173 return ((struct lysp_grp*)node)->typedefs;
1174 case LYS_ACTION:
1175 return ((struct lysp_action*)node)->typedefs;
1176 case LYS_INOUT:
1177 return ((struct lysp_action_inout*)node)->typedefs;
1178 case LYS_NOTIF:
1179 return ((struct lysp_notif*)node)->typedefs;
1180 default:
Radek Krejci056d0a82018-12-06 16:57:25 +01001181 return NULL;
1182 }
1183}
1184
Radek Krejci53ea6152018-12-13 15:21:15 +01001185API const struct lysp_grp *
1186lysp_node_groupings(const struct lysp_node *node)
1187{
1188 switch (node->nodetype) {
1189 case LYS_CONTAINER:
1190 return ((struct lysp_node_container*)node)->groupings;
1191 case LYS_LIST:
1192 return ((struct lysp_node_list*)node)->groupings;
1193 case LYS_GROUPING:
1194 return ((struct lysp_grp*)node)->groupings;
1195 case LYS_ACTION:
1196 return ((struct lysp_action*)node)->groupings;
1197 case LYS_INOUT:
1198 return ((struct lysp_action_inout*)node)->groupings;
1199 case LYS_NOTIF:
1200 return ((struct lysp_notif*)node)->groupings;
1201 default:
1202 return NULL;
1203 }
1204}
1205
Radek Krejcibbe09a92018-11-08 09:36:54 +01001206struct lysp_action **
Radek Krejci056d0a82018-12-06 16:57:25 +01001207lysp_node_actions_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001208{
1209 assert(node);
1210 switch (node->nodetype) {
1211 case LYS_CONTAINER:
1212 return &((struct lysp_node_container*)node)->actions;
1213 case LYS_LIST:
1214 return &((struct lysp_node_list*)node)->actions;
1215 case LYS_GROUPING:
1216 return &((struct lysp_grp*)node)->actions;
1217 case LYS_AUGMENT:
1218 return &((struct lysp_augment*)node)->actions;
1219 default:
1220 return NULL;
1221 }
1222}
1223
Radek Krejci056d0a82018-12-06 16:57:25 +01001224API const struct lysp_action *
1225lysp_node_actions(const struct lysp_node *node)
1226{
1227 struct lysp_action **actions;
1228 actions = lysp_node_actions_p((struct lysp_node*)node);
1229 if (actions) {
1230 return *actions;
1231 } else {
1232 return NULL;
1233 }
1234}
1235
Radek Krejcibbe09a92018-11-08 09:36:54 +01001236struct lysp_notif **
Radek Krejci056d0a82018-12-06 16:57:25 +01001237lysp_node_notifs_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001238{
1239 assert(node);
1240 switch (node->nodetype) {
1241 case LYS_CONTAINER:
1242 return &((struct lysp_node_container*)node)->notifs;
1243 case LYS_LIST:
1244 return &((struct lysp_node_list*)node)->notifs;
1245 case LYS_GROUPING:
1246 return &((struct lysp_grp*)node)->notifs;
1247 case LYS_AUGMENT:
1248 return &((struct lysp_augment*)node)->notifs;
1249 default:
1250 return NULL;
1251 }
1252}
1253
Radek Krejci056d0a82018-12-06 16:57:25 +01001254API const struct lysp_notif *
1255lysp_node_notifs(const struct lysp_node *node)
1256{
1257 struct lysp_notif **notifs;
1258 notifs = lysp_node_notifs_p((struct lysp_node*)node);
1259 if (notifs) {
1260 return *notifs;
1261 } else {
1262 return NULL;
1263 }
1264}
1265
Radek Krejcibbe09a92018-11-08 09:36:54 +01001266struct lysp_node **
Radek Krejci056d0a82018-12-06 16:57:25 +01001267lysp_node_children_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001268{
1269 assert(node);
1270 switch (node->nodetype) {
1271 case LYS_CONTAINER:
1272 return &((struct lysp_node_container*)node)->child;
1273 case LYS_CHOICE:
1274 return &((struct lysp_node_choice*)node)->child;
1275 case LYS_LIST:
1276 return &((struct lysp_node_list*)node)->child;
1277 case LYS_CASE:
1278 return &((struct lysp_node_case*)node)->child;
1279 case LYS_GROUPING:
1280 return &((struct lysp_grp*)node)->data;
1281 case LYS_AUGMENT:
1282 return &((struct lysp_augment*)node)->child;
1283 case LYS_INOUT:
1284 return &((struct lysp_action_inout*)node)->data;
1285 case LYS_NOTIF:
1286 return &((struct lysp_notif*)node)->data;
1287 default:
1288 return NULL;
1289 }
1290}
1291
Radek Krejci056d0a82018-12-06 16:57:25 +01001292API const struct lysp_node *
1293lysp_node_children(const struct lysp_node *node)
1294{
1295 struct lysp_node **children;
Radek Krejcie7b95092019-05-15 11:03:07 +02001296
1297 if (!node) {
1298 return NULL;
1299 }
1300
Radek Krejci056d0a82018-12-06 16:57:25 +01001301 children = lysp_node_children_p((struct lysp_node*)node);
1302 if (children) {
1303 return *children;
1304 } else {
1305 return NULL;
1306 }
1307}
1308
1309struct lysc_action **
1310lysc_node_actions_p(struct lysc_node *node)
1311{
1312 assert(node);
1313 switch (node->nodetype) {
1314 case LYS_CONTAINER:
1315 return &((struct lysc_node_container*)node)->actions;
1316 case LYS_LIST:
1317 return &((struct lysc_node_list*)node)->actions;
1318 default:
1319 return NULL;
1320 }
1321}
1322
1323API const struct lysc_action *
1324lysc_node_actions(const struct lysc_node *node)
1325{
1326 struct lysc_action **actions;
1327 actions = lysc_node_actions_p((struct lysc_node*)node);
1328 if (actions) {
1329 return *actions;
1330 } else {
1331 return NULL;
1332 }
1333}
1334
1335struct lysc_notif **
1336lysc_node_notifs_p(struct lysc_node *node)
1337{
1338 assert(node);
1339 switch (node->nodetype) {
1340 case LYS_CONTAINER:
1341 return &((struct lysc_node_container*)node)->notifs;
1342 case LYS_LIST:
1343 return &((struct lysc_node_list*)node)->notifs;
1344 default:
1345 return NULL;
1346 }
1347}
1348
1349API const struct lysc_notif *
1350lysc_node_notifs(const struct lysc_node *node)
1351{
1352 struct lysc_notif **notifs;
1353 notifs = lysc_node_notifs_p((struct lysc_node*)node);
1354 if (notifs) {
1355 return *notifs;
1356 } else {
1357 return NULL;
1358 }
1359}
1360
Radek Krejcibbe09a92018-11-08 09:36:54 +01001361struct lysc_node **
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001362lysc_node_children_p(const struct lysc_node *node, uint16_t flags)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001363{
1364 assert(node);
1365 switch (node->nodetype) {
1366 case LYS_CONTAINER:
1367 return &((struct lysc_node_container*)node)->child;
1368 case LYS_CHOICE:
Radek Krejcia3045382018-11-22 14:30:31 +01001369 if (((struct lysc_node_choice*)node)->cases) {
Radek Krejci95710c92019-02-11 15:49:55 +01001370 return &((struct lysc_node_choice*)node)->cases->child;
Radek Krejcia3045382018-11-22 14:30:31 +01001371 } else {
1372 return NULL;
1373 }
Radek Krejci01342af2019-01-03 15:18:08 +01001374 case LYS_CASE:
1375 return &((struct lysc_node_case*)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001376 case LYS_LIST:
1377 return &((struct lysc_node_list*)node)->child;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001378 case LYS_ACTION:
1379 if (flags & LYS_CONFIG_R) {
1380 return &((struct lysc_action*)node)->output.data;
1381 } else {
1382 /* LYS_CONFIG_W, but also the default case */
1383 return &((struct lysc_action*)node)->input.data;
1384 }
Radek Krejcifc11bd72019-04-11 16:00:05 +02001385 case LYS_NOTIF:
1386 return &((struct lysc_notif*)node)->data;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001387 default:
1388 return NULL;
1389 }
1390}
1391
Radek Krejci056d0a82018-12-06 16:57:25 +01001392API const struct lysc_node *
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001393lysc_node_children(const struct lysc_node *node, uint16_t flags)
Radek Krejcia3045382018-11-22 14:30:31 +01001394{
Radek Krejci056d0a82018-12-06 16:57:25 +01001395 struct lysc_node **children;
Radek Krejcie7b95092019-05-15 11:03:07 +02001396
1397 if (!node) {
1398 return NULL;
1399 }
1400
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001401 children = lysc_node_children_p((struct lysc_node*)node, flags);
Radek Krejci056d0a82018-12-06 16:57:25 +01001402 if (children) {
1403 return *children;
1404 } else {
Radek Krejcia3045382018-11-22 14:30:31 +01001405 return NULL;
1406 }
1407}
1408
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001409struct lys_module *
1410lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod)
1411{
1412 unsigned int u;
1413
1414 for (u = 0; u < ctx->list.count; ++u) {
1415 if (((struct lys_module*)ctx->list.objs[u])->parsed == mod) {
1416 return ((struct lys_module*)ctx->list.objs[u]);
1417 }
1418 }
1419 return NULL;
1420}
1421
Radek Krejcid6b76452019-09-03 17:03:03 +02001422enum ly_stmt
Michal Vaskob36053d2020-03-26 15:49:30 +01001423lysp_match_kw(struct lys_yang_parser_ctx *ctx, const char **data)
David Sedlákc10e7902018-12-17 02:17:59 +01001424{
David Sedlák1bccdfa2019-06-17 15:55:27 +02001425/**
1426 * @brief Move the DATA pointer by COUNT items. Also updates the indent value in yang parser context
1427 * @param[in] CTX yang parser context to update its indent value.
1428 * @param[in,out] DATA pointer to move
1429 * @param[in] COUNT number of items for which the DATA pointer is supposed to move on.
1430 */
1431#define MOVE_IN(CTX, DATA, COUNT) (*(DATA))+=COUNT;if(CTX){(CTX)->indent+=COUNT;}
1432#define IF_KW(STR, LEN, STMT) if (!strncmp(*(data), STR, LEN)) {MOVE_IN(ctx, data, LEN);*kw=STMT;}
1433#define IF_KW_PREFIX(STR, LEN) if (!strncmp(*(data), STR, LEN)) {MOVE_IN(ctx, data, LEN);
1434#define IF_KW_PREFIX_END }
David Sedlák572e7ab2019-06-04 16:01:58 +02001435
Radek Krejcid6b76452019-09-03 17:03:03 +02001436 enum ly_stmt result = LY_STMT_NONE;
1437 enum ly_stmt *kw = &result;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001438 /* read the keyword itself */
1439 switch (**data) {
David Sedlák23a59a62018-10-26 13:08:02 +02001440 case 'a':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001441 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001442 IF_KW("rgument", 7, LY_STMT_ARGUMENT)
1443 else IF_KW("ugment", 6, LY_STMT_AUGMENT)
1444 else IF_KW("ction", 5, LY_STMT_ACTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001445 else IF_KW_PREFIX("ny", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001446 IF_KW("data", 4, LY_STMT_ANYDATA)
1447 else IF_KW("xml", 3, LY_STMT_ANYXML)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001448 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001449 break;
1450 case 'b':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001451 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001452 IF_KW("ase", 3, LY_STMT_BASE)
1453 else IF_KW("elongs-to", 9, LY_STMT_BELONGS_TO)
1454 else IF_KW("it", 2, LY_STMT_BIT)
David Sedlák23a59a62018-10-26 13:08:02 +02001455 break;
1456 case 'c':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001457 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001458 IF_KW("ase", 3, LY_STMT_CASE)
1459 else IF_KW("hoice", 5, LY_STMT_CHOICE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001460 else IF_KW_PREFIX("on", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001461 IF_KW("fig", 3, LY_STMT_CONFIG)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001462 else IF_KW_PREFIX("ta", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001463 IF_KW("ct", 2, LY_STMT_CONTACT)
1464 else IF_KW("iner", 4, LY_STMT_CONTAINER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001465 IF_KW_PREFIX_END
1466 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001467 break;
1468 case 'd':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001469 MOVE_IN(ctx, data, 1);
1470 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001471 IF_KW("fault", 5, LY_STMT_DEFAULT)
1472 else IF_KW("scription", 9, LY_STMT_DESCRIPTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001473 else IF_KW_PREFIX("viat", 4)
Radek Krejcid6b76452019-09-03 17:03:03 +02001474 IF_KW("e", 1, LY_STMT_DEVIATE)
1475 else IF_KW("ion", 3, LY_STMT_DEVIATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001476 IF_KW_PREFIX_END
1477 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001478 break;
1479 case 'e':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001480 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001481 IF_KW("num", 3, LY_STMT_ENUM)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001482 else IF_KW_PREFIX("rror-", 5)
Radek Krejcid6b76452019-09-03 17:03:03 +02001483 IF_KW("app-tag", 7, LY_STMT_ERROR_APP_TAG)
1484 else IF_KW("message", 7, LY_STMT_ERROR_MESSAGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001485 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001486 else IF_KW("xtension", 8, LY_STMT_EXTENSION)
David Sedlák23a59a62018-10-26 13:08:02 +02001487 break;
1488 case 'f':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001489 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001490 IF_KW("eature", 6, LY_STMT_FEATURE)
1491 else IF_KW("raction-digits", 14, LY_STMT_FRACTION_DIGITS)
David Sedlák23a59a62018-10-26 13:08:02 +02001492 break;
1493 case 'g':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001494 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001495 IF_KW("rouping", 7, LY_STMT_GROUPING)
David Sedlák23a59a62018-10-26 13:08:02 +02001496 break;
1497 case 'i':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001498 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001499 IF_KW("dentity", 7, LY_STMT_IDENTITY)
1500 else IF_KW("f-feature", 9, LY_STMT_IF_FEATURE)
1501 else IF_KW("mport", 5, LY_STMT_IMPORT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001502 else IF_KW_PREFIX("n", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001503 IF_KW("clude", 5, LY_STMT_INCLUDE)
1504 else IF_KW("put", 3, LY_STMT_INPUT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001505 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001506 break;
1507 case 'k':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001508 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001509 IF_KW("ey", 2, LY_STMT_KEY)
David Sedlák23a59a62018-10-26 13:08:02 +02001510 break;
1511 case 'l':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001512 MOVE_IN(ctx, data, 1);
1513 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001514 IF_KW("af-list", 7, LY_STMT_LEAF_LIST)
1515 else IF_KW("af", 2, LY_STMT_LEAF)
1516 else IF_KW("ngth", 4, LY_STMT_LENGTH)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001517 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001518 else IF_KW("ist", 3, LY_STMT_LIST)
David Sedlák23a59a62018-10-26 13:08:02 +02001519 break;
1520 case 'm':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001521 MOVE_IN(ctx, data, 1);
1522 IF_KW_PREFIX("a", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001523 IF_KW("ndatory", 7, LY_STMT_MANDATORY)
1524 else IF_KW("x-elements", 10, LY_STMT_MAX_ELEMENTS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001525 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001526 else IF_KW("in-elements", 11, LY_STMT_MIN_ELEMENTS)
1527 else IF_KW("ust", 3, LY_STMT_MUST)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001528 else IF_KW_PREFIX("od", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001529 IF_KW("ule", 3, LY_STMT_MODULE)
1530 else IF_KW("ifier", 5, LY_STMT_MODIFIER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001531 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001532 break;
1533 case 'n':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001534 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001535 IF_KW("amespace", 8, LY_STMT_NAMESPACE)
1536 else IF_KW("otification", 11, LY_STMT_NOTIFICATION)
David Sedlák23a59a62018-10-26 13:08:02 +02001537 break;
1538 case 'o':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001539 MOVE_IN(ctx, data, 1);
1540 IF_KW_PREFIX("r", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001541 IF_KW("dered-by", 8, LY_STMT_ORDERED_BY)
1542 else IF_KW("ganization", 10, LY_STMT_ORGANIZATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001543 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001544 else IF_KW("utput", 5, LY_STMT_OUTPUT)
David Sedlák23a59a62018-10-26 13:08:02 +02001545 break;
1546 case 'p':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001547 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001548 IF_KW("ath", 3, LY_STMT_PATH)
1549 else IF_KW("attern", 6, LY_STMT_PATTERN)
1550 else IF_KW("osition", 7, LY_STMT_POSITION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001551 else IF_KW_PREFIX("re", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001552 IF_KW("fix", 3, LY_STMT_PREFIX)
1553 else IF_KW("sence", 5, LY_STMT_PRESENCE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001554 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001555 break;
1556 case 'r':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001557 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001558 IF_KW("ange", 4, LY_STMT_RANGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001559 else IF_KW_PREFIX("e", 1)
1560 IF_KW_PREFIX("f", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001561 IF_KW("erence", 6, LY_STMT_REFERENCE)
1562 else IF_KW("ine", 3, LY_STMT_REFINE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001563 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001564 else IF_KW("quire-instance", 14, LY_STMT_REQUIRE_INSTANCE)
1565 else IF_KW("vision-date", 11, LY_STMT_REVISION_DATE)
1566 else IF_KW("vision", 6, LY_STMT_REVISION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001567 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001568 else IF_KW("pc", 2, LY_STMT_RPC)
David Sedlák23a59a62018-10-26 13:08:02 +02001569 break;
1570 case 's':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001571 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001572 IF_KW("tatus", 5, LY_STMT_STATUS)
1573 else IF_KW("ubmodule", 8, LY_STMT_SUBMODULE)
David Sedlák23a59a62018-10-26 13:08:02 +02001574 break;
1575 case 't':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001576 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001577 IF_KW("ypedef", 6, LY_STMT_TYPEDEF)
1578 else IF_KW("ype", 3, LY_STMT_TYPE)
David Sedlák23a59a62018-10-26 13:08:02 +02001579 break;
1580 case 'u':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001581 MOVE_IN(ctx, data, 1);
1582 IF_KW_PREFIX("ni", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001583 IF_KW("que", 3, LY_STMT_UNIQUE)
1584 else IF_KW("ts", 2, LY_STMT_UNITS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001585 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001586 else IF_KW("ses", 3, LY_STMT_USES)
David Sedlák23a59a62018-10-26 13:08:02 +02001587 break;
1588 case 'v':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001589 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001590 IF_KW("alue", 4, LY_STMT_VALUE)
David Sedlák23a59a62018-10-26 13:08:02 +02001591 break;
1592 case 'w':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001593 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001594 IF_KW("hen", 3, LY_STMT_WHEN)
David Sedlák23a59a62018-10-26 13:08:02 +02001595 break;
1596 case 'y':
David Sedlák1bccdfa2019-06-17 15:55:27 +02001597 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001598 IF_KW("ang-version", 11, LY_STMT_YANG_VERSION)
1599 else IF_KW("in-element", 10, LY_STMT_YIN_ELEMENT)
David Sedlák23a59a62018-10-26 13:08:02 +02001600 break;
David Sedlák23a59a62018-10-26 13:08:02 +02001601 default:
David Sedlák1bccdfa2019-06-17 15:55:27 +02001602 /* if context is not NULL we are matching keyword from YANG data*/
1603 if (ctx) {
1604 if (**data == ';') {
1605 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001606 *kw = LY_STMT_SYNTAX_SEMICOLON;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001607 } else if (**data == '{') {
1608 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001609 *kw = LY_STMT_SYNTAX_LEFT_BRACE;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001610 } else if (**data == '}') {
1611 MOVE_IN(ctx, data, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001612 *kw = LY_STMT_SYNTAX_RIGHT_BRACE;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001613 }
1614 }
David Sedlák23a59a62018-10-26 13:08:02 +02001615 break;
1616 }
1617
David Sedlák1bccdfa2019-06-17 15:55:27 +02001618#undef IF_KW
1619#undef IF_KW_PREFIX
1620#undef IF_KW_PREFIX_END
David Sedlák18730132019-03-15 15:51:34 +01001621#undef MOVE_IN
David Sedlák18730132019-03-15 15:51:34 +01001622
David Sedlák1bccdfa2019-06-17 15:55:27 +02001623 return result;
David Sedlák23a59a62018-10-26 13:08:02 +02001624}
David Sedlákecf5eb82019-06-03 14:12:44 +02001625
Radek Krejcid3ca0632019-04-16 16:54:54 +02001626unsigned int
1627lysp_ext_instance_iter(struct lysp_ext_instance *ext, unsigned int index, LYEXT_SUBSTMT substmt)
1628{
1629 LY_CHECK_ARG_RET(NULL, ext, LY_EINVAL);
1630
1631 for (; index < LY_ARRAY_SIZE(ext); index++) {
1632 if (ext[index].insubstmt == substmt) {
1633 return index;
1634 }
1635 }
1636
1637 return LY_ARRAY_SIZE(ext);
1638}
1639
Radek Krejcia1911222019-07-22 17:24:50 +02001640/**
1641 * @brief Schema mapping of YANG modules to prefixes in values.
1642 *
1643 * Implementation of ly_clb_get_prefix. Inverse function to lys_resolve_prefix.
1644 *
1645 * In this case the @p mod is searched in the list of imports and the import's prefix
1646 * (not the module's itself) prefix is returned.
1647 */
1648const char *
1649lys_get_prefix(const struct lys_module *mod, void *private)
1650{
1651 struct lys_module *context_mod = (struct lys_module*)private;
1652 unsigned int u;
Radek Krejcid3ca0632019-04-16 16:54:54 +02001653
Radek Krejci474f9b82019-07-24 11:36:37 +02001654 if (context_mod == mod) {
1655 return context_mod->prefix;
1656 }
Radek Krejcia1911222019-07-22 17:24:50 +02001657 LY_ARRAY_FOR(context_mod->compiled->imports, u) {
1658 if (context_mod->compiled->imports[u].module == mod) {
1659 /* match */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02001660 return context_mod->compiled->imports[u].prefix;
Radek Krejcia1911222019-07-22 17:24:50 +02001661 }
1662 }
1663
1664 return NULL;
1665}
1666
1667/**
1668 * @brief Schema mapping of prefix in values to YANG modules (imports).
1669 *
1670 * Implementation of ly_clb_resolve_prefix. Inverse function to lys_get_prefix().
1671 *
1672 * In this case the @p prefix is searched in the list of imports' prefixes (not the prefixes of the imported modules themselves).
1673 */
1674const struct lys_module *
Michal Vasko52927e22020-03-16 17:26:14 +01001675lys_resolve_prefix(const struct ly_ctx *UNUSED(ctx), const char *prefix, size_t prefix_len, void *private)
Radek Krejcia1911222019-07-22 17:24:50 +02001676{
1677 return lys_module_find_prefix((const struct lys_module*)private, prefix, prefix_len);
1678}