blob: 0e0e45a8f677ef7d730356c723416e60cb84c11b [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
Michal Vaskoc130e162021-10-19 11:30:00 +0200180lysc_unres_must_free(struct lysc_unres_must *m)
181{
182 LY_ARRAY_FREE(m->local_mods);
183 free(m);
184}
185
186static void
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200187lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
188{
189 assert(!r->dflt || !r->dflts);
190 if (r->dflt) {
191 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
192 free(r->dflt);
193 } else {
194 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
195 }
196 free(r);
197}
198
199void
Radek Krejcia6016992021-03-03 10:13:41 +0100200lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200201{
202 int len;
203 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
204
205 if (!name) {
206 /* removing last path segment */
207 if (ctx->path[ctx->path_len - 1] == '}') {
208 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
209 if (ctx->path[ctx->path_len] == '=') {
210 ctx->path[ctx->path_len++] = '}';
211 } else {
212 /* not a top-level special tag, remove also preceiding '/' */
213 goto remove_nodelevel;
214 }
215 } else {
216remove_nodelevel:
217 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
218 if (ctx->path_len == 0) {
219 /* top-level (last segment) */
220 ctx->path_len = 1;
221 }
222 }
223 /* set new terminating NULL-byte */
224 ctx->path[ctx->path_len] = '\0';
225 } else {
226 if (ctx->path_len > 1) {
Radek Krejcia6016992021-03-03 10:13:41 +0100227 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200228 /* extension of the special tag */
229 nextlevel = 2;
230 --ctx->path_len;
231 } else {
232 /* there is already some path, so add next level */
233 nextlevel = 1;
234 }
235 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
236
237 if (nextlevel != 2) {
Radek Krejcia6016992021-03-03 10:13:41 +0100238 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200239 /* module not changed, print the name unprefixed */
240 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
241 } else {
242 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
243 }
244 } else {
245 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
246 }
247 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
248 /* output truncated */
249 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
250 } else {
251 ctx->path_len += len;
252 }
253 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100254
Radek Krejciddace2c2021-01-08 11:30:56 +0100255 LOG_LOCBACK(0, 0, 1, 0);
256 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200257}
258
aPiecek6b3d5422021-07-30 15:55:43 +0200259/**
260 * @brief Compile information from the identity statement
261 *
262 * The backlinks to the identities derived from this one are supposed to be filled later via ::lys_compile_identity_bases().
263 *
264 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
265 * @param[in] ctx libyang context.
266 * @param[in] parsed_mod Module with the identities.
267 * @param[in] identities_p Array of the parsed identity definitions to precompile.
268 * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
269 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
270 * to be processed.
271 * @return LY_ERR value.
272 */
273static LY_ERR
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200274lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
275 struct lysp_ident *identities_p, struct lysc_ident **identities)
276{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100277 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200278 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100279 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200280 LY_ERR ret = LY_SUCCESS;
281
282 assert(ctx_sc || ctx);
283
284 if (!ctx_sc) {
285 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100286 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200287 context.pmod = parsed_mod;
288 context.path_len = 1;
289 context.path[0] = '/';
290 ctx_sc = &context;
291 }
292
293 if (!identities_p) {
294 return LY_SUCCESS;
295 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200296
297 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200298 LY_ARRAY_FOR(identities_p, u) {
299 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
300
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100301 /* add new compiled identity */
302 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
303
304 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
305 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
306 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
307 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200308 /* 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 +0100309 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100310 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200311
312 lysc_update_path(ctx_sc, NULL, NULL);
313 }
314 lysc_update_path(ctx_sc, NULL, NULL);
315done:
316 return ret;
317}
318
319/**
320 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
321 *
322 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
323 *
324 * @param[in] ctx Compile context for logging.
325 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
326 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
327 * @return LY_SUCCESS if everything is ok.
328 * @return LY_EVALID if the identity is derived from itself.
329 */
330static LY_ERR
331lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
332{
333 LY_ERR ret = LY_SUCCESS;
334 LY_ARRAY_COUNT_TYPE u, v;
335 struct ly_set recursion = {0};
336 struct lysc_ident *drv;
337
338 if (!derived) {
339 return LY_SUCCESS;
340 }
341
342 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
343 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100344 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200345 "Identity \"%s\" is indirectly derived from itself.", ident->name);
346 ret = LY_EVALID;
347 goto cleanup;
348 }
349 ret = ly_set_add(&recursion, derived[u], 0, NULL);
350 LY_CHECK_GOTO(ret, cleanup);
351 }
352
353 for (v = 0; v < recursion.count; ++v) {
354 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200355 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
356 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100357 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200358 "Identity \"%s\" is indirectly derived from itself.", ident->name);
359 ret = LY_EVALID;
360 goto cleanup;
361 }
362 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
363 LY_CHECK_GOTO(ret, cleanup);
364 }
365 }
366
367cleanup:
368 ly_set_erase(&recursion, NULL);
369 return ret;
370}
371
372LY_ERR
373lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
aPiecekf4a0a192021-08-03 15:14:17 +0200374 struct lysc_ident *ident, struct lysc_ident ***bases)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200375{
376 LY_ARRAY_COUNT_TYPE u, v;
377 const char *s, *name;
378 const struct lys_module *mod;
379 struct lysc_ident **idref;
380
aPiecekf4a0a192021-08-03 15:14:17 +0200381 assert(ident || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200382
383 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100384 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200385 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
386 return LY_EVALID;
387 }
388
389 LY_ARRAY_FOR(bases_p, u) {
390 s = strchr(bases_p[u], ':');
391 if (s) {
392 /* prefixed identity */
393 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200394 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 +0200395 } else {
396 name = bases_p[u];
397 mod = base_pmod->mod;
398 }
399 if (!mod) {
400 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100401 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200402 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
403 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100404 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200405 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
406 }
407 return LY_EVALID;
408 }
409
410 idref = NULL;
411 LY_ARRAY_FOR(mod->identities, v) {
412 if (!strcmp(name, mod->identities[v].name)) {
413 if (ident) {
414 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100415 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200416 "Identity \"%s\" is derived from itself.", ident->name);
417 return LY_EVALID;
418 }
419 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
420 /* we have match! store the backlink */
421 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
422 *idref = ident;
423 } else {
424 /* we have match! store the found identity */
425 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
426 *idref = &mod->identities[v];
427 }
428 break;
429 }
430 }
aPiecekf4a0a192021-08-03 15:14:17 +0200431 if (!idref) {
Radek Krejci10443f42021-03-28 17:40:35 +0200432 if (ident) {
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 identity \"%s\".", bases_p[u], ident->name);
435 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100436 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200437 "Unable to find base (%s) of identityref.", bases_p[u]);
438 }
439 return LY_EVALID;
440 }
441 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100442
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.
aPiecekf4a0a192021-08-03 15:14:17 +0200450 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set.
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;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200457
458 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100459
aPiecekf3e2db82021-08-05 10:18:43 +0200460 for (u = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
aPiecekf4a0a192021-08-03 15:14:17 +0200461 /* find matching parsed identity */
aPiecekf3e2db82021-08-05 10:18:43 +0200462 for (v = 0; v < LY_ARRAY_COUNT(idents_p); ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100463 if (idents_p[v].name == (*idents)[u].name) {
464 break;
465 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100466 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100467
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200468 if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) {
469 /* identity not found (it may be from a submodule) or identity without bases */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200470 continue;
471 }
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200472
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100473 lysc_update_path(ctx, NULL, (*idents)[u].name);
aPiecekf4a0a192021-08-03 15:14:17 +0200474 LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200475 lysc_update_path(ctx, NULL, NULL);
476 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100477
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200478 lysc_update_path(ctx, NULL, NULL);
479 return LY_SUCCESS;
480}
481
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200482static void *
483lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
484{
485 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
486 if (substmts[u].stmt == stmt) {
487 return substmts[u].storage;
488 }
489 }
490 return NULL;
491}
492
493LY_ERR
Radek Krejci6b88a462021-02-17 12:39:34 +0100494lys_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 +0200495{
aPiecek1c4da362021-04-29 14:26:34 +0200496 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200497 LY_ARRAY_COUNT_TYPE u;
498 struct lysp_stmt *stmt;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200499 void *parsed = NULL, **compiled = NULL;
500
501 /* check for invalid substatements */
Radek Krejci6b88a462021-02-17 12:39:34 +0100502 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200503 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
504 continue;
505 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100506 LY_ARRAY_FOR(ext->substmts, u) {
507 if (ext->substmts[u].stmt == stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200508 break;
509 }
510 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100511 if (u == LY_ARRAY_COUNT(ext->substmts)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100512 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 +0100513 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200514 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200515 goto cleanup;
516 }
517 }
518
519 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
520
Radek Krejci6b88a462021-02-17 12:39:34 +0100521 /* note into the compile context that we are processing extension now */
522 ctx->ext = ext;
523
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200524 /* keep order of the processing the same as the order in the defined substmts,
525 * 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 +0200526
Radek Krejci6b88a462021-02-17 12:39:34 +0100527 LY_ARRAY_FOR(ext->substmts, u) {
528 uint64_t stmt_counter = 0;
529
530 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
531 if (ext->substmts[u].stmt != stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200532 continue;
533 }
534
Radek Krejci6b88a462021-02-17 12:39:34 +0100535 parsed = NULL;
536 stmt_counter++;
537 if (ext->substmts[u].storage) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200538 switch (stmt->kw) {
Radek Krejci6b88a462021-02-17 12:39:34 +0100539 case LY_STMT_ACTION:
540 case LY_STMT_ANYDATA:
541 case LY_STMT_ANYXML:
542 case LY_STMT_CONTAINER:
543 case LY_STMT_CHOICE:
544 case LY_STMT_LEAF:
545 case LY_STMT_LEAF_LIST:
546 case LY_STMT_LIST:
547 case LY_STMT_NOTIFICATION:
548 case LY_STMT_RPC:
549 case LY_STMT_USES:
aPiecek60d9d672021-04-27 15:49:57 +0200550 if (!ext_p->parsed) {
551 struct lysp_ext_instance *unconst_ext_p;
552 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
553 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
554 unconst_ext_p = (struct lysp_ext_instance *)ext_p;
555 unconst_ext_p->parsed = parsed;
556 } else {
Michal Vaskoa9309bb2021-07-09 09:31:55 +0200557 struct lysp_node *node, *last_node = NULL;
aPiecek60d9d672021-04-27 15:49:57 +0200558 /* get last parsed node */
559 LY_LIST_FOR(ext_p->parsed, node) {
560 last_node = node;
561 }
562 /* create and link sibling */
563 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
564 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
565 last_node->next = parsed;
566 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100567
568 /* set storage as an alternative document root in the compile context */
569 r = lys_compile_node(ctx, parsed, NULL, 0, NULL);
Radek Krejci6b88a462021-02-17 12:39:34 +0100570 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200571 break;
Radek Krejci1b2eef82021-02-17 11:17:27 +0100572 case LY_STMT_DESCRIPTION:
573 case LY_STMT_REFERENCE:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200574 case LY_STMT_UNITS: {
Radek Krejci6b88a462021-02-17 12:39:34 +0100575 const char **str_p;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200576
Radek Krejci6b88a462021-02-17 12:39:34 +0100577 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200578 /* single item */
Radek Krejci6b88a462021-02-17 12:39:34 +0100579 if (*((const char **)ext->substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100580 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200581 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200582 goto cleanup;
583 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100584 str_p = (const char **)ext->substmts[u].storage;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200585 } else {
586 /* sized array */
Radek Krejci6b88a462021-02-17 12:39:34 +0100587 const char ***strings_array = (const char ***)ext->substmts[u].storage;
588 LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200589 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100590 r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200591 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
592 break;
593 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100594 case LY_STMT_IF_FEATURE: {
595 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200596
Radek Krejci76c8c4e2021-02-17 10:16:48 +0100597 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200598 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Radek Krejci6b88a462021-02-17 12:39:34 +0100599
600 r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled);
601 FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100602 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
603 if (!enabled) {
604 /* it is disabled, remove the whole extension instance */
605 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200606 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200607 break;
Radek Krejci6b88a462021-02-17 12:39:34 +0100608 }
609 case LY_STMT_STATUS:
610 assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME);
611 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
612 break;
613 case LY_STMT_TYPE: {
614 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts);
615 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts);
616
617 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
618 /* single item */
619 if (*(struct lysc_type **)ext->substmts[u].storage) {
620 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200621 ret = LY_EVALID;
Radek Krejci6b88a462021-02-17 12:39:34 +0100622 goto cleanup;
623 }
624 compiled = ext->substmts[u].storage;
625 } else {
626 /* sized array */
627 struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL;
628 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
629 compiled = (void *)type;
630 }
631
632 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
633 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
634 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled,
635 units && !*units ? units : NULL, NULL);
636 lysp_type_free(ctx->ctx, parsed);
637 free(parsed);
638 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
639 break;
640 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200641 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
642 * also note that in many statements their extensions are not taken into account */
643 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100644 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 +0100645 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200646 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200647 goto cleanup;
648 }
649 }
650 }
651
Radek Krejci6b88a462021-02-17 12:39:34 +0100652 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 +0100653 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
Radek Krejci6b88a462021-02-17 12:39:34 +0100654 ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200655 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200656 goto cleanup;
657 }
658 }
659
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200660cleanup:
Radek Krejci6b88a462021-02-17 12:39:34 +0100661 ctx->ext = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200662 return ret;
663}
664
665/**
666 * @brief Check when for cyclic dependencies.
667 *
668 * @param[in] set Set with all the referenced nodes.
669 * @param[in] node Node whose "when" referenced nodes are in @p set.
670 * @return LY_ERR value
671 */
672static LY_ERR
673lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
674{
675 struct lyxp_set tmp_set;
676 struct lyxp_set_scnode *xp_scnode;
677 uint32_t i, j;
678 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200679 LY_ERR ret = LY_SUCCESS;
680
681 memset(&tmp_set, 0, sizeof tmp_set);
682
683 /* prepare in_ctx of the set */
684 for (i = 0; i < set->used; ++i) {
685 xp_scnode = &set->val.scnodes[i];
686
Radek Krejcif13b87b2020-12-01 22:02:17 +0100687 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200688 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100689 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200690 }
691 }
692
693 for (i = 0; i < set->used; ++i) {
694 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100695 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200696 /* already checked */
697 continue;
698 }
699
Michal Vasko1a09b212021-05-06 13:00:10 +0200700 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200701 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200702 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200703 continue;
704 }
705
706 node = xp_scnode->scnode;
707 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100708 struct lysc_when **when_list, *when;
709
Radek Krejciddace2c2021-01-08 11:30:56 +0100710 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100711 when_list = lysc_node_when(node);
712 LY_ARRAY_FOR(when_list, u) {
713 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200714 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vasko400e9672021-01-11 13:39:17 +0100715 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200716 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100717 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200718 goto cleanup;
719 }
720
721 for (j = 0; j < tmp_set.used; ++j) {
722 /* skip roots'n'stuff */
723 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
724 /* try to find this node in our set */
725 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100726 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
727 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Michal Vasko2c4d9152021-07-20 09:17:28 +0200728 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".",
729 tmp_set.val.scnodes[j].scnode->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200730 ret = LY_EVALID;
731 goto cleanup;
732 }
733
734 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100735 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200736 } else {
737 /* no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200738 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200739 }
740 }
741
742 /* merge this set into the global when set */
743 lyxp_set_scnode_merge(set, &tmp_set);
744 }
745
746 /* check when of non-data parents as well */
747 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100748
Radek Krejciddace2c2021-01-08 11:30:56 +0100749 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200750 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
751
752 /* this node when was checked (xp_scnode could have been reallocd) */
Michal Vasko60edc2f2021-07-20 09:18:02 +0200753 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200754 }
755
756cleanup:
757 lyxp_set_free_content(&tmp_set);
758 return ret;
759}
760
761LY_ERR
762lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
763 const char *name2)
764{
765 uint16_t flg1, flg2;
766
767 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
768 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
769
770 if ((flg1 < flg2) && (mod1 == mod2)) {
771 if (ctx) {
Michal Vasko23864e02021-06-24 09:23:58 +0200772 LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200773 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
774 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
775 }
776 return LY_EVALID;
777 }
778
779 return LY_SUCCESS;
780}
781
Michal Vasko25d6ad02020-10-22 12:20:22 +0200782LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200783lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100784 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200785{
786 uint32_t i;
787 const char *ptr, *start;
788 const struct lys_module *mod;
789
Michal Vasko25d6ad02020-10-22 12:20:22 +0200790 assert(implement || mod_p);
791
Michal Vaskocfaff232020-10-20 09:35:14 +0200792 for (i = 0; i < expr->used; ++i) {
793 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
794 /* token cannot have a prefix */
795 continue;
796 }
797
798 start = expr->expr + expr->tok_pos[i];
799 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
800 /* token without a prefix */
801 continue;
802 }
803
804 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
805 /* unknown prefix, do not care right now */
806 continue;
807 }
808
Michal Vasko0c296722021-07-14 08:53:16 +0200809 /* unimplemented module found */
810 if (!mod->implemented && !implement) {
811 /* should not be implemented now */
812 *mod_p = mod;
813 break;
814 }
815
Michal Vaskocfaff232020-10-20 09:35:14 +0200816 if (!mod->implemented) {
Michal Vasko0c296722021-07-14 08:53:16 +0200817 /* implement if not implemented */
818 LY_CHECK_RET(lys_implement((struct lys_module *)mod, NULL, unres));
819 }
820 if (!mod->compiled) {
821 /* compile if not implemented before or only marked for compilation */
822 LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres));
Michal Vaskocfaff232020-10-20 09:35:14 +0200823 }
824 }
825
Michal Vasko25d6ad02020-10-22 12:20:22 +0200826 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200827}
828
829/**
Michal Vaskoc130e162021-10-19 11:30:00 +0200830 * @brief Check when expressions of a node on a complete compiled schema tree.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200831 *
832 * @param[in] ctx Compile context.
833 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100834 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200835 * @return LY_ERECOMPILE
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200836 * @return LY_ERR value
837 */
838static LY_ERR
Michal Vaskoc130e162021-10-19 11:30:00 +0200839lys_compile_unres_when(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200840{
841 struct lyxp_set tmp_set;
842 uint32_t i, opts;
843 LY_ARRAY_COUNT_TYPE u;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100844 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200845 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200846 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200847
Radek Krejciddace2c2021-01-08 11:30:56 +0100848 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100849
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200850 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100851 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200852
Radek Krejci9a3823e2021-01-27 20:26:46 +0100853 whens = lysc_node_when(node);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100854 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200855 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200856 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200857 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100858 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200859 if (ret) {
860 goto cleanup;
861 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200862 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100863 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200864 continue;
865 }
866
867 /* check "when" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200868 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Radek Krejci9a3823e2021-01-27 20:26:46 +0100869 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200870 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100871 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200872 goto cleanup;
873 }
874
875 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100876 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200877 for (i = 0; i < tmp_set.used; ++i) {
878 /* skip roots'n'stuff */
Michal Vasko6b8c5102021-10-19 11:29:32 +0200879 if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) &&
880 (tmp_set.val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START_USED)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200881 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
882
883 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100884 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200885 schema->name);
886 LY_CHECK_GOTO(ret, cleanup);
887
Michal Vasko1a09b212021-05-06 13:00:10 +0200888 /* check dummy node children/value accessing */
889 if (lysc_data_parent(schema) == node) {
890 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
891 ret = LY_EVALID;
892 goto cleanup;
893 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
894 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200895 ret = LY_EVALID;
896 goto cleanup;
897 }
898 }
899 }
900
901 /* check cyclic dependencies */
902 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
903 LY_CHECK_GOTO(ret, cleanup);
904
905 lyxp_set_free_content(&tmp_set);
906 }
907
Michal Vaskoc130e162021-10-19 11:30:00 +0200908cleanup:
909 lyxp_set_free_content(&tmp_set);
910 LOG_LOCBACK(1, 0, 0, 0);
911 return ret;
912}
913
914/**
915 * @brief Check must expressions of a node on a complete compiled schema tree.
916 *
917 * @param[in] ctx Compile context.
918 * @param[in] node Node to check.
919 * @param[in] local_mods Sized array of local modules for musts of @p node at the same index.
920 * @param[in,out] unres Global unres structure.
921 * @return LY_ERECOMPILE
922 * @return LY_ERR value
923 */
924static LY_ERR
925lys_compile_unres_must(struct lysc_ctx *ctx, const struct lysc_node *node, const struct lysp_module **local_mods,
926 struct lys_glob_unres *unres)
927{
928 struct lyxp_set tmp_set;
929 uint32_t i, opts;
930 LY_ARRAY_COUNT_TYPE u;
931 struct lysc_must *musts = NULL;
932 LY_ERR ret = LY_SUCCESS;
933 const struct lys_module *mod;
934 uint16_t flg;
935
936 LOG_LOCSET(node, NULL, NULL, NULL);
937
938 memset(&tmp_set, 0, sizeof tmp_set);
939 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
940
941 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200942 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200943 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200944 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200945 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100946 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200947 if (ret) {
948 goto cleanup;
949 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200950 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
951 musts[u].cond->expr, mod->name);
952 continue;
953 }
954
955 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200956 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 +0100957 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200958 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100959 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200960 goto cleanup;
961 }
962
963 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100964 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200965 for (i = 0; i < tmp_set.used; ++i) {
966 /* skip roots'n'stuff */
967 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
968 /* XPath expression cannot reference "lower" status than the node that has the definition */
Michal Vaskoc130e162021-10-19 11:30:00 +0200969 if (local_mods[u]->mod == node->module) {
970 /* use flags of the context node since the definition is local */
971 flg = node->flags;
972 } else {
973 /* definition is foreign (deviation, refine), always current */
974 flg = LYS_STATUS_CURR;
975 }
976 ret = lysc_check_status(ctx, flg, local_mods[u]->mod, node->name, tmp_set.val.scnodes[i].scnode->flags,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200977 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
978 LY_CHECK_GOTO(ret, cleanup);
979 }
980 }
981
982 lyxp_set_free_content(&tmp_set);
983 }
984
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200985cleanup:
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 Vaskoc130e162021-10-19 11:30:00 +0200997 * @param[in] local_mod Local module for the leafref type.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100998 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200999 * @return LY_ERECOMPILE if context recompilation is needed,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001000 * @return LY_ERR value.
1001 */
1002static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001003lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
Michal Vaskoc130e162021-10-19 11:30:00 +02001004 const struct lysp_module *local_mod, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001005{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001006 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001007 struct ly_path *p;
1008 struct lysc_type *type;
Michal Vaskoc130e162021-10-19 11:30:00 +02001009 uint16_t flg;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001010
1011 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1012
Michal Vasko24fc4d12021-07-12 14:41:20 +02001013 /* first implement all the modules in the path */
1014 LY_CHECK_RET(lys_compile_expr_implement(ctx->ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1015
Michal Vaskoed725d72021-06-23 12:03:45 +02001016 /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */
1017 LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, NULL, lref->path,
Michal Vaskod1e53b92021-01-28 13:11:06 +01001018 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +02001019 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001020
1021 /* get the target node */
1022 target = p[LY_ARRAY_COUNT(p) - 1].node;
1023 ly_path_free(node->module->ctx, p);
1024
1025 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001026 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 +02001027 lref->path->expr, lys_nodetype2str(target->nodetype));
1028 return LY_EVALID;
1029 }
1030
1031 /* check status */
1032 ctx->path[0] = '\0';
1033 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1034 ctx->path_len = strlen(ctx->path);
Michal Vaskoc130e162021-10-19 11:30:00 +02001035 if (node->module == local_mod->mod) {
1036 /* use flags of the context node since the definition is local */
1037 flg = node->flags;
1038 } else {
1039 /* definition is foreign (deviation), always current */
1040 flg = LYS_STATUS_CURR;
1041 }
1042 if (lysc_check_status(ctx, flg, local_mod->mod, node->name, target->flags, target->module, target->name)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001043 return LY_EVALID;
1044 }
1045 ctx->path_len = 1;
1046 ctx->path[1] = '\0';
1047
1048 /* check config */
1049 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001050 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001051 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001052 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1053 return LY_EVALID;
1054 }
1055 }
1056
1057 /* store the target's type and check for circular chain of leafrefs */
1058 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1059 for (type = lref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref *)type)->realtype) {
1060 if (type == (struct lysc_type *)lref) {
1061 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001062 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1063 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001064 return LY_EVALID;
1065 }
1066 }
1067
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001068 return LY_SUCCESS;
1069}
1070
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001071/**
1072 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1073 *
1074 * @param[in] ctx Compile context.
1075 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1076 * @param[in] type Type of the default value.
1077 * @param[in] dflt Default value.
1078 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1079 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001080 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001081 * @return LY_ERR value.
1082 */
1083static LY_ERR
1084lys_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 +01001085 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001086{
1087 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001088 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001089 struct ly_err_item *err = NULL;
1090
Radek Krejci0b013302021-03-29 15:22:32 +02001091 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +02001092 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001093 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001094 if (ret == LY_ERECOMPILE) {
1095 /* fine, but we need to recompile */
1096 return LY_ERECOMPILE;
1097 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001098 /* we have no data so we will not be resolving it */
1099 ret = LY_SUCCESS;
1100 }
1101
1102 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001103 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001104 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001105 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001106 ly_err_free(err);
1107 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001108 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001109 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001110 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001111 return ret;
1112 }
1113
Michal Vasko04338d92021-09-01 07:58:14 +02001114 LY_ATOMIC_INC_BARRIER(((struct lysc_type *)storage->realtype)->refcount);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001115 return LY_SUCCESS;
1116}
1117
1118/**
1119 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1120 *
1121 * @param[in] ctx Compile context.
1122 * @param[in] leaf Leaf that the default value is for.
1123 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001124 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001125 * @return LY_ERR value.
1126 */
1127static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001128lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1129 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001130{
1131 LY_ERR ret;
1132
1133 assert(!leaf->dflt);
1134
1135 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1136 /* ignore default values for keys and mandatory leaves */
1137 return LY_SUCCESS;
1138 }
1139
1140 /* allocate the default value */
1141 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1142 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1143
1144 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001145 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001146 if (ret) {
1147 free(leaf->dflt);
1148 leaf->dflt = NULL;
1149 }
1150
1151 return ret;
1152}
1153
1154/**
1155 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1156 *
1157 * @param[in] ctx Compile context.
1158 * @param[in] llist Leaf-list that the default value(s) are for.
1159 * @param[in] dflt Default value to compile, in case of a single value.
1160 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001161 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001162 * @return LY_ERR value.
1163 */
1164static LY_ERR
1165lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001166 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001167{
1168 LY_ERR ret;
1169 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1170
1171 assert(dflt || dflts);
1172
Radek Krejcic7d13e32020-12-09 12:32:24 +01001173 /* in case there were already some defaults and we are adding new by deviations */
1174 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001175
1176 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001177 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 +02001178
1179 /* fill each new default value */
1180 if (dflts) {
1181 LY_ARRAY_FOR(dflts, u) {
1182 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001183 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001184 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001185 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1186 LY_ARRAY_INCREMENT(llist->dflts);
1187 }
1188 } else {
1189 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001190 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001191 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001192 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1193 LY_ARRAY_INCREMENT(llist->dflts);
1194 }
1195
1196 /* check default value uniqueness */
1197 if (llist->flags & LYS_CONFIG_W) {
1198 /* configuration data values must be unique - so check the default values */
1199 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1200 for (v = 0; v < u; ++v) {
1201 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001202 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001203 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001204 llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON, NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001205 lysc_update_path(ctx, NULL, NULL);
1206 return LY_EVALID;
1207 }
1208 }
1209 }
1210 }
1211
1212 return LY_SUCCESS;
1213}
1214
Michal Vaskof4258e12021-06-15 12:11:42 +02001215/**
aPiecek732cd142021-07-07 16:29:59 +02001216 * @brief Iteratively get all leafrefs from @p node
1217 * if the node is of type union, otherwise just return the leafref.
1218 *
1219 * @param[in] node Node that may contain the leafref.
1220 * @param[in,out] index Value that is passed between function calls.
1221 * For each new node, initialize value of the @p index to 0, otherwise
1222 * do not modify the value between calls.
1223 * @return Pointer to the leafref or next leafref, otherwise NULL.
1224 */
1225static struct lysc_type_leafref *
1226lys_type_leafref_next(const struct lysc_node *node, uint64_t *index)
1227{
1228 struct lysc_type_leafref *ret = NULL;
1229 struct lysc_type_union *uni;
1230 struct lysc_type *leaf_type;
1231
1232 assert(node->nodetype & LYD_NODE_TERM);
1233
1234 leaf_type = ((struct lysc_node_leaf *)node)->type;
1235 if (leaf_type->basetype == LY_TYPE_UNION) {
1236 uni = (struct lysc_type_union *)leaf_type;
1237
1238 /* find next union leafref */
1239 while (*index < LY_ARRAY_COUNT(uni->types)) {
1240 if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) {
1241 ret = (struct lysc_type_leafref *)uni->types[*index];
1242 ++(*index);
1243 break;
1244 }
1245
1246 ++(*index);
1247 }
1248 } else {
1249 /* return just the single leafref */
1250 if (*index == 0) {
1251 ++(*index);
1252 assert(leaf_type->basetype == LY_TYPE_LEAFREF);
1253 ret = (struct lysc_type_leafref *)leaf_type;
1254 }
1255 }
1256
1257 return ret;
1258}
1259
1260/**
Michal Vaskof4258e12021-06-15 12:11:42 +02001261 * @brief Finish dependency set compilation by resolving all the unres sets.
1262 *
1263 * @param[in] ctx libyang context.
1264 * @param[in] unres Global unres structure with the sets to resolve.
1265 * @return LY_SUCCESS on success.
1266 * @return LY_ERECOMPILE if the dep set needs to be recompiled.
1267 * @return LY_ERR value on error.
1268 */
1269static LY_ERR
1270lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001271{
aPiecek732cd142021-07-07 16:29:59 +02001272 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001273 struct lysc_node *node;
aPiecek732cd142021-07-07 16:29:59 +02001274 struct lysc_type *typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001275 struct lysc_type_leafref *lref;
aPiecekd7bd52d2021-07-08 08:59:59 +02001276 struct lysc_ctx cctx;
Michal Vaskof4258e12021-06-15 12:11:42 +02001277 struct lys_depset_unres *ds_unres;
aPiecekd7bd52d2021-07-08 08:59:59 +02001278 struct ly_path *path;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001279 LY_ARRAY_COUNT_TYPE v;
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001280 struct lysc_unres_leafref *l;
aPiecekd7bd52d2021-07-08 08:59:59 +02001281 uint32_t i, processed_leafrefs = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001282
Michal Vaskof4258e12021-06-15 12:11:42 +02001283 ds_unres = &unres->ds_unres;
1284
Michal Vasko405cc9e2020-12-01 12:01:27 +01001285 /* fake compile context */
aPiecekd7bd52d2021-07-08 08:59:59 +02001286resolve_all:
1287 memset(&cctx, 0, sizeof cctx);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001288 cctx.ctx = ctx;
1289 cctx.path_len = 1;
1290 cctx.path[0] = '/';
1291
1292 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1293 * 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 +02001294 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation.
1295 * Also do the same check for set of the disabled leafrefs, but without the second round. */
1296 while (ds_unres->disabled_leafrefs.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001297 /* remember index, it can change before we get to free this item */
1298 i = ds_unres->disabled_leafrefs.count - 1;
1299 l = ds_unres->disabled_leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001300 cctx.cur_mod = l->node->module;
1301 cctx.pmod = l->node->module->parsed;
aPiecekc6526b42021-07-12 15:21:39 +02001302
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001303 LOG_LOCSET(l->node, NULL, NULL, NULL);
aPiecekc6526b42021-07-12 15:21:39 +02001304 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001305 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
1306 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres);
aPiecekc6526b42021-07-12 15:21:39 +02001307 }
aPiecekc6526b42021-07-12 15:21:39 +02001308 LOG_LOCBACK(1, 0, 0, 0);
1309 LY_CHECK_RET(ret);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001310
1311 ly_set_rm_index(&ds_unres->disabled_leafrefs, i, free);
aPiecekc6526b42021-07-12 15:21:39 +02001312 }
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001313
aPiecekd7bd52d2021-07-08 08:59:59 +02001314 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001315 l = ds_unres->leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001316 cctx.cur_mod = l->node->module;
1317 cctx.pmod = l->node->module->parsed;
1318 LOG_LOCSET(l->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001319
aPiecek732cd142021-07-07 16:29:59 +02001320 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001321 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
1322 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001323 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001324
Radek Krejciddace2c2021-01-08 11:30:56 +01001325 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001326 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001327 }
aPiecekd7bd52d2021-07-08 08:59:59 +02001328 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001329 l = ds_unres->leafrefs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001330
Michal Vasko405cc9e2020-12-01 12:01:27 +01001331 /* store pointer to the real type */
aPiecek732cd142021-07-07 16:29:59 +02001332 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001333 while ((lref = lys_type_leafref_next(l->node, &v))) {
aPiecek732cd142021-07-07 16:29:59 +02001334 for (typeiter = lref->realtype;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001335 typeiter->basetype == LY_TYPE_LEAFREF;
1336 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
aPiecek732cd142021-07-07 16:29:59 +02001337 lref->realtype = typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001338 }
1339
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001340 /* If 'goto' will be used on the 'resolve_all' label, then
aPiecekd7bd52d2021-07-08 08:59:59 +02001341 * the current leafref will not be processed again.
1342 */
1343 processed_leafrefs++;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001344 }
1345
Michal Vaskoc130e162021-10-19 11:30:00 +02001346 /* check when */
1347 while (ds_unres->whens.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001348 i = ds_unres->whens.count - 1;
1349 node = ds_unres->whens.objs[i];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001350 cctx.cur_mod = node->module;
1351 cctx.pmod = node->module->parsed;
1352
Radek Krejciddace2c2021-01-08 11:30:56 +01001353 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001354 ret = lys_compile_unres_when(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001355 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001356 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001357
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001358 ly_set_rm_index(&ds_unres->whens, i, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001359 }
1360
1361 /* check must */
1362 while (ds_unres->musts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001363 i = ds_unres->musts.count - 1;
1364 struct lysc_unres_must *m = ds_unres->musts.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001365 cctx.cur_mod = m->node->module;
1366 cctx.pmod = m->node->module->parsed;
1367
1368 LOG_LOCSET(m->node, NULL, NULL, NULL);
1369 ret = lys_compile_unres_must(&cctx, m->node, m->local_mods, unres);
1370 LOG_LOCBACK(1, 0, 0, 0);
1371 LY_CHECK_RET(ret);
1372
1373 lysc_unres_must_free(m);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001374 ly_set_rm_index(&ds_unres->musts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001375 }
1376
1377 /* finish incomplete default values compilation */
Michal Vaskof4258e12021-06-15 12:11:42 +02001378 while (ds_unres->dflts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001379 i = ds_unres->dflts.count - 1;
1380 struct lysc_unres_dflt *r = ds_unres->dflts.objs[i];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001381 cctx.cur_mod = r->leaf->module;
1382 cctx.pmod = r->leaf->module->parsed;
1383
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001384 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001385 if (r->leaf->nodetype == LYS_LEAF) {
1386 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1387 } else {
1388 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1389 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001390 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001391 LY_CHECK_RET(ret);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001392
1393 lysc_unres_dflt_free(ctx, r);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001394 ly_set_rm_index(&ds_unres->dflts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001395 }
1396
Michal Vasko40c158c2021-04-28 17:01:03 +02001397 /* some unres items may have been added */
aPiecekc6526b42021-07-12 15:21:39 +02001398 if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count ||
Michal Vaskoc130e162021-10-19 11:30:00 +02001399 ds_unres->whens.count || ds_unres->musts.count || ds_unres->dflts.count) {
aPiecekd7bd52d2021-07-08 08:59:59 +02001400 goto resolve_all;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001401 }
1402
Michal Vasko30ab8e72021-04-19 12:47:52 +02001403 /* finally, remove all disabled nodes */
Michal Vaskof4258e12021-06-15 12:11:42 +02001404 for (i = 0; i < ds_unres->disabled.count; ++i) {
1405 node = ds_unres->disabled.snodes[i];
Michal Vasko30ab8e72021-04-19 12:47:52 +02001406 if (node->flags & LYS_KEY) {
1407 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001408 LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001409 LOG_LOCBACK(1, 0, 0, 0);
1410 return LY_EVALID;
1411 }
1412
1413 lysc_node_free(ctx, node, 1);
1414 }
1415
aPiecekd7bd52d2021-07-08 08:59:59 +02001416 /* also check if the leafref target has not been disabled */
1417 for (i = 0; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001418 l = ds_unres->leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001419 cctx.cur_mod = l->node->module;
1420 cctx.pmod = l->node->module->parsed;
aPiecekd7bd52d2021-07-08 08:59:59 +02001421
1422 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001423 while ((lref = lys_type_leafref_next(l->node, &v))) {
1424 ret = ly_path_compile_leafref(cctx.ctx, l->node, NULL, lref->path,
1425 (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
aPiecekd7bd52d2021-07-08 08:59:59 +02001426 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
Michal Vaskoc130e162021-10-19 11:30:00 +02001427 ly_path_free(l->node->module->ctx, path);
aPiecekd7bd52d2021-07-08 08:59:59 +02001428
1429 assert(ret != LY_ERECOMPILE);
1430 if (ret) {
Michal Vaskoc130e162021-10-19 11:30:00 +02001431 LOG_LOCSET(l->node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001432 LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.",
Michal Vaskoc130e162021-10-19 11:30:00 +02001433 l->node->name);
aPiecekd7bd52d2021-07-08 08:59:59 +02001434 LOG_LOCBACK(1, 0, 0, 0);
1435 return LY_EVALID;
1436 }
1437 }
1438 }
1439
Michal Vasko405cc9e2020-12-01 12:01:27 +01001440 return LY_SUCCESS;
1441}
1442
Michal Vaskof4258e12021-06-15 12:11:42 +02001443/**
1444 * @brief Erase dep set unres.
1445 *
1446 * @param[in] ctx libyang context.
1447 * @param[in] unres Global unres structure with the sets to resolve.
1448 */
1449static void
1450lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001451{
1452 uint32_t i;
1453
Michal Vaskoc130e162021-10-19 11:30:00 +02001454 ly_set_erase(&unres->ds_unres.whens, NULL);
1455 for (i = 0; i < unres->ds_unres.musts.count; ++i) {
1456 lysc_unres_must_free(unres->ds_unres.musts.objs[i]);
1457 }
1458 ly_set_erase(&unres->ds_unres.musts, NULL);
1459 ly_set_erase(&unres->ds_unres.leafrefs, free);
Michal Vaskof4258e12021-06-15 12:11:42 +02001460 for (i = 0; i < unres->ds_unres.dflts.count; ++i) {
1461 lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]);
Michal Vaskodf6319c2021-06-10 14:41:05 +02001462 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001463 ly_set_erase(&unres->ds_unres.dflts, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001464 ly_set_erase(&unres->ds_unres.disabled_leafrefs, free);
Michal Vaskof4258e12021-06-15 12:11:42 +02001465 ly_set_erase(&unres->ds_unres.disabled, NULL);
1466}
1467
Michal Vasko709f9a52021-07-21 10:51:59 +02001468/**
1469 * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed.
1470 *
1471 * @param[in] ctx libyang context.
1472 * @param[in] dep_set Dependency set to compile.
1473 * @param[in,out] unres Global unres to use.
1474 * @return LY_ERR value.
1475 */
1476static LY_ERR
1477lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres)
Michal Vaskof4258e12021-06-15 12:11:42 +02001478{
1479 LY_ERR ret = LY_SUCCESS;
1480 struct lys_module *mod;
1481 uint32_t i;
1482
1483 for (i = 0; i < dep_set->count; ++i) {
1484 mod = dep_set->objs[i];
1485 if (!mod->to_compile) {
1486 /* skip */
1487 continue;
1488 }
1489 assert(mod->implemented);
1490
1491 /* free the compiled module, if any */
1492 lysc_module_free(mod->compiled);
1493 mod->compiled = NULL;
1494
1495 /* (re)compile the module */
1496 LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001497 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001498
1499 /* resolve dep set unres */
1500 ret = lys_compile_unres_depset(ctx, unres);
1501 if (ret == LY_ERECOMPILE) {
1502 /* new module is implemented, discard current dep set unres and recompile the whole dep set */
1503 lys_compile_unres_depset_erase(ctx, unres);
Michal Vasko709f9a52021-07-21 10:51:59 +02001504 return lys_compile_depset_r(ctx, dep_set, unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001505 } else if (ret) {
1506 /* error */
1507 goto cleanup;
1508 }
1509
1510 /* success, unset the flags of all the modules in the dep set */
1511 for (i = 0; i < dep_set->count; ++i) {
1512 mod = dep_set->objs[i];
1513 mod->to_compile = 0;
1514 }
1515
1516cleanup:
1517 lys_compile_unres_depset_erase(ctx, unres);
1518 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001519}
1520
Michal Vasko709f9a52021-07-21 10:51:59 +02001521LY_ERR
1522lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1523{
1524 uint32_t i;
1525
1526 for (i = 0; i < unres->dep_sets.count; ++i) {
1527 LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres));
1528 }
1529
1530 return LY_SUCCESS;
1531}
1532
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001533/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001534 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001535 *
1536 * @param[in] ctx Compile context with unres sets.
1537 * @return LY_ERR value.
1538 */
1539static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001540lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001541{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001542 struct lysc_augment *aug;
1543 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001544 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001545 uint32_t i;
1546
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001547 /* check that all augments were applied */
1548 for (i = 0; i < ctx->augs.count; ++i) {
1549 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001550 ctx->cur_mod = aug->aug_pmod->mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001551 lysc_update_path(ctx, NULL, "{augment}");
1552 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1553 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
Michal Vasko28fe5f62021-03-03 16:37:39 +01001554 aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001555 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001556 lysc_update_path(ctx, NULL, NULL);
1557 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001558 }
1559 if (ctx->augs.count) {
1560 return LY_ENOTFOUND;
1561 }
1562
1563 /* check that all deviations were applied */
1564 for (i = 0; i < ctx->devs.count; ++i) {
1565 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001566 lysc_update_path(ctx, NULL, "{deviation}");
1567 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1568 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1569 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1570 lysc_update_path(ctx, NULL, NULL);
1571 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001572 }
1573 if (ctx->devs.count) {
1574 return LY_ENOTFOUND;
1575 }
1576
1577 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001578}
1579
1580/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001581 * @brief Erase all the module unres sets in a compile context.
1582 *
1583 * @param[in] ctx Compile context with unres sets.
1584 * @param[in] error Whether the compilation finished with an error or not.
1585 */
1586static void
1587lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1588{
1589 uint32_t i;
1590
1591 ly_set_erase(&ctx->groupings, NULL);
1592 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001593
1594 if (!error) {
1595 /* there can be no leftover deviations or augments */
1596 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1597 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1598
1599 ly_set_erase(&ctx->augs, NULL);
1600 ly_set_erase(&ctx->devs, NULL);
1601 ly_set_erase(&ctx->uses_augs, NULL);
1602 ly_set_erase(&ctx->uses_rfns, NULL);
1603 } else {
1604 for (i = 0; i < ctx->augs.count; ++i) {
1605 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1606 }
1607 ly_set_erase(&ctx->augs, NULL);
1608 for (i = 0; i < ctx->devs.count; ++i) {
1609 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1610 }
1611 ly_set_erase(&ctx->devs, NULL);
1612 for (i = 0; i < ctx->uses_augs.count; ++i) {
1613 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1614 }
1615 ly_set_erase(&ctx->uses_augs, NULL);
1616 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1617 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1618 }
1619 ly_set_erase(&ctx->uses_rfns, NULL);
1620 }
1621}
1622
Michal Vaskod39bea42021-06-14 10:42:49 +02001623LY_ERR
Michal Vaskof4258e12021-06-15 12:11:42 +02001624lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001625{
1626 struct lysc_ctx ctx = {0};
Michal Vasko0b395e12021-04-23 13:43:07 +02001627 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001628 struct lysp_module *sp;
1629 struct lysp_submodule *submod;
1630 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001631 struct lysp_node_grp *grp;
1632 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001633 LY_ERR ret = LY_SUCCESS;
1634
1635 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1636
Michal Vaskof4258e12021-06-15 12:11:42 +02001637 assert(mod->implemented && mod->to_compile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001638
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001639 sp = mod->parsed;
1640
1641 ctx.ctx = mod->ctx;
1642 ctx.cur_mod = mod;
1643 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001644 ctx.path_len = 1;
1645 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001646 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001647
Michal Vasko0b395e12021-04-23 13:43:07 +02001648 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001649 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1650 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1651 mod_c->mod = mod;
1652
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001653 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001654 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1655 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001656
1657 /* data nodes */
1658 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001659 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001660 }
1661
Radek Krejci2a9fc652021-01-22 17:44:34 +01001662 /* top-level RPCs */
1663 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001664 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001665 }
1666
1667 /* top-level notifications */
1668 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001669 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001670 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001671
1672 /* extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001673 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001674
1675 /* the same for submodules */
1676 LY_ARRAY_FOR(sp->includes, u) {
1677 submod = sp->includes[u].submodule;
1678 ctx.pmod = (struct lysp_module *)submod;
1679
1680 LY_LIST_FOR(submod->data, pnode) {
1681 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001682 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001683 }
1684
Radek Krejci2a9fc652021-01-22 17:44:34 +01001685 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1686 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001687 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001688 }
1689
1690 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1691 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001692 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001693 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001694
Michal Vasko1ccbf542021-04-19 11:35:00 +02001695 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001696 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001697 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001698
1699 /* validate non-instantiated groupings from the parsed schema,
1700 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko7c565922021-06-10 14:58:27 +02001701 ctx.compile_opts |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001702 LY_LIST_FOR(sp->groupings, grp) {
1703 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001704 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001705 }
1706 }
1707 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001708 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1709 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001710 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001711 }
1712 }
1713 }
1714 LY_ARRAY_FOR(sp->includes, u) {
1715 submod = sp->includes[u].submodule;
1716 ctx.pmod = (struct lysp_module *)submod;
1717
Radek Krejci2a9fc652021-01-22 17:44:34 +01001718 LY_LIST_FOR(submod->groupings, grp) {
1719 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001720 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001721 }
1722 }
1723 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001724 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1725 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001726 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001727 }
1728 }
1729 }
1730 }
1731 ctx.pmod = sp;
1732
Radek Krejciddace2c2021-01-08 11:30:56 +01001733 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001734
Michal Vasko405cc9e2020-12-01 12:01:27 +01001735 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001736 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001737
Michal Vasko1ccbf542021-04-19 11:35:00 +02001738cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01001739 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001740 lys_compile_unres_mod_erase(&ctx, ret);
1741 if (ret) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001742 lysc_module_free(mod_c);
1743 mod->compiled = NULL;
1744 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001745 return ret;
1746}
Michal Vasko65333882021-06-10 14:12:16 +02001747
aPiecek6b3d5422021-07-30 15:55:43 +02001748LY_ERR
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001749lys_compile_identities(struct lys_module *mod)
1750{
1751 struct lysc_ctx ctx = {0};
1752 struct lysp_submodule *submod;
1753 LY_ARRAY_COUNT_TYPE u;
1754
aPiecek6b3d5422021-07-30 15:55:43 +02001755 /* pre-compile identities of the module and any submodules */
1756 LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, mod->parsed, mod->parsed->identities, &mod->identities));
1757 LY_ARRAY_FOR(mod->parsed->includes, u) {
1758 submod = mod->parsed->includes[u].submodule;
1759 LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, (struct lysp_module *)submod, submod->identities, &mod->identities));
1760 }
1761
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001762 /* prepare context */
1763 ctx.ctx = mod->ctx;
1764 ctx.cur_mod = mod;
1765 ctx.pmod = mod->parsed;
1766 ctx.path_len = 1;
1767 ctx.path[0] = '/';
1768
1769 if (mod->parsed->identities) {
1770 LY_CHECK_RET(lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities));
1771 }
1772 lysc_update_path(&ctx, NULL, "{submodule}");
1773 LY_ARRAY_FOR(mod->parsed->includes, u) {
1774 submod = mod->parsed->includes[u].submodule;
1775 if (submod->identities) {
1776 ctx.pmod = (struct lysp_module *)submod;
1777 lysc_update_path(&ctx, NULL, submod->name);
1778 LY_CHECK_RET(lys_compile_identities_derived(&ctx, submod->identities, &mod->identities));
1779 lysc_update_path(&ctx, NULL, NULL);
1780 }
1781 }
1782 lysc_update_path(&ctx, NULL, NULL);
1783
1784 return LY_SUCCESS;
1785}
1786
1787/**
Michal Vasko65333882021-06-10 14:12:16 +02001788 * @brief Check whether a module does not have any (recursive) compiled import.
1789 *
1790 * @param[in] mod Module to examine.
1791 * @return LY_SUCCESS on success.
Michal Vaskof4258e12021-06-15 12:11:42 +02001792 * @return LY_ERECOMPILE on required recompilation of the dep set.
Michal Vasko65333882021-06-10 14:12:16 +02001793 * @return LY_ERR on error.
1794 */
1795static LY_ERR
1796lys_has_compiled_import_r(struct lys_module *mod)
1797{
1798 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoe7927122021-06-15 12:00:04 +02001799 struct lys_module *m;
Michal Vasko65333882021-06-10 14:12:16 +02001800
1801 LY_ARRAY_FOR(mod->parsed->imports, u) {
Michal Vaskoe7927122021-06-15 12:00:04 +02001802 m = mod->parsed->imports[u].module;
1803 if (!m->implemented) {
Michal Vasko65333882021-06-10 14:12:16 +02001804 continue;
1805 }
1806
Michal Vaskoe7927122021-06-15 12:00:04 +02001807 if (!m->to_compile) {
Michal Vaskod39bea42021-06-14 10:42:49 +02001808 /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */
Michal Vaskof4258e12021-06-15 12:11:42 +02001809 m->to_compile = 1;
Michal Vasko65333882021-06-10 14:12:16 +02001810 return LY_ERECOMPILE;
1811 }
1812
1813 /* recursive */
Michal Vaskoe7927122021-06-15 12:00:04 +02001814 LY_CHECK_RET(lys_has_compiled_import_r(m));
Michal Vasko65333882021-06-10 14:12:16 +02001815 }
1816
1817 return LY_SUCCESS;
1818}
1819
1820LY_ERR
1821lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
1822{
1823 LY_ERR ret;
1824 struct lys_module *m;
1825
1826 assert(!mod->implemented);
1827
1828 /* we have module from the current context */
1829 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
1830 if (m) {
1831 assert(m != mod);
1832
1833 /* check collision with other implemented revision */
1834 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s%s%s\" is present in the context in other implemented revision (%s).",
1835 mod->name, mod->revision ? "@" : "", mod->revision ? mod->revision : "", m->revision ? m->revision : "none");
1836 return LY_EDENIED;
1837 }
1838
1839 /* set features */
1840 ret = lys_set_features(mod->parsed, features);
1841 if (ret && (ret != LY_EEXIST)) {
1842 return ret;
1843 }
1844
Michal Vasko65333882021-06-10 14:12:16 +02001845 /*
1846 * mark the module implemented, which means
1847 * 1) to (re)compile it only ::lys_compile() call is needed
1848 * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
1849 * but there can be some unres items added that do
1850 */
1851 mod->implemented = 1;
1852
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001853 /* this module is compiled in this compilation */
1854 mod->to_compile = 1;
1855
Michal Vasko65333882021-06-10 14:12:16 +02001856 /* add the module into newly implemented module set */
1857 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
1858
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001859 /* mark target modules with our augments and deviations */
1860 LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres));
Michal Vasko65333882021-06-10 14:12:16 +02001861
Michal Vaskod39bea42021-06-14 10:42:49 +02001862 /* check whether this module may reference any modules compiled previously */
1863 LY_CHECK_RET(lys_has_compiled_import_r(mod));
Michal Vasko65333882021-06-10 14:12:16 +02001864
Michal Vasko65333882021-06-10 14:12:16 +02001865 return LY_SUCCESS;
1866}