blob: 123222865fa6754caf521dc9f9e2a7398f292ba2 [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 Vaskoedb0fa52022-10-04 10:36:00 +02007 * Copyright (c) 2015 - 2022 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 Krejci3e6632f2021-03-22 22:08:21 +010037#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020038#include "plugins_types.h"
39#include "schema_compile_amend.h"
40#include "schema_compile_node.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010041#include "schema_features.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020042#include "set.h"
43#include "tree.h"
44#include "tree_data.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020045#include "tree_schema.h"
Michal Vaskoc636ea42022-09-16 10:20:31 +020046#include "tree_schema_free.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020047#include "tree_schema_internal.h"
48#include "xpath.h"
49
Michal Vaskoa0ba01e2022-10-19 13:26:57 +020050void
51lysc_update_path(struct lysc_ctx *ctx, const struct lys_module *parent_module, const char *name)
52{
53 int len;
54 uint8_t nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
55
56 if (!name) {
57 /* removing last path segment */
58 if (ctx->path[ctx->path_len - 1] == '}') {
59 for ( ; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len) {}
60 if (ctx->path[ctx->path_len] == '=') {
61 ctx->path[ctx->path_len++] = '}';
62 } else {
63 /* not a top-level special tag, remove also preceiding '/' */
64 goto remove_nodelevel;
65 }
66 } else {
67remove_nodelevel:
68 for ( ; ctx->path[ctx->path_len] != '/'; --ctx->path_len) {}
69 if (ctx->path_len == 0) {
70 /* top-level (last segment) */
71 ctx->path_len = 1;
72 }
73 }
74 /* set new terminating NULL-byte */
75 ctx->path[ctx->path_len] = '\0';
76 } else {
77 if (ctx->path_len > 1) {
78 if (!parent_module && (ctx->path[ctx->path_len - 1] == '}') && (ctx->path[ctx->path_len - 2] != '\'')) {
79 /* extension of the special tag */
80 nextlevel = 2;
81 --ctx->path_len;
82 } else {
83 /* there is already some path, so add next level */
84 nextlevel = 1;
85 }
86 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
87
88 if (nextlevel != 2) {
89 if ((parent_module && (parent_module == ctx->cur_mod)) || (!parent_module && (ctx->path_len > 1) && (name[0] == '{'))) {
90 /* module not changed, print the name unprefixed */
91 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
92 } else {
93 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->cur_mod->name, name);
94 }
95 } else {
96 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
97 }
98 if (len >= LYSC_CTX_BUFSIZE - (int)ctx->path_len) {
99 /* output truncated */
100 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
101 } else {
102 ctx->path_len += len;
103 }
104 }
105
106 LOG_LOCBACK(0, 0, 1, 0);
107 LOG_LOCSET(NULL, NULL, ctx->path, NULL);
108}
109
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200110/**
111 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
Michal Vasko193dacd2022-10-13 08:43:05 +0200112 *
113 * @param[in] ctx Compile context.
114 * @param[in] extp Parsed extension instance.
115 * @param[out] ext Compiled extension definition.
116 * @return LY_ERR value.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200117 */
118static LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200119lys_compile_extension(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lysc_ext **ext)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200120{
121 LY_ERR ret = LY_SUCCESS;
Michal Vasko193dacd2022-10-13 08:43:05 +0200122 struct lysp_ext *ep = extp->def;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200123
Michal Vasko193dacd2022-10-13 08:43:05 +0200124 if (!ep->compiled) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200125 lysc_update_path(ctx, NULL, "{extension}");
Michal Vasko193dacd2022-10-13 08:43:05 +0200126 lysc_update_path(ctx, NULL, ep->name);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200127
128 /* compile the extension definition */
Michal Vasko193dacd2022-10-13 08:43:05 +0200129 *ext = ep->compiled = calloc(1, sizeof **ext);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200130 (*ext)->refcount = 1;
Michal Vasko193dacd2022-10-13 08:43:05 +0200131 DUP_STRING_GOTO(ctx->ctx, ep->name, (*ext)->name, ret, cleanup);
132 DUP_STRING_GOTO(ctx->ctx, ep->argname, (*ext)->argname, ret, cleanup);
133 LY_CHECK_GOTO(ret = lysp_ext_find_definition(ctx->ctx, extp, (const struct lys_module **)&(*ext)->module, NULL),
134 cleanup);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200135
136 /* compile nested extensions */
Michal Vasko193dacd2022-10-13 08:43:05 +0200137 COMPILE_EXTS_GOTO(ctx, ep->exts, (*ext)->exts, *ext, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200138
139 lysc_update_path(ctx, NULL, NULL);
140 lysc_update_path(ctx, NULL, NULL);
141
142 /* find extension definition plugin */
Michal Vasko193dacd2022-10-13 08:43:05 +0200143 (*ext)->plugin = extp->record ? (struct lyplg_ext *)&extp->record->plugin : NULL;
Michal Vasko54b11952022-06-08 12:29:39 +0200144 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200145
Michal Vasko193dacd2022-10-13 08:43:05 +0200146 *ext = ep->compiled;
Michal Vaskoc636ea42022-09-16 10:20:31 +0200147
Michal Vasko193dacd2022-10-13 08:43:05 +0200148cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100149 if (ret) {
150 lysc_update_path(ctx, NULL, NULL);
151 lysc_update_path(ctx, NULL, NULL);
152 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200153 return ret;
154}
155
156LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +0200157lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *extp, struct lysc_ext_instance *ext, void *parent)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200158{
Radek Krejci85ac8312021-03-03 20:21:33 +0100159 LY_ERR ret = LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200160
Michal Vasko193dacd2022-10-13 08:43:05 +0200161 DUP_STRING_GOTO(ctx->ctx, extp->argument, ext->argument, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200162 ext->module = ctx->cur_mod;
163 ext->parent = parent;
Michal Vasko193dacd2022-10-13 08:43:05 +0200164 ext->parent_stmt = extp->parent_stmt;
165 ext->parent_stmt_index = extp->parent_stmt_index;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200166
Michal Vasko193dacd2022-10-13 08:43:05 +0200167 lysc_update_path(ctx, (ext->parent_stmt & LY_STMT_NODE_MASK) ? ((struct lysc_node *)ext->parent)->module : NULL,
168 "{extension}");
169 lysc_update_path(ctx, NULL, extp->name);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100170
Michal Vasko193dacd2022-10-13 08:43:05 +0200171 /* compile extension if not already */
172 LY_CHECK_GOTO(ret = lys_compile_extension(ctx, extp, &ext->def), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200173
Michal Vasko193dacd2022-10-13 08:43:05 +0200174 /* compile */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200175 if (ext->def->plugin && ext->def->plugin->compile) {
176 if (ext->argument) {
Radek Krejcia6016992021-03-03 10:13:41 +0100177 lysc_update_path(ctx, ext->module, ext->argument);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200178 }
Michal Vasko193dacd2022-10-13 08:43:05 +0200179 ret = ext->def->plugin->compile(ctx, extp, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100180 if (ret == LY_ENOT) {
Michal Vaskoc636ea42022-09-16 10:20:31 +0200181 lysc_ext_instance_free(&ctx->free_ctx, ext);
Radek Krejcicc21a4f2021-02-09 15:23:31 +0100182 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200183 if (ext->argument) {
184 lysc_update_path(ctx, NULL, NULL);
185 }
Michal Vaskofc2cd072021-02-24 13:17:17 +0100186 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200187 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200188
189cleanup:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100190 lysc_update_path(ctx, NULL, NULL);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100191 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200192 return ret;
193}
194
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200195static void
Michal Vaskoc130e162021-10-19 11:30:00 +0200196lysc_unres_must_free(struct lysc_unres_must *m)
197{
198 LY_ARRAY_FREE(m->local_mods);
199 free(m);
200}
201
202static void
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200203lysc_unres_dflt_free(const struct ly_ctx *ctx, struct lysc_unres_dflt *r)
204{
205 assert(!r->dflt || !r->dflts);
206 if (r->dflt) {
207 lysp_qname_free((struct ly_ctx *)ctx, r->dflt);
208 free(r->dflt);
209 } else {
210 FREE_ARRAY((struct ly_ctx *)ctx, r->dflts, lysp_qname_free);
211 }
212 free(r);
213}
214
Michal Vasko193dacd2022-10-13 08:43:05 +0200215LY_ERR
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200216lys_identity_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lysp_module *parsed_mod,
Michal Vasko9b232082022-06-07 10:59:31 +0200217 const struct lysp_ident *identities_p, struct lysc_ident **identities)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200218{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100219 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoc636ea42022-09-16 10:20:31 +0200220 struct lysc_ctx cctx;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100221 struct lysc_ident *ident;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200222 LY_ERR ret = LY_SUCCESS;
223
224 assert(ctx_sc || ctx);
225
226 if (!ctx_sc) {
Michal Vaskoc636ea42022-09-16 10:20:31 +0200227 if (parsed_mod) {
Michal Vaskoedb0fa52022-10-04 10:36:00 +0200228 LYSC_CTX_INIT_PMOD(cctx, parsed_mod, NULL);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200229 } else {
230 LYSC_CTX_INIT_CTX(cctx, ctx);
231 }
232 ctx_sc = &cctx;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200233 }
234
235 if (!identities_p) {
236 return LY_SUCCESS;
237 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200238
239 lysc_update_path(ctx_sc, NULL, "{identity}");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200240 LY_ARRAY_FOR(identities_p, u) {
241 lysc_update_path(ctx_sc, NULL, identities_p[u].name);
242
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100243 /* add new compiled identity */
Michal Vasko9b232082022-06-07 10:59:31 +0200244 LY_ARRAY_NEW_GOTO(ctx_sc->ctx, *identities, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100245
246 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].name, ident->name, ret, done);
247 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].dsc, ident->dsc, ret, done);
248 DUP_STRING_GOTO(ctx_sc->ctx, identities_p[u].ref, ident->ref, ret, done);
249 ident->module = ctx_sc->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200250 /* 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 +0100251 COMPILE_EXTS_GOTO(ctx_sc, identities_p[u].exts, ident->exts, ident, ret, done);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100252 ident->flags = identities_p[u].flags;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200253
254 lysc_update_path(ctx_sc, NULL, NULL);
255 }
256 lysc_update_path(ctx_sc, NULL, NULL);
Michal Vasko9b232082022-06-07 10:59:31 +0200257
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200258done:
Michal Vasko9b232082022-06-07 10:59:31 +0200259 if (ret) {
260 lysc_update_path(ctx_sc, NULL, NULL);
261 lysc_update_path(ctx_sc, NULL, NULL);
262 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200263 return ret;
264}
265
266/**
267 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
268 *
269 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
270 *
271 * @param[in] ctx Compile context for logging.
272 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
273 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
274 * @return LY_SUCCESS if everything is ok.
275 * @return LY_EVALID if the identity is derived from itself.
276 */
277static LY_ERR
278lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
279{
280 LY_ERR ret = LY_SUCCESS;
281 LY_ARRAY_COUNT_TYPE u, v;
282 struct ly_set recursion = {0};
283 struct lysc_ident *drv;
284
285 if (!derived) {
286 return LY_SUCCESS;
287 }
288
289 for (u = 0; u < LY_ARRAY_COUNT(derived); ++u) {
290 if (ident == derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100291 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200292 "Identity \"%s\" is indirectly derived from itself.", ident->name);
293 ret = LY_EVALID;
294 goto cleanup;
295 }
296 ret = ly_set_add(&recursion, derived[u], 0, NULL);
297 LY_CHECK_GOTO(ret, cleanup);
298 }
299
300 for (v = 0; v < recursion.count; ++v) {
301 drv = recursion.objs[v];
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200302 for (u = 0; u < LY_ARRAY_COUNT(drv->derived); ++u) {
303 if (ident == drv->derived[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100304 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200305 "Identity \"%s\" is indirectly derived from itself.", ident->name);
306 ret = LY_EVALID;
307 goto cleanup;
308 }
309 ret = ly_set_add(&recursion, drv->derived[u], 0, NULL);
310 LY_CHECK_GOTO(ret, cleanup);
311 }
312 }
313
314cleanup:
315 ly_set_erase(&recursion, NULL);
316 return ret;
317}
318
319LY_ERR
320lys_compile_identity_bases(struct lysc_ctx *ctx, const struct lysp_module *base_pmod, const char **bases_p,
aPiecekf4a0a192021-08-03 15:14:17 +0200321 struct lysc_ident *ident, struct lysc_ident ***bases)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200322{
323 LY_ARRAY_COUNT_TYPE u, v;
324 const char *s, *name;
325 const struct lys_module *mod;
326 struct lysc_ident **idref;
327
aPiecekf4a0a192021-08-03 15:14:17 +0200328 assert(ident || bases);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200329
330 if ((LY_ARRAY_COUNT(bases_p) > 1) && (ctx->pmod->version < LYS_VERSION_1_1)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100331 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200332 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
333 return LY_EVALID;
334 }
335
336 LY_ARRAY_FOR(bases_p, u) {
337 s = strchr(bases_p[u], ':');
338 if (s) {
339 /* prefixed identity */
340 name = &s[1];
Radek Krejci8df109d2021-04-23 12:19:08 +0200341 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 +0200342 } else {
343 name = bases_p[u];
344 mod = base_pmod->mod;
345 }
346 if (!mod) {
347 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100348 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200349 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
350 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100351 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200352 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
353 }
354 return LY_EVALID;
355 }
356
357 idref = NULL;
358 LY_ARRAY_FOR(mod->identities, v) {
359 if (!strcmp(name, mod->identities[v].name)) {
360 if (ident) {
361 if (ident == &mod->identities[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100362 LOGVAL(ctx->ctx, LYVE_REFERENCE,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200363 "Identity \"%s\" is derived from itself.", ident->name);
364 return LY_EVALID;
365 }
366 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->identities[v], ident->derived));
367 /* we have match! store the backlink */
368 LY_ARRAY_NEW_RET(ctx->ctx, mod->identities[v].derived, idref, LY_EMEM);
369 *idref = ident;
370 } else {
371 /* we have match! store the found identity */
372 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
373 *idref = &mod->identities[v];
374 }
375 break;
376 }
377 }
aPiecekf4a0a192021-08-03 15:14:17 +0200378 if (!idref) {
Radek Krejci10443f42021-03-28 17:40:35 +0200379 if (ident) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100380 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200381 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
382 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100383 LOGVAL(ctx->ctx, LYVE_SYNTAX_YANG,
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200384 "Unable to find base (%s) of identityref.", bases_p[u]);
385 }
386 return LY_EVALID;
387 }
388 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100389
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200390 return LY_SUCCESS;
391}
392
393/**
394 * @brief For the given array of identities, set the backlinks from all their base identities.
Michal Vasko193dacd2022-10-13 08:43:05 +0200395 *
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200396 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
397 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
aPiecekf4a0a192021-08-03 15:14:17 +0200398 * @param[in,out] idents Array of referencing identities to which the backlinks are supposed to be set.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200399 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
400 */
401static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100402lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident **idents)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200403{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100404 LY_ARRAY_COUNT_TYPE u, v;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200405
406 lysc_update_path(ctx, NULL, "{identity}");
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100407
aPiecekf3e2db82021-08-05 10:18:43 +0200408 for (u = 0; u < LY_ARRAY_COUNT(*idents); ++u) {
aPiecekf4a0a192021-08-03 15:14:17 +0200409 /* find matching parsed identity */
aPiecekf3e2db82021-08-05 10:18:43 +0200410 for (v = 0; v < LY_ARRAY_COUNT(idents_p); ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100411 if (idents_p[v].name == (*idents)[u].name) {
412 break;
413 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100414 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100415
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200416 if ((v == LY_ARRAY_COUNT(idents_p)) || !idents_p[v].bases) {
417 /* identity not found (it may be from a submodule) or identity without bases */
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200418 continue;
419 }
Michal Vaskodc6f84c2021-06-15 14:50:27 +0200420
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100421 lysc_update_path(ctx, NULL, (*idents)[u].name);
aPiecekf4a0a192021-08-03 15:14:17 +0200422 LY_CHECK_RET(lys_compile_identity_bases(ctx, ctx->pmod, idents_p[v].bases, &(*idents)[u], NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200423 lysc_update_path(ctx, NULL, NULL);
424 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100425
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200426 lysc_update_path(ctx, NULL, NULL);
427 return LY_SUCCESS;
428}
429
Michal Vaskoe20599c2022-12-02 10:45:01 +0100430LY_ERR
431lys_compile_expr_implement(const struct ly_ctx *ctx, const struct lyxp_expr *expr, LY_VALUE_FORMAT format,
432 void *prefix_data, ly_bool implement, struct lys_glob_unres *unres, const struct lys_module **mod_p)
433{
434 uint32_t i;
435 const char *ptr, *start, **imp_f, *all_f[] = {"*", NULL};
436 const struct lys_module *mod;
437
438 assert(implement || mod_p);
439
Michal Vaskoaa548942023-06-08 12:23:14 +0200440 if (mod_p) {
441 *mod_p = NULL;
442 }
443
Michal Vaskoe20599c2022-12-02 10:45:01 +0100444 for (i = 0; i < expr->used; ++i) {
445 if ((expr->tokens[i] != LYXP_TOKEN_NAMETEST) && (expr->tokens[i] != LYXP_TOKEN_LITERAL)) {
446 /* token cannot have a prefix */
447 continue;
448 }
449
450 start = expr->expr + expr->tok_pos[i];
451 if (!(ptr = ly_strnchr(start, ':', expr->tok_len[i]))) {
452 /* token without a prefix */
453 continue;
454 }
455
456 if (!(mod = ly_resolve_prefix(ctx, start, ptr - start, format, prefix_data))) {
457 /* unknown prefix, do not care right now */
458 continue;
459 }
460
461 /* unimplemented module found */
462 if (!mod->implemented && !implement) {
463 /* should not be implemented now */
464 *mod_p = mod;
465 break;
466 }
467
468 if (!mod->implemented) {
469 /* implement if not implemented */
470 imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
471 LY_CHECK_RET(lys_implement((struct lys_module *)mod, imp_f, unres));
472 }
473 if (!mod->compiled) {
474 /* compile if not implemented before or only marked for compilation */
475 LY_CHECK_RET(lys_compile((struct lys_module *)mod, &unres->ds_unres));
476 }
477 }
478
479 return LY_SUCCESS;
480}
481
482/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200483 * @brief Check when for cyclic dependencies.
484 *
485 * @param[in] set Set with all the referenced nodes.
486 * @param[in] node Node whose "when" referenced nodes are in @p set.
487 * @return LY_ERR value
488 */
489static LY_ERR
490lys_compile_unres_when_cyclic(struct lyxp_set *set, const struct lysc_node *node)
491{
492 struct lyxp_set tmp_set;
493 struct lyxp_set_scnode *xp_scnode;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200494 uint32_t i, j, idx;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200495 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200496 LY_ERR ret = LY_SUCCESS;
497
498 memset(&tmp_set, 0, sizeof tmp_set);
499
500 /* prepare in_ctx of the set */
501 for (i = 0; i < set->used; ++i) {
502 xp_scnode = &set->val.scnodes[i];
503
Radek Krejcif13b87b2020-12-01 22:02:17 +0100504 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_START_USED) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200505 /* check node when, skip the context node (it was just checked) */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100506 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200507 }
508 }
509
510 for (i = 0; i < set->used; ++i) {
511 xp_scnode = &set->val.scnodes[i];
Radek Krejcif13b87b2020-12-01 22:02:17 +0100512 if (xp_scnode->in_ctx != LYXP_SET_SCNODE_ATOM_CTX) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200513 /* already checked */
514 continue;
515 }
516
Michal Vasko1a09b212021-05-06 13:00:10 +0200517 if ((xp_scnode->type != LYXP_NODE_ELEM) || !lysc_node_when(xp_scnode->scnode)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200518 /* no when to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200519 xp_scnode->in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200520 continue;
521 }
522
523 node = xp_scnode->scnode;
524 do {
Radek Krejci9a3823e2021-01-27 20:26:46 +0100525 struct lysc_when **when_list, *when;
526
Radek Krejciddace2c2021-01-08 11:30:56 +0100527 LOG_LOCSET(node, NULL, NULL, NULL);
Radek Krejci9a3823e2021-01-27 20:26:46 +0100528 when_list = lysc_node_when(node);
529 LY_ARRAY_FOR(when_list, u) {
530 when = when_list[u];
Radek Krejci8df109d2021-04-23 12:19:08 +0200531 ret = lyxp_atomize(set->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200532 when->context, when->context, &tmp_set, LYXP_SCNODE_SCHEMA);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200533 if (ret != LY_SUCCESS) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100534 LOGVAL(set->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
Michal Vasko59e69e72022-02-18 09:18:21 +0100535 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200536 goto cleanup;
537 }
538
539 for (j = 0; j < tmp_set.used; ++j) {
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200540 if (tmp_set.val.scnodes[j].type != LYXP_NODE_ELEM) {
541 /* skip roots'n'stuff, no when, nothing to check */
Michal Vasko1a09b212021-05-06 13:00:10 +0200542 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200543 continue;
544 }
545
546 /* try to find this node in our set */
547 if (lyxp_set_scnode_contains(set, tmp_set.val.scnodes[j].scnode, LYXP_NODE_ELEM, -1, &idx) &&
548 (set->val.scnodes[idx].in_ctx == LYXP_SET_SCNODE_START_USED)) {
549 LOGVAL(set->ctx, LYVE_SEMANTICS, "When condition cyclic dependency on the node \"%s\".",
550 tmp_set.val.scnodes[j].scnode->name);
551 ret = LY_EVALID;
552 LOG_LOCBACK(1, 0, 0, 0);
553 goto cleanup;
554 }
555
556 /* needs to be checked, if in both sets, will be ignored */
557 tmp_set.val.scnodes[j].in_ctx = LYXP_SET_SCNODE_ATOM_CTX;
558 }
559
560 if (when->context != node) {
561 /* node actually depends on this "when", not the context node */
562 assert(tmp_set.val.scnodes[0].scnode == when->context);
563 if (tmp_set.val.scnodes[0].in_ctx == LYXP_SET_SCNODE_START_USED) {
564 /* replace the non-traversed context node with the dependent node */
565 tmp_set.val.scnodes[0].scnode = (struct lysc_node *)node;
566 } else {
567 /* context node was traversed, so just add the dependent node */
568 ret = lyxp_set_scnode_insert_node(&tmp_set, node, LYXP_SET_SCNODE_START_USED, LYXP_AXIS_CHILD, NULL);
569 LY_CHECK_ERR_GOTO(ret, LOG_LOCBACK(1, 0, 0, 0), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200570 }
571 }
572
573 /* merge this set into the global when set */
574 lyxp_set_scnode_merge(set, &tmp_set);
575 }
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200576 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200577
578 /* check when of non-data parents as well */
579 node = node->parent;
580 } while (node && (node->nodetype & (LYS_CASE | LYS_CHOICE)));
581
582 /* this node when was checked (xp_scnode could have been reallocd) */
Michal Vasko60edc2f2021-07-20 09:18:02 +0200583 set->val.scnodes[i].in_ctx = LYXP_SET_SCNODE_ATOM_NODE;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200584 }
585
586cleanup:
587 lyxp_set_free_content(&tmp_set);
588 return ret;
589}
590
591LY_ERR
592lysc_check_status(struct lysc_ctx *ctx, uint16_t flags1, void *mod1, const char *name1, uint16_t flags2, void *mod2,
593 const char *name2)
594{
595 uint16_t flg1, flg2;
596
597 flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
598 flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
599
600 if ((flg1 < flg2) && (mod1 == mod2)) {
601 if (ctx) {
Michal Vasko23864e02021-06-24 09:23:58 +0200602 LOGVAL(ctx->ctx, LYVE_REFERENCE, "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".",
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200603 flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1,
604 flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
605 }
606 return LY_EVALID;
607 }
608
609 return LY_SUCCESS;
610}
611
Michal Vaskocfaff232020-10-20 09:35:14 +0200612/**
Michal Vaskoc130e162021-10-19 11:30:00 +0200613 * @brief Check when expressions of a node on a complete compiled schema tree.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200614 *
615 * @param[in] ctx Compile context.
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100616 * @param[in] when When to check.
617 * @param[in] node Node with @p when.
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100618 * @return LY_ERR value.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200619 */
620static LY_ERR
Michal Vaskoe20599c2022-12-02 10:45:01 +0100621lys_compile_unres_when(struct lysc_ctx *ctx, const struct lysc_when *when, const struct lysc_node *node)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200622{
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100623 struct lyxp_set tmp_set = {0};
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200624 uint32_t i, opts;
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200625 struct lysc_node *schema;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200626 LY_ERR ret = LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200627
Michal Vaskod1e53b92021-01-28 13:11:06 +0100628 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200629
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100630 /* check "when" */
631 ret = lyxp_atomize(ctx->ctx, when->cond, node->module, LY_VALUE_SCHEMA_RESOLVED, when->prefixes, when->context,
632 when->context, &tmp_set, opts);
633 if (ret) {
634 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid when condition \"%s\".", when->cond->expr);
635 goto cleanup;
636 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200637
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100638 ctx->path[0] = '\0';
639 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
640 for (i = 0; i < tmp_set.used; ++i) {
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200641 if (tmp_set.val.scnodes[i].type != LYXP_NODE_ELEM) {
642 /* skip roots'n'stuff */
643 continue;
644 } else if (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_START_USED) {
645 /* context node not actually traversed */
646 continue;
647 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200648
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200649 schema = tmp_set.val.scnodes[i].scnode;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200650
Michal Vaskoe4a6d012023-05-22 14:34:52 +0200651 /* XPath expression cannot reference "lower" status than the node that has the definition */
652 if (lysc_check_status(NULL, when->flags, node->module, node->name, schema->flags, schema->module,
653 schema->name)) {
654 LOGWRN(ctx->ctx, "When condition \"%s\" may be referencing %s node \"%s\".", when->cond->expr,
655 (schema->flags == LYS_STATUS_OBSLT) ? "obsolete" : "deprecated", schema->name);
656 }
657
658 /* check dummy node children/value accessing */
659 if (lysc_data_parent(schema) == node) {
660 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node children.");
661 ret = LY_EVALID;
662 goto cleanup;
663 } else if ((schema == node) && (tmp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL)) {
664 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "When condition is accessing its own conditional node value.");
665 ret = LY_EVALID;
666 goto cleanup;
667 }
668 }
669
670 if (when->context != node) {
671 /* node actually depends on this "when", not the context node */
672 assert(tmp_set.val.scnodes[0].scnode == when->context);
673 if (tmp_set.val.scnodes[0].in_ctx == LYXP_SET_SCNODE_START_USED) {
674 /* replace the non-traversed context node with the dependent node */
675 tmp_set.val.scnodes[0].scnode = (struct lysc_node *)node;
676 } else {
677 /* context node was traversed, so just add the dependent node */
678 ret = lyxp_set_scnode_insert_node(&tmp_set, node, LYXP_SET_SCNODE_START_USED, LYXP_AXIS_CHILD, NULL);
679 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200680 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200681 }
682
Michal Vasko4ed3bd52022-12-02 10:28:04 +0100683 /* check cyclic dependencies */
684 ret = lys_compile_unres_when_cyclic(&tmp_set, node);
685 LY_CHECK_GOTO(ret, cleanup);
686
Michal Vaskoc130e162021-10-19 11:30:00 +0200687cleanup:
688 lyxp_set_free_content(&tmp_set);
Michal Vaskoc130e162021-10-19 11:30:00 +0200689 return ret;
690}
691
692/**
693 * @brief Check must expressions of a node on a complete compiled schema tree.
694 *
695 * @param[in] ctx Compile context.
696 * @param[in] node Node to check.
697 * @param[in] local_mods Sized array of local modules for musts of @p node at the same index.
Michal Vaskoaa548942023-06-08 12:23:14 +0200698 * @return LY_ERR value.
Michal Vaskoc130e162021-10-19 11:30:00 +0200699 */
700static LY_ERR
Michal Vaskoaa548942023-06-08 12:23:14 +0200701lys_compile_unres_must(struct lysc_ctx *ctx, const struct lysc_node *node, const struct lysp_module **local_mods)
Michal Vaskoc130e162021-10-19 11:30:00 +0200702{
703 struct lyxp_set tmp_set;
704 uint32_t i, opts;
705 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoaa548942023-06-08 12:23:14 +0200706 struct lysc_must *musts;
Michal Vaskoc130e162021-10-19 11:30:00 +0200707 LY_ERR ret = LY_SUCCESS;
Michal Vaskoc130e162021-10-19 11:30:00 +0200708 uint16_t flg;
709
710 LOG_LOCSET(node, NULL, NULL, NULL);
711
712 memset(&tmp_set, 0, sizeof tmp_set);
713 opts = LYXP_SCNODE_SCHEMA | ((node->flags & LYS_IS_OUTPUT) ? LYXP_SCNODE_OUTPUT : 0);
714
715 musts = lysc_node_musts(node);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200716 LY_ARRAY_FOR(musts, u) {
Michal Vaskocfaff232020-10-20 09:35:14 +0200717 /* check "must" */
Radek Krejci8df109d2021-04-23 12:19:08 +0200718 ret = lyxp_atomize(ctx->ctx, musts[u].cond, node->module, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes, node,
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200719 node, &tmp_set, opts);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200720 if (ret) {
Michal Vasko7c3134d2022-07-14 10:57:59 +0200721 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid must condition \"%s\".", musts[u].cond->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200722 goto cleanup;
723 }
724
725 ctx->path[0] = '\0';
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100726 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200727 for (i = 0; i < tmp_set.used; ++i) {
728 /* skip roots'n'stuff */
729 if (tmp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Michal Vasko7c3134d2022-07-14 10:57:59 +0200730 struct lysc_node *schema = tmp_set.val.scnodes[i].scnode;
731
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200732 /* XPath expression cannot reference "lower" status than the node that has the definition */
Michal Vaskoc130e162021-10-19 11:30:00 +0200733 if (local_mods[u]->mod == node->module) {
734 /* use flags of the context node since the definition is local */
735 flg = node->flags;
736 } else {
737 /* definition is foreign (deviation, refine), always current */
738 flg = LYS_STATUS_CURR;
739 }
Michal Vasko7c3134d2022-07-14 10:57:59 +0200740 if (lysc_check_status(NULL, flg, local_mods[u]->mod, node->name, schema->flags, schema->module,
741 schema->name)) {
742 LOGWRN(ctx->ctx, "Must condition \"%s\" may be referencing %s node \"%s\".", musts[u].cond->expr,
743 (schema->flags == LYS_STATUS_OBSLT) ? "obsolete" : "deprecated", schema->name);
744 break;
745 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200746 }
747 }
748
749 lyxp_set_free_content(&tmp_set);
750 }
751
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200752cleanup:
753 lyxp_set_free_content(&tmp_set);
Radek Krejciddace2c2021-01-08 11:30:56 +0100754 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200755 return ret;
756}
757
758/**
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100759 * @brief Remove all disabled bits/enums from a sized array.
760 *
761 * @param[in] ctx Context with the dictionary.
762 * @param[in] items Sized array of bits/enums.
763 */
764static void
Michal Vaskoc636ea42022-09-16 10:20:31 +0200765lys_compile_unres_disabled_bitenum_remove(struct lysf_ctx *ctx, struct lysc_type_bitenum_item *items)
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100766{
767 LY_ARRAY_COUNT_TYPE u = 0, last_u;
768
769 while (u < LY_ARRAY_COUNT(items)) {
770 if (items[u].flags & LYS_DISABLED) {
771 /* free the disabled item */
772 lysc_enum_item_free(ctx, &items[u]);
773
774 /* replace it with the following items */
775 last_u = LY_ARRAY_COUNT(items) - 1;
776 if (u < last_u) {
777 memmove(items + u, items + u + 1, (last_u - u) * sizeof *items);
778 }
779
780 /* one item less */
781 LY_ARRAY_DECREMENT(items);
782 continue;
783 }
784
785 ++u;
786 }
787}
788
789/**
790 * @brief Find and remove all disabled bits/enums in a leaf/leaf-list type.
791 *
792 * @param[in] ctx Compile context.
793 * @param[in] leaf Leaf/leaf-list to check.
794 * @return LY_ERR value
795 */
796static LY_ERR
797lys_compile_unres_disabled_bitenum(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf)
798{
799 struct lysc_type **t;
800 LY_ARRAY_COUNT_TYPE u, count;
801 struct lysc_type_enum *ent;
Michal Vasko28864d52023-03-23 08:07:46 +0100802 ly_bool has_value = 0;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100803
804 if (leaf->type->basetype == LY_TYPE_UNION) {
805 t = ((struct lysc_type_union *)leaf->type)->types;
806 count = LY_ARRAY_COUNT(t);
807 } else {
808 t = &leaf->type;
809 count = 1;
810 }
811 for (u = 0; u < count; ++u) {
812 if ((t[u]->basetype == LY_TYPE_BITS) || (t[u]->basetype == LY_TYPE_ENUM)) {
813 /* remove all disabled items */
814 ent = (struct lysc_type_enum *)(t[u]);
Michal Vaskoc636ea42022-09-16 10:20:31 +0200815 lys_compile_unres_disabled_bitenum_remove(&ctx->free_ctx, ent->enums);
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100816
Michal Vasko28864d52023-03-23 08:07:46 +0100817 if (LY_ARRAY_COUNT(ent->enums)) {
818 has_value = 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100819 }
Michal Vasko28864d52023-03-23 08:07:46 +0100820 } else {
821 has_value = 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100822 }
823 }
824
Michal Vasko28864d52023-03-23 08:07:46 +0100825 if (!has_value) {
826 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Node \"%s\" without any (or all disabled) valid values.", leaf->name);
827 return LY_EVALID;
828 }
829
Michal Vaskof4fa90d2021-11-11 15:05:19 +0100830 return LY_SUCCESS;
831}
832
833/**
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200834 * @brief Check leafref for its target existence on a complete compiled schema tree.
835 *
836 * @param[in] ctx Compile context.
837 * @param[in] node Context node for the leafref.
838 * @param[in] lref Leafref to check/resolve.
Michal Vaskoc130e162021-10-19 11:30:00 +0200839 * @param[in] local_mod Local module for the leafref type.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200840 * @return LY_ERR value.
841 */
842static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100843lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, struct lysc_type_leafref *lref,
Michal Vaskoaa548942023-06-08 12:23:14 +0200844 const struct lysp_module *local_mod)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200845{
Michal Vaskod1e53b92021-01-28 13:11:06 +0100846 const struct lysc_node *target = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200847 struct ly_path *p;
848 struct lysc_type *type;
Michal Vaskoc130e162021-10-19 11:30:00 +0200849 uint16_t flg;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200850
851 assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
852
Michal Vaskof2a793b2023-03-13 11:56:50 +0100853 if (lref->realtype) {
854 /* already resolved, may happen (shared union typedef with a leafref) */
855 return LY_SUCCESS;
856 }
857
Michal Vaskoed725d72021-06-23 12:03:45 +0200858 /* try to find the target, current module is that of the context node (RFC 7950 6.4.1 second bullet) */
Michal Vaskoedb0fa52022-10-04 10:36:00 +0200859 LY_CHECK_RET(ly_path_compile_leafref(ctx->ctx, node, ctx->ext, lref->path,
Michal Vaskod1e53b92021-01-28 13:11:06 +0100860 (node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
Michal Vasko24fc4d12021-07-12 14:41:20 +0200861 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &p));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200862
863 /* get the target node */
864 target = p[LY_ARRAY_COUNT(p) - 1].node;
865 ly_path_free(node->module->ctx, p);
866
867 if (!(target->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100868 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 +0200869 lref->path->expr, lys_nodetype2str(target->nodetype));
870 return LY_EVALID;
871 }
872
873 /* check status */
874 ctx->path[0] = '\0';
875 lysc_path(node, LYSC_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
876 ctx->path_len = strlen(ctx->path);
Michal Vaskoc130e162021-10-19 11:30:00 +0200877 if (node->module == local_mod->mod) {
878 /* use flags of the context node since the definition is local */
879 flg = node->flags;
880 } else {
881 /* definition is foreign (deviation), always current */
882 flg = LYS_STATUS_CURR;
883 }
884 if (lysc_check_status(ctx, flg, local_mod->mod, node->name, target->flags, target->module, target->name)) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200885 return LY_EVALID;
886 }
887 ctx->path_len = 1;
888 ctx->path[1] = '\0';
889
890 /* check config */
891 if (lref->require_instance) {
Michal Vaskod1e53b92021-01-28 13:11:06 +0100892 if ((node->flags & LYS_CONFIG_W) && (target->flags & LYS_CONFIG_R)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100893 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - target is supposed"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200894 " to represent configuration data (as the leafref does), but it does not.", lref->path->expr);
895 return LY_EVALID;
896 }
897 }
898
Michal Vaskod15c7de2022-05-09 15:34:09 +0200899 /* check for circular chain of leafrefs */
900 for (type = ((struct lysc_node_leaf *)target)->type;
901 type && (type->basetype == LY_TYPE_LEAFREF);
902 type = ((struct lysc_type_leafref *)type)->realtype) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200903 if (type == (struct lysc_type *)lref) {
904 /* circular chain detected */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100905 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
906 lref->path->expr);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200907 return LY_EVALID;
908 }
909 }
910
Michal Vaskod15c7de2022-05-09 15:34:09 +0200911 /* store the type */
912 lref->realtype = ((struct lysc_node_leaf *)target)->type;
913 ++lref->realtype->refcount;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200914 return LY_SUCCESS;
915}
916
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200917/**
918 * @brief Compile default value(s) for leaf or leaf-list expecting a complete compiled schema tree.
919 *
920 * @param[in] ctx Compile context.
921 * @param[in] node Leaf or leaf-list to compile the default value(s) for.
922 * @param[in] type Type of the default value.
923 * @param[in] dflt Default value.
924 * @param[in] dflt_pmod Parsed module of the @p dflt to resolve possible prefixes.
925 * @param[in,out] storage Storage for the compiled default value.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100926 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vaskoaa548942023-06-08 12:23:14 +0200927 * @return LY_ERECOMPILE if the whole dep set needs to be recompiled for the value to be checked.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200928 * @return LY_ERR value.
929 */
930static LY_ERR
931lys_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 +0100932 const struct lysp_module *dflt_pmod, struct lyd_value *storage, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200933{
934 LY_ERR ret;
Michal Vasko25d6ad02020-10-22 12:20:22 +0200935 uint32_t options;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200936 struct ly_err_item *err = NULL;
937
Radek Krejci0b013302021-03-29 15:22:32 +0200938 options = (ctx->ctx->flags & LY_CTX_REF_IMPLEMENTED) ? LYPLG_TYPE_STORE_IMPLEMENT : 0;
Radek Krejci8df109d2021-04-23 12:19:08 +0200939 ret = type->plugin->store(ctx->ctx, type, dflt, strlen(dflt), options, LY_VALUE_SCHEMA, (void *)dflt_pmod,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100940 LYD_HINT_SCHEMA, node, storage, unres, &err);
Michal Vasko1ccbf542021-04-19 11:35:00 +0200941 if (ret == LY_ERECOMPILE) {
942 /* fine, but we need to recompile */
943 return LY_ERECOMPILE;
944 } else if (ret == LY_EINCOMPLETE) {
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200945 /* we have no data so we will not be resolving it */
946 ret = LY_SUCCESS;
947 }
948
949 if (ret) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100950 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200951 if (err) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100952 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type (%s).", err->msg);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200953 ly_err_free(err);
954 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100955 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Invalid default - value does not fit the type.");
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200956 }
Radek Krejciddace2c2021-01-08 11:30:56 +0100957 LOG_LOCBACK(1, 0, 0, 0);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200958 return ret;
959 }
960
Michal Vasko04338d92021-09-01 07:58:14 +0200961 LY_ATOMIC_INC_BARRIER(((struct lysc_type *)storage->realtype)->refcount);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200962 return LY_SUCCESS;
963}
964
965/**
966 * @brief Compile default value of a leaf expecting a complete compiled schema tree.
967 *
968 * @param[in] ctx Compile context.
969 * @param[in] leaf Leaf that the default value is for.
970 * @param[in] dflt Default value to compile.
Michal Vasko405cc9e2020-12-01 12:01:27 +0100971 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200972 * @return LY_ERR value.
973 */
974static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +0100975lys_compile_unres_leaf_dlft(struct lysc_ctx *ctx, struct lysc_node_leaf *leaf, struct lysp_qname *dflt,
976 struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200977{
978 LY_ERR ret;
979
980 assert(!leaf->dflt);
981
982 if (leaf->flags & (LYS_MAND_TRUE | LYS_KEY)) {
983 /* ignore default values for keys and mandatory leaves */
984 return LY_SUCCESS;
985 }
986
987 /* allocate the default value */
988 leaf->dflt = calloc(1, sizeof *leaf->dflt);
989 LY_CHECK_ERR_RET(!leaf->dflt, LOGMEM(ctx->ctx), LY_EMEM);
990
991 /* store the default value */
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100992 ret = lys_compile_unres_dflt(ctx, &leaf->node, leaf->type, dflt->str, dflt->mod, leaf->dflt, unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +0200993 if (ret) {
994 free(leaf->dflt);
995 leaf->dflt = NULL;
996 }
997
998 return ret;
999}
1000
1001/**
1002 * @brief Compile default values of a leaf-list expecting a complete compiled schema tree.
1003 *
1004 * @param[in] ctx Compile context.
1005 * @param[in] llist Leaf-list that the default value(s) are for.
1006 * @param[in] dflt Default value to compile, in case of a single value.
1007 * @param[in] dflts Sized array of default values, in case of more values.
Michal Vasko405cc9e2020-12-01 12:01:27 +01001008 * @param[in,out] unres Global unres structure for newly implemented modules.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001009 * @return LY_ERR value.
1010 */
1011static LY_ERR
1012lys_compile_unres_llist_dflts(struct lysc_ctx *ctx, struct lysc_node_leaflist *llist, struct lysp_qname *dflt,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001013 struct lysp_qname *dflts, struct lys_glob_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001014{
1015 LY_ERR ret;
1016 LY_ARRAY_COUNT_TYPE orig_count, u, v;
1017
1018 assert(dflt || dflts);
1019
Radek Krejcic7d13e32020-12-09 12:32:24 +01001020 /* in case there were already some defaults and we are adding new by deviations */
1021 orig_count = LY_ARRAY_COUNT(llist->dflts);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001022
1023 /* allocate new items */
Radek Krejcic7d13e32020-12-09 12:32:24 +01001024 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 +02001025
1026 /* fill each new default value */
1027 if (dflts) {
1028 LY_ARRAY_FOR(dflts, u) {
1029 llist->dflts[orig_count + u] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001030 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflts[u].str, dflts[u].mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001031 llist->dflts[orig_count + u], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001032 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count + u]), ret);
1033 LY_ARRAY_INCREMENT(llist->dflts);
1034 }
1035 } else {
1036 llist->dflts[orig_count] = calloc(1, sizeof **llist->dflts);
Michal Vasko14ed9cd2021-01-28 14:16:25 +01001037 ret = lys_compile_unres_dflt(ctx, &llist->node, llist->type, dflt->str, dflt->mod,
Michal Vasko405cc9e2020-12-01 12:01:27 +01001038 llist->dflts[orig_count], unres);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001039 LY_CHECK_ERR_RET(ret, free(llist->dflts[orig_count]), ret);
1040 LY_ARRAY_INCREMENT(llist->dflts);
1041 }
1042
1043 /* check default value uniqueness */
1044 if (llist->flags & LYS_CONFIG_W) {
1045 /* configuration data values must be unique - so check the default values */
1046 for (u = orig_count; u < LY_ARRAY_COUNT(llist->dflts); ++u) {
1047 for (v = 0; v < u; ++v) {
1048 if (!llist->dflts[u]->realtype->plugin->compare(llist->dflts[u], llist->dflts[v])) {
Radek Krejcia6016992021-03-03 10:13:41 +01001049 lysc_update_path(ctx, llist->parent ? llist->parent->module : NULL, llist->name);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001050 LOGVAL(ctx->ctx, LYVE_SEMANTICS, "Configuration leaf-list has multiple defaults of the same value \"%s\".",
Michal Vasko7b3a00e2023-08-09 11:58:03 +02001051 (char *)llist->dflts[u]->realtype->plugin->print(ctx->ctx, llist->dflts[u], LY_VALUE_CANON,
1052 NULL, NULL, NULL));
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001053 lysc_update_path(ctx, NULL, NULL);
1054 return LY_EVALID;
1055 }
1056 }
1057 }
1058 }
1059
1060 return LY_SUCCESS;
1061}
1062
Michal Vaskof4258e12021-06-15 12:11:42 +02001063/**
aPiecek732cd142021-07-07 16:29:59 +02001064 * @brief Iteratively get all leafrefs from @p node
1065 * if the node is of type union, otherwise just return the leafref.
1066 *
1067 * @param[in] node Node that may contain the leafref.
1068 * @param[in,out] index Value that is passed between function calls.
1069 * For each new node, initialize value of the @p index to 0, otherwise
1070 * do not modify the value between calls.
1071 * @return Pointer to the leafref or next leafref, otherwise NULL.
1072 */
1073static struct lysc_type_leafref *
1074lys_type_leafref_next(const struct lysc_node *node, uint64_t *index)
1075{
1076 struct lysc_type_leafref *ret = NULL;
1077 struct lysc_type_union *uni;
1078 struct lysc_type *leaf_type;
1079
1080 assert(node->nodetype & LYD_NODE_TERM);
1081
1082 leaf_type = ((struct lysc_node_leaf *)node)->type;
1083 if (leaf_type->basetype == LY_TYPE_UNION) {
1084 uni = (struct lysc_type_union *)leaf_type;
1085
1086 /* find next union leafref */
1087 while (*index < LY_ARRAY_COUNT(uni->types)) {
1088 if (uni->types[*index]->basetype == LY_TYPE_LEAFREF) {
1089 ret = (struct lysc_type_leafref *)uni->types[*index];
1090 ++(*index);
1091 break;
1092 }
1093
1094 ++(*index);
1095 }
1096 } else {
1097 /* return just the single leafref */
1098 if (*index == 0) {
1099 ++(*index);
1100 assert(leaf_type->basetype == LY_TYPE_LEAFREF);
1101 ret = (struct lysc_type_leafref *)leaf_type;
1102 }
1103 }
1104
1105 return ret;
1106}
1107
1108/**
Michal Vaskoaa548942023-06-08 12:23:14 +02001109 * @brief Implement all referenced modules by leafrefs, when and must conditions.
1110 *
1111 * @param[in] ctx libyang context.
1112 * @param[in] unres Global unres structure with the sets to resolve.
1113 * @return LY_SUCCESS on success.
1114 * @return LY_ERECOMPILE if the whole dep set needs to be recompiled with the new implemented modules.
1115 * @return LY_ERR value on error.
1116 */
1117static LY_ERR
1118lys_compile_unres_depset_implement(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1119{
1120 struct lys_depset_unres *ds_unres = &unres->ds_unres;
1121 struct lysc_type_leafref *lref;
1122 const struct lys_module *mod;
1123 LY_ARRAY_COUNT_TYPE u;
1124 struct lysc_unres_leafref *l;
1125 struct lysc_unres_when *w;
1126 struct lysc_unres_must *m;
1127 struct lysc_must *musts;
1128 ly_bool not_implemented;
1129 uint32_t di = 0, li = 0, wi = 0, mi = 0;
1130
1131implement_all:
1132 /* disabled leafrefs - even those because we need to check their target exists */
1133 while (di < ds_unres->disabled_leafrefs.count) {
1134 l = ds_unres->disabled_leafrefs.objs[di];
1135
1136 u = 0;
1137 while ((lref = lys_type_leafref_next(l->node, &u))) {
1138 LY_CHECK_RET(lys_compile_expr_implement(ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1139 }
1140
1141 ++di;
1142 }
1143
1144 /* leafrefs */
1145 while (li < ds_unres->leafrefs.count) {
1146 l = ds_unres->leafrefs.objs[li];
1147
1148 u = 0;
1149 while ((lref = lys_type_leafref_next(l->node, &u))) {
1150 LY_CHECK_RET(lys_compile_expr_implement(ctx, lref->path, LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, 1, unres, NULL));
1151 }
1152
1153 ++li;
1154 }
1155
1156 /* when conditions */
1157 while (wi < ds_unres->whens.count) {
1158 w = ds_unres->whens.objs[wi];
1159
1160 LY_CHECK_RET(lys_compile_expr_implement(ctx, w->when->cond, LY_VALUE_SCHEMA_RESOLVED, w->when->prefixes,
1161 ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod));
1162 if (mod) {
1163 LOGWRN(ctx, "When condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
1164 w->when->cond->expr, mod->name);
1165
1166 /* remove from the set to skip the check */
1167 ly_set_rm_index(&ds_unres->whens, wi, free);
1168 continue;
1169 }
1170
1171 ++wi;
1172 }
1173
1174 /* must conditions */
1175 while (mi < ds_unres->musts.count) {
1176 m = ds_unres->musts.objs[mi];
1177
1178 not_implemented = 0;
1179 musts = lysc_node_musts(m->node);
1180 LY_ARRAY_FOR(musts, u) {
1181 LY_CHECK_RET(lys_compile_expr_implement(ctx, musts[u].cond, LY_VALUE_SCHEMA_RESOLVED, musts[u].prefixes,
1182 ctx->flags & LY_CTX_REF_IMPLEMENTED, unres, &mod));
1183 if (mod) {
1184 LOGWRN(ctx, "Must condition \"%s\" check skipped because referenced module \"%s\" is not implemented.",
1185 musts[u].cond->expr, mod->name);
1186
1187 /* need to implement modules from all the expressions */
1188 not_implemented = 1;
1189 }
1190 }
1191
1192 if (not_implemented) {
1193 /* remove from the set to skip the check */
1194 lysc_unres_must_free(m);
1195 ly_set_rm_index(&ds_unres->musts, mi, NULL);
1196 continue;
1197 }
1198
1199 ++mi;
1200 }
1201
1202 if ((di < ds_unres->disabled_leafrefs.count) || (li < ds_unres->leafrefs.count) || (wi < ds_unres->whens.count)) {
1203 /* new items in the sets */
1204 goto implement_all;
1205 }
1206
1207 return LY_SUCCESS;
1208}
1209
1210/**
Michal Vaskof4258e12021-06-15 12:11:42 +02001211 * @brief Finish dependency set compilation by resolving all the unres sets.
1212 *
1213 * @param[in] ctx libyang context.
1214 * @param[in] unres Global unres structure with the sets to resolve.
1215 * @return LY_SUCCESS on success.
1216 * @return LY_ERECOMPILE if the dep set needs to be recompiled.
1217 * @return LY_ERR value on error.
1218 */
1219static LY_ERR
1220lys_compile_unres_depset(struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001221{
Michal Vaskoaa548942023-06-08 12:23:14 +02001222 LY_ERR ret = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001223 struct lysc_node *node;
aPiecek732cd142021-07-07 16:29:59 +02001224 struct lysc_type *typeiter;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001225 struct lysc_type_leafref *lref;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001226 struct lysc_ctx cctx = {0};
1227 struct lys_depset_unres *ds_unres = &unres->ds_unres;
aPiecekd7bd52d2021-07-08 08:59:59 +02001228 struct ly_path *path;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001229 LY_ARRAY_COUNT_TYPE v;
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001230 struct lysc_unres_leafref *l;
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001231 struct lysc_unres_when *w;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001232 struct lysc_unres_must *m;
Michal Vaskoe20599c2022-12-02 10:45:01 +01001233 struct lysc_unres_dflt *d;
aPiecekd7bd52d2021-07-08 08:59:59 +02001234 uint32_t i, processed_leafrefs = 0;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001235
aPiecekd7bd52d2021-07-08 08:59:59 +02001236resolve_all:
Michal Vaskoaa548942023-06-08 12:23:14 +02001237 /* implement all referenced modules to get final ds_unres set */
1238 if ((ret = lys_compile_unres_depset_implement(ctx, unres))) {
1239 goto cleanup;
1240 }
1241
1242 /* check disabled leafrefs */
aPiecekc6526b42021-07-12 15:21:39 +02001243 while (ds_unres->disabled_leafrefs.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001244 /* remember index, it can change before we get to free this item */
1245 i = ds_unres->disabled_leafrefs.count - 1;
1246 l = ds_unres->disabled_leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001247 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
aPiecekc6526b42021-07-12 15:21:39 +02001248
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001249 LOG_LOCSET(l->node, NULL, NULL, NULL);
aPiecekc6526b42021-07-12 15:21:39 +02001250 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001251 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoaa548942023-06-08 12:23:14 +02001252 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod);
aPiecekc6526b42021-07-12 15:21:39 +02001253 }
aPiecekc6526b42021-07-12 15:21:39 +02001254 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001255 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001256
1257 ly_set_rm_index(&ds_unres->disabled_leafrefs, i, free);
aPiecekc6526b42021-07-12 15:21:39 +02001258 }
Michal Vaskoa23e1d92021-07-13 12:04:16 +02001259
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001260 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
1261 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
1262 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation.
1263 * Also do the same check for set of the disabled leafrefs, but without the second round. */
aPiecekd7bd52d2021-07-08 08:59:59 +02001264 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001265 l = ds_unres->leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001266 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001267
Michal Vaskoc636ea42022-09-16 10:20:31 +02001268 LOG_LOCSET(l->node, NULL, NULL, NULL);
aPiecek732cd142021-07-07 16:29:59 +02001269 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001270 while ((ret == LY_SUCCESS) && (lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoaa548942023-06-08 12:23:14 +02001271 ret = lys_compile_unres_leafref(&cctx, l->node, lref, l->local_mod);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001272 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001273 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001274 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001275 }
aPiecekd7bd52d2021-07-08 08:59:59 +02001276 for (i = processed_leafrefs; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001277 l = ds_unres->leafrefs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001278
Michal Vasko405cc9e2020-12-01 12:01:27 +01001279 /* store pointer to the real type */
aPiecek732cd142021-07-07 16:29:59 +02001280 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001281 while ((lref = lys_type_leafref_next(l->node, &v))) {
aPiecek732cd142021-07-07 16:29:59 +02001282 for (typeiter = lref->realtype;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001283 typeiter->basetype == LY_TYPE_LEAFREF;
1284 typeiter = ((struct lysc_type_leafref *)typeiter)->realtype) {}
Michal Vaskod15c7de2022-05-09 15:34:09 +02001285
Michal Vaskoc636ea42022-09-16 10:20:31 +02001286 lysc_type_free(&cctx.free_ctx, lref->realtype);
aPiecek732cd142021-07-07 16:29:59 +02001287 lref->realtype = typeiter;
Michal Vaskod15c7de2022-05-09 15:34:09 +02001288 ++lref->realtype->refcount;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001289 }
1290
Michal Vaskoe20599c2022-12-02 10:45:01 +01001291 /* if 'goto' will be used on the 'resolve_all' label, then the current leafref will not be processed again */
aPiecekd7bd52d2021-07-08 08:59:59 +02001292 processed_leafrefs++;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001293 }
1294
Michal Vaskoaa548942023-06-08 12:23:14 +02001295 /* check when, the referenced modules must be implemented now */
Michal Vaskoc130e162021-10-19 11:30:00 +02001296 while (ds_unres->whens.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001297 i = ds_unres->whens.count - 1;
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001298 w = ds_unres->whens.objs[i];
1299 LYSC_CTX_INIT_PMOD(cctx, w->node->module->parsed, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001300
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001301 LOG_LOCSET(w->node, NULL, NULL, NULL);
Michal Vaskoe20599c2022-12-02 10:45:01 +01001302 ret = lys_compile_unres_when(&cctx, w->when, w->node);
1303 LOG_LOCBACK(w->node ? 1 : 0, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001304 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001305
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001306 free(w);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001307 ly_set_rm_index(&ds_unres->whens, i, NULL);
Michal Vaskoc130e162021-10-19 11:30:00 +02001308 }
1309
1310 /* check must */
1311 while (ds_unres->musts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001312 i = ds_unres->musts.count - 1;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001313 m = ds_unres->musts.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001314 LYSC_CTX_INIT_PMOD(cctx, m->node->module->parsed, m->ext);
Michal Vaskoc130e162021-10-19 11:30:00 +02001315
1316 LOG_LOCSET(m->node, NULL, NULL, NULL);
Michal Vaskoaa548942023-06-08 12:23:14 +02001317 ret = lys_compile_unres_must(&cctx, m->node, m->local_mods);
Michal Vaskoc130e162021-10-19 11:30:00 +02001318 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001319 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoc130e162021-10-19 11:30:00 +02001320
1321 lysc_unres_must_free(m);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001322 ly_set_rm_index(&ds_unres->musts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001323 }
1324
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001325 /* remove disabled enums/bits */
Michal Vasko5eaf7322021-11-22 15:58:26 +01001326 while (ds_unres->disabled_bitenums.count) {
1327 i = ds_unres->disabled_bitenums.count - 1;
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001328 node = ds_unres->disabled_bitenums.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001329 LYSC_CTX_INIT_PMOD(cctx, node->module->parsed, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001330
1331 LOG_LOCSET(node, NULL, NULL, NULL);
1332 ret = lys_compile_unres_disabled_bitenum(&cctx, (struct lysc_node_leaf *)node);
1333 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001334 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001335
1336 ly_set_rm_index(&ds_unres->disabled_bitenums, i, NULL);
1337 }
1338
Michal Vasko405cc9e2020-12-01 12:01:27 +01001339 /* finish incomplete default values compilation */
Michal Vaskof4258e12021-06-15 12:11:42 +02001340 while (ds_unres->dflts.count) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001341 i = ds_unres->dflts.count - 1;
Michal Vaskoe20599c2022-12-02 10:45:01 +01001342 d = ds_unres->dflts.objs[i];
1343 LYSC_CTX_INIT_PMOD(cctx, d->leaf->module->parsed, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001344
Michal Vaskoe20599c2022-12-02 10:45:01 +01001345 LOG_LOCSET(&d->leaf->node, NULL, NULL, NULL);
1346 if (d->leaf->nodetype == LYS_LEAF) {
1347 ret = lys_compile_unres_leaf_dlft(&cctx, d->leaf, d->dflt, unres);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001348 } else {
Michal Vaskoe20599c2022-12-02 10:45:01 +01001349 ret = lys_compile_unres_llist_dflts(&cctx, d->llist, d->dflt, d->dflts, unres);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001350 }
Radek Krejciddace2c2021-01-08 11:30:56 +01001351 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001352 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001353
Michal Vaskoe20599c2022-12-02 10:45:01 +01001354 lysc_unres_dflt_free(ctx, d);
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001355 ly_set_rm_index(&ds_unres->dflts, i, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001356 }
1357
Michal Vaskoaa548942023-06-08 12:23:14 +02001358 /* some unres items may have been added by the default values */
aPiecekc6526b42021-07-12 15:21:39 +02001359 if ((processed_leafrefs != ds_unres->leafrefs.count) || ds_unres->disabled_leafrefs.count ||
Michal Vaskoc130e162021-10-19 11:30:00 +02001360 ds_unres->whens.count || ds_unres->musts.count || ds_unres->dflts.count) {
aPiecekd7bd52d2021-07-08 08:59:59 +02001361 goto resolve_all;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001362 }
1363
Michal Vasko30ab8e72021-04-19 12:47:52 +02001364 /* finally, remove all disabled nodes */
Michal Vaskof4258e12021-06-15 12:11:42 +02001365 for (i = 0; i < ds_unres->disabled.count; ++i) {
1366 node = ds_unres->disabled.snodes[i];
Michal Vasko30ab8e72021-04-19 12:47:52 +02001367 if (node->flags & LYS_KEY) {
1368 LOG_LOCSET(node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001369 LOGVAL(ctx, LYVE_REFERENCE, "Key \"%s\" is disabled.", node->name);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001370 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001371 ret = LY_EVALID;
1372 goto cleanup;
Michal Vasko30ab8e72021-04-19 12:47:52 +02001373 }
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001374 LYSC_CTX_INIT_PMOD(cctx, node->module->parsed, NULL);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001375
Michal Vaskoc636ea42022-09-16 10:20:31 +02001376 lysc_node_free(&cctx.free_ctx, node, 1);
Michal Vasko30ab8e72021-04-19 12:47:52 +02001377 }
1378
aPiecekd7bd52d2021-07-08 08:59:59 +02001379 /* also check if the leafref target has not been disabled */
1380 for (i = 0; i < ds_unres->leafrefs.count; ++i) {
Michal Vaskoa91d87e2021-10-19 11:58:57 +02001381 l = ds_unres->leafrefs.objs[i];
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001382 LYSC_CTX_INIT_PMOD(cctx, l->node->module->parsed, l->ext);
aPiecekd7bd52d2021-07-08 08:59:59 +02001383
1384 v = 0;
Michal Vaskoc130e162021-10-19 11:30:00 +02001385 while ((lref = lys_type_leafref_next(l->node, &v))) {
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001386 ret = ly_path_compile_leafref(cctx.ctx, l->node, cctx.ext, lref->path,
Michal Vaskoc130e162021-10-19 11:30:00 +02001387 (l->node->flags & LYS_IS_OUTPUT) ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT, LY_PATH_TARGET_MANY,
aPiecekd7bd52d2021-07-08 08:59:59 +02001388 LY_VALUE_SCHEMA_RESOLVED, lref->prefixes, &path);
Michal Vaskoc130e162021-10-19 11:30:00 +02001389 ly_path_free(l->node->module->ctx, path);
aPiecekd7bd52d2021-07-08 08:59:59 +02001390
1391 assert(ret != LY_ERECOMPILE);
1392 if (ret) {
Michal Vaskoc130e162021-10-19 11:30:00 +02001393 LOG_LOCSET(l->node, NULL, NULL, NULL);
Michal Vaskoe02e7402021-07-23 08:29:28 +02001394 LOGVAL(ctx, LYVE_REFERENCE, "Target of leafref \"%s\" cannot be referenced because it is disabled.",
Michal Vaskoc130e162021-10-19 11:30:00 +02001395 l->node->name);
aPiecekd7bd52d2021-07-08 08:59:59 +02001396 LOG_LOCBACK(1, 0, 0, 0);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001397 ret = LY_EVALID;
1398 goto cleanup;
aPiecekd7bd52d2021-07-08 08:59:59 +02001399 }
1400 }
1401 }
1402
Michal Vaskoc636ea42022-09-16 10:20:31 +02001403cleanup:
1404 lysf_ctx_erase(&cctx.free_ctx);
1405 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001406}
1407
Michal Vaskof4258e12021-06-15 12:11:42 +02001408/**
1409 * @brief Erase dep set unres.
1410 *
1411 * @param[in] ctx libyang context.
1412 * @param[in] unres Global unres structure with the sets to resolve.
1413 */
1414static void
1415lys_compile_unres_depset_erase(const struct ly_ctx *ctx, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +01001416{
1417 uint32_t i;
1418
Michal Vasko4ed3bd52022-12-02 10:28:04 +01001419 ly_set_erase(&unres->ds_unres.whens, free);
Michal Vaskoc130e162021-10-19 11:30:00 +02001420 for (i = 0; i < unres->ds_unres.musts.count; ++i) {
1421 lysc_unres_must_free(unres->ds_unres.musts.objs[i]);
1422 }
1423 ly_set_erase(&unres->ds_unres.musts, NULL);
1424 ly_set_erase(&unres->ds_unres.leafrefs, free);
Michal Vaskof4258e12021-06-15 12:11:42 +02001425 for (i = 0; i < unres->ds_unres.dflts.count; ++i) {
1426 lysc_unres_dflt_free(ctx, unres->ds_unres.dflts.objs[i]);
Michal Vaskodf6319c2021-06-10 14:41:05 +02001427 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001428 ly_set_erase(&unres->ds_unres.dflts, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001429 ly_set_erase(&unres->ds_unres.disabled, NULL);
Michal Vaskof4fa90d2021-11-11 15:05:19 +01001430 ly_set_erase(&unres->ds_unres.disabled_leafrefs, free);
1431 ly_set_erase(&unres->ds_unres.disabled_bitenums, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001432}
1433
Michal Vasko709f9a52021-07-21 10:51:59 +02001434/**
1435 * @brief Compile all flagged modules in a dependency set, recursively if recompilation is needed.
1436 *
1437 * @param[in] ctx libyang context.
1438 * @param[in] dep_set Dependency set to compile.
1439 * @param[in,out] unres Global unres to use.
1440 * @return LY_ERR value.
1441 */
1442static LY_ERR
1443lys_compile_depset_r(struct ly_ctx *ctx, struct ly_set *dep_set, struct lys_glob_unres *unres)
Michal Vaskof4258e12021-06-15 12:11:42 +02001444{
1445 LY_ERR ret = LY_SUCCESS;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001446 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vaskof4258e12021-06-15 12:11:42 +02001447 struct lys_module *mod;
1448 uint32_t i;
1449
1450 for (i = 0; i < dep_set->count; ++i) {
1451 mod = dep_set->objs[i];
1452 if (!mod->to_compile) {
1453 /* skip */
1454 continue;
1455 }
1456 assert(mod->implemented);
1457
1458 /* free the compiled module, if any */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001459 lysc_module_free(&fctx, mod->compiled);
Michal Vaskof4258e12021-06-15 12:11:42 +02001460 mod->compiled = NULL;
1461
1462 /* (re)compile the module */
1463 LY_CHECK_GOTO(ret = lys_compile(mod, &unres->ds_unres), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001464 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001465
1466 /* resolve dep set unres */
1467 ret = lys_compile_unres_depset(ctx, unres);
1468 if (ret == LY_ERECOMPILE) {
1469 /* new module is implemented, discard current dep set unres and recompile the whole dep set */
1470 lys_compile_unres_depset_erase(ctx, unres);
Michal Vasko709f9a52021-07-21 10:51:59 +02001471 return lys_compile_depset_r(ctx, dep_set, unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001472 } else if (ret) {
1473 /* error */
1474 goto cleanup;
1475 }
1476
1477 /* success, unset the flags of all the modules in the dep set */
1478 for (i = 0; i < dep_set->count; ++i) {
1479 mod = dep_set->objs[i];
1480 mod->to_compile = 0;
1481 }
1482
1483cleanup:
1484 lys_compile_unres_depset_erase(ctx, unres);
Michal Vaskoc636ea42022-09-16 10:20:31 +02001485 lysf_ctx_erase(&fctx);
Michal Vaskof4258e12021-06-15 12:11:42 +02001486 return ret;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001487}
1488
Michal Vasko6a4ef772022-02-08 15:07:44 +01001489/**
1490 * @brief Check if-feature of all features of all modules in a dep set.
1491 *
1492 * @param[in] dep_set Dep set to check.
1493 * @return LY_ERR value.
1494 */
1495static LY_ERR
1496lys_compile_depset_check_features(struct ly_set *dep_set)
1497{
1498 struct lys_module *mod;
1499 uint32_t i;
1500
1501 for (i = 0; i < dep_set->count; ++i) {
1502 mod = dep_set->objs[i];
1503 if (!mod->to_compile) {
1504 /* skip */
1505 continue;
1506 }
1507
1508 /* check features of this module */
1509 LY_CHECK_RET(lys_check_features(mod->parsed));
1510 }
1511
1512 return LY_SUCCESS;
1513}
1514
Michal Vasko709f9a52021-07-21 10:51:59 +02001515LY_ERR
1516lys_compile_depset_all(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1517{
1518 uint32_t i;
1519
1520 for (i = 0; i < unres->dep_sets.count; ++i) {
Michal Vasko6a4ef772022-02-08 15:07:44 +01001521 LY_CHECK_RET(lys_compile_depset_check_features(unres->dep_sets.objs[i]));
Michal Vasko709f9a52021-07-21 10:51:59 +02001522 LY_CHECK_RET(lys_compile_depset_r(ctx, unres->dep_sets.objs[i], unres));
1523 }
1524
1525 return LY_SUCCESS;
1526}
1527
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001528/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001529 * @brief Finish compilation of all the module unres sets in a compile context.
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001530 *
1531 * @param[in] ctx Compile context with unres sets.
1532 * @return LY_ERR value.
1533 */
1534static LY_ERR
Michal Vasko405cc9e2020-12-01 12:01:27 +01001535lys_compile_unres_mod(struct lysc_ctx *ctx)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001536{
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001537 struct lysc_augment *aug;
1538 struct lysc_deviation *dev;
Michal Vasko1ade6f12021-04-19 11:32:45 +02001539 struct lys_module *orig_mod = ctx->cur_mod;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001540 uint32_t i;
1541
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001542 /* check that all augments were applied */
1543 for (i = 0; i < ctx->augs.count; ++i) {
1544 aug = ctx->augs.objs[i];
Michal Vasko1ade6f12021-04-19 11:32:45 +02001545 ctx->cur_mod = aug->aug_pmod->mod;
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001546 if (aug->ext) {
1547 lysc_update_path(ctx, NULL, "{extension}");
1548 lysc_update_path(ctx, NULL, aug->ext->name);
1549 }
Radek Krejci2efc45b2020-12-22 16:25:44 +01001550 lysc_update_path(ctx, NULL, "{augment}");
1551 lysc_update_path(ctx, NULL, aug->nodeid->expr);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001552 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Augment%s target node \"%s\" from module \"%s\" was not found.",
1553 aug->ext ? " extension" : "", aug->nodeid->expr, LYSP_MODULE_NAME(aug->aug_pmod));
Michal Vasko1ade6f12021-04-19 11:32:45 +02001554 ctx->cur_mod = orig_mod;
Radek Krejci2efc45b2020-12-22 16:25:44 +01001555 lysc_update_path(ctx, NULL, NULL);
1556 lysc_update_path(ctx, NULL, NULL);
Michal Vaskoa0ba01e2022-10-19 13:26:57 +02001557 if (aug->ext) {
1558 lysc_update_path(ctx, NULL, NULL);
1559 lysc_update_path(ctx, NULL, NULL);
1560 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001561 }
1562 if (ctx->augs.count) {
1563 return LY_ENOTFOUND;
1564 }
1565
1566 /* check that all deviations were applied */
1567 for (i = 0; i < ctx->devs.count; ++i) {
1568 dev = ctx->devs.objs[i];
Radek Krejci2efc45b2020-12-22 16:25:44 +01001569 lysc_update_path(ctx, NULL, "{deviation}");
1570 lysc_update_path(ctx, NULL, dev->nodeid->expr);
1571 LOGVAL(ctx->ctx, LYVE_REFERENCE, "Deviation(s) target node \"%s\" from module \"%s\" was not found.",
1572 dev->nodeid->expr, LYSP_MODULE_NAME(dev->dev_pmods[0]));
1573 lysc_update_path(ctx, NULL, NULL);
1574 lysc_update_path(ctx, NULL, NULL);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001575 }
1576 if (ctx->devs.count) {
1577 return LY_ENOTFOUND;
1578 }
1579
1580 return LY_SUCCESS;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001581}
1582
1583/**
Michal Vasko405cc9e2020-12-01 12:01:27 +01001584 * @brief Erase all the module unres sets in a compile context.
1585 *
1586 * @param[in] ctx Compile context with unres sets.
1587 * @param[in] error Whether the compilation finished with an error or not.
1588 */
1589static void
1590lys_compile_unres_mod_erase(struct lysc_ctx *ctx, ly_bool error)
1591{
1592 uint32_t i;
1593
1594 ly_set_erase(&ctx->groupings, NULL);
1595 ly_set_erase(&ctx->tpdf_chain, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001596
1597 if (!error) {
1598 /* there can be no leftover deviations or augments */
1599 LY_CHECK_ERR_RET(ctx->augs.count, LOGINT(ctx->ctx), );
1600 LY_CHECK_ERR_RET(ctx->devs.count, LOGINT(ctx->ctx), );
1601
1602 ly_set_erase(&ctx->augs, NULL);
1603 ly_set_erase(&ctx->devs, NULL);
1604 ly_set_erase(&ctx->uses_augs, NULL);
1605 ly_set_erase(&ctx->uses_rfns, NULL);
1606 } else {
1607 for (i = 0; i < ctx->augs.count; ++i) {
1608 lysc_augment_free(ctx->ctx, ctx->augs.objs[i]);
1609 }
1610 ly_set_erase(&ctx->augs, NULL);
1611 for (i = 0; i < ctx->devs.count; ++i) {
1612 lysc_deviation_free(ctx->ctx, ctx->devs.objs[i]);
1613 }
1614 ly_set_erase(&ctx->devs, NULL);
1615 for (i = 0; i < ctx->uses_augs.count; ++i) {
1616 lysc_augment_free(ctx->ctx, ctx->uses_augs.objs[i]);
1617 }
1618 ly_set_erase(&ctx->uses_augs, NULL);
1619 for (i = 0; i < ctx->uses_rfns.count; ++i) {
1620 lysc_refine_free(ctx->ctx, ctx->uses_rfns.objs[i]);
1621 }
1622 ly_set_erase(&ctx->uses_rfns, NULL);
1623 }
1624}
1625
Michal Vaskod39bea42021-06-14 10:42:49 +02001626LY_ERR
Michal Vaskof4258e12021-06-15 12:11:42 +02001627lys_compile(struct lys_module *mod, struct lys_depset_unres *unres)
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001628{
Michal Vaskoc636ea42022-09-16 10:20:31 +02001629 struct lysc_ctx ctx;
Michal Vasko0b395e12021-04-23 13:43:07 +02001630 struct lysc_module *mod_c = NULL;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001631 struct lysp_module *sp;
1632 struct lysp_submodule *submod;
1633 struct lysp_node *pnode;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001634 struct lysp_node_grp *grp;
1635 LY_ARRAY_COUNT_TYPE u;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001636 LY_ERR ret = LY_SUCCESS;
1637
1638 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, !mod->compiled, mod->ctx, LY_EINVAL);
1639
Michal Vaskof4258e12021-06-15 12:11:42 +02001640 assert(mod->implemented && mod->to_compile);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001641
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001642 sp = mod->parsed;
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001643 LYSC_CTX_INIT_PMOD(ctx, sp, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001644 ctx.unres = unres;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001645
Michal Vasko0b395e12021-04-23 13:43:07 +02001646 ++mod->ctx->change_count;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001647 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
1648 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
1649 mod_c->mod = mod;
1650
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001651 /* compile augments and deviations of our module from other modules so they can be applied during compilation */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001652 LY_CHECK_GOTO(ret = lys_precompile_own_augments(&ctx), cleanup);
1653 LY_CHECK_GOTO(ret = lys_precompile_own_deviations(&ctx), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001654
1655 /* data nodes */
1656 LY_LIST_FOR(sp->data, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001657 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001658 }
1659
Radek Krejci2a9fc652021-01-22 17:44:34 +01001660 /* top-level RPCs */
1661 LY_LIST_FOR((struct lysp_node *)sp->rpcs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001662 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001663 }
1664
1665 /* top-level notifications */
1666 LY_LIST_FOR((struct lysp_node *)sp->notifs, pnode) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001667 LY_CHECK_GOTO(ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL), cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001668 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001669
Michal Vasko193dacd2022-10-13 08:43:05 +02001670 /* module extension instances */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001671 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001672
1673 /* the same for submodules */
1674 LY_ARRAY_FOR(sp->includes, u) {
1675 submod = sp->includes[u].submodule;
1676 ctx.pmod = (struct lysp_module *)submod;
1677
1678 LY_LIST_FOR(submod->data, pnode) {
1679 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001680 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001681 }
1682
Radek Krejci2a9fc652021-01-22 17:44:34 +01001683 LY_LIST_FOR((struct lysp_node *)submod->rpcs, pnode) {
1684 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001685 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001686 }
1687
1688 LY_LIST_FOR((struct lysp_node *)submod->notifs, pnode) {
1689 ret = lys_compile_node(&ctx, pnode, NULL, 0, NULL);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001690 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci2a9fc652021-01-22 17:44:34 +01001691 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001692
Michal Vasko1ccbf542021-04-19 11:35:00 +02001693 COMPILE_EXTS_GOTO(&ctx, submod->exts, mod_c->exts, mod_c, ret, cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001694 }
Michal Vasko12606ee2020-11-25 17:05:11 +01001695 ctx.pmod = sp;
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001696
1697 /* validate non-instantiated groupings from the parsed schema,
1698 * without it we would accept even the schemas with invalid grouping specification */
Michal Vasko7c565922021-06-10 14:58:27 +02001699 ctx.compile_opts |= LYS_COMPILE_GROUPING;
Radek Krejci2a9fc652021-01-22 17:44:34 +01001700 LY_LIST_FOR(sp->groupings, grp) {
1701 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001702 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001703 }
1704 }
1705 LY_LIST_FOR(sp->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001706 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1707 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001708 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001709 }
1710 }
1711 }
1712 LY_ARRAY_FOR(sp->includes, u) {
1713 submod = sp->includes[u].submodule;
1714 ctx.pmod = (struct lysp_module *)submod;
1715
Radek Krejci2a9fc652021-01-22 17:44:34 +01001716 LY_LIST_FOR(submod->groupings, grp) {
1717 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001718 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, NULL, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001719 }
1720 }
1721 LY_LIST_FOR(submod->data, pnode) {
Radek Krejci2a9fc652021-01-22 17:44:34 +01001722 LY_LIST_FOR((struct lysp_node_grp *)lysp_node_groupings(pnode), grp) {
1723 if (!(grp->flags & LYS_USED_GRP)) {
Michal Vasko1ccbf542021-04-19 11:35:00 +02001724 LY_CHECK_GOTO(ret = lys_compile_grouping(&ctx, pnode, grp), cleanup);
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001725 }
1726 }
1727 }
1728 }
1729 ctx.pmod = sp;
1730
Radek Krejciddace2c2021-01-08 11:30:56 +01001731 LOG_LOCBACK(0, 0, 1, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001732
Michal Vasko405cc9e2020-12-01 12:01:27 +01001733 /* finish compilation for all unresolved module items in the context */
Michal Vasko1ccbf542021-04-19 11:35:00 +02001734 LY_CHECK_GOTO(ret = lys_compile_unres_mod(&ctx), cleanup);
Michal Vasko12606ee2020-11-25 17:05:11 +01001735
Michal Vasko1ccbf542021-04-19 11:35:00 +02001736cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +01001737 LOG_LOCBACK(0, 0, 1, 0);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001738 lys_compile_unres_mod_erase(&ctx, ret);
1739 if (ret) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001740 lysc_module_free(&ctx.free_ctx, mod_c);
Michal Vasko1ccbf542021-04-19 11:35:00 +02001741 mod->compiled = NULL;
1742 }
Michal Vasko1a7a7bd2020-10-16 14:39:15 +02001743 return ret;
1744}
Michal Vasko65333882021-06-10 14:12:16 +02001745
aPiecek6b3d5422021-07-30 15:55:43 +02001746LY_ERR
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001747lys_compile_identities(struct lys_module *mod)
1748{
Michal Vasko776ae742022-08-04 11:08:21 +02001749 LY_ERR rc = LY_SUCCESS;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001750 struct lysc_ctx ctx;
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001751 struct lysp_submodule *submod;
1752 LY_ARRAY_COUNT_TYPE u;
1753
aPiecek6b3d5422021-07-30 15:55:43 +02001754 /* pre-compile identities of the module and any submodules */
Michal Vasko776ae742022-08-04 11:08:21 +02001755 rc = lys_identity_precompile(NULL, mod->ctx, mod->parsed, mod->parsed->identities, &mod->identities);
1756 LY_CHECK_GOTO(rc, cleanup);
aPiecek6b3d5422021-07-30 15:55:43 +02001757 LY_ARRAY_FOR(mod->parsed->includes, u) {
1758 submod = mod->parsed->includes[u].submodule;
Michal Vasko776ae742022-08-04 11:08:21 +02001759 rc = lys_identity_precompile(NULL, mod->ctx, (struct lysp_module *)submod, submod->identities, &mod->identities);
1760 LY_CHECK_GOTO(rc, cleanup);
aPiecek6b3d5422021-07-30 15:55:43 +02001761 }
1762
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001763 /* prepare context */
Michal Vaskoedb0fa52022-10-04 10:36:00 +02001764 LYSC_CTX_INIT_PMOD(ctx, mod->parsed, NULL);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001765
1766 if (mod->parsed->identities) {
Michal Vasko776ae742022-08-04 11:08:21 +02001767 rc = lys_compile_identities_derived(&ctx, mod->parsed->identities, &mod->identities);
1768 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001769 }
1770 lysc_update_path(&ctx, NULL, "{submodule}");
1771 LY_ARRAY_FOR(mod->parsed->includes, u) {
1772 submod = mod->parsed->includes[u].submodule;
1773 if (submod->identities) {
1774 ctx.pmod = (struct lysp_module *)submod;
1775 lysc_update_path(&ctx, NULL, submod->name);
Michal Vasko776ae742022-08-04 11:08:21 +02001776 rc = lys_compile_identities_derived(&ctx, submod->identities, &mod->identities);
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001777 lysc_update_path(&ctx, NULL, NULL);
1778 }
Michal Vasko776ae742022-08-04 11:08:21 +02001779
1780 if (rc) {
1781 break;
1782 }
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001783 }
1784 lysc_update_path(&ctx, NULL, NULL);
1785
Michal Vasko776ae742022-08-04 11:08:21 +02001786cleanup:
1787 /* always needed when using lysc_update_path() */
1788 LOG_LOCBACK(0, 0, 1, 0);
1789 return rc;
Michal Vaskofa5a7d72021-06-15 11:41:20 +02001790}
1791
1792/**
Michal Vasko65333882021-06-10 14:12:16 +02001793 * @brief Check whether a module does not have any (recursive) compiled import.
1794 *
1795 * @param[in] mod Module to examine.
1796 * @return LY_SUCCESS on success.
Michal Vaskof4258e12021-06-15 12:11:42 +02001797 * @return LY_ERECOMPILE on required recompilation of the dep set.
Michal Vasko65333882021-06-10 14:12:16 +02001798 * @return LY_ERR on error.
1799 */
1800static LY_ERR
1801lys_has_compiled_import_r(struct lys_module *mod)
1802{
1803 LY_ARRAY_COUNT_TYPE u;
Michal Vaskoe7927122021-06-15 12:00:04 +02001804 struct lys_module *m;
Michal Vasko65333882021-06-10 14:12:16 +02001805
1806 LY_ARRAY_FOR(mod->parsed->imports, u) {
Michal Vaskoe7927122021-06-15 12:00:04 +02001807 m = mod->parsed->imports[u].module;
1808 if (!m->implemented) {
Michal Vasko65333882021-06-10 14:12:16 +02001809 continue;
1810 }
1811
Michal Vaskoe7927122021-06-15 12:00:04 +02001812 if (!m->to_compile) {
Michal Vaskod39bea42021-06-14 10:42:49 +02001813 /* module was not/will not be compiled in this compilation (so disabled nodes are not present) */
Michal Vaskof4258e12021-06-15 12:11:42 +02001814 m->to_compile = 1;
Michal Vasko65333882021-06-10 14:12:16 +02001815 return LY_ERECOMPILE;
1816 }
1817
1818 /* recursive */
Michal Vaskoe7927122021-06-15 12:00:04 +02001819 LY_CHECK_RET(lys_has_compiled_import_r(m));
Michal Vasko65333882021-06-10 14:12:16 +02001820 }
1821
1822 return LY_SUCCESS;
1823}
1824
1825LY_ERR
1826lys_implement(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
1827{
Michal Vaskodc668d22023-02-13 10:23:13 +01001828 LY_ERR r;
Michal Vasko65333882021-06-10 14:12:16 +02001829 struct lys_module *m;
1830
1831 assert(!mod->implemented);
1832
Michal Vasko978532b2022-01-21 14:13:40 +01001833 /* check collision with other implemented revision */
Michal Vasko65333882021-06-10 14:12:16 +02001834 m = ly_ctx_get_module_implemented(mod->ctx, mod->name);
1835 if (m) {
1836 assert(m != mod);
Michal Vaskodc668d22023-02-13 10:23:13 +01001837 LOGERR(mod->ctx, LY_EDENIED, "Module \"%s@%s\" is already implemented in revision \"%s\".",
1838 mod->name, mod->revision ? mod->revision : "<none>", m->revision ? m->revision : "<none>");
1839 return LY_EDENIED;
Michal Vasko65333882021-06-10 14:12:16 +02001840 }
1841
1842 /* set features */
Michal Vaskodc668d22023-02-13 10:23:13 +01001843 r = lys_set_features(mod->parsed, features);
1844 if (r && (r != LY_EEXIST)) {
1845 return r;
Michal Vasko65333882021-06-10 14:12:16 +02001846 }
1847
Michal Vasko65333882021-06-10 14:12:16 +02001848 /*
1849 * mark the module implemented, which means
1850 * 1) to (re)compile it only ::lys_compile() call is needed
1851 * 2) its compilation will never cause new modules to be implemented (::lys_compile() does not return ::LY_ERECOMPILE)
1852 * but there can be some unres items added that do
1853 */
1854 mod->implemented = 1;
1855
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001856 /* this module is compiled in this compilation */
1857 mod->to_compile = 1;
1858
Michal Vasko65333882021-06-10 14:12:16 +02001859 /* add the module into newly implemented module set */
1860 LY_CHECK_RET(ly_set_add(&unres->implementing, mod, 1, NULL));
1861
Michal Vaskoa9f807e2021-06-15 12:07:16 +02001862 /* mark target modules with our augments and deviations */
1863 LY_CHECK_RET(lys_precompile_augments_deviations(mod, unres));
Michal Vasko65333882021-06-10 14:12:16 +02001864
Michal Vaskod39bea42021-06-14 10:42:49 +02001865 /* check whether this module may reference any modules compiled previously */
1866 LY_CHECK_RET(lys_has_compiled_import_r(mod));
Michal Vasko65333882021-06-10 14:12:16 +02001867
Michal Vasko65333882021-06-10 14:12:16 +02001868 return LY_SUCCESS;
1869}