blob: 8ba8ad85af894b6ac40668b709cef2f9efa85cc6 [file] [log] [blame]
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001/**
2 * @file schema_compile.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko19a09022021-06-15 11:54:08 +02004 * @author Michal Vasko <mvasko@cesnet.cz>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02005 * @brief Schema compilation.
6 *
Michal Vasko19a09022021-06-15 11:54:08 +02007 * Copyright (c) 2015 - 2021 CESNET, z.s.p.o.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
16#define _GNU_SOURCE
17
18#include "schema_compile.h"
19
20#include <assert.h>
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020021#include <stddef.h>
22#include <stdint.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include "common.h"
28#include "compat.h"
29#include "context.h"
30#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020031#include "in.h"
Radek Krejci47fab892020-11-05 17:02:41 +010032#include "log.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020033#include "parser_schema.h"
34#include "path.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020035#include "plugins.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020036#include "plugins_exts.h"
Radek Krejci77114102021-03-10 15:21:57 +010037#include "plugins_exts_compile.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010038#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020039#include "plugins_types.h"
40#include "schema_compile_amend.h"
41#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010042#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020043#include "set.h"
44#include "tree.h"
45#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020046#include "tree_schema.h"
47#include "tree_schema_internal.h"
48#include "xpath.h"
49
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020050/**
51 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
52 */
53static LY_ERR
54lys_compile_extension(struct lysc_ctx *ctx, const struct lys_module *ext_mod, struct lysp_ext *ext_p, struct lysc_ext **ext)
55{
56 LY_ERR ret = LY_SUCCESS;
57
Radek Krejci720d2612021-03-03 19:44:22 +010058 if (ext_p->compiled && (ext_p->compiled->refcount == 1)) {
59 /* context recompilation - all the extension instances were previously freed (the last link to the compiled extension
60 * remains from the parsed extension definition) and now we are recompiling them again, to have the up-to-date
61 * extension definition, we have to recompile it as well now */
62 lysc_extension_free(ctx->ctx, &ext_p->compiled);
63 }
64
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020065 if (!ext_p->compiled) {
66 lysc_update_path(ctx, NULL, "{extension}");
67 lysc_update_path(ctx, NULL, ext_p->name);
68
69 /* compile the extension definition */
70 ext_p->compiled = calloc(1, sizeof **ext);
71 ext_p->compiled->refcount = 1;
72 DUP_STRING_GOTO(ctx->ctx, ext_p->name, ext_p->compiled->name, ret, done);
Radek Krejci9f87b0c2021-03-05 14:45:26 +010073 DUP_STRING_GOTO(ctx->ctx, ext_p->argname, ext_p->compiled->argname, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020074 ext_p->compiled->module = (struct lys_module *)ext_mod;
Radek Krejciab430862021-03-02 20:13:40 +010075 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext_p->compiled->exts, *ext, ret, done);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020076
77 lysc_update_path(ctx, NULL, NULL);
78 lysc_update_path(ctx, NULL, NULL);
79
80 /* find extension definition plugin */
Radek Krejci3e6632f2021-03-22 22:08:21 +010081 ext_p->compiled->plugin = lyplg_find(LYPLG_EXTENSION, ext_p->compiled->module->name,
82 ext_p->compiled->module->revision, ext_p->compiled->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020083 }
84
85 *ext = lysc_ext_dup(ext_p->compiled);
86
87done:
Radek Krejci2efc45b2020-12-22 16:25:44 +010088 if (ret) {
89 lysc_update_path(ctx, NULL, NULL);
90 lysc_update_path(ctx, NULL, NULL);
91 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020092 return ret;
93}
94
95LY_ERR
96lys_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 +010097 const struct lys_module *ext_mod)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020098{
Radek Krejci85ac8312021-03-03 20:21:33 +010099 LY_ERR ret = LY_SUCCESS;
100 struct lysp_ext *ext_def;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200101
Radek Krejciab430862021-03-02 20:13:40 +0100102 ext->parent_stmt = ext_p->parent_stmt;
103 ext->parent_stmt_index = ext_p->parent_stmt_index;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200104 ext->module = ctx->cur_mod;
105 ext->parent = parent;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200106
Radek Krejciab430862021-03-02 20:13:40 +0100107 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 +0100108 lysc_update_path(ctx, NULL, ext_p->name);
109
Radek Krejci85ac8312021-03-03 20:21:33 +0100110 LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, ext_p, &ext_mod, &ext_def), cleanup);
111 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, ext_mod, ext_def, &ext->def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200112
Radek Krejci9f87b0c2021-03-05 14:45:26 +0100113 if (ext_def->argname) {
Radek Krejci85ac8312021-03-03 20:21:33 +0100114 LY_CHECK_GOTO(ret = lysp_ext_instance_resolve_argument(ctx->ctx, ext_p, ext_def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200115 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200116
Radek Krejci85ac8312021-03-03 20:21:33 +0100117 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument, ret);
118 LY_CHECK_RET(ret);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200119
120 if (ext->def->plugin && ext->def->plugin->compile) {
121 if (ext->argument) {
Radek Krejcia6016992021-03-03 10:13:41 +0100122 lysc_update_path(ctx, ext->module, ext->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200123 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100124 ret = ext->def->plugin->compile(ctx, ext_p, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100125 if (ret == LY_ENOT) {
126 lysc_ext_instance_free(ctx->ctx, ext);
127 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200128 if (ext->argument) {
129 lysc_update_path(ctx, NULL, NULL);
130 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100131 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200132 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200133
134cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100135 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100136 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200137
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200138 return ret;
139}
140
141struct lysc_ext *
142lysc_ext_dup(struct lysc_ext *orig)
143{
144 ++orig->refcount;
145 return orig;
146}
147
Radek Krejcidab4f0b2021-03-29 14:07:18 +0200148API LY_ERR
Radek Krejci1b2eef82021-02-17 11:17:27 +0100149lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt, void **instance_p, enum ly_stmt_cardinality *cardinality_p)
150{
151 LY_ARRAY_COUNT_TYPE u;
152
153 LY_ARRAY_FOR(ext->substmts, u) {
Radek Krejci61837f72021-03-02 19:53:59 +0100154 if (LY_STMT_IS_DATA_NODE(substmt)) {
155 if (!LY_STMT_IS_DATA_NODE(ext->substmts[u].stmt)) {
Radek Krejci1b2eef82021-02-17 11:17:27 +0100156 continue;
157 }
158 } else if (LY_STMT_IS_OP(substmt)) {
159 if (!LY_STMT_IS_OP(ext->substmts[u].stmt)) {
160 continue;
161 }
162 } else if (ext->substmts[u].stmt != substmt) {
163 continue;
164 }
165
166 /* match */
167 if (cardinality_p) {
168 *cardinality_p = ext->substmts[u].cardinality;
169 }
170 if (instance_p) {
171 *instance_p = ext->substmts[u].storage;
172 }
173 return LY_SUCCESS;
174 }
175
176 return LY_ENOT;
177}
178
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200179static void
180lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
181{
182 assert(!r->dflt || !r->dflts);
183 if (r->dflt) {
184 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
185 free(r->dflt);
186 } else {
187 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
188 }
189 free(r);
190}
191
192void
Radek Krejcia6016992021-03-03 10:13:41 +0100193lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200194{
195 int len;
196 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
197
198 if (!name) {
199 /* removing last path segment */
200 if (ctx->path[ctx->path_len - 1] == '}') {
201 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
202 if (ctx->path[ctx->path_len] == '=') {
203 ctx->path[ctx->path_len++] = '}';
204 } else {
205 /* not a top-level special tag, remove also preceiding '/' */
206 goto remove_nodelevel;
207 }
208 } else {
209remove_nodelevel:
210 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
211 if (ctx->path_len == 0) {
212 /* top-level (last segment) */
213 ctx->path_len = 1;
214 }
215 }
216 /* set new terminating NULL-byte */
217 ctx->path[ctx->path_len] = '\0';
218 } else {
219 if (ctx->path_len > 1) {
Radek Krejcia6016992021-03-03 10:13:41 +0100220 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200221 /* extension of the special tag */
222 nextlevel = 2;
223 --ctx->path_len;
224 } else {
225 /* there is already some path, so add next level */
226 nextlevel = 1;
227 }
228 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
229
230 if (nextlevel != 2) {
Radek Krejcia6016992021-03-03 10:13:41 +0100231 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200232 /* module not changed, print the name unprefixed */
233 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
234 } else {
235 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
236 }
237 } else {
238 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
239 }
240 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
241 /* output truncated */
242 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
243 } else {
244 ctx->path_len += len;
245 }
246 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100247
Radek Krejciddace2c2021-01-08 11:30:56 +0100248 LOG_LOCBACK(0, 0, 1, 0);
249 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200250}
251
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200252LY_ERR
253lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
254 struct lysp_ident *identities_p, struct lysc_ident **identities)
255{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100256 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200257 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100258 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200259 LY_ERR ret = LY_SUCCESS;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100260 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200261
262 assert(ctx_sc || ctx);
263
264 if (!ctx_sc) {
265 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100266 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200267 context.pmod = parsed_mod;
268 context.path_len = 1;
269 context.path[0] = '/';
270 ctx_sc = &context;
271 }
272
273 if (!identities_p) {
274 return LY_SUCCESS;
275 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200276
277 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200278 LY_ARRAY_FOR(identities_p, u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100279 /* evaluate if-features */
280 LY_CHECK_RET(lys_eval_iffeatures(ctx, identities_p[u].iffeatures, &enabled));
281 if (!enabled) {
282 continue;
283 }
284
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200285 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
286
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100287 /* add new compiled identity */
288 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
289
290 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
291 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
292 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
293 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200294 /* 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 +0100295 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100296 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200297
298 lysc_update_path(ctx_sc, NULL, NULL);
299 }
300 lysc_update_path(ctx_sc, NULL, NULL);
301done:
302 return ret;
303}
304
305/**
306 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
307 *
308 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
309 *
310 * @param[in] ctx Compile context for logging.
311 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
312 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
313 * @return LY_SUCCESS if everything is ok.
314 * @return LY_EVALID if the identity is derived from itself.
315 */
316static LY_ERR
317lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
318{
319 LY_ERR ret = LY_SUCCESS;
320 LY_ARRAY_COUNT_TYPE u, v;
321 struct ly_set recursion = {0};
322 struct lysc_ident *drv;
323
324 if (!derived) {
325 return LY_SUCCESS;
326 }
327
328 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
329 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100330 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200331 "Identity \"%s\" is indirectly derived from itself.", ident->name);
332 ret = LY_EVALID;
333 goto cleanup;
334 }
335 ret = ly_set_add(&recursion, derived[u], 0, NULL);
336 LY_CHECK_GOTO(ret, cleanup);
337 }
338
339 for (v = 0; v < recursion.count; ++v) {
340 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200341 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
342 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100343 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200344 "Identity \"%s\" is indirectly derived from itself.", ident->name);
345 ret = LY_EVALID;
346 goto cleanup;
347 }
348 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
349 LY_CHECK_GOTO(ret, cleanup);
350 }
351 }
352
353cleanup:
354 ly_set_erase(&recursion, NULL);
355 return ret;
356}
357
358LY_ERR
359lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100360 struct lysc_ident *ident, struct lysc_ident ***bases, ly_bool *enabled)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200361{
362 LY_ARRAY_COUNT_TYPE u, v;
363 const char *s, *name;
364 const struct lys_module *mod;
365 struct lysc_ident **idref;
366
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100367 assert((ident && enabled) || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200368
369 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100370 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200371 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
372 return LY_EVALID;
373 }
374
375 LY_ARRAY_FOR(bases_p, u) {
376 s = strchr(bases_p[u], ':');
377 if (s) {
378 /* prefixed identity */
379 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200380 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 +0200381 } else {
382 name = bases_p[u];
383 mod = base_pmod->mod;
384 }
385 if (!mod) {
386 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100387 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200388 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
389 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100390 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200391 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
392 }
393 return LY_EVALID;
394 }
395
396 idref = NULL;
397 LY_ARRAY_FOR(mod->identities, v) {
398 if (!strcmp(name, mod->identities[v].name)) {
399 if (ident) {
400 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100401 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200402 "Identity \"%s\" is derived from itself.", ident->name);
403 return LY_EVALID;
404 }
405 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
406 /* we have match! store the backlink */
407 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
408 *idref = ident;
409 } else {
410 /* we have match! store the found identity */
411 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
412 *idref = &mod->identities[v];
413 }
414 break;
415 }
416 }
417 if (!idref || !(*idref)) {
Michal Vasko7c565922021-06-10 14:58:27 +0200418 if (ident || (ctx->compile_opts & LYS_COMPILE_DISABLED)) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100419 /* look into the parsed module to check whether the identity is not merely disabled */
420 LY_ARRAY_FOR(mod->parsed->identities, v) {
421 if (!strcmp(mod->parsed->identities[v].name, name)) {
Radek Krejci10443f42021-03-28 17:40:35 +0200422 if (ident) {
423 *enabled = 0;
424 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100425 return LY_SUCCESS;
426 }
427 }
Radek Krejci10443f42021-03-28 17:40:35 +0200428 }
429 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100430 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200431 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
432 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100433 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200434 "Unable to find base (%s) of identityref.", bases_p[u]);
435 }
436 return LY_EVALID;
437 }
438 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100439
440 if (ident) {
441 *enabled = 1;
442 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200443 return LY_SUCCESS;
444}
445
446/**
447 * @brief For the given array of identities, set the backlinks from all their base identities.
448 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
449 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100450 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set. Any
451 * identities with disabled bases are removed.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200452 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
453 */
454static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100455lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200456{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100457 LY_ARRAY_COUNT_TYPE u, v;
458 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200459
460 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100461
462restart:
Radek Krejcic7d13e32020-12-09 12:32:24 +0100463 for (u = 0, v = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100464 /* find matching parsed identity, the disabled ones are missing in the compiled array */
465 while (v < LY_ARRAY_COUNT(idents_p)) {
466 if (idents_p[v].name == (*idents)[u].name) {
467 break;
468 }
469 ++v;
470 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100471
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200472 if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) {
473 /* identity not found (it may be from a submodule) or identity without bases */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200474 continue;
475 }
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200476
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100477 lysc_update_path(ctx, NULL, (*idents)[u].name);
Michal Vaskofc0dc522021-06-15 15:27:34 +0200478 LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL, &enabled));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200479 lysc_update_path(ctx, NULL, NULL);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100480
481 if (!enabled) {
482 /* remove the identity */
483 lysc_ident_free(ctx->ctx, &(*idents)[u]);
484 LY_ARRAY_DECREMENT(*idents);
485 if (u < LY_ARRAY_COUNT(*idents)) {
486 memmove(&(*idents)[u], &(*idents)[u + 1], (LY_ARRAY_COUNT(*idents) - u) * sizeof **idents);
487 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100488
489 /* revert compilation of all the previous identities */
490 for (v = 0; v < u; ++v) {
491 LY_ARRAY_FREE((*idents)[v].derived);
Radek Krejci454820e2021-03-28 17:57:45 +0200492 (*idents)[v].derived = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100493 }
494
Michal Vasko74c82ae2020-11-03 17:36:53 +0100495 /* free the whole array if there are no identites left */
496 if (!LY_ARRAY_COUNT(*idents)) {
497 LY_ARRAY_FREE(*idents);
498 *idents = NULL;
499 }
500
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100501 /* restart the whole process without this identity */
502 goto restart;
503 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200504 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100505
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200506 lysc_update_path(ctx, NULL, NULL);
507 return LY_SUCCESS;
508}
509
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200510static void *
511lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
512{
513 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
514 if (substmts[u].stmt == stmt) {
515 return substmts[u].storage;
516 }
517 }
518 return NULL;
519}
520
521LY_ERR
Radek Krejci6b88a462021-02-17 12:39:34 +0100522lys_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 +0200523{
aPiecek1c4da362021-04-29 14:26:34 +0200524 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200525 LY_ARRAY_COUNT_TYPE u;
526 struct lysp_stmt *stmt;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200527 void *parsed = NULL, **compiled = NULL;
528
529 /* check for invalid substatements */
Radek Krejci6b88a462021-02-17 12:39:34 +0100530 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200531 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
532 continue;
533 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100534 LY_ARRAY_FOR(ext->substmts, u) {
535 if (ext->substmts[u].stmt == stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200536 break;
537 }
538 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100539 if (u == LY_ARRAY_COUNT(ext->substmts)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100540 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 +0100541 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200542 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200543 goto cleanup;
544 }
545 }
546
547 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
548
Radek Krejci6b88a462021-02-17 12:39:34 +0100549 /* note into the compile context that we are processing extension now */
550 ctx->ext = ext;
551
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200552 /* keep order of the processing the same as the order in the defined substmts,
553 * 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 +0200554
Radek Krejci6b88a462021-02-17 12:39:34 +0100555 LY_ARRAY_FOR(ext->substmts, u) {
556 uint64_t stmt_counter = 0;
557
558 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
559 if (ext->substmts[u].stmt != stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200560 continue;
561 }
562
Radek Krejci6b88a462021-02-17 12:39:34 +0100563 parsed = NULL;
564 stmt_counter++;
565 if (ext->substmts[u].storage) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200566 switch (stmt->kw) {
Radek Krejci6b88a462021-02-17 12:39:34 +0100567 case LY_STMT_ACTION:
568 case LY_STMT_ANYDATA:
569 case LY_STMT_ANYXML:
570 case LY_STMT_CONTAINER:
571 case LY_STMT_CHOICE:
572 case LY_STMT_LEAF:
573 case LY_STMT_LEAF_LIST:
574 case LY_STMT_LIST:
575 case LY_STMT_NOTIFICATION:
576 case LY_STMT_RPC:
577 case LY_STMT_USES:
aPiecek60d9d672021-04-27 15:49:57 +0200578 if (!ext_p->parsed) {
579 struct lysp_ext_instance *unconst_ext_p;
580 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
581 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
582 unconst_ext_p = (struct lysp_ext_instance *)ext_p;
583 unconst_ext_p->parsed = parsed;
584 } else {
Michal Vaskoa9309bb2021-07-09 09:31:55 +0200585 struct lysp_node *node, *last_node = NULL;
aPiecek60d9d672021-04-27 15:49:57 +0200586 /* get last parsed node */
587 LY_LIST_FOR(ext_p->parsed, node) {
588 last_node = node;
589 }
590 /* create and link sibling */
591 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
592 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
593 last_node->next = parsed;
594 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100595
596 /* set storage as an alternative document root in the compile context */
597 r = lys_compile_node(ctx, parsed, NULL, 0, NULL);
Radek Krejci6b88a462021-02-17 12:39:34 +0100598 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200599 break;
Radek Krejci1b2eef82021-02-17 11:17:27 +0100600 case LY_STMT_DESCRIPTION:
601 case LY_STMT_REFERENCE:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200602 case LY_STMT_UNITS: {
Radek Krejci6b88a462021-02-17 12:39:34 +0100603 const char **str_p;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200604
Radek Krejci6b88a462021-02-17 12:39:34 +0100605 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200606 /* single item */
Radek Krejci6b88a462021-02-17 12:39:34 +0100607 if (*((const char **)ext->substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100608 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200609 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200610 goto cleanup;
611 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100612 str_p = (const char **)ext->substmts[u].storage;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200613 } else {
614 /* sized array */
Radek Krejci6b88a462021-02-17 12:39:34 +0100615 const char ***strings_array = (const char ***)ext->substmts[u].storage;
616 LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200617 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100618 r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200619 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
620 break;
621 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100622 case LY_STMT_IF_FEATURE: {
623 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200624
Radek Krejci76c8c4e2021-02-17 10:16:48 +0100625 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200626 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Radek Krejci6b88a462021-02-17 12:39:34 +0100627
628 r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled);
629 FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100630 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
631 if (!enabled) {
632 /* it is disabled, remove the whole extension instance */
633 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200634 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200635 break;
Radek Krejci6b88a462021-02-17 12:39:34 +0100636 }
637 case LY_STMT_STATUS:
638 assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME);
639 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
640 break;
641 case LY_STMT_TYPE: {
642 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts);
643 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts);
644
645 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
646 /* single item */
647 if (*(struct lysc_type **)ext->substmts[u].storage) {
648 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200649 ret = LY_EVALID;
Radek Krejci6b88a462021-02-17 12:39:34 +0100650 goto cleanup;
651 }
652 compiled = ext->substmts[u].storage;
653 } else {
654 /* sized array */
655 struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL;
656 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
657 compiled = (void *)type;
658 }
659
660 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
661 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
662 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled,
663 units && !*units ? units : NULL, NULL);
664 lysp_type_free(ctx->ctx, parsed);
665 free(parsed);
666 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
667 break;
668 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200669 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
670 * also note that in many statements their extensions are not taken into account */
671 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100672 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 +0100673 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200674 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200675 goto cleanup;
676 }
677 }
678 }
679
Radek Krejci6b88a462021-02-17 12:39:34 +0100680 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 +0100681 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
Radek Krejci6b88a462021-02-17 12:39:34 +0100682 ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200683 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200684 goto cleanup;
685 }
686 }
687
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200688cleanup:
Radek Krejci6b88a462021-02-17 12:39:34 +0100689 ctx->ext = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200690 return ret;
691}
692
693/**
694 * @brief Check when for cyclic dependencies.
695 *
696 * @param[in] set Set with all the referenced nodes.
697 * @param[in] node Node whose "when" referenced nodes are in @p set.
698 * @return LY_ERR value
699 */
700static LY_ERR
701lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
702{
703 struct lyxp_set tmp_set;
704 struct lyxp_set_scnode *xp_scnode;
705 uint32_t i, j;
706 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200707 LY_ERR ret = LY_SUCCESS;
708
709 memset(&tmp_set, 0, sizeof tmp_set);
710
711 /* prepare in_ctx of the set */
712 for (i = 0; i < set->used; ++i) {
713 xp_scnode = &set->val.scnodes[i];
714
Radek Krejcif13b87b2020-12-01 22:02:17 +0100715 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200716 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100717 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200718 }
719 }
720
721 for (i = 0; i < set->used; ++i) {
722 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100723 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200724 /* already checked */
725 continue;
726 }
727
Michal Vasko1a09b212021-05-06 13:00:10 +0200728 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200729 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200730 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200731 continue;
732 }
733
734 node = xp_scnode->scnode;
735 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100736 struct lysc_when **when_list, *when;
737
Radek Krejciddace2c2021-01-08 11:30:56 +0100738 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100739 when_list = lysc_node_when(node);
740 LY_ARRAY_FOR(when_list, u) {
741 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200742 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vasko400e9672021-01-11 13:39:17 +0100743 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200744 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100745 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200746 goto cleanup;
747 }
748
749 for (j = 0; j < tmp_set.used; ++j) {
750 /* skip roots'n'stuff */
751 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
752 /* try to find this node in our set */
753 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100754 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
755 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Michal Vasko2c4d9152021-07-20 09:17:28 +0200756 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".",
757 tmp_set.val.scnodes[j].scnode->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200758 ret = LY_EVALID;
759 goto cleanup;
760 }
761
762 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100763 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200764 } else {
765 /* no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200766 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200767 }
768 }
769
770 /* merge this set into the global when set */
771 lyxp_set_scnode_merge(set, &tmp_set);
772 }
773
774 /* check when of non-data parents as well */
775 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100776
Radek Krejciddace2c2021-01-08 11:30:56 +0100777 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200778 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
779
780 /* this node when was checked (xp_scnode could have been reallocd) */
Michal Vasko60edc2f2021-07-20 09:18:02 +0200781 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200782 }
783
784cleanup:
785 lyxp_set_free_content(&tmp_set);
786 return ret;
787}
788
789LY_ERR
790lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
791 const char *name2)
792{
793 uint16_t flg1, flg2;
794
795 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
796 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
797
798 if ((flg1 < flg2) && (mod1 == mod2)) {
799 if (ctx) {
Michal Vasko23864e02021-06-24 09:23:58 +0200800 LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200801 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
802 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
803 }
804 return LY_EVALID;
805 }
806
807 return LY_SUCCESS;
808}
809
Michal Vasko25d6ad02020-10-22 12:20:22 +0200810LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200811lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100812 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200813{
814 uint32_t i;
815 const char *ptr, *start;
816 const struct lys_module *mod;
817
Michal Vasko25d6ad02020-10-22 12:20:22 +0200818 assert(implement || mod_p);
819
Michal Vaskocfaff232020-10-20 09:35:14 +0200820 for (i = 0; i < expr->used; ++i) {
821 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
822 /* token cannot have a prefix */
823 continue;
824 }
825
826 start = expr->expr + expr->tok_pos[i];
827 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
828 /* token without a prefix */
829 continue;
830 }
831
832 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
833 /* unknown prefix, do not care right now */
834 continue;
835 }
836
Michal Vasko0c296722021-07-14 08:53:16 +0200837 /* unimplemented module found */
838 if (!mod->implemented && !implement) {
839 /* should not be implemented now */
840 *mod_p = mod;
841 break;
842 }
843
Michal Vaskocfaff232020-10-20 09:35:14 +0200844 if (!mod->implemented) {
Michal Vasko0c296722021-07-14 08:53:16 +0200845 /* implement if not implemented */
846 LY_CHECK_RET(lys_implement((struct lys_module *)mod, NULL, unres));
847 }
848 if (!mod->compiled) {
849 /* compile if not implemented before or only marked for compilation */
850 LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres));
Michal Vaskocfaff232020-10-20 09:35:14 +0200851 }
852 }
853
Michal Vasko25d6ad02020-10-22 12:20:22 +0200854 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200855}
856
857/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200858 * @brief Check when/must expressions of a node on a complete compiled schema tree.
859 *
860 * @param[in] ctx Compile context.
861 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100862 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200863 * @return LY_ERECOMPILE
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200864 * @return LY_ERR value
865 */
866static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100867lys_compile_unres_xpath(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200868{
869 struct lyxp_set tmp_set;
870 uint32_t i, opts;
871 LY_ARRAY_COUNT_TYPE u;
872 ly_bool input_done = 0;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100873 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200874 struct lysc_must *musts = NULL;
875 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200876 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200877
Radek Krejciddace2c2021-01-08 11:30:56 +0100878 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100879
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200880 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100881 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200882
Radek Krejci9a3823e2021-01-27 20:26:46 +0100883 whens = lysc_node_when(node);
884 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200885
Radek Krejci9a3823e2021-01-27 20:26:46 +0100886 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200887 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200888 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200889 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100890 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200891 if (ret) {
892 goto cleanup;
893 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200894 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100895 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200896 continue;
897 }
898
899 /* check "when" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200900 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Radek Krejci9a3823e2021-01-27 20:26:46 +0100901 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200902 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100903 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200904 goto cleanup;
905 }
906
907 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100908 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200909 for (i = 0; i < tmp_set.used; ++i) {
910 /* skip roots'n'stuff */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100911 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 +0200912 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
913
914 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100915 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200916 schema->name);
917 LY_CHECK_GOTO(ret, cleanup);
918
Michal Vasko1a09b212021-05-06 13:00:10 +0200919 /* check dummy node children/value accessing */
920 if (lysc_data_parent(schema) == node) {
921 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
922 ret = LY_EVALID;
923 goto cleanup;
924 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
925 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200926 ret = LY_EVALID;
927 goto cleanup;
928 }
929 }
930 }
931
932 /* check cyclic dependencies */
933 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
934 LY_CHECK_GOTO(ret, cleanup);
935
936 lyxp_set_free_content(&tmp_set);
937 }
938
939check_musts:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200940 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200941 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200942 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200943 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100944 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200945 if (ret) {
946 goto cleanup;
947 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200948 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
949 musts[u].cond->expr, mod->name);
950 continue;
951 }
952
953 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200954 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 +0100955 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200956 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100957 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200958 goto cleanup;
959 }
960
961 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100962 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200963 for (i = 0; i < tmp_set.used; ++i) {
964 /* skip roots'n'stuff */
965 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
966 /* XPath expression cannot reference "lower" status than the node that has the definition */
967 ret = lysc_check_status(ctx, node->flags, node->module, node->name, tmp_set.val.scnodes[i].scnode->flags,
968 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
969 LY_CHECK_GOTO(ret, cleanup);
970 }
971 }
972
973 lyxp_set_free_content(&tmp_set);
974 }
975
976 if ((node->nodetype & (LYS_RPC | LYS_ACTION)) && !input_done) {
977 /* now check output musts */
978 input_done = 1;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100979 whens = NULL;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100980 musts = ((struct lysc_node_action *)node)->output.musts;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200981 opts = LYXP_SCNODE_OUTPUT;
982 goto check_musts;
983 }
984
985cleanup:
986 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +0100987 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200988 return ret;
989}
990
991/**
992 * @brief Check leafref for its target existence on a complete compiled schema tree.
993 *
994 * @param[in] ctx Compile context.
995 * @param[in] node Context node for the leafref.
996 * @param[in] lref Leafref to check/resolve.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100997 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200998 * @return LY_ERECOMPILE if context recompilation is needed,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200999 * @return LY_ERR value.
1000 */
1001static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001002lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
1003 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001004{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001005 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001006 struct ly_path *p;
1007 struct lysc_type *type;
1008
1009 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1010
Michal Vasko24fc4d12021-07-12 14:41:20 +02001011 /* first implement all the modules in the path */
1012 LY_CHECK_RET(lys_compile_expr_implement(ctx->ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1013
Michal Vaskoed725d72021-06-23 12:03:45 +02001014 /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */
1015 LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, NULL, lref->path,
Michal Vaskod1e53b92021-01-28 13:11:06 +01001016 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +02001017 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001018
1019 /* get the target node */
1020 target = p[LY_ARRAY_COUNT(p) - 1].node;
1021 ly_path_free(node->module->ctx, p);
1022
1023 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001024 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 +02001025 lref->path->expr, lys_nodetype2str(target->nodetype));
1026 return LY_EVALID;
1027 }
1028
1029 /* check status */
1030 ctx->path[0] = '\0';
1031 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1032 ctx->path_len = strlen(ctx->path);
1033 if (lysc_check_status(ctx, node->flags, node->module, node->name, target->flags, target->module, target->name)) {
1034 return LY_EVALID;
1035 }
1036 ctx->path_len = 1;
1037 ctx->path[1] = '\0';
1038
1039 /* check config */
1040 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001041 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001042 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001043 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1044 return LY_EVALID;
1045 }
1046 }
1047
1048 /* store the target's type and check for circular chain of leafrefs */
1049 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1050 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
1051 if (type == (struct lysc_type *)lref) {
1052 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001053 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1054 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001055 return LY_EVALID;
1056 }
1057 }
1058
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001059 return LY_SUCCESS;
1060}
1061
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001062/**
1063 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1064 *
1065 * @param[in] ctx Compile context.
1066 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1067 * @param[in] type Type of the default value.
1068 * @param[in] dflt Default value.
1069 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1070 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001071 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001072 * @return LY_ERR value.
1073 */
1074static LY_ERR
1075lys_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 +01001076 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001077{
1078 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001079 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001080 struct ly_err_item *err = NULL;
1081
Radek Krejci0b013302021-03-29 15:22:32 +02001082 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +02001083 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001084 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001085 if (ret == LY_ERECOMPILE) {
1086 /* fine, but we need to recompile */
1087 return LY_ERECOMPILE;
1088 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001089 /* we have no data so we will not be resolving it */
1090 ret = LY_SUCCESS;
1091 }
1092
1093 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001094 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001095 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001096 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001097 ly_err_free(err);
1098 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001099 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001100 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001101 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001102 return ret;
1103 }
1104
1105 ++((struct lysc_type *)storage->realtype)->refcount;
1106 return LY_SUCCESS;
1107}
1108
1109/**
1110 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1111 *
1112 * @param[in] ctx Compile context.
1113 * @param[in] leaf Leaf that the default value is for.
1114 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001115 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001116 * @return LY_ERR value.
1117 */
1118static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001119lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1120 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001121{
1122 LY_ERR ret;
1123
1124 assert(!leaf->dflt);
1125
1126 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1127 /* ignore default values for keys and mandatory leaves */
1128 return LY_SUCCESS;
1129 }
1130
1131 /* allocate the default value */
1132 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1133 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1134
1135 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001136 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001137 if (ret) {
1138 free(leaf->dflt);
1139 leaf->dflt = NULL;
1140 }
1141
1142 return ret;
1143}
1144
1145/**
1146 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1147 *
1148 * @param[in] ctx Compile context.
1149 * @param[in] llist Leaf-list that the default value(s) are for.
1150 * @param[in] dflt Default value to compile, in case of a single value.
1151 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001152 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001153 * @return LY_ERR value.
1154 */
1155static LY_ERR
1156lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001157 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001158{
1159 LY_ERR ret;
1160 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1161
1162 assert(dflt || dflts);
1163
Radek Krejcic7d13e32020-12-09 12:32:24 +01001164 /* in case there were already some defaults and we are adding new by deviations */
1165 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001166
1167 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001168 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 +02001169
1170 /* fill each new default value */
1171 if (dflts) {
1172 LY_ARRAY_FOR(dflts, u) {
1173 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001174 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001175 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001176 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1177 LY_ARRAY_INCREMENT(llist->dflts);
1178 }
1179 } else {
1180 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001181 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001182 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001183 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1184 LY_ARRAY_INCREMENT(llist->dflts);
1185 }
1186
1187 /* check default value uniqueness */
1188 if (llist->flags & LYS_CONFIG_W) {
1189 /* configuration data values must be unique - so check the default values */
1190 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1191 for (v = 0; v < u; ++v) {
1192 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001193 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001194 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001195 llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON, NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001196 lysc_update_path(ctx, NULL, NULL);
1197 return LY_EVALID;
1198 }
1199 }
1200 }
1201 }
1202
1203 return LY_SUCCESS;
1204}
1205
Michal Vaskof4258e12021-06-15 12:11:42 +02001206/**
aPiecek732cd142021-07-07 16:29:59 +02001207 * @brief Iteratively get all leafrefs from @p node
1208 * if the node is of type union, otherwise just return the leafref.
1209 *
1210 * @param[in] node Node that may contain the leafref.
1211 * @param[in,out] index Value that is passed between function calls.
1212 * For each new node, initialize value of the @p index to 0, otherwise
1213 * do not modify the value between calls.
1214 * @return Pointer to the leafref or next leafref, otherwise NULL.
1215 */
1216static struct lysc_type_leafref *
1217lys_type_leafref_next(const struct lysc_node *node, uint64_t *index)
1218{
1219 struct lysc_type_leafref *ret = NULL;
1220 struct lysc_type_union *uni;
1221 struct lysc_type *leaf_type;
1222
1223 assert(node->nodetype & LYD_NODE_TERM);
1224
1225 leaf_type = ((struct lysc_node_leaf *)node)->type;
1226 if (leaf_type->basetype == LY_TYPE_UNION) {
1227 uni = (struct lysc_type_union *)leaf_type;
1228
1229 /* find next union leafref */
1230 while (*index < LY_ARRAY_COUNT(uni->types)) {
1231 if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) {
1232 ret = (struct lysc_type_leafref *)uni->types[*index];
1233 ++(*index);
1234 break;
1235 }
1236
1237 ++(*index);
1238 }
1239 } else {
1240 /* return just the single leafref */
1241 if (*index == 0) {
1242 ++(*index);
1243 assert(leaf_type->basetype == LY_TYPE_LEAFREF);
1244 ret = (struct lysc_type_leafref *)leaf_type;
1245 }
1246 }
1247
1248 return ret;
1249}
1250
1251/**
Michal Vaskof4258e12021-06-15 12:11:42 +02001252 * @brief Finish dependency set compilation by resolving all the unres sets.
1253 *
1254 * @param[in] ctx libyang context.
1255 * @param[in] unres Global unres structure with the sets to resolve.
1256 * @return LY_SUCCESS on success.
1257 * @return LY_ERECOMPILE if the dep set needs to be recompiled.
1258 * @return LY_ERR value on error.
1259 */
1260static LY_ERR
1261lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001262{
aPiecek732cd142021-07-07 16:29:59 +02001263 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001264 struct lysc_node *node;
aPiecek732cd142021-07-07 16:29:59 +02001265 struct lysc_type *typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001266 struct lysc_type_leafref *lref;
aPiecekd7bd52d2021-07-08 08:59:59 +02001267 struct lysc_ctx cctx;
Michal Vaskof4258e12021-06-15 12:11:42 +02001268 struct lys_depset_unres *ds_unres;
aPiecekd7bd52d2021-07-08 08:59:59 +02001269 struct ly_path *path;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001270 LY_ARRAY_COUNT_TYPE v;
aPiecekd7bd52d2021-07-08 08:59:59 +02001271 uint32_t i, processed_leafrefs = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001272
Michal Vaskof4258e12021-06-15 12:11:42 +02001273 ds_unres = &unres->ds_unres;
1274
Michal Vasko405cc9e2020-12-01 12:01:27 +01001275 /* fake compile context */
aPiecekd7bd52d2021-07-08 08:59:59 +02001276resolve_all:
1277 memset(&cctx, 0, sizeof cctx);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001278 cctx.ctx = ctx;
1279 cctx.path_len = 1;
1280 cctx.path[0] = '/';
1281
1282 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1283 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
aPiecekc6526b42021-07-12 15:21:39 +02001284 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation.
1285 * Also do the same check for set of the disabled leafrefs, but without the second round. */
1286 while (ds_unres->disabled_leafrefs.count) {
1287 node = ds_unres->disabled_leafrefs.objs[ds_unres->disabled_leafrefs.count - 1];
1288 cctx.cur_mod = node->module;
1289 cctx.pmod = node->module->parsed;
1290 LOG_LOCSET(node, NULL, NULL, NULL);
1291
aPiecekc6526b42021-07-12 15:21:39 +02001292 v = 0;
1293 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(node, &v))) {
1294 ret = lys_compile_unres_leafref(&cctx, node, lref, unres);
1295 }
1296
1297 LOG_LOCBACK(1, 0, 0, 0);
1298 LY_CHECK_RET(ret);
1299 ly_set_rm_index(&ds_unres->disabled_leafrefs, ds_unres->disabled_leafrefs.count - 1, NULL);
1300 }
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001301
aPiecekd7bd52d2021-07-08 08:59:59 +02001302 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001303 node = ds_unres->leafrefs.objs[i];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001304 cctx.cur_mod = node->module;
1305 cctx.pmod = node->module->parsed;
Radek Krejciddace2c2021-01-08 11:30:56 +01001306 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001307
aPiecek732cd142021-07-07 16:29:59 +02001308 v = 0;
1309 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(node, &v))) {
1310 ret = lys_compile_unres_leafref(&cctx, node, lref, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001311 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001312
Radek Krejciddace2c2021-01-08 11:30:56 +01001313 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001314 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001315 }
aPiecekd7bd52d2021-07-08 08:59:59 +02001316 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
1317 node = ds_unres->leafrefs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001318
Michal Vasko405cc9e2020-12-01 12:01:27 +01001319 /* store pointer to the real type */
aPiecek732cd142021-07-07 16:29:59 +02001320 v = 0;
1321 while ((lref = lys_type_leafref_next(node, &v))) {
1322 for (typeiter = lref->realtype;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001323 typeiter->basetype == LY_TYPE_LEAFREF;
1324 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
aPiecek732cd142021-07-07 16:29:59 +02001325 lref->realtype = typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001326 }
1327
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001328 /* If 'goto' will be used on the 'resolve_all' label, then
aPiecekd7bd52d2021-07-08 08:59:59 +02001329 * the current leafref will not be processed again.
1330 */
1331 processed_leafrefs++;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001332 }
1333
1334 /* check xpath */
Michal Vaskof4258e12021-06-15 12:11:42 +02001335 while (ds_unres->xpath.count) {
1336 node = ds_unres->xpath.objs[ds_unres->xpath.count - 1];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001337 cctx.cur_mod = node->module;
1338 cctx.pmod = node->module->parsed;
1339
Radek Krejciddace2c2021-01-08 11:30:56 +01001340 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001341 ret = lys_compile_unres_xpath(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001342 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001343 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001344
Michal Vaskof4258e12021-06-15 12:11:42 +02001345 ly_set_rm_index(&ds_unres->xpath, ds_unres->xpath.count - 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001346 }
1347
1348 /* finish incomplete default values compilation */
Michal Vaskof4258e12021-06-15 12:11:42 +02001349 while (ds_unres->dflts.count) {
1350 struct lysc_unres_dflt *r = ds_unres->dflts.objs[ds_unres->dflts.count - 1];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001351 cctx.cur_mod = r->leaf->module;
1352 cctx.pmod = r->leaf->module->parsed;
1353
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001354 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001355 if (r->leaf->nodetype == LYS_LEAF) {
1356 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1357 } else {
1358 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1359 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001360 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001361 LY_CHECK_RET(ret);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001362
1363 lysc_unres_dflt_free(ctx, r);
Michal Vaskof4258e12021-06-15 12:11:42 +02001364 ly_set_rm_index(&ds_unres->dflts, ds_unres->dflts.count - 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001365 }
1366
Michal Vasko40c158c2021-04-28 17:01:03 +02001367 /* some unres items may have been added */
aPiecekc6526b42021-07-12 15:21:39 +02001368 if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count ||
1369 ds_unres->xpath.count || ds_unres->dflts.count) {
aPiecekd7bd52d2021-07-08 08:59:59 +02001370 goto resolve_all;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001371 }
1372
Michal Vasko30ab8e72021-04-19 12:47:52 +02001373 /* finally, remove all disabled nodes */
Michal Vaskof4258e12021-06-15 12:11:42 +02001374 for (i = 0; i < ds_unres->disabled.count; ++i) {
1375 node = ds_unres->disabled.snodes[i];
Michal Vasko30ab8e72021-04-19 12:47:52 +02001376 if (node->flags & LYS_KEY) {
1377 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001378 LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001379 LOG_LOCBACK(1, 0, 0, 0);
1380 return LY_EVALID;
1381 }
1382
1383 lysc_node_free(ctx, node, 1);
1384 }
1385
aPiecekd7bd52d2021-07-08 08:59:59 +02001386 /* also check if the leafref target has not been disabled */
1387 for (i = 0; i < ds_unres->leafrefs.count; ++i) {
1388 node = ds_unres->leafrefs.objs[i];
1389 cctx.cur_mod = node->module;
1390 cctx.pmod = node->module->parsed;
1391
1392 v = 0;
1393 while ((lref = lys_type_leafref_next(node, &v))) {
1394 ret = ly_path_compile_leafref(cctx.ctx, node, NULL, lref->path,
1395 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
1396 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
1397 ly_path_free(node->module->ctx, path);
1398
1399 assert(ret != LY_ERECOMPILE);
1400 if (ret) {
1401 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001402 LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.",
1403 node->name);
aPiecekd7bd52d2021-07-08 08:59:59 +02001404 LOG_LOCBACK(1, 0, 0, 0);
1405 return LY_EVALID;
1406 }
1407 }
1408 }
1409
Michal Vasko405cc9e2020-12-01 12:01:27 +01001410 return LY_SUCCESS;
1411}
1412
Michal Vaskof4258e12021-06-15 12:11:42 +02001413/**
1414 * @brief Erase dep set unres.
1415 *
1416 * @param[in] ctx libyang context.
1417 * @param[in] unres Global unres structure with the sets to resolve.
1418 */
1419static void
1420lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001421{
1422 uint32_t i;
1423
Michal Vaskof4258e12021-06-15 12:11:42 +02001424 for (i = 0; i < unres->ds_unres.dflts.count; ++i) {
1425 lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]);
Michal Vaskodf6319c2021-06-10 14:41:05 +02001426 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001427 ly_set_erase(&unres->ds_unres.dflts, NULL);
1428 ly_set_erase(&unres->ds_unres.xpath, NULL);
1429 ly_set_erase(&unres->ds_unres.leafrefs, NULL);
aPiecekc6526b42021-07-12 15:21:39 +02001430 ly_set_erase(&unres->ds_unres.disabled_leafrefs, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001431 ly_set_erase(&unres->ds_unres.disabled, NULL);
1432}
1433
Michal Vasko709f9a52021-07-21 10:51:59 +02001434/**
1435 * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed.
1436 *
1437 * @param[in] ctx libyang context.
1438 * @param[in] dep_set Dependency set to compile.
1439 * @param[in,out] unres Global unres to use.
1440 * @return LY_ERR value.
1441 */
1442static LY_ERR
1443lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres)
Michal Vaskof4258e12021-06-15 12:11:42 +02001444{
1445 LY_ERR ret = LY_SUCCESS;
1446 struct lys_module *mod;
1447 uint32_t i;
1448
1449 for (i = 0; i < dep_set->count; ++i) {
1450 mod = dep_set->objs[i];
1451 if (!mod->to_compile) {
1452 /* skip */
1453 continue;
1454 }
1455 assert(mod->implemented);
1456
1457 /* free the compiled module, if any */
1458 lysc_module_free(mod->compiled);
1459 mod->compiled = NULL;
1460
1461 /* (re)compile the module */
1462 LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001463 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001464
1465 /* resolve dep set unres */
1466 ret = lys_compile_unres_depset(ctx, unres);
1467 if (ret == LY_ERECOMPILE) {
1468 /* new module is implemented, discard current dep set unres and recompile the whole dep set */
1469 lys_compile_unres_depset_erase(ctx, unres);
Michal Vasko709f9a52021-07-21 10:51:59 +02001470 return lys_compile_depset_r(ctx, dep_set, unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001471 } else if (ret) {
1472 /* error */
1473 goto cleanup;
1474 }
1475
1476 /* success, unset the flags of all the modules in the dep set */
1477 for (i = 0; i < dep_set->count; ++i) {
1478 mod = dep_set->objs[i];
1479 mod->to_compile = 0;
1480 }
1481
1482cleanup:
1483 lys_compile_unres_depset_erase(ctx, unres);
1484 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001485}
1486
Michal Vasko709f9a52021-07-21 10:51:59 +02001487LY_ERR
1488lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1489{
1490 uint32_t i;
1491
1492 for (i = 0; i < unres->dep_sets.count; ++i) {
1493 LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres));
1494 }
1495
1496 return LY_SUCCESS;
1497}
1498
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001499/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001500 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001501 *
1502 * @param[in] ctx Compile context with unres sets.
1503 * @return LY_ERR value.
1504 */
1505static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001506lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001507{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001508 struct lysc_augment *aug;
1509 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001510 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001511 uint32_t i;
1512
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001513 /* check that all augments were applied */
1514 for (i = 0; i < ctx->augs.count; ++i) {
1515 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001516 ctx->cur_mod = aug->aug_pmod->mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001517 lysc_update_path(ctx, NULL, "{augment}");
1518 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1519 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
Michal Vasko28fe5f62021-03-03 16:37:39 +01001520 aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001521 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001522 lysc_update_path(ctx, NULL, NULL);
1523 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001524 }
1525 if (ctx->augs.count) {
1526 return LY_ENOTFOUND;
1527 }
1528
1529 /* check that all deviations were applied */
1530 for (i = 0; i < ctx->devs.count; ++i) {
1531 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001532 lysc_update_path(ctx, NULL, "{deviation}");
1533 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1534 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1535 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1536 lysc_update_path(ctx, NULL, NULL);
1537 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001538 }
1539 if (ctx->devs.count) {
1540 return LY_ENOTFOUND;
1541 }
1542
1543 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001544}
1545
1546/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001547 * @brief Erase all the module unres sets in a compile context.
1548 *
1549 * @param[in] ctx Compile context with unres sets.
1550 * @param[in] error Whether the compilation finished with an error or not.
1551 */
1552static void
1553lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1554{
1555 uint32_t i;
1556
1557 ly_set_erase(&ctx->groupings, NULL);
1558 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001559
1560 if (!error) {
1561 /* there can be no leftover deviations or augments */
1562 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1563 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1564
1565 ly_set_erase(&ctx->augs, NULL);
1566 ly_set_erase(&ctx->devs, NULL);
1567 ly_set_erase(&ctx->uses_augs, NULL);
1568 ly_set_erase(&ctx->uses_rfns, NULL);
1569 } else {
1570 for (i = 0; i < ctx->augs.count; ++i) {
1571 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1572 }
1573 ly_set_erase(&ctx->augs, NULL);
1574 for (i = 0; i < ctx->devs.count; ++i) {
1575 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1576 }
1577 ly_set_erase(&ctx->devs, NULL);
1578 for (i = 0; i < ctx->uses_augs.count; ++i) {
1579 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1580 }
1581 ly_set_erase(&ctx->uses_augs, NULL);
1582 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1583 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1584 }
1585 ly_set_erase(&ctx->uses_rfns, NULL);
1586 }
1587}
1588
Michal Vaskod39bea42021-06-14 10:42:49 +02001589LY_ERR
Michal Vaskof4258e12021-06-15 12:11:42 +02001590lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001591{
1592 struct lysc_ctx ctx = {0};
Michal Vasko0b395e12021-04-23 13:43:07 +02001593 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001594 struct lysp_module *sp;
1595 struct lysp_submodule *submod;
1596 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001597 struct lysp_node_grp *grp;
1598 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001599 LY_ERR ret = LY_SUCCESS;
1600
1601 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1602
Michal Vaskof4258e12021-06-15 12:11:42 +02001603 assert(mod->implemented && mod->to_compile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001604
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001605 sp = mod->parsed;
1606
1607 ctx.ctx = mod->ctx;
1608 ctx.cur_mod = mod;
1609 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001610 ctx.path_len = 1;
1611 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001612 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001613
Michal Vasko0b395e12021-04-23 13:43:07 +02001614 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001615 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1616 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1617 mod_c->mod = mod;
1618
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001619 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001620 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1621 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001622
1623 /* data nodes */
1624 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001625 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001626 }
1627
Radek Krejci2a9fc652021-01-22 17:44:34 +01001628 /* top-level RPCs */
1629 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001630 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001631 }
1632
1633 /* top-level notifications */
1634 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001635 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001636 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001637
1638 /* extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001639 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001640
1641 /* the same for submodules */
1642 LY_ARRAY_FOR(sp->includes, u) {
1643 submod = sp->includes[u].submodule;
1644 ctx.pmod = (struct lysp_module *)submod;
1645
1646 LY_LIST_FOR(submod->data, pnode) {
1647 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001648 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001649 }
1650
Radek Krejci2a9fc652021-01-22 17:44:34 +01001651 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1652 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001653 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001654 }
1655
1656 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1657 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001658 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001659 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001660
Michal Vasko1ccbf542021-04-19 11:35:00 +02001661 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001662 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001663 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001664
1665 /* validate non-instantiated groupings from the parsed schema,
1666 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko7c565922021-06-10 14:58:27 +02001667 ctx.compile_opts |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001668 LY_LIST_FOR(sp->groupings, grp) {
1669 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001670 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001671 }
1672 }
1673 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001674 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1675 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001676 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001677 }
1678 }
1679 }
1680 LY_ARRAY_FOR(sp->includes, u) {
1681 submod = sp->includes[u].submodule;
1682 ctx.pmod = (struct lysp_module *)submod;
1683
Radek Krejci2a9fc652021-01-22 17:44:34 +01001684 LY_LIST_FOR(submod->groupings, grp) {
1685 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001686 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001687 }
1688 }
1689 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001690 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1691 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001692 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001693 }
1694 }
1695 }
1696 }
1697 ctx.pmod = sp;
1698
Radek Krejciddace2c2021-01-08 11:30:56 +01001699 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001700
Michal Vasko405cc9e2020-12-01 12:01:27 +01001701 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001702 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001703
Michal Vasko1ccbf542021-04-19 11:35:00 +02001704cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01001705 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001706 lys_compile_unres_mod_erase(&ctx, ret);
1707 if (ret) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001708 lysc_module_free(mod_c);
1709 mod->compiled = NULL;
1710 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001711 return ret;
1712}
Michal Vasko65333882021-06-10 14:12:16 +02001713
1714/**
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001715 * @brief Compile identites in a module and all its submodules.
1716 *
1717 * @param[in] mod Module to process.
1718 * @return LY_ERR value.
1719 */
1720static LY_ERR
1721lys_compile_identities(struct lys_module *mod)
1722{
1723 struct lysc_ctx ctx = {0};
1724 struct lysp_submodule *submod;
1725 LY_ARRAY_COUNT_TYPE u;
1726
1727 /* prepare context */
1728 ctx.ctx = mod->ctx;
1729 ctx.cur_mod = mod;
1730 ctx.pmod = mod->parsed;
1731 ctx.path_len = 1;
1732 ctx.path[0] = '/';
1733
1734 if (mod->parsed->identities) {
1735 LY_CHECK_RET(lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities));
1736 }
1737 lysc_update_path(&ctx, NULL, "{submodule}");
1738 LY_ARRAY_FOR(mod->parsed->includes, u) {
1739 submod = mod->parsed->includes[u].submodule;
1740 if (submod->identities) {
1741 ctx.pmod = (struct lysp_module *)submod;
1742 lysc_update_path(&ctx, NULL, submod->name);
1743 LY_CHECK_RET(lys_compile_identities_derived(&ctx, submod->identities, &mod->identities));
1744 lysc_update_path(&ctx, NULL, NULL);
1745 }
1746 }
1747 lysc_update_path(&ctx, NULL, NULL);
1748
1749 return LY_SUCCESS;
1750}
1751
1752/**
Michal Vasko65333882021-06-10 14:12:16 +02001753 * @brief Check whether a module does not have any (recursive) compiled import.
1754 *
1755 * @param[in] mod Module to examine.
1756 * @return LY_SUCCESS on success.
Michal Vaskof4258e12021-06-15 12:11:42 +02001757 * @return LY_ERECOMPILE on required recompilation of the dep set.
Michal Vasko65333882021-06-10 14:12:16 +02001758 * @return LY_ERR on error.
1759 */
1760static LY_ERR
1761lys_has_compiled_import_r(struct lys_module *mod)
1762{
1763 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoe7927122021-06-15 12:00:04 +02001764 struct lys_module *m;
Michal Vasko65333882021-06-10 14:12:16 +02001765
1766 LY_ARRAY_FOR(mod->parsed->imports, u) {
Michal Vaskoe7927122021-06-15 12:00:04 +02001767 m = mod->parsed->imports[u].module;
1768 if (!m->implemented) {
Michal Vasko65333882021-06-10 14:12:16 +02001769 continue;
1770 }
1771
Michal Vaskoe7927122021-06-15 12:00:04 +02001772 if (!m->to_compile) {
Michal Vaskod39bea42021-06-14 10:42:49 +02001773 /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */
Michal Vaskof4258e12021-06-15 12:11:42 +02001774 m->to_compile = 1;
Michal Vasko65333882021-06-10 14:12:16 +02001775 return LY_ERECOMPILE;
1776 }
1777
1778 /* recursive */
Michal Vaskoe7927122021-06-15 12:00:04 +02001779 LY_CHECK_RET(lys_has_compiled_import_r(m));
Michal Vasko65333882021-06-10 14:12:16 +02001780 }
1781
1782 return LY_SUCCESS;
1783}
1784
1785LY_ERR
1786lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
1787{
1788 LY_ERR ret;
1789 struct lys_module *m;
1790
1791 assert(!mod->implemented);
1792
1793 /* we have module from the current context */
1794 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
1795 if (m) {
1796 assert(m != mod);
1797
1798 /* check collision with other implemented revision */
1799 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
1800 mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
1801 return LY_EDENIED;
1802 }
1803
1804 /* set features */
1805 ret = lys_set_features(mod->parsed, features);
1806 if (ret && (ret != LY_EEXIST)) {
1807 return ret;
1808 }
1809
Michal Vasko65333882021-06-10 14:12:16 +02001810 /*
1811 * mark the module implemented, which means
1812 * 1) to (re)compile it only ::lys_compile() call is needed
1813 * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
1814 * but there can be some unres items added that do
1815 */
1816 mod->implemented = 1;
1817
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001818 /* this module is compiled in this compilation */
1819 mod->to_compile = 1;
1820
Michal Vasko65333882021-06-10 14:12:16 +02001821 /* add the module into newly implemented module set */
1822 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
1823
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001824 /* compile identities */
1825 LY_CHECK_RET(lys_compile_identities(mod));
1826
1827 /* mark target modules with our augments and deviations */
1828 LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres));
Michal Vasko65333882021-06-10 14:12:16 +02001829
Michal Vaskod39bea42021-06-14 10:42:49 +02001830 /* check whether this module may reference any modules compiled previously */
1831 LY_CHECK_RET(lys_has_compiled_import_r(mod));
Michal Vasko65333882021-06-10 14:12:16 +02001832
Michal Vasko65333882021-06-10 14:12:16 +02001833 return LY_SUCCESS;
1834}