blob: 58d458a8aab9d91663810c40305c3ca45235510b [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
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100148LIBYANG_API_DEF LY_ERR
Michal Vasko733d9fd2022-02-02 09:11:53 +0100149lysc_ext_substmt(const struct lysc_ext_instance *ext, enum ly_stmt substmt, void **instance_p,
150 enum ly_stmt_cardinality *cardinality_p)
Radek Krejci1b2eef82021-02-17 11:17:27 +0100151{
152 LY_ARRAY_COUNT_TYPE u;
153
Michal Vasko55bce0e2022-02-15 10:46:08 +0100154 if (instance_p) {
155 *instance_p = NULL;
156 }
157 if (cardinality_p) {
158 *cardinality_p = 0;
159 }
160
Radek Krejci1b2eef82021-02-17 11:17:27 +0100161 LY_ARRAY_FOR(ext->substmts, u) {
Radek Krejci61837f72021-03-02 19:53:59 +0100162 if (LY_STMT_IS_DATA_NODE(substmt)) {
163 if (!LY_STMT_IS_DATA_NODE(ext->substmts[u].stmt)) {
Radek Krejci1b2eef82021-02-17 11:17:27 +0100164 continue;
165 }
166 } else if (LY_STMT_IS_OP(substmt)) {
167 if (!LY_STMT_IS_OP(ext->substmts[u].stmt)) {
168 continue;
169 }
170 } else if (ext->substmts[u].stmt != substmt) {
171 continue;
172 }
173
174 /* match */
175 if (cardinality_p) {
176 *cardinality_p = ext->substmts[u].cardinality;
177 }
178 if (instance_p) {
179 *instance_p = ext->substmts[u].storage;
180 }
181 return LY_SUCCESS;
182 }
183
184 return LY_ENOT;
185}
186
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200187static void
Michal Vaskoc130e162021-10-19 11:30:00 +0200188lysc_unres_must_free(struct lysc_unres_must *m)
189{
190 LY_ARRAY_FREE(m->local_mods);
191 free(m);
192}
193
194static void
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200195lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
196{
197 assert(!r->dflt || !r->dflts);
198 if (r->dflt) {
199 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
200 free(r->dflt);
201 } else {
202 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
203 }
204 free(r);
205}
206
207void
Radek Krejcia6016992021-03-03 10:13:41 +0100208lysc_update_path(struct lysc_ctx *ctx, struct lys_module *parent_module, const char *name)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200209{
210 int len;
211 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
212
213 if (!name) {
214 /* removing last path segment */
215 if (ctx->path[ctx->path_len - 1] == '}') {
216 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
217 if (ctx->path[ctx->path_len] == '=') {
218 ctx->path[ctx->path_len++] = '}';
219 } else {
220 /* not a top-level special tag, remove also preceiding '/' */
221 goto remove_nodelevel;
222 }
223 } else {
224remove_nodelevel:
225 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
226 if (ctx->path_len == 0) {
227 /* top-level (last segment) */
228 ctx->path_len = 1;
229 }
230 }
231 /* set new terminating NULL-byte */
232 ctx->path[ctx->path_len] = '\0';
233 } else {
234 if (ctx->path_len > 1) {
Radek Krejcia6016992021-03-03 10:13:41 +0100235 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200236 /* extension of the special tag */
237 nextlevel = 2;
238 --ctx->path_len;
239 } else {
240 /* there is already some path, so add next level */
241 nextlevel = 1;
242 }
243 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
244
245 if (nextlevel != 2) {
Radek Krejcia6016992021-03-03 10:13:41 +0100246 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200247 /* module not changed, print the name unprefixed */
248 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
249 } else {
250 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
251 }
252 } else {
253 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
254 }
255 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
256 /* output truncated */
257 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
258 } else {
259 ctx->path_len += len;
260 }
261 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100262
Radek Krejciddace2c2021-01-08 11:30:56 +0100263 LOG_LOCBACK(0, 0, 1, 0);
264 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200265}
266
aPiecek6b3d5422021-07-30 15:55:43 +0200267/**
268 * @brief Compile information from the identity statement
269 *
270 * The backlinks to the identities derived from this one are supposed to be filled later via ::lys_compile_identity_bases().
271 *
272 * @param[in] ctx_sc Compile context - alternative to the combination of @p ctx and @p parsed_mod.
273 * @param[in] ctx libyang context.
274 * @param[in] parsed_mod Module with the identities.
275 * @param[in] identities_p Array of the parsed identity definitions to precompile.
276 * @param[in,out] identities Pointer to the storage of the (pre)compiled identities array where the new identities are
277 * supposed to be added. The storage is supposed to be initiated to NULL when the first parsed identities are going
278 * to be processed.
279 * @return LY_ERR value.
280 */
281static LY_ERR
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200282lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
283 struct lysp_ident *identities_p, struct lysc_ident **identities)
284{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100285 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200286 struct lysc_ctx context = {0};
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100287 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200288 LY_ERR ret = LY_SUCCESS;
289
290 assert(ctx_sc || ctx);
291
292 if (!ctx_sc) {
293 context.ctx = ctx;
Radek Krejci3aac9a72020-12-01 12:24:26 +0100294 context.cur_mod = parsed_mod ? parsed_mod->mod : NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200295 context.pmod = parsed_mod;
296 context.path_len = 1;
297 context.path[0] = '/';
298 ctx_sc = &context;
299 }
300
301 if (!identities_p) {
302 return LY_SUCCESS;
303 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200304
305 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200306 LY_ARRAY_FOR(identities_p, u) {
307 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
308
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100309 /* add new compiled identity */
310 LY_ARRAY_NEW_RET(ctx_sc->ctx, *identities, ident, LY_EMEM);
311
312 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
313 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
314 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
315 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200316 /* 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 +0100317 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100318 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200319
320 lysc_update_path(ctx_sc, NULL, NULL);
321 }
322 lysc_update_path(ctx_sc, NULL, NULL);
323done:
324 return ret;
325}
326
327/**
328 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
329 *
330 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
331 *
332 * @param[in] ctx Compile context for logging.
333 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
334 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
335 * @return LY_SUCCESS if everything is ok.
336 * @return LY_EVALID if the identity is derived from itself.
337 */
338static LY_ERR
339lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
340{
341 LY_ERR ret = LY_SUCCESS;
342 LY_ARRAY_COUNT_TYPE u, v;
343 struct ly_set recursion = {0};
344 struct lysc_ident *drv;
345
346 if (!derived) {
347 return LY_SUCCESS;
348 }
349
350 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
351 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100352 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200353 "Identity \"%s\" is indirectly derived from itself.", ident->name);
354 ret = LY_EVALID;
355 goto cleanup;
356 }
357 ret = ly_set_add(&recursion, derived[u], 0, NULL);
358 LY_CHECK_GOTO(ret, cleanup);
359 }
360
361 for (v = 0; v < recursion.count; ++v) {
362 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200363 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
364 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100365 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200366 "Identity \"%s\" is indirectly derived from itself.", ident->name);
367 ret = LY_EVALID;
368 goto cleanup;
369 }
370 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
371 LY_CHECK_GOTO(ret, cleanup);
372 }
373 }
374
375cleanup:
376 ly_set_erase(&recursion, NULL);
377 return ret;
378}
379
380LY_ERR
381lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
aPiecekf4a0a192021-08-03 15:14:17 +0200382 struct lysc_ident *ident, struct lysc_ident ***bases)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200383{
384 LY_ARRAY_COUNT_TYPE u, v;
385 const char *s, *name;
386 const struct lys_module *mod;
387 struct lysc_ident **idref;
388
aPiecekf4a0a192021-08-03 15:14:17 +0200389 assert(ident || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200390
391 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100392 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200393 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
394 return LY_EVALID;
395 }
396
397 LY_ARRAY_FOR(bases_p, u) {
398 s = strchr(bases_p[u], ':');
399 if (s) {
400 /* prefixed identity */
401 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200402 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 +0200403 } else {
404 name = bases_p[u];
405 mod = base_pmod->mod;
406 }
407 if (!mod) {
408 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100409 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200410 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
411 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100412 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200413 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
414 }
415 return LY_EVALID;
416 }
417
418 idref = NULL;
419 LY_ARRAY_FOR(mod->identities, v) {
420 if (!strcmp(name, mod->identities[v].name)) {
421 if (ident) {
422 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100423 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200424 "Identity \"%s\" is derived from itself.", ident->name);
425 return LY_EVALID;
426 }
427 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
428 /* we have match! store the backlink */
429 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
430 *idref = ident;
431 } else {
432 /* we have match! store the found identity */
433 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
434 *idref = &mod->identities[v];
435 }
436 break;
437 }
438 }
aPiecekf4a0a192021-08-03 15:14:17 +0200439 if (!idref) {
Radek Krejci10443f42021-03-28 17:40:35 +0200440 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100441 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200442 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
443 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100444 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200445 "Unable to find base (%s) of identityref.", bases_p[u]);
446 }
447 return LY_EVALID;
448 }
449 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100450
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200451 return LY_SUCCESS;
452}
453
454/**
455 * @brief For the given array of identities, set the backlinks from all their base identities.
456 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
457 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
aPiecekf4a0a192021-08-03 15:14:17 +0200458 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200459 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
460 */
461static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100462lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200463{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100464 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200465
466 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100467
aPiecekf3e2db82021-08-05 10:18:43 +0200468 for (u = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
aPiecekf4a0a192021-08-03 15:14:17 +0200469 /* find matching parsed identity */
aPiecekf3e2db82021-08-05 10:18:43 +0200470 for (v = 0; v < LY_ARRAY_COUNT(idents_p); ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100471 if (idents_p[v].name == (*idents)[u].name) {
472 break;
473 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100474 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100475
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200476 if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) {
477 /* identity not found (it may be from a submodule) or identity without bases */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200478 continue;
479 }
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200480
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100481 lysc_update_path(ctx, NULL, (*idents)[u].name);
aPiecekf4a0a192021-08-03 15:14:17 +0200482 LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200483 lysc_update_path(ctx, NULL, NULL);
484 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100485
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200486 lysc_update_path(ctx, NULL, NULL);
487 return LY_SUCCESS;
488}
489
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200490static void *
491lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
492{
493 for (LY_ARRAY_COUNT_TYPE u = 0; substmts[u].stmt; ++u) {
494 if (substmts[u].stmt == stmt) {
495 return substmts[u].storage;
496 }
497 }
498 return NULL;
499}
500
501LY_ERR
Radek Krejci6b88a462021-02-17 12:39:34 +0100502lys_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 +0200503{
aPiecek1c4da362021-04-29 14:26:34 +0200504 LY_ERR ret = LY_SUCCESS, r;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200505 LY_ARRAY_COUNT_TYPE u;
506 struct lysp_stmt *stmt;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200507 void *parsed = NULL, **compiled = NULL;
508
509 /* check for invalid substatements */
Radek Krejci6b88a462021-02-17 12:39:34 +0100510 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200511 if (stmt->flags & (LYS_YIN_ATTR | LYS_YIN_ARGUMENT)) {
512 continue;
513 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100514 LY_ARRAY_FOR(ext->substmts, u) {
515 if (ext->substmts[u].stmt == stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200516 break;
517 }
518 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100519 if (u == LY_ARRAY_COUNT(ext->substmts)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100520 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 +0100521 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200522 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200523 goto cleanup;
524 }
525 }
526
527 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
528
Radek Krejci6b88a462021-02-17 12:39:34 +0100529 /* note into the compile context that we are processing extension now */
530 ctx->ext = ext;
531
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200532 /* keep order of the processing the same as the order in the defined substmts,
533 * 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 +0200534
Radek Krejci6b88a462021-02-17 12:39:34 +0100535 LY_ARRAY_FOR(ext->substmts, u) {
536 uint64_t stmt_counter = 0;
537
538 for (stmt = ext_p->child; stmt; stmt = stmt->next) {
539 if (ext->substmts[u].stmt != stmt->kw) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200540 continue;
541 }
542
Radek Krejci6b88a462021-02-17 12:39:34 +0100543 parsed = NULL;
544 stmt_counter++;
545 if (ext->substmts[u].storage) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200546 switch (stmt->kw) {
Radek Krejci6b88a462021-02-17 12:39:34 +0100547 case LY_STMT_ACTION:
548 case LY_STMT_ANYDATA:
549 case LY_STMT_ANYXML:
550 case LY_STMT_CONTAINER:
551 case LY_STMT_CHOICE:
552 case LY_STMT_LEAF:
553 case LY_STMT_LEAF_LIST:
554 case LY_STMT_LIST:
555 case LY_STMT_NOTIFICATION:
556 case LY_STMT_RPC:
557 case LY_STMT_USES:
aPiecek60d9d672021-04-27 15:49:57 +0200558 if (!ext_p->parsed) {
559 struct lysp_ext_instance *unconst_ext_p;
560 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
561 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
562 unconst_ext_p = (struct lysp_ext_instance *)ext_p;
563 unconst_ext_p->parsed = parsed;
564 } else {
Michal Vaskoa9309bb2021-07-09 09:31:55 +0200565 struct lysp_node *node, *last_node = NULL;
aPiecek60d9d672021-04-27 15:49:57 +0200566 /* get last parsed node */
567 LY_LIST_FOR(ext_p->parsed, node) {
568 last_node = node;
569 }
570 /* create and link sibling */
571 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
572 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
573 last_node->next = parsed;
574 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100575
576 /* set storage as an alternative document root in the compile context */
577 r = lys_compile_node(ctx, parsed, NULL, 0, NULL);
Radek Krejci6b88a462021-02-17 12:39:34 +0100578 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200579 break;
Radek Krejci1b2eef82021-02-17 11:17:27 +0100580 case LY_STMT_DESCRIPTION:
581 case LY_STMT_REFERENCE:
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200582 case LY_STMT_UNITS: {
Radek Krejci6b88a462021-02-17 12:39:34 +0100583 const char **str_p;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200584
Radek Krejci6b88a462021-02-17 12:39:34 +0100585 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200586 /* single item */
Radek Krejci6b88a462021-02-17 12:39:34 +0100587 if (*((const char **)ext->substmts[u].storage)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100588 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200589 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200590 goto cleanup;
591 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100592 str_p = (const char **)ext->substmts[u].storage;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200593 } else {
594 /* sized array */
Radek Krejci6b88a462021-02-17 12:39:34 +0100595 const char ***strings_array = (const char ***)ext->substmts[u].storage;
596 LY_ARRAY_NEW_GOTO(ctx->ctx, *strings_array, str_p, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200597 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100598 r = lydict_insert(ctx->ctx, stmt->arg, 0, str_p);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200599 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
600 break;
601 }
Radek Krejci6b88a462021-02-17 12:39:34 +0100602 case LY_STMT_IF_FEATURE: {
603 ly_bool enabled;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200604
Radek Krejci76c8c4e2021-02-17 10:16:48 +0100605 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200606 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
Radek Krejci6b88a462021-02-17 12:39:34 +0100607
608 r = lys_eval_iffeatures(ctx->ctx, parsed, &enabled);
609 FREE_ARRAY(ctx->ctx, (struct lysp_qname *)parsed, lysp_qname_free);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100610 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
611 if (!enabled) {
612 /* it is disabled, remove the whole extension instance */
613 return LY_ENOT;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200614 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200615 break;
Radek Krejci6b88a462021-02-17 12:39:34 +0100616 }
617 case LY_STMT_STATUS:
618 assert(ext->substmts[u].cardinality < LY_STMT_CARD_SOME);
619 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, &ext->substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
620 break;
621 case LY_STMT_TYPE: {
622 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, ext->substmts);
623 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, ext->substmts);
624
625 if (ext->substmts[u].cardinality < LY_STMT_CARD_SOME) {
626 /* single item */
627 if (*(struct lysc_type **)ext->substmts[u].storage) {
628 LOGVAL(ctx->ctx, LY_VCODE_DUPSTMT, stmt->stmt);
aPiecek1c4da362021-04-29 14:26:34 +0200629 ret = LY_EVALID;
Radek Krejci6b88a462021-02-17 12:39:34 +0100630 goto cleanup;
631 }
632 compiled = ext->substmts[u].storage;
633 } else {
634 /* sized array */
635 struct lysc_type ***types = (struct lysc_type ***)ext->substmts[u].storage, **type = NULL;
636 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
637 compiled = (void *)type;
638 }
639
640 r = lysp_stmt_parse(ctx, stmt, &parsed, NULL);
641 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
642 r = lys_compile_type(ctx, NULL, flags ? *flags : 0, ext_p->name, parsed, (struct lysc_type **)compiled,
643 units && !*units ? units : NULL, NULL);
644 lysp_type_free(ctx->ctx, parsed);
645 free(parsed);
646 LY_CHECK_ERR_GOTO(r, ret = r, cleanup);
647 break;
648 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200649 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
650 * also note that in many statements their extensions are not taken into account */
651 default:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100652 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 +0100653 stmt->stmt, ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200654 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200655 goto cleanup;
656 }
657 }
658 }
659
Radek Krejci6b88a462021-02-17 12:39:34 +0100660 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 +0100661 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
Radek Krejci6b88a462021-02-17 12:39:34 +0100662 ly_stmt2str(ext->substmts[u].stmt), ext_p->name, ext_p->argument ? " " : "", ext_p->argument ? ext_p->argument : "");
aPiecek1c4da362021-04-29 14:26:34 +0200663 ret = LY_EVALID;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200664 goto cleanup;
665 }
666 }
667
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200668cleanup:
Radek Krejci6b88a462021-02-17 12:39:34 +0100669 ctx->ext = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200670 return ret;
671}
672
673/**
674 * @brief Check when for cyclic dependencies.
675 *
676 * @param[in] set Set with all the referenced nodes.
677 * @param[in] node Node whose "when" referenced nodes are in @p set.
678 * @return LY_ERR value
679 */
680static LY_ERR
681lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
682{
683 struct lyxp_set tmp_set;
684 struct lyxp_set_scnode *xp_scnode;
685 uint32_t i, j;
686 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200687 LY_ERR ret = LY_SUCCESS;
688
689 memset(&tmp_set, 0, sizeof tmp_set);
690
691 /* prepare in_ctx of the set */
692 for (i = 0; i < set->used; ++i) {
693 xp_scnode = &set->val.scnodes[i];
694
Radek Krejcif13b87b2020-12-01 22:02:17 +0100695 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200696 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100697 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200698 }
699 }
700
701 for (i = 0; i < set->used; ++i) {
702 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100703 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200704 /* already checked */
705 continue;
706 }
707
Michal Vasko1a09b212021-05-06 13:00:10 +0200708 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200709 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200710 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200711 continue;
712 }
713
714 node = xp_scnode->scnode;
715 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100716 struct lysc_when **when_list, *when;
717
Radek Krejciddace2c2021-01-08 11:30:56 +0100718 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100719 when_list = lysc_node_when(node);
720 LY_ARRAY_FOR(when_list, u) {
721 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200722 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vasko400e9672021-01-11 13:39:17 +0100723 when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200724 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100725 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko59e69e72022-02-18 09:18:21 +0100726 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200727 goto cleanup;
728 }
729
730 for (j = 0; j < tmp_set.used; ++j) {
731 /* skip roots'n'stuff */
732 if (tmp_set.val.scnodes[j].type == LYXP_NODE_ELEM) {
733 /* try to find this node in our set */
734 uint32_t idx;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100735 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
736 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
Michal Vasko2c4d9152021-07-20 09:17:28 +0200737 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".",
738 tmp_set.val.scnodes[j].scnode->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200739 ret = LY_EVALID;
Michal Vasko59e69e72022-02-18 09:18:21 +0100740 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200741 goto cleanup;
742 }
743
744 /* needs to be checked, if in both sets, will be ignored */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100745 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200746 } else {
747 /* no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200748 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200749 }
750 }
751
752 /* merge this set into the global when set */
753 lyxp_set_scnode_merge(set, &tmp_set);
754 }
755
756 /* check when of non-data parents as well */
757 node = node->parent;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100758
Radek Krejciddace2c2021-01-08 11:30:56 +0100759 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200760 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
761
762 /* this node when was checked (xp_scnode could have been reallocd) */
Michal Vasko60edc2f2021-07-20 09:18:02 +0200763 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200764 }
765
766cleanup:
767 lyxp_set_free_content(&tmp_set);
768 return ret;
769}
770
771LY_ERR
772lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
773 const char *name2)
774{
775 uint16_t flg1, flg2;
776
777 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
778 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
779
780 if ((flg1 < flg2) && (mod1 == mod2)) {
781 if (ctx) {
Michal Vasko23864e02021-06-24 09:23:58 +0200782 LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200783 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
784 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
785 }
786 return LY_EVALID;
787 }
788
789 return LY_SUCCESS;
790}
791
Michal Vasko25d6ad02020-10-22 12:20:22 +0200792LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200793lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100794 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
Michal Vaskocfaff232020-10-20 09:35:14 +0200795{
796 uint32_t i;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200797 const char *ptr, *start, **imp_f, *all_f[] = {"*", NULL};
Michal Vaskocfaff232020-10-20 09:35:14 +0200798 const struct lys_module *mod;
799
Michal Vasko25d6ad02020-10-22 12:20:22 +0200800 assert(implement || mod_p);
801
Michal Vaskocfaff232020-10-20 09:35:14 +0200802 for (i = 0; i < expr->used; ++i) {
803 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
804 /* token cannot have a prefix */
805 continue;
806 }
807
808 start = expr->expr + expr->tok_pos[i];
809 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
810 /* token without a prefix */
811 continue;
812 }
813
814 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
815 /* unknown prefix, do not care right now */
816 continue;
817 }
818
Michal Vasko0c296722021-07-14 08:53:16 +0200819 /* unimplemented module found */
820 if (!mod->implemented && !implement) {
821 /* should not be implemented now */
822 *mod_p = mod;
823 break;
824 }
825
Michal Vaskocfaff232020-10-20 09:35:14 +0200826 if (!mod->implemented) {
Michal Vasko0c296722021-07-14 08:53:16 +0200827 /* implement if not implemented */
Michal Vaskoc56d6372021-10-19 12:29:00 +0200828 imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
829 LY_CHECK_RET(lys_implement((struct lys_module *)mod, imp_f, unres));
Michal Vasko0c296722021-07-14 08:53:16 +0200830 }
831 if (!mod->compiled) {
832 /* compile if not implemented before or only marked for compilation */
833 LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres));
Michal Vaskocfaff232020-10-20 09:35:14 +0200834 }
835 }
836
Michal Vasko25d6ad02020-10-22 12:20:22 +0200837 return LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200838}
839
840/**
Michal Vaskoc130e162021-10-19 11:30:00 +0200841 * @brief Check when expressions of a node on a complete compiled schema tree.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200842 *
843 * @param[in] ctx Compile context.
844 * @param[in] node Node to check.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100845 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +0200846 * @return LY_ERECOMPILE
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200847 * @return LY_ERR value
848 */
849static LY_ERR
Michal Vaskoc130e162021-10-19 11:30:00 +0200850lys_compile_unres_when(struct lysc_ctx *ctx, const struct lysc_node *node, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200851{
852 struct lyxp_set tmp_set;
853 uint32_t i, opts;
854 LY_ARRAY_COUNT_TYPE u;
Radek Krejci9a3823e2021-01-27 20:26:46 +0100855 struct lysc_when **whens = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200856 LY_ERR ret = LY_SUCCESS;
Michal Vaskocfaff232020-10-20 09:35:14 +0200857 const struct lys_module *mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200858
Radek Krejciddace2c2021-01-08 11:30:56 +0100859 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100860
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200861 memset(&tmp_set, 0, sizeof tmp_set);
Michal Vaskod1e53b92021-01-28 13:11:06 +0100862 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200863
Radek Krejci9a3823e2021-01-27 20:26:46 +0100864 whens = lysc_node_when(node);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100865 LY_ARRAY_FOR(whens, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200866 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200867 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200868 ret = lys_compile_expr_implement(ctx->ctx, whens[u]->cond, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100869 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200870 if (ret) {
871 goto cleanup;
872 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200873 LOGWRN(ctx->ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
Radek Krejci9a3823e2021-01-27 20:26:46 +0100874 whens[u]->cond->expr, mod->name);
Michal Vaskocfaff232020-10-20 09:35:14 +0200875 continue;
876 }
877
878 /* check "when" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200879 ret = lyxp_atomize(ctx->ctx, whens[u]->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, whens[u]->prefixes,
Radek Krejci9a3823e2021-01-27 20:26:46 +0100880 whens[u]->context, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200881 if (ret) {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100882 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", whens[u]->cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200883 goto cleanup;
884 }
885
886 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100887 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200888 for (i = 0; i < tmp_set.used; ++i) {
889 /* skip roots'n'stuff */
Michal Vasko6b8c5102021-10-19 11:29:32 +0200890 if ((tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) &&
891 (tmp_set.val.scnodes[i].in_ctx != LYXP_SET_SCNODE_START_USED)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200892 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
893
894 /* XPath expression cannot reference "lower" status than the node that has the definition */
Radek Krejci9a3823e2021-01-27 20:26:46 +0100895 ret = lysc_check_status(ctx, whens[u]->flags, node->module, node->name, schema->flags, schema->module,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200896 schema->name);
897 LY_CHECK_GOTO(ret, cleanup);
898
Michal Vasko1a09b212021-05-06 13:00:10 +0200899 /* check dummy node children/value accessing */
900 if (lysc_data_parent(schema) == node) {
901 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
902 ret = LY_EVALID;
903 goto cleanup;
904 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
905 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200906 ret = LY_EVALID;
907 goto cleanup;
908 }
909 }
910 }
911
912 /* check cyclic dependencies */
913 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
914 LY_CHECK_GOTO(ret, cleanup);
915
916 lyxp_set_free_content(&tmp_set);
917 }
918
Michal Vaskoc130e162021-10-19 11:30:00 +0200919cleanup:
920 lyxp_set_free_content(&tmp_set);
921 LOG_LOCBACK(1, 0, 0, 0);
922 return ret;
923}
924
925/**
926 * @brief Check must expressions of a node on a complete compiled schema tree.
927 *
928 * @param[in] ctx Compile context.
929 * @param[in] node Node to check.
930 * @param[in] local_mods Sized array of local modules for musts of @p node at the same index.
931 * @param[in,out] unres Global unres structure.
932 * @return LY_ERECOMPILE
933 * @return LY_ERR value
934 */
935static LY_ERR
936lys_compile_unres_must(struct lysc_ctx *ctx, const struct lysc_node *node, const struct lysp_module **local_mods,
937 struct lys_glob_unres *unres)
938{
939 struct lyxp_set tmp_set;
940 uint32_t i, opts;
941 LY_ARRAY_COUNT_TYPE u;
942 struct lysc_must *musts = NULL;
943 LY_ERR ret = LY_SUCCESS;
944 const struct lys_module *mod;
945 uint16_t flg;
946
947 LOG_LOCSET(node, NULL, NULL, NULL);
948
949 memset(&tmp_set, 0, sizeof tmp_set);
950 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
951
952 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200953 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200954 /* first check whether all the referenced modules are implemented */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200955 mod = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200956 ret = lys_compile_expr_implement(ctx->ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100957 ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200958 if (ret) {
959 goto cleanup;
960 } else if (mod) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200961 LOGWRN(ctx->ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
962 musts[u].cond->expr, mod->name);
963 continue;
964 }
965
966 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200967 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 +0100968 &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200969 if (ret) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100970 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must restriction \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200971 goto cleanup;
972 }
973
974 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100975 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200976 for (i = 0; i < tmp_set.used; ++i) {
977 /* skip roots'n'stuff */
978 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
979 /* XPath expression cannot reference "lower" status than the node that has the definition */
Michal Vaskoc130e162021-10-19 11:30:00 +0200980 if (local_mods[u]->mod == node->module) {
981 /* use flags of the context node since the definition is local */
982 flg = node->flags;
983 } else {
984 /* definition is foreign (deviation, refine), always current */
985 flg = LYS_STATUS_CURR;
986 }
987 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 +0200988 tmp_set.val.scnodes[i].scnode->module, tmp_set.val.scnodes[i].scnode->name);
989 LY_CHECK_GOTO(ret, cleanup);
990 }
991 }
992
993 lyxp_set_free_content(&tmp_set);
994 }
995
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200996cleanup:
997 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +0100998 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200999 return ret;
1000}
1001
1002/**
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001003 * @brief Remove all disabled bits/enums from a sized array.
1004 *
1005 * @param[in] ctx Context with the dictionary.
1006 * @param[in] items Sized array of bits/enums.
1007 */
1008static void
1009lys_compile_unres_disabled_bitenum_remove(struct ly_ctx *ctx, struct lysc_type_bitenum_item *items)
1010{
1011 LY_ARRAY_COUNT_TYPE u = 0, last_u;
1012
1013 while (u < LY_ARRAY_COUNT(items)) {
1014 if (items[u].flags & LYS_DISABLED) {
1015 /* free the disabled item */
1016 lysc_enum_item_free(ctx, &items[u]);
1017
1018 /* replace it with the following items */
1019 last_u = LY_ARRAY_COUNT(items) - 1;
1020 if (u < last_u) {
1021 memmove(items + u, items + u + 1, (last_u - u) * sizeof *items);
1022 }
1023
1024 /* one item less */
1025 LY_ARRAY_DECREMENT(items);
1026 continue;
1027 }
1028
1029 ++u;
1030 }
1031}
1032
1033/**
1034 * @brief Find and remove all disabled bits/enums in a leaf/leaf-list type.
1035 *
1036 * @param[in] ctx Compile context.
1037 * @param[in] leaf Leaf/leaf-list to check.
1038 * @return LY_ERR value
1039 */
1040static LY_ERR
1041lys_compile_unres_disabled_bitenum(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf)
1042{
1043 struct lysc_type **t;
1044 LY_ARRAY_COUNT_TYPE u, count;
1045 struct lysc_type_enum *ent;
1046
1047 if (leaf->type->basetype == LY_TYPE_UNION) {
1048 t = ((struct lysc_type_union *)leaf->type)->types;
1049 count = LY_ARRAY_COUNT(t);
1050 } else {
1051 t = &leaf->type;
1052 count = 1;
1053 }
1054 for (u = 0; u < count; ++u) {
1055 if ((t[u]->basetype == LY_TYPE_BITS) || (t[u]->basetype == LY_TYPE_ENUM)) {
1056 /* remove all disabled items */
1057 ent = (struct lysc_type_enum *)(t[u]);
1058 lys_compile_unres_disabled_bitenum_remove(ctx->ctx, ent->enums);
1059
1060 if (!LY_ARRAY_COUNT(ent->enums)) {
1061 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "%s type of node \"%s\" without any (or all disabled) valid values.",
1062 (ent->basetype == LY_TYPE_BITS) ? "Bits" : "Enumeration", leaf->name);
1063 return LY_EVALID;
1064 }
1065 }
1066 }
1067
1068 return LY_SUCCESS;
1069}
1070
1071/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001072 * @brief Check leafref for its target existence on a complete compiled schema tree.
1073 *
1074 * @param[in] ctx Compile context.
1075 * @param[in] node Context node for the leafref.
1076 * @param[in] lref Leafref to check/resolve.
Michal Vaskoc130e162021-10-19 11:30:00 +02001077 * @param[in] local_mod Local module for the leafref type.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001078 * @param[in,out] unres Global unres structure.
Michal Vasko40c158c2021-04-28 17:01:03 +02001079 * @return LY_ERECOMPILE if context recompilation is needed,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001080 * @return LY_ERR value.
1081 */
1082static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001083lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
Michal Vaskoc130e162021-10-19 11:30:00 +02001084 const struct lysp_module *local_mod, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001085{
Michal Vaskod1e53b92021-01-28 13:11:06 +01001086 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001087 struct ly_path *p;
1088 struct lysc_type *type;
Michal Vaskoc130e162021-10-19 11:30:00 +02001089 uint16_t flg;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001090
1091 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
1092
Michal Vasko24fc4d12021-07-12 14:41:20 +02001093 /* first implement all the modules in the path */
1094 LY_CHECK_RET(lys_compile_expr_implement(ctx->ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1095
Michal Vaskoed725d72021-06-23 12:03:45 +02001096 /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */
1097 LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, NULL, lref->path,
Michal Vaskod1e53b92021-01-28 13:11:06 +01001098 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +02001099 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001100
1101 /* get the target node */
1102 target = p[LY_ARRAY_COUNT(p) - 1].node;
1103 ly_path_free(node->module->ctx, p);
1104
1105 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001106 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 +02001107 lref->path->expr, lys_nodetype2str(target->nodetype));
1108 return LY_EVALID;
1109 }
1110
1111 /* check status */
1112 ctx->path[0] = '\0';
1113 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
1114 ctx->path_len = strlen(ctx->path);
Michal Vaskoc130e162021-10-19 11:30:00 +02001115 if (node->module == local_mod->mod) {
1116 /* use flags of the context node since the definition is local */
1117 flg = node->flags;
1118 } else {
1119 /* definition is foreign (deviation), always current */
1120 flg = LYS_STATUS_CURR;
1121 }
1122 if (lysc_check_status(ctx, flg, local_mod->mod, node->name, target->flags, target->module, target->name)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001123 return LY_EVALID;
1124 }
1125 ctx->path_len = 1;
1126 ctx->path[1] = '\0';
1127
1128 /* check config */
1129 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +01001130 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001131 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001132 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
1133 return LY_EVALID;
1134 }
1135 }
1136
Michal Vaskod15c7de2022-05-09 15:34:09 +02001137 /* check for circular chain of leafrefs */
1138 for (type = ((struct lysc_node_leaf *)target)->type;
1139 type && (type->basetype == LY_TYPE_LEAFREF);
1140 type = ((struct lysc_type_leafref *)type)->realtype) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001141 if (type == (struct lysc_type *)lref) {
1142 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001143 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
1144 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001145 return LY_EVALID;
1146 }
1147 }
1148
Michal Vaskod15c7de2022-05-09 15:34:09 +02001149 /* store the type */
1150 lref->realtype = ((struct lysc_node_leaf *)target)->type;
1151 ++lref->realtype->refcount;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001152 return LY_SUCCESS;
1153}
1154
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001155/**
1156 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
1157 *
1158 * @param[in] ctx Compile context.
1159 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
1160 * @param[in] type Type of the default value.
1161 * @param[in] dflt Default value.
1162 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
1163 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001164 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001165 * @return LY_ERR value.
1166 */
1167static LY_ERR
1168lys_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 +01001169 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001170{
1171 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +02001172 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001173 struct ly_err_item *err = NULL;
1174
Radek Krejci0b013302021-03-29 15:22:32 +02001175 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +02001176 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001177 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001178 if (ret == LY_ERECOMPILE) {
1179 /* fine, but we need to recompile */
1180 return LY_ERECOMPILE;
1181 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001182 /* we have no data so we will not be resolving it */
1183 ret = LY_SUCCESS;
1184 }
1185
1186 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +01001187 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001188 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001189 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001190 ly_err_free(err);
1191 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001192 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001193 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001194 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001195 return ret;
1196 }
1197
Michal Vasko04338d92021-09-01 07:58:14 +02001198 LY_ATOMIC_INC_BARRIER(((struct lysc_type *)storage->realtype)->refcount);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001199 return LY_SUCCESS;
1200}
1201
1202/**
1203 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
1204 *
1205 * @param[in] ctx Compile context.
1206 * @param[in] leaf Leaf that the default value is for.
1207 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001208 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001209 * @return LY_ERR value.
1210 */
1211static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001212lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
1213 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001214{
1215 LY_ERR ret;
1216
1217 assert(!leaf->dflt);
1218
1219 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
1220 /* ignore default values for keys and mandatory leaves */
1221 return LY_SUCCESS;
1222 }
1223
1224 /* allocate the default value */
1225 leaf->dflt = calloc(1, sizeof *leaf->dflt);
1226 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
1227
1228 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001229 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001230 if (ret) {
1231 free(leaf->dflt);
1232 leaf->dflt = NULL;
1233 }
1234
1235 return ret;
1236}
1237
1238/**
1239 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1240 *
1241 * @param[in] ctx Compile context.
1242 * @param[in] llist Leaf-list that the default value(s) are for.
1243 * @param[in] dflt Default value to compile, in case of a single value.
1244 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001245 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001246 * @return LY_ERR value.
1247 */
1248static LY_ERR
1249lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001250 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001251{
1252 LY_ERR ret;
1253 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1254
1255 assert(dflt || dflts);
1256
Radek Krejcic7d13e32020-12-09 12:32:24 +01001257 /* in case there were already some defaults and we are adding new by deviations */
1258 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001259
1260 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001261 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 +02001262
1263 /* fill each new default value */
1264 if (dflts) {
1265 LY_ARRAY_FOR(dflts, u) {
1266 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001267 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001268 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001269 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1270 LY_ARRAY_INCREMENT(llist->dflts);
1271 }
1272 } else {
1273 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001274 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001275 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001276 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1277 LY_ARRAY_INCREMENT(llist->dflts);
1278 }
1279
1280 /* check default value uniqueness */
1281 if (llist->flags & LYS_CONFIG_W) {
1282 /* configuration data values must be unique - so check the default values */
1283 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1284 for (v = 0; v < u; ++v) {
1285 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001286 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001287 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Radek Krejci6d5ba0c2021-04-26 07:49:59 +02001288 llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON, NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001289 lysc_update_path(ctx, NULL, NULL);
1290 return LY_EVALID;
1291 }
1292 }
1293 }
1294 }
1295
1296 return LY_SUCCESS;
1297}
1298
Michal Vaskof4258e12021-06-15 12:11:42 +02001299/**
aPiecek732cd142021-07-07 16:29:59 +02001300 * @brief Iteratively get all leafrefs from @p node
1301 * if the node is of type union, otherwise just return the leafref.
1302 *
1303 * @param[in] node Node that may contain the leafref.
1304 * @param[in,out] index Value that is passed between function calls.
1305 * For each new node, initialize value of the @p index to 0, otherwise
1306 * do not modify the value between calls.
1307 * @return Pointer to the leafref or next leafref, otherwise NULL.
1308 */
1309static struct lysc_type_leafref *
1310lys_type_leafref_next(const struct lysc_node *node, uint64_t *index)
1311{
1312 struct lysc_type_leafref *ret = NULL;
1313 struct lysc_type_union *uni;
1314 struct lysc_type *leaf_type;
1315
1316 assert(node->nodetype & LYD_NODE_TERM);
1317
1318 leaf_type = ((struct lysc_node_leaf *)node)->type;
1319 if (leaf_type->basetype == LY_TYPE_UNION) {
1320 uni = (struct lysc_type_union *)leaf_type;
1321
1322 /* find next union leafref */
1323 while (*index < LY_ARRAY_COUNT(uni->types)) {
1324 if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) {
1325 ret = (struct lysc_type_leafref *)uni->types[*index];
1326 ++(*index);
1327 break;
1328 }
1329
1330 ++(*index);
1331 }
1332 } else {
1333 /* return just the single leafref */
1334 if (*index == 0) {
1335 ++(*index);
1336 assert(leaf_type->basetype == LY_TYPE_LEAFREF);
1337 ret = (struct lysc_type_leafref *)leaf_type;
1338 }
1339 }
1340
1341 return ret;
1342}
1343
1344/**
Michal Vaskof4258e12021-06-15 12:11:42 +02001345 * @brief Finish dependency set compilation by resolving all the unres sets.
1346 *
1347 * @param[in] ctx libyang context.
1348 * @param[in] unres Global unres structure with the sets to resolve.
1349 * @return LY_SUCCESS on success.
1350 * @return LY_ERECOMPILE if the dep set needs to be recompiled.
1351 * @return LY_ERR value on error.
1352 */
1353static LY_ERR
1354lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001355{
aPiecek732cd142021-07-07 16:29:59 +02001356 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001357 struct lysc_node *node;
aPiecek732cd142021-07-07 16:29:59 +02001358 struct lysc_type *typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001359 struct lysc_type_leafref *lref;
aPiecekd7bd52d2021-07-08 08:59:59 +02001360 struct lysc_ctx cctx;
Michal Vaskof4258e12021-06-15 12:11:42 +02001361 struct lys_depset_unres *ds_unres;
aPiecekd7bd52d2021-07-08 08:59:59 +02001362 struct ly_path *path;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001363 LY_ARRAY_COUNT_TYPE v;
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001364 struct lysc_unres_leafref *l;
aPiecekd7bd52d2021-07-08 08:59:59 +02001365 uint32_t i, processed_leafrefs = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001366
Michal Vaskof4258e12021-06-15 12:11:42 +02001367 ds_unres = &unres->ds_unres;
1368
Michal Vasko405cc9e2020-12-01 12:01:27 +01001369 /* fake compile context */
aPiecekd7bd52d2021-07-08 08:59:59 +02001370resolve_all:
1371 memset(&cctx, 0, sizeof cctx);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001372 cctx.ctx = ctx;
1373 cctx.path_len = 1;
1374 cctx.path[0] = '/';
1375
1376 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1377 * 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 +02001378 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation.
1379 * Also do the same check for set of the disabled leafrefs, but without the second round. */
1380 while (ds_unres->disabled_leafrefs.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001381 /* remember index, it can change before we get to free this item */
1382 i = ds_unres->disabled_leafrefs.count - 1;
1383 l = ds_unres->disabled_leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001384 cctx.cur_mod = l->node->module;
1385 cctx.pmod = l->node->module->parsed;
aPiecekc6526b42021-07-12 15:21:39 +02001386
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001387 LOG_LOCSET(l->node, NULL, NULL, NULL);
aPiecekc6526b42021-07-12 15:21:39 +02001388 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001389 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
1390 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres);
aPiecekc6526b42021-07-12 15:21:39 +02001391 }
aPiecekc6526b42021-07-12 15:21:39 +02001392 LOG_LOCBACK(1, 0, 0, 0);
1393 LY_CHECK_RET(ret);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001394
1395 ly_set_rm_index(&ds_unres->disabled_leafrefs, i, free);
aPiecekc6526b42021-07-12 15:21:39 +02001396 }
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001397
aPiecekd7bd52d2021-07-08 08:59:59 +02001398 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001399 l = ds_unres->leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001400 cctx.cur_mod = l->node->module;
1401 cctx.pmod = l->node->module->parsed;
1402 LOG_LOCSET(l->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001403
aPiecek732cd142021-07-07 16:29:59 +02001404 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001405 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
1406 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod, unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001407 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001408
Radek Krejciddace2c2021-01-08 11:30:56 +01001409 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001410 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001411 }
aPiecekd7bd52d2021-07-08 08:59:59 +02001412 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001413 l = ds_unres->leafrefs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001414
Michal Vasko405cc9e2020-12-01 12:01:27 +01001415 /* store pointer to the real type */
aPiecek732cd142021-07-07 16:29:59 +02001416 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001417 while ((lref = lys_type_leafref_next(l->node, &v))) {
aPiecek732cd142021-07-07 16:29:59 +02001418 for (typeiter = lref->realtype;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001419 typeiter->basetype == LY_TYPE_LEAFREF;
1420 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
Michal Vaskod15c7de2022-05-09 15:34:09 +02001421
1422 lysc_type_free(ctx, lref->realtype);
aPiecek732cd142021-07-07 16:29:59 +02001423 lref->realtype = typeiter;
Michal Vaskod15c7de2022-05-09 15:34:09 +02001424 ++lref->realtype->refcount;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001425 }
1426
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001427 /* If 'goto' will be used on the 'resolve_all' label, then
aPiecekd7bd52d2021-07-08 08:59:59 +02001428 * the current leafref will not be processed again.
1429 */
1430 processed_leafrefs++;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001431 }
1432
Michal Vaskoc130e162021-10-19 11:30:00 +02001433 /* check when */
1434 while (ds_unres->whens.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001435 i = ds_unres->whens.count - 1;
1436 node = ds_unres->whens.objs[i];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001437 cctx.cur_mod = node->module;
1438 cctx.pmod = node->module->parsed;
1439
Radek Krejciddace2c2021-01-08 11:30:56 +01001440 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001441 ret = lys_compile_unres_when(&cctx, node, unres);
Radek Krejciddace2c2021-01-08 11:30:56 +01001442 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001443 LY_CHECK_RET(ret);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001444
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001445 ly_set_rm_index(&ds_unres->whens, i, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001446 }
1447
1448 /* check must */
1449 while (ds_unres->musts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001450 i = ds_unres->musts.count - 1;
1451 struct lysc_unres_must *m = ds_unres->musts.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001452 cctx.cur_mod = m->node->module;
1453 cctx.pmod = m->node->module->parsed;
1454
1455 LOG_LOCSET(m->node, NULL, NULL, NULL);
1456 ret = lys_compile_unres_must(&cctx, m->node, m->local_mods, unres);
1457 LOG_LOCBACK(1, 0, 0, 0);
1458 LY_CHECK_RET(ret);
1459
1460 lysc_unres_must_free(m);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001461 ly_set_rm_index(&ds_unres->musts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001462 }
1463
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001464 /* remove disabled enums/bits */
Michal Vasko5eaf7322021-11-22 15:58:26 +01001465 while (ds_unres->disabled_bitenums.count) {
1466 i = ds_unres->disabled_bitenums.count - 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001467 node = ds_unres->disabled_bitenums.objs[i];
1468 cctx.cur_mod = node->module;
1469 cctx.pmod = node->module->parsed;
1470
1471 LOG_LOCSET(node, NULL, NULL, NULL);
1472 ret = lys_compile_unres_disabled_bitenum(&cctx, (struct lysc_node_leaf *)node);
1473 LOG_LOCBACK(1, 0, 0, 0);
1474 LY_CHECK_RET(ret);
1475
1476 ly_set_rm_index(&ds_unres->disabled_bitenums, i, NULL);
1477 }
1478
Michal Vasko405cc9e2020-12-01 12:01:27 +01001479 /* finish incomplete default values compilation */
Michal Vaskof4258e12021-06-15 12:11:42 +02001480 while (ds_unres->dflts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001481 i = ds_unres->dflts.count - 1;
1482 struct lysc_unres_dflt *r = ds_unres->dflts.objs[i];
Michal Vasko405cc9e2020-12-01 12:01:27 +01001483 cctx.cur_mod = r->leaf->module;
1484 cctx.pmod = r->leaf->module->parsed;
1485
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001486 LOG_LOCSET(&r->leaf->node, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001487 if (r->leaf->nodetype == LYS_LEAF) {
1488 ret = lys_compile_unres_leaf_dlft(&cctx, r->leaf, r->dflt, unres);
1489 } else {
1490 ret = lys_compile_unres_llist_dflts(&cctx, r->llist, r->dflt, r->dflts, unres);
1491 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001492 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko7213ac52021-06-15 11:52:13 +02001493 LY_CHECK_RET(ret);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001494
1495 lysc_unres_dflt_free(ctx, r);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001496 ly_set_rm_index(&ds_unres->dflts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001497 }
1498
Michal Vasko40c158c2021-04-28 17:01:03 +02001499 /* some unres items may have been added */
aPiecekc6526b42021-07-12 15:21:39 +02001500 if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count ||
Michal Vaskoc130e162021-10-19 11:30:00 +02001501 ds_unres->whens.count || ds_unres->musts.count || ds_unres->dflts.count) {
aPiecekd7bd52d2021-07-08 08:59:59 +02001502 goto resolve_all;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001503 }
1504
Michal Vasko30ab8e72021-04-19 12:47:52 +02001505 /* finally, remove all disabled nodes */
Michal Vaskof4258e12021-06-15 12:11:42 +02001506 for (i = 0; i < ds_unres->disabled.count; ++i) {
1507 node = ds_unres->disabled.snodes[i];
Michal Vasko30ab8e72021-04-19 12:47:52 +02001508 if (node->flags & LYS_KEY) {
1509 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001510 LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001511 LOG_LOCBACK(1, 0, 0, 0);
1512 return LY_EVALID;
1513 }
1514
1515 lysc_node_free(ctx, node, 1);
1516 }
1517
aPiecekd7bd52d2021-07-08 08:59:59 +02001518 /* also check if the leafref target has not been disabled */
1519 for (i = 0; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001520 l = ds_unres->leafrefs.objs[i];
Michal Vaskoc130e162021-10-19 11:30:00 +02001521 cctx.cur_mod = l->node->module;
1522 cctx.pmod = l->node->module->parsed;
aPiecekd7bd52d2021-07-08 08:59:59 +02001523
1524 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001525 while ((lref = lys_type_leafref_next(l->node, &v))) {
1526 ret = ly_path_compile_leafref(cctx.ctx, l->node, NULL, lref->path,
1527 (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
aPiecekd7bd52d2021-07-08 08:59:59 +02001528 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
Michal Vaskoc130e162021-10-19 11:30:00 +02001529 ly_path_free(l->node->module->ctx, path);
aPiecekd7bd52d2021-07-08 08:59:59 +02001530
1531 assert(ret != LY_ERECOMPILE);
1532 if (ret) {
Michal Vaskoc130e162021-10-19 11:30:00 +02001533 LOG_LOCSET(l->node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001534 LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.",
Michal Vaskoc130e162021-10-19 11:30:00 +02001535 l->node->name);
aPiecekd7bd52d2021-07-08 08:59:59 +02001536 LOG_LOCBACK(1, 0, 0, 0);
1537 return LY_EVALID;
1538 }
1539 }
1540 }
1541
Michal Vasko405cc9e2020-12-01 12:01:27 +01001542 return LY_SUCCESS;
1543}
1544
Michal Vaskof4258e12021-06-15 12:11:42 +02001545/**
1546 * @brief Erase dep set unres.
1547 *
1548 * @param[in] ctx libyang context.
1549 * @param[in] unres Global unres structure with the sets to resolve.
1550 */
1551static void
1552lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001553{
1554 uint32_t i;
1555
Michal Vaskoc130e162021-10-19 11:30:00 +02001556 ly_set_erase(&unres->ds_unres.whens, NULL);
1557 for (i = 0; i < unres->ds_unres.musts.count; ++i) {
1558 lysc_unres_must_free(unres->ds_unres.musts.objs[i]);
1559 }
1560 ly_set_erase(&unres->ds_unres.musts, NULL);
1561 ly_set_erase(&unres->ds_unres.leafrefs, free);
Michal Vaskof4258e12021-06-15 12:11:42 +02001562 for (i = 0; i < unres->ds_unres.dflts.count; ++i) {
1563 lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]);
Michal Vaskodf6319c2021-06-10 14:41:05 +02001564 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001565 ly_set_erase(&unres->ds_unres.dflts, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001566 ly_set_erase(&unres->ds_unres.disabled, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001567 ly_set_erase(&unres->ds_unres.disabled_leafrefs, free);
1568 ly_set_erase(&unres->ds_unres.disabled_bitenums, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001569}
1570
Michal Vasko709f9a52021-07-21 10:51:59 +02001571/**
1572 * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed.
1573 *
1574 * @param[in] ctx libyang context.
1575 * @param[in] dep_set Dependency set to compile.
1576 * @param[in,out] unres Global unres to use.
1577 * @return LY_ERR value.
1578 */
1579static LY_ERR
1580lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres)
Michal Vaskof4258e12021-06-15 12:11:42 +02001581{
1582 LY_ERR ret = LY_SUCCESS;
1583 struct lys_module *mod;
1584 uint32_t i;
1585
1586 for (i = 0; i < dep_set->count; ++i) {
1587 mod = dep_set->objs[i];
1588 if (!mod->to_compile) {
1589 /* skip */
1590 continue;
1591 }
1592 assert(mod->implemented);
1593
1594 /* free the compiled module, if any */
1595 lysc_module_free(mod->compiled);
1596 mod->compiled = NULL;
1597
1598 /* (re)compile the module */
1599 LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001600 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001601
1602 /* resolve dep set unres */
1603 ret = lys_compile_unres_depset(ctx, unres);
1604 if (ret == LY_ERECOMPILE) {
1605 /* new module is implemented, discard current dep set unres and recompile the whole dep set */
1606 lys_compile_unres_depset_erase(ctx, unres);
Michal Vasko709f9a52021-07-21 10:51:59 +02001607 return lys_compile_depset_r(ctx, dep_set, unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001608 } else if (ret) {
1609 /* error */
1610 goto cleanup;
1611 }
1612
1613 /* success, unset the flags of all the modules in the dep set */
1614 for (i = 0; i < dep_set->count; ++i) {
1615 mod = dep_set->objs[i];
1616 mod->to_compile = 0;
1617 }
1618
1619cleanup:
1620 lys_compile_unres_depset_erase(ctx, unres);
1621 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001622}
1623
Michal Vasko6a4ef772022-02-08 15:07:44 +01001624/**
1625 * @brief Check if-feature of all features of all modules in a dep set.
1626 *
1627 * @param[in] dep_set Dep set to check.
1628 * @return LY_ERR value.
1629 */
1630static LY_ERR
1631lys_compile_depset_check_features(struct ly_set *dep_set)
1632{
1633 struct lys_module *mod;
1634 uint32_t i;
1635
1636 for (i = 0; i < dep_set->count; ++i) {
1637 mod = dep_set->objs[i];
1638 if (!mod->to_compile) {
1639 /* skip */
1640 continue;
1641 }
1642
1643 /* check features of this module */
1644 LY_CHECK_RET(lys_check_features(mod->parsed));
1645 }
1646
1647 return LY_SUCCESS;
1648}
1649
Michal Vasko709f9a52021-07-21 10:51:59 +02001650LY_ERR
1651lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1652{
1653 uint32_t i;
1654
1655 for (i = 0; i < unres->dep_sets.count; ++i) {
Michal Vasko6a4ef772022-02-08 15:07:44 +01001656 LY_CHECK_RET(lys_compile_depset_check_features(unres->dep_sets.objs[i]));
Michal Vasko709f9a52021-07-21 10:51:59 +02001657 LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres));
1658 }
1659
1660 return LY_SUCCESS;
1661}
1662
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001663/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001664 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001665 *
1666 * @param[in] ctx Compile context with unres sets.
1667 * @return LY_ERR value.
1668 */
1669static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001670lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001671{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001672 struct lysc_augment *aug;
1673 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001674 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001675 uint32_t i;
1676
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001677 /* check that all augments were applied */
1678 for (i = 0; i < ctx->augs.count; ++i) {
1679 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001680 ctx->cur_mod = aug->aug_pmod->mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001681 lysc_update_path(ctx, NULL, "{augment}");
1682 lysc_update_path(ctx, NULL, aug->nodeid->expr);
1683 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment target node \"%s\" from module \"%s\" was not found.",
Michal Vasko28fe5f62021-03-03 16:37:39 +01001684 aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001685 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001686 lysc_update_path(ctx, NULL, NULL);
1687 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001688 }
1689 if (ctx->augs.count) {
1690 return LY_ENOTFOUND;
1691 }
1692
1693 /* check that all deviations were applied */
1694 for (i = 0; i < ctx->devs.count; ++i) {
1695 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001696 lysc_update_path(ctx, NULL, "{deviation}");
1697 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1698 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1699 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1700 lysc_update_path(ctx, NULL, NULL);
1701 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001702 }
1703 if (ctx->devs.count) {
1704 return LY_ENOTFOUND;
1705 }
1706
1707 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001708}
1709
1710/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001711 * @brief Erase all the module unres sets in a compile context.
1712 *
1713 * @param[in] ctx Compile context with unres sets.
1714 * @param[in] error Whether the compilation finished with an error or not.
1715 */
1716static void
1717lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1718{
1719 uint32_t i;
1720
1721 ly_set_erase(&ctx->groupings, NULL);
1722 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001723
1724 if (!error) {
1725 /* there can be no leftover deviations or augments */
1726 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1727 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1728
1729 ly_set_erase(&ctx->augs, NULL);
1730 ly_set_erase(&ctx->devs, NULL);
1731 ly_set_erase(&ctx->uses_augs, NULL);
1732 ly_set_erase(&ctx->uses_rfns, NULL);
1733 } else {
1734 for (i = 0; i < ctx->augs.count; ++i) {
1735 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1736 }
1737 ly_set_erase(&ctx->augs, NULL);
1738 for (i = 0; i < ctx->devs.count; ++i) {
1739 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1740 }
1741 ly_set_erase(&ctx->devs, NULL);
1742 for (i = 0; i < ctx->uses_augs.count; ++i) {
1743 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1744 }
1745 ly_set_erase(&ctx->uses_augs, NULL);
1746 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1747 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1748 }
1749 ly_set_erase(&ctx->uses_rfns, NULL);
1750 }
1751}
1752
Michal Vaskod39bea42021-06-14 10:42:49 +02001753LY_ERR
Michal Vaskof4258e12021-06-15 12:11:42 +02001754lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001755{
1756 struct lysc_ctx ctx = {0};
Michal Vasko0b395e12021-04-23 13:43:07 +02001757 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001758 struct lysp_module *sp;
1759 struct lysp_submodule *submod;
1760 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001761 struct lysp_node_grp *grp;
1762 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001763 LY_ERR ret = LY_SUCCESS;
1764
1765 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1766
Michal Vaskof4258e12021-06-15 12:11:42 +02001767 assert(mod->implemented && mod->to_compile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001768
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001769 sp = mod->parsed;
1770
1771 ctx.ctx = mod->ctx;
1772 ctx.cur_mod = mod;
1773 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001774 ctx.path_len = 1;
1775 ctx.path[0] = '/';
Michal Vasko405cc9e2020-12-01 12:01:27 +01001776 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001777
Michal Vasko0b395e12021-04-23 13:43:07 +02001778 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001779 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1780 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1781 mod_c->mod = mod;
1782
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001783 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001784 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1785 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001786
1787 /* data nodes */
1788 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001789 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001790 }
1791
Radek Krejci2a9fc652021-01-22 17:44:34 +01001792 /* top-level RPCs */
1793 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001794 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001795 }
1796
1797 /* top-level notifications */
1798 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001799 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001800 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001801
1802 /* extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001803 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001804
1805 /* the same for submodules */
1806 LY_ARRAY_FOR(sp->includes, u) {
1807 submod = sp->includes[u].submodule;
1808 ctx.pmod = (struct lysp_module *)submod;
1809
1810 LY_LIST_FOR(submod->data, pnode) {
1811 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001812 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001813 }
1814
Radek Krejci2a9fc652021-01-22 17:44:34 +01001815 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1816 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001817 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001818 }
1819
1820 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1821 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001822 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001823 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001824
Michal Vasko1ccbf542021-04-19 11:35:00 +02001825 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001826 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001827 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001828
1829 /* validate non-instantiated groupings from the parsed schema,
1830 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko7c565922021-06-10 14:58:27 +02001831 ctx.compile_opts |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001832 LY_LIST_FOR(sp->groupings, grp) {
1833 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001834 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001835 }
1836 }
1837 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001838 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1839 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001840 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001841 }
1842 }
1843 }
1844 LY_ARRAY_FOR(sp->includes, u) {
1845 submod = sp->includes[u].submodule;
1846 ctx.pmod = (struct lysp_module *)submod;
1847
Radek Krejci2a9fc652021-01-22 17:44:34 +01001848 LY_LIST_FOR(submod->groupings, grp) {
1849 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001850 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001851 }
1852 }
1853 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001854 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1855 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001856 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001857 }
1858 }
1859 }
1860 }
1861 ctx.pmod = sp;
1862
Radek Krejciddace2c2021-01-08 11:30:56 +01001863 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001864
Michal Vasko405cc9e2020-12-01 12:01:27 +01001865 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001866 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001867
Michal Vasko1ccbf542021-04-19 11:35:00 +02001868cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01001869 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001870 lys_compile_unres_mod_erase(&ctx, ret);
1871 if (ret) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001872 lysc_module_free(mod_c);
1873 mod->compiled = NULL;
1874 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001875 return ret;
1876}
Michal Vasko65333882021-06-10 14:12:16 +02001877
aPiecek6b3d5422021-07-30 15:55:43 +02001878LY_ERR
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001879lys_compile_identities(struct lys_module *mod)
1880{
1881 struct lysc_ctx ctx = {0};
1882 struct lysp_submodule *submod;
1883 LY_ARRAY_COUNT_TYPE u;
1884
aPiecek6b3d5422021-07-30 15:55:43 +02001885 /* pre-compile identities of the module and any submodules */
1886 LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, mod->parsed, mod->parsed->identities, &mod->identities));
1887 LY_ARRAY_FOR(mod->parsed->includes, u) {
1888 submod = mod->parsed->includes[u].submodule;
1889 LY_CHECK_RET(lys_identity_precompile(NULL, mod->ctx, (struct lysp_module *)submod, submod->identities, &mod->identities));
1890 }
1891
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001892 /* prepare context */
1893 ctx.ctx = mod->ctx;
1894 ctx.cur_mod = mod;
1895 ctx.pmod = mod->parsed;
1896 ctx.path_len = 1;
1897 ctx.path[0] = '/';
1898
1899 if (mod->parsed->identities) {
1900 LY_CHECK_RET(lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities));
1901 }
1902 lysc_update_path(&ctx, NULL, "{submodule}");
1903 LY_ARRAY_FOR(mod->parsed->includes, u) {
1904 submod = mod->parsed->includes[u].submodule;
1905 if (submod->identities) {
1906 ctx.pmod = (struct lysp_module *)submod;
1907 lysc_update_path(&ctx, NULL, submod->name);
1908 LY_CHECK_RET(lys_compile_identities_derived(&ctx, submod->identities, &mod->identities));
1909 lysc_update_path(&ctx, NULL, NULL);
1910 }
1911 }
1912 lysc_update_path(&ctx, NULL, NULL);
1913
1914 return LY_SUCCESS;
1915}
1916
1917/**
Michal Vasko65333882021-06-10 14:12:16 +02001918 * @brief Check whether a module does not have any (recursive) compiled import.
1919 *
1920 * @param[in] mod Module to examine.
1921 * @return LY_SUCCESS on success.
Michal Vaskof4258e12021-06-15 12:11:42 +02001922 * @return LY_ERECOMPILE on required recompilation of the dep set.
Michal Vasko65333882021-06-10 14:12:16 +02001923 * @return LY_ERR on error.
1924 */
1925static LY_ERR
1926lys_has_compiled_import_r(struct lys_module *mod)
1927{
1928 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoe7927122021-06-15 12:00:04 +02001929 struct lys_module *m;
Michal Vasko65333882021-06-10 14:12:16 +02001930
1931 LY_ARRAY_FOR(mod->parsed->imports, u) {
Michal Vaskoe7927122021-06-15 12:00:04 +02001932 m = mod->parsed->imports[u].module;
1933 if (!m->implemented) {
Michal Vasko65333882021-06-10 14:12:16 +02001934 continue;
1935 }
1936
Michal Vaskoe7927122021-06-15 12:00:04 +02001937 if (!m->to_compile) {
Michal Vaskod39bea42021-06-14 10:42:49 +02001938 /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */
Michal Vaskof4258e12021-06-15 12:11:42 +02001939 m->to_compile = 1;
Michal Vasko65333882021-06-10 14:12:16 +02001940 return LY_ERECOMPILE;
1941 }
1942
1943 /* recursive */
Michal Vaskoe7927122021-06-15 12:00:04 +02001944 LY_CHECK_RET(lys_has_compiled_import_r(m));
Michal Vasko65333882021-06-10 14:12:16 +02001945 }
1946
1947 return LY_SUCCESS;
1948}
1949
1950LY_ERR
1951lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
1952{
1953 LY_ERR ret;
1954 struct lys_module *m;
1955
1956 assert(!mod->implemented);
1957
Michal Vasko978532b2022-01-21 14:13:40 +01001958 /* check collision with other implemented revision */
Michal Vasko65333882021-06-10 14:12:16 +02001959 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
1960 if (m) {
1961 assert(m != mod);
Michal Vasko978532b2022-01-21 14:13:40 +01001962 if (!strcmp(mod->name, "yang") && (strcmp(m->revision, mod->revision) > 0)) {
1963 /* special case for newer internal module, continue */
1964 LOGVRB("Internal module \"%s@%s\" is already implemented in revision \"%s\", using it instead.",
1965 mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>");
1966 } else {
1967 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in revision \"%s\".",
1968 mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>");
1969 return LY_EDENIED;
1970 }
Michal Vasko65333882021-06-10 14:12:16 +02001971 }
1972
1973 /* set features */
1974 ret = lys_set_features(mod->parsed, features);
1975 if (ret && (ret != LY_EEXIST)) {
1976 return ret;
1977 }
1978
Michal Vasko65333882021-06-10 14:12:16 +02001979 /*
1980 * mark the module implemented, which means
1981 * 1) to (re)compile it only ::lys_compile() call is needed
1982 * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
1983 * but there can be some unres items added that do
1984 */
1985 mod->implemented = 1;
1986
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001987 /* this module is compiled in this compilation */
1988 mod->to_compile = 1;
1989
Michal Vasko65333882021-06-10 14:12:16 +02001990 /* add the module into newly implemented module set */
1991 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
1992
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001993 /* mark target modules with our augments and deviations */
1994 LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres));
Michal Vasko65333882021-06-10 14:12:16 +02001995
Michal Vaskod39bea42021-06-14 10:42:49 +02001996 /* check whether this module may reference any modules compiled previously */
1997 LY_CHECK_RET(lys_has_compiled_import_r(mod));
Michal Vasko65333882021-06-10 14:12:16 +02001998
Michal Vasko65333882021-06-10 14:12:16 +02001999 return LY_SUCCESS;
2000}