blob: 242dc8e0f6b689f723ffde3dc7bf1bd63d476d64 [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 Krejci47fab892020-11-05 17:02:41 +010019#include <stddef.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <stdint.h>
Radek Krejci9ed7a192018-10-31 16:23:51 +010021#include <stdlib.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020023#include <time.h>
24
Radek Krejci535ea9f2020-05-29 16:01:05 +020025#include "common.h"
Michal Vasko69730152020-10-09 16:30:07 +020026#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020027#include "context.h"
Radek Krejci77114102021-03-10 15:21:57 +010028#include "dict.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020029#include "hash_table.h"
Radek Krejci47fab892020-11-05 17:02:41 +010030#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020031#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010032#include "log.h"
Michal Vasko69730152020-10-09 16:30:07 +020033#include "parser_schema.h"
Michal Vasko962b6cd2020-12-08 10:07:49 +010034#include "schema_compile.h"
Michal Vasko79135ae2020-12-16 10:08:35 +010035#include "schema_features.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020036#include "set.h"
37#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010038#include "tree_edit.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020039#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020040#include "tree_schema_internal.h"
41
Radek Krejci85747952019-06-07 16:43:43 +020042LY_ERR
Radek Krejcie7b95092019-05-15 11:03:07 +020043lysp_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 +020044{
45 struct lysp_import *i;
46
Michal Vasko69730152020-10-09 16:30:07 +020047 if (module_prefix && (&module_prefix != value) && !strcmp(module_prefix, *value)) {
Michal Vaskob36053d2020-03-26 15:49:30 +010048 LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used as module prefix.", *value);
Radek Krejci86d106e2018-10-18 09:53:19 +020049 return LY_EEXIST;
50 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +010051 LY_ARRAY_FOR(imports, struct lysp_import, i) {
Michal Vasko69730152020-10-09 16:30:07 +020052 if (i->prefix && (&i->prefix != value) && !strcmp(i->prefix, *value)) {
Michal Vaskob36053d2020-03-26 15:49:30 +010053 LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used to import \"%s\" module.", *value, i->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +010054 return LY_EEXIST;
Radek Krejci86d106e2018-10-18 09:53:19 +020055 }
56 }
57 return LY_SUCCESS;
58}
59
60LY_ERR
Juraj Vijtiuk74dad9e2021-05-26 12:42:14 +020061lysp_check_date(struct lys_parser_ctx *ctx, const char *date, size_t date_len, const char *stmt)
Radek Krejci86d106e2018-10-18 09:53:19 +020062{
Radek Krejci86d106e2018-10-18 09:53:19 +020063 struct tm tm, tm_;
64 char *r;
65
Michal Vaskob36053d2020-03-26 15:49:30 +010066 LY_CHECK_ARG_RET(ctx ? PARSER_CTX(ctx) : NULL, date, LY_EINVAL);
67 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 +020068
Radek Krejcif13b87b2020-12-01 22:02:17 +010069 /* check format: YYYY-MM-DD */
Radek Krejci1deb5be2020-08-26 16:43:36 +020070 for (uint8_t i = 0; i < date_len; i++) {
Michal Vasko69730152020-10-09 16:30:07 +020071 if ((i == 4) || (i == 7)) {
Radek Krejci86d106e2018-10-18 09:53:19 +020072 if (date[i] != '-') {
73 goto error;
74 }
75 } else if (!isdigit(date[i])) {
76 goto error;
77 }
78 }
79
80 /* check content, e.g. 2018-02-31 */
81 memset(&tm, 0, sizeof tm);
82 r = strptime(date, "%Y-%m-%d", &tm);
Michal Vasko69730152020-10-09 16:30:07 +020083 if (!r || (r != &date[LY_REV_SIZE - 1])) {
Radek Krejci86d106e2018-10-18 09:53:19 +020084 goto error;
85 }
86 memcpy(&tm_, &tm, sizeof tm);
87 mktime(&tm_); /* mktime modifies tm_ if it refers invalid date */
88 if (tm.tm_mday != tm_.tm_mday) { /* e.g 2018-02-29 -> 2018-03-01 */
89 /* checking days is enough, since other errors
90 * have been checked by strptime() */
91 goto error;
92 }
93
94 return LY_SUCCESS;
95
96error:
Radek Krejcid33273d2018-10-25 14:55:52 +020097 if (stmt) {
Radek Krejci2efc45b2020-12-22 16:25:44 +010098 LOGVAL_PARSER(ctx, LY_VCODE_INVAL, date_len, date, stmt);
Radek Krejcid33273d2018-10-25 14:55:52 +020099 }
Radek Krejci86d106e2018-10-18 09:53:19 +0200100 return LY_EINVAL;
101}
102
103void
104lysp_sort_revisions(struct lysp_revision *revs)
105{
Radek Krejci857189e2020-09-01 13:26:36 +0200106 LY_ARRAY_COUNT_TYPE i, r;
Radek Krejci86d106e2018-10-18 09:53:19 +0200107 struct lysp_revision rev;
108
Radek Krejcic7d13e32020-12-09 12:32:24 +0100109 for (i = 1, r = 0; i < LY_ARRAY_COUNT(revs); i++) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200110 if (strcmp(revs[i].date, revs[r].date) > 0) {
Radek Krejci86d106e2018-10-18 09:53:19 +0200111 r = i;
112 }
113 }
114
115 if (r) {
116 /* the newest revision is not on position 0, switch them */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200117 memcpy(&rev, &revs[0], sizeof rev);
118 memcpy(&revs[0], &revs[r], sizeof rev);
119 memcpy(&revs[r], &rev, sizeof rev);
Radek Krejci86d106e2018-10-18 09:53:19 +0200120 }
121}
Radek Krejci151a5b72018-10-19 14:21:44 +0200122
Radek Krejcibbe09a92018-11-08 09:36:54 +0100123static const struct lysp_tpdf *
124lysp_type_match(const char *name, struct lysp_node *node)
125{
Radek Krejci0fb28562018-12-13 15:17:37 +0100126 const struct lysp_tpdf *typedefs;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200127 LY_ARRAY_COUNT_TYPE u;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100128
Radek Krejci0fb28562018-12-13 15:17:37 +0100129 typedefs = lysp_node_typedefs(node);
130 LY_ARRAY_FOR(typedefs, u) {
131 if (!strcmp(name, typedefs[u].name)) {
132 /* match */
133 return &typedefs[u];
Radek Krejcibbe09a92018-11-08 09:36:54 +0100134 }
135 }
136
137 return NULL;
138}
139
Radek Krejci4f28eda2018-11-12 11:46:16 +0100140static LY_DATA_TYPE
141lysp_type_str2builtin(const char *name, size_t len)
142{
143 if (len >= 4) { /* otherwise it does not match any built-in type */
144 if (name[0] == 'b') {
145 if (name[1] == 'i') {
Michal Vasko69730152020-10-09 16:30:07 +0200146 if ((len == 6) && !strncmp(&name[2], "nary", 4)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100147 return LY_TYPE_BINARY;
Michal Vasko69730152020-10-09 16:30:07 +0200148 } else if ((len == 4) && !strncmp(&name[2], "ts", 2)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100149 return LY_TYPE_BITS;
150 }
Michal Vasko69730152020-10-09 16:30:07 +0200151 } else if ((len == 7) && !strncmp(&name[1], "oolean", 6)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100152 return LY_TYPE_BOOL;
153 }
154 } else if (name[0] == 'd') {
Michal Vasko69730152020-10-09 16:30:07 +0200155 if ((len == 9) && !strncmp(&name[1], "ecimal64", 8)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100156 return LY_TYPE_DEC64;
157 }
158 } else if (name[0] == 'e') {
Michal Vasko69730152020-10-09 16:30:07 +0200159 if ((len == 5) && !strncmp(&name[1], "mpty", 4)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100160 return LY_TYPE_EMPTY;
Michal Vasko69730152020-10-09 16:30:07 +0200161 } else if ((len == 11) && !strncmp(&name[1], "numeration", 10)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100162 return LY_TYPE_ENUM;
163 }
164 } else if (name[0] == 'i') {
165 if (name[1] == 'n') {
Michal Vasko69730152020-10-09 16:30:07 +0200166 if ((len == 4) && !strncmp(&name[2], "t8", 2)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100167 return LY_TYPE_INT8;
168 } else if (len == 5) {
169 if (!strncmp(&name[2], "t16", 3)) {
170 return LY_TYPE_INT16;
171 } else if (!strncmp(&name[2], "t32", 3)) {
172 return LY_TYPE_INT32;
173 } else if (!strncmp(&name[2], "t64", 3)) {
174 return LY_TYPE_INT64;
175 }
Michal Vasko69730152020-10-09 16:30:07 +0200176 } else if ((len == 19) && !strncmp(&name[2], "stance-identifier", 17)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100177 return LY_TYPE_INST;
178 }
Michal Vasko69730152020-10-09 16:30:07 +0200179 } else if ((len == 11) && !strncmp(&name[1], "dentityref", 10)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100180 return LY_TYPE_IDENT;
181 }
182 } else if (name[0] == 'l') {
Michal Vasko69730152020-10-09 16:30:07 +0200183 if ((len == 7) && !strncmp(&name[1], "eafref", 6)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100184 return LY_TYPE_LEAFREF;
185 }
186 } else if (name[0] == 's') {
Michal Vasko69730152020-10-09 16:30:07 +0200187 if ((len == 6) && !strncmp(&name[1], "tring", 5)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100188 return LY_TYPE_STRING;
189 }
190 } else if (name[0] == 'u') {
191 if (name[1] == 'n') {
Michal Vasko69730152020-10-09 16:30:07 +0200192 if ((len == 5) && !strncmp(&name[2], "ion", 3)) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100193 return LY_TYPE_UNION;
194 }
Michal Vasko69730152020-10-09 16:30:07 +0200195 } else if ((name[1] == 'i') && (name[2] == 'n') && (name[3] == 't')) {
196 if ((len == 5) && (name[4] == '8')) {
Radek Krejci4f28eda2018-11-12 11:46:16 +0100197 return LY_TYPE_UINT8;
198 } else if (len == 6) {
199 if (!strncmp(&name[4], "16", 2)) {
200 return LY_TYPE_UINT16;
201 } else if (!strncmp(&name[4], "32", 2)) {
202 return LY_TYPE_UINT32;
203 } else if (!strncmp(&name[4], "64", 2)) {
204 return LY_TYPE_UINT64;
205 }
206 }
207 }
208 }
209 }
210
211 return LY_TYPE_UNKNOWN;
212}
213
Radek Krejcibbe09a92018-11-08 09:36:54 +0100214LY_ERR
Michal Vaskoa99b3572021-02-01 11:54:58 +0100215lysp_type_find(const char *id, struct lysp_node *start_node, const struct lysp_module *start_module,
216 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100217{
218 const char *str, *name;
219 struct lysp_tpdf *typedefs;
Michal Vaskob2d55bf2020-11-02 15:42:43 +0100220 const struct lys_module *mod;
Michal Vaskoa99b3572021-02-01 11:54:58 +0100221 const struct lysp_module *local_module;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200222 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100223
224 assert(id);
225 assert(start_module);
226 assert(tpdf);
227 assert(node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100228
Radek Krejci4f28eda2018-11-12 11:46:16 +0100229 *node = NULL;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100230 str = strchr(id, ':');
231 if (str) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200232 mod = ly_resolve_prefix(start_module->mod->ctx, id, str - id, LY_VALUE_SCHEMA, (void *)start_module);
Michal Vaskoa99b3572021-02-01 11:54:58 +0100233 local_module = mod ? mod->parsed : NULL;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100234 name = str + 1;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100235 *type = LY_TYPE_UNKNOWN;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100236 } else {
Michal Vaskoa99b3572021-02-01 11:54:58 +0100237 local_module = start_module;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100238 name = id;
Radek Krejci4f28eda2018-11-12 11:46:16 +0100239
240 /* check for built-in types */
241 *type = lysp_type_str2builtin(name, strlen(name));
242 if (*type) {
243 *tpdf = NULL;
244 return LY_SUCCESS;
245 }
Radek Krejcibbe09a92018-11-08 09:36:54 +0100246 }
Michal Vaskoa99b3572021-02-01 11:54:58 +0100247 LY_CHECK_RET(!local_module, LY_ENOTFOUND);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100248
Michal Vaskoa99b3572021-02-01 11:54:58 +0100249 if (start_node && (local_module == start_module)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100250 /* search typedefs in parent's nodes */
251 *node = start_node;
252 while (*node) {
253 *tpdf = lysp_type_match(name, *node);
254 if (*tpdf) {
255 /* match */
256 return LY_SUCCESS;
257 }
258 *node = (*node)->parent;
259 }
260 }
261
Michal Vasko915e5442021-06-08 14:59:21 +0200262 /* go to main module if in submodule */
263 local_module = local_module->mod->parsed;
264
Radek Krejcibbe09a92018-11-08 09:36:54 +0100265 /* search in top-level typedefs */
Michal Vaskoa99b3572021-02-01 11:54:58 +0100266 if (local_module->typedefs) {
267 LY_ARRAY_FOR(local_module->typedefs, u) {
268 if (!strcmp(name, local_module->typedefs[u].name)) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100269 /* match */
Michal Vaskoa99b3572021-02-01 11:54:58 +0100270 *tpdf = &local_module->typedefs[u];
Radek Krejcibbe09a92018-11-08 09:36:54 +0100271 return LY_SUCCESS;
272 }
273 }
274 }
275
Michal Vasko915e5442021-06-08 14:59:21 +0200276 /* search in all submodules' typedefs */
Michal Vaskoa99b3572021-02-01 11:54:58 +0100277 LY_ARRAY_FOR(local_module->includes, u) {
278 typedefs = local_module->includes[u].submodule->typedefs;
Radek Krejci76b3e962018-12-14 17:01:25 +0100279 LY_ARRAY_FOR(typedefs, v) {
280 if (!strcmp(name, typedefs[v].name)) {
281 /* match */
282 *tpdf = &typedefs[v];
283 return LY_SUCCESS;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100284 }
285 }
286 }
287
288 return LY_ENOTFOUND;
289}
290
David Sedlák6544c182019-07-12 13:17:33 +0200291LY_ERR
David Sedlák07869a52019-07-12 14:28:19 +0200292lysp_check_enum_name(struct lys_parser_ctx *ctx, const char *name, size_t name_len)
David Sedlák6544c182019-07-12 13:17:33 +0200293{
294 if (!name_len) {
295 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not be zero-length.");
296 return LY_EVALID;
297 } else if (isspace(name[0]) || isspace(name[name_len - 1])) {
298 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not have any leading or trailing whitespaces (\"%.*s\").",
Radek Krejci422afb12021-03-04 16:38:16 +0100299 (int)name_len, name);
David Sedlák6544c182019-07-12 13:17:33 +0200300 return LY_EVALID;
301 } else {
302 for (size_t u = 0; u < name_len; ++u) {
303 if (iscntrl(name[u])) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100304 LOGWRN(PARSER_CTX(ctx), "Control characters in enum name should be avoided (\"%.*s\", character number %d).",
Radek Krejci422afb12021-03-04 16:38:16 +0100305 (int)name_len, name, u + 1);
David Sedlák6544c182019-07-12 13:17:33 +0200306 break;
307 }
308 }
309 }
310
311 return LY_SUCCESS;
312}
313
Michal Vaskob36053d2020-03-26 15:49:30 +0100314/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100315 * @brief Check name of a new type to avoid name collisions.
316 *
317 * @param[in] ctx Parser context, module where the type is being defined is taken from here.
318 * @param[in] node Schema node where the type is being defined, NULL in case of a top-level typedef.
319 * @param[in] tpdf Typedef definition to check.
320 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
321 * typedefs are checked, caller is supposed to free the table.
322 * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's
323 * typedefs are checked, caller is supposed to free the table.
324 * @return LY_EEXIST in case of collision, LY_SUCCESS otherwise.
325 */
326static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100327lysp_check_dup_typedef(struct lys_parser_ctx *ctx, struct lysp_node *node, const struct lysp_tpdf *tpdf,
Radek Krejci0f969882020-08-21 16:56:47 +0200328 struct hash_table *tpdfs_global, struct hash_table *tpdfs_scoped)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100329{
330 struct lysp_node *parent;
331 uint32_t hash;
332 size_t name_len;
333 const char *name;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200334 LY_ARRAY_COUNT_TYPE u;
Radek Krejci0fb28562018-12-13 15:17:37 +0100335 const struct lysp_tpdf *typedefs;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100336
337 assert(ctx);
338 assert(tpdf);
339
340 name = tpdf->name;
341 name_len = strlen(name);
342
Radek Krejci4f28eda2018-11-12 11:46:16 +0100343 if (lysp_type_str2builtin(name, name_len)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100344 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 +0100345 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100346 }
347
348 /* check locally scoped typedefs (avoid name shadowing) */
349 if (node) {
Radek Krejci0fb28562018-12-13 15:17:37 +0100350 typedefs = lysp_node_typedefs(node);
351 LY_ARRAY_FOR(typedefs, u) {
352 if (&typedefs[u] == tpdf) {
353 break;
354 }
355 if (!strcmp(name, typedefs[u].name)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100356 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with sibling type.", name);
Radek Krejci0fb28562018-12-13 15:17:37 +0100357 return LY_EEXIST;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100358 }
359 }
360 /* search typedefs in parent's nodes */
Radek Krejci87e78ca2019-05-02 09:51:29 +0200361 for (parent = node->parent; parent; parent = parent->parent) {
Radek Krejcibbe09a92018-11-08 09:36:54 +0100362 if (lysp_type_match(name, parent)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100363 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 +0100364 return LY_EEXIST;
365 }
366 }
367 }
368
369 /* check collision with the top-level typedefs */
370 hash = dict_hash(name, name_len);
371 if (node) {
372 lyht_insert(tpdfs_scoped, &name, hash, NULL);
373 if (!lyht_find(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100374 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 +0100375 return LY_EEXIST;
376 }
377 } else {
378 if (lyht_insert(tpdfs_global, &name, hash, NULL)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100379 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 +0100380 return LY_EEXIST;
381 }
Radek Krejci3b1f9292018-11-08 10:58:35 +0100382 /* it is not necessary to test collision with the scoped types - in lysp_check_typedefs, all the
383 * top-level typedefs are inserted into the tables before the scoped typedefs, so the collision
384 * is detected in the first branch few lines above */
Radek Krejcibbe09a92018-11-08 09:36:54 +0100385 }
386
387 return LY_SUCCESS;
388}
389
Radek Krejci857189e2020-09-01 13:26:36 +0200390/**
391 * @brief Compare identifiers.
Michal Vasko62524a92021-02-26 10:08:50 +0100392 * Implementation of ::lyht_value_equal_cb.
Radek Krejci857189e2020-09-01 13:26:36 +0200393 */
394static ly_bool
395lysp_id_cmp(void *val1, void *val2, ly_bool UNUSED(mod), void *UNUSED(cb_data))
Radek Krejcibbe09a92018-11-08 09:36:54 +0100396{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200397 return strcmp(val1, val2) == 0 ? 1 : 0;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100398}
399
400LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100401lysp_check_dup_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod)
Radek Krejcibbe09a92018-11-08 09:36:54 +0100402{
403 struct hash_table *ids_global;
404 struct hash_table *ids_scoped;
Radek Krejci0fb28562018-12-13 15:17:37 +0100405 const struct lysp_tpdf *typedefs;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200406 LY_ARRAY_COUNT_TYPE u, v;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200407 uint32_t i;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100408 LY_ERR ret = LY_SUCCESS;
Radek Krejcibbe09a92018-11-08 09:36:54 +0100409
410 /* check name collisions - typedefs and groupings */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100411 ids_global = lyht_new(LYHT_MIN_SIZE, sizeof(char *), lysp_id_cmp, NULL, 1);
412 ids_scoped = lyht_new(LYHT_MIN_SIZE, sizeof(char *), lysp_id_cmp, NULL, 1);
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200413 LY_ARRAY_FOR(mod->typedefs, v) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100414 ret = lysp_check_dup_typedef(ctx, NULL, &mod->typedefs[v], ids_global, ids_scoped);
415 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100416 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200417 LY_ARRAY_FOR(mod->includes, v) {
418 LY_ARRAY_FOR(mod->includes[v].submodule->typedefs, u) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100419 ret = lysp_check_dup_typedef(ctx, NULL, &mod->includes[v].submodule->typedefs[u], ids_global, ids_scoped);
420 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci3b1f9292018-11-08 10:58:35 +0100421 }
422 }
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200423 for (i = 0; i < ctx->tpdfs_nodes.count; ++i) {
424 typedefs = lysp_node_typedefs((struct lysp_node *)ctx->tpdfs_nodes.objs[i]);
425 LY_ARRAY_FOR(typedefs, u) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100426 ret = lysp_check_dup_typedef(ctx, (struct lysp_node *)ctx->tpdfs_nodes.objs[i], &typedefs[u], ids_global, ids_scoped);
427 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100428 }
429 }
Michal Vasko405cc9e2020-12-01 12:01:27 +0100430
Radek Krejcibbe09a92018-11-08 09:36:54 +0100431cleanup:
432 lyht_free(ids_global);
433 lyht_free(ids_scoped);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100434 return ret;
435}
436
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100437static ly_bool
438ly_ptrequal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
439{
440 void *ptr1 = *((void **)val1_p), *ptr2 = *((void **)val2_p);
441
442 return ptr1 == ptr2 ? 1 : 0;
443}
444
445LY_ERR
446lysp_check_dup_features(struct lys_parser_ctx *ctx, struct lysp_module *mod)
447{
448 LY_ARRAY_COUNT_TYPE u;
449 struct hash_table *ht;
450 struct lysp_feature *f;
451 uint32_t hash;
452 LY_ERR ret = LY_SUCCESS, r;
453
454 ht = lyht_new(1, sizeof(void *), ly_ptrequal_cb, NULL, 1);
455 LY_CHECK_RET(!ht, LY_EMEM);
456
457 /* add all module features into a hash table */
458 LY_ARRAY_FOR(mod->features, struct lysp_feature, f) {
459 hash = dict_hash(f->name, strlen(f->name));
460 r = lyht_insert(ht, &f->name, hash, NULL);
461 if (r == LY_EEXIST) {
462 LOGVAL_PARSER(ctx, LY_VCODE_DUPIDENT, f->name, "feature");
463 ret = LY_EVALID;
464 goto cleanup;
465 } else if (r) {
466 ret = r;
467 goto cleanup;
468 }
469 }
470
471 /* add all submodule features into a hash table */
472 LY_ARRAY_FOR(mod->includes, u) {
473 LY_ARRAY_FOR(mod->includes[u].submodule->features, struct lysp_feature, f) {
474 hash = dict_hash(f->name, strlen(f->name));
475 r = lyht_insert(ht, &f->name, hash, NULL);
476 if (r == LY_EEXIST) {
477 LOGVAL_PARSER(ctx, LY_VCODE_DUPIDENT, f->name, "feature");
478 ret = LY_EVALID;
479 goto cleanup;
480 } else if (r) {
481 ret = r;
482 goto cleanup;
483 }
484 }
485 }
486
487cleanup:
488 lyht_free(ht);
489 return ret;
490}
491
492LY_ERR
493lysp_check_dup_identities(struct lys_parser_ctx *ctx, struct lysp_module *mod)
494{
495 LY_ARRAY_COUNT_TYPE u;
496 struct hash_table *ht;
497 struct lysp_ident *i;
498 uint32_t hash;
499 LY_ERR ret = LY_SUCCESS, r;
500
501 ht = lyht_new(1, sizeof(void *), ly_ptrequal_cb, NULL, 1);
502 LY_CHECK_RET(!ht, LY_EMEM);
503
504 /* add all module identities into a hash table */
505 LY_ARRAY_FOR(mod->identities, struct lysp_ident, i) {
506 hash = dict_hash(i->name, strlen(i->name));
507 r = lyht_insert(ht, &i->name, hash, NULL);
508 if (r == LY_EEXIST) {
509 LOGVAL_PARSER(ctx, LY_VCODE_DUPIDENT, i->name, "identity");
510 ret = LY_EVALID;
511 goto cleanup;
512 } else if (r) {
513 ret = r;
514 goto cleanup;
515 }
516 }
517
518 /* add all submodule identities into a hash table */
519 LY_ARRAY_FOR(mod->includes, u) {
520 LY_ARRAY_FOR(mod->includes[u].submodule->identities, struct lysp_ident, i) {
521 hash = dict_hash(i->name, strlen(i->name));
522 r = lyht_insert(ht, &i->name, hash, NULL);
523 if (r == LY_EEXIST) {
524 LOGVAL_PARSER(ctx, LY_VCODE_DUPIDENT, i->name, "identity");
525 ret = LY_EVALID;
526 goto cleanup;
527 } else if (r) {
528 ret = r;
529 goto cleanup;
530 }
531 }
532 }
533
534cleanup:
535 lyht_free(ht);
536 return ret;
537}
538
Radek Krejci9ed7a192018-10-31 16:23:51 +0100539struct lysp_load_module_check_data {
540 const char *name;
541 const char *revision;
542 const char *path;
Michal Vasko22df3f02020-08-24 13:29:22 +0200543 const char *submoduleof;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100544};
545
546static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100547lysp_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 +0100548{
549 struct lysp_load_module_check_data *info = data;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100550 const char *filename, *dot, *rev, *name;
Radek Krejcib3289d62019-09-18 12:21:39 +0200551 uint8_t latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100552 size_t len;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100553 struct lysp_revision *revs;
554
555 name = mod ? mod->mod->name : submod->name;
556 revs = mod ? mod->revs : submod->revs;
Radek Krejcib3289d62019-09-18 12:21:39 +0200557 latest_revision = mod ? mod->mod->latest_revision : submod->latest_revision;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100558
559 if (info->name) {
560 /* check name of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100561 if (strcmp(info->name, name)) {
562 LOGERR(ctx, LY_EINVAL, "Unexpected module \"%s\" parsed instead of \"%s\").", name, info->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100563 return LY_EINVAL;
564 }
565 }
566 if (info->revision) {
567 /* check revision of the parsed model */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100568 if (!revs || strcmp(info->revision, revs[0].date)) {
569 LOGERR(ctx, LY_EINVAL, "Module \"%s\" parsed with the wrong revision (\"%s\" instead \"%s\").", name,
Michal Vasko69730152020-10-09 16:30:07 +0200570 revs ? revs[0].date : "none", info->revision);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100571 return LY_EINVAL;
572 }
Radek Krejcib3289d62019-09-18 12:21:39 +0200573 } else if (!latest_revision) {
574 /* do not log, we just need to drop the schema and use the latest revision from the context */
575 return LY_EEXIST;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100576 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100577 if (submod) {
578 assert(info->submoduleof);
579
Radek Krejci9ed7a192018-10-31 16:23:51 +0100580 /* check that the submodule belongs-to our module */
Michal Vaskoc3781c32020-10-06 14:04:08 +0200581 if (strcmp(info->submoduleof, submod->mod->name)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100582 LOGVAL(ctx, LYVE_REFERENCE, "Included \"%s\" submodule from \"%s\" belongs-to a different module \"%s\".",
Michal Vasko69730152020-10-09 16:30:07 +0200583 submod->name, info->submoduleof, submod->mod->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100584 return LY_EVALID;
585 }
586 /* check circular dependency */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100587 if (submod->parsing) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100588 LOGVAL(ctx, LYVE_REFERENCE, "A circular dependency (include) for module \"%s\".", submod->name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100589 return LY_EVALID;
590 }
591 }
592 if (info->path) {
593 /* check that name and revision match filename */
594 filename = strrchr(info->path, '/');
595 if (!filename) {
596 filename = info->path;
597 } else {
598 filename++;
599 }
600 /* name */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100601 len = strlen(name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100602 rev = strchr(filename, '@');
603 dot = strrchr(info->path, '.');
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100604 if (strncmp(filename, name, len) ||
Michal Vasko69730152020-10-09 16:30:07 +0200605 ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100606 LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, name);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100607 }
608 /* revision */
609 if (rev) {
610 len = dot - ++rev;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100611 if (!revs || (len != LY_REV_SIZE - 1) || strncmp(revs[0].date, rev, len)) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100612 LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename,
Michal Vasko69730152020-10-09 16:30:07 +0200613 revs ? revs[0].date : "none");
Radek Krejci9ed7a192018-10-31 16:23:51 +0100614 }
615 }
616 }
617 return LY_SUCCESS;
618}
619
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200620/**
Michal Vasko4e205e82021-06-08 14:01:47 +0200621 * @brief Parse a (sub)module from a local file and add into the context.
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200622 *
623 * This function does not check the presence of the (sub)module in context, it should be done before calling this function.
624 *
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200625 * @param[in] ctx libyang context where to work.
626 * @param[in] name Name of the (sub)module to load.
627 * @param[in] revision Optional revision of the (sub)module to load, if NULL the newest revision is being loaded.
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200628 * @param[in] main_ctx Parser context of the main module in case of loading submodule.
629 * @param[in] main_name Main module name in case of loading submodule.
630 * @param[in] required Module is required so error (even if the input file not found) are important. If 0, there is some
631 * backup and it is actually ok if the input data are not found. However, parser reports errors even in this case.
Michal Vaskodd992582021-06-10 14:34:57 +0200632 * @param[in,out] new_mods Set of all the new mods added to the context. Includes this module and all of its imports.
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200633 * @param[out] result Parsed YANG schema tree of the requested module (struct lys_module*) or submodule (struct lysp_submodule*).
634 * If it is a module, it is already in the context!
Michal Vasko4e205e82021-06-08 14:01:47 +0200635 * @return LY_SUCCESS on success.
Michal Vasko4e205e82021-06-08 14:01:47 +0200636 * @return LY_ERR on error.
Michal Vaskoe7a1daf2021-04-19 18:04:27 +0200637 */
638static LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +0200639lys_parse_localfile(struct ly_ctx *ctx, const char *name, const char *revision, struct lys_parser_ctx *main_ctx,
Michal Vaskodd992582021-06-10 14:34:57 +0200640 const char *main_name, ly_bool required, struct ly_set *new_mods, void **result)
Radek Krejci9ed7a192018-10-31 16:23:51 +0100641{
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200642 struct ly_in *in;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100643 char *filepath = NULL;
644 LYS_INFORMAT format;
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100645 void *mod = NULL;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100646 LY_ERR ret = LY_SUCCESS;
647 struct lysp_load_module_check_data check_data = {0};
648
Michal Vasko87f1cf02021-06-08 14:02:47 +0200649 LY_CHECK_RET(lys_search_localfile(ly_ctx_get_searchdirs(ctx), !(ctx->flags & LY_CTX_DISABLE_SEARCHDIR_CWD), name,
650 revision, &filepath, &format));
Michal Vasko3a41dff2020-07-15 14:30:28 +0200651 if (!filepath) {
652 if (required) {
653 LOGERR(ctx, LY_ENOTFOUND, "Data model \"%s%s%s\" not found in local searchdirs.", name, revision ? "@" : "",
Michal Vasko69730152020-10-09 16:30:07 +0200654 revision ? revision : "");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200655 }
656 return LY_ENOTFOUND;
657 }
Radek Krejci9ed7a192018-10-31 16:23:51 +0100658
659 LOGVRB("Loading schema from \"%s\" file.", filepath);
660
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200661 /* get the (sub)module */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200662 LY_CHECK_ERR_GOTO(ret = ly_in_new_filepath(filepath, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +0200663 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", filepath), cleanup);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100664 check_data.name = name;
665 check_data.revision = revision;
666 check_data.path = filepath;
fredgancd485b82019-10-18 15:00:17 +0800667 check_data.submoduleof = main_name;
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200668 if (main_ctx) {
Michal Vasko7a0b0762020-09-02 16:37:01 +0200669 ret = lys_parse_submodule(ctx, in, format, main_ctx, lysp_load_module_check, &check_data,
Michal Vasko69730152020-10-09 16:30:07 +0200670 (struct lysp_submodule **)&mod);
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200671 } else {
Michal Vaskodd992582021-06-10 14:34:57 +0200672 ret = lys_parse_in(ctx, in, format, lysp_load_module_check, &check_data, new_mods, (struct lys_module **)&mod);
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200673
674 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +0200675 ly_in_free(in, 1);
Michal Vasko7a0b0762020-09-02 16:37:01 +0200676 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9ed7a192018-10-31 16:23:51 +0100677
678 *result = mod;
679
680 /* success */
Michal Vasko7a0b0762020-09-02 16:37:01 +0200681
Radek Krejci9ed7a192018-10-31 16:23:51 +0100682cleanup:
683 free(filepath);
684 return ret;
685}
686
Radek Krejcid33273d2018-10-25 14:55:52 +0200687LY_ERR
Michal Vaskodd992582021-06-10 14:34:57 +0200688lys_parse_load(struct ly_ctx *ctx, const char *name, const char *revision, struct ly_set *new_mods,
Michal Vasko4e205e82021-06-08 14:01:47 +0200689 struct lys_module **mod)
Radek Krejci086c7132018-10-26 15:29:04 +0200690{
Radek Krejci9ed7a192018-10-31 16:23:51 +0100691 const char *module_data = NULL;
Radek Krejci086c7132018-10-26 15:29:04 +0200692 LYS_INFORMAT format = LYS_IN_UNKNOWN;
Michal Vasko69730152020-10-09 16:30:07 +0200693
Radek Krejci9ed7a192018-10-31 16:23:51 +0100694 void (*module_data_free)(void *module_data, void *user_data) = NULL;
695 struct lysp_load_module_check_data check_data = {0};
Michal Vasko4e205e82021-06-08 14:01:47 +0200696 struct lys_module *ctx_latest = NULL;
Michal Vasko63f3d842020-07-08 10:10:14 +0200697 struct ly_in *in;
Radek Krejci086c7132018-10-26 15:29:04 +0200698
Michal Vaskodd992582021-06-10 14:34:57 +0200699 assert(mod && new_mods);
Radek Krejci0af46292019-01-11 16:02:31 +0100700
Michal Vasko0550b762020-11-24 18:04:08 +0100701 /*
702 * try to get the module from the context
703 */
Radek Krejci0af46292019-01-11 16:02:31 +0100704 if (!*mod) {
Radek Krejci0af46292019-01-11 16:02:31 +0100705 if (revision) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200706 /* get the specific revision */
Michal Vasko22df3f02020-08-24 13:29:22 +0200707 *mod = (struct lys_module *)ly_ctx_get_module(ctx, name, revision);
Radek Krejci0af46292019-01-11 16:02:31 +0100708 } else {
Michal Vasko4e205e82021-06-08 14:01:47 +0200709 /* get the requested module of the latest revision in the context */
710 *mod = (struct lys_module *)ly_ctx_get_module_latest(ctx, name);
711 if (*mod && ((*mod)->latest_revision == 1)) {
712 /* let us now search with callback and searchpaths to check if there is newer revision outside the context */
713 ctx_latest = *mod;
714 *mod = NULL;
Radek Krejcib3289d62019-09-18 12:21:39 +0200715 }
Radek Krejci0af46292019-01-11 16:02:31 +0100716 }
Radek Krejci086c7132018-10-26 15:29:04 +0200717 }
718
Michal Vasko4e205e82021-06-08 14:01:47 +0200719 /* we have module from the current context, circular check */
720 if (*mod && (*mod)->parsed->parsing) {
721 LOGVAL(ctx, LYVE_REFERENCE, "A circular dependency (import) for module \"%s\".", name);
722 *mod = NULL;
723 return LY_EVALID;
Michal Vasko0550b762020-11-24 18:04:08 +0100724 }
Radek Krejci086c7132018-10-26 15:29:04 +0200725
Michal Vasko0550b762020-11-24 18:04:08 +0100726 /*
727 * no suitable module in the context, try to load it
728 */
729 if (!*mod) {
Radek Krejci9ed7a192018-10-31 16:23:51 +0100730 /* module not present in the context, get the input data and parse it */
Radek Krejci086c7132018-10-26 15:29:04 +0200731 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
732search_clb:
Michal Vasko87f1cf02021-06-08 14:02:47 +0200733 if (ctx->imp_clb && !ctx->imp_clb(name, revision, NULL, NULL, ctx->imp_clb_data, &format, &module_data,
734 &module_data_free)) {
735 LY_CHECK_RET(ly_in_new_memory(module_data, &in));
736 check_data.name = name;
737 check_data.revision = revision;
Michal Vaskodd992582021-06-10 14:34:57 +0200738 lys_parse_in(ctx, in, format, lysp_load_module_check, &check_data, new_mods, mod);
Michal Vasko87f1cf02021-06-08 14:02:47 +0200739 ly_in_free(in, 0);
740 if (module_data_free) {
741 module_data_free((void *)module_data, ctx->imp_clb_data);
Radek Krejci086c7132018-10-26 15:29:04 +0200742 }
743 }
744 if (!(*mod) && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
745 goto search_file;
746 }
747 } else {
748search_file:
749 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
750 /* module was not received from the callback or there is no callback set */
Michal Vaskodd992582021-06-10 14:34:57 +0200751 lys_parse_localfile(ctx, name, revision, NULL, NULL, ctx_latest ? 0 : 1, new_mods, (void **)mod);
Radek Krejci086c7132018-10-26 15:29:04 +0200752 }
Michal Vasko0550b762020-11-24 18:04:08 +0100753 if (!*mod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejci086c7132018-10-26 15:29:04 +0200754 goto search_clb;
755 }
756 }
Radek Krejci9ed7a192018-10-31 16:23:51 +0100757
Radek Krejcib3289d62019-09-18 12:21:39 +0200758 /* update the latest_revision flag - here we have selected the latest available schema,
759 * consider that even the callback provides correct latest revision */
Michal Vasko0550b762020-11-24 18:04:08 +0100760 if (!*mod && ctx_latest) {
Michal Vasko003c44a2021-02-24 17:13:11 +0100761 LOGVRB("Newer revision than \"%s@%s\" not found, using this as the latest revision.", ctx_latest->name,
Michal Vasko0550b762020-11-24 18:04:08 +0100762 ctx_latest->revision);
763 ctx_latest->latest_revision = 2;
764 *mod = ctx_latest;
765 } else if (*mod && !revision && ((*mod)->latest_revision == 1)) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100766 (*mod)->latest_revision = 2;
Radek Krejci9ed7a192018-10-31 16:23:51 +0100767 }
Radek Krejci086c7132018-10-26 15:29:04 +0200768
Michal Vasko0550b762020-11-24 18:04:08 +0100769 if (!*mod) {
Michal Vasko4e205e82021-06-08 14:01:47 +0200770 LOGVAL(ctx, LYVE_REFERENCE, "Loading \"%s\" module failed.", name);
Michal Vasko0550b762020-11-24 18:04:08 +0100771 return LY_EVALID;
772 }
Radek Krejci086c7132018-10-26 15:29:04 +0200773 }
Radek Krejci086c7132018-10-26 15:29:04 +0200774
775 return LY_SUCCESS;
776}
777
778LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200779lysp_check_stringchar(struct lys_parser_ctx *ctx, uint32_t c)
David Sedlák4a650532019-07-10 11:55:18 +0200780{
781 if (!is_yangutf8char(c)) {
782 LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, c);
783 return LY_EVALID;
784 }
785 return LY_SUCCESS;
786}
787
788LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200789lysp_check_identifierchar(struct lys_parser_ctx *ctx, uint32_t c, ly_bool first, uint8_t *prefix)
David Sedlák4a650532019-07-10 11:55:18 +0200790{
Michal Vasko69730152020-10-09 16:30:07 +0200791 if (first || (prefix && ((*prefix) == 1))) {
David Sedlák4a650532019-07-10 11:55:18 +0200792 if (!is_yangidentstartchar(c)) {
aPiecekc89b2242021-05-14 14:19:11 +0200793 if ((c < UCHAR_MAX) && isprint(c)) {
Michal Vasko7c769042021-03-25 12:20:49 +0100794 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '%c' (0x%04x).", (char)c, c);
795 } else {
796 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character 0x%04x.", c);
797 }
David Sedlák4a650532019-07-10 11:55:18 +0200798 return LY_EVALID;
799 }
800 if (prefix) {
801 if (first) {
802 (*prefix) = 0;
803 } else {
804 (*prefix) = 2;
805 }
806 }
Michal Vasko69730152020-10-09 16:30:07 +0200807 } else if ((c == ':') && prefix && ((*prefix) == 0)) {
David Sedlák4a650532019-07-10 11:55:18 +0200808 (*prefix) = 1;
809 } else if (!is_yangidentchar(c)) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200810 LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier character '%c' (0x%04x).", (char)c, c);
David Sedlák4a650532019-07-10 11:55:18 +0200811 return LY_EVALID;
812 }
813
814 return LY_SUCCESS;
815}
816
Radek Krejci771928a2021-01-19 13:42:36 +0100817/**
818 * @brief Try to find the parsed submodule in main module for the given include record.
819 *
820 * @param[in] pctx main parser context
821 * @param[in] inc The include record with missing parsed submodule. According to include info try to find
822 * the corresponding parsed submodule in main module's includes.
823 * @return LY_SUCCESS - the parsed submodule was found and inserted into the @p inc record
824 * @return LY_ENOT - the parsed module was not found.
825 * @return LY_EVALID - YANG rule violation
826 */
827static LY_ERR
828lysp_get_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
Radek Krejcid33273d2018-10-25 14:55:52 +0200829{
Radek Krejci771928a2021-01-19 13:42:36 +0100830 LY_ARRAY_COUNT_TYPE i;
831 struct lysp_module *main_pmod = pctx->parsed_mod->mod->parsed;
Michal Vasko69730152020-10-09 16:30:07 +0200832
Radek Krejci771928a2021-01-19 13:42:36 +0100833 LY_ARRAY_FOR(main_pmod->includes, i) {
834 if (strcmp(main_pmod->includes[i].name, inc->name)) {
835 continue;
836 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200837
Radek Krejci771928a2021-01-19 13:42:36 +0100838 if (inc->rev[0] && strncmp(inc->rev, main_pmod->includes[i].rev, LY_REV_SIZE)) {
839 LOGVAL(PARSER_CTX(pctx), LYVE_REFERENCE,
840 "Submodule %s includes different revision (%s) of the submodule %s:%s included by the main module %s.",
841 ((struct lysp_submodule *)pctx->parsed_mod)->name, inc->rev,
842 main_pmod->includes[i].name, main_pmod->includes[i].rev, main_pmod->mod->name);
843 return LY_EVALID;
844 }
845
846 inc->submodule = main_pmod->includes[i].submodule;
847 return inc->submodule ? LY_SUCCESS : LY_ENOT;
848 }
849
850 if (main_pmod->version == LYS_VERSION_1_1) {
851 LOGVAL(PARSER_CTX(pctx), LYVE_REFERENCE,
852 "YANG 1.1 requires all submodules to be included from main module. "
853 "But submodule \"%s\" includes submodule \"%s\" which is not included by main module \"%s\".",
854 ((struct lysp_submodule *)pctx->parsed_mod)->name, inc->name, main_pmod->mod->name);
855 return LY_EVALID;
856 } else {
857 return LY_ENOT;
858 }
859}
860
861/**
862 * @brief Make the copy of the given include record into the main module.
863 *
864 * YANG 1.0 does not require the main module to include all the submodules. Therefore, parsing submodules can cause
865 * reallocating and extending the includes array in the main module by the submodules included only in submodules.
866 *
867 * @param[in] pctx main parser context
868 * @param[in] inc Include record to copy into main module taken from @p pctx.
869 * @return LY_ERR value.
870 */
871static LY_ERR
872lysp_inject_submodule(struct lys_parser_ctx *pctx, struct lysp_include *inc)
873{
874 LY_ARRAY_COUNT_TYPE i;
875 struct lysp_include *inc_new, *inc_tofill = NULL;
876 struct lysp_module *main_pmod = pctx->parsed_mod->mod->parsed;
877
878 /* first, try to find the corresponding record with missing parsed submodule */
879 LY_ARRAY_FOR(main_pmod->includes, i) {
880 if (strcmp(main_pmod->includes[i].name, inc->name)) {
881 continue;
882 }
883 inc_tofill = &main_pmod->includes[i];
884 break;
885 }
886
887 if (inc_tofill) {
888 inc_tofill->submodule = inc->submodule;
889 } else {
890 LY_ARRAY_NEW_RET(PARSER_CTX(pctx), main_pmod->includes, inc_new, LY_EMEM);
891
892 inc_new->submodule = inc->submodule;
893 DUP_STRING_RET(PARSER_CTX(pctx), inc->name, inc_new->name);
894 DUP_STRING_RET(PARSER_CTX(pctx), inc->dsc, inc_new->dsc);
895 DUP_STRING_RET(PARSER_CTX(pctx), inc->ref, inc_new->ref);
896 /* TODO duplicate extensions */
897 memcpy(inc_new->rev, inc->rev, LY_REV_SIZE);
898 inc_new->injected = 1;
899 }
900 return LY_SUCCESS;
901}
902
903LY_ERR
904lysp_load_submodules(struct lys_parser_ctx *pctx, struct lysp_module *pmod)
905{
906 LY_ARRAY_COUNT_TYPE u;
907 struct ly_ctx *ctx = PARSER_CTX(pctx);
908
909 LY_ARRAY_FOR(pmod->includes, u) {
910 LY_ERR ret = LY_SUCCESS;
911 struct lysp_submodule *submod = NULL;
912 struct lysp_include *inc = &pmod->includes[u];
913
914 if (inc->submodule) {
915 continue;
916 }
917
918 if (pmod->is_submod) {
919 /* try to find the submodule in the main module or its submodules */
920 ret = lysp_get_submodule(pctx, inc);
921 LY_CHECK_RET(ret && ret != LY_ENOT, ret);
922 LY_CHECK_RET(ret == LY_SUCCESS, LY_SUCCESS); /* submodule found in linked with the inc */
923 }
924
925 /* submodule not present in the main module, get the input data and parse it */
926 if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
Radek Krejcidf549132021-01-21 10:32:32 +0100927search_clb:
Radek Krejci771928a2021-01-19 13:42:36 +0100928 if (ctx->imp_clb) {
929 const char *submodule_data = NULL;
930 LYS_INFORMAT format = LYS_IN_UNKNOWN;
931 void (*submodule_data_free)(void *module_data, void *user_data) = NULL;
932 struct lysp_load_module_check_data check_data = {0};
933 struct ly_in *in;
934
935 if (ctx->imp_clb(pctx->parsed_mod->mod->name, NULL, inc->name,
936 inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data,
937 &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) {
938 LY_CHECK_RET(ly_in_new_memory(submodule_data, &in));
939 check_data.name = inc->name;
940 check_data.revision = inc->rev[0] ? inc->rev : NULL;
941 check_data.submoduleof = pctx->parsed_mod->mod->name;
942 lys_parse_submodule(ctx, in, format, pctx, lysp_load_module_check, &check_data, &submod);
943
944 /* update inc pointer - parsing another (YANG 1.0) submodule can cause injecting
945 * submodule's include into main module, where it is missing */
946 inc = &pmod->includes[u];
947
948 ly_in_free(in, 0);
949 if (submodule_data_free) {
950 submodule_data_free((void *)submodule_data, ctx->imp_clb_data);
951 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200952 }
953 }
Radek Krejci771928a2021-01-19 13:42:36 +0100954 if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
955 goto search_file;
956 }
957 } else {
Radek Krejcidf549132021-01-21 10:32:32 +0100958search_file:
Radek Krejci771928a2021-01-19 13:42:36 +0100959 if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) {
960 /* submodule was not received from the callback or there is no callback set */
Michal Vasko4e205e82021-06-08 14:01:47 +0200961 lys_parse_localfile(ctx, inc->name, inc->rev[0] ? inc->rev : NULL, pctx,
Radek Krejci771928a2021-01-19 13:42:36 +0100962 pctx->parsed_mod->mod->name, 1, NULL, (void **)&submod);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100963
Radek Krejci771928a2021-01-19 13:42:36 +0100964 /* update inc pointer - parsing another (YANG 1.0) submodule can cause injecting
965 * submodule's include into main module, where it is missing */
966 inc = &pmod->includes[u];
967 }
968 if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) {
969 goto search_clb;
970 }
971 }
972 if (submod) {
973 if (!inc->rev[0] && (submod->latest_revision == 1)) {
974 /* update the latest_revision flag - here we have selected the latest available schema,
975 * consider that even the callback provides correct latest revision */
976 submod->latest_revision = 2;
977 }
978
979 inc->submodule = submod;
980 if (ret == LY_ENOT) {
981 /* the submodule include is not present in YANG 1.0 main module - add it there */
982 LY_CHECK_RET(lysp_inject_submodule(pctx, &pmod->includes[u]));
983 }
984 }
985 if (!inc->submodule) {
986 LOGVAL(ctx, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.", inc->name,
987 pctx->parsed_mod->is_submod ? ((struct lysp_submodule *)pctx->parsed_mod)->name : pctx->parsed_mod->mod->name);
988 return LY_EVALID;
989 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200990 }
991
992 return LY_SUCCESS;
993}
994
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100995API const struct lysc_when *
996lysc_has_when(const struct lysc_node *node)
997{
Radek Krejci9a3823e2021-01-27 20:26:46 +0100998 struct lysc_when **when;
999
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01001000 if (!node) {
1001 return NULL;
1002 }
1003
1004 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001005 when = lysc_node_when(node);
1006 if (when) {
1007 return when[0];
Michal Vaskod5cfa6e2020-11-23 16:56:08 +01001008 }
1009 node = node->parent;
1010 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
1011
1012 return NULL;
1013}
1014
Radek Krejci0935f412019-08-20 16:15:18 +02001015API const char *
Radek Krejcia3045382018-11-22 14:30:31 +01001016lys_nodetype2str(uint16_t nodetype)
1017{
Michal Vaskod989ba02020-08-24 10:59:24 +02001018 switch (nodetype) {
Radek Krejcia3045382018-11-22 14:30:31 +01001019 case LYS_CONTAINER:
1020 return "container";
1021 case LYS_CHOICE:
1022 return "choice";
1023 case LYS_LEAF:
1024 return "leaf";
1025 case LYS_LEAFLIST:
1026 return "leaf-list";
1027 case LYS_LIST:
1028 return "list";
1029 case LYS_ANYXML:
1030 return "anyxml";
1031 case LYS_ANYDATA:
1032 return "anydata";
Radek Krejcif12a1f02019-02-11 16:42:08 +01001033 case LYS_CASE:
1034 return "case";
Michal Vasko1bf09392020-03-27 12:38:10 +01001035 case LYS_RPC:
1036 return "RPC";
Radek Krejcif538ce52019-03-05 10:46:14 +01001037 case LYS_ACTION:
Michal Vasko1bf09392020-03-27 12:38:10 +01001038 return "action";
Radek Krejcif538ce52019-03-05 10:46:14 +01001039 case LYS_NOTIF:
Michal Vaskoa3881362020-01-21 15:57:35 +01001040 return "notification";
Radek Krejcifc81ea82019-04-18 13:27:22 +02001041 case LYS_USES:
1042 return "uses";
Radek Krejcia3045382018-11-22 14:30:31 +01001043 default:
1044 return "unknown";
1045 }
1046}
1047
Radek Krejci39b7fc22021-02-26 23:29:18 +01001048API enum ly_stmt
1049lys_nodetype2stmt(uint16_t nodetype)
1050{
1051 switch (nodetype) {
1052 case LYS_CONTAINER:
1053 return LY_STMT_CONTAINER;
1054 case LYS_CHOICE:
1055 return LY_STMT_CHOICE;
1056 case LYS_LEAF:
1057 return LY_STMT_LEAF;
1058 case LYS_LEAFLIST:
1059 return LY_STMT_LEAF_LIST;
1060 case LYS_LIST:
1061 return LY_STMT_LIST;
1062 case LYS_ANYXML:
1063 return LY_STMT_ANYXML;
1064 case LYS_ANYDATA:
1065 return LY_STMT_ANYDATA;
1066 case LYS_CASE:
1067 return LY_STMT_CASE;
1068 case LYS_RPC:
1069 return LY_STMT_RPC;
1070 case LYS_ACTION:
1071 return LY_STMT_ACTION;
1072 case LYS_NOTIF:
1073 return LY_STMT_NOTIFICATION;
1074 case LYS_USES:
1075 return LY_STMT_USES;
1076 case LYS_INPUT:
1077 return LY_STMT_INPUT;
1078 case LYS_OUTPUT:
1079 return LY_STMT_OUTPUT;
1080 default:
1081 return LY_STMT_NONE;
1082 }
1083}
1084
Radek Krejci693262f2019-04-29 15:23:20 +02001085const char *
1086lys_datatype2str(LY_DATA_TYPE basetype)
1087{
Michal Vaskod989ba02020-08-24 10:59:24 +02001088 switch (basetype) {
Radek Krejci693262f2019-04-29 15:23:20 +02001089 case LY_TYPE_BINARY:
1090 return "binary";
1091 case LY_TYPE_UINT8:
1092 return "uint8";
1093 case LY_TYPE_UINT16:
1094 return "uint16";
1095 case LY_TYPE_UINT32:
1096 return "uint32";
1097 case LY_TYPE_UINT64:
1098 return "uint64";
1099 case LY_TYPE_STRING:
1100 return "string";
1101 case LY_TYPE_BITS:
1102 return "bits";
1103 case LY_TYPE_BOOL:
1104 return "boolean";
1105 case LY_TYPE_DEC64:
1106 return "decimal64";
1107 case LY_TYPE_EMPTY:
1108 return "empty";
1109 case LY_TYPE_ENUM:
1110 return "enumeration";
1111 case LY_TYPE_IDENT:
1112 return "identityref";
1113 case LY_TYPE_INST:
1114 return "instance-identifier";
1115 case LY_TYPE_LEAFREF:
1116 return "leafref";
1117 case LY_TYPE_UNION:
1118 return "union";
1119 case LY_TYPE_INT8:
1120 return "int8";
1121 case LY_TYPE_INT16:
1122 return "int16";
1123 case LY_TYPE_INT32:
1124 return "int32";
1125 case LY_TYPE_INT64:
1126 return "int64";
1127 default:
1128 return "unknown";
1129 }
1130}
1131
Radek Krejci056d0a82018-12-06 16:57:25 +01001132API const struct lysp_tpdf *
1133lysp_node_typedefs(const struct lysp_node *node)
1134{
Radek Krejci0fb28562018-12-13 15:17:37 +01001135 switch (node->nodetype) {
1136 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001137 return ((struct lysp_node_container *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001138 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001139 return ((struct lysp_node_list *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001140 case LYS_GROUPING:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001141 return ((struct lysp_node_grp *)node)->typedefs;
Michal Vasko1bf09392020-03-27 12:38:10 +01001142 case LYS_RPC:
Radek Krejci0fb28562018-12-13 15:17:37 +01001143 case LYS_ACTION:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001144 return ((struct lysp_node_action *)node)->typedefs;
Michal Vasko7f45cf22020-10-01 12:49:44 +02001145 case LYS_INPUT:
1146 case LYS_OUTPUT:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001147 return ((struct lysp_node_action_inout *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001148 case LYS_NOTIF:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001149 return ((struct lysp_node_notif *)node)->typedefs;
Radek Krejci0fb28562018-12-13 15:17:37 +01001150 default:
Radek Krejci056d0a82018-12-06 16:57:25 +01001151 return NULL;
1152 }
1153}
1154
Radek Krejci2a9fc652021-01-22 17:44:34 +01001155API const struct lysp_node_grp *
Radek Krejci53ea6152018-12-13 15:21:15 +01001156lysp_node_groupings(const struct lysp_node *node)
1157{
1158 switch (node->nodetype) {
1159 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001160 return ((struct lysp_node_container *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001161 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001162 return ((struct lysp_node_list *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001163 case LYS_GROUPING:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001164 return ((struct lysp_node_grp *)node)->groupings;
Michal Vasko1bf09392020-03-27 12:38:10 +01001165 case LYS_RPC:
Radek Krejci53ea6152018-12-13 15:21:15 +01001166 case LYS_ACTION:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001167 return ((struct lysp_node_action *)node)->groupings;
Michal Vasko7f45cf22020-10-01 12:49:44 +02001168 case LYS_INPUT:
1169 case LYS_OUTPUT:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001170 return ((struct lysp_node_action_inout *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001171 case LYS_NOTIF:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001172 return ((struct lysp_node_notif *)node)->groupings;
Radek Krejci53ea6152018-12-13 15:21:15 +01001173 default:
1174 return NULL;
1175 }
1176}
1177
Radek Krejci2a9fc652021-01-22 17:44:34 +01001178struct lysp_node_action **
Radek Krejci056d0a82018-12-06 16:57:25 +01001179lysp_node_actions_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001180{
1181 assert(node);
Michal Vasko7f45cf22020-10-01 12:49:44 +02001182
Radek Krejcibbe09a92018-11-08 09:36:54 +01001183 switch (node->nodetype) {
1184 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001185 return &((struct lysp_node_container *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001186 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001187 return &((struct lysp_node_list *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001188 case LYS_GROUPING:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001189 return &((struct lysp_node_grp *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001190 case LYS_AUGMENT:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001191 return &((struct lysp_node_augment *)node)->actions;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001192 default:
1193 return NULL;
1194 }
1195}
1196
Radek Krejci2a9fc652021-01-22 17:44:34 +01001197API const struct lysp_node_action *
Radek Krejci056d0a82018-12-06 16:57:25 +01001198lysp_node_actions(const struct lysp_node *node)
1199{
Radek Krejci2a9fc652021-01-22 17:44:34 +01001200 struct lysp_node_action **actions;
Michal Vasko69730152020-10-09 16:30:07 +02001201
Michal Vasko22df3f02020-08-24 13:29:22 +02001202 actions = lysp_node_actions_p((struct lysp_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001203 if (actions) {
1204 return *actions;
1205 } else {
1206 return NULL;
1207 }
1208}
1209
Radek Krejci2a9fc652021-01-22 17:44:34 +01001210struct lysp_node_notif **
Radek Krejci056d0a82018-12-06 16:57:25 +01001211lysp_node_notifs_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001212{
1213 assert(node);
1214 switch (node->nodetype) {
1215 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001216 return &((struct lysp_node_container *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001217 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001218 return &((struct lysp_node_list *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001219 case LYS_GROUPING:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001220 return &((struct lysp_node_grp *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001221 case LYS_AUGMENT:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001222 return &((struct lysp_node_augment *)node)->notifs;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001223 default:
1224 return NULL;
1225 }
1226}
1227
Radek Krejci2a9fc652021-01-22 17:44:34 +01001228API const struct lysp_node_notif *
Radek Krejci056d0a82018-12-06 16:57:25 +01001229lysp_node_notifs(const struct lysp_node *node)
1230{
Radek Krejci2a9fc652021-01-22 17:44:34 +01001231 struct lysp_node_notif **notifs;
Michal Vasko69730152020-10-09 16:30:07 +02001232
Michal Vasko22df3f02020-08-24 13:29:22 +02001233 notifs = lysp_node_notifs_p((struct lysp_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001234 if (notifs) {
1235 return *notifs;
1236 } else {
1237 return NULL;
1238 }
1239}
1240
Radek Krejcibbe09a92018-11-08 09:36:54 +01001241struct lysp_node **
Michal Vasko544e58a2021-01-28 14:33:41 +01001242lysp_node_child_p(struct lysp_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001243{
1244 assert(node);
1245 switch (node->nodetype) {
1246 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001247 return &((struct lysp_node_container *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001248 case LYS_CHOICE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001249 return &((struct lysp_node_choice *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001250 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001251 return &((struct lysp_node_list *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001252 case LYS_CASE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001253 return &((struct lysp_node_case *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001254 case LYS_GROUPING:
Radek Krejci01180ac2021-01-27 08:48:22 +01001255 return &((struct lysp_node_grp *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001256 case LYS_AUGMENT:
Radek Krejci2a9fc652021-01-22 17:44:34 +01001257 return &((struct lysp_node_augment *)node)->child;
Michal Vasko7f45cf22020-10-01 12:49:44 +02001258 case LYS_INPUT:
1259 case LYS_OUTPUT:
Radek Krejci01180ac2021-01-27 08:48:22 +01001260 return &((struct lysp_node_action_inout *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001261 case LYS_NOTIF:
Radek Krejci01180ac2021-01-27 08:48:22 +01001262 return &((struct lysp_node_notif *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001263 default:
1264 return NULL;
1265 }
1266}
1267
Radek Krejci056d0a82018-12-06 16:57:25 +01001268API const struct lysp_node *
Michal Vasko544e58a2021-01-28 14:33:41 +01001269lysp_node_child(const struct lysp_node *node)
Radek Krejci056d0a82018-12-06 16:57:25 +01001270{
Michal Vasko544e58a2021-01-28 14:33:41 +01001271 struct lysp_node **child;
Radek Krejcie7b95092019-05-15 11:03:07 +02001272
1273 if (!node) {
1274 return NULL;
1275 }
1276
Michal Vasko544e58a2021-01-28 14:33:41 +01001277 child = lysp_node_child_p((struct lysp_node *)node);
1278 if (child) {
1279 return *child;
Radek Krejci056d0a82018-12-06 16:57:25 +01001280 } else {
1281 return NULL;
1282 }
1283}
1284
Radek Krejci9a3823e2021-01-27 20:26:46 +01001285struct lysp_restr **
1286lysp_node_musts_p(const struct lysp_node *node)
1287{
1288 if (!node) {
1289 return NULL;
1290 }
1291
Radek Krejci2d5f6df2021-01-28 14:00:13 +01001292 switch (node->nodetype) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001293 case LYS_CONTAINER:
1294 return &((struct lysp_node_container *)node)->musts;
1295 case LYS_LEAF:
1296 return &((struct lysp_node_leaf *)node)->musts;
1297 case LYS_LEAFLIST:
1298 return &((struct lysp_node_leaflist *)node)->musts;
1299 case LYS_LIST:
1300 return &((struct lysp_node_list *)node)->musts;
1301 case LYS_ANYXML:
1302 case LYS_ANYDATA:
1303 return &((struct lysp_node_anydata *)node)->musts;
1304 case LYS_NOTIF:
1305 return &((struct lysp_node_notif *)node)->musts;
1306 case LYS_INPUT:
1307 case LYS_OUTPUT:
1308 return &((struct lysp_node_action_inout *)node)->musts;
1309 default:
1310 return NULL;
1311 }
1312}
1313
1314struct lysp_restr *
1315lysp_node_musts(const struct lysp_node *node)
1316{
1317 struct lysp_restr **musts;
1318
1319 musts = lysp_node_musts_p(node);
1320 if (musts) {
1321 return *musts;
1322 } else {
1323 return NULL;
1324 }
1325}
1326
1327struct lysp_when **
1328lysp_node_when_p(const struct lysp_node *node)
1329{
1330 if (!node) {
1331 return NULL;
1332 }
1333
Radek Krejci2d5f6df2021-01-28 14:00:13 +01001334 switch (node->nodetype) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001335 case LYS_CONTAINER:
1336 return &((struct lysp_node_container *)node)->when;
1337 case LYS_CHOICE:
1338 return &((struct lysp_node_choice *)node)->when;
1339 case LYS_LEAF:
1340 return &((struct lysp_node_leaf *)node)->when;
1341 case LYS_LEAFLIST:
1342 return &((struct lysp_node_leaflist *)node)->when;
1343 case LYS_LIST:
1344 return &((struct lysp_node_list *)node)->when;
1345 case LYS_ANYXML:
1346 case LYS_ANYDATA:
1347 return &((struct lysp_node_anydata *)node)->when;
1348 case LYS_CASE:
1349 return &((struct lysp_node_case *)node)->when;
1350 case LYS_USES:
1351 return &((struct lysp_node_uses *)node)->when;
1352 case LYS_AUGMENT:
1353 return &((struct lysp_node_augment *)node)->when;
1354 default:
1355 return NULL;
1356 }
1357}
1358
1359struct lysp_when *
1360lysp_node_when(const struct lysp_node *node)
1361{
1362 struct lysp_when **when;
1363
1364 when = lysp_node_when_p(node);
1365 if (when) {
1366 return *when;
1367 } else {
1368 return NULL;
1369 }
1370}
1371
Radek Krejci2a9fc652021-01-22 17:44:34 +01001372struct lysc_node_action **
Radek Krejci056d0a82018-12-06 16:57:25 +01001373lysc_node_actions_p(struct lysc_node *node)
1374{
1375 assert(node);
1376 switch (node->nodetype) {
1377 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001378 return &((struct lysc_node_container *)node)->actions;
Radek Krejci056d0a82018-12-06 16:57:25 +01001379 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001380 return &((struct lysc_node_list *)node)->actions;
Radek Krejci056d0a82018-12-06 16:57:25 +01001381 default:
1382 return NULL;
1383 }
1384}
1385
Radek Krejci2a9fc652021-01-22 17:44:34 +01001386API const struct lysc_node_action *
Radek Krejci056d0a82018-12-06 16:57:25 +01001387lysc_node_actions(const struct lysc_node *node)
1388{
Radek Krejci2a9fc652021-01-22 17:44:34 +01001389 struct lysc_node_action **actions;
Michal Vasko69730152020-10-09 16:30:07 +02001390
Michal Vasko22df3f02020-08-24 13:29:22 +02001391 actions = lysc_node_actions_p((struct lysc_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001392 if (actions) {
1393 return *actions;
1394 } else {
1395 return NULL;
1396 }
1397}
1398
Radek Krejci2a9fc652021-01-22 17:44:34 +01001399struct lysc_node_notif **
Radek Krejci056d0a82018-12-06 16:57:25 +01001400lysc_node_notifs_p(struct lysc_node *node)
1401{
1402 assert(node);
1403 switch (node->nodetype) {
1404 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001405 return &((struct lysc_node_container *)node)->notifs;
Radek Krejci056d0a82018-12-06 16:57:25 +01001406 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001407 return &((struct lysc_node_list *)node)->notifs;
Radek Krejci056d0a82018-12-06 16:57:25 +01001408 default:
1409 return NULL;
1410 }
1411}
1412
Radek Krejci2a9fc652021-01-22 17:44:34 +01001413API const struct lysc_node_notif *
Radek Krejci056d0a82018-12-06 16:57:25 +01001414lysc_node_notifs(const struct lysc_node *node)
1415{
Radek Krejci2a9fc652021-01-22 17:44:34 +01001416 struct lysc_node_notif **notifs;
Michal Vasko69730152020-10-09 16:30:07 +02001417
Michal Vasko22df3f02020-08-24 13:29:22 +02001418 notifs = lysc_node_notifs_p((struct lysc_node *)node);
Radek Krejci056d0a82018-12-06 16:57:25 +01001419 if (notifs) {
1420 return *notifs;
1421 } else {
1422 return NULL;
1423 }
1424}
1425
Radek Krejcibbe09a92018-11-08 09:36:54 +01001426struct lysc_node **
Michal Vasko544e58a2021-01-28 14:33:41 +01001427lysc_node_child_p(const struct lysc_node *node)
Radek Krejcibbe09a92018-11-08 09:36:54 +01001428{
Michal Vasko544e58a2021-01-28 14:33:41 +01001429 assert(node && !(node->nodetype & (LYS_RPC | LYS_ACTION)));
1430
Radek Krejcibbe09a92018-11-08 09:36:54 +01001431 switch (node->nodetype) {
1432 case LYS_CONTAINER:
Michal Vasko22df3f02020-08-24 13:29:22 +02001433 return &((struct lysc_node_container *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001434 case LYS_CHOICE:
Michal Vasko20424b42020-08-31 12:29:38 +02001435 return (struct lysc_node **)&((struct lysc_node_choice *)node)->cases;
Radek Krejci01342af2019-01-03 15:18:08 +01001436 case LYS_CASE:
Michal Vasko22df3f02020-08-24 13:29:22 +02001437 return &((struct lysc_node_case *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001438 case LYS_LIST:
Michal Vasko22df3f02020-08-24 13:29:22 +02001439 return &((struct lysc_node_list *)node)->child;
Michal Vasko7f45cf22020-10-01 12:49:44 +02001440 case LYS_INPUT:
1441 case LYS_OUTPUT:
Radek Krejci01180ac2021-01-27 08:48:22 +01001442 return &((struct lysc_node_action_inout *)node)->child;
Radek Krejcifc11bd72019-04-11 16:00:05 +02001443 case LYS_NOTIF:
Radek Krejci01180ac2021-01-27 08:48:22 +01001444 return &((struct lysc_node_notif *)node)->child;
Radek Krejcibbe09a92018-11-08 09:36:54 +01001445 default:
1446 return NULL;
1447 }
1448}
1449
Radek Krejci056d0a82018-12-06 16:57:25 +01001450API const struct lysc_node *
Michal Vasko544e58a2021-01-28 14:33:41 +01001451lysc_node_child(const struct lysc_node *node)
Radek Krejcia3045382018-11-22 14:30:31 +01001452{
Michal Vasko544e58a2021-01-28 14:33:41 +01001453 struct lysc_node **child;
Radek Krejcie7b95092019-05-15 11:03:07 +02001454
1455 if (!node) {
1456 return NULL;
1457 }
1458
Michal Vasko544e58a2021-01-28 14:33:41 +01001459 if (node->nodetype & (LYS_RPC | LYS_ACTION)) {
1460 return &((struct lysc_node_action *)node)->input.node;
Radek Krejcibe154442021-01-21 11:06:36 +01001461 } else {
Michal Vasko544e58a2021-01-28 14:33:41 +01001462 child = lysc_node_child_p(node);
1463 if (child) {
1464 return *child;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001465 }
Michal Vasko2a668712020-10-21 11:48:09 +02001466 }
Michal Vasko544e58a2021-01-28 14:33:41 +01001467
1468 return NULL;
Michal Vasko2a668712020-10-21 11:48:09 +02001469}
1470
Radek Krejci9a3823e2021-01-27 20:26:46 +01001471struct lysc_must **
1472lysc_node_musts_p(const struct lysc_node *node)
1473{
1474 if (!node) {
1475 return NULL;
1476 }
1477
Radek Krejci2d5f6df2021-01-28 14:00:13 +01001478 switch (node->nodetype) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001479 case LYS_CONTAINER:
1480 return &((struct lysc_node_container *)node)->musts;
1481 case LYS_LEAF:
1482 return &((struct lysc_node_leaf *)node)->musts;
1483 case LYS_LEAFLIST:
1484 return &((struct lysc_node_leaflist *)node)->musts;
1485 case LYS_LIST:
1486 return &((struct lysc_node_list *)node)->musts;
1487 case LYS_ANYXML:
1488 case LYS_ANYDATA:
1489 return &((struct lysc_node_anydata *)node)->musts;
1490 case LYS_NOTIF:
1491 return &((struct lysc_node_notif *)node)->musts;
1492 case LYS_INPUT:
1493 case LYS_OUTPUT:
1494 return &((struct lysc_node_action_inout *)node)->musts;
1495 default:
1496 return NULL;
1497 }
1498}
1499
1500API struct lysc_must *
1501lysc_node_musts(const struct lysc_node *node)
1502{
1503 struct lysc_must **must_p;
1504
1505 must_p = lysc_node_musts_p(node);
1506 if (must_p) {
1507 return *must_p;
1508 } else {
1509 return NULL;
1510 }
1511}
1512
1513struct lysc_when ***
1514lysc_node_when_p(const struct lysc_node *node)
1515{
1516 if (!node) {
1517 return NULL;
1518 }
1519
Radek Krejci2d5f6df2021-01-28 14:00:13 +01001520 switch (node->nodetype) {
Radek Krejci9a3823e2021-01-27 20:26:46 +01001521 case LYS_CONTAINER:
1522 return &((struct lysc_node_container *)node)->when;
1523 case LYS_CHOICE:
1524 return &((struct lysc_node_choice *)node)->when;
1525 case LYS_LEAF:
1526 return &((struct lysc_node_leaf *)node)->when;
1527 case LYS_LEAFLIST:
1528 return &((struct lysc_node_leaflist *)node)->when;
1529 case LYS_LIST:
1530 return &((struct lysc_node_list *)node)->when;
1531 case LYS_ANYXML:
1532 case LYS_ANYDATA:
1533 return &((struct lysc_node_anydata *)node)->when;
1534 case LYS_CASE:
1535 return &((struct lysc_node_case *)node)->when;
1536 case LYS_NOTIF:
1537 return &((struct lysc_node_notif *)node)->when;
1538 case LYS_RPC:
1539 case LYS_ACTION:
1540 return &((struct lysc_node_action *)node)->when;
1541 default:
1542 return NULL;
1543 }
1544}
1545
1546API struct lysc_when **
1547lysc_node_when(const struct lysc_node *node)
1548{
1549 struct lysc_when ***when_p;
1550
1551 when_p = lysc_node_when_p(node);
1552 if (when_p) {
1553 return *when_p;
1554 } else {
1555 return NULL;
1556 }
1557}
1558
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001559struct lys_module *
1560lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod)
1561{
Radek Krejci1deb5be2020-08-26 16:43:36 +02001562 for (uint32_t u = 0; u < ctx->list.count; ++u) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001563 if (((struct lys_module *)ctx->list.objs[u])->parsed == mod) {
Michal Vasko69730152020-10-09 16:30:07 +02001564 return (struct lys_module *)ctx->list.objs[u];
Radek Krejci96a0bfd2018-11-22 15:25:06 +01001565 }
1566 }
1567 return NULL;
1568}
1569
Radek Krejcid6b76452019-09-03 17:03:03 +02001570enum ly_stmt
Radek Krejcid54412f2020-12-17 20:25:35 +01001571lysp_match_kw(struct ly_in *in, uint64_t *indent)
David Sedlákc10e7902018-12-17 02:17:59 +01001572{
David Sedlák1bccdfa2019-06-17 15:55:27 +02001573/**
Radek Krejcid54412f2020-12-17 20:25:35 +01001574 * @brief Move the input by COUNT items. Also updates the indent value in yang parser context
David Sedlák1bccdfa2019-06-17 15:55:27 +02001575 * @param[in] COUNT number of items for which the DATA pointer is supposed to move on.
Michal Vasko64246d82020-08-19 12:35:00 +02001576 *
1577 * *INDENT-OFF*
David Sedlák1bccdfa2019-06-17 15:55:27 +02001578 */
Radek Krejcid54412f2020-12-17 20:25:35 +01001579#define MOVE_IN(COUNT) \
1580 ly_in_skip(in, COUNT); \
1581 if (indent) { \
1582 (*indent)+=COUNT; \
1583 }
1584#define IF_KW(STR, LEN, STMT) \
1585 if (!strncmp(in->current, STR, LEN)) { \
1586 MOVE_IN(LEN); \
1587 (*kw)=STMT; \
1588 }
1589#define IF_KW_PREFIX(STR, LEN) \
1590 if (!strncmp(in->current, STR, LEN)) { \
1591 MOVE_IN(LEN);
1592#define IF_KW_PREFIX_END \
1593 }
David Sedlák572e7ab2019-06-04 16:01:58 +02001594
Michal Vasko63f3d842020-07-08 10:10:14 +02001595 const char *start = in->current;
Radek Krejcid6b76452019-09-03 17:03:03 +02001596 enum ly_stmt result = LY_STMT_NONE;
1597 enum ly_stmt *kw = &result;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001598 /* read the keyword itself */
Michal Vasko63f3d842020-07-08 10:10:14 +02001599 switch (in->current[0]) {
David Sedlák23a59a62018-10-26 13:08:02 +02001600 case 'a':
Radek Krejcid54412f2020-12-17 20:25:35 +01001601 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001602 IF_KW("rgument", 7, LY_STMT_ARGUMENT)
1603 else IF_KW("ugment", 6, LY_STMT_AUGMENT)
1604 else IF_KW("ction", 5, LY_STMT_ACTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001605 else IF_KW_PREFIX("ny", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001606 IF_KW("data", 4, LY_STMT_ANYDATA)
1607 else IF_KW("xml", 3, LY_STMT_ANYXML)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001608 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001609 break;
1610 case 'b':
Radek Krejcid54412f2020-12-17 20:25:35 +01001611 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001612 IF_KW("ase", 3, LY_STMT_BASE)
1613 else IF_KW("elongs-to", 9, LY_STMT_BELONGS_TO)
1614 else IF_KW("it", 2, LY_STMT_BIT)
David Sedlák23a59a62018-10-26 13:08:02 +02001615 break;
1616 case 'c':
Radek Krejcid54412f2020-12-17 20:25:35 +01001617 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001618 IF_KW("ase", 3, LY_STMT_CASE)
1619 else IF_KW("hoice", 5, LY_STMT_CHOICE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001620 else IF_KW_PREFIX("on", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001621 IF_KW("fig", 3, LY_STMT_CONFIG)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001622 else IF_KW_PREFIX("ta", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001623 IF_KW("ct", 2, LY_STMT_CONTACT)
1624 else IF_KW("iner", 4, LY_STMT_CONTAINER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001625 IF_KW_PREFIX_END
1626 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001627 break;
1628 case 'd':
Radek Krejcid54412f2020-12-17 20:25:35 +01001629 MOVE_IN(1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001630 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001631 IF_KW("fault", 5, LY_STMT_DEFAULT)
1632 else IF_KW("scription", 9, LY_STMT_DESCRIPTION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001633 else IF_KW_PREFIX("viat", 4)
Radek Krejcid6b76452019-09-03 17:03:03 +02001634 IF_KW("e", 1, LY_STMT_DEVIATE)
1635 else IF_KW("ion", 3, LY_STMT_DEVIATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001636 IF_KW_PREFIX_END
1637 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001638 break;
1639 case 'e':
Radek Krejcid54412f2020-12-17 20:25:35 +01001640 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001641 IF_KW("num", 3, LY_STMT_ENUM)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001642 else IF_KW_PREFIX("rror-", 5)
Radek Krejcid6b76452019-09-03 17:03:03 +02001643 IF_KW("app-tag", 7, LY_STMT_ERROR_APP_TAG)
1644 else IF_KW("message", 7, LY_STMT_ERROR_MESSAGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001645 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001646 else IF_KW("xtension", 8, LY_STMT_EXTENSION)
David Sedlák23a59a62018-10-26 13:08:02 +02001647 break;
1648 case 'f':
Radek Krejcid54412f2020-12-17 20:25:35 +01001649 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001650 IF_KW("eature", 6, LY_STMT_FEATURE)
1651 else IF_KW("raction-digits", 14, LY_STMT_FRACTION_DIGITS)
David Sedlák23a59a62018-10-26 13:08:02 +02001652 break;
1653 case 'g':
Radek Krejcid54412f2020-12-17 20:25:35 +01001654 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001655 IF_KW("rouping", 7, LY_STMT_GROUPING)
David Sedlák23a59a62018-10-26 13:08:02 +02001656 break;
1657 case 'i':
Radek Krejcid54412f2020-12-17 20:25:35 +01001658 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001659 IF_KW("dentity", 7, LY_STMT_IDENTITY)
1660 else IF_KW("f-feature", 9, LY_STMT_IF_FEATURE)
1661 else IF_KW("mport", 5, LY_STMT_IMPORT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001662 else IF_KW_PREFIX("n", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001663 IF_KW("clude", 5, LY_STMT_INCLUDE)
1664 else IF_KW("put", 3, LY_STMT_INPUT)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001665 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001666 break;
1667 case 'k':
Radek Krejcid54412f2020-12-17 20:25:35 +01001668 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001669 IF_KW("ey", 2, LY_STMT_KEY)
David Sedlák23a59a62018-10-26 13:08:02 +02001670 break;
1671 case 'l':
Radek Krejcid54412f2020-12-17 20:25:35 +01001672 MOVE_IN(1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001673 IF_KW_PREFIX("e", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001674 IF_KW("af-list", 7, LY_STMT_LEAF_LIST)
1675 else IF_KW("af", 2, LY_STMT_LEAF)
1676 else IF_KW("ngth", 4, LY_STMT_LENGTH)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001677 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001678 else IF_KW("ist", 3, LY_STMT_LIST)
David Sedlák23a59a62018-10-26 13:08:02 +02001679 break;
1680 case 'm':
Radek Krejcid54412f2020-12-17 20:25:35 +01001681 MOVE_IN(1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001682 IF_KW_PREFIX("a", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001683 IF_KW("ndatory", 7, LY_STMT_MANDATORY)
1684 else IF_KW("x-elements", 10, LY_STMT_MAX_ELEMENTS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001685 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001686 else IF_KW("in-elements", 11, LY_STMT_MIN_ELEMENTS)
1687 else IF_KW("ust", 3, LY_STMT_MUST)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001688 else IF_KW_PREFIX("od", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001689 IF_KW("ule", 3, LY_STMT_MODULE)
1690 else IF_KW("ifier", 5, LY_STMT_MODIFIER)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001691 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001692 break;
1693 case 'n':
Radek Krejcid54412f2020-12-17 20:25:35 +01001694 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001695 IF_KW("amespace", 8, LY_STMT_NAMESPACE)
1696 else IF_KW("otification", 11, LY_STMT_NOTIFICATION)
David Sedlák23a59a62018-10-26 13:08:02 +02001697 break;
1698 case 'o':
Radek Krejcid54412f2020-12-17 20:25:35 +01001699 MOVE_IN(1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001700 IF_KW_PREFIX("r", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001701 IF_KW("dered-by", 8, LY_STMT_ORDERED_BY)
1702 else IF_KW("ganization", 10, LY_STMT_ORGANIZATION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001703 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001704 else IF_KW("utput", 5, LY_STMT_OUTPUT)
David Sedlák23a59a62018-10-26 13:08:02 +02001705 break;
1706 case 'p':
Radek Krejcid54412f2020-12-17 20:25:35 +01001707 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001708 IF_KW("ath", 3, LY_STMT_PATH)
1709 else IF_KW("attern", 6, LY_STMT_PATTERN)
1710 else IF_KW("osition", 7, LY_STMT_POSITION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001711 else IF_KW_PREFIX("re", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001712 IF_KW("fix", 3, LY_STMT_PREFIX)
1713 else IF_KW("sence", 5, LY_STMT_PRESENCE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001714 IF_KW_PREFIX_END
David Sedlák23a59a62018-10-26 13:08:02 +02001715 break;
1716 case 'r':
Radek Krejcid54412f2020-12-17 20:25:35 +01001717 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001718 IF_KW("ange", 4, LY_STMT_RANGE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001719 else IF_KW_PREFIX("e", 1)
1720 IF_KW_PREFIX("f", 1)
Radek Krejcid6b76452019-09-03 17:03:03 +02001721 IF_KW("erence", 6, LY_STMT_REFERENCE)
1722 else IF_KW("ine", 3, LY_STMT_REFINE)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001723 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001724 else IF_KW("quire-instance", 14, LY_STMT_REQUIRE_INSTANCE)
1725 else IF_KW("vision-date", 11, LY_STMT_REVISION_DATE)
1726 else IF_KW("vision", 6, LY_STMT_REVISION)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001727 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001728 else IF_KW("pc", 2, LY_STMT_RPC)
David Sedlák23a59a62018-10-26 13:08:02 +02001729 break;
1730 case 's':
Radek Krejcid54412f2020-12-17 20:25:35 +01001731 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001732 IF_KW("tatus", 5, LY_STMT_STATUS)
1733 else IF_KW("ubmodule", 8, LY_STMT_SUBMODULE)
David Sedlák23a59a62018-10-26 13:08:02 +02001734 break;
1735 case 't':
Radek Krejcid54412f2020-12-17 20:25:35 +01001736 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001737 IF_KW("ypedef", 6, LY_STMT_TYPEDEF)
1738 else IF_KW("ype", 3, LY_STMT_TYPE)
David Sedlák23a59a62018-10-26 13:08:02 +02001739 break;
1740 case 'u':
Radek Krejcid54412f2020-12-17 20:25:35 +01001741 MOVE_IN(1);
David Sedlák1bccdfa2019-06-17 15:55:27 +02001742 IF_KW_PREFIX("ni", 2)
Radek Krejcid6b76452019-09-03 17:03:03 +02001743 IF_KW("que", 3, LY_STMT_UNIQUE)
1744 else IF_KW("ts", 2, LY_STMT_UNITS)
David Sedlák1bccdfa2019-06-17 15:55:27 +02001745 IF_KW_PREFIX_END
Radek Krejcid6b76452019-09-03 17:03:03 +02001746 else IF_KW("ses", 3, LY_STMT_USES)
David Sedlák23a59a62018-10-26 13:08:02 +02001747 break;
1748 case 'v':
Radek Krejcid54412f2020-12-17 20:25:35 +01001749 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001750 IF_KW("alue", 4, LY_STMT_VALUE)
David Sedlák23a59a62018-10-26 13:08:02 +02001751 break;
1752 case 'w':
Radek Krejcid54412f2020-12-17 20:25:35 +01001753 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001754 IF_KW("hen", 3, LY_STMT_WHEN)
David Sedlák23a59a62018-10-26 13:08:02 +02001755 break;
1756 case 'y':
Radek Krejcid54412f2020-12-17 20:25:35 +01001757 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001758 IF_KW("ang-version", 11, LY_STMT_YANG_VERSION)
1759 else IF_KW("in-element", 10, LY_STMT_YIN_ELEMENT)
David Sedlák23a59a62018-10-26 13:08:02 +02001760 break;
David Sedlák23a59a62018-10-26 13:08:02 +02001761 default:
Radek Krejcid54412f2020-12-17 20:25:35 +01001762 /* if indent is not NULL we are matching keyword from YANG data */
1763 if (indent) {
Michal Vasko63f3d842020-07-08 10:10:14 +02001764 if (in->current[0] == ';') {
Radek Krejcid54412f2020-12-17 20:25:35 +01001765 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001766 *kw = LY_STMT_SYNTAX_SEMICOLON;
Michal Vasko63f3d842020-07-08 10:10:14 +02001767 } else if (in->current[0] == '{') {
Radek Krejcid54412f2020-12-17 20:25:35 +01001768 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001769 *kw = LY_STMT_SYNTAX_LEFT_BRACE;
Michal Vasko63f3d842020-07-08 10:10:14 +02001770 } else if (in->current[0] == '}') {
Radek Krejcid54412f2020-12-17 20:25:35 +01001771 MOVE_IN(1);
Radek Krejcid6b76452019-09-03 17:03:03 +02001772 *kw = LY_STMT_SYNTAX_RIGHT_BRACE;
David Sedlák1bccdfa2019-06-17 15:55:27 +02001773 }
1774 }
David Sedlák23a59a62018-10-26 13:08:02 +02001775 break;
1776 }
1777
Michal Vasko63f3d842020-07-08 10:10:14 +02001778 if ((*kw < LY_STMT_SYNTAX_SEMICOLON) && isalnum(in->current[0])) {
Radek Krejci6e546bf2020-05-19 16:16:19 +02001779 /* the keyword is not terminated */
1780 *kw = LY_STMT_NONE;
Michal Vasko63f3d842020-07-08 10:10:14 +02001781 in->current = start;
Radek Krejci6e546bf2020-05-19 16:16:19 +02001782 }
1783
David Sedlák1bccdfa2019-06-17 15:55:27 +02001784#undef IF_KW
1785#undef IF_KW_PREFIX
1786#undef IF_KW_PREFIX_END
David Sedlák18730132019-03-15 15:51:34 +01001787#undef MOVE_IN
Michal Vasko64246d82020-08-19 12:35:00 +02001788 /* *INDENT-ON* */
David Sedlák18730132019-03-15 15:51:34 +01001789
David Sedlák1bccdfa2019-06-17 15:55:27 +02001790 return result;
David Sedlák23a59a62018-10-26 13:08:02 +02001791}
David Sedlákecf5eb82019-06-03 14:12:44 +02001792
Radek Krejci85ac8312021-03-03 20:21:33 +01001793LY_ERR
1794lysp_ext_find_definition(const struct ly_ctx *ctx, const struct lysp_ext_instance *ext, const struct lys_module **ext_mod,
1795 struct lysp_ext **ext_def)
1796{
Radek Krejci85ac8312021-03-03 20:21:33 +01001797 const char *tmp, *name, *prefix;
1798 size_t pref_len, name_len;
1799 LY_ARRAY_COUNT_TYPE v;
1800 const struct lys_module *mod = NULL;
1801
Radek Krejcicbb62422021-03-15 09:29:21 +01001802 assert(ext_def);
1803
Radek Krejci85ac8312021-03-03 20:21:33 +01001804 *ext_def = NULL;
1805 if (ext_mod) {
1806 *ext_mod = NULL;
1807 }
1808
Radek Krejci677abea2021-03-05 14:24:53 +01001809 /* parse the prefix, the nodeid was previously already parsed and checked */
Radek Krejci85ac8312021-03-03 20:21:33 +01001810 tmp = ext->name;
Radek Krejci677abea2021-03-05 14:24:53 +01001811 ly_parse_nodeid(&tmp, &prefix, &pref_len, &name, &name_len);
Radek Krejci85ac8312021-03-03 20:21:33 +01001812
1813 /* get module where the extension definition should be placed */
1814 mod = ly_resolve_prefix(ctx, prefix, pref_len, ext->format, ext->prefix_data);
1815 if (!mod) {
Radek Krejci422afb12021-03-04 16:38:16 +01001816 LOGVAL(ctx, LYVE_REFERENCE, "Invalid prefix \"%.*s\" used for extension instance identifier.", (int)pref_len, prefix);
Radek Krejci85ac8312021-03-03 20:21:33 +01001817 return LY_EVALID;
1818 } else if (!mod->parsed->extensions) {
1819 LOGVAL(ctx, LYVE_REFERENCE, "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
1820 ext->name, mod->name);
1821 return LY_EVALID;
1822 }
1823
1824 /* find the parsed extension definition there */
1825 LY_ARRAY_FOR(mod->parsed->extensions, v) {
1826 if (!strcmp(name, mod->parsed->extensions[v].name)) {
1827 *ext_def = &mod->parsed->extensions[v];
1828 break;
1829 }
1830 }
1831
Radek Krejcicbb62422021-03-15 09:29:21 +01001832 if (!(*ext_def)) {
Radek Krejci85ac8312021-03-03 20:21:33 +01001833 LOGVAL(ctx, LYVE_REFERENCE, "Extension definition of extension instance \"%s\" not found.", ext->name);
1834 return LY_EVALID;
1835 }
1836
1837 if (ext_mod) {
1838 *ext_mod = mod;
1839 }
1840 return LY_SUCCESS;
1841}
1842
1843LY_ERR
1844lysp_ext_instance_resolve_argument(struct ly_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysp_ext *ext_def)
1845{
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001846 if (!ext_def->argname || ext_p->argument) {
Radek Krejci85ac8312021-03-03 20:21:33 +01001847 /* nothing to do */
1848 return LY_SUCCESS;
1849 }
1850
Radek Krejci8df109d2021-04-23 12:19:08 +02001851 if (ext_p->format == LY_VALUE_XML) {
Radek Krejci85ac8312021-03-03 20:21:33 +01001852 /* Schema was parsed from YIN and an argument is expected, ... */
1853 struct lysp_stmt *stmt = NULL;
1854
1855 if (ext_def->flags & LYS_YINELEM_TRUE) {
1856 /* ... argument was the first XML child element */
1857 for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {}
1858 if (stmt) {
1859 const char *arg, *ext, *name_arg, *name_ext, *prefix_arg, *prefix_ext;
1860 size_t name_arg_len, name_ext_len, prefix_arg_len, prefix_ext_len;
1861
1862 stmt = ext_p->child;
1863
1864 arg = stmt->stmt;
1865 ly_parse_nodeid(&arg, &prefix_arg, &prefix_arg_len, &name_arg, &name_arg_len);
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001866 if (ly_strncmp(ext_def->argname, name_arg, name_arg_len)) {
Radek Krejci85ac8312021-03-03 20:21:33 +01001867 LOGVAL(ctx, LYVE_SEMANTICS, "Extension instance \"%s\" expects argument element \"%s\" as its first XML child, "
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001868 "but \"%.*s\" element found.", ext_p->name, ext_def->argname, (int)name_arg_len, name_arg);
Radek Krejci85ac8312021-03-03 20:21:33 +01001869 return LY_EVALID;
1870 }
1871
1872 /* check namespace - all the extension instances must be qualified and argument element is expected in the same
1873 * namespace. Do not check just prefixes, there can be different prefixes pointing to the same namespace */
1874 ext = ext_p->name; /* include prefix */
1875 ly_parse_nodeid(&ext, &prefix_ext, &prefix_ext_len, &name_ext, &name_ext_len);
1876
1877 if (ly_resolve_prefix(ctx, prefix_ext, prefix_ext_len, ext_p->format, ext_p->prefix_data) !=
1878 ly_resolve_prefix(ctx, prefix_arg, prefix_arg_len, stmt->format, stmt->prefix_data)) {
1879 LOGVAL(ctx, LYVE_SEMANTICS, "Extension instance \"%s\" element and its argument element \"%s\" are "
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001880 "expected in the same namespace, but they differ.", ext_p->name, ext_def->argname);
Radek Krejci85ac8312021-03-03 20:21:33 +01001881 return LY_EVALID;
1882 }
1883 }
1884 } else {
1885 /* ... argument was one of the XML attributes which are represented as child stmt
1886 * with LYS_YIN_ATTR flag */
1887 for (stmt = ext_p->child; stmt && (stmt->flags & LYS_YIN_ATTR); stmt = stmt->next) {
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001888 if (!strcmp(stmt->stmt, ext_def->argname)) {
Radek Krejci85ac8312021-03-03 20:21:33 +01001889 /* this is the extension's argument */
1890 break;
1891 }
1892 }
1893 }
1894
1895 if (stmt) {
1896 LY_CHECK_RET(lydict_insert(ctx, stmt->arg, 0, &ext_p->argument));
1897 stmt->flags |= LYS_YIN_ARGUMENT;
1898 }
1899 }
1900
1901 if (!ext_p->argument) {
1902 /* missing extension's argument */
1903 LOGVAL(ctx, LYVE_SEMANTICS, "Extension instance \"%s\" misses argument %s\"%s\".",
Radek Krejci9f87b0c2021-03-05 14:45:26 +01001904 ext_p->name, (ext_def->flags & LYS_YINELEM_TRUE) ? "element " : "", ext_def->argname);
Radek Krejci85ac8312021-03-03 20:21:33 +01001905 return LY_EVALID;
1906 }
1907
1908 return LY_SUCCESS;
1909}
1910
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001911LY_ARRAY_COUNT_TYPE
Radek Krejcifc596f92021-02-26 22:40:26 +01001912lysp_ext_instance_iter(struct lysp_ext_instance *ext, LY_ARRAY_COUNT_TYPE index, enum ly_stmt substmt)
Radek Krejcid3ca0632019-04-16 16:54:54 +02001913{
1914 LY_CHECK_ARG_RET(NULL, ext, LY_EINVAL);
1915
Michal Vaskod989ba02020-08-24 10:59:24 +02001916 for ( ; index < LY_ARRAY_COUNT(ext); index++) {
Radek Krejciab430862021-03-02 20:13:40 +01001917 if (ext[index].parent_stmt == substmt) {
Radek Krejcid3ca0632019-04-16 16:54:54 +02001918 return index;
1919 }
1920 }
1921
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001922 return LY_ARRAY_COUNT(ext);
Radek Krejcid3ca0632019-04-16 16:54:54 +02001923}
1924
Michal Vasko62ed12d2020-05-21 10:08:25 +02001925const struct lysc_node *
Michal Vasko72244882021-01-12 15:21:05 +01001926lysc_data_node(const struct lysc_node *schema)
Michal Vasko62ed12d2020-05-21 10:08:25 +02001927{
1928 const struct lysc_node *parent;
1929
Michal Vasko72244882021-01-12 15:21:05 +01001930 parent = schema;
Radek Krejcidf549132021-01-21 10:32:32 +01001931 while (parent && !(parent->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYDATA | LYS_RPC |
1932 LYS_ACTION | LYS_NOTIF))) {
Radek Krejci7d95fbb2021-01-26 17:33:13 +01001933 parent = parent->parent;
Michal Vasko72244882021-01-12 15:21:05 +01001934 }
Michal Vasko62ed12d2020-05-21 10:08:25 +02001935
1936 return parent;
1937}