blob: c0306340851002f974fb98c56320f7e4a0efd67c [file] [log] [blame]
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001/**
2 * @file schema_compile.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema compilation.
5 *
6 * Copyright (c) 2015 - 2020 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 */
14
15#define _GNU_SOURCE
16
17#include "schema_compile.h"
18
19#include <assert.h>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020020#include <stddef.h>
21#include <stdint.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include "common.h"
27#include "compat.h"
28#include "context.h"
29#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020030#include "in.h"
Radek Krejci47fab892020-11-05 17:02:41 +010031#include "log.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020032#include "parser_schema.h"
33#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020034#include "plugins.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020035#include "plugins_exts.h"
Radek Krejci77114102021-03-10 15:21:57 +010036#include "plugins_exts_compile.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010037#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020038#include "plugins_types.h"
39#include "schema_compile_amend.h"
40#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010041#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020042#include "set.h"
43#include "tree.h"
44#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020045#include "tree_schema.h"
46#include "tree_schema_internal.h"
47#include "xpath.h"
48
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020049/**
50 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
51 */
52static LY_ERR
53lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
54{
55 LY_ERR ret = LY_SUCCESS;
56
Radek Krejci720d2612021-03-03 19:44:22 +010057 if (ext_p->compiled && (ext_p->compiled->refcount == 1)) {
58 /* context recompilation - all the extension instances were previously freed (the last link to the compiled extension
59 * remains from the parsed extension definition) and now we are recompiling them again, to have the up-to-date
60 * extension definition, we have to recompile it as well now */
61 lysc_extension_free(ctx->ctx, &ext_p->compiled);
62 }
63
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020064 if (!ext_p->compiled) {
65 lysc_update_path(ctx, NULL, "{extension}");
66 lysc_update_path(ctx, NULL, ext_p->name);
67
68 /* compile the extension definition */
69 ext_p->compiled = calloc(1, sizeof **ext);
70 ext_p->compiled->refcount = 1;
71 DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
Radek Krejci9f87b0c2021-03-05 14:45:26 +010072 DUP_STRING_GOTO(ctx->ctx, ext_p->argname, ext_p->compiled->argname, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020073 ext_p->compiled->module = (struct lys_module *)ext_mod;
Radek Krejciab430862021-03-02 20:13:40 +010074 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020075
76 lysc_update_path(ctx, NULL, NULL);
77 lysc_update_path(ctx, NULL, NULL);
78
79 /* find extension definition plugin */
Radek Krejci3e6632f2021-03-22 22:08:21 +010080 ext_p->compiled->plugin = lyplg_find(LYPLG_EXTENSION, ext_p->compiled->module->name,
81 ext_p->compiled->module->revision, ext_p->compiled->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020082 }
83
84 *ext = lysc_ext_dup(ext_p->compiled);
85
86done:
Radek Krejci2efc45b2020-12-22 16:25:44 +010087 if (ret) {
88 lysc_update_path(ctx, NULL, NULL);
89 lysc_update_path(ctx, NULL, NULL);
90 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020091 return ret;
92}
93
94LY_ERR
95lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent,
Radek Krejciab430862021-03-02 20:13:40 +010096 const struct lys_module *ext_mod)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020097{
Radek Krejci85ac8312021-03-03 20:21:33 +010098 LY_ERR ret = LY_SUCCESS;
99 struct lysp_ext *ext_def;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200100
Radek Krejciab430862021-03-02 20:13:40 +0100101 ext->parent_stmt = ext_p->parent_stmt;
102 ext->parent_stmt_index = ext_p->parent_stmt_index;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200103 ext->module = ctx->cur_mod;
104 ext->parent = parent;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200105
Radek Krejciab430862021-03-02 20:13:40 +0100106 lysc_update_path(ctx, LY_STMT_IS_NODE(ext->parent_stmt) ? ((struct lysc_node *)ext->parent)->module : NULL, "{extension}");
Michal Vaskofc2cd072021-02-24 13:17:17 +0100107 lysc_update_path(ctx, NULL, ext_p->name);
108
Radek Krejci85ac8312021-03-03 20:21:33 +0100109 LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, ext_p, &ext_mod, &ext_def), cleanup);
110 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, ext_def, &ext->def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200111
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100112 if (ext_def->argname) {
Radek Krejci85ac8312021-03-03 20:21:33 +0100113 LY_CHECK_GOTO(ret = lysp_ext_instance_resolve_argument(ctx->ctx, ext_p, ext_def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200114 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200115
Radek Krejci85ac8312021-03-03 20:21:33 +0100116 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
117 LY_CHECK_RET(ret);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200118
119 if (ext->def->plugin && ext->def->plugin->compile) {
120 if (ext->argument) {
Radek Krejcia6016992021-03-03 10:13:41 +0100121 lysc_update_path(ctx, ext->module, ext->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200122 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100123 ret = ext->def->plugin->compile(ctx, ext_p, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100124 if (ret == LY_ENOT) {
125 lysc_ext_instance_free(ctx->ctx, ext);
126 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200127 if (ext->argument) {
128 lysc_update_path(ctx, NULL, NULL);
129 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100130 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200131 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200132
133cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100134 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100135 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200136
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200137 return ret;
138}
139
140struct lysc_ext *
141lysc_ext_dup(struct lysc_ext *orig)
142{
143 ++orig->refcount;
144 return orig;
145}
146
Radek Krejcidab4f0b2021-03-29 14:07:18 +0200147API LY_ERR
Radek Krejci1b2eef82021-02-17 11:17:27 +0100148lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt, void **instance_p, enum ly_stmt_cardinality *cardinality_p)
149{
150 LY_ARRAY_COUNT_TYPE u;
151
152 LY_ARRAY_FOR(ext->substmts, u) {
Radek Krejci61837f72021-03-02 19:53:59 +0100153 if (LY_STMT_IS_DATA_NODE(substmt)) {
154 if (!LY_STMT_IS_DATA_NODE(ext->substmts[u].stmt)) {
Radek Krejci1b2eef82021-02-17 11:17:27 +0100155 continue;
156 }
157 } else if (LY_STMT_IS_OP(substmt)) {
158 if (!LY_STMT_IS_OP(ext->substmts[u].stmt)) {
159 continue;
160 }
161 } else if (ext->substmts[u].stmt != substmt) {
162 continue;
163 }
164
165 /* match */
166 if (cardinality_p) {
167 *cardinality_p = ext->substmts[u].cardinality;
168 }
169 if (instance_p) {
170 *instance_p = ext->substmts[u].storage;
171 }
172 return LY_SUCCESS;
173 }
174
175 return LY_ENOT;
176}
177
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200178static void
179lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
180{
181 assert(!r->dflt || !r->dflts);
182 if (r->dflt) {
183 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
184 free(r->dflt);
185 } else {
186 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
187 }
188 free(r);
189}
190
191void
Radek Krejcia6016992021-03-03 10:13:41 +0100192lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200193{
194 int len;
195 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
196
197 if (!name) {
198 /* removing last path segment */
199 if (ctx->path[ctx->path_len - 1] == '}') {
200 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
201 if (ctx->path[ctx->path_len] == '=') {
202 ctx->path[ctx->path_len++] = '}';
203 } else {
204 /* not a top-level special tag, remove also preceiding '/' */
205 goto remove_nodelevel;
206 }
207 } else {
208remove_nodelevel:
209 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
210 if (ctx->path_len == 0) {
211 /* top-level (last segment) */
212 ctx->path_len = 1;
213 }
214 }
215 /* set new terminating NULL-byte */
216 ctx->path[ctx->path_len] = '\0';
217 } else {
218 if (ctx->path_len > 1) {
Radek Krejcia6016992021-03-03 10:13:41 +0100219 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200220 /* extension of the special tag */
221 nextlevel = 2;
222 --ctx->path_len;
223 } else {
224 /* there is already some path, so add next level */
225 nextlevel = 1;
226 }
227 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
228
229 if (nextlevel != 2) {
Radek Krejcia6016992021-03-03 10:13:41 +0100230 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200231 /* module not changed, print the name unprefixed */
232 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
233 } else {
234 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
235 }
236 } else {
237 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
238 }
239 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
240 /* output truncated */
241 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
242 } else {
243 ctx->path_len += len;
244 }
245 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100246
Radek Krejciddace2c2021-01-08 11:30:56 +0100247 LOG_LOCBACK(0, 0, 1, 0);
248 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200249}
250
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200251LY_ERR
252lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
253 struct lysp_ident *identities_p, struct lysc_ident **identities)
254{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100255 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200256 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100257 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200258 LY_ERR ret = LY_SUCCESS;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100259 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200260
261 assert(ctx_sc || ctx);
262
263 if (!ctx_sc) {
264 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100265 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200266 context.pmod = parsed_mod;
267 context.path_len = 1;
268 context.path[0] = '/';
269 ctx_sc = &context;
270 }
271
272 if (!identities_p) {
273 return LY_SUCCESS;
274 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200275
276 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200277 LY_ARRAY_FOR(identities_p, u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100278 /* evaluate if-features */
279 LY_CHECK_RET(lys_eval_iffeatures(ctx, identities_p[u].iffeatures, &enabled));
280 if (!enabled) {
281 continue;
282 }
283
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200284 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
285
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100286 /* add new compiled identity */
287 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
288
289 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
290 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
291 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
292 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200293 /* backlinks (derived) can be added no sooner than when all the identities in the current module are present */
Radek Krejciab430862021-03-02 20:13:40 +0100294 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100295 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200296
297 lysc_update_path(ctx_sc, NULL, NULL);
298 }
299 lysc_update_path(ctx_sc, NULL, NULL);
300done:
301 return ret;
302}
303
304/**
305 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
306 *
307 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
308 *
309 * @param[in] ctx Compile context for logging.
310 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
311 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
312 * @return LY_SUCCESS if everything is ok.
313 * @return LY_EVALID if the identity is derived from itself.
314 */
315static LY_ERR
316lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
317{
318 LY_ERR ret = LY_SUCCESS;
319 LY_ARRAY_COUNT_TYPE u, v;
320 struct ly_set recursion = {0};
321 struct lysc_ident *drv;
322
323 if (!derived) {
324 return LY_SUCCESS;
325 }
326
327 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
328 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100329 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200330 "Identity \"%s\" is indirectly derived from itself.", ident->name);
331 ret = LY_EVALID;
332 goto cleanup;
333 }
334 ret = ly_set_add(&recursion, derived[u], 0, NULL);
335 LY_CHECK_GOTO(ret, cleanup);
336 }
337
338 for (v = 0; v < recursion.count; ++v) {
339 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200340 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
341 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100342 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200343 "Identity \"%s\" is indirectly derived from itself.", ident->name);
344 ret = LY_EVALID;
345 goto cleanup;
346 }
347 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
348 LY_CHECK_GOTO(ret, cleanup);
349 }
350 }
351
352cleanup:
353 ly_set_erase(&recursion, NULL);
354 return ret;
355}
356
357LY_ERR
358lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100359 struct lysc_ident *ident, struct lysc_ident ***bases, ly_bool *enabled)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200360{
361 LY_ARRAY_COUNT_TYPE u, v;
362 const char *s, *name;
363 const struct lys_module *mod;
364 struct lysc_ident **idref;
365
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100366 assert((ident && enabled) || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200367
368 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100369 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200370 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
371 return LY_EVALID;
372 }
373
374 LY_ARRAY_FOR(bases_p, u) {
375 s = strchr(bases_p[u], ':');
376 if (s) {
377 /* prefixed identity */
378 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200379 mod = ly_resolve_prefix(ctx->ctx, bases_p[u], s - bases_p[u], LY_VALUE_SCHEMA, (void *)base_pmod);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200380 } else {
381 name = bases_p[u];
382 mod = base_pmod->mod;
383 }
384 if (!mod) {
385 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100386 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200387 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
388 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100389 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200390 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
391 }
392 return LY_EVALID;
393 }
394
395 idref = NULL;
396 LY_ARRAY_FOR(mod->identities, v) {
397 if (!strcmp(name, mod->identities[v].name)) {
398 if (ident) {
399 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100400 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200401 "Identity \"%s\" is derived from itself.", ident->name);
402 return LY_EVALID;
403 }
404 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
405 /* we have match! store the backlink */
406 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
407 *idref = ident;
408 } else {
409 /* we have match! store the found identity */
410 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
411 *idref = &mod->identities[v];
412 }
413 break;
414 }
415 }
416 if (!idref || !(*idref)) {
Radek Krejci10443f42021-03-28 17:40:35 +0200417 if (ident || (ctx->options & LYS_COMPILE_DISABLED)) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100418 /* look into the parsed module to check whether the identity is not merely disabled */
419 LY_ARRAY_FOR(mod->parsed->identities, v) {
420 if (!strcmp(mod->parsed->identities[v].name, name)) {
Radek Krejci10443f42021-03-28 17:40:35 +0200421 if (ident) {
422 *enabled = 0;
423 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100424 return LY_SUCCESS;
425 }
426 }
Radek Krejci10443f42021-03-28 17:40:35 +0200427 }
428 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100429 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200430 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
431 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100432 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200433 "Unable to find base (%s) of identityref.", bases_p[u]);
434 }
435 return LY_EVALID;
436 }
437 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100438
439 if (ident) {
440 *enabled = 1;
441 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200442 return LY_SUCCESS;
443}
444
445/**
446 * @brief For the given array of identities, set the backlinks from all their base identities.
447 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
448 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100449 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set. Any
450 * identities with disabled bases are removed.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200451 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
452 */
453static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100454lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200455{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100456 LY_ARRAY_COUNT_TYPE u, v;
457 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200458
459 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100460
461restart:
Radek Krejcic7d13e32020-12-09 12:32:24 +0100462 for (u = 0, v = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100463 /* find matching parsed identity, the disabled ones are missing in the compiled array */
464 while (v < LY_ARRAY_COUNT(idents_p)) {
465 if (idents_p[v].name == (*idents)[u].name) {
466 break;
467 }
468 ++v;
469 }
470 assert(v < LY_ARRAY_COUNT(idents_p));
471
472 if (!idents_p[v].bases) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200473 continue;
474 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100475 lysc_update_path(ctx, NULL, (*idents)[u].name);
476 LY_CHECK_RET(lys_compile_identity_bases(ctx, (*idents)[u].module->parsed, idents_p[v].bases, &(*idents)[u], NULL,
477 &enabled));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200478 lysc_update_path(ctx, NULL, NULL);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100479
480 if (!enabled) {
481 /* remove the identity */
482 lysc_ident_free(ctx->ctx, &(*idents)[u]);
483 LY_ARRAY_DECREMENT(*idents);
484 if (u < LY_ARRAY_COUNT(*idents)) {
485 memmove(&(*idents)[u], &(*idents)[u + 1], (LY_ARRAY_COUNT(*idents) - u) * sizeof **idents);
486 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100487
488 /* revert compilation of all the previous identities */
489 for (v = 0; v < u; ++v) {
490 LY_ARRAY_FREE((*idents)[v].derived);
Radek Krejci454820e2021-03-28 17:57:45 +0200491 (*idents)[v].derived = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100492 }
493
Michal Vasko74c82ae2020-11-03 17:36:53 +0100494 /* free the whole array if there are no identites left */
495 if (!LY_ARRAY_COUNT(*idents)) {
496 LY_ARRAY_FREE(*idents);
497 *idents = NULL;
498 }
499
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100500 /* restart the whole process without this identity */
501 goto restart;
502 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200503 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100504
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200505 lysc_update_path(ctx, NULL, NULL);
506 return LY_SUCCESS;
507}
508
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200509static void *
510lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
511{
512 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
513 if (substmts[u].stmt == stmt) {
514 return substmts[u].storage;
515 }
516 }
517 return NULL;
518}
519
520LY_ERR
Radek Krejci6b88a462021-02-17 12:39:34 +0100521lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200522{
aPiecek1c4da362021-04-29 14:26:34 +0200523 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200524 LY_ARRAY_COUNT_TYPE u;
525 struct lysp_stmt *stmt;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200526 void *parsed = NULL, **compiled = NULL;
527
528 /* check for invalid substatements */
Radek Krejci6b88a462021-02-17 12:39:34 +0100529 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200530 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
531 continue;
532 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100533 LY_ARRAY_FOR(ext->substmts, u) {
534 if (ext->substmts[u].stmt == stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200535 break;
536 }
537 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100538 if (u == LY_ARRAY_COUNT(ext->substmts)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100539 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
Radek Krejci6b88a462021-02-17 12:39:34 +0100540 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200541 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200542 goto cleanup;
543 }
544 }
545
546 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
547
Radek Krejci6b88a462021-02-17 12:39:34 +0100548 /* note into the compile context that we are processing extension now */
549 ctx->ext = ext;
550
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200551 /* keep order of the processing the same as the order in the defined substmts,
552 * the order is important for some of the statements depending on others (e.g. type needs status and units) */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200553
Radek Krejci6b88a462021-02-17 12:39:34 +0100554 LY_ARRAY_FOR(ext->substmts, u) {
555 uint64_t stmt_counter = 0;
556
557 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
558 if (ext->substmts[u].stmt != stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200559 continue;
560 }
561
Radek Krejci6b88a462021-02-17 12:39:34 +0100562 parsed = NULL;
563 stmt_counter++;
564 if (ext->substmts[u].storage) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200565 switch (stmt->kw) {
Radek Krejci6b88a462021-02-17 12:39:34 +0100566 case LY_STMT_ACTION:
567 case LY_STMT_ANYDATA:
568 case LY_STMT_ANYXML:
569 case LY_STMT_CONTAINER:
570 case LY_STMT_CHOICE:
571 case LY_STMT_LEAF:
572 case LY_STMT_LEAF_LIST:
573 case LY_STMT_LIST:
574 case LY_STMT_NOTIFICATION:
575 case LY_STMT_RPC:
576 case LY_STMT_USES:
aPiecek60d9d672021-04-27 15:49:57 +0200577 if (!ext_p->parsed) {
578 struct lysp_ext_instance *unconst_ext_p;
579 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
580 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
581 unconst_ext_p = (struct lysp_ext_instance *)ext_p;
582 unconst_ext_p->parsed = parsed;
583 } else {
584 struct lysp_node *node, *last_node;
585 /* get last parsed node */
586 LY_LIST_FOR(ext_p->parsed, node) {
587 last_node = node;
588 }
589 /* create and link sibling */
590 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
591 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
592 last_node->next = parsed;
593 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100594
595 /* set storage as an alternative document root in the compile context */
596 r = lys_compile_node(ctx, parsed, NULL, 0, NULL);
Radek Krejci6b88a462021-02-17 12:39:34 +0100597 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200598 break;
Radek Krejci1b2eef82021-02-17 11:17:27 +0100599 case LY_STMT_DESCRIPTION:
600 case LY_STMT_REFERENCE:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200601 case LY_STMT_UNITS: {
Radek Krejci6b88a462021-02-17 12:39:34 +0100602 const char **str_p;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200603
Radek Krejci6b88a462021-02-17 12:39:34 +0100604 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200605 /* single item */
Radek Krejci6b88a462021-02-17 12:39:34 +0100606 if (*((const char **)ext->substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100607 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200608 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200609 goto cleanup;
610 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100611 str_p = (const char **)ext->substmts[u].storage;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200612 } else {
613 /* sized array */
Radek Krejci6b88a462021-02-17 12:39:34 +0100614 const char ***strings_array = (const char ***)ext->substmts[u].storage;
615 LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200616 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100617 r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200618 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
619 break;
620 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100621 case LY_STMT_IF_FEATURE: {
622 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200623
Radek Krejci76c8c4e2021-02-17 10:16:48 +0100624 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200625 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Radek Krejci6b88a462021-02-17 12:39:34 +0100626
627 r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled);
628 FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100629 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
630 if (!enabled) {
631 /* it is disabled, remove the whole extension instance */
632 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200633 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200634 break;
Radek Krejci6b88a462021-02-17 12:39:34 +0100635 }
636 case LY_STMT_STATUS:
637 assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME);
638 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
639 break;
640 case LY_STMT_TYPE: {
641 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts);
642 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts);
643
644 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
645 /* single item */
646 if (*(struct lysc_type **)ext->substmts[u].storage) {
647 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200648 ret = LY_EVALID;
Radek Krejci6b88a462021-02-17 12:39:34 +0100649 goto cleanup;
650 }
651 compiled = ext->substmts[u].storage;
652 } else {
653 /* sized array */
654 struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL;
655 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
656 compiled = (void *)type;
657 }
658
659 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
660 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
661 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled,
662 units && !*units ? units : NULL, NULL);
663 lysp_type_free(ctx->ctx, parsed);
664 free(parsed);
665 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
666 break;
667 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200668 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
669 * also note that in many statements their extensions are not taken into account */
670 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100671 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
Radek Krejci6b88a462021-02-17 12:39:34 +0100672 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200673 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200674 goto cleanup;
675 }
676 }
677 }
678
Radek Krejci6b88a462021-02-17 12:39:34 +0100679 if (((ext->substmts[u].cardinality == LY_STMT_CARD_MAND) || (ext->substmts[u].cardinality == LY_STMT_CARD_SOME)) && !stmt_counter) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100680 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
Radek Krejci6b88a462021-02-17 12:39:34 +0100681 ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200682 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200683 goto cleanup;
684 }
685 }
686
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200687cleanup:
Radek Krejci6b88a462021-02-17 12:39:34 +0100688 ctx->ext = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200689 return ret;
690}
691
692/**
693 * @brief Check when for cyclic dependencies.
694 *
695 * @param[in] set Set with all the referenced nodes.
696 * @param[in] node Node whose "when" referenced nodes are in @p set.
697 * @return LY_ERR value
698 */
699static LY_ERR
700lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
701{
702 struct lyxp_set tmp_set;
703 struct lyxp_set_scnode *xp_scnode;
704 uint32_t i, j;
705 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200706 LY_ERR ret = LY_SUCCESS;
707
708 memset(&tmp_set, 0, sizeof tmp_set);
709
710 /* prepare in_ctx of the set */
711 for (i = 0; i < set->used; ++i) {
712 xp_scnode = &set->val.scnodes[i];
713
Radek Krejcif13b87b2020-12-01 22:02:17 +0100714 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200715 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100716 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200717 }
718 }
719
720 for (i = 0; i < set->used; ++i) {
721 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100722 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200723 /* already checked */
724 continue;
725 }
726
Michal Vasko1a09b212021-05-06 13:00:10 +0200727 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200728 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200729 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200730 continue;
731 }
732
733 node = xp_scnode->scnode;
734 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100735 struct lysc_when **when_list, *when;
736
Radek Krejciddace2c2021-01-08 11:30:56 +0100737 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100738 when_list = lysc_node_when(node);
739 LY_ARRAY_FOR(when_list, u) {
740 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200741 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vasko400e9672021-01-11 13:39:17 +0100742 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200743 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100744 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200745 goto cleanup;
746 }
747
748 for (j = 0; j < tmp_set.used; ++j) {
749 /* skip roots'n'stuff */
750 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
751 /* try to find this node in our set */
752 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100753 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
754 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100755 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition includes a self-reference.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200756 ret = LY_EVALID;
757 goto cleanup;
758 }
759
760 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100761 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200762 } else {
763 /* no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200764 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200765 }
766 }
767
768 /* merge this set into the global when set */
769 lyxp_set_scnode_merge(set, &tmp_set);
770 }
771
772 /* check when of non-data parents as well */
773 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100774
Radek Krejciddace2c2021-01-08 11:30:56 +0100775 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200776 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
777
778 /* this node when was checked (xp_scnode could have been reallocd) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100779 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_START_USED;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200780 }
781
782cleanup:
783 lyxp_set_free_content(&tmp_set);
784 return ret;
785}
786
787LY_ERR
788lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
789 const char *name2)
790{
791 uint16_t flg1, flg2;
792
793 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
794 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
795
796 if ((flg1 < flg2) && (mod1 == mod2)) {
797 if (ctx) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100798 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200799 "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
800 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
801 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
802 }
803 return LY_EVALID;
804 }
805
806 return LY_SUCCESS;
807}
808
Michal Vasko25d6ad02020-10-22 12:20:22 +0200809LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200810lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100811 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200812{
813 uint32_t i;
814 const char *ptr, *start;
815 const struct lys_module *mod;
816
Michal Vasko25d6ad02020-10-22 12:20:22 +0200817 assert(implement || mod_p);
818
Michal Vaskocfaff232020-10-20 09:35:14 +0200819 for (i = 0; i < expr->used; ++i) {
820 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
821 /* token cannot have a prefix */
822 continue;
823 }
824
825 start = expr->expr + expr->tok_pos[i];
826 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
827 /* token without a prefix */
828 continue;
829 }
830
831 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
832 /* unknown prefix, do not care right now */
833 continue;
834 }
835
836 if (!mod->implemented) {
837 /* unimplemented module found */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200838 if (implement) {
Michal Vasko405cc9e2020-12-01 12:01:27 +0100839 LY_CHECK_RET(lys_set_implemented_r((struct lys_module *)mod, NULL, unres));
Michal Vasko40c158c2021-04-28 17:01:03 +0200840 if (unres->recompile) {
841 return LY_ERECOMPILE;
842 }
Michal Vasko25d6ad02020-10-22 12:20:22 +0200843 } else {
Michal Vaskocfaff232020-10-20 09:35:14 +0200844 *mod_p = mod;
Michal Vasko25d6ad02020-10-22 12:20:22 +0200845 break;
Michal Vaskocfaff232020-10-20 09:35:14 +0200846 }
Michal Vaskocfaff232020-10-20 09:35:14 +0200847 }
848 }
849
Michal Vasko25d6ad02020-10-22 12:20:22 +0200850 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200851}
852
853/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200854 * @brief Check when/must expressions of a node on a complete compiled schema tree.
855 *
856 * @param[in] ctx Compile context.
857 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100858 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200859 * @return LY_ERECOMPILE
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200860 * @return LY_ERR value
861 */
862static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100863lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200864{
865 struct lyxp_set tmp_set;
866 uint32_t i, opts;
867 LY_ARRAY_COUNT_TYPE u;
868 ly_bool input_done = 0;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100869 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200870 struct lysc_must *musts = NULL;
871 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200872 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200873
Radek Krejciddace2c2021-01-08 11:30:56 +0100874 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100875
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200876 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100877 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200878
Radek Krejci9a3823e2021-01-27 20:26:46 +0100879 whens = lysc_node_when(node);
880 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200881
Radek Krejci9a3823e2021-01-27 20:26:46 +0100882 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200883 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200884 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200885 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100886 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200887 if (ret) {
888 goto cleanup;
889 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200890 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100891 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200892 continue;
893 }
894
895 /* check "when" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200896 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Radek Krejci9a3823e2021-01-27 20:26:46 +0100897 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200898 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100899 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200900 goto cleanup;
901 }
902
903 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100904 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200905 for (i = 0; i < tmp_set.used; ++i) {
906 /* skip roots'n'stuff */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100907 if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (tmp_set.val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START_USED)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200908 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
909
910 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100911 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200912 schema->name);
913 LY_CHECK_GOTO(ret, cleanup);
914
Michal Vasko1a09b212021-05-06 13:00:10 +0200915 /* check dummy node children/value accessing */
916 if (lysc_data_parent(schema) == node) {
917 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
918 ret = LY_EVALID;
919 goto cleanup;
920 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
921 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200922 ret = LY_EVALID;
923 goto cleanup;
924 }
925 }
926 }
927
928 /* check cyclic dependencies */
929 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
930 LY_CHECK_GOTO(ret, cleanup);
931
932 lyxp_set_free_content(&tmp_set);
933 }
934
935check_musts:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200936 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200937 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200938 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200939 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100940 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200941 if (ret) {
942 goto cleanup;
943 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200944 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
945 musts[u].cond->expr, mod->name);
946 continue;
947 }
948
949 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200950 ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes, node,
Michal Vasko400e9672021-01-11 13:39:17 +0100951 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200952 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100953 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200954 goto cleanup;
955 }
956
957 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100958 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200959 for (i = 0; i < tmp_set.used; ++i) {
960 /* skip roots'n'stuff */
961 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
962 /* XPath expression cannot reference "lower" status than the node that has the definition */
963 ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
964 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
965 LY_CHECK_GOTO(ret, cleanup);
966 }
967 }
968
969 lyxp_set_free_content(&tmp_set);
970 }
971
972 if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
973 /* now check output musts */
974 input_done = 1;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100975 whens = NULL;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100976 musts = ((struct lysc_node_action *)node)->output.musts;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200977 opts = LYXP_SCNODE_OUTPUT;
978 goto check_musts;
979 }
980
981cleanup:
982 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +0100983 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200984 return ret;
985}
986
987/**
988 * @brief Check leafref for its target existence on a complete compiled schema tree.
989 *
990 * @param[in] ctx Compile context.
991 * @param[in] node Context node for the leafref.
992 * @param[in] lref Leafref to check/resolve.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100993 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200994 * @return LY_ERECOMPILE if context recompilation is needed,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200995 * @return LY_ERR value.
996 */
997static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100998lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
999 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001000{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001001 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001002 struct ly_path *p;
1003 struct lysc_type *type;
1004
1005 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1006
1007 /* try to find the target */
Radek Krejcid5d37432021-03-12 13:46:40 +01001008 LY_CHECK_RET(ly_path_compile(ctx->ctx, lref->cur_mod, node, NULL, lref->path, LY_PATH_LREF_TRUE,
Michal Vaskod1e53b92021-01-28 13:11:06 +01001009 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Radek Krejci8df109d2021-04-23 12:19:08 +02001010 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, unres, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001011
1012 /* get the target node */
1013 target = p[LY_ARRAY_COUNT(p) - 1].node;
1014 ly_path_free(node->module->ctx, p);
1015
1016 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001017 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001018 lref->path->expr, lys_nodetype2str(target->nodetype));
1019 return LY_EVALID;
1020 }
1021
1022 /* check status */
1023 ctx->path[0] = '\0';
1024 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1025 ctx->path_len = strlen(ctx->path);
1026 if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
1027 return LY_EVALID;
1028 }
1029 ctx->path_len = 1;
1030 ctx->path[1] = '\0';
1031
1032 /* check config */
1033 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001034 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001035 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001036 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1037 return LY_EVALID;
1038 }
1039 }
1040
1041 /* store the target's type and check for circular chain of leafrefs */
1042 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1043 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
1044 if (type == (struct lysc_type *)lref) {
1045 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001046 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1047 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001048 return LY_EVALID;
1049 }
1050 }
1051
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001052 /* TODO check if leafref and its target are under common if-features */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001053
1054 return LY_SUCCESS;
1055}
1056
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001057/**
1058 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1059 *
1060 * @param[in] ctx Compile context.
1061 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1062 * @param[in] type Type of the default value.
1063 * @param[in] dflt Default value.
1064 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1065 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001066 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001067 * @return LY_ERR value.
1068 */
1069static LY_ERR
1070lys_compile_unres_dflt(struct lysc_ctx *ctx, struct lysc_node *node, struct lysc_type *type, const char *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001071 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001072{
1073 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001074 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001075 struct ly_err_item *err = NULL;
1076
Radek Krejci0b013302021-03-29 15:22:32 +02001077 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +02001078 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001079 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001080 if (ret == LY_ERECOMPILE) {
1081 /* fine, but we need to recompile */
1082 return LY_ERECOMPILE;
1083 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001084 /* we have no data so we will not be resolving it */
1085 ret = LY_SUCCESS;
1086 }
1087
1088 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001089 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001090 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001091 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001092 ly_err_free(err);
1093 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001094 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001095 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001096 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001097 return ret;
1098 }
1099
1100 ++((struct lysc_type *)storage->realtype)->refcount;
1101 return LY_SUCCESS;
1102}
1103
1104/**
1105 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1106 *
1107 * @param[in] ctx Compile context.
1108 * @param[in] leaf Leaf that the default value is for.
1109 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001110 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001111 * @return LY_ERR value.
1112 */
1113static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001114lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1115 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001116{
1117 LY_ERR ret;
1118
1119 assert(!leaf->dflt);
1120
1121 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1122 /* ignore default values for keys and mandatory leaves */
1123 return LY_SUCCESS;
1124 }
1125
1126 /* allocate the default value */
1127 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1128 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1129
1130 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001131 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001132 if (ret) {
1133 free(leaf->dflt);
1134 leaf->dflt = NULL;
1135 }
1136
1137 return ret;
1138}
1139
1140/**
1141 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1142 *
1143 * @param[in] ctx Compile context.
1144 * @param[in] llist Leaf-list that the default value(s) are for.
1145 * @param[in] dflt Default value to compile, in case of a single value.
1146 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001147 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001148 * @return LY_ERR value.
1149 */
1150static LY_ERR
1151lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001152 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001153{
1154 LY_ERR ret;
1155 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1156
1157 assert(dflt || dflts);
1158
Radek Krejcic7d13e32020-12-09 12:32:24 +01001159 /* in case there were already some defaults and we are adding new by deviations */
1160 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001161
1162 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001163 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, orig_count + (dflts ? LY_ARRAY_COUNT(dflts) : 1), LY_EMEM);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001164
1165 /* fill each new default value */
1166 if (dflts) {
1167 LY_ARRAY_FOR(dflts, u) {
1168 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001169 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001170 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001171 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1172 LY_ARRAY_INCREMENT(llist->dflts);
1173 }
1174 } else {
1175 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001176 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001177 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001178 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1179 LY_ARRAY_INCREMENT(llist->dflts);
1180 }
1181
1182 /* check default value uniqueness */
1183 if (llist->flags & LYS_CONFIG_W) {
1184 /* configuration data values must be unique - so check the default values */
1185 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1186 for (v = 0; v < u; ++v) {
1187 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001188 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001189 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001190 llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON, NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001191 lysc_update_path(ctx, NULL, NULL);
1192 return LY_EVALID;
1193 }
1194 }
1195 }
1196 }
1197
1198 return LY_SUCCESS;
1199}
1200
Michal Vasko405cc9e2020-12-01 12:01:27 +01001201LY_ERR
1202lys_compile_unres_glob(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1203{
Radek Krejci2efc45b2020-12-22 16:25:44 +01001204 LY_ERR ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001205 struct lysc_node *node;
1206 struct lysc_type *type, *typeiter;
1207 struct lysc_type_leafref *lref;
1208 struct lysc_ctx cctx = {0};
1209 LY_ARRAY_COUNT_TYPE v;
1210 uint32_t i;
1211
1212 if (unres->recompile) {
Michal Vasko40c158c2021-04-28 17:01:03 +02001213recompilation:
1214 assert(unres->recompile);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001215 /* recompile all the modules and resolve the new unres instead (during recompilation) */
1216 unres->recompile = 0;
1217 return lys_recompile(ctx, 1);
1218 }
1219
1220 /* fake compile context */
1221 cctx.ctx = ctx;
1222 cctx.path_len = 1;
1223 cctx.path[0] = '/';
1224
1225 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1226 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
1227 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
1228 for (i = 0; i < unres->leafrefs.count; ++i) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001229 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001230 node = unres->leafrefs.objs[i];
1231 cctx.cur_mod = node->module;
1232 cctx.pmod = node->module->parsed;
1233
Radek Krejciddace2c2021-01-08 11:30:56 +01001234 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001235
Michal Vasko405cc9e2020-12-01 12:01:27 +01001236 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1237 type = ((struct lysc_node_leaf *)node)->type;
1238 if (type->basetype == LY_TYPE_LEAFREF) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001239 ret = lys_compile_unres_leafref(&cctx, node, (struct lysc_type_leafref *)type, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001240 } else if (type->basetype == LY_TYPE_UNION) {
1241 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1242 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1243 lref = (struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001244 ret = lys_compile_unres_leafref(&cctx, node, lref, unres);
1245 if (ret) {
1246 break;
1247 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001248 }
1249 }
1250 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001251
Radek Krejciddace2c2021-01-08 11:30:56 +01001252 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko40c158c2021-04-28 17:01:03 +02001253 if (ret == LY_ERECOMPILE) {
1254 /* leafref caused a new module to be implemented, following leafrefs referencing the module would fail */
1255 goto recompilation;
1256 } else if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001257 return ret;
1258 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001259 }
1260 while (unres->leafrefs.count) {
1261 node = unres->leafrefs.objs[unres->leafrefs.count - 1];
1262 cctx.cur_mod = node->module;
1263 cctx.pmod = node->module->parsed;
1264
Radek Krejciddace2c2021-01-08 11:30:56 +01001265 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001266
Michal Vasko405cc9e2020-12-01 12:01:27 +01001267 /* store pointer to the real type */
1268 type = ((struct lysc_node_leaf *)node)->type;
1269 if (type->basetype == LY_TYPE_LEAFREF) {
1270 for (typeiter = ((struct lysc_type_leafref *)type)->realtype;
1271 typeiter->basetype == LY_TYPE_LEAFREF;
1272 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1273 ((struct lysc_type_leafref *)type)->realtype = typeiter;
1274 } else if (type->basetype == LY_TYPE_UNION) {
1275 LY_ARRAY_FOR(((struct lysc_type_union *)type)->types, v) {
1276 if (((struct lysc_type_union *)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
1277 for (typeiter = ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype;
1278 typeiter->basetype == LY_TYPE_LEAFREF;
1279 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
1280 ((struct lysc_type_leafref *)((struct lysc_type_union *)type)->types[v])->realtype = typeiter;
1281 }
1282 }
1283 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001284 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001285
1286 ly_set_rm_index(&unres->leafrefs, unres->leafrefs.count - 1, NULL);
1287 }
1288
1289 /* check xpath */
1290 while (unres->xpath.count) {
1291 node = unres->xpath.objs[unres->xpath.count - 1];
1292 cctx.cur_mod = node->module;
1293 cctx.pmod = node->module->parsed;
1294
Radek Krejciddace2c2021-01-08 11:30:56 +01001295 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001296
1297 ret = lys_compile_unres_xpath(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001298 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko40c158c2021-04-28 17:01:03 +02001299 if (ret == LY_ERECOMPILE) {
1300 goto recompilation;
1301 } else if (ret) {
1302 return ret;
1303 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001304
1305 ly_set_rm_index(&unres->xpath, unres->xpath.count - 1, NULL);
1306 }
1307
1308 /* finish incomplete default values compilation */
1309 while (unres->dflts.count) {
1310 struct lysc_unres_dflt *r = unres->dflts.objs[unres->dflts.count - 1];
1311 cctx.cur_mod = r->leaf->module;
1312 cctx.pmod = r->leaf->module->parsed;
1313
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001314 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001315
Radek Krejci2efc45b2020-12-22 16:25:44 +01001316 if (r->leaf->nodetype == LYS_LEAF) {
1317 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1318 } else {
1319 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1320 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001321 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko40c158c2021-04-28 17:01:03 +02001322 if (ret == LY_ERECOMPILE) {
1323 goto recompilation;
1324 } else if (ret) {
1325 return ret;
1326 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001327
1328 lysc_unres_dflt_free(ctx, r);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001329 ly_set_rm_index(&unres->dflts, unres->dflts.count - 1, NULL);
1330 }
1331
Michal Vasko40c158c2021-04-28 17:01:03 +02001332 /* some unres items may have been added */
1333 if (unres->leafrefs.count || unres->xpath.count || unres->dflts.count) {
Michal Vasko405cc9e2020-12-01 12:01:27 +01001334 return lys_compile_unres_glob(ctx, unres);
1335 }
1336
Michal Vasko30ab8e72021-04-19 12:47:52 +02001337 /* finally, remove all disabled nodes */
1338 for (i = 0; i < unres->disabled.count; ++i) {
1339 node = unres->disabled.snodes[i];
1340 if (node->flags & LYS_KEY) {
1341 LOG_LOCSET(node, NULL, NULL, NULL);
1342 LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled by its if-features.", node->name);
1343 LOG_LOCBACK(1, 0, 0, 0);
1344 return LY_EVALID;
1345 }
1346
1347 lysc_node_free(ctx, node, 1);
1348 }
1349
Michal Vasko405cc9e2020-12-01 12:01:27 +01001350 return LY_SUCCESS;
1351}
1352
1353void
1354lys_compile_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1355{
1356 uint32_t i;
1357 struct lys_module *m;
1358
1359 for (i = 0; i < unres->implementing.count; ++i) {
1360 m = unres->implementing.objs[i];
1361 assert(m->implemented);
1362
1363 /* make the module correctly non-implemented again */
1364 m->implemented = 0;
1365 lys_precompile_augments_deviations_revert(ctx, m);
1366 }
1367
1368 for (i = 0; i < unres->creating.count; ++i) {
1369 m = unres->creating.objs[i];
1370
1371 /* remove the module from the context and free it */
1372 ly_set_rm(&ctx->list, m, NULL);
Radek Krejci90ed21e2021-04-12 14:47:46 +02001373 lys_module_free(m);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001374 }
1375
1376 if (unres->implementing.count) {
1377 /* recompile because some implemented modules are no longer implemented */
1378 lys_recompile(ctx, 0);
1379 }
1380}
1381
1382void
1383lys_compile_unres_glob_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
1384{
1385 uint32_t i;
1386
1387 ly_set_erase(&unres->implementing, NULL);
1388 ly_set_erase(&unres->creating, NULL);
1389 for (i = 0; i < unres->dflts.count; ++i) {
1390 lysc_unres_dflt_free(ctx, unres->dflts.objs[i]);
1391 }
1392 ly_set_erase(&unres->dflts, NULL);
1393 ly_set_erase(&unres->xpath, NULL);
1394 ly_set_erase(&unres->leafrefs, NULL);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001395 ly_set_erase(&unres->disabled, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001396}
1397
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001398/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001399 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001400 *
1401 * @param[in] ctx Compile context with unres sets.
1402 * @return LY_ERR value.
1403 */
1404static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001405lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001406{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001407 struct lysc_augment *aug;
1408 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001409 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001410 uint32_t i;
1411
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001412 /* check that all augments were applied */
1413 for (i = 0; i < ctx->augs.count; ++i) {
1414 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001415 ctx->cur_mod = aug->aug_pmod->mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001416 lysc_update_path(ctx, NULL, "{augment}");
1417 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1418 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
Michal Vasko28fe5f62021-03-03 16:37:39 +01001419 aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001420 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001421 lysc_update_path(ctx, NULL, NULL);
1422 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001423 }
1424 if (ctx->augs.count) {
1425 return LY_ENOTFOUND;
1426 }
1427
1428 /* check that all deviations were applied */
1429 for (i = 0; i < ctx->devs.count; ++i) {
1430 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001431 lysc_update_path(ctx, NULL, "{deviation}");
1432 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1433 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1434 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1435 lysc_update_path(ctx, NULL, NULL);
1436 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001437 }
1438 if (ctx->devs.count) {
1439 return LY_ENOTFOUND;
1440 }
1441
1442 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001443}
1444
1445/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001446 * @brief Erase all the module unres sets in a compile context.
1447 *
1448 * @param[in] ctx Compile context with unres sets.
1449 * @param[in] error Whether the compilation finished with an error or not.
1450 */
1451static void
1452lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1453{
1454 uint32_t i;
1455
1456 ly_set_erase(&ctx->groupings, NULL);
1457 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001458
1459 if (!error) {
1460 /* there can be no leftover deviations or augments */
1461 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1462 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1463
1464 ly_set_erase(&ctx->augs, NULL);
1465 ly_set_erase(&ctx->devs, NULL);
1466 ly_set_erase(&ctx->uses_augs, NULL);
1467 ly_set_erase(&ctx->uses_rfns, NULL);
1468 } else {
1469 for (i = 0; i < ctx->augs.count; ++i) {
1470 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1471 }
1472 ly_set_erase(&ctx->augs, NULL);
1473 for (i = 0; i < ctx->devs.count; ++i) {
1474 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1475 }
1476 ly_set_erase(&ctx->devs, NULL);
1477 for (i = 0; i < ctx->uses_augs.count; ++i) {
1478 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1479 }
1480 ly_set_erase(&ctx->uses_augs, NULL);
1481 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1482 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1483 }
1484 ly_set_erase(&ctx->uses_rfns, NULL);
1485 }
1486}
1487
1488/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001489 * @brief Compile identites in the current module and all its submodules.
1490 *
1491 * @param[in] ctx Compile context.
1492 * @return LY_ERR value.
1493 */
1494static LY_ERR
1495lys_compile_identities(struct lysc_ctx *ctx)
1496{
1497 struct lysp_submodule *submod;
1498 LY_ARRAY_COUNT_TYPE u;
1499
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001500 if (ctx->cur_mod->parsed->identities) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001501 LY_CHECK_RET(lys_compile_identities_derived(ctx, ctx->cur_mod->parsed->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001502 }
1503 lysc_update_path(ctx, NULL, "{submodule}");
1504 LY_ARRAY_FOR(ctx->cur_mod->parsed->includes, u) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001505 submod = ctx->cur_mod->parsed->includes[u].submodule;
1506 if (submod->identities) {
1507 lysc_update_path(ctx, NULL, submod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001508 LY_CHECK_RET(lys_compile_identities_derived(ctx, submod->identities, &ctx->cur_mod->identities));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001509 lysc_update_path(ctx, NULL, NULL);
1510 }
1511 }
1512 lysc_update_path(ctx, NULL, NULL);
1513
1514 return LY_SUCCESS;
1515}
1516
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001517LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001518lys_recompile(struct ly_ctx *ctx, ly_bool log)
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001519{
1520 uint32_t idx;
1521 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001522 struct lys_glob_unres unres = {0};
1523 LY_ERR ret = LY_SUCCESS;
Radek Krejci430a5582020-12-01 13:35:18 +01001524 uint32_t prev_lo = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001525
Michal Vasko1ccbf542021-04-19 11:35:00 +02001526 /* we are always recompiling all the modules */
1527 unres.full_compilation = 1;
1528
Michal Vasko405cc9e2020-12-01 12:01:27 +01001529 if (!log) {
1530 /* recompile, must succeed because the modules were already compiled; hide messages because any
1531 * warnings were already printed, are not really relevant, and would hide the real error */
1532 prev_lo = ly_log_options(0);
1533 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001534
1535 /* free all the modules */
1536 for (idx = 0; idx < ctx->list.count; ++idx) {
1537 mod = ctx->list.objs[idx];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001538 if (mod->compiled) {
1539 /* free the module */
Radek Krejci90ed21e2021-04-12 14:47:46 +02001540 lysc_module_free(mod->compiled);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001541 mod->compiled = NULL;
1542 }
1543
1544 /* free precompiled iffeatures */
1545 lys_free_feature_iffeatures(mod->parsed);
1546 }
1547
1548 /* recompile all the modules */
1549 for (idx = 0; idx < ctx->list.count; ++idx) {
1550 mod = ctx->list.objs[idx];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001551 if (!mod->implemented || mod->compiled) {
1552 /* nothing to do */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001553 continue;
1554 }
1555
Michal Vasko405cc9e2020-12-01 12:01:27 +01001556 /* recompile */
Michal Vaskoe8220db2021-06-02 15:39:05 +02001557 ret = lys_compile(mod, 0, 1, &unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001558 if (ret) {
1559 if (!log) {
1560 LOGERR(mod->ctx, ret, "Recompilation of module \"%s\" failed.", mod->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001561 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001562 goto cleanup;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001563 }
Michal Vasko1ccbf542021-04-19 11:35:00 +02001564
1565 if (unres.recompile) {
1566 /* we need to recompile again (newly compiled module caused another new implemented module) */
1567 ret = lys_recompile(ctx, log);
1568 goto cleanup;
1569 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001570 }
1571
Michal Vasko405cc9e2020-12-01 12:01:27 +01001572 /* resolve global unres */
1573 LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
1574
1575cleanup:
1576 if (!log) {
1577 ly_log_options(prev_lo);
1578 }
1579 lys_compile_unres_glob_erase(ctx, &unres);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001580 return ret;
1581}
1582
Michal Vasko1ccbf542021-04-19 11:35:00 +02001583/**
1584 * @brief Check whether a module does not have any (recursive) compiled import.
1585 *
1586 * @param[in] mod Module to examine.
1587 * @return Whether the module has a compiled imported module.
1588 */
1589static ly_bool
1590lys_has_compiled_import_r(struct lys_module *mod)
1591{
1592 LY_ARRAY_COUNT_TYPE u;
1593
1594 LY_ARRAY_FOR(mod->parsed->imports, u) {
1595 if (!mod->parsed->imports[u].module->implemented) {
1596 continue;
1597 }
1598
1599 if (mod->parsed->imports[u].module->compiled) {
1600 return 1;
1601 }
1602
1603 /* recursive */
1604 if (lys_has_compiled_import_r(mod->parsed->imports[u].module)) {
1605 return 1;
1606 }
1607 }
1608
1609 return 0;
1610}
1611
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001612LY_ERR
Michal Vaskoe8220db2021-06-02 15:39:05 +02001613lys_compile(struct lys_module *mod, uint32_t options, ly_bool recompile, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001614{
1615 struct lysc_ctx ctx = {0};
Michal Vasko0b395e12021-04-23 13:43:07 +02001616 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001617 struct lysp_module *sp;
1618 struct lysp_submodule *submod;
1619 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001620 struct lysp_node_grp *grp;
1621 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001622 LY_ERR ret = LY_SUCCESS;
1623
1624 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1625
Michal Vasko1ccbf542021-04-19 11:35:00 +02001626 /* if some previous module was not fully compiled, it is forbidden to compile another one (even though it
1627 * may be okay in some cases) */
Michal Vaskoe8220db2021-06-02 15:39:05 +02001628 assert(mod->implemented && !unres->recompile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001629
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001630 sp = mod->parsed;
1631
1632 ctx.ctx = mod->ctx;
1633 ctx.cur_mod = mod;
1634 ctx.pmod = sp;
1635 ctx.options = options;
1636 ctx.path_len = 1;
1637 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001638 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001639
Michal Vaskoe8220db2021-06-02 15:39:05 +02001640 /* skip compilation tasks that need to be performed only once for implemented modules */
1641 if (!recompile) {
1642 /* identities */
1643 LY_CHECK_GOTO(ret = lys_compile_identities(&ctx), cleanup);
Michal Vasko0b395e12021-04-23 13:43:07 +02001644
Michal Vaskoe8220db2021-06-02 15:39:05 +02001645 /* augments and deviations */
1646 LY_CHECK_GOTO(ret = lys_precompile_augments_deviations(&ctx), cleanup);
1647
1648 if (!unres->recompile && !unres->full_compilation) {
1649 /* check whether this module may reference any already-compiled modules */
1650 if (lys_has_compiled_import_r(mod)) {
1651 /* it may and we need even disabled nodes in those modules, recompile them */
1652 unres->recompile = 1;
1653 }
Michal Vasko0b395e12021-04-23 13:43:07 +02001654 }
Michal Vasko0b395e12021-04-23 13:43:07 +02001655
Michal Vaskoe8220db2021-06-02 15:39:05 +02001656 if (unres->recompile) {
1657 /* we need the context recompiled */
1658 goto cleanup;
1659 }
Michal Vasko0b395e12021-04-23 13:43:07 +02001660 }
1661
1662 /* now the actual compilation will take place */
1663 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001664 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1665 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1666 mod_c->mod = mod;
1667
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001668 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001669 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1670 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001671
1672 /* data nodes */
1673 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001674 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001675 }
1676
Radek Krejci2a9fc652021-01-22 17:44:34 +01001677 /* top-level RPCs */
1678 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001679 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001680 }
1681
1682 /* top-level notifications */
1683 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001684 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001685 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001686
1687 /* extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001688 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001689
1690 /* the same for submodules */
1691 LY_ARRAY_FOR(sp->includes, u) {
1692 submod = sp->includes[u].submodule;
1693 ctx.pmod = (struct lysp_module *)submod;
1694
1695 LY_LIST_FOR(submod->data, pnode) {
1696 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001697 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001698 }
1699
Radek Krejci2a9fc652021-01-22 17:44:34 +01001700 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1701 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001702 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001703 }
1704
1705 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1706 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001707 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001708 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001709
Michal Vasko1ccbf542021-04-19 11:35:00 +02001710 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001711 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001712 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001713
1714 /* validate non-instantiated groupings from the parsed schema,
1715 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001716 ctx.options |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001717 LY_LIST_FOR(sp->groupings, grp) {
1718 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001719 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001720 }
1721 }
1722 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001723 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1724 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001725 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001726 }
1727 }
1728 }
1729 LY_ARRAY_FOR(sp->includes, u) {
1730 submod = sp->includes[u].submodule;
1731 ctx.pmod = (struct lysp_module *)submod;
1732
Radek Krejci2a9fc652021-01-22 17:44:34 +01001733 LY_LIST_FOR(submod->groupings, grp) {
1734 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001735 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001736 }
1737 }
1738 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001739 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1740 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001741 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001742 }
1743 }
1744 }
1745 }
1746 ctx.pmod = sp;
1747
Radek Krejciddace2c2021-01-08 11:30:56 +01001748 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001749
Michal Vasko405cc9e2020-12-01 12:01:27 +01001750 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001751 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001752
Michal Vasko1ccbf542021-04-19 11:35:00 +02001753cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01001754 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001755 lys_compile_unres_mod_erase(&ctx, ret);
1756 if (ret) {
1757 lys_precompile_augments_deviations_revert(ctx.ctx, mod);
1758 lysc_module_free(mod_c);
1759 mod->compiled = NULL;
1760 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001761 return ret;
1762}