blob: 5a4b9fa34a0c03ae5d41f4fb9c32afca986d13ba [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 Krejci535ea9f2020-05-29 16:01:05 +020014
15#define _GNU_SOURCE
Radek Krejci86d106e2018-10-18 09:53:19 +020016
Radek Krejcie7b95092019-05-15 11:03:07 +020017#include <assert.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020018#include <ctype.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <stdint.h>
Radek Krejci9ed7a192018-10-31 16:23:51 +010020#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020021#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020022#include <time.h>
23
Michal Vaskoc5a22832020-08-20 13:21:33 +020024#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include "hash_table.h"
28#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020029#include "parser.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020030#include "parser_schema.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020031#include "parser_internal.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
Michal Vaskocb18c7f2020-08-24 09:22:28 +020038lysc_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *context_node,
Radek Krejci857189e2020-09-01 13:26:36 +020039 const struct lys_module *context_module, uint16_t nodetype, ly_bool implement,
Radek Krejci0f969882020-08-21 16:56:47 +020040 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 Krejci1deb5be2020-08-26 16:43:36 +020047 uint32_t getnext_extra_flag = 0;
48 uint16_t 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 Vasko22df3f02020-08-24 13:29:22 +020095 ret = lys_set_implemented_internal((struct lys_module *)mod, ctx->ctx->module_set_id);
Michal Vasko294b76d2019-12-16 10:37:54 +010096 LY_CHECK_RET(ret);
Radek Krejci9bb94eb2018-12-04 16:48:35 +010097 }
Michal Vasko1bf09392020-03-27 12:38:10 +010098 if (context_node && (context_node->nodetype & (LYS_RPC | LYS_ACTION))) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +010099 /* 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,
Radek Krejci0f969882020-08-21 16:56:47 +0200174 uint16_t flags1, void *mod1, const char *name1,
175 uint16_t flags2, void *mod2, const char *name2)
Radek Krejci4f28eda2018-11-12 11:46:16 +0100176{
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 Krejci1deb5be2020-08-26 16:43:36 +0200196lysp_check_date(struct lys_parser_ctx *ctx, const char *date, uint8_t date_len, const char *stmt)
Radek Krejci86d106e2018-10-18 09:53:19 +0200197{
Radek Krejci86d106e2018-10-18 09:53:19 +0200198 struct tm tm, tm_;
199 char *r;
200
Michal Vaskob36053d2020-03-26 15:49:30 +0100201 LY_CHECK_ARG_RET(ctx ? PARSER_CTX(ctx) : NULL, date, LY_EINVAL);
202 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 +0200203
204 /* check format */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200205 for (uint8_t i = 0; i < date_len; i++) {
Radek Krejci86d106e2018-10-18 09:53:19 +0200206 if (i == 4 || i == 7) {
207 if (date[i] != '-') {
208 goto error;
209 }
210 } else if (!isdigit(date[i])) {
211 goto error;
212 }
213 }
214
215 /* check content, e.g. 2018-02-31 */
216 memset(&tm, 0, sizeof tm);
217 r = strptime(date, "%Y-%m-%d", &tm);
218 if (!r || r != &date[LY_REV_SIZE - 1]) {
219 goto error;
220 }
221 memcpy(&tm_, &tm, sizeof tm);
222 mktime(&tm_); /* mktime modifies tm_ if it refers invalid date */
223 if (tm.tm_mday != tm_.tm_mday) { /* e.g 2018-02-29 -> 2018-03-01 */
224 /* checking days is enough, since other errors
225 * have been checked by strptime() */
226 goto error;
227 }
228
229 return LY_SUCCESS;
230
231error:
Radek Krejcid33273d2018-10-25 14:55:52 +0200232 if (stmt) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100233 if (ctx) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100234 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, date_len, date, stmt);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100235 } else {
236 LOGVAL(NULL, LY_VLOG_NONE, NULL, LY_VCODE_INVAL, date_len, date, stmt);
237 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200238 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200239 return LY_EINVAL;
240}
241
242void
243lysp_sort_revisions(struct lysp_revision *revs)
244{
Radek Krejci857189e2020-09-01 13:26:36 +0200245 LY_ARRAY_COUNT_TYPE i, r;
Radek Krejci86d106e2018-10-18 09:53:19 +0200246 struct lysp_revision rev;
247
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200248 for (i = 1, r = 0; revs && i < LY_ARRAY_COUNT(revs); i++) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200249 if (strcmp(revs[i].date, revs[r].date) > 0) {
Radek Krejci86d106e2018-10-18 09:53:19 +0200250 r = i;
251 }
252 }
253
254 if (r) {
255 /* the newest revision is not on position 0, switch them */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200256 memcpy(&rev, &revs[0], sizeof rev);
257 memcpy(&revs[0], &revs[r], sizeof rev);
258 memcpy(&revs[r], &rev, sizeof rev);
Radek Krejci86d106e2018-10-18 09:53:19 +0200259 }
260}
Radek Krejci151a5b72018-10-19 14:21:44 +0200261
Radek Krejcibbe09a92018-11-08 09:36:54 +0100262static const struct lysp_tpdf *
263lysp_type_match(const char *name, struct lysp_node *node)
264{
Radek Krejci0fb28562018-12-13 15:17:37 +0100265 const struct lysp_tpdf *typedefs;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200266 LY_ARRAY_COUNT_TYPE u;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100267
Radek Krejci0fb28562018-12-13 15:17:37 +0100268 typedefs = lysp_node_typedefs(node);
269 LY_ARRAY_FOR(typedefs, u) {
270 if (!strcmp(name, typedefs[u].name)) {
271 /* match */
272 return &typedefs[u];
Radek Krejcibbe09a92018-11-08 09:36:54 +0100273 }
274 }
275
276 return NULL;
277}
278
Radek Krejci4f28eda2018-11-12 11:46:16 +0100279static LY_DATA_TYPE
280lysp_type_str2builtin(const char *name, size_t len)
281{
282 if (len >= 4) { /* otherwise it does not match any built-in type */
283 if (name[0] == 'b') {
284 if (name[1] == 'i') {
285 if (len == 6 && !strncmp(&name[2], "nary", 4)) {
286 return LY_TYPE_BINARY;
287 } else if (len == 4 && !strncmp(&name[2], "ts", 2)) {
288 return LY_TYPE_BITS;
289 }
290 } else if (len == 7 && !strncmp(&name[1], "oolean", 6)) {
291 return LY_TYPE_BOOL;
292 }
293 } else if (name[0] == 'd') {
294 if (len == 9 && !strncmp(&name[1], "ecimal64", 8)) {
295 return LY_TYPE_DEC64;
296 }
297 } else if (name[0] == 'e') {
298 if (len == 5 && !strncmp(&name[1], "mpty", 4)) {
299 return LY_TYPE_EMPTY;
300 } else if (len == 11 && !strncmp(&name[1], "numeration", 10)) {
301 return LY_TYPE_ENUM;
302 }
303 } else if (name[0] == 'i') {
304 if (name[1] == 'n') {
305 if (len == 4 && !strncmp(&name[2], "t8", 2)) {
306 return LY_TYPE_INT8;
307 } else if (len == 5) {
308 if (!strncmp(&name[2], "t16", 3)) {
309 return LY_TYPE_INT16;
310 } else if (!strncmp(&name[2], "t32", 3)) {
311 return LY_TYPE_INT32;
312 } else if (!strncmp(&name[2], "t64", 3)) {
313 return LY_TYPE_INT64;
314 }
315 } else if (len == 19 && !strncmp(&name[2], "stance-identifier", 17)) {
316 return LY_TYPE_INST;
317 }
318 } else if (len == 11 && !strncmp(&name[1], "dentityref", 10)) {
319 return LY_TYPE_IDENT;
320 }
321 } else if (name[0] == 'l') {
322 if (len == 7 && !strncmp(&name[1], "eafref", 6)) {
323 return LY_TYPE_LEAFREF;
324 }
325 } else if (name[0] == 's') {
326 if (len == 6 && !strncmp(&name[1], "tring", 5)) {
327 return LY_TYPE_STRING;
328 }
329 } else if (name[0] == 'u') {
330 if (name[1] == 'n') {
331 if (len == 5 && !strncmp(&name[2], "ion", 3)) {
332 return LY_TYPE_UNION;
333 }
334 } else if (name[1] == 'i' && name[2] == 'n' && name[3] == 't') {
335 if (len == 5 && name[4] == '8') {
336 return LY_TYPE_UINT8;
337 } else if (len == 6) {
338 if (!strncmp(&name[4], "16", 2)) {
339 return LY_TYPE_UINT16;
340 } else if (!strncmp(&name[4], "32", 2)) {
341 return LY_TYPE_UINT32;
342 } else if (!strncmp(&name[4], "64", 2)) {
343 return LY_TYPE_UINT64;
344 }
345 }
346 }
347 }
348 }
349
350 return LY_TYPE_UNKNOWN;
351}
352
Radek Krejcibbe09a92018-11-08 09:36:54 +0100353LY_ERR
354lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module,
Radek Krejci0f969882020-08-21 16:56:47 +0200355 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100356{
357 const char *str, *name;
358 struct lysp_tpdf *typedefs;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200359 struct lys_module *mod;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200360 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100361
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) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200371 mod = lys_module_find_prefix(start_module->mod, id, str - id);
372 *module = mod ? mod->parsed : NULL;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100373 name = str + 1;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100374 *type = LY_TYPE_UNKNOWN;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100375 } else {
376 *module = start_module;
377 name = id;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100378
379 /* check for built-in types */
380 *type = lysp_type_str2builtin(name, strlen(name));
381 if (*type) {
382 *tpdf = NULL;
383 return LY_SUCCESS;
384 }
Radek Krejcibbe09a92018-11-08 09:36:54 +0100385 }
386 LY_CHECK_RET(!(*module), LY_ENOTFOUND);
387
388 if (start_node && *module == start_module) {
389 /* search typedefs in parent's nodes */
390 *node = start_node;
391 while (*node) {
392 *tpdf = lysp_type_match(name, *node);
393 if (*tpdf) {
394 /* match */
395 return LY_SUCCESS;
396 }
397 *node = (*node)->parent;
398 }
399 }
400
401 /* search in top-level typedefs */
402 if ((*module)->typedefs) {
403 LY_ARRAY_FOR((*module)->typedefs, u) {
404 if (!strcmp(name, (*module)->typedefs[u].name)) {
405 /* match */
406 *tpdf = &(*module)->typedefs[u];
407 return LY_SUCCESS;
408 }
409 }
410 }
411
412 /* search in submodules' typedefs */
413 LY_ARRAY_FOR((*module)->includes, u) {
414 typedefs = (*module)->includes[u].submodule->typedefs;
Radek Krejci76b3e962018-12-14 17:01:25 +0100415 LY_ARRAY_FOR(typedefs, v) {
416 if (!strcmp(name, typedefs[v].name)) {
417 /* match */
418 *tpdf = &typedefs[v];
419 return LY_SUCCESS;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100420 }
421 }
422 }
423
424 return LY_ENOTFOUND;
425}
426
David Sedlák6544c182019-07-12 13:17:33 +0200427LY_ERR
David Sedlák07869a52019-07-12 14:28:19 +0200428lysp_check_enum_name(struct lys_parser_ctx *ctx, const char *name, size_t name_len)
David Sedlák6544c182019-07-12 13:17:33 +0200429{
430 if (!name_len) {
431 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not be zero-length.");
432 return LY_EVALID;
433 } else if (isspace(name[0]) || isspace(name[name_len - 1])) {
434 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not have any leading or trailing whitespaces (\"%.*s\").",
435 name_len, name);
436 return LY_EVALID;
437 } else {
438 for (size_t u = 0; u < name_len; ++u) {
439 if (iscntrl(name[u])) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100440 LOGWRN(PARSER_CTX(ctx), "Control characters in enum name should be avoided (\"%.*s\", character number %d).",
David Sedlák6544c182019-07-12 13:17:33 +0200441 name_len, name, u + 1);
442 break;
443 }
444 }
445 }
446
447 return LY_SUCCESS;
448}
449
Michal Vaskob36053d2020-03-26 15:49:30 +0100450/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100451 * @brief Check name of a new type to avoid name collisions.
452 *
453 * @param[in] ctx Parser context, module where the type is being defined is taken from here.
454 * @param[in] node Schema node where the type is being defined, NULL in case of a top-level typedef.
455 * @param[in] tpdf Typedef definition to check.
456 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
457 * typedefs are checked, caller is supposed to free the table.
458 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
459 * typedefs are checked, caller is supposed to free the table.
460 * @return LY_EEXIST in case of collision, LY_SUCCESS otherwise.
461 */
462static LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200463lysp_check_typedef(struct lys_parser_ctx *ctx, struct lysp_node *node, const struct lysp_tpdf *tpdf,
Radek Krejci0f969882020-08-21 16:56:47 +0200464 struct hash_table *tpdfs_global, struct hash_table *tpdfs_scoped)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100465{
466 struct lysp_node *parent;
467 uint32_t hash;
468 size_t name_len;
469 const char *name;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200470 LY_ARRAY_COUNT_TYPE u;
Radek Krejci0fb28562018-12-13 15:17:37 +0100471 const struct lysp_tpdf *typedefs;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100472
473 assert(ctx);
474 assert(tpdf);
475
476 name = tpdf->name;
477 name_len = strlen(name);
478
Radek Krejci4f28eda2018-11-12 11:46:16 +0100479 if (lysp_type_str2builtin(name, name_len)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100480 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 +0100481 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100482 }
483
484 /* check locally scoped typedefs (avoid name shadowing) */
485 if (node) {
Radek Krejci0fb28562018-12-13 15:17:37 +0100486 typedefs = lysp_node_typedefs(node);
487 LY_ARRAY_FOR(typedefs, u) {
488 if (&typedefs[u] == tpdf) {
489 break;
490 }
491 if (!strcmp(name, typedefs[u].name)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100492 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with sibling type.", name);
Radek Krejci0fb28562018-12-13 15:17:37 +0100493 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100494 }
495 }
496 /* search typedefs in parent's nodes */
Radek Krejci87e78ca2019-05-02 09:51:29 +0200497 for (parent = node->parent; parent; parent = parent->parent) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100498 if (lysp_type_match(name, parent)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100499 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 +0100500 return LY_EEXIST;
501 }
502 }
503 }
504
505 /* check collision with the top-level typedefs */
506 hash = dict_hash(name, name_len);
507 if (node) {
508 lyht_insert(tpdfs_scoped, &name, hash, NULL);
509 if (!lyht_find(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100510 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 +0100511 return LY_EEXIST;
512 }
513 } else {
514 if (lyht_insert(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100515 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 +0100516 return LY_EEXIST;
517 }
Radek Krejci3b1f9292018-11-08 10:58:35 +0100518 /* it is not necessary to test collision with the scoped types - in lysp_check_typedefs, all the
519 * top-level typedefs are inserted into the tables before the scoped typedefs, so the collision
520 * is detected in the first branch few lines above */
Radek Krejcibbe09a92018-11-08 09:36:54 +0100521 }
522
523 return LY_SUCCESS;
524}
525
Radek Krejci857189e2020-09-01 13:26:36 +0200526/**
527 * @brief Compare identifiers.
528 * Implementation of ::values_equal_cb.
529 */
530static ly_bool
531lysp_id_cmp(void *val1, void *val2, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Radek Krejcibbe09a92018-11-08 09:36:54 +0100532{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200533 return strcmp(val1, val2) == 0 ? 1 : 0;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100534}
535
536LY_ERR
David Sedlákd2ebe572019-07-22 12:53:14 +0200537lysp_parse_finalize_reallocated(struct lys_parser_ctx *ctx, struct lysp_grp *groupings, struct lysp_augment *augments,
Radek Krejci0f969882020-08-21 16:56:47 +0200538 struct lysp_action *actions, struct lysp_notif *notifs)
David Sedlákd2ebe572019-07-22 12:53:14 +0200539{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200540 LY_ARRAY_COUNT_TYPE u, v;
David Sedlákd2ebe572019-07-22 12:53:14 +0200541 struct lysp_node *child;
542
543 /* finalize parent pointers to the reallocated items */
544
545 /* gropings */
546 LY_ARRAY_FOR(groupings, u) {
547 LY_LIST_FOR(groupings[u].data, child) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200548 child->parent = (struct lysp_node *)&groupings[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200549 }
550 LY_ARRAY_FOR(groupings[u].actions, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200551 groupings[u].actions[v].parent = (struct lysp_node *)&groupings[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200552 }
553 LY_ARRAY_FOR(groupings[u].notifs, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200554 groupings[u].notifs[v].parent = (struct lysp_node *)&groupings[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200555 }
556 LY_ARRAY_FOR(groupings[u].groupings, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200557 groupings[u].groupings[v].parent = (struct lysp_node *)&groupings[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200558 }
559 if (groupings[u].typedefs) {
Radek Krejciba03a5a2020-08-27 14:40:41 +0200560 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, &groupings[u], 0, NULL));
David Sedlákd2ebe572019-07-22 12:53:14 +0200561 }
562 }
563
564 /* augments */
565 LY_ARRAY_FOR(augments, u) {
566 LY_LIST_FOR(augments[u].child, child) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200567 child->parent = (struct lysp_node *)&augments[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200568 }
569 LY_ARRAY_FOR(augments[u].actions, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200570 augments[u].actions[v].parent = (struct lysp_node *)&augments[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200571 }
572 LY_ARRAY_FOR(augments[u].notifs, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200573 augments[u].notifs[v].parent = (struct lysp_node *)&augments[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200574 }
575 }
576
577 /* actions */
578 LY_ARRAY_FOR(actions, u) {
579 if (actions[u].input.parent) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200580 actions[u].input.parent = (struct lysp_node *)&actions[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200581 LY_LIST_FOR(actions[u].input.data, child) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200582 child->parent = (struct lysp_node *)&actions[u].input;
David Sedlákd2ebe572019-07-22 12:53:14 +0200583 }
584 LY_ARRAY_FOR(actions[u].input.groupings, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200585 actions[u].input.groupings[v].parent = (struct lysp_node *)&actions[u].input;
David Sedlákd2ebe572019-07-22 12:53:14 +0200586 }
587 if (actions[u].input.typedefs) {
Radek Krejciba03a5a2020-08-27 14:40:41 +0200588 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, &actions[u].input, 0, NULL));
David Sedlákd2ebe572019-07-22 12:53:14 +0200589 }
590 }
591 if (actions[u].output.parent) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200592 actions[u].output.parent = (struct lysp_node *)&actions[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200593 LY_LIST_FOR(actions[u].output.data, child) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200594 child->parent = (struct lysp_node *)&actions[u].output;
David Sedlákd2ebe572019-07-22 12:53:14 +0200595 }
596 LY_ARRAY_FOR(actions[u].output.groupings, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200597 actions[u].output.groupings[v].parent = (struct lysp_node *)&actions[u].output;
David Sedlákd2ebe572019-07-22 12:53:14 +0200598 }
599 if (actions[u].output.typedefs) {
Radek Krejciba03a5a2020-08-27 14:40:41 +0200600 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, &actions[u].output, 0, NULL));
David Sedlákd2ebe572019-07-22 12:53:14 +0200601 }
602 }
603 LY_ARRAY_FOR(actions[u].groupings, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200604 actions[u].groupings[v].parent = (struct lysp_node *)&actions[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200605 }
606 if (actions[u].typedefs) {
Radek Krejciba03a5a2020-08-27 14:40:41 +0200607 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, &actions[u], 0, NULL));
David Sedlákd2ebe572019-07-22 12:53:14 +0200608 }
609 }
610
611 /* notifications */
612 LY_ARRAY_FOR(notifs, u) {
613 LY_LIST_FOR(notifs[u].data, child) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200614 child->parent = (struct lysp_node *)&notifs[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200615 }
616 LY_ARRAY_FOR(notifs[u].groupings, v) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200617 notifs[u].groupings[v].parent = (struct lysp_node *)&notifs[u];
David Sedlákd2ebe572019-07-22 12:53:14 +0200618 }
619 if (notifs[u].typedefs) {
Radek Krejciba03a5a2020-08-27 14:40:41 +0200620 LY_CHECK_RET(ly_set_add(&ctx->tpdfs_nodes, &notifs[u], 0, NULL));
David Sedlákd2ebe572019-07-22 12:53:14 +0200621 }
622 }
623
624 return LY_SUCCESS;
625}
626
627LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +0200628lysp_check_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100629{
630 struct hash_table *ids_global;
631 struct hash_table *ids_scoped;
Radek Krejci0fb28562018-12-13 15:17:37 +0100632 const struct lysp_tpdf *typedefs;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200633 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200634 uint32_t i;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100635 LY_ERR ret = LY_EVALID;
636
637 /* check name collisions - typedefs and groupings */
Michal Vasko22df3f02020-08-24 13:29:22 +0200638 ids_global = lyht_new(8, sizeof(char *), lysp_id_cmp, NULL, 1);
639 ids_scoped = lyht_new(8, sizeof(char *), lysp_id_cmp, NULL, 1);
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200640 LY_ARRAY_FOR(mod->typedefs, v) {
641 if (lysp_check_typedef(ctx, NULL, &mod->typedefs[v], ids_global, ids_scoped)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100642 goto cleanup;
643 }
644 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200645 LY_ARRAY_FOR(mod->includes, v) {
646 LY_ARRAY_FOR(mod->includes[v].submodule->typedefs, u) {
647 if (lysp_check_typedef(ctx, NULL, &mod->includes[v].submodule->typedefs[u], ids_global, ids_scoped)) {
Radek Krejci3b1f9292018-11-08 10:58:35 +0100648 goto cleanup;
649 }
650 }
651 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200652 for (i = 0; i < ctx->tpdfs_nodes.count; ++i) {
653 typedefs = lysp_node_typedefs((struct lysp_node *)ctx->tpdfs_nodes.objs[i]);
654 LY_ARRAY_FOR(typedefs, u) {
655 if (lysp_check_typedef(ctx, (struct lysp_node *)ctx->tpdfs_nodes.objs[i], &typedefs[u], ids_global, ids_scoped)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100656 goto cleanup;
657 }
658 }
659 }
660 ret = LY_SUCCESS;
661cleanup:
662 lyht_free(ids_global);
663 lyht_free(ids_scoped);
664 ly_set_erase(&ctx->tpdfs_nodes, NULL);
665
666 return ret;
667}
668
Radek Krejci9ed7a192018-10-31 16:23:51 +0100669struct lysp_load_module_check_data {
670 const char *name;
671 const char *revision;
672 const char *path;
Michal Vasko22df3f02020-08-24 13:29:22 +0200673 const char *submoduleof;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100674};
675
676static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100677lysp_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 +0100678{
679 struct lysp_load_module_check_data *info = data;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100680 const char *filename, *dot, *rev, *name;
Radek Krejcib3289d62019-09-18 12:21:39 +0200681 uint8_t latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100682 size_t len;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100683 struct lysp_revision *revs;
684
685 name = mod ? mod->mod->name : submod->name;
686 revs = mod ? mod->revs : submod->revs;
Radek Krejcib3289d62019-09-18 12:21:39 +0200687 latest_revision = mod ? mod->mod->latest_revision : submod->latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100688
689 if (info->name) {
690 /* check name of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100691 if (strcmp(info->name, name)) {
692 LOGERR(ctx, LY_EINVAL, "Unexpected module \"%s\" parsed instead of \"%s\").", name, info->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100693 return LY_EINVAL;
694 }
695 }
696 if (info->revision) {
697 /* check revision of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100698 if (!revs || strcmp(info->revision, revs[0].date)) {
699 LOGERR(ctx, LY_EINVAL, "Module \"%s\" parsed with the wrong revision (\"%s\" instead \"%s\").", name,
Radek Krejcib07b5c92019-04-08 10:56:37 +0200700 revs ? revs[0].date : "none", info->revision);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100701 return LY_EINVAL;
702 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200703 } else if (!latest_revision) {
704 /* do not log, we just need to drop the schema and use the latest revision from the context */
705 return LY_EEXIST;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100706 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100707 if (submod) {
708 assert(info->submoduleof);
709
Radek Krejci9ed7a192018-10-31 16:23:51 +0100710 /* check that the submodule belongs-to our module */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100711 if (strcmp(info->submoduleof, submod->belongsto)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100712 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 +0100713 submod->name, info->submoduleof, submod->belongsto);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100714 return LY_EVALID;
715 }
716 /* check circular dependency */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100717 if (submod->parsing) {
718 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (include) for module \"%s\".", submod->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100719 return LY_EVALID;
720 }
721 }
722 if (info->path) {
723 /* check that name and revision match filename */
724 filename = strrchr(info->path, '/');
725 if (!filename) {
726 filename = info->path;
727 } else {
728 filename++;
729 }
730 /* name */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100731 len = strlen(name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100732 rev = strchr(filename, '@');
733 dot = strrchr(info->path, '.');
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100734 if (strncmp(filename, name, len) ||
Radek Krejci9ed7a192018-10-31 16:23:51 +0100735 ((rev && rev != &filename[len]) || (!rev && dot != &filename[len]))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100736 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100737 }
738 /* revision */
739 if (rev) {
740 len = dot - ++rev;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100741 if (!revs || len != 10 || strncmp(revs[0].date, rev, len)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100742 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100743 revs ? revs[0].date : "none");
Radek Krejci9ed7a192018-10-31 16:23:51 +0100744 }
745 }
746 }
747 return LY_SUCCESS;
748}
749
750LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200751lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, ly_bool implement,
752 struct lys_parser_ctx *main_ctx, const char *main_name, ly_bool required, void **result)
Radek Krejci9ed7a192018-10-31 16:23:51 +0100753{
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200754 struct ly_in *in;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100755 char *filepath = NULL;
756 LYS_INFORMAT format;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100757 void *mod = NULL;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100758 LY_ERR ret = LY_SUCCESS;
759 struct lysp_load_module_check_data check_data = {0};
760
761 LY_CHECK_RET(lys_search_localfile(ly_ctx_get_searchdirs(ctx), !(ctx->flags & LY_CTX_DISABLE_SEARCHDIR_CWD), name, revision,
762 &filepath, &format));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200763 if (!filepath) {
764 if (required) {
765 LOGERR(ctx, LY_ENOTFOUND, "Data model \"%s%s%s\" not found in local searchdirs.", name, revision ? "@" : "",
766 revision ? revision : "");
767 }
768 return LY_ENOTFOUND;
769 }
Radek Krejci9ed7a192018-10-31 16:23:51 +0100770
771 LOGVRB("Loading schema from \"%s\" file.", filepath);
772
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200773 /* get the (sub)module */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200774 LY_CHECK_ERR_GOTO(ret = ly_in_new_filepath(filepath, 0, &in),
775 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", filepath), cleanup);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100776 check_data.name = name;
777 check_data.revision = revision;
778 check_data.path = filepath;
fredgancd485b82019-10-18 15:00:17 +0800779 check_data.submoduleof = main_name;
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200780 if (main_ctx) {
Michal Vasko7a0b0762020-09-02 16:37:01 +0200781 ret = lys_parse_submodule(ctx, in, format, main_ctx, lysp_load_module_check, &check_data,
Radek Krejci0f969882020-08-21 16:56:47 +0200782 (struct lysp_submodule **)&mod);
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200783 } else {
Michal Vasko7a0b0762020-09-02 16:37:01 +0200784 ret = lys_create_module(ctx, in, format, implement, lysp_load_module_check, &check_data,
Radek Krejci0f969882020-08-21 16:56:47 +0200785 (struct lys_module **)&mod);
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200786
787 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200788 ly_in_free(in, 1);
Michal Vasko7a0b0762020-09-02 16:37:01 +0200789 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100790
791 *result = mod;
792
793 /* success */
Michal Vasko7a0b0762020-09-02 16:37:01 +0200794
Radek Krejci9ed7a192018-10-31 16:23:51 +0100795cleanup:
796 free(filepath);
797 return ret;
798}
799
Radek Krejcid33273d2018-10-25 14:55:52 +0200800LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200801lysp_load_module(struct ly_ctx *ctx, const char *name, const char *revision, ly_bool implement, ly_bool require_parsed,
Radek Krejci0f969882020-08-21 16:56:47 +0200802 struct lys_module **mod)
Radek Krejci086c7132018-10-26 15:29:04 +0200803{
Radek Krejci9ed7a192018-10-31 16:23:51 +0100804 const char *module_data = NULL;
Radek Krejci086c7132018-10-26 15:29:04 +0200805 LYS_INFORMAT format = LYS_IN_UNKNOWN;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100806 void (*module_data_free)(void *module_data, void *user_data) = NULL;
807 struct lysp_load_module_check_data check_data = {0};
Radek Krejcib3289d62019-09-18 12:21:39 +0200808 struct lys_module *m = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +0200809 struct ly_in *in;
Radek Krejci086c7132018-10-26 15:29:04 +0200810
Radek Krejci0af46292019-01-11 16:02:31 +0100811 assert(mod);
812
Radek Krejcia53d7c92020-08-21 11:30:56 +0200813 if (ctx->flags & LY_CTX_ALLIMPLEMENTED) {
814 implement = 1;
815 }
816
Radek Krejci0af46292019-01-11 16:02:31 +0100817 if (!*mod) {
818 /* try to get the module from the context */
819 if (revision) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200820 /* get the specific revision */
Michal Vasko22df3f02020-08-24 13:29:22 +0200821 *mod = (struct lys_module *)ly_ctx_get_module(ctx, name, revision);
Radek Krejcied5acc52019-04-25 15:57:04 +0200822 } else if (implement) {
823 /* prefer the implemented module instead of the latest one */
Michal Vasko22df3f02020-08-24 13:29:22 +0200824 *mod = (struct lys_module *)ly_ctx_get_module_implemented(ctx, name);
Radek Krejcied5acc52019-04-25 15:57:04 +0200825 if (!*mod) {
826 /* there is no implemented module in the context, try to get the latest revision module */
827 goto latest_in_the_context;
828 }
Radek Krejci0af46292019-01-11 16:02:31 +0100829 } else {
Radek Krejcied5acc52019-04-25 15:57:04 +0200830 /* get the requested module of the latest revision in the context */
831latest_in_the_context:
Michal Vasko22df3f02020-08-24 13:29:22 +0200832 *mod = (struct lys_module *)ly_ctx_get_module_latest(ctx, name);
Radek Krejcib3289d62019-09-18 12:21:39 +0200833 if (*mod && (*mod)->latest_revision == 1) {
834 /* let us now search with callback and searchpaths to check if there is newer revision outside the context */
835 m = *mod;
836 *mod = NULL;
837 }
Radek Krejci0af46292019-01-11 16:02:31 +0100838 }
Radek Krejci086c7132018-10-26 15:29:04 +0200839 }
840
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100841 if (!(*mod) || (require_parsed && !(*mod)->parsed)) {
842 (*mod) = NULL;
843
Radek Krejci086c7132018-10-26 15:29:04 +0200844 /* check collision with other implemented revision */
845 if (implement && ly_ctx_get_module_implemented(ctx, name)) {
846 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
847 "Module \"%s\" is already present in other implemented revision.", name);
848 return LY_EDENIED;
849 }
850
Radek Krejci9ed7a192018-10-31 16:23:51 +0100851 /* module not present in the context, get the input data and parse it */
Radek Krejci086c7132018-10-26 15:29:04 +0200852 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
853search_clb:
854 if (ctx->imp_clb) {
855 if (ctx->imp_clb(name, revision, NULL, NULL, ctx->imp_clb_data,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100856 &format, &module_data, &module_data_free) == LY_SUCCESS) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200857 LY_CHECK_RET(ly_in_new_memory(module_data, &in));
Radek Krejci9ed7a192018-10-31 16:23:51 +0100858 check_data.name = name;
859 check_data.revision = revision;
Michal Vasko7a0b0762020-09-02 16:37:01 +0200860 lys_create_module(ctx, in, format, implement, lysp_load_module_check, &check_data, mod);
Michal Vasko63f3d842020-07-08 10:10:14 +0200861 ly_in_free(in, 0);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100862 if (module_data_free) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200863 module_data_free((void *)module_data, ctx->imp_clb_data);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100864 }
Radek Krejci086c7132018-10-26 15:29:04 +0200865 }
866 }
867 if (!(*mod) && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
868 goto search_file;
869 }
870 } else {
871search_file:
872 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
873 /* module was not received from the callback or there is no callback set */
Radek Krejci78f06822019-10-30 12:54:05 +0100874 lys_module_localfile(ctx, name, revision, implement, NULL, NULL, m ? 0 : 1, (void **)mod);
Radek Krejci086c7132018-10-26 15:29:04 +0200875 }
876 if (!(*mod) && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
877 goto search_clb;
878 }
879 }
Radek Krejci9ed7a192018-10-31 16:23:51 +0100880
Radek Krejcib3289d62019-09-18 12:21:39 +0200881 /* update the latest_revision flag - here we have selected the latest available schema,
882 * consider that even the callback provides correct latest revision */
883 if (!(*mod) && m) {
Radek Krejci78f06822019-10-30 12:54:05 +0100884 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 +0200885 m->latest_revision = 2;
886 *mod = m;
887 } else if ((*mod) && !revision && ((*mod)->latest_revision == 1)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100888 (*mod)->latest_revision = 2;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100889 }
Radek Krejci086c7132018-10-26 15:29:04 +0200890 } else {
891 /* we have module from the current context */
Radek Krejci0af46292019-01-11 16:02:31 +0100892 if (implement) {
893 m = ly_ctx_get_module_implemented(ctx, name);
894 if (m && m != *mod) {
895 /* check collision with other implemented revision */
896 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE,
897 "Module \"%s\" is already present in other implemented revision.", name);
898 *mod = NULL;
899 return LY_EDENIED;
900 }
Radek Krejci086c7132018-10-26 15:29:04 +0200901 }
902
903 /* circular check */
Radek Krejcif8f882a2018-10-31 14:51:15 +0100904 if ((*mod)->parsed && (*mod)->parsed->parsing) {
Radek Krejci086c7132018-10-26 15:29:04 +0200905 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (import) for module \"%s\".", name);
906 *mod = NULL;
907 return LY_EVALID;
908 }
909 }
910 if (!(*mod)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100911 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "%s \"%s\" module failed.", implement ? "Loading" : "Importing", name);
Radek Krejci086c7132018-10-26 15:29:04 +0200912 return LY_EVALID;
913 }
914
915 if (implement) {
916 /* mark the module implemented, check for collision was already done */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100917 (*mod)->implemented = 1;
Radek Krejci086c7132018-10-26 15:29:04 +0200918 }
Radek Krejci086c7132018-10-26 15:29:04 +0200919
920 return LY_SUCCESS;
921}
922
923LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200924lysp_check_stringchar(struct lys_parser_ctx *ctx, uint32_t c)
David Sedlák4a650532019-07-10 11:55:18 +0200925{
926 if (!is_yangutf8char(c)) {
927 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, c);
928 return LY_EVALID;
929 }
930 return LY_SUCCESS;
931}
932
933LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200934lysp_check_identifierchar(struct lys_parser_ctx *ctx, uint32_t c, ly_bool first, uint8_t *prefix)
David Sedlák4a650532019-07-10 11:55:18 +0200935{
936 if (first || (prefix && (*prefix) == 1)) {
937 if (!is_yangidentstartchar(c)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200938 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '%c' (0x%04x).", (char)c, c);
David Sedlák4a650532019-07-10 11:55:18 +0200939 return LY_EVALID;
940 }
941 if (prefix) {
942 if (first) {
943 (*prefix) = 0;
944 } else {
945 (*prefix) = 2;
946 }
947 }
948 } else if (c == ':' && prefix && (*prefix) == 0) {
949 (*prefix) = 1;
950 } else if (!is_yangidentchar(c)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200951 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier character '%c' (0x%04x).", (char)c, c);
David Sedlák4a650532019-07-10 11:55:18 +0200952 return LY_EVALID;
953 }
954
955 return LY_SUCCESS;
956}
957
958LY_ERR
Michal Vasko7c8439f2020-08-05 13:25:19 +0200959lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
Radek Krejcid33273d2018-10-25 14:55:52 +0200960{
Michal Vaskob36053d2020-03-26 15:49:30 +0100961 struct ly_ctx *ctx = (struct ly_ctx *)(PARSER_CTX(pctx));
Radek Krejci3eb299d2019-04-08 15:07:44 +0200962 struct lysp_submodule *submod = NULL;
Radek Krejcid33273d2018-10-25 14:55:52 +0200963 const char *submodule_data = NULL;
964 LYS_INFORMAT format = LYS_IN_UNKNOWN;
965 void (*submodule_data_free)(void *module_data, void *user_data) = NULL;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100966 struct lysp_load_module_check_data check_data = {0};
Michal Vasko63f3d842020-07-08 10:10:14 +0200967 struct ly_in *in;
Radek Krejcid33273d2018-10-25 14:55:52 +0200968
Radek Krejcibbe09a92018-11-08 09:36:54 +0100969 /* submodule not present in the context, get the input data and parse it */
Michal Vaskob36053d2020-03-26 15:49:30 +0100970 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcid33273d2018-10-25 14:55:52 +0200971search_clb:
Michal Vaskob36053d2020-03-26 15:49:30 +0100972 if (ctx->imp_clb) {
Michal Vasko7c8439f2020-08-05 13:25:19 +0200973 if (ctx->imp_clb(pctx->main_mod->name, NULL, inc->name, inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data,
Radek Krejcibbe09a92018-11-08 09:36:54 +0100974 &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200975 LY_CHECK_RET(ly_in_new_memory(submodule_data, &in));
Radek Krejcibbe09a92018-11-08 09:36:54 +0100976 check_data.name = inc->name;
977 check_data.revision = inc->rev[0] ? inc->rev : NULL;
Michal Vasko7c8439f2020-08-05 13:25:19 +0200978 check_data.submoduleof = pctx->main_mod->name;
Michal Vasko7a0b0762020-09-02 16:37:01 +0200979 lys_parse_submodule(ctx, in, format, pctx, lysp_load_module_check, &check_data, &submod);
Michal Vasko63f3d842020-07-08 10:10:14 +0200980 ly_in_free(in, 0);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100981 if (submodule_data_free) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200982 submodule_data_free((void *)submodule_data, ctx->imp_clb_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200983 }
984 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200985 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100986 if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100987 goto search_file;
Radek Krejcid33273d2018-10-25 14:55:52 +0200988 }
Radek Krejci2d31ea72018-10-25 15:46:42 +0200989 } else {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100990search_file:
Michal Vaskob36053d2020-03-26 15:49:30 +0100991 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100992 /* submodule was not received from the callback or there is no callback set */
Michal Vasko7c8439f2020-08-05 13:25:19 +0200993 lys_module_localfile(ctx, inc->name, inc->rev[0] ? inc->rev : NULL, 0, pctx, pctx->main_mod->name, 1,
Michal Vasko22df3f02020-08-24 13:29:22 +0200994 (void **)&submod);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100995 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100996 if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100997 goto search_clb;
998 }
999 }
1000 if (submod) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001001 if (!inc->rev[0] && (submod->latest_revision == 1)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +01001002 /* update the latest_revision flag - here we have selected the latest available schema,
1003 * consider that even the callback provides correct latest revision */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001004 submod->latest_revision = 2;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001005 }
1006
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001007 inc->submodule = submod;
Radek Krejcid33273d2018-10-25 14:55:52 +02001008 }
1009 if (!inc->submodule) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001010 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.",
Michal Vasko7c8439f2020-08-05 13:25:19 +02001011 inc->name, pctx->main_mod->name);
Radek Krejcid33273d2018-10-25 14:55:52 +02001012 return LY_EVALID;
1013 }
1014
1015 return LY_SUCCESS;
1016}
1017
Radek Krejcice8c1592018-10-29 15:35:51 +01001018struct lys_module *
Radek Krejcia3045382018-11-22 14:30:31 +01001019lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len)
Radek Krejcice8c1592018-10-29 15:35:51 +01001020{
Michal Vasko7c8439f2020-08-05 13:25:19 +02001021 struct lys_module *m = NULL;
1022 LY_ARRAY_COUNT_TYPE u;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001023
Radek Krejci873ab432020-08-13 13:47:27 +02001024 if (!len || !ly_strncmp(mod->prefix, prefix, len)) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001025 /* it is the prefix of the module itself */
1026 m = (struct lys_module *)mod;
Radek Krejci73dead22019-07-11 16:46:16 +02001027 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001028
1029 /* search in imports */
1030 if (!m && mod->parsed) {
1031 LY_ARRAY_FOR(mod->parsed->imports, u) {
1032 if (!ly_strncmp(mod->parsed->imports[u].prefix, prefix, len)) {
1033 m = mod->parsed->imports[u].module;
1034 break;
1035 }
1036 }
Radek Krejcibbe09a92018-11-08 09:36:54 +01001037 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001038
1039 return m;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001040}
1041
Radek Krejcia3045382018-11-22 14:30:31 +01001042const char *
Radek Krejci693262f2019-04-29 15:23:20 +02001043lys_prefix_find_module(const struct lys_module *mod, const struct lys_module *import)
1044{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001045 LY_ARRAY_COUNT_TYPE u;
Radek Krejci693262f2019-04-29 15:23:20 +02001046
1047 if (import == mod) {
1048 return mod->prefix;
1049 }
1050
1051 if (mod->parsed) {
1052 LY_ARRAY_FOR(mod->parsed->imports, u) {
1053 if (mod->parsed->imports[u].module == import) {
1054 return mod->parsed->imports[u].prefix;
1055 }
1056 }
1057 } else {
1058 /* we don't have original information about the import's prefix,
1059 * so the prefix of the import module itself is returned instead */
1060 return import->prefix;
1061 }
1062
1063 return NULL;
1064}
1065
Radek Krejci0935f412019-08-20 16:15:18 +02001066API const char *
Radek Krejcia3045382018-11-22 14:30:31 +01001067lys_nodetype2str(uint16_t nodetype)
1068{
Michal Vaskod989ba02020-08-24 10:59:24 +02001069 switch (nodetype) {
Radek Krejcia3045382018-11-22 14:30:31 +01001070 case LYS_CONTAINER:
1071 return "container";
1072 case LYS_CHOICE:
1073 return "choice";
1074 case LYS_LEAF:
1075 return "leaf";
1076 case LYS_LEAFLIST:
1077 return "leaf-list";
1078 case LYS_LIST:
1079 return "list";
1080 case LYS_ANYXML:
1081 return "anyxml";
1082 case LYS_ANYDATA:
1083 return "anydata";
Radek Krejcif12a1f02019-02-11 16:42:08 +01001084 case LYS_CASE:
1085 return "case";
Michal Vasko1bf09392020-03-27 12:38:10 +01001086 case LYS_RPC:
1087 return "RPC";
Radek Krejcif538ce52019-03-05 10:46:14 +01001088 case LYS_ACTION:
Michal Vasko1bf09392020-03-27 12:38:10 +01001089 return "action";
Radek Krejcif538ce52019-03-05 10:46:14 +01001090 case LYS_NOTIF:
Michal Vaskoa3881362020-01-21 15:57:35 +01001091 return "notification";
Radek Krejcifc81ea82019-04-18 13:27:22 +02001092 case LYS_USES:
1093 return "uses";
Radek Krejcia3045382018-11-22 14:30:31 +01001094 default:
1095 return "unknown";
1096 }
1097}
1098
Radek Krejci693262f2019-04-29 15:23:20 +02001099const char *
1100lys_datatype2str(LY_DATA_TYPE basetype)
1101{
Michal Vaskod989ba02020-08-24 10:59:24 +02001102 switch (basetype) {
Radek Krejci693262f2019-04-29 15:23:20 +02001103 case LY_TYPE_BINARY:
1104 return "binary";
1105 case LY_TYPE_UINT8:
1106 return "uint8";
1107 case LY_TYPE_UINT16:
1108 return "uint16";
1109 case LY_TYPE_UINT32:
1110 return "uint32";
1111 case LY_TYPE_UINT64:
1112 return "uint64";
1113 case LY_TYPE_STRING:
1114 return "string";
1115 case LY_TYPE_BITS:
1116 return "bits";
1117 case LY_TYPE_BOOL:
1118 return "boolean";
1119 case LY_TYPE_DEC64:
1120 return "decimal64";
1121 case LY_TYPE_EMPTY:
1122 return "empty";
1123 case LY_TYPE_ENUM:
1124 return "enumeration";
1125 case LY_TYPE_IDENT:
1126 return "identityref";
1127 case LY_TYPE_INST:
1128 return "instance-identifier";
1129 case LY_TYPE_LEAFREF:
1130 return "leafref";
1131 case LY_TYPE_UNION:
1132 return "union";
1133 case LY_TYPE_INT8:
1134 return "int8";
1135 case LY_TYPE_INT16:
1136 return "int16";
1137 case LY_TYPE_INT32:
1138 return "int32";
1139 case LY_TYPE_INT64:
1140 return "int64";
1141 default:
1142 return "unknown";
1143 }
1144}
1145
Radek Krejci056d0a82018-12-06 16:57:25 +01001146API const struct lysp_tpdf *
1147lysp_node_typedefs(const struct lysp_node *node)
1148{
Radek Krejci0fb28562018-12-13 15:17:37 +01001149 switch (node->nodetype) {
1150 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001151 return ((struct lysp_node_container *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001152 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001153 return ((struct lysp_node_list *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001154 case LYS_GROUPING:
Michal Vasko22df3f02020-08-24 13:29:22 +02001155 return ((struct lysp_grp *)node)->typedefs;
Michal Vasko1bf09392020-03-27 12:38:10 +01001156 case LYS_RPC:
Radek Krejci0fb28562018-12-13 15:17:37 +01001157 case LYS_ACTION:
Michal Vasko22df3f02020-08-24 13:29:22 +02001158 return ((struct lysp_action *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001159 case LYS_INOUT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001160 return ((struct lysp_action_inout *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001161 case LYS_NOTIF:
Michal Vasko22df3f02020-08-24 13:29:22 +02001162 return ((struct lysp_notif *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001163 default:
Radek Krejci056d0a82018-12-06 16:57:25 +01001164 return NULL;
1165 }
1166}
1167
Radek Krejci53ea6152018-12-13 15:21:15 +01001168API const struct lysp_grp *
1169lysp_node_groupings(const struct lysp_node *node)
1170{
1171 switch (node->nodetype) {
1172 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001173 return ((struct lysp_node_container *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001174 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001175 return ((struct lysp_node_list *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001176 case LYS_GROUPING:
Michal Vasko22df3f02020-08-24 13:29:22 +02001177 return ((struct lysp_grp *)node)->groupings;
Michal Vasko1bf09392020-03-27 12:38:10 +01001178 case LYS_RPC:
Radek Krejci53ea6152018-12-13 15:21:15 +01001179 case LYS_ACTION:
Michal Vasko22df3f02020-08-24 13:29:22 +02001180 return ((struct lysp_action *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001181 case LYS_INOUT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001182 return ((struct lysp_action_inout *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001183 case LYS_NOTIF:
Michal Vasko22df3f02020-08-24 13:29:22 +02001184 return ((struct lysp_notif *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001185 default:
1186 return NULL;
1187 }
1188}
1189
Radek Krejcibbe09a92018-11-08 09:36:54 +01001190struct lysp_action **
Radek Krejci056d0a82018-12-06 16:57:25 +01001191lysp_node_actions_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001192{
1193 assert(node);
1194 switch (node->nodetype) {
1195 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001196 return &((struct lysp_node_container *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001197 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001198 return &((struct lysp_node_list *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001199 case LYS_GROUPING:
Michal Vasko22df3f02020-08-24 13:29:22 +02001200 return &((struct lysp_grp *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001201 case LYS_AUGMENT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001202 return &((struct lysp_augment *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001203 default:
1204 return NULL;
1205 }
1206}
1207
Radek Krejci056d0a82018-12-06 16:57:25 +01001208API const struct lysp_action *
1209lysp_node_actions(const struct lysp_node *node)
1210{
1211 struct lysp_action **actions;
Michal Vasko22df3f02020-08-24 13:29:22 +02001212 actions = lysp_node_actions_p((struct lysp_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001213 if (actions) {
1214 return *actions;
1215 } else {
1216 return NULL;
1217 }
1218}
1219
Radek Krejcibbe09a92018-11-08 09:36:54 +01001220struct lysp_notif **
Radek Krejci056d0a82018-12-06 16:57:25 +01001221lysp_node_notifs_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001222{
1223 assert(node);
1224 switch (node->nodetype) {
1225 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001226 return &((struct lysp_node_container *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001227 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001228 return &((struct lysp_node_list *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001229 case LYS_GROUPING:
Michal Vasko22df3f02020-08-24 13:29:22 +02001230 return &((struct lysp_grp *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001231 case LYS_AUGMENT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001232 return &((struct lysp_augment *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001233 default:
1234 return NULL;
1235 }
1236}
1237
Radek Krejci056d0a82018-12-06 16:57:25 +01001238API const struct lysp_notif *
1239lysp_node_notifs(const struct lysp_node *node)
1240{
1241 struct lysp_notif **notifs;
Michal Vasko22df3f02020-08-24 13:29:22 +02001242 notifs = lysp_node_notifs_p((struct lysp_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001243 if (notifs) {
1244 return *notifs;
1245 } else {
1246 return NULL;
1247 }
1248}
1249
Radek Krejcibbe09a92018-11-08 09:36:54 +01001250struct lysp_node **
Radek Krejci056d0a82018-12-06 16:57:25 +01001251lysp_node_children_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001252{
1253 assert(node);
1254 switch (node->nodetype) {
1255 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001256 return &((struct lysp_node_container *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001257 case LYS_CHOICE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001258 return &((struct lysp_node_choice *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001259 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001260 return &((struct lysp_node_list *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001261 case LYS_CASE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001262 return &((struct lysp_node_case *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001263 case LYS_GROUPING:
Michal Vasko22df3f02020-08-24 13:29:22 +02001264 return &((struct lysp_grp *)node)->data;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001265 case LYS_AUGMENT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001266 return &((struct lysp_augment *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001267 case LYS_INOUT:
Michal Vasko22df3f02020-08-24 13:29:22 +02001268 return &((struct lysp_action_inout *)node)->data;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001269 case LYS_NOTIF:
Michal Vasko22df3f02020-08-24 13:29:22 +02001270 return &((struct lysp_notif *)node)->data;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001271 default:
1272 return NULL;
1273 }
1274}
1275
Radek Krejci056d0a82018-12-06 16:57:25 +01001276API const struct lysp_node *
1277lysp_node_children(const struct lysp_node *node)
1278{
1279 struct lysp_node **children;
Radek Krejcie7b95092019-05-15 11:03:07 +02001280
1281 if (!node) {
1282 return NULL;
1283 }
1284
Michal Vasko22df3f02020-08-24 13:29:22 +02001285 children = lysp_node_children_p((struct lysp_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001286 if (children) {
1287 return *children;
1288 } else {
1289 return NULL;
1290 }
1291}
1292
1293struct lysc_action **
1294lysc_node_actions_p(struct lysc_node *node)
1295{
1296 assert(node);
1297 switch (node->nodetype) {
1298 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001299 return &((struct lysc_node_container *)node)->actions;
Radek Krejci056d0a82018-12-06 16:57:25 +01001300 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001301 return &((struct lysc_node_list *)node)->actions;
Radek Krejci056d0a82018-12-06 16:57:25 +01001302 default:
1303 return NULL;
1304 }
1305}
1306
1307API const struct lysc_action *
1308lysc_node_actions(const struct lysc_node *node)
1309{
1310 struct lysc_action **actions;
Michal Vasko22df3f02020-08-24 13:29:22 +02001311 actions = lysc_node_actions_p((struct lysc_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001312 if (actions) {
1313 return *actions;
1314 } else {
1315 return NULL;
1316 }
1317}
1318
1319struct lysc_notif **
1320lysc_node_notifs_p(struct lysc_node *node)
1321{
1322 assert(node);
1323 switch (node->nodetype) {
1324 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001325 return &((struct lysc_node_container *)node)->notifs;
Radek Krejci056d0a82018-12-06 16:57:25 +01001326 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001327 return &((struct lysc_node_list *)node)->notifs;
Radek Krejci056d0a82018-12-06 16:57:25 +01001328 default:
1329 return NULL;
1330 }
1331}
1332
1333API const struct lysc_notif *
1334lysc_node_notifs(const struct lysc_node *node)
1335{
1336 struct lysc_notif **notifs;
Michal Vasko22df3f02020-08-24 13:29:22 +02001337 notifs = lysc_node_notifs_p((struct lysc_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001338 if (notifs) {
1339 return *notifs;
1340 } else {
1341 return NULL;
1342 }
1343}
1344
Radek Krejcibbe09a92018-11-08 09:36:54 +01001345struct lysc_node **
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001346lysc_node_children_p(const struct lysc_node *node, uint16_t flags)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001347{
1348 assert(node);
1349 switch (node->nodetype) {
1350 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001351 return &((struct lysc_node_container *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001352 case LYS_CHOICE:
Michal Vasko20424b42020-08-31 12:29:38 +02001353 return (struct lysc_node **)&((struct lysc_node_choice *)node)->cases;
Radek Krejci01342af2019-01-03 15:18:08 +01001354 case LYS_CASE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001355 return &((struct lysc_node_case *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001356 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001357 return &((struct lysc_node_list *)node)->child;
Michal Vasko1bf09392020-03-27 12:38:10 +01001358 case LYS_RPC:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001359 case LYS_ACTION:
1360 if (flags & LYS_CONFIG_R) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001361 return &((struct lysc_action *)node)->output.data;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001362 } else {
1363 /* LYS_CONFIG_W, but also the default case */
Michal Vasko22df3f02020-08-24 13:29:22 +02001364 return &((struct lysc_action *)node)->input.data;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001365 }
Radek Krejcifc11bd72019-04-11 16:00:05 +02001366 case LYS_NOTIF:
Michal Vasko22df3f02020-08-24 13:29:22 +02001367 return &((struct lysc_notif *)node)->data;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001368 default:
1369 return NULL;
1370 }
1371}
1372
Radek Krejci056d0a82018-12-06 16:57:25 +01001373API const struct lysc_node *
Radek Krejci6eeb58f2019-02-22 16:29:37 +01001374lysc_node_children(const struct lysc_node *node, uint16_t flags)
Radek Krejcia3045382018-11-22 14:30:31 +01001375{
Radek Krejci056d0a82018-12-06 16:57:25 +01001376 struct lysc_node **children;
Radek Krejcie7b95092019-05-15 11:03:07 +02001377
1378 if (!node) {
1379 return NULL;
1380 }
1381
Michal Vasko22df3f02020-08-24 13:29:22 +02001382 children = lysc_node_children_p((struct lysc_node *)node, flags);
Radek Krejci056d0a82018-12-06 16:57:25 +01001383 if (children) {
1384 return *children;
1385 } else {
Radek Krejcia3045382018-11-22 14:30:31 +01001386 return NULL;
1387 }
1388}
1389
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001390struct lys_module *
1391lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod)
1392{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001393 for (uint32_t u = 0; u < ctx->list.count; ++u) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001394 if (((struct lys_module *)ctx->list.objs[u])->parsed == mod) {
1395 return ((struct lys_module *)ctx->list.objs[u]);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001396 }
1397 }
1398 return NULL;
1399}
1400
Radek Krejcid6b76452019-09-03 17:03:03 +02001401enum ly_stmt
Michal Vasko63f3d842020-07-08 10:10:14 +02001402lysp_match_kw(struct lys_yang_parser_ctx *ctx, struct ly_in *in)
David Sedlákc10e7902018-12-17 02:17:59 +01001403{
David Sedlák1bccdfa2019-06-17 15:55:27 +02001404/**
Michal Vasko63f3d842020-07-08 10:10:14 +02001405 * @brief Move the INPUT by COUNT items. Also updates the indent value in yang parser context
David Sedlák1bccdfa2019-06-17 15:55:27 +02001406 * @param[in] CTX yang parser context to update its indent value.
Michal Vasko63f3d842020-07-08 10:10:14 +02001407 * @param[in,out] IN input to move
David Sedlák1bccdfa2019-06-17 15:55:27 +02001408 * @param[in] COUNT number of items for which the DATA pointer is supposed to move on.
Michal Vasko64246d82020-08-19 12:35:00 +02001409 *
1410 * *INDENT-OFF*
David Sedlák1bccdfa2019-06-17 15:55:27 +02001411 */
Michal Vasko63f3d842020-07-08 10:10:14 +02001412#define MOVE_IN(CTX, IN, COUNT) ly_in_skip(IN, COUNT);if(CTX){(CTX)->indent+=COUNT;}
1413#define IF_KW(STR, LEN, STMT) if (!strncmp(in->current, STR, LEN)) {MOVE_IN(ctx, in, LEN);*kw=STMT;}
1414#define IF_KW_PREFIX(STR, LEN) if (!strncmp(in->current, STR, LEN)) {MOVE_IN(ctx, in, LEN);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001415#define IF_KW_PREFIX_END }
David Sedlák572e7ab2019-06-04 16:01:58 +02001416
Michal Vasko63f3d842020-07-08 10:10:14 +02001417 const char *start = in->current;
Radek Krejcid6b76452019-09-03 17:03:03 +02001418 enum ly_stmt result = LY_STMT_NONE;
1419 enum ly_stmt *kw = &result;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001420 /* read the keyword itself */
Michal Vasko63f3d842020-07-08 10:10:14 +02001421 switch (in->current[0]) {
David Sedlák23a59a62018-10-26 13:08:02 +02001422 case 'a':
Michal Vasko63f3d842020-07-08 10:10:14 +02001423 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001424 IF_KW("rgument", 7, LY_STMT_ARGUMENT)
1425 else IF_KW("ugment", 6, LY_STMT_AUGMENT)
1426 else IF_KW("ction", 5, LY_STMT_ACTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001427 else IF_KW_PREFIX("ny", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001428 IF_KW("data", 4, LY_STMT_ANYDATA)
1429 else IF_KW("xml", 3, LY_STMT_ANYXML)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001430 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001431 break;
1432 case 'b':
Michal Vasko63f3d842020-07-08 10:10:14 +02001433 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001434 IF_KW("ase", 3, LY_STMT_BASE)
1435 else IF_KW("elongs-to", 9, LY_STMT_BELONGS_TO)
1436 else IF_KW("it", 2, LY_STMT_BIT)
David Sedlák23a59a62018-10-26 13:08:02 +02001437 break;
1438 case 'c':
Michal Vasko63f3d842020-07-08 10:10:14 +02001439 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001440 IF_KW("ase", 3, LY_STMT_CASE)
1441 else IF_KW("hoice", 5, LY_STMT_CHOICE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001442 else IF_KW_PREFIX("on", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001443 IF_KW("fig", 3, LY_STMT_CONFIG)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001444 else IF_KW_PREFIX("ta", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001445 IF_KW("ct", 2, LY_STMT_CONTACT)
1446 else IF_KW("iner", 4, LY_STMT_CONTAINER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001447 IF_KW_PREFIX_END
1448 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001449 break;
1450 case 'd':
Michal Vasko63f3d842020-07-08 10:10:14 +02001451 MOVE_IN(ctx, in, 1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001452 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001453 IF_KW("fault", 5, LY_STMT_DEFAULT)
1454 else IF_KW("scription", 9, LY_STMT_DESCRIPTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001455 else IF_KW_PREFIX("viat", 4)
Radek Krejcid6b76452019-09-03 17:03:03 +02001456 IF_KW("e", 1, LY_STMT_DEVIATE)
1457 else IF_KW("ion", 3, LY_STMT_DEVIATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001458 IF_KW_PREFIX_END
1459 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001460 break;
1461 case 'e':
Michal Vasko63f3d842020-07-08 10:10:14 +02001462 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001463 IF_KW("num", 3, LY_STMT_ENUM)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001464 else IF_KW_PREFIX("rror-", 5)
Radek Krejcid6b76452019-09-03 17:03:03 +02001465 IF_KW("app-tag", 7, LY_STMT_ERROR_APP_TAG)
1466 else IF_KW("message", 7, LY_STMT_ERROR_MESSAGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001467 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001468 else IF_KW("xtension", 8, LY_STMT_EXTENSION)
David Sedlák23a59a62018-10-26 13:08:02 +02001469 break;
1470 case 'f':
Michal Vasko63f3d842020-07-08 10:10:14 +02001471 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001472 IF_KW("eature", 6, LY_STMT_FEATURE)
1473 else IF_KW("raction-digits", 14, LY_STMT_FRACTION_DIGITS)
David Sedlák23a59a62018-10-26 13:08:02 +02001474 break;
1475 case 'g':
Michal Vasko63f3d842020-07-08 10:10:14 +02001476 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001477 IF_KW("rouping", 7, LY_STMT_GROUPING)
David Sedlák23a59a62018-10-26 13:08:02 +02001478 break;
1479 case 'i':
Michal Vasko63f3d842020-07-08 10:10:14 +02001480 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001481 IF_KW("dentity", 7, LY_STMT_IDENTITY)
1482 else IF_KW("f-feature", 9, LY_STMT_IF_FEATURE)
1483 else IF_KW("mport", 5, LY_STMT_IMPORT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001484 else IF_KW_PREFIX("n", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001485 IF_KW("clude", 5, LY_STMT_INCLUDE)
1486 else IF_KW("put", 3, LY_STMT_INPUT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001487 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001488 break;
1489 case 'k':
Michal Vasko63f3d842020-07-08 10:10:14 +02001490 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001491 IF_KW("ey", 2, LY_STMT_KEY)
David Sedlák23a59a62018-10-26 13:08:02 +02001492 break;
1493 case 'l':
Michal Vasko63f3d842020-07-08 10:10:14 +02001494 MOVE_IN(ctx, in, 1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001495 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001496 IF_KW("af-list", 7, LY_STMT_LEAF_LIST)
1497 else IF_KW("af", 2, LY_STMT_LEAF)
1498 else IF_KW("ngth", 4, LY_STMT_LENGTH)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001499 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001500 else IF_KW("ist", 3, LY_STMT_LIST)
David Sedlák23a59a62018-10-26 13:08:02 +02001501 break;
1502 case 'm':
Michal Vasko63f3d842020-07-08 10:10:14 +02001503 MOVE_IN(ctx, in, 1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001504 IF_KW_PREFIX("a", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001505 IF_KW("ndatory", 7, LY_STMT_MANDATORY)
1506 else IF_KW("x-elements", 10, LY_STMT_MAX_ELEMENTS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001507 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001508 else IF_KW("in-elements", 11, LY_STMT_MIN_ELEMENTS)
1509 else IF_KW("ust", 3, LY_STMT_MUST)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001510 else IF_KW_PREFIX("od", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001511 IF_KW("ule", 3, LY_STMT_MODULE)
1512 else IF_KW("ifier", 5, LY_STMT_MODIFIER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001513 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001514 break;
1515 case 'n':
Michal Vasko63f3d842020-07-08 10:10:14 +02001516 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001517 IF_KW("amespace", 8, LY_STMT_NAMESPACE)
1518 else IF_KW("otification", 11, LY_STMT_NOTIFICATION)
David Sedlák23a59a62018-10-26 13:08:02 +02001519 break;
1520 case 'o':
Michal Vasko63f3d842020-07-08 10:10:14 +02001521 MOVE_IN(ctx, in, 1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001522 IF_KW_PREFIX("r", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001523 IF_KW("dered-by", 8, LY_STMT_ORDERED_BY)
1524 else IF_KW("ganization", 10, LY_STMT_ORGANIZATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001525 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001526 else IF_KW("utput", 5, LY_STMT_OUTPUT)
David Sedlák23a59a62018-10-26 13:08:02 +02001527 break;
1528 case 'p':
Michal Vasko63f3d842020-07-08 10:10:14 +02001529 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001530 IF_KW("ath", 3, LY_STMT_PATH)
1531 else IF_KW("attern", 6, LY_STMT_PATTERN)
1532 else IF_KW("osition", 7, LY_STMT_POSITION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001533 else IF_KW_PREFIX("re", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001534 IF_KW("fix", 3, LY_STMT_PREFIX)
1535 else IF_KW("sence", 5, LY_STMT_PRESENCE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001536 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001537 break;
1538 case 'r':
Michal Vasko63f3d842020-07-08 10:10:14 +02001539 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001540 IF_KW("ange", 4, LY_STMT_RANGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001541 else IF_KW_PREFIX("e", 1)
1542 IF_KW_PREFIX("f", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001543 IF_KW("erence", 6, LY_STMT_REFERENCE)
1544 else IF_KW("ine", 3, LY_STMT_REFINE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001545 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001546 else IF_KW("quire-instance", 14, LY_STMT_REQUIRE_INSTANCE)
1547 else IF_KW("vision-date", 11, LY_STMT_REVISION_DATE)
1548 else IF_KW("vision", 6, LY_STMT_REVISION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001549 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001550 else IF_KW("pc", 2, LY_STMT_RPC)
David Sedlák23a59a62018-10-26 13:08:02 +02001551 break;
1552 case 's':
Michal Vasko63f3d842020-07-08 10:10:14 +02001553 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001554 IF_KW("tatus", 5, LY_STMT_STATUS)
1555 else IF_KW("ubmodule", 8, LY_STMT_SUBMODULE)
David Sedlák23a59a62018-10-26 13:08:02 +02001556 break;
1557 case 't':
Michal Vasko63f3d842020-07-08 10:10:14 +02001558 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001559 IF_KW("ypedef", 6, LY_STMT_TYPEDEF)
1560 else IF_KW("ype", 3, LY_STMT_TYPE)
David Sedlák23a59a62018-10-26 13:08:02 +02001561 break;
1562 case 'u':
Michal Vasko63f3d842020-07-08 10:10:14 +02001563 MOVE_IN(ctx, in, 1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001564 IF_KW_PREFIX("ni", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001565 IF_KW("que", 3, LY_STMT_UNIQUE)
1566 else IF_KW("ts", 2, LY_STMT_UNITS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001567 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001568 else IF_KW("ses", 3, LY_STMT_USES)
David Sedlák23a59a62018-10-26 13:08:02 +02001569 break;
1570 case 'v':
Michal Vasko63f3d842020-07-08 10:10:14 +02001571 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001572 IF_KW("alue", 4, LY_STMT_VALUE)
David Sedlák23a59a62018-10-26 13:08:02 +02001573 break;
1574 case 'w':
Michal Vasko63f3d842020-07-08 10:10:14 +02001575 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001576 IF_KW("hen", 3, LY_STMT_WHEN)
David Sedlák23a59a62018-10-26 13:08:02 +02001577 break;
1578 case 'y':
Michal Vasko63f3d842020-07-08 10:10:14 +02001579 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001580 IF_KW("ang-version", 11, LY_STMT_YANG_VERSION)
1581 else IF_KW("in-element", 10, LY_STMT_YIN_ELEMENT)
David Sedlák23a59a62018-10-26 13:08:02 +02001582 break;
David Sedlák23a59a62018-10-26 13:08:02 +02001583 default:
David Sedlák1bccdfa2019-06-17 15:55:27 +02001584 /* if context is not NULL we are matching keyword from YANG data*/
1585 if (ctx) {
Michal Vasko63f3d842020-07-08 10:10:14 +02001586 if (in->current[0] == ';') {
1587 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001588 *kw = LY_STMT_SYNTAX_SEMICOLON;
Michal Vasko63f3d842020-07-08 10:10:14 +02001589 } else if (in->current[0] == '{') {
1590 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001591 *kw = LY_STMT_SYNTAX_LEFT_BRACE;
Michal Vasko63f3d842020-07-08 10:10:14 +02001592 } else if (in->current[0] == '}') {
1593 MOVE_IN(ctx, in, 1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001594 *kw = LY_STMT_SYNTAX_RIGHT_BRACE;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001595 }
1596 }
David Sedlák23a59a62018-10-26 13:08:02 +02001597 break;
1598 }
1599
Michal Vasko63f3d842020-07-08 10:10:14 +02001600 if ((*kw < LY_STMT_SYNTAX_SEMICOLON) && isalnum(in->current[0])) {
Radek Krejci6e546bf2020-05-19 16:16:19 +02001601 /* the keyword is not terminated */
1602 *kw = LY_STMT_NONE;
Michal Vasko63f3d842020-07-08 10:10:14 +02001603 in->current = start;
Radek Krejci6e546bf2020-05-19 16:16:19 +02001604 }
1605
David Sedlák1bccdfa2019-06-17 15:55:27 +02001606#undef IF_KW
1607#undef IF_KW_PREFIX
1608#undef IF_KW_PREFIX_END
David Sedlák18730132019-03-15 15:51:34 +01001609#undef MOVE_IN
Michal Vasko64246d82020-08-19 12:35:00 +02001610 /* *INDENT-ON* */
David Sedlák18730132019-03-15 15:51:34 +01001611
David Sedlák1bccdfa2019-06-17 15:55:27 +02001612 return result;
David Sedlák23a59a62018-10-26 13:08:02 +02001613}
David Sedlákecf5eb82019-06-03 14:12:44 +02001614
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001615LY_ARRAY_COUNT_TYPE
1616lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, LYEXT_SUBSTMT substmt)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001617{
1618 LY_CHECK_ARG_RET(NULL, ext, LY_EINVAL);
1619
Michal Vaskod989ba02020-08-24 10:59:24 +02001620 for ( ; index < LY_ARRAY_COUNT(ext); index++) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001621 if (ext[index].insubstmt == substmt) {
1622 return index;
1623 }
1624 }
1625
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001626 return LY_ARRAY_COUNT(ext);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001627}
1628
Michal Vasko62ed12d2020-05-21 10:08:25 +02001629const struct lysc_node *
1630lysc_data_parent(const struct lysc_node *schema)
1631{
1632 const struct lysc_node *parent;
1633
Radek Krejci1e008d22020-08-17 11:37:37 +02001634 for (parent = schema->parent; parent && (parent->nodetype & (LYS_CHOICE | LYS_CASE)); parent = parent->parent) {}
Michal Vasko62ed12d2020-05-21 10:08:25 +02001635
1636 return parent;
1637}
Michal Vasko00cbf532020-06-15 13:58:47 +02001638
Radek Krejci857189e2020-09-01 13:26:36 +02001639ly_bool
Michal Vasko00cbf532020-06-15 13:58:47 +02001640lysc_is_output(const struct lysc_node *schema)
1641{
1642 const struct lysc_node *parent;
1643
1644 assert(schema);
1645
Radek Krejci1e008d22020-08-17 11:37:37 +02001646 for (parent = schema->parent; parent && !(parent->nodetype & (LYS_RPC | LYS_ACTION)); parent = parent->parent) {}
Michal Vasko00cbf532020-06-15 13:58:47 +02001647 if (parent && (schema->flags & LYS_CONFIG_R)) {
1648 return 1;
1649 }
1650 return 0;
1651}
Michal Vaskod975f862020-06-23 13:29:28 +02001652
Radek Krejci857189e2020-09-01 13:26:36 +02001653API ly_bool
Michal Vaskod975f862020-06-23 13:29:28 +02001654lysc_is_userordered(const struct lysc_node *schema)
1655{
1656 if (!schema || !(schema->nodetype & (LYS_LEAFLIST | LYS_LIST)) || !(schema->flags & LYS_ORDBY_USER)) {
1657 return 0;
1658 }
1659
1660 return 1;
1661}
Michal Vasko2fd91b92020-07-17 16:39:02 +02001662
1663API LY_ERR
1664lysc_set_private(const struct lysc_node *node, void *priv, void **prev)
1665{
1666 struct lysc_action *act;
1667 struct lysc_notif *notif;
1668
1669 LY_CHECK_ARG_RET(NULL, node, LY_EINVAL);
1670
1671 switch (node->nodetype) {
1672 case LYS_CONTAINER:
1673 case LYS_CHOICE:
1674 case LYS_CASE:
1675 case LYS_LEAF:
1676 case LYS_LEAFLIST:
1677 case LYS_LIST:
1678 case LYS_ANYXML:
1679 case LYS_ANYDATA:
1680 if (prev) {
1681 *prev = node->priv;
1682 }
1683 ((struct lysc_node *)node)->priv = priv;
1684 break;
1685 case LYS_RPC:
1686 case LYS_ACTION:
1687 act = (struct lysc_action *)node;
1688 if (prev) {
1689 *prev = act->priv;
1690 }
1691 act->priv = priv;
1692 break;
1693 case LYS_NOTIF:
1694 notif = (struct lysc_notif *)node;
1695 if (prev) {
1696 *prev = notif->priv;
1697 }
1698 notif->priv = priv;
1699 break;
1700 default:
1701 return LY_EINVAL;
1702 }
1703
1704 return LY_SUCCESS;
1705}