blob: 3ba39ba12d260af68260f6ce0b4b2e64a430ce70 [file] [log] [blame]
Radek Krejci19a96102018-11-15 13:38:09 +01001/**
2 * @file tree_schema.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema tree implementation
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#include "common.h"
16
Radek Krejcie7b95092019-05-15 11:03:07 +020017#include <assert.h>
Radek Krejci19a96102018-11-15 13:38:09 +010018#include <ctype.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <stddef.h>
20#include <stdint.h>
Radek Krejci19a96102018-11-15 13:38:09 +010021#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdlib.h>
23#include <string.h>
Radek Krejci19a96102018-11-15 13:38:09 +010024
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include "dict.h"
26#include "log.h"
Radek Krejci0935f412019-08-20 16:15:18 +020027#include "plugins_exts.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020028#include "set.h"
29#include "plugins_types.h"
Radek Krejci0935f412019-08-20 16:15:18 +020030#include "plugins_exts_internal.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020031#include "tree.h"
32#include "tree_schema.h"
Radek Krejci19a96102018-11-15 13:38:09 +010033#include "tree_schema_internal.h"
34#include "xpath.h"
35
36/**
37 * @brief Duplicate string into dictionary
38 * @param[in] CTX libyang context of the dictionary.
39 * @param[in] ORIG String to duplicate.
40 * @param[out] DUP Where to store the result.
41 */
42#define DUP_STRING(CTX, ORIG, DUP) if (ORIG) {DUP = lydict_insert(CTX, ORIG, 0);}
43
Radek Krejciec4da802019-05-02 13:02:41 +020044#define COMPILE_ARRAY_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
Radek Krejci19a96102018-11-15 13:38:09 +010045 if (ARRAY_P) { \
46 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_SIZE(ARRAY_P), RET, GOTO); \
Radek Krejcid05cbd92018-12-05 14:26:40 +010047 size_t __array_offset = LY_ARRAY_SIZE(ARRAY_C); \
Radek Krejci19a96102018-11-15 13:38:09 +010048 for (ITER = 0; ITER < LY_ARRAY_SIZE(ARRAY_P); ++ITER) { \
49 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020050 RET = FUNC(CTX, &(ARRAY_P)[ITER], &(ARRAY_C)[ITER + __array_offset]); \
Radek Krejcid05cbd92018-12-05 14:26:40 +010051 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
52 } \
53 }
54
Radek Krejciec4da802019-05-02 13:02:41 +020055#define COMPILE_ARRAY1_GOTO(CTX, ARRAY_P, ARRAY_C, PARENT, ITER, FUNC, USES_STATUS, RET, GOTO) \
Radek Krejci6eeb58f2019-02-22 16:29:37 +010056 if (ARRAY_P) { \
57 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_SIZE(ARRAY_P), RET, GOTO); \
58 size_t __array_offset = LY_ARRAY_SIZE(ARRAY_C); \
59 for (ITER = 0; ITER < LY_ARRAY_SIZE(ARRAY_P); ++ITER) { \
60 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020061 RET = FUNC(CTX, &(ARRAY_P)[ITER], PARENT, &(ARRAY_C)[ITER + __array_offset], USES_STATUS); \
Radek Krejci6eeb58f2019-02-22 16:29:37 +010062 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
63 } \
64 }
65
Radek Krejci0935f412019-08-20 16:15:18 +020066#define COMPILE_EXTS_GOTO(CTX, EXTS_P, EXT_C, PARENT, PARENT_TYPE, RET, GOTO) \
67 if (EXTS_P) { \
68 LY_ARRAY_CREATE_GOTO((CTX)->ctx, EXT_C, LY_ARRAY_SIZE(EXTS_P), RET, GOTO); \
69 for (uint32_t __exts_iter = 0, __array_offset = LY_ARRAY_SIZE(EXT_C); __exts_iter < LY_ARRAY_SIZE(EXTS_P); ++__exts_iter) { \
70 LY_ARRAY_INCREMENT(EXT_C); \
71 RET = lys_compile_ext(CTX, &(EXTS_P)[__exts_iter], &(EXT_C)[__exts_iter + __array_offset], PARENT, PARENT_TYPE); \
72 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
73 } \
74 }
75
Radek Krejciec4da802019-05-02 13:02:41 +020076#define COMPILE_ARRAY_UNIQUE_GOTO(CTX, ARRAY_P, ARRAY_C, ITER, FUNC, RET, GOTO) \
Radek Krejcid05cbd92018-12-05 14:26:40 +010077 if (ARRAY_P) { \
78 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, LY_ARRAY_SIZE(ARRAY_P), RET, GOTO); \
79 size_t __array_offset = LY_ARRAY_SIZE(ARRAY_C); \
80 for (ITER = 0; ITER < LY_ARRAY_SIZE(ARRAY_P); ++ITER) { \
81 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +020082 RET = FUNC(CTX, &(ARRAY_P)[ITER], ARRAY_C, &(ARRAY_C)[ITER + __array_offset]); \
Radek Krejci19a96102018-11-15 13:38:09 +010083 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
84 } \
85 }
86
Radek Krejciec4da802019-05-02 13:02:41 +020087#define COMPILE_MEMBER_GOTO(CTX, MEMBER_P, MEMBER_C, FUNC, RET, GOTO) \
Radek Krejci19a96102018-11-15 13:38:09 +010088 if (MEMBER_P) { \
89 MEMBER_C = calloc(1, sizeof *(MEMBER_C)); \
90 LY_CHECK_ERR_GOTO(!(MEMBER_C), LOGMEM((CTX)->ctx); RET = LY_EMEM, GOTO); \
Radek Krejciec4da802019-05-02 13:02:41 +020091 RET = FUNC(CTX, MEMBER_P, MEMBER_C); \
Radek Krejci19a96102018-11-15 13:38:09 +010092 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
93 }
94
Radek Krejciec4da802019-05-02 13:02:41 +020095#define COMPILE_MEMBER_ARRAY_GOTO(CTX, MEMBER_P, ARRAY_C, FUNC, RET, GOTO) \
Radek Krejci00b874b2019-02-12 10:54:50 +010096 if (MEMBER_P) { \
97 LY_ARRAY_CREATE_GOTO((CTX)->ctx, ARRAY_C, 1, RET, GOTO); \
98 size_t __array_offset = LY_ARRAY_SIZE(ARRAY_C); \
99 LY_ARRAY_INCREMENT(ARRAY_C); \
Radek Krejciec4da802019-05-02 13:02:41 +0200100 RET = FUNC(CTX, MEMBER_P, &(ARRAY_C)[__array_offset]); \
Radek Krejci00b874b2019-02-12 10:54:50 +0100101 LY_CHECK_GOTO(RET != LY_SUCCESS, GOTO); \
102 }
103
Radek Krejcid05cbd92018-12-05 14:26:40 +0100104#define COMPILE_CHECK_UNIQUENESS(CTX, ARRAY, MEMBER, EXCL, STMT, IDENT) \
105 if (ARRAY) { \
Radek Krejci0af46292019-01-11 16:02:31 +0100106 for (unsigned int u__ = 0; u__ < LY_ARRAY_SIZE(ARRAY); ++u__) { \
107 if (&(ARRAY)[u__] != EXCL && (void*)((ARRAY)[u__].MEMBER) == (void*)(IDENT)) { \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100108 LOGVAL((CTX)->ctx, LY_VLOG_STR, (CTX)->path, LY_VCODE_DUPIDENT, IDENT, STMT); \
109 return LY_EVALID; \
110 } \
111 } \
112 }
113
Radek Krejci19a96102018-11-15 13:38:09 +0100114static struct lysc_ext_instance *
115lysc_ext_instance_dup(struct ly_ctx *ctx, struct lysc_ext_instance *orig)
116{
Radek Krejcie7b95092019-05-15 11:03:07 +0200117 /* TODO - extensions */
Radek Krejci19a96102018-11-15 13:38:09 +0100118 (void) ctx;
119 (void) orig;
120 return NULL;
121}
122
Radek Krejcib56c7502019-02-13 14:19:54 +0100123/**
Radek Krejci474f9b82019-07-24 11:36:37 +0200124 * @brief Add record into the compile context's list of incomplete default values.
125 * @param[in] ctx Compile context with the incomplete default values list.
126 * @param[in] context_node Context schema node to store in the record.
127 * @param[in] dflt Incomplete default value to store in the record.
128 * @param[in] dflt_mod Module of the default value definition to store in the record.
129 * @return LY_EMEM in case of memory allocation failure.
130 * @return LY_SUCCESS
131 */
132static LY_ERR
133lysc_incomplete_dflts_add(struct lysc_ctx *ctx, struct lysc_node *context_node, struct lyd_value *dflt, struct lys_module *dflt_mod)
134{
135 struct lysc_incomplete_dflt *r;
136 r = malloc(sizeof *r);
137 LY_CHECK_ERR_RET(!r, LOGMEM(ctx->ctx), LY_EMEM);
138 r->context_node = context_node;
139 r->dflt = dflt;
140 r->dflt_mod = dflt_mod;
141 ly_set_add(&ctx->dflts, r, LY_SET_OPT_USEASLIST);
142
143 return LY_SUCCESS;
144}
145
146/**
147 * @brief Remove record of the given default value from the compile context's list of incomplete default values.
148 * @param[in] ctx Compile context with the incomplete default values list.
149 * @param[in] dflt Incomplete default values identifying the record to remove.
150 */
151static void
152lysc_incomplete_dflts_remove(struct lysc_ctx *ctx, struct lyd_value *dflt)
153{
154 unsigned int u;
155 struct lysc_incomplete_dflt *r;
156
157 for (u = 0; u < ctx->dflts.count; ++u) {
158 r = (struct lysc_incomplete_dflt*)ctx->dflts.objs[u];
159 if (r->dflt == dflt) {
160 free(ctx->dflts.objs[u]);
161 memmove(&ctx->dflts.objs[u], &ctx->dflts.objs[u + 1], (ctx->dflts.count - (u + 1)) * sizeof *ctx->dflts.objs);
162 --ctx->dflts.count;
163 return;
164 }
165 }
166}
167
Radek Krejci0e59c312019-08-15 15:34:15 +0200168void
Radek Krejci327de162019-06-14 12:52:07 +0200169lysc_update_path(struct lysc_ctx *ctx, struct lysc_node *parent, const char *name)
170{
171 int len;
172 int nextlevel = 0; /* 0 - no starttag, 1 - '/' starttag, 2 - '=' starttag + '}' endtag */
173
174 if (!name) {
175 /* removing last path segment */
176 if (ctx->path[ctx->path_len - 1] == '}') {
177 for (; ctx->path[ctx->path_len] != '=' && ctx->path[ctx->path_len] != '{'; --ctx->path_len);
178 if (ctx->path[ctx->path_len] == '=') {
179 ctx->path[ctx->path_len++] = '}';
180 } else {
181 /* not a top-level special tag, remove also preceiding '/' */
182 goto remove_nodelevel;
183 }
184 } else {
185remove_nodelevel:
186 for (; ctx->path[ctx->path_len] != '/' ; --ctx->path_len);
187 if (ctx->path_len == 0) {
188 /* top-level (last segment) */
Radek Krejciacc79042019-07-25 14:14:57 +0200189 ctx->path_len = 1;
Radek Krejci327de162019-06-14 12:52:07 +0200190 }
191 }
192 /* set new terminating NULL-byte */
193 ctx->path[ctx->path_len] = '\0';
194 } else {
195 if (ctx->path_len > 1) {
196 if (!parent && ctx->path[ctx->path_len - 1] == '}' && ctx->path[ctx->path_len - 2] != '\'') {
197 /* extension of the special tag */
198 nextlevel = 2;
199 --ctx->path_len;
200 } else {
201 /* there is already some path, so add next level */
202 nextlevel = 1;
203 }
204 } /* else the path is just initiated with '/', so do not add additional slash in case of top-level nodes */
205
206 if (nextlevel != 2) {
207 if ((parent && parent->module == ctx->mod) || (!parent && ctx->path_len > 1 && name[0] == '{')) {
208 /* module not changed, print the name unprefixed */
Radek Krejci70ee9152019-07-25 11:27:27 +0200209 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s", nextlevel ? "/" : "", name);
Radek Krejci327de162019-06-14 12:52:07 +0200210 } else {
Radek Krejci70ee9152019-07-25 11:27:27 +0200211 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "%s%s:%s", nextlevel ? "/" : "", ctx->mod->name, name);
Radek Krejci327de162019-06-14 12:52:07 +0200212 }
213 } else {
Radek Krejci70ee9152019-07-25 11:27:27 +0200214 len = snprintf(&ctx->path[ctx->path_len], LYSC_CTX_BUFSIZE - ctx->path_len, "='%s'}", name);
Radek Krejci327de162019-06-14 12:52:07 +0200215 }
Radek Krejciacc79042019-07-25 14:14:57 +0200216 if (len >= LYSC_CTX_BUFSIZE - ctx->path_len) {
217 /* output truncated */
218 ctx->path_len = LYSC_CTX_BUFSIZE - 1;
219 } else {
220 ctx->path_len += len;
221 }
Radek Krejci327de162019-06-14 12:52:07 +0200222 }
223}
224
225/**
Radek Krejcib56c7502019-02-13 14:19:54 +0100226 * @brief Duplicate the compiled pattern structure.
227 *
228 * Instead of duplicating memory, the reference counter in the @p orig is increased.
229 *
230 * @param[in] orig The pattern structure to duplicate.
231 * @return The duplicated structure to use.
232 */
Radek Krejci19a96102018-11-15 13:38:09 +0100233static struct lysc_pattern*
234lysc_pattern_dup(struct lysc_pattern *orig)
235{
236 ++orig->refcount;
237 return orig;
238}
239
Radek Krejcib56c7502019-02-13 14:19:54 +0100240/**
241 * @brief Duplicate the array of compiled patterns.
242 *
243 * The sized array itself is duplicated, but the pattern structures are just shadowed by increasing their reference counter.
244 *
245 * @param[in] ctx Libyang context for logging.
246 * @param[in] orig The patterns sized array to duplicate.
247 * @return New sized array as a copy of @p orig.
248 * @return NULL in case of memory allocation error.
249 */
Radek Krejci19a96102018-11-15 13:38:09 +0100250static struct lysc_pattern**
251lysc_patterns_dup(struct ly_ctx *ctx, struct lysc_pattern **orig)
252{
Radek Krejcid05cbd92018-12-05 14:26:40 +0100253 struct lysc_pattern **dup = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +0100254 unsigned int u;
255
Radek Krejcib56c7502019-02-13 14:19:54 +0100256 assert(orig);
257
Radek Krejci19a96102018-11-15 13:38:09 +0100258 LY_ARRAY_CREATE_RET(ctx, dup, LY_ARRAY_SIZE(orig), NULL);
259 LY_ARRAY_FOR(orig, u) {
260 dup[u] = lysc_pattern_dup(orig[u]);
261 LY_ARRAY_INCREMENT(dup);
262 }
263 return dup;
264}
265
Radek Krejcib56c7502019-02-13 14:19:54 +0100266/**
267 * @brief Duplicate compiled range structure.
268 *
269 * @param[in] ctx Libyang context for logging.
270 * @param[in] orig The range structure to be duplicated.
271 * @return New compiled range structure as a copy of @p orig.
272 * @return NULL in case of memory allocation error.
273 */
Radek Krejci19a96102018-11-15 13:38:09 +0100274struct lysc_range*
275lysc_range_dup(struct ly_ctx *ctx, const struct lysc_range *orig)
276{
277 struct lysc_range *dup;
278 LY_ERR ret;
279
Radek Krejcib56c7502019-02-13 14:19:54 +0100280 assert(orig);
281
Radek Krejci19a96102018-11-15 13:38:09 +0100282 dup = calloc(1, sizeof *dup);
283 LY_CHECK_ERR_RET(!dup, LOGMEM(ctx), NULL);
284 if (orig->parts) {
285 LY_ARRAY_CREATE_GOTO(ctx, dup->parts, LY_ARRAY_SIZE(orig->parts), ret, cleanup);
286 LY_ARRAY_SIZE(dup->parts) = LY_ARRAY_SIZE(orig->parts);
287 memcpy(dup->parts, orig->parts, LY_ARRAY_SIZE(dup->parts) * sizeof *dup->parts);
288 }
289 DUP_STRING(ctx, orig->eapptag, dup->eapptag);
290 DUP_STRING(ctx, orig->emsg, dup->emsg);
291 dup->exts = lysc_ext_instance_dup(ctx, orig->exts);
292
293 return dup;
294cleanup:
295 free(dup);
296 (void) ret; /* set but not used due to the return type */
297 return NULL;
298}
299
Radek Krejcib56c7502019-02-13 14:19:54 +0100300/**
301 * @brief Stack for processing if-feature expressions.
302 */
Radek Krejci19a96102018-11-15 13:38:09 +0100303struct iff_stack {
Radek Krejcib56c7502019-02-13 14:19:54 +0100304 int size; /**< number of items in the stack */
305 int index; /**< first empty item */
306 uint8_t *stack;/**< stack - array of @ref ifftokens to create the if-feature expression in prefix format */
Radek Krejci19a96102018-11-15 13:38:09 +0100307};
308
Radek Krejcib56c7502019-02-13 14:19:54 +0100309/**
310 * @brief Add @ref ifftokens into the stack.
311 * @param[in] stack The if-feature stack to use.
312 * @param[in] value One of the @ref ifftokens to store in the stack.
313 * @return LY_EMEM in case of memory allocation error
314 * @return LY_ESUCCESS if the value successfully stored.
315 */
Radek Krejci19a96102018-11-15 13:38:09 +0100316static LY_ERR
317iff_stack_push(struct iff_stack *stack, uint8_t value)
318{
319 if (stack->index == stack->size) {
320 stack->size += 4;
321 stack->stack = ly_realloc(stack->stack, stack->size * sizeof *stack->stack);
322 LY_CHECK_ERR_RET(!stack->stack, LOGMEM(NULL); stack->size = 0, LY_EMEM);
323 }
324 stack->stack[stack->index++] = value;
325 return LY_SUCCESS;
326}
327
Radek Krejcib56c7502019-02-13 14:19:54 +0100328/**
329 * @brief Get (and remove) the last item form the stack.
330 * @param[in] stack The if-feature stack to use.
331 * @return The value from the top of the stack.
332 */
Radek Krejci19a96102018-11-15 13:38:09 +0100333static uint8_t
334iff_stack_pop(struct iff_stack *stack)
335{
Radek Krejcib56c7502019-02-13 14:19:54 +0100336 assert(stack && stack->index);
337
Radek Krejci19a96102018-11-15 13:38:09 +0100338 stack->index--;
339 return stack->stack[stack->index];
340}
341
Radek Krejcib56c7502019-02-13 14:19:54 +0100342/**
343 * @brief Clean up the stack.
344 * @param[in] stack The if-feature stack to use.
345 */
Radek Krejci19a96102018-11-15 13:38:09 +0100346static void
347iff_stack_clean(struct iff_stack *stack)
348{
349 stack->size = 0;
350 free(stack->stack);
351}
352
Radek Krejcib56c7502019-02-13 14:19:54 +0100353/**
354 * @brief Store the @ref ifftokens (@p op) on the given position in the 2bits array
355 * (libyang format of the if-feature expression).
356 * @param[in,out] list The 2bits array to modify.
357 * @param[in] op The operand (@ref ifftokens) to store.
358 * @param[in] pos Position (0-based) where to store the given @p op.
359 */
Radek Krejci19a96102018-11-15 13:38:09 +0100360static void
361iff_setop(uint8_t *list, uint8_t op, int pos)
362{
363 uint8_t *item;
364 uint8_t mask = 3;
365
366 assert(pos >= 0);
367 assert(op <= 3); /* max 2 bits */
368
369 item = &list[pos / 4];
370 mask = mask << 2 * (pos % 4);
371 *item = (*item) & ~mask;
372 *item = (*item) | (op << 2 * (pos % 4));
373}
374
Radek Krejcib56c7502019-02-13 14:19:54 +0100375#define LYS_IFF_LP 0x04 /**< Additional, temporary, value of @ref ifftokens: ( */
376#define LYS_IFF_RP 0x08 /**< Additional, temporary, value of @ref ifftokens: ) */
Radek Krejci19a96102018-11-15 13:38:09 +0100377
Radek Krejci0af46292019-01-11 16:02:31 +0100378/**
379 * @brief Find a feature of the given name and referenced in the given module.
380 *
381 * If the compiled schema is available (the schema is implemented), the feature from the compiled schema is
382 * returned. Otherwise, the special array of pre-compiled features is used to search for the feature. Such
383 * features are always disabled (feature from not implemented schema cannot be enabled), but in case the schema
384 * will be made implemented in future (no matter if implicitly via augmenting/deviating it or explicitly via
385 * ly_ctx_module_implement()), the compilation of these feature structure is finished, but the pointers
386 * assigned till that time will be still valid.
387 *
388 * @param[in] mod Module where the feature was referenced (used to resolve prefix of the feature).
389 * @param[in] name Name of the feature including possible prefix.
390 * @param[in] len Length of the string representing the feature identifier in the name variable (mandatory!).
391 * @return Pointer to the feature structure if found, NULL otherwise.
392 */
Radek Krejci19a96102018-11-15 13:38:09 +0100393static struct lysc_feature *
Radek Krejci0af46292019-01-11 16:02:31 +0100394lys_feature_find(struct lys_module *mod, const char *name, size_t len)
Radek Krejci19a96102018-11-15 13:38:09 +0100395{
396 size_t i;
Radek Krejci0af46292019-01-11 16:02:31 +0100397 struct lysc_feature *f, *flist;
Radek Krejci19a96102018-11-15 13:38:09 +0100398
399 for (i = 0; i < len; ++i) {
400 if (name[i] == ':') {
401 /* we have a prefixed feature */
Radek Krejci0af46292019-01-11 16:02:31 +0100402 mod = lys_module_find_prefix(mod, name, i);
Radek Krejci19a96102018-11-15 13:38:09 +0100403 LY_CHECK_RET(!mod, NULL);
404
405 name = &name[i + 1];
406 len = len - i - 1;
407 }
408 }
409
410 /* we have the correct module, get the feature */
Radek Krejci0af46292019-01-11 16:02:31 +0100411 if (mod->implemented) {
412 /* module is implemented so there is already the compiled schema */
413 flist = mod->compiled->features;
414 } else {
415 flist = mod->off_features;
416 }
417 LY_ARRAY_FOR(flist, i) {
418 f = &flist[i];
Radek Krejci19a96102018-11-15 13:38:09 +0100419 if (!strncmp(f->name, name, len) && f->name[len] == '\0') {
420 return f;
421 }
422 }
423
424 return NULL;
425}
426
427static LY_ERR
Radek Krejci0935f412019-08-20 16:15:18 +0200428lys_compile_ext(struct lysc_ctx *ctx, struct lysp_ext_instance *ext_p, struct lysc_ext_instance *ext, void *parent, LYEXT_PARENT parent_type)
Radek Krejci19a96102018-11-15 13:38:09 +0100429{
430 const char *name;
431 unsigned int u;
432 const struct lys_module *mod;
Radek Krejci0935f412019-08-20 16:15:18 +0200433 struct lysc_ext *elist = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +0100434
435 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument);
436 ext->insubstmt = ext_p->insubstmt;
437 ext->insubstmt_index = ext_p->insubstmt_index;
Radek Krejci28681fa2019-09-06 13:08:45 +0200438 ext->module = ctx->mod_def;
Radek Krejci0935f412019-08-20 16:15:18 +0200439 ext->parent = parent;
440 ext->parent_type = parent_type;
Radek Krejci19a96102018-11-15 13:38:09 +0100441
442 /* get module where the extension definition should be placed */
443 for (u = 0; ext_p->name[u] != ':'; ++u);
Radek Krejcie86bf772018-12-14 11:39:53 +0100444 mod = lys_module_find_prefix(ctx->mod_def, ext_p->name, u);
Radek Krejci19a96102018-11-15 13:38:09 +0100445 LY_CHECK_ERR_RET(!mod, LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
446 "Invalid prefix \"%.*s\" used for extension instance identifier.", u, ext_p->name),
447 LY_EVALID);
448 LY_CHECK_ERR_RET(!mod->parsed->extensions,
449 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
450 "Extension instance \"%s\" refers \"%s\" module that does not contain extension definitions.",
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100451 ext_p->name, mod->name),
Radek Krejci19a96102018-11-15 13:38:09 +0100452 LY_EVALID);
453 name = &ext_p->name[u + 1];
Radek Krejci0935f412019-08-20 16:15:18 +0200454
Radek Krejci19a96102018-11-15 13:38:09 +0100455 /* find the extension definition there */
Radek Krejci0935f412019-08-20 16:15:18 +0200456 if (mod->off_extensions) {
457 elist = mod->off_extensions;
458 } else {
459 elist = mod->compiled->extensions;
460 }
461 LY_ARRAY_FOR(elist, u) {
462 if (!strcmp(name, elist[u].name)) {
463 ext->def = &elist[u];
Radek Krejci19a96102018-11-15 13:38:09 +0100464 break;
465 }
466 }
Radek Krejci0935f412019-08-20 16:15:18 +0200467 LY_CHECK_ERR_RET(!ext->def,
468 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
469 "Extension definition of extension instance \"%s\" not found.", ext_p->name),
Radek Krejci19a96102018-11-15 13:38:09 +0100470 LY_EVALID);
Radek Krejci0935f412019-08-20 16:15:18 +0200471
472 if (ext->def->plugin && ext->def->plugin->compile) {
Radek Krejciad5963b2019-09-06 16:03:05 +0200473 lysc_update_path(ctx, ext->parent_type == LYEXT_PAR_NODE ? (struct lysc_node*)ext->parent : NULL, "{extension}");
474 lysc_update_path(ctx, NULL, ext_p->name );
475 if (ext->argument) {
476 lysc_update_path(ctx, (struct lysc_node*)ext, ext->argument);
477 }
Radek Krejci0935f412019-08-20 16:15:18 +0200478 LY_CHECK_RET(ext->def->plugin->compile(ctx, ext_p, ext),LY_EVALID);
Radek Krejciad5963b2019-09-06 16:03:05 +0200479 if (ext->argument) {
480 lysc_update_path(ctx, NULL, NULL);
481 }
482 lysc_update_path(ctx, NULL, NULL);
483 lysc_update_path(ctx, NULL, NULL);
Radek Krejci0935f412019-08-20 16:15:18 +0200484 }
485
486 return LY_SUCCESS;
487}
488
489/**
490 * @brief Fill in the prepared compiled extensions definition structure according to the parsed extension definition.
491 */
492static LY_ERR
493lys_compile_extension(struct lysc_ctx *ctx, struct lysp_ext *ext_p, struct lysc_ext *ext)
494{
495 LY_ERR ret = LY_SUCCESS;
496
497 DUP_STRING(ctx->ctx, ext_p->name, ext->name);
498 DUP_STRING(ctx->ctx, ext_p->argument, ext->argument);
499 ext->module = ctx->mod_def;
500 COMPILE_EXTS_GOTO(ctx, ext_p->exts, ext->exts, ext, LYEXT_PAR_EXT, ret, done);
501
502done:
503 return ret;
504}
505
506/**
507 * @brief Link the extensions definitions with the available extension plugins.
508 *
509 * This is done only in the compiled (implemented) module. Extensions of a non-implemented modules
510 * are not connected with even available extension plugins.
511 *
512 * @param[in] extensions List of extensions to be processed ([sized array](@ref sizedarrays)).
513 */
514static void
515lys_compile_extension_plugins(struct lysc_ext *extensions)
516{
517 unsigned int u;
518
519 LY_ARRAY_FOR(extensions, u) {
520 extensions[u].plugin = lyext_get_plugin(&extensions[u]);
521 }
522}
523
524LY_ERR
525lys_extension_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module,
526 struct lysp_ext *extensions_p, struct lysc_ext **extensions)
527{
528 unsigned int offset = 0, u;
529 struct lysc_ctx context = {0};
530
531 assert(ctx_sc || ctx);
532
533 if (!ctx_sc) {
534 context.ctx = ctx;
535 context.mod = module;
536 context.path_len = 1;
537 context.path[0] = '/';
538 ctx_sc = &context;
539 }
540
541 if (!extensions_p) {
542 return LY_SUCCESS;
543 }
544 if (*extensions) {
545 offset = LY_ARRAY_SIZE(*extensions);
546 }
547
548 lysc_update_path(ctx_sc, NULL, "{extension}");
549 LY_ARRAY_CREATE_RET(ctx_sc->ctx, *extensions, LY_ARRAY_SIZE(extensions_p), LY_EMEM);
550 LY_ARRAY_FOR(extensions_p, u) {
551 lysc_update_path(ctx_sc, NULL, extensions_p[u].name);
552 LY_ARRAY_INCREMENT(*extensions);
553 COMPILE_CHECK_UNIQUENESS(ctx_sc, *extensions, name, &(*extensions)[offset + u], "extension", extensions_p[u].name);
554 LY_CHECK_RET(lys_compile_extension(ctx_sc, &extensions_p[u], &(*extensions)[offset + u]));
555 lysc_update_path(ctx_sc, NULL, NULL);
556 }
557 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +0100558
559 return LY_SUCCESS;
560}
561
Radek Krejcib56c7502019-02-13 14:19:54 +0100562/**
563 * @brief Compile information from the if-feature statement
564 * @param[in] ctx Compile context.
565 * @param[in] value The if-feature argument to process. It is pointer-to-pointer-to-char just to unify the compile functions.
Radek Krejcib56c7502019-02-13 14:19:54 +0100566 * @param[in,out] iff Prepared (empty) compiled if-feature structure to fill.
567 * @return LY_ERR value.
568 */
Radek Krejci19a96102018-11-15 13:38:09 +0100569static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200570lys_compile_iffeature(struct lysc_ctx *ctx, const char **value, struct lysc_iffeature *iff)
Radek Krejci19a96102018-11-15 13:38:09 +0100571{
572 const char *c = *value;
573 int r, rc = EXIT_FAILURE;
574 int i, j, last_not, checkversion = 0;
575 unsigned int f_size = 0, expr_size = 0, f_exp = 1;
576 uint8_t op;
577 struct iff_stack stack = {0, 0, NULL};
578 struct lysc_feature *f;
579
580 assert(c);
581
582 /* pre-parse the expression to get sizes for arrays, also do some syntax checks of the expression */
583 for (i = j = last_not = 0; c[i]; i++) {
584 if (c[i] == '(') {
585 j++;
586 checkversion = 1;
587 continue;
588 } else if (c[i] == ')') {
589 j--;
590 continue;
591 } else if (isspace(c[i])) {
592 checkversion = 1;
593 continue;
594 }
595
596 if (!strncmp(&c[i], "not", r = 3) || !strncmp(&c[i], "and", r = 3) || !strncmp(&c[i], "or", r = 2)) {
Radek Krejci6788abc2019-06-14 13:56:49 +0200597 int sp;
598 for(sp = 0; c[i + r + sp] && isspace(c[i + r + sp]); sp++);
599 if (c[i + r + sp] == '\0') {
Radek Krejci19a96102018-11-15 13:38:09 +0100600 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
601 "Invalid value \"%s\" of if-feature - unexpected end of expression.", *value);
602 return LY_EVALID;
603 } else if (!isspace(c[i + r])) {
604 /* feature name starting with the not/and/or */
605 last_not = 0;
606 f_size++;
607 } else if (c[i] == 'n') { /* not operation */
608 if (last_not) {
609 /* double not */
610 expr_size = expr_size - 2;
611 last_not = 0;
612 } else {
613 last_not = 1;
614 }
615 } else { /* and, or */
Radek Krejci6788abc2019-06-14 13:56:49 +0200616 if (f_exp != f_size) {
617 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
618 "Invalid value \"%s\" of if-feature - missing feature/expression before \"%.*s\" operation.", *value, r, &c[i]);
619 return LY_EVALID;
620 }
Radek Krejci19a96102018-11-15 13:38:09 +0100621 f_exp++;
Radek Krejci6788abc2019-06-14 13:56:49 +0200622
Radek Krejci19a96102018-11-15 13:38:09 +0100623 /* not a not operation */
624 last_not = 0;
625 }
626 i += r;
627 } else {
628 f_size++;
629 last_not = 0;
630 }
631 expr_size++;
632
633 while (!isspace(c[i])) {
Radek Krejci6788abc2019-06-14 13:56:49 +0200634 if (!c[i] || c[i] == ')' || c[i] == '(') {
Radek Krejci19a96102018-11-15 13:38:09 +0100635 i--;
636 break;
637 }
638 i++;
639 }
640 }
Radek Krejci6788abc2019-06-14 13:56:49 +0200641 if (j) {
Radek Krejci19a96102018-11-15 13:38:09 +0100642 /* not matching count of ( and ) */
643 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
644 "Invalid value \"%s\" of if-feature - non-matching opening and closing parentheses.", *value);
645 return LY_EVALID;
646 }
Radek Krejci6788abc2019-06-14 13:56:49 +0200647 if (f_exp != f_size) {
648 /* features do not match the needed arguments for the logical operations */
649 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
650 "Invalid value \"%s\" of if-feature - number of features in expression does not match "
651 "the required number of operands for the operations.", *value);
652 return LY_EVALID;
653 }
Radek Krejci19a96102018-11-15 13:38:09 +0100654
655 if (checkversion || expr_size > 1) {
656 /* check that we have 1.1 module */
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100657 if (ctx->mod_def->version != LYS_VERSION_1_1) {
Radek Krejci19a96102018-11-15 13:38:09 +0100658 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
659 "Invalid value \"%s\" of if-feature - YANG 1.1 expression in YANG 1.0 module.", *value);
660 return LY_EVALID;
661 }
662 }
663
664 /* allocate the memory */
665 LY_ARRAY_CREATE_RET(ctx->ctx, iff->features, f_size, LY_EMEM);
666 iff->expr = calloc((j = (expr_size / 4) + ((expr_size % 4) ? 1 : 0)), sizeof *iff->expr);
667 stack.stack = malloc(expr_size * sizeof *stack.stack);
668 LY_CHECK_ERR_GOTO(!stack.stack || !iff->expr, LOGMEM(ctx->ctx), error);
669
670 stack.size = expr_size;
671 f_size--; expr_size--; /* used as indexes from now */
672
673 for (i--; i >= 0; i--) {
674 if (c[i] == ')') {
675 /* push it on stack */
676 iff_stack_push(&stack, LYS_IFF_RP);
677 continue;
678 } else if (c[i] == '(') {
679 /* pop from the stack into result all operators until ) */
680 while((op = iff_stack_pop(&stack)) != LYS_IFF_RP) {
681 iff_setop(iff->expr, op, expr_size--);
682 }
683 continue;
684 } else if (isspace(c[i])) {
685 continue;
686 }
687
688 /* end of operator or operand -> find beginning and get what is it */
689 j = i + 1;
690 while (i >= 0 && !isspace(c[i]) && c[i] != '(') {
691 i--;
692 }
693 i++; /* go back by one step */
694
695 if (!strncmp(&c[i], "not", 3) && isspace(c[i + 3])) {
696 if (stack.index && stack.stack[stack.index - 1] == LYS_IFF_NOT) {
697 /* double not */
698 iff_stack_pop(&stack);
699 } else {
700 /* not has the highest priority, so do not pop from the stack
701 * as in case of AND and OR */
702 iff_stack_push(&stack, LYS_IFF_NOT);
703 }
704 } else if (!strncmp(&c[i], "and", 3) && isspace(c[i + 3])) {
705 /* as for OR - pop from the stack all operators with the same or higher
706 * priority and store them to the result, then push the AND to the stack */
707 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_AND) {
708 op = iff_stack_pop(&stack);
709 iff_setop(iff->expr, op, expr_size--);
710 }
711 iff_stack_push(&stack, LYS_IFF_AND);
712 } else if (!strncmp(&c[i], "or", 2) && isspace(c[i + 2])) {
713 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_OR) {
714 op = iff_stack_pop(&stack);
715 iff_setop(iff->expr, op, expr_size--);
716 }
717 iff_stack_push(&stack, LYS_IFF_OR);
718 } else {
719 /* feature name, length is j - i */
720
721 /* add it to the expression */
722 iff_setop(iff->expr, LYS_IFF_F, expr_size--);
723
724 /* now get the link to the feature definition */
Radek Krejci0af46292019-01-11 16:02:31 +0100725 f = lys_feature_find(ctx->mod_def, &c[i], j - i);
726 LY_CHECK_ERR_GOTO(!f, LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
727 "Invalid value \"%s\" of if-feature - unable to find feature \"%.*s\".", *value, j - i, &c[i]);
728 rc = LY_EVALID, error)
Radek Krejci19a96102018-11-15 13:38:09 +0100729 iff->features[f_size] = f;
730 LY_ARRAY_INCREMENT(iff->features);
731 f_size--;
732 }
733 }
734 while (stack.index) {
735 op = iff_stack_pop(&stack);
736 iff_setop(iff->expr, op, expr_size--);
737 }
738
739 if (++expr_size || ++f_size) {
740 /* not all expected operators and operands found */
741 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
742 "Invalid value \"%s\" of if-feature - processing error.", *value);
743 rc = LY_EINT;
744 } else {
745 rc = LY_SUCCESS;
746 }
747
748error:
749 /* cleanup */
750 iff_stack_clean(&stack);
751
752 return rc;
753}
754
Radek Krejcib56c7502019-02-13 14:19:54 +0100755/**
756 * @brief Compile information from the when statement
757 * @param[in] ctx Compile context.
758 * @param[in] when_p The parsed when statement structure.
Radek Krejcib56c7502019-02-13 14:19:54 +0100759 * @param[out] when Pointer where to store pointer to the created compiled when structure.
760 * @return LY_ERR value.
761 */
Radek Krejci19a96102018-11-15 13:38:09 +0100762static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200763lys_compile_when(struct lysc_ctx *ctx, struct lysp_when *when_p, struct lysc_when **when)
Radek Krejci19a96102018-11-15 13:38:09 +0100764{
Radek Krejci19a96102018-11-15 13:38:09 +0100765 LY_ERR ret = LY_SUCCESS;
766
Radek Krejci00b874b2019-02-12 10:54:50 +0100767 *when = calloc(1, sizeof **when);
768 (*when)->refcount = 1;
769 (*when)->cond = lyxp_expr_parse(ctx->ctx, when_p->cond);
770 DUP_STRING(ctx->ctx, when_p->dsc, (*when)->dsc);
771 DUP_STRING(ctx->ctx, when_p->ref, (*when)->ref);
772 LY_CHECK_ERR_GOTO(!(*when)->cond, ret = ly_errcode(ctx->ctx), done);
Radek Krejci0935f412019-08-20 16:15:18 +0200773 COMPILE_EXTS_GOTO(ctx, when_p->exts, (*when)->exts, (*when), LYEXT_PAR_WHEN, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100774
775done:
776 return ret;
777}
778
Radek Krejcib56c7502019-02-13 14:19:54 +0100779/**
780 * @brief Compile information from the must statement
781 * @param[in] ctx Compile context.
782 * @param[in] must_p The parsed must statement structure.
Radek Krejcib56c7502019-02-13 14:19:54 +0100783 * @param[in,out] must Prepared (empty) compiled must structure to fill.
784 * @return LY_ERR value.
785 */
Radek Krejci19a96102018-11-15 13:38:09 +0100786static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200787lys_compile_must(struct lysc_ctx *ctx, struct lysp_restr *must_p, struct lysc_must *must)
Radek Krejci19a96102018-11-15 13:38:09 +0100788{
Radek Krejci19a96102018-11-15 13:38:09 +0100789 LY_ERR ret = LY_SUCCESS;
790
791 must->cond = lyxp_expr_parse(ctx->ctx, must_p->arg);
792 LY_CHECK_ERR_GOTO(!must->cond, ret = ly_errcode(ctx->ctx), done);
Radek Krejci462cf252019-07-24 09:49:08 +0200793 must->module = ctx->mod_def;
Radek Krejci19a96102018-11-15 13:38:09 +0100794 DUP_STRING(ctx->ctx, must_p->eapptag, must->eapptag);
795 DUP_STRING(ctx->ctx, must_p->emsg, must->emsg);
Radek Krejcic8b31002019-01-08 10:24:45 +0100796 DUP_STRING(ctx->ctx, must_p->dsc, must->dsc);
797 DUP_STRING(ctx->ctx, must_p->ref, must->ref);
Radek Krejci0935f412019-08-20 16:15:18 +0200798 COMPILE_EXTS_GOTO(ctx, must_p->exts, must->exts, must, LYEXT_PAR_MUST, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100799
800done:
801 return ret;
802}
803
Radek Krejcib56c7502019-02-13 14:19:54 +0100804/**
805 * @brief Compile information from the import statement
806 * @param[in] ctx Compile context.
807 * @param[in] imp_p The parsed import statement structure.
Radek Krejcib56c7502019-02-13 14:19:54 +0100808 * @param[in,out] imp Prepared (empty) compiled import structure to fill.
809 * @return LY_ERR value.
810 */
Radek Krejci19a96102018-11-15 13:38:09 +0100811static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200812lys_compile_import(struct lysc_ctx *ctx, struct lysp_import *imp_p, struct lysc_import *imp)
Radek Krejci19a96102018-11-15 13:38:09 +0100813{
Radek Krejci19a96102018-11-15 13:38:09 +0100814 struct lys_module *mod = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +0100815 LY_ERR ret = LY_SUCCESS;
816
817 DUP_STRING(ctx->ctx, imp_p->prefix, imp->prefix);
Radek Krejci0935f412019-08-20 16:15:18 +0200818 COMPILE_EXTS_GOTO(ctx, imp_p->exts, imp->exts, imp, LYEXT_PAR_IMPORT, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100819 imp->module = imp_p->module;
820
Radek Krejci7f2a5362018-11-28 13:05:37 +0100821 /* make sure that we have the parsed version (lysp_) of the imported module to import groupings or typedefs.
822 * The compiled version is needed only for augments, deviates and leafrefs, so they are checked (and added,
Radek Krejci0e5d8382018-11-28 16:37:53 +0100823 * if needed) when these nodes are finally being instantiated and validated at the end of schema compilation. */
Radek Krejci19a96102018-11-15 13:38:09 +0100824 if (!imp->module->parsed) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100825 /* try to use filepath if present */
826 if (imp->module->filepath) {
827 mod = (struct lys_module*)lys_parse_path(ctx->ctx, imp->module->filepath,
828 !strcmp(&imp->module->filepath[strlen(imp->module->filepath - 4)], ".yin") ? LYS_IN_YIN : LYS_IN_YANG);
Radek Krejci19a96102018-11-15 13:38:09 +0100829 if (mod != imp->module) {
830 LOGERR(ctx->ctx, LY_EINT, "Filepath \"%s\" of the module \"%s\" does not match.",
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100831 imp->module->filepath, imp->module->name);
Radek Krejci19a96102018-11-15 13:38:09 +0100832 mod = NULL;
833 }
834 }
835 if (!mod) {
Radek Krejci0af46292019-01-11 16:02:31 +0100836 if (lysp_load_module(ctx->ctx, imp->module->name, imp->module->revision, 0, 1, &mod)) {
Radek Krejci19a96102018-11-15 13:38:09 +0100837 LOGERR(ctx->ctx, LY_ENOTFOUND, "Unable to reload \"%s\" module to import it into \"%s\", source data not found.",
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100838 imp->module->name, ctx->mod->name);
Radek Krejci19a96102018-11-15 13:38:09 +0100839 return LY_ENOTFOUND;
840 }
841 }
Radek Krejci19a96102018-11-15 13:38:09 +0100842 }
843
844done:
845 return ret;
846}
847
Radek Krejcib56c7502019-02-13 14:19:54 +0100848/**
849 * @brief Compile information from the identity statement
850 *
851 * The backlinks to the identities derived from this one are supposed to be filled later via lys_compile_identity_bases().
852 *
853 * @param[in] ctx Compile context.
854 * @param[in] ident_p The parsed identity statement structure.
Radek Krejcib56c7502019-02-13 14:19:54 +0100855 * @param[in] idents List of so far compiled identities to check the name uniqueness.
856 * @param[in,out] ident Prepared (empty) compiled identity structure to fill.
857 * @return LY_ERR value.
858 */
Radek Krejci19a96102018-11-15 13:38:09 +0100859static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +0200860lys_compile_identity(struct lysc_ctx *ctx, struct lysp_ident *ident_p, struct lysc_ident *idents, struct lysc_ident *ident)
Radek Krejci19a96102018-11-15 13:38:09 +0100861{
862 unsigned int u;
863 LY_ERR ret = LY_SUCCESS;
864
Radek Krejci327de162019-06-14 12:52:07 +0200865 lysc_update_path(ctx, NULL, ident_p->name);
866
Radek Krejcid05cbd92018-12-05 14:26:40 +0100867 COMPILE_CHECK_UNIQUENESS(ctx, idents, name, ident, "identity", ident_p->name);
Radek Krejci19a96102018-11-15 13:38:09 +0100868 DUP_STRING(ctx->ctx, ident_p->name, ident->name);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200869 DUP_STRING(ctx->ctx, ident_p->dsc, ident->dsc);
870 DUP_STRING(ctx->ctx, ident_p->ref, ident->ref);
Radek Krejci693262f2019-04-29 15:23:20 +0200871 ident->module = ctx->mod;
Radek Krejciec4da802019-05-02 13:02:41 +0200872 COMPILE_ARRAY_GOTO(ctx, ident_p->iffeatures, ident->iffeatures, u, lys_compile_iffeature, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100873 /* backlings (derived) can be added no sooner than when all the identities in the current module are present */
Radek Krejci0935f412019-08-20 16:15:18 +0200874 COMPILE_EXTS_GOTO(ctx, ident_p->exts, ident->exts, ident, LYEXT_PAR_IDENT, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +0100875 ident->flags = ident_p->flags;
876
Radek Krejci327de162019-06-14 12:52:07 +0200877 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +0100878done:
879 return ret;
880}
881
Radek Krejcib56c7502019-02-13 14:19:54 +0100882/**
883 * @brief Check circular dependency of identities - identity MUST NOT reference itself (via their base statement).
884 *
885 * The function works in the same way as lys_compile_feature_circular_check() with different structures and error messages.
886 *
887 * @param[in] ctx Compile context for logging.
888 * @param[in] ident The base identity (its derived list is being extended by the identity being currently processed).
889 * @param[in] derived The list of derived identities of the identity being currently processed (not the one provided as @p ident)
890 * @return LY_SUCCESS if everything is ok.
891 * @return LY_EVALID if the identity is derived from itself.
892 */
Radek Krejci38222632019-02-12 16:55:05 +0100893static LY_ERR
894lys_compile_identity_circular_check(struct lysc_ctx *ctx, struct lysc_ident *ident, struct lysc_ident **derived)
895{
896 LY_ERR ret = LY_EVALID;
897 unsigned int u, v;
898 struct ly_set recursion = {0};
899 struct lysc_ident *drv;
900
901 if (!derived) {
902 return LY_SUCCESS;
903 }
904
905 for (u = 0; u < LY_ARRAY_SIZE(derived); ++u) {
906 if (ident == derived[u]) {
907 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
908 "Identity \"%s\" is indirectly derived from itself.", ident->name);
909 goto cleanup;
910 }
911 ly_set_add(&recursion, derived[u], 0);
912 }
913
914 for (v = 0; v < recursion.count; ++v) {
915 drv = recursion.objs[v];
916 if (!drv->derived) {
917 continue;
918 }
919 for (u = 0; u < LY_ARRAY_SIZE(drv->derived); ++u) {
920 if (ident == drv->derived[u]) {
921 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
922 "Identity \"%s\" is indirectly derived from itself.", ident->name);
923 goto cleanup;
924 }
925 ly_set_add(&recursion, drv->derived[u], 0);
926 }
927 }
928 ret = LY_SUCCESS;
929
930cleanup:
931 ly_set_erase(&recursion, NULL);
932 return ret;
933}
934
Radek Krejcia3045382018-11-22 14:30:31 +0100935/**
936 * @brief Find and process the referenced base identities from another identity or identityref
937 *
Radek Krejciaca74032019-06-04 08:53:06 +0200938 * For bases in identity set backlinks to them from the base identities. For identityref, store
Radek Krejcia3045382018-11-22 14:30:31 +0100939 * the array of pointers to the base identities. So one of the ident or bases parameter must be set
940 * to distinguish these two use cases.
941 *
942 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
943 * @param[in] bases_p Array of names (including prefix if necessary) of base identities.
944 * @param[in] ident Referencing identity to work with.
945 * @param[in] bases Array of bases of identityref to fill in.
946 * @return LY_ERR value.
947 */
Radek Krejci19a96102018-11-15 13:38:09 +0100948static LY_ERR
Radek Krejci555cb5b2018-11-16 14:54:33 +0100949lys_compile_identity_bases(struct lysc_ctx *ctx, const char **bases_p, struct lysc_ident *ident, struct lysc_ident ***bases)
Radek Krejci19a96102018-11-15 13:38:09 +0100950{
Radek Krejci555cb5b2018-11-16 14:54:33 +0100951 unsigned int u, v;
Radek Krejci19a96102018-11-15 13:38:09 +0100952 const char *s, *name;
Radek Krejcie86bf772018-12-14 11:39:53 +0100953 struct lys_module *mod;
Radek Krejci555cb5b2018-11-16 14:54:33 +0100954 struct lysc_ident **idref;
955
956 assert(ident || bases);
957
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100958 if (LY_ARRAY_SIZE(bases_p) > 1 && ctx->mod_def->version < 2) {
Radek Krejci555cb5b2018-11-16 14:54:33 +0100959 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
960 "Multiple bases in %s are allowed only in YANG 1.1 modules.", ident ? "identity" : "identityref type");
961 return LY_EVALID;
962 }
963
964 for (u = 0; u < LY_ARRAY_SIZE(bases_p); ++u) {
965 s = strchr(bases_p[u], ':');
966 if (s) {
967 /* prefixed identity */
968 name = &s[1];
Radek Krejcie86bf772018-12-14 11:39:53 +0100969 mod = lys_module_find_prefix(ctx->mod_def, bases_p[u], s - bases_p[u]);
Radek Krejci555cb5b2018-11-16 14:54:33 +0100970 } else {
971 name = bases_p[u];
Radek Krejcie86bf772018-12-14 11:39:53 +0100972 mod = ctx->mod_def;
Radek Krejci555cb5b2018-11-16 14:54:33 +0100973 }
974 if (!mod) {
975 if (ident) {
976 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
977 "Invalid prefix used for base (%s) of identity \"%s\".", bases_p[u], ident->name);
978 } else {
979 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
980 "Invalid prefix used for base (%s) of identityref.", bases_p[u]);
981 }
982 return LY_EVALID;
983 }
984 idref = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +0100985 if (mod->compiled && mod->compiled->identities) {
986 for (v = 0; v < LY_ARRAY_SIZE(mod->compiled->identities); ++v) {
987 if (!strcmp(name, mod->compiled->identities[v].name)) {
Radek Krejci555cb5b2018-11-16 14:54:33 +0100988 if (ident) {
Radek Krejci38222632019-02-12 16:55:05 +0100989 if (ident == &mod->compiled->identities[v]) {
990 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
991 "Identity \"%s\" is derived from itself.", ident->name);
992 return LY_EVALID;
993 }
994 LY_CHECK_RET(lys_compile_identity_circular_check(ctx, &mod->compiled->identities[v], ident->derived));
Radek Krejci555cb5b2018-11-16 14:54:33 +0100995 /* we have match! store the backlink */
Radek Krejcie86bf772018-12-14 11:39:53 +0100996 LY_ARRAY_NEW_RET(ctx->ctx, mod->compiled->identities[v].derived, idref, LY_EMEM);
Radek Krejci555cb5b2018-11-16 14:54:33 +0100997 *idref = ident;
998 } else {
999 /* we have match! store the found identity */
1000 LY_ARRAY_NEW_RET(ctx->ctx, *bases, idref, LY_EMEM);
Radek Krejcie86bf772018-12-14 11:39:53 +01001001 *idref = &mod->compiled->identities[v];
Radek Krejci555cb5b2018-11-16 14:54:33 +01001002 }
1003 break;
1004 }
1005 }
1006 }
1007 if (!idref || !(*idref)) {
1008 if (ident) {
1009 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1010 "Unable to find base (%s) of identity \"%s\".", bases_p[u], ident->name);
1011 } else {
1012 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1013 "Unable to find base (%s) of identityref.", bases_p[u]);
1014 }
1015 return LY_EVALID;
1016 }
1017 }
1018 return LY_SUCCESS;
1019}
1020
Radek Krejcia3045382018-11-22 14:30:31 +01001021/**
1022 * @brief For the given array of identities, set the backlinks from all their base identities.
1023 * @param[in] ctx Compile context, not only for logging but also to get the current module to resolve prefixes.
1024 * @param[in] idents_p Array of identities definitions from the parsed schema structure.
1025 * @param[in] idents Array of referencing identities to which the backlinks are supposed to be set.
1026 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
1027 */
Radek Krejci555cb5b2018-11-16 14:54:33 +01001028static LY_ERR
1029lys_compile_identities_derived(struct lysc_ctx *ctx, struct lysp_ident *idents_p, struct lysc_ident *idents)
1030{
1031 unsigned int i;
Radek Krejci19a96102018-11-15 13:38:09 +01001032
1033 for (i = 0; i < LY_ARRAY_SIZE(idents_p); ++i) {
1034 if (!idents_p[i].bases) {
1035 continue;
1036 }
Radek Krejci327de162019-06-14 12:52:07 +02001037 lysc_update_path(ctx, NULL, idents[i].name);
Radek Krejci555cb5b2018-11-16 14:54:33 +01001038 LY_CHECK_RET(lys_compile_identity_bases(ctx, idents_p[i].bases, &idents[i], NULL));
Radek Krejci327de162019-06-14 12:52:07 +02001039 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01001040 }
1041 return LY_SUCCESS;
1042}
1043
Radek Krejci0af46292019-01-11 16:02:31 +01001044LY_ERR
Radek Krejci327de162019-06-14 12:52:07 +02001045lys_feature_precompile(struct lysc_ctx *ctx_sc, struct ly_ctx *ctx, struct lys_module *module, struct lysp_feature *features_p, struct lysc_feature **features)
Radek Krejci0af46292019-01-11 16:02:31 +01001046{
1047 unsigned int offset = 0, u;
1048 struct lysc_ctx context = {0};
1049
Radek Krejci327de162019-06-14 12:52:07 +02001050 assert(ctx_sc || ctx);
1051
1052 if (!ctx_sc) {
1053 context.ctx = ctx;
1054 context.mod = module;
1055 context.path_len = 1;
1056 context.path[0] = '/';
1057 ctx_sc = &context;
1058 }
Radek Krejci0af46292019-01-11 16:02:31 +01001059
1060 if (!features_p) {
1061 return LY_SUCCESS;
1062 }
1063 if (*features) {
1064 offset = LY_ARRAY_SIZE(*features);
1065 }
1066
Radek Krejci327de162019-06-14 12:52:07 +02001067 lysc_update_path(ctx_sc, NULL, "{feature}");
1068 LY_ARRAY_CREATE_RET(ctx_sc->ctx, *features, LY_ARRAY_SIZE(features_p), LY_EMEM);
Radek Krejci0af46292019-01-11 16:02:31 +01001069 LY_ARRAY_FOR(features_p, u) {
Radek Krejci327de162019-06-14 12:52:07 +02001070 lysc_update_path(ctx_sc, NULL, features_p[u].name);
1071
Radek Krejci0af46292019-01-11 16:02:31 +01001072 LY_ARRAY_INCREMENT(*features);
Radek Krejci327de162019-06-14 12:52:07 +02001073 COMPILE_CHECK_UNIQUENESS(ctx_sc, *features, name, &(*features)[offset + u], "feature", features_p[u].name);
1074 DUP_STRING(ctx_sc->ctx, features_p[u].name, (*features)[offset + u].name);
1075 DUP_STRING(ctx_sc->ctx, features_p[u].dsc, (*features)[offset + u].dsc);
1076 DUP_STRING(ctx_sc->ctx, features_p[u].ref, (*features)[offset + u].ref);
Radek Krejci0af46292019-01-11 16:02:31 +01001077 (*features)[offset + u].flags = features_p[u].flags;
Radek Krejci327de162019-06-14 12:52:07 +02001078 (*features)[offset + u].module = ctx_sc->mod;
1079
1080 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001081 }
Radek Krejci327de162019-06-14 12:52:07 +02001082 lysc_update_path(ctx_sc, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001083
1084 return LY_SUCCESS;
1085}
1086
Radek Krejcia3045382018-11-22 14:30:31 +01001087/**
Radek Krejci09a1fc52019-02-13 10:55:17 +01001088 * @brief Check circular dependency of features - feature MUST NOT reference itself (via their if-feature statement).
Radek Krejcib56c7502019-02-13 14:19:54 +01001089 *
1090 * The function works in the same way as lys_compile_identity_circular_check() with different structures and error messages.
1091 *
Radek Krejci09a1fc52019-02-13 10:55:17 +01001092 * @param[in] ctx Compile context for logging.
Radek Krejcib56c7502019-02-13 14:19:54 +01001093 * @param[in] feature The feature referenced in if-feature statement (its depfeatures list is being extended by the feature
1094 * being currently processed).
1095 * @param[in] depfeatures The list of depending features of the feature being currently processed (not the one provided as @p feature)
Radek Krejci09a1fc52019-02-13 10:55:17 +01001096 * @return LY_SUCCESS if everything is ok.
1097 * @return LY_EVALID if the feature references indirectly itself.
1098 */
1099static LY_ERR
1100lys_compile_feature_circular_check(struct lysc_ctx *ctx, struct lysc_feature *feature, struct lysc_feature **depfeatures)
1101{
1102 LY_ERR ret = LY_EVALID;
1103 unsigned int u, v;
1104 struct ly_set recursion = {0};
1105 struct lysc_feature *drv;
1106
1107 if (!depfeatures) {
1108 return LY_SUCCESS;
1109 }
1110
1111 for (u = 0; u < LY_ARRAY_SIZE(depfeatures); ++u) {
1112 if (feature == depfeatures[u]) {
1113 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1114 "Feature \"%s\" is indirectly referenced from itself.", feature->name);
1115 goto cleanup;
1116 }
1117 ly_set_add(&recursion, depfeatures[u], 0);
1118 }
1119
1120 for (v = 0; v < recursion.count; ++v) {
1121 drv = recursion.objs[v];
1122 if (!drv->depfeatures) {
1123 continue;
1124 }
1125 for (u = 0; u < LY_ARRAY_SIZE(drv->depfeatures); ++u) {
1126 if (feature == drv->depfeatures[u]) {
1127 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1128 "Feature \"%s\" is indirectly referenced from itself.", feature->name);
1129 goto cleanup;
1130 }
1131 ly_set_add(&recursion, drv->depfeatures[u], 0);
1132 }
1133 }
1134 ret = LY_SUCCESS;
1135
1136cleanup:
1137 ly_set_erase(&recursion, NULL);
1138 return ret;
1139}
1140
1141/**
Radek Krejci0af46292019-01-11 16:02:31 +01001142 * @brief Create pre-compiled features array.
1143 *
1144 * See lys_feature_precompile() for more details.
1145 *
Radek Krejcia3045382018-11-22 14:30:31 +01001146 * @param[in] ctx Compile context.
1147 * @param[in] feature_p Parsed feature definition to compile.
Radek Krejci0af46292019-01-11 16:02:31 +01001148 * @param[in,out] features List of already (pre)compiled features to find the corresponding precompiled feature structure.
Radek Krejcia3045382018-11-22 14:30:31 +01001149 * @return LY_ERR value.
1150 */
Radek Krejci19a96102018-11-15 13:38:09 +01001151static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02001152lys_feature_precompile_finish(struct lysc_ctx *ctx, struct lysp_feature *feature_p, struct lysc_feature *features)
Radek Krejci19a96102018-11-15 13:38:09 +01001153{
Radek Krejci0af46292019-01-11 16:02:31 +01001154 unsigned int u, v, x;
1155 struct lysc_feature *feature, **df;
Radek Krejci19a96102018-11-15 13:38:09 +01001156 LY_ERR ret = LY_SUCCESS;
Radek Krejci19a96102018-11-15 13:38:09 +01001157
Radek Krejci327de162019-06-14 12:52:07 +02001158
Radek Krejci0af46292019-01-11 16:02:31 +01001159 /* find the preprecompiled feature */
1160 LY_ARRAY_FOR(features, x) {
1161 if (strcmp(features[x].name, feature_p->name)) {
1162 continue;
1163 }
1164 feature = &features[x];
Radek Krejci327de162019-06-14 12:52:07 +02001165 lysc_update_path(ctx, NULL, "{feature}");
1166 lysc_update_path(ctx, NULL, feature_p->name);
Radek Krejci19a96102018-11-15 13:38:09 +01001167
Radek Krejci0af46292019-01-11 16:02:31 +01001168 /* finish compilation started in lys_feature_precompile() */
Radek Krejci0935f412019-08-20 16:15:18 +02001169 COMPILE_EXTS_GOTO(ctx, feature_p->exts, feature->exts, feature, LYEXT_PAR_FEATURE, ret, done);
Radek Krejciec4da802019-05-02 13:02:41 +02001170 COMPILE_ARRAY_GOTO(ctx, feature_p->iffeatures, feature->iffeatures, u, lys_compile_iffeature, ret, done);
Radek Krejci0af46292019-01-11 16:02:31 +01001171 if (feature->iffeatures) {
1172 for (u = 0; u < LY_ARRAY_SIZE(feature->iffeatures); ++u) {
1173 if (feature->iffeatures[u].features) {
1174 for (v = 0; v < LY_ARRAY_SIZE(feature->iffeatures[u].features); ++v) {
Radek Krejci09a1fc52019-02-13 10:55:17 +01001175 /* check for circular dependency - direct reference first,... */
1176 if (feature == feature->iffeatures[u].features[v]) {
1177 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
1178 "Feature \"%s\" is referenced from itself.", feature->name);
1179 return LY_EVALID;
1180 }
1181 /* ... and indirect circular reference */
1182 LY_CHECK_RET(lys_compile_feature_circular_check(ctx, feature->iffeatures[u].features[v], feature->depfeatures));
1183
Radek Krejci0af46292019-01-11 16:02:31 +01001184 /* add itself into the dependants list */
1185 LY_ARRAY_NEW_RET(ctx->ctx, feature->iffeatures[u].features[v]->depfeatures, df, LY_EMEM);
1186 *df = feature;
1187 }
Radek Krejci19a96102018-11-15 13:38:09 +01001188 }
Radek Krejci19a96102018-11-15 13:38:09 +01001189 }
1190 }
Radek Krejci327de162019-06-14 12:52:07 +02001191 lysc_update_path(ctx, NULL, NULL);
1192 lysc_update_path(ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01001193 done:
1194 return ret;
Radek Krejci19a96102018-11-15 13:38:09 +01001195 }
Radek Krejci0af46292019-01-11 16:02:31 +01001196
1197 LOGINT(ctx->ctx);
1198 return LY_EINT;
Radek Krejci19a96102018-11-15 13:38:09 +01001199}
1200
Radek Krejcib56c7502019-02-13 14:19:54 +01001201/**
1202 * @brief Revert compiled list of features back to the precompiled state.
1203 *
1204 * Function is needed in case the compilation failed and the schema is expected to revert back to the non-compiled status.
1205 * The features are supposed to be stored again as off_features in ::lys_module structure.
1206 *
1207 * @param[in] ctx Compilation context.
1208 * @param[in] mod The module structure still holding the compiled (but possibly not finished, only the list of compiled features is taken) schema
1209 * and supposed to hold the off_features list.
1210 */
Radek Krejci95710c92019-02-11 15:49:55 +01001211static void
1212lys_feature_precompile_revert(struct lysc_ctx *ctx, struct lys_module *mod)
1213{
1214 unsigned int u, v;
1215
1216 /* keep the off_features list until the complete lys_module is freed */
1217 mod->off_features = mod->compiled->features;
1218 mod->compiled->features = NULL;
1219
1220 /* in the off_features list, remove all the parts (from finished compiling process)
1221 * which may points into the data being freed here */
1222 LY_ARRAY_FOR(mod->off_features, u) {
1223 LY_ARRAY_FOR(mod->off_features[u].iffeatures, v) {
1224 lysc_iffeature_free(ctx->ctx, &mod->off_features[u].iffeatures[v]);
1225 }
1226 LY_ARRAY_FREE(mod->off_features[u].iffeatures);
1227 mod->off_features[u].iffeatures = NULL;
1228
1229 LY_ARRAY_FOR(mod->off_features[u].exts, v) {
1230 lysc_ext_instance_free(ctx->ctx, &(mod->off_features[u].exts)[v]);
1231 }
1232 LY_ARRAY_FREE(mod->off_features[u].exts);
1233 mod->off_features[u].exts = NULL;
1234 }
1235}
1236
Radek Krejcia3045382018-11-22 14:30:31 +01001237/**
1238 * @brief Validate and normalize numeric value from a range definition.
1239 * @param[in] ctx Compile context.
1240 * @param[in] basetype Base YANG built-in type of the node connected with the range restriction. Actually only LY_TYPE_DEC64 is important to
1241 * allow processing of the fractions. The fraction point is extracted from the value which is then normalize according to given frdigits into
1242 * valcopy to allow easy parsing and storing of the value. libyang stores decimal number without the decimal point which is always recovered from
1243 * the known fraction-digits value. So, with fraction-digits 2, number 3.14 is stored as 314 and number 1 is stored as 100.
1244 * @param[in] frdigits The fraction-digits of the type in case of LY_TYPE_DEC64.
1245 * @param[in] value String value of the range boundary.
1246 * @param[out] len Number of the processed bytes from the value. Processing stops on the first character which is not part of the number boundary.
1247 * @param[out] valcopy NULL-terminated string with the numeric value to parse and store.
1248 * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID (no number) or LY_EINVAL (decimal64 not matching fraction-digits value).
1249 */
Radek Krejcie88beef2019-05-30 15:47:19 +02001250LY_ERR
Radek Krejci6cba4292018-11-15 17:33:29 +01001251range_part_check_value_syntax(struct lysc_ctx *ctx, LY_DATA_TYPE basetype, uint8_t frdigits, const char *value, size_t *len, char **valcopy)
Radek Krejci19a96102018-11-15 13:38:09 +01001252{
Radek Krejci6cba4292018-11-15 17:33:29 +01001253 size_t fraction = 0, size;
1254
Radek Krejci19a96102018-11-15 13:38:09 +01001255 *len = 0;
1256
1257 assert(value);
1258 /* parse value */
1259 if (!isdigit(value[*len]) && (value[*len] != '-') && (value[*len] != '+')) {
1260 return LY_EVALID;
1261 }
1262
1263 if ((value[*len] == '-') || (value[*len] == '+')) {
1264 ++(*len);
1265 }
1266
1267 while (isdigit(value[*len])) {
1268 ++(*len);
1269 }
1270
1271 if ((basetype != LY_TYPE_DEC64) || (value[*len] != '.') || !isdigit(value[*len + 1])) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001272 if (basetype == LY_TYPE_DEC64) {
1273 goto decimal;
1274 } else {
1275 *valcopy = strndup(value, *len);
1276 return LY_SUCCESS;
1277 }
Radek Krejci19a96102018-11-15 13:38:09 +01001278 }
1279 fraction = *len;
1280
1281 ++(*len);
1282 while (isdigit(value[*len])) {
1283 ++(*len);
1284 }
1285
Radek Krejci6cba4292018-11-15 17:33:29 +01001286 if (basetype == LY_TYPE_DEC64) {
1287decimal:
1288 assert(frdigits);
Radek Krejci943177f2019-06-14 16:32:43 +02001289 if (fraction && (*len - 1 - fraction > frdigits)) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001290 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1291 "Range boundary \"%.*s\" of decimal64 type exceeds defined number (%u) of fraction digits.",
1292 *len, value, frdigits);
1293 return LY_EINVAL;
1294 }
1295 if (fraction) {
1296 size = (*len) + (frdigits - ((*len) - 1 - fraction));
1297 } else {
1298 size = (*len) + frdigits + 1;
1299 }
1300 *valcopy = malloc(size * sizeof **valcopy);
Radek Krejci19a96102018-11-15 13:38:09 +01001301 LY_CHECK_ERR_RET(!(*valcopy), LOGMEM(ctx->ctx), LY_EMEM);
1302
Radek Krejci6cba4292018-11-15 17:33:29 +01001303 (*valcopy)[size - 1] = '\0';
1304 if (fraction) {
1305 memcpy(&(*valcopy)[0], &value[0], fraction);
1306 memcpy(&(*valcopy)[fraction], &value[fraction + 1], (*len) - 1 - (fraction));
1307 memset(&(*valcopy)[(*len) - 1], '0', frdigits - ((*len) - 1 - fraction));
1308 } else {
1309 memcpy(&(*valcopy)[0], &value[0], *len);
1310 memset(&(*valcopy)[*len], '0', frdigits);
1311 }
Radek Krejci19a96102018-11-15 13:38:09 +01001312 }
1313 return LY_SUCCESS;
1314}
1315
Radek Krejcia3045382018-11-22 14:30:31 +01001316/**
1317 * @brief Check that values in range are in ascendant order.
1318 * @param[in] unsigned_value Flag to note that we are working with unsigned values.
Radek Krejci5969f272018-11-23 10:03:58 +01001319 * @param[in] max Flag to distinguish if checking min or max value. min value must be strictly higher than previous,
1320 * max can be also equal.
Radek Krejcia3045382018-11-22 14:30:31 +01001321 * @param[in] value Current value to check.
1322 * @param[in] prev_value The last seen value.
1323 * @return LY_SUCCESS or LY_EEXIST for invalid order.
1324 */
Radek Krejci19a96102018-11-15 13:38:09 +01001325static LY_ERR
Radek Krejci5969f272018-11-23 10:03:58 +01001326range_part_check_ascendancy(int unsigned_value, int max, int64_t value, int64_t prev_value)
Radek Krejci19a96102018-11-15 13:38:09 +01001327{
1328 if (unsigned_value) {
Radek Krejci5969f272018-11-23 10:03:58 +01001329 if ((max && (uint64_t)prev_value > (uint64_t)value) || (!max && (uint64_t)prev_value >= (uint64_t)value)) {
Radek Krejci19a96102018-11-15 13:38:09 +01001330 return LY_EEXIST;
1331 }
1332 } else {
Radek Krejci5969f272018-11-23 10:03:58 +01001333 if ((max && prev_value > value) || (!max && prev_value >= value)) {
Radek Krejci19a96102018-11-15 13:38:09 +01001334 return LY_EEXIST;
1335 }
1336 }
1337 return LY_SUCCESS;
1338}
1339
Radek Krejcia3045382018-11-22 14:30:31 +01001340/**
1341 * @brief Set min/max value of the range part.
1342 * @param[in] ctx Compile context.
1343 * @param[in] part Range part structure to fill.
1344 * @param[in] max Flag to distinguish if storing min or max value.
1345 * @param[in] prev The last seen value to check that all values in range are specified in ascendant order.
1346 * @param[in] basetype Type of the value to get know implicit min/max values and other checking rules.
1347 * @param[in] first Flag for the first value of the range to avoid ascendancy order.
1348 * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
1349 * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
Radek Krejci5969f272018-11-23 10:03:58 +01001350 * @param[in] base_range Range from the type from which the current type is derived (if not built-in) to get type's min and max values.
Radek Krejcia3045382018-11-22 14:30:31 +01001351 * @param[in,out] value Numeric range value to be stored, if not provided the type's min/max value is set.
1352 * @return LY_ERR value - LY_SUCCESS, LY_EDENIED (value brokes type's boundaries), LY_EVALID (not a number),
1353 * LY_EEXIST (value is smaller than the previous one), LY_EINVAL (decimal64 value does not corresponds with the
1354 * frdigits value), LY_EMEM.
1355 */
Radek Krejci19a96102018-11-15 13:38:09 +01001356static LY_ERR
1357range_part_minmax(struct lysc_ctx *ctx, struct lysc_range_part *part, int max, int64_t prev, LY_DATA_TYPE basetype, int first, int length_restr,
Radek Krejci5969f272018-11-23 10:03:58 +01001358 uint8_t frdigits, struct lysc_range *base_range, const char **value)
Radek Krejci19a96102018-11-15 13:38:09 +01001359{
1360 LY_ERR ret = LY_SUCCESS;
1361 char *valcopy = NULL;
1362 size_t len;
1363
1364 if (value) {
Radek Krejci6cba4292018-11-15 17:33:29 +01001365 ret = range_part_check_value_syntax(ctx, basetype, frdigits, *value, &len, &valcopy);
Radek Krejci5969f272018-11-23 10:03:58 +01001366 LY_CHECK_GOTO(ret, finalize);
1367 }
1368 if (!valcopy && base_range) {
1369 if (max) {
1370 part->max_64 = base_range->parts[LY_ARRAY_SIZE(base_range->parts) - 1].max_64;
1371 } else {
1372 part->min_64 = base_range->parts[0].min_64;
1373 }
1374 if (!first) {
1375 ret = range_part_check_ascendancy(basetype <= LY_TYPE_STRING ? 1 : 0, max, max ? part->max_64 : part->min_64, prev);
1376 }
1377 goto finalize;
Radek Krejci19a96102018-11-15 13:38:09 +01001378 }
1379
1380 switch (basetype) {
Radek Krejci19a96102018-11-15 13:38:09 +01001381 case LY_TYPE_INT8: /* range */
1382 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001383 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-128), INT64_C(127), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001384 } else if (max) {
1385 part->max_64 = INT64_C(127);
1386 } else {
1387 part->min_64 = INT64_C(-128);
1388 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001389 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001390 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001391 }
1392 break;
1393 case LY_TYPE_INT16: /* range */
1394 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001395 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-32768), INT64_C(32767), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001396 } else if (max) {
1397 part->max_64 = INT64_C(32767);
1398 } else {
1399 part->min_64 = INT64_C(-32768);
1400 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001401 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001402 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001403 }
1404 break;
1405 case LY_TYPE_INT32: /* range */
1406 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001407 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-2147483648), INT64_C(2147483647), 10, max ? &part->max_64 : &part->min_64);
Radek Krejci19a96102018-11-15 13:38:09 +01001408 } else if (max) {
1409 part->max_64 = INT64_C(2147483647);
1410 } else {
1411 part->min_64 = INT64_C(-2147483648);
1412 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001413 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001414 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001415 }
1416 break;
1417 case LY_TYPE_INT64: /* range */
Radek Krejci25cfef72018-11-23 14:15:52 +01001418 case LY_TYPE_DEC64: /* range */
Radek Krejci19a96102018-11-15 13:38:09 +01001419 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001420 ret = ly_parse_int(valcopy, strlen(valcopy), INT64_C(-9223372036854775807) - INT64_C(1), INT64_C(9223372036854775807), 10,
Radek Krejci19a96102018-11-15 13:38:09 +01001421 max ? &part->max_64 : &part->min_64);
1422 } else if (max) {
1423 part->max_64 = INT64_C(9223372036854775807);
1424 } else {
1425 part->min_64 = INT64_C(-9223372036854775807) - INT64_C(1);
1426 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001427 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001428 ret = range_part_check_ascendancy(0, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001429 }
1430 break;
1431 case LY_TYPE_UINT8: /* range */
1432 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001433 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(255), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001434 } else if (max) {
1435 part->max_u64 = UINT64_C(255);
1436 } else {
1437 part->min_u64 = UINT64_C(0);
1438 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001439 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001440 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001441 }
1442 break;
1443 case LY_TYPE_UINT16: /* range */
1444 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001445 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(65535), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001446 } else if (max) {
1447 part->max_u64 = UINT64_C(65535);
1448 } else {
1449 part->min_u64 = UINT64_C(0);
1450 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001451 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001452 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001453 }
1454 break;
1455 case LY_TYPE_UINT32: /* range */
1456 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001457 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(4294967295), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001458 } else if (max) {
1459 part->max_u64 = UINT64_C(4294967295);
1460 } else {
1461 part->min_u64 = UINT64_C(0);
1462 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001463 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001464 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001465 }
1466 break;
1467 case LY_TYPE_UINT64: /* range */
Radek Krejci19a96102018-11-15 13:38:09 +01001468 case LY_TYPE_STRING: /* length */
Radek Krejci25cfef72018-11-23 14:15:52 +01001469 case LY_TYPE_BINARY: /* length */
Radek Krejci19a96102018-11-15 13:38:09 +01001470 if (valcopy) {
Radek Krejci249973a2019-06-10 10:50:54 +02001471 ret = ly_parse_uint(valcopy, strlen(valcopy), UINT64_C(18446744073709551615), 10, max ? &part->max_u64 : &part->min_u64);
Radek Krejci19a96102018-11-15 13:38:09 +01001472 } else if (max) {
1473 part->max_u64 = UINT64_C(18446744073709551615);
1474 } else {
1475 part->min_u64 = UINT64_C(0);
1476 }
Radek Krejci6cba4292018-11-15 17:33:29 +01001477 if (!ret && !first) {
Radek Krejci5969f272018-11-23 10:03:58 +01001478 ret = range_part_check_ascendancy(1, max, max ? part->max_64 : part->min_64, prev);
Radek Krejci19a96102018-11-15 13:38:09 +01001479 }
1480 break;
1481 default:
1482 LOGINT(ctx->ctx);
1483 ret = LY_EINT;
1484 }
1485
Radek Krejci5969f272018-11-23 10:03:58 +01001486finalize:
Radek Krejci19a96102018-11-15 13:38:09 +01001487 if (ret == LY_EDENIED) {
1488 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1489 "Invalid %s restriction - value \"%s\" does not fit the type limitations.",
1490 length_restr ? "length" : "range", valcopy ? valcopy : *value);
1491 } else if (ret == LY_EVALID) {
1492 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1493 "Invalid %s restriction - invalid value \"%s\".",
1494 length_restr ? "length" : "range", valcopy ? valcopy : *value);
1495 } else if (ret == LY_EEXIST) {
1496 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1497 "Invalid %s restriction - values are not in ascending order (%s).",
Radek Krejci6cba4292018-11-15 17:33:29 +01001498 length_restr ? "length" : "range",
Radek Krejci5969f272018-11-23 10:03:58 +01001499 (valcopy && basetype != LY_TYPE_DEC64) ? valcopy : value ? *value : max ? "max" : "min");
Radek Krejci19a96102018-11-15 13:38:09 +01001500 } else if (!ret && value) {
1501 *value = *value + len;
1502 }
1503 free(valcopy);
1504 return ret;
1505}
1506
Radek Krejcia3045382018-11-22 14:30:31 +01001507/**
1508 * @brief Compile the parsed range restriction.
1509 * @param[in] ctx Compile context.
1510 * @param[in] range_p Parsed range structure to compile.
1511 * @param[in] basetype Base YANG built-in type of the node with the range restriction.
1512 * @param[in] length_restr Flag to distinguish between range and length restrictions. Only for logging.
1513 * @param[in] frdigits The fraction-digits value in case of LY_TYPE_DEC64 basetype.
1514 * @param[in] base_range Range restriction of the type from which the current type is derived. The current
1515 * range restriction must be more restrictive than the base_range.
1516 * @param[in,out] range Pointer to the created current range structure.
1517 * @return LY_ERR value.
1518 */
Radek Krejci19a96102018-11-15 13:38:09 +01001519static LY_ERR
Radek Krejci6cba4292018-11-15 17:33:29 +01001520lys_compile_type_range(struct lysc_ctx *ctx, struct lysp_restr *range_p, LY_DATA_TYPE basetype, int length_restr, uint8_t frdigits,
Radek Krejci19a96102018-11-15 13:38:09 +01001521 struct lysc_range *base_range, struct lysc_range **range)
1522{
1523 LY_ERR ret = LY_EVALID;
1524 const char *expr;
1525 struct lysc_range_part *parts = NULL, *part;
1526 int range_expected = 0, uns;
1527 unsigned int parts_done = 0, u, v;
1528
1529 assert(range);
1530 assert(range_p);
1531
1532 expr = range_p->arg;
1533 while(1) {
1534 if (isspace(*expr)) {
1535 ++expr;
1536 } else if (*expr == '\0') {
1537 if (range_expected) {
1538 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1539 "Invalid %s restriction - unexpected end of the expression after \"..\" (%s).",
1540 length_restr ? "length" : "range", range_p->arg);
1541 goto cleanup;
1542 } else if (!parts || parts_done == LY_ARRAY_SIZE(parts)) {
1543 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1544 "Invalid %s restriction - unexpected end of the expression (%s).",
1545 length_restr ? "length" : "range", range_p->arg);
1546 goto cleanup;
1547 }
1548 parts_done++;
1549 break;
1550 } else if (!strncmp(expr, "min", 3)) {
1551 if (parts) {
1552 /* min cannot be used elsewhere than in the first part */
1553 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1554 "Invalid %s restriction - unexpected data before min keyword (%.*s).", length_restr ? "length" : "range",
1555 expr - range_p->arg, range_p->arg);
1556 goto cleanup;
1557 }
1558 expr += 3;
1559
1560 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
Radek Krejci5969f272018-11-23 10:03:58 +01001561 LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, 0, basetype, 1, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001562 part->max_64 = part->min_64;
1563 } else if (*expr == '|') {
1564 if (!parts || range_expected) {
1565 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1566 "Invalid %s restriction - unexpected beginning of the expression (%s).", length_restr ? "length" : "range", expr);
1567 goto cleanup;
1568 }
1569 expr++;
1570 parts_done++;
1571 /* process next part of the expression */
1572 } else if (!strncmp(expr, "..", 2)) {
1573 expr += 2;
1574 while (isspace(*expr)) {
1575 expr++;
1576 }
1577 if (!parts || LY_ARRAY_SIZE(parts) == parts_done) {
1578 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1579 "Invalid %s restriction - unexpected \"..\" without a lower bound.", length_restr ? "length" : "range");
1580 goto cleanup;
1581 }
1582 /* continue expecting the upper boundary */
1583 range_expected = 1;
1584 } else if (isdigit(*expr) || (*expr == '-') || (*expr == '+')) {
1585 /* number */
1586 if (range_expected) {
1587 part = &parts[LY_ARRAY_SIZE(parts) - 1];
Radek Krejci5969f272018-11-23 10:03:58 +01001588 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, NULL, &expr), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001589 range_expected = 0;
1590 } else {
1591 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
1592 LY_CHECK_GOTO(range_part_minmax(ctx, part, 0, parts_done ? parts[LY_ARRAY_SIZE(parts) - 2].max_64 : 0,
Radek Krejci5969f272018-11-23 10:03:58 +01001593 basetype, parts_done ? 0 : 1, length_restr, frdigits, NULL, &expr), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001594 part->max_64 = part->min_64;
1595 }
1596
1597 /* continue with possible another expression part */
1598 } else if (!strncmp(expr, "max", 3)) {
1599 expr += 3;
1600 while (isspace(*expr)) {
1601 expr++;
1602 }
1603 if (*expr != '\0') {
1604 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data after max keyword (%s).",
1605 length_restr ? "length" : "range", expr);
1606 goto cleanup;
1607 }
1608 if (range_expected) {
1609 part = &parts[LY_ARRAY_SIZE(parts) - 1];
Radek Krejci5969f272018-11-23 10:03:58 +01001610 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, part->min_64, basetype, 0, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001611 range_expected = 0;
1612 } else {
1613 LY_ARRAY_NEW_GOTO(ctx->ctx, parts, part, ret, cleanup);
1614 LY_CHECK_GOTO(range_part_minmax(ctx, part, 1, parts_done ? parts[LY_ARRAY_SIZE(parts) - 2].max_64 : 0,
Radek Krejci5969f272018-11-23 10:03:58 +01001615 basetype, parts_done ? 0 : 1, length_restr, frdigits, base_range, NULL), cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01001616 part->min_64 = part->max_64;
1617 }
1618 } else {
1619 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid %s restriction - unexpected data (%s).",
1620 length_restr ? "length" : "range", expr);
1621 goto cleanup;
1622 }
1623 }
1624
1625 /* check with the previous range/length restriction */
1626 if (base_range) {
1627 switch (basetype) {
1628 case LY_TYPE_BINARY:
1629 case LY_TYPE_UINT8:
1630 case LY_TYPE_UINT16:
1631 case LY_TYPE_UINT32:
1632 case LY_TYPE_UINT64:
1633 case LY_TYPE_STRING:
1634 uns = 1;
1635 break;
1636 case LY_TYPE_DEC64:
1637 case LY_TYPE_INT8:
1638 case LY_TYPE_INT16:
1639 case LY_TYPE_INT32:
1640 case LY_TYPE_INT64:
1641 uns = 0;
1642 break;
1643 default:
1644 LOGINT(ctx->ctx);
1645 ret = LY_EINT;
1646 goto cleanup;
1647 }
1648 for (u = v = 0; u < parts_done && v < LY_ARRAY_SIZE(base_range->parts); ++u) {
1649 if ((uns && parts[u].min_u64 < base_range->parts[v].min_u64) || (!uns && parts[u].min_64 < base_range->parts[v].min_64)) {
1650 goto baseerror;
1651 }
1652 /* current lower bound is not lower than the base */
1653 if (base_range->parts[v].min_64 == base_range->parts[v].max_64) {
1654 /* base has single value */
1655 if (base_range->parts[v].min_64 == parts[u].min_64) {
1656 /* both lower bounds are the same */
1657 if (parts[u].min_64 != parts[u].max_64) {
1658 /* current continues with a range */
1659 goto baseerror;
1660 } else {
1661 /* equal single values, move both forward */
1662 ++v;
1663 continue;
1664 }
1665 } else {
1666 /* base is single value lower than current range, so the
1667 * value from base range is removed in the current,
1668 * move only base and repeat checking */
1669 ++v;
1670 --u;
1671 continue;
1672 }
1673 } else {
1674 /* base is the range */
1675 if (parts[u].min_64 == parts[u].max_64) {
1676 /* current is a single value */
1677 if ((uns && parts[u].max_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].max_64 > base_range->parts[v].max_64)) {
1678 /* current is behind the base range, so base range is omitted,
1679 * move the base and keep the current for further check */
1680 ++v;
1681 --u;
1682 } /* else it is within the base range, so move the current, but keep the base */
1683 continue;
1684 } else {
1685 /* both are ranges - check the higher bound, the lower was already checked */
1686 if ((uns && parts[u].max_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].max_64 > base_range->parts[v].max_64)) {
1687 /* higher bound is higher than the current higher bound */
1688 if ((uns && parts[u].min_u64 > base_range->parts[v].max_u64) || (!uns && parts[u].min_64 > base_range->parts[v].max_64)) {
1689 /* but the current lower bound is also higher, so the base range is omitted,
1690 * continue with the same current, but move the base */
1691 --u;
1692 ++v;
1693 continue;
1694 }
1695 /* current range starts within the base range but end behind it */
1696 goto baseerror;
1697 } else {
1698 /* current range is smaller than the base,
1699 * move current, but stay with the base */
1700 continue;
1701 }
1702 }
1703 }
1704 }
1705 if (u != parts_done) {
1706baseerror:
1707 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
1708 "Invalid %s restriction - the derived restriction (%s) is not equally or more limiting.",
1709 length_restr ? "length" : "range", range_p->arg);
1710 goto cleanup;
1711 }
1712 }
1713
1714 if (!(*range)) {
1715 *range = calloc(1, sizeof **range);
1716 LY_CHECK_ERR_RET(!(*range), LOGMEM(ctx->ctx), LY_EMEM);
1717 }
1718
Radek Krejcic8b31002019-01-08 10:24:45 +01001719 /* we rewrite the following values as the types chain is being processed */
Radek Krejci19a96102018-11-15 13:38:09 +01001720 if (range_p->eapptag) {
1721 lydict_remove(ctx->ctx, (*range)->eapptag);
1722 (*range)->eapptag = lydict_insert(ctx->ctx, range_p->eapptag, 0);
1723 }
1724 if (range_p->emsg) {
1725 lydict_remove(ctx->ctx, (*range)->emsg);
1726 (*range)->emsg = lydict_insert(ctx->ctx, range_p->emsg, 0);
1727 }
Radek Krejcic8b31002019-01-08 10:24:45 +01001728 if (range_p->dsc) {
1729 lydict_remove(ctx->ctx, (*range)->dsc);
1730 (*range)->dsc = lydict_insert(ctx->ctx, range_p->dsc, 0);
1731 }
1732 if (range_p->ref) {
1733 lydict_remove(ctx->ctx, (*range)->ref);
1734 (*range)->ref = lydict_insert(ctx->ctx, range_p->ref, 0);
1735 }
Radek Krejci19a96102018-11-15 13:38:09 +01001736 /* extensions are taken only from the last range by the caller */
1737
1738 (*range)->parts = parts;
1739 parts = NULL;
1740 ret = LY_SUCCESS;
1741cleanup:
Radek Krejci19a96102018-11-15 13:38:09 +01001742 LY_ARRAY_FREE(parts);
1743
1744 return ret;
1745}
1746
1747/**
1748 * @brief Checks pattern syntax.
1749 *
Radek Krejcia3045382018-11-22 14:30:31 +01001750 * @param[in] ctx Compile context.
Radek Krejci19a96102018-11-15 13:38:09 +01001751 * @param[in] pattern Pattern to check.
Radek Krejci54579462019-04-30 12:47:06 +02001752 * @param[in,out] pcre2_code Compiled PCRE2 pattern. If NULL, the compiled information used to validate pattern are freed.
Radek Krejcia3045382018-11-22 14:30:31 +01001753 * @return LY_ERR value - LY_SUCCESS, LY_EMEM, LY_EVALID.
Radek Krejci19a96102018-11-15 13:38:09 +01001754 */
1755static LY_ERR
Radek Krejci54579462019-04-30 12:47:06 +02001756lys_compile_type_pattern_check(struct lysc_ctx *ctx, const char *pattern, pcre2_code **code)
Radek Krejci19a96102018-11-15 13:38:09 +01001757{
Radek Krejci54579462019-04-30 12:47:06 +02001758 int idx, idx2, start, end, count;
Radek Krejci19a96102018-11-15 13:38:09 +01001759 char *perl_regex, *ptr;
Radek Krejci54579462019-04-30 12:47:06 +02001760 int err_code;
1761 const char *orig_ptr;
1762 PCRE2_SIZE err_offset;
1763 pcre2_code *code_local;
Radek Krejci19a96102018-11-15 13:38:09 +01001764#define URANGE_LEN 19
1765 char *ublock2urange[][2] = {
1766 {"BasicLatin", "[\\x{0000}-\\x{007F}]"},
1767 {"Latin-1Supplement", "[\\x{0080}-\\x{00FF}]"},
1768 {"LatinExtended-A", "[\\x{0100}-\\x{017F}]"},
1769 {"LatinExtended-B", "[\\x{0180}-\\x{024F}]"},
1770 {"IPAExtensions", "[\\x{0250}-\\x{02AF}]"},
1771 {"SpacingModifierLetters", "[\\x{02B0}-\\x{02FF}]"},
1772 {"CombiningDiacriticalMarks", "[\\x{0300}-\\x{036F}]"},
1773 {"Greek", "[\\x{0370}-\\x{03FF}]"},
1774 {"Cyrillic", "[\\x{0400}-\\x{04FF}]"},
1775 {"Armenian", "[\\x{0530}-\\x{058F}]"},
1776 {"Hebrew", "[\\x{0590}-\\x{05FF}]"},
1777 {"Arabic", "[\\x{0600}-\\x{06FF}]"},
1778 {"Syriac", "[\\x{0700}-\\x{074F}]"},
1779 {"Thaana", "[\\x{0780}-\\x{07BF}]"},
1780 {"Devanagari", "[\\x{0900}-\\x{097F}]"},
1781 {"Bengali", "[\\x{0980}-\\x{09FF}]"},
1782 {"Gurmukhi", "[\\x{0A00}-\\x{0A7F}]"},
1783 {"Gujarati", "[\\x{0A80}-\\x{0AFF}]"},
1784 {"Oriya", "[\\x{0B00}-\\x{0B7F}]"},
1785 {"Tamil", "[\\x{0B80}-\\x{0BFF}]"},
1786 {"Telugu", "[\\x{0C00}-\\x{0C7F}]"},
1787 {"Kannada", "[\\x{0C80}-\\x{0CFF}]"},
1788 {"Malayalam", "[\\x{0D00}-\\x{0D7F}]"},
1789 {"Sinhala", "[\\x{0D80}-\\x{0DFF}]"},
1790 {"Thai", "[\\x{0E00}-\\x{0E7F}]"},
1791 {"Lao", "[\\x{0E80}-\\x{0EFF}]"},
1792 {"Tibetan", "[\\x{0F00}-\\x{0FFF}]"},
1793 {"Myanmar", "[\\x{1000}-\\x{109F}]"},
1794 {"Georgian", "[\\x{10A0}-\\x{10FF}]"},
1795 {"HangulJamo", "[\\x{1100}-\\x{11FF}]"},
1796 {"Ethiopic", "[\\x{1200}-\\x{137F}]"},
1797 {"Cherokee", "[\\x{13A0}-\\x{13FF}]"},
1798 {"UnifiedCanadianAboriginalSyllabics", "[\\x{1400}-\\x{167F}]"},
1799 {"Ogham", "[\\x{1680}-\\x{169F}]"},
1800 {"Runic", "[\\x{16A0}-\\x{16FF}]"},
1801 {"Khmer", "[\\x{1780}-\\x{17FF}]"},
1802 {"Mongolian", "[\\x{1800}-\\x{18AF}]"},
1803 {"LatinExtendedAdditional", "[\\x{1E00}-\\x{1EFF}]"},
1804 {"GreekExtended", "[\\x{1F00}-\\x{1FFF}]"},
1805 {"GeneralPunctuation", "[\\x{2000}-\\x{206F}]"},
1806 {"SuperscriptsandSubscripts", "[\\x{2070}-\\x{209F}]"},
1807 {"CurrencySymbols", "[\\x{20A0}-\\x{20CF}]"},
1808 {"CombiningMarksforSymbols", "[\\x{20D0}-\\x{20FF}]"},
1809 {"LetterlikeSymbols", "[\\x{2100}-\\x{214F}]"},
1810 {"NumberForms", "[\\x{2150}-\\x{218F}]"},
1811 {"Arrows", "[\\x{2190}-\\x{21FF}]"},
1812 {"MathematicalOperators", "[\\x{2200}-\\x{22FF}]"},
1813 {"MiscellaneousTechnical", "[\\x{2300}-\\x{23FF}]"},
1814 {"ControlPictures", "[\\x{2400}-\\x{243F}]"},
1815 {"OpticalCharacterRecognition", "[\\x{2440}-\\x{245F}]"},
1816 {"EnclosedAlphanumerics", "[\\x{2460}-\\x{24FF}]"},
1817 {"BoxDrawing", "[\\x{2500}-\\x{257F}]"},
1818 {"BlockElements", "[\\x{2580}-\\x{259F}]"},
1819 {"GeometricShapes", "[\\x{25A0}-\\x{25FF}]"},
1820 {"MiscellaneousSymbols", "[\\x{2600}-\\x{26FF}]"},
1821 {"Dingbats", "[\\x{2700}-\\x{27BF}]"},
1822 {"BraillePatterns", "[\\x{2800}-\\x{28FF}]"},
1823 {"CJKRadicalsSupplement", "[\\x{2E80}-\\x{2EFF}]"},
1824 {"KangxiRadicals", "[\\x{2F00}-\\x{2FDF}]"},
1825 {"IdeographicDescriptionCharacters", "[\\x{2FF0}-\\x{2FFF}]"},
1826 {"CJKSymbolsandPunctuation", "[\\x{3000}-\\x{303F}]"},
1827 {"Hiragana", "[\\x{3040}-\\x{309F}]"},
1828 {"Katakana", "[\\x{30A0}-\\x{30FF}]"},
1829 {"Bopomofo", "[\\x{3100}-\\x{312F}]"},
1830 {"HangulCompatibilityJamo", "[\\x{3130}-\\x{318F}]"},
1831 {"Kanbun", "[\\x{3190}-\\x{319F}]"},
1832 {"BopomofoExtended", "[\\x{31A0}-\\x{31BF}]"},
1833 {"EnclosedCJKLettersandMonths", "[\\x{3200}-\\x{32FF}]"},
1834 {"CJKCompatibility", "[\\x{3300}-\\x{33FF}]"},
1835 {"CJKUnifiedIdeographsExtensionA", "[\\x{3400}-\\x{4DB5}]"},
1836 {"CJKUnifiedIdeographs", "[\\x{4E00}-\\x{9FFF}]"},
1837 {"YiSyllables", "[\\x{A000}-\\x{A48F}]"},
1838 {"YiRadicals", "[\\x{A490}-\\x{A4CF}]"},
1839 {"HangulSyllables", "[\\x{AC00}-\\x{D7A3}]"},
1840 {"PrivateUse", "[\\x{E000}-\\x{F8FF}]"},
1841 {"CJKCompatibilityIdeographs", "[\\x{F900}-\\x{FAFF}]"},
1842 {"AlphabeticPresentationForms", "[\\x{FB00}-\\x{FB4F}]"},
1843 {"ArabicPresentationForms-A", "[\\x{FB50}-\\x{FDFF}]"},
1844 {"CombiningHalfMarks", "[\\x{FE20}-\\x{FE2F}]"},
1845 {"CJKCompatibilityForms", "[\\x{FE30}-\\x{FE4F}]"},
1846 {"SmallFormVariants", "[\\x{FE50}-\\x{FE6F}]"},
1847 {"ArabicPresentationForms-B", "[\\x{FE70}-\\x{FEFE}]"},
1848 {"HalfwidthandFullwidthForms", "[\\x{FF00}-\\x{FFEF}]"},
1849 {NULL, NULL}
1850 };
1851
1852 /* adjust the expression to a Perl equivalent
1853 * http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#regexs */
1854
1855 /* we need to replace all "$" with "\$", count them now */
1856 for (count = 0, ptr = strpbrk(pattern, "^$"); ptr; ++count, ptr = strpbrk(ptr + 1, "^$"));
1857
1858 perl_regex = malloc((strlen(pattern) + 4 + count) * sizeof(char));
1859 LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx->ctx), LY_EMEM);
1860 perl_regex[0] = '\0';
1861
1862 ptr = perl_regex;
1863
Radek Krejci19a96102018-11-15 13:38:09 +01001864 for (orig_ptr = pattern; orig_ptr[0]; ++orig_ptr) {
1865 if (orig_ptr[0] == '$') {
1866 ptr += sprintf(ptr, "\\$");
1867 } else if (orig_ptr[0] == '^') {
1868 ptr += sprintf(ptr, "\\^");
1869 } else {
1870 ptr[0] = orig_ptr[0];
1871 ++ptr;
1872 }
1873 }
Radek Krejci5819f7c2019-05-31 14:53:29 +02001874 ptr[0] = '\0';
1875 ++ptr;
Radek Krejci19a96102018-11-15 13:38:09 +01001876
1877 /* substitute Unicode Character Blocks with exact Character Ranges */
1878 while ((ptr = strstr(perl_regex, "\\p{Is"))) {
1879 start = ptr - perl_regex;
1880
1881 ptr = strchr(ptr, '}');
1882 if (!ptr) {
1883 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_INREGEXP,
1884 pattern, perl_regex + start + 2, "unterminated character property");
1885 free(perl_regex);
1886 return LY_EVALID;
1887 }
1888 end = (ptr - perl_regex) + 1;
1889
1890 /* need more space */
1891 if (end - start < URANGE_LEN) {
1892 perl_regex = ly_realloc(perl_regex, strlen(perl_regex) + (URANGE_LEN - (end - start)) + 1);
1893 LY_CHECK_ERR_RET(!perl_regex, LOGMEM(ctx->ctx); free(perl_regex), LY_EMEM);
1894 }
1895
1896 /* find our range */
1897 for (idx = 0; ublock2urange[idx][0]; ++idx) {
1898 if (!strncmp(perl_regex + start + 5, ublock2urange[idx][0], strlen(ublock2urange[idx][0]))) {
1899 break;
1900 }
1901 }
1902 if (!ublock2urange[idx][0]) {
1903 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_INREGEXP,
1904 pattern, perl_regex + start + 5, "unknown block name");
1905 free(perl_regex);
1906 return LY_EVALID;
1907 }
1908
1909 /* make the space in the string and replace the block (but we cannot include brackets if it was already enclosed in them) */
1910 for (idx2 = 0, count = 0; idx2 < start; ++idx2) {
1911 if ((perl_regex[idx2] == '[') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
1912 ++count;
1913 }
1914 if ((perl_regex[idx2] == ']') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
1915 --count;
1916 }
1917 }
1918 if (count) {
1919 /* skip brackets */
1920 memmove(perl_regex + start + (URANGE_LEN - 2), perl_regex + end, strlen(perl_regex + end) + 1);
1921 memcpy(perl_regex + start, ublock2urange[idx][1] + 1, URANGE_LEN - 2);
1922 } else {
1923 memmove(perl_regex + start + URANGE_LEN, perl_regex + end, strlen(perl_regex + end) + 1);
1924 memcpy(perl_regex + start, ublock2urange[idx][1], URANGE_LEN);
1925 }
1926 }
1927
1928 /* must return 0, already checked during parsing */
Radek Krejci5819f7c2019-05-31 14:53:29 +02001929 code_local = pcre2_compile((PCRE2_SPTR)perl_regex, PCRE2_ZERO_TERMINATED,
1930 PCRE2_UTF | PCRE2_ANCHORED | PCRE2_ENDANCHORED | PCRE2_DOLLAR_ENDONLY | PCRE2_NO_AUTO_CAPTURE,
Radek Krejci54579462019-04-30 12:47:06 +02001931 &err_code, &err_offset, NULL);
1932 if (!code_local) {
1933 PCRE2_UCHAR err_msg[256] = {0};
1934 pcre2_get_error_message(err_code, err_msg, 256);
Radek Krejci19a96102018-11-15 13:38:09 +01001935 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_INREGEXP, pattern, perl_regex + err_offset, err_msg);
1936 free(perl_regex);
1937 return LY_EVALID;
1938 }
1939 free(perl_regex);
1940
Radek Krejci54579462019-04-30 12:47:06 +02001941 if (code) {
1942 *code = code_local;
Radek Krejci19a96102018-11-15 13:38:09 +01001943 } else {
Radek Krejci54579462019-04-30 12:47:06 +02001944 free(code_local);
Radek Krejci19a96102018-11-15 13:38:09 +01001945 }
1946
1947 return LY_SUCCESS;
1948
1949#undef URANGE_LEN
1950}
1951
Radek Krejcia3045382018-11-22 14:30:31 +01001952/**
1953 * @brief Compile parsed pattern restriction in conjunction with the patterns from base type.
1954 * @param[in] ctx Compile context.
1955 * @param[in] patterns_p Array of parsed patterns from the current type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01001956 * @param[in] base_patterns Compiled patterns from the type from which the current type is derived.
1957 * Patterns from the base type are inherited to have all the patterns that have to match at one place.
1958 * @param[out] patterns Pointer to the storage for the patterns of the current type.
1959 * @return LY_ERR LY_SUCCESS, LY_EMEM, LY_EVALID.
1960 */
Radek Krejci19a96102018-11-15 13:38:09 +01001961static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02001962lys_compile_type_patterns(struct lysc_ctx *ctx, struct lysp_restr *patterns_p,
Radek Krejci19a96102018-11-15 13:38:09 +01001963 struct lysc_pattern **base_patterns, struct lysc_pattern ***patterns)
1964{
1965 struct lysc_pattern **pattern;
Radek Krejci0935f412019-08-20 16:15:18 +02001966 unsigned int u;
Radek Krejci19a96102018-11-15 13:38:09 +01001967 LY_ERR ret = LY_SUCCESS;
1968
1969 /* first, copy the patterns from the base type */
1970 if (base_patterns) {
1971 *patterns = lysc_patterns_dup(ctx->ctx, base_patterns);
1972 LY_CHECK_ERR_RET(!(*patterns), LOGMEM(ctx->ctx), LY_EMEM);
1973 }
1974
1975 LY_ARRAY_FOR(patterns_p, u) {
1976 LY_ARRAY_NEW_RET(ctx->ctx, (*patterns), pattern, LY_EMEM);
1977 *pattern = calloc(1, sizeof **pattern);
1978 ++(*pattern)->refcount;
1979
Radek Krejci54579462019-04-30 12:47:06 +02001980 ret = lys_compile_type_pattern_check(ctx, &patterns_p[u].arg[1], &(*pattern)->code);
Radek Krejci19a96102018-11-15 13:38:09 +01001981 LY_CHECK_RET(ret);
Radek Krejci19a96102018-11-15 13:38:09 +01001982
1983 if (patterns_p[u].arg[0] == 0x15) {
1984 (*pattern)->inverted = 1;
1985 }
Radek Krejci54579462019-04-30 12:47:06 +02001986 DUP_STRING(ctx->ctx, &patterns_p[u].arg[1], (*pattern)->expr);
Radek Krejci19a96102018-11-15 13:38:09 +01001987 DUP_STRING(ctx->ctx, patterns_p[u].eapptag, (*pattern)->eapptag);
1988 DUP_STRING(ctx->ctx, patterns_p[u].emsg, (*pattern)->emsg);
Radek Krejcic8b31002019-01-08 10:24:45 +01001989 DUP_STRING(ctx->ctx, patterns_p[u].dsc, (*pattern)->dsc);
1990 DUP_STRING(ctx->ctx, patterns_p[u].ref, (*pattern)->ref);
Radek Krejci0935f412019-08-20 16:15:18 +02001991 COMPILE_EXTS_GOTO(ctx, patterns_p[u].exts, (*pattern)->exts, (*pattern), LYEXT_PAR_PATTERN, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01001992 }
1993done:
1994 return ret;
1995}
1996
Radek Krejcia3045382018-11-22 14:30:31 +01001997/**
1998 * @brief map of the possible restrictions combination for the specific built-in type.
1999 */
Radek Krejci19a96102018-11-15 13:38:09 +01002000static uint16_t type_substmt_map[LY_DATA_TYPE_COUNT] = {
2001 0 /* LY_TYPE_UNKNOWN */,
2002 LYS_SET_LENGTH /* LY_TYPE_BINARY */,
Radek Krejci5969f272018-11-23 10:03:58 +01002003 LYS_SET_RANGE /* LY_TYPE_UINT8 */,
2004 LYS_SET_RANGE /* LY_TYPE_UINT16 */,
2005 LYS_SET_RANGE /* LY_TYPE_UINT32 */,
2006 LYS_SET_RANGE /* LY_TYPE_UINT64 */,
2007 LYS_SET_LENGTH | LYS_SET_PATTERN /* LY_TYPE_STRING */,
Radek Krejci19a96102018-11-15 13:38:09 +01002008 LYS_SET_BIT /* LY_TYPE_BITS */,
2009 0 /* LY_TYPE_BOOL */,
2010 LYS_SET_FRDIGITS | LYS_SET_RANGE /* LY_TYPE_DEC64 */,
2011 0 /* LY_TYPE_EMPTY */,
2012 LYS_SET_ENUM /* LY_TYPE_ENUM */,
2013 LYS_SET_BASE /* LY_TYPE_IDENT */,
2014 LYS_SET_REQINST /* LY_TYPE_INST */,
2015 LYS_SET_REQINST | LYS_SET_PATH /* LY_TYPE_LEAFREF */,
Radek Krejci19a96102018-11-15 13:38:09 +01002016 LYS_SET_TYPE /* LY_TYPE_UNION */,
2017 LYS_SET_RANGE /* LY_TYPE_INT8 */,
Radek Krejci19a96102018-11-15 13:38:09 +01002018 LYS_SET_RANGE /* LY_TYPE_INT16 */,
Radek Krejci19a96102018-11-15 13:38:09 +01002019 LYS_SET_RANGE /* LY_TYPE_INT32 */,
Radek Krejci5969f272018-11-23 10:03:58 +01002020 LYS_SET_RANGE /* LY_TYPE_INT64 */
2021};
2022
2023/**
2024 * @brief stringification of the YANG built-in data types
2025 */
2026const char* ly_data_type2str[LY_DATA_TYPE_COUNT] = {"unknown", "binary", "8bit unsigned integer", "16bit unsigned integer",
2027 "32bit unsigned integer", "64bit unsigned integer", "string", "bits", "boolean", "decimal64", "empty", "enumeration",
2028 "identityref", "instance-identifier", "leafref", "union", "8bit integer", "16bit integer", "32bit integer", "64bit integer"
Radek Krejci19a96102018-11-15 13:38:09 +01002029};
2030
Radek Krejcia3045382018-11-22 14:30:31 +01002031/**
2032 * @brief Compile parsed type's enum structures (for enumeration and bits types).
2033 * @param[in] ctx Compile context.
2034 * @param[in] enums_p Array of the parsed enum structures to compile.
2035 * @param[in] basetype Base YANG built-in type from which the current type is derived. Only LY_TYPE_ENUM and LY_TYPE_BITS are expected.
Radek Krejcia3045382018-11-22 14:30:31 +01002036 * @param[in] base_enums Array of the compiled enums information from the (latest) base type to check if the current enums are compatible.
2037 * @param[out] enums Newly created array of the compiled enums information for the current type.
2038 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
2039 */
Radek Krejci19a96102018-11-15 13:38:09 +01002040static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02002041lys_compile_type_enums(struct lysc_ctx *ctx, struct lysp_type_enum *enums_p, LY_DATA_TYPE basetype,
Radek Krejci693262f2019-04-29 15:23:20 +02002042 struct lysc_type_bitenum_item *base_enums, struct lysc_type_bitenum_item **enums)
Radek Krejci19a96102018-11-15 13:38:09 +01002043{
2044 LY_ERR ret = LY_SUCCESS;
Radek Krejci4ad42aa2019-07-23 16:55:58 +02002045 unsigned int u, v, match = 0;
Radek Krejci19a96102018-11-15 13:38:09 +01002046 int32_t value = 0;
2047 uint32_t position = 0;
Radek Krejci693262f2019-04-29 15:23:20 +02002048 struct lysc_type_bitenum_item *e, storage;
Radek Krejci19a96102018-11-15 13:38:09 +01002049
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002050 if (base_enums && ctx->mod_def->version < 2) {
Radek Krejci19a96102018-11-15 13:38:09 +01002051 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "%s type can be subtyped only in YANG 1.1 modules.",
2052 basetype == LY_TYPE_ENUM ? "Enumeration" : "Bits");
2053 return LY_EVALID;
2054 }
2055
2056 LY_ARRAY_FOR(enums_p, u) {
2057 LY_ARRAY_NEW_RET(ctx->ctx, *enums, e, LY_EMEM);
2058 DUP_STRING(ctx->ctx, enums_p[u].name, e->name);
Radek Krejcic8b31002019-01-08 10:24:45 +01002059 DUP_STRING(ctx->ctx, enums_p[u].ref, e->dsc);
2060 DUP_STRING(ctx->ctx, enums_p[u].ref, e->ref);
Radek Krejci693262f2019-04-29 15:23:20 +02002061 e->flags = enums_p[u].flags & LYS_FLAGS_COMPILED_MASK;
Radek Krejci19a96102018-11-15 13:38:09 +01002062 if (base_enums) {
2063 /* check the enum/bit presence in the base type - the set of enums/bits in the derived type must be a subset */
2064 LY_ARRAY_FOR(base_enums, v) {
2065 if (!strcmp(e->name, base_enums[v].name)) {
2066 break;
2067 }
2068 }
2069 if (v == LY_ARRAY_SIZE(base_enums)) {
2070 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2071 "Invalid %s - derived type adds new item \"%s\".",
2072 basetype == LY_TYPE_ENUM ? "enumeration" : "bits", e->name);
2073 return LY_EVALID;
2074 }
2075 match = v;
2076 }
2077
2078 if (basetype == LY_TYPE_ENUM) {
Radek Krejci693262f2019-04-29 15:23:20 +02002079 e->flags |= LYS_ISENUM;
Radek Krejci19a96102018-11-15 13:38:09 +01002080 if (enums_p[u].flags & LYS_SET_VALUE) {
2081 e->value = (int32_t)enums_p[u].value;
2082 if (!u || e->value >= value) {
2083 value = e->value + 1;
2084 }
2085 /* check collision with other values */
2086 for (v = 0; v < LY_ARRAY_SIZE(*enums) - 1; ++v) {
2087 if (e->value == (*enums)[v].value) {
2088 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2089 "Invalid enumeration - value %d collide in items \"%s\" and \"%s\".",
2090 e->value, e->name, (*enums)[v].name);
2091 return LY_EVALID;
2092 }
2093 }
2094 } else if (base_enums) {
2095 /* inherit the assigned value */
2096 e->value = base_enums[match].value;
2097 if (!u || e->value >= value) {
2098 value = e->value + 1;
2099 }
2100 } else {
2101 /* assign value automatically */
2102 if (u && value == INT32_MIN) {
2103 /* counter overflow */
2104 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2105 "Invalid enumeration - it is not possible to auto-assign enum value for "
2106 "\"%s\" since the highest value is already 2147483647.", e->name);
2107 return LY_EVALID;
2108 }
2109 e->value = value++;
2110 }
2111 } else { /* LY_TYPE_BITS */
2112 if (enums_p[u].flags & LYS_SET_VALUE) {
2113 e->value = (int32_t)enums_p[u].value;
2114 if (!u || (uint32_t)e->value >= position) {
2115 position = (uint32_t)e->value + 1;
2116 }
2117 /* check collision with other values */
2118 for (v = 0; v < LY_ARRAY_SIZE(*enums) - 1; ++v) {
2119 if (e->value == (*enums)[v].value) {
2120 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2121 "Invalid bits - position %u collide in items \"%s\" and \"%s\".",
2122 (uint32_t)e->value, e->name, (*enums)[v].name);
2123 return LY_EVALID;
2124 }
2125 }
2126 } else if (base_enums) {
2127 /* inherit the assigned value */
2128 e->value = base_enums[match].value;
2129 if (!u || (uint32_t)e->value >= position) {
2130 position = (uint32_t)e->value + 1;
2131 }
2132 } else {
2133 /* assign value automatically */
2134 if (u && position == 0) {
2135 /* counter overflow */
2136 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2137 "Invalid bits - it is not possible to auto-assign bit position for "
2138 "\"%s\" since the highest value is already 4294967295.", e->name);
2139 return LY_EVALID;
2140 }
2141 e->value = position++;
2142 }
2143 }
2144
2145 if (base_enums) {
2146 /* the assigned values must not change from the derived type */
2147 if (e->value != base_enums[match].value) {
2148 if (basetype == LY_TYPE_ENUM) {
2149 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2150 "Invalid enumeration - value of the item \"%s\" has changed from %d to %d in the derived type.",
2151 e->name, base_enums[match].value, e->value);
2152 } else {
2153 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2154 "Invalid bits - position of the item \"%s\" has changed from %u to %u in the derived type.",
2155 e->name, (uint32_t)base_enums[match].value, (uint32_t)e->value);
2156 }
2157 return LY_EVALID;
2158 }
2159 }
2160
Radek Krejciec4da802019-05-02 13:02:41 +02002161 COMPILE_ARRAY_GOTO(ctx, enums_p[u].iffeatures, e->iffeatures, v, lys_compile_iffeature, ret, done);
Radek Krejci0935f412019-08-20 16:15:18 +02002162 COMPILE_EXTS_GOTO(ctx, enums_p[u].exts, e->exts, e, basetype == LY_TYPE_ENUM ? LYEXT_PAR_TYPE_ENUM : LYEXT_PAR_TYPE_BIT, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01002163
2164 if (basetype == LY_TYPE_BITS) {
2165 /* keep bits ordered by position */
2166 for (v = u; v && (*enums)[v - 1].value > e->value; --v);
2167 if (v != u) {
2168 memcpy(&storage, e, sizeof *e);
2169 memmove(&(*enums)[v + 1], &(*enums)[v], (u - v) * sizeof **enums);
2170 memcpy(&(*enums)[v], &storage, sizeof storage);
2171 }
2172 }
2173 }
2174
2175done:
2176 return ret;
2177}
2178
Radek Krejcia3045382018-11-22 14:30:31 +01002179#define MOVE_PATH_PARENT(NODE, LIMIT_COND, TERM, ERR_MSG, ...) \
2180 for ((NODE) = (NODE)->parent; \
2181 (NODE) && !((NODE)->nodetype & (LYS_CONTAINER | LYS_LIST | LYS_ACTION | LYS_NOTIF | LYS_ACTION)); \
2182 (NODE) = (NODE)->parent); \
2183 if (!(NODE) && (LIMIT_COND)) { /* we are going higher than top-level */ \
2184 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, ERR_MSG, ##__VA_ARGS__); \
2185 TERM; \
2186 }
2187
2188/**
2189 * @brief Validate the predicate(s) from the leafref path.
2190 * @param[in] ctx Compile context
2191 * @param[in, out] predicate Pointer to the predicate in the leafref path. The pointer is moved after the validated predicate(s).
2192 * Since there can be multiple adjacent predicates for lists with multiple keys, all such predicates are validated.
Radek Krejci4ce68932018-11-28 12:53:36 +01002193 * @param[in] start_node Path context node (where the path is instantiated).
Radek Krejcia3045382018-11-22 14:30:31 +01002194 * @param[in] context_node Predicate context node (where the predicate is placed).
Radek Krejci96a0bfd2018-11-22 15:25:06 +01002195 * @param[in] path_context Schema where the path was defined to correct resolve of the prefixes.
Radek Krejcia3045382018-11-22 14:30:31 +01002196 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
2197 */
2198static LY_ERR
Radek Krejci4ce68932018-11-28 12:53:36 +01002199lys_compile_leafref_predicate_validate(struct lysc_ctx *ctx, const char **predicate, const struct lysc_node *start_node,
Radek Krejcibade82a2018-12-05 10:13:48 +01002200 const struct lysc_node_list *context_node, const struct lys_module *path_context)
Radek Krejcia3045382018-11-22 14:30:31 +01002201{
2202 LY_ERR ret = LY_EVALID;
2203 const struct lys_module *mod;
2204 const struct lysc_node *src_node, *dst_node;
2205 const char *path_key_expr, *pke_start, *src, *src_prefix, *dst, *dst_prefix;
2206 size_t src_len, src_prefix_len, dst_len, dst_prefix_len;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002207 unsigned int dest_parent_times, c;
Radek Krejcia3045382018-11-22 14:30:31 +01002208 const char *start, *end, *pke_end;
2209 struct ly_set keys = {0};
2210 int i;
2211
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002212 assert(path_context);
2213
Radek Krejcia3045382018-11-22 14:30:31 +01002214 while (**predicate == '[') {
2215 start = (*predicate)++;
2216
2217 while (isspace(**predicate)) {
2218 ++(*predicate);
2219 }
Radek Krejcib4a4a272019-06-10 12:44:52 +02002220 LY_CHECK_GOTO(ly_parse_nodeid(predicate, &src_prefix, &src_prefix_len, &src, &src_len), cleanup);
Radek Krejcia3045382018-11-22 14:30:31 +01002221 while (isspace(**predicate)) {
2222 ++(*predicate);
2223 }
2224 if (**predicate != '=') {
2225 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejcibade82a2018-12-05 10:13:48 +01002226 "Invalid leafref path predicate \"%.*s\" - missing \"=\" after node-identifier.",
2227 *predicate - start + 1, start);
Radek Krejcia3045382018-11-22 14:30:31 +01002228 goto cleanup;
2229 }
2230 ++(*predicate);
2231 while (isspace(**predicate)) {
2232 ++(*predicate);
2233 }
2234
2235 if ((end = pke_end = strchr(*predicate, ']')) == NULL) {
2236 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2237 "Invalid leafref path predicate \"%s\" - missing predicate termination.", start);
2238 goto cleanup;
2239 }
2240 --pke_end;
2241 while (isspace(*pke_end)) {
2242 --pke_end;
2243 }
Radek Krejci7adf4ff2018-12-05 08:55:00 +01002244 ++pke_end;
Radek Krejcia3045382018-11-22 14:30:31 +01002245 /* localize path-key-expr */
2246 pke_start = path_key_expr = *predicate;
2247 /* move after the current predicate */
2248 *predicate = end + 1;
2249
2250 /* source (must be leaf or leaf-list) */
2251 if (src_prefix) {
Radek Krejci96a0bfd2018-11-22 15:25:06 +01002252 mod = lys_module_find_prefix(path_context, src_prefix, src_prefix_len);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002253 if (!mod) {
2254 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2255 "Invalid leafref path predicate \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".",
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002256 *predicate - start, start, src_prefix_len, src_prefix, path_context->name);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002257 goto cleanup;
2258 }
Radek Krejci92cc8512019-04-25 09:57:06 +02002259 if (!mod->implemented) {
2260 /* make the module implemented */
2261 ly_ctx_module_implement_internal(ctx->ctx, (struct lys_module*)mod, 2);
2262 }
Radek Krejcia3045382018-11-22 14:30:31 +01002263 } else {
Radek Krejci4ce68932018-11-28 12:53:36 +01002264 mod = start_node->module;
Radek Krejcia3045382018-11-22 14:30:31 +01002265 }
Radek Krejcibade82a2018-12-05 10:13:48 +01002266 src_node = NULL;
Radek Krejci0fe9b512019-07-26 17:51:05 +02002267 if (!(context_node->flags & LYS_KEYLESS)) {
2268 struct lysc_node *key;
2269 for (key = context_node->child; key && key->nodetype == LYS_LEAF && (key->flags & LYS_KEY); key = key->next) {
2270 if (!strncmp(src, key->name, src_len) && key->name[src_len] == '\0') {
2271 src_node = key;
Radek Krejcibade82a2018-12-05 10:13:48 +01002272 break;
2273 }
2274 }
2275 }
Radek Krejcia3045382018-11-22 14:30:31 +01002276 if (!src_node) {
2277 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejcibade82a2018-12-05 10:13:48 +01002278 "Invalid leafref path predicate \"%.*s\" - predicate's key node \"%.*s\" not found.",
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002279 *predicate - start, start, src_len, src, mod->name);
Radek Krejcia3045382018-11-22 14:30:31 +01002280 goto cleanup;
2281 }
Radek Krejcia3045382018-11-22 14:30:31 +01002282
2283 /* check that there is only one predicate for the */
Radek Krejcibade82a2018-12-05 10:13:48 +01002284 c = keys.count;
Radek Krejcia3045382018-11-22 14:30:31 +01002285 i = ly_set_add(&keys, (void*)src_node, 0);
2286 LY_CHECK_GOTO(i == -1, cleanup);
Radek Krejcibade82a2018-12-05 10:13:48 +01002287 if (keys.count == c) { /* node was already present in the set */
Radek Krejcia3045382018-11-22 14:30:31 +01002288 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejcibade82a2018-12-05 10:13:48 +01002289 "Invalid leafref path predicate \"%.*s\" - multiple equality tests for the key \"%s\".",
Radek Krejcia3045382018-11-22 14:30:31 +01002290 *predicate - start, start, src_node->name);
2291 goto cleanup;
2292 }
2293
2294 /* destination */
2295 dest_parent_times = 0;
Radek Krejci4ce68932018-11-28 12:53:36 +01002296 dst_node = start_node;
Radek Krejcia3045382018-11-22 14:30:31 +01002297
2298 /* current-function-invocation *WSP "/" *WSP rel-path-keyexpr */
Radek Krejci7a3f89f2019-07-12 11:17:33 +02002299 if (strncmp(path_key_expr, "current", 7)) {
2300error_current_function_invocation:
Radek Krejcia3045382018-11-22 14:30:31 +01002301 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2302 "Invalid leafref path predicate \"%.*s\" - missing current-function-invocation.",
2303 *predicate - start, start);
2304 goto cleanup;
2305 }
Radek Krejci7a3f89f2019-07-12 11:17:33 +02002306 for (path_key_expr += 7; isspace(*path_key_expr); ++path_key_expr);
2307 if (*path_key_expr != '(') {
2308 goto error_current_function_invocation;
Radek Krejcia3045382018-11-22 14:30:31 +01002309 }
Radek Krejci7a3f89f2019-07-12 11:17:33 +02002310 for (path_key_expr++; isspace(*path_key_expr); ++path_key_expr);
2311 if (*path_key_expr != ')') {
2312 goto error_current_function_invocation;
2313 }
2314 for (path_key_expr++; isspace(*path_key_expr); ++path_key_expr);
Radek Krejcia3045382018-11-22 14:30:31 +01002315
2316 if (*path_key_expr != '/') {
2317 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2318 "Invalid leafref path predicate \"%.*s\" - missing \"/\" after current-function-invocation.",
2319 *predicate - start, start);
2320 goto cleanup;
2321 }
2322 ++path_key_expr;
2323 while (isspace(*path_key_expr)) {
2324 ++path_key_expr;
2325 }
2326
2327 /* rel-path-keyexpr:
2328 * 1*(".." *WSP "/" *WSP) *(node-identifier *WSP "/" *WSP) node-identifier */
2329 while (!strncmp(path_key_expr, "..", 2)) {
2330 ++dest_parent_times;
2331 path_key_expr += 2;
2332 while (isspace(*path_key_expr)) {
2333 ++path_key_expr;
2334 }
2335 if (*path_key_expr != '/') {
2336 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2337 "Invalid leafref path predicate \"%.*s\" - missing \"/\" in \"../\" rel-path-keyexpr pattern.",
2338 *predicate - start, start);
2339 goto cleanup;
2340 }
2341 ++path_key_expr;
2342 while (isspace(*path_key_expr)) {
2343 ++path_key_expr;
2344 }
2345
2346 /* path is supposed to be evaluated in data tree, so we have to skip
2347 * all schema nodes that cannot be instantiated in data tree */
2348 MOVE_PATH_PARENT(dst_node, !strncmp(path_key_expr, "..", 2), goto cleanup,
2349 "Invalid leafref path predicate \"%.*s\" - too many \"..\" in rel-path-keyexpr.",
2350 *predicate - start, start);
2351 }
2352 if (!dest_parent_times) {
2353 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2354 "Invalid leafref path predicate \"%.*s\" - at least one \"..\" is expected in rel-path-keyexpr.",
2355 *predicate - start, start);
2356 goto cleanup;
2357 }
2358 if (path_key_expr == pke_end) {
2359 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2360 "Invalid leafref path predicate \"%.*s\" - at least one node-identifier is expected in rel-path-keyexpr.",
2361 *predicate - start, start);
2362 goto cleanup;
2363 }
2364
2365 while(path_key_expr != pke_end) {
Radek Krejci7a3f89f2019-07-12 11:17:33 +02002366 for (;*path_key_expr == '/' || isspace(*path_key_expr); ++path_key_expr);
Radek Krejcib4a4a272019-06-10 12:44:52 +02002367 if (ly_parse_nodeid(&path_key_expr, &dst_prefix, &dst_prefix_len, &dst, &dst_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +01002368 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejcibade82a2018-12-05 10:13:48 +01002369 "Invalid node identifier in leafref path predicate - character %d (of %.*s).",
2370 path_key_expr - start + 1, *predicate - start, start);
Radek Krejcia3045382018-11-22 14:30:31 +01002371 goto cleanup;
2372 }
2373
2374 if (dst_prefix) {
Radek Krejci96a0bfd2018-11-22 15:25:06 +01002375 mod = lys_module_find_prefix(path_context, dst_prefix, dst_prefix_len);
Radek Krejcia3045382018-11-22 14:30:31 +01002376 } else {
Radek Krejci4ce68932018-11-28 12:53:36 +01002377 mod = start_node->module;
Radek Krejcia3045382018-11-22 14:30:31 +01002378 }
2379 if (!mod) {
2380 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci92cc8512019-04-25 09:57:06 +02002381 "Invalid leafref path predicate \"%.*s\" - unable to find module of the node \"%.*s\" in rel-path-keyexpr.",
Radek Krejcia3045382018-11-22 14:30:31 +01002382 *predicate - start, start, dst_len, dst);
2383 goto cleanup;
2384 }
Radek Krejci92cc8512019-04-25 09:57:06 +02002385 if (!mod->implemented) {
2386 /* make the module implemented */
2387 ly_ctx_module_implement_internal(ctx->ctx, (struct lys_module*)mod, 2);
2388 }
Radek Krejcia3045382018-11-22 14:30:31 +01002389
2390 dst_node = lys_child(dst_node, mod, dst, dst_len, 0, LYS_GETNEXT_NOSTATECHECK);
2391 if (!dst_node) {
2392 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci92cc8512019-04-25 09:57:06 +02002393 "Invalid leafref path predicate \"%.*s\" - unable to find node \"%.*s\" in the rel-path-keyexpr.",
Radek Krejcia3045382018-11-22 14:30:31 +01002394 *predicate - start, start, path_key_expr - pke_start, pke_start);
2395 goto cleanup;
2396 }
2397 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002398 if (!(dst_node->nodetype & (dst_node->module->version < LYS_VERSION_1_1 ? LYS_LEAF : LYS_LEAF | LYS_LEAFLIST))) {
Radek Krejcia3045382018-11-22 14:30:31 +01002399 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci92cc8512019-04-25 09:57:06 +02002400 "Invalid leafref path predicate \"%.*s\" - rel-path-keyexpr \"%.*s\" refers %s instead of leaf.",
Radek Krejcia3045382018-11-22 14:30:31 +01002401 *predicate - start, start, path_key_expr - pke_start, pke_start, lys_nodetype2str(dst_node->nodetype));
2402 goto cleanup;
2403 }
2404 }
2405
2406 ret = LY_SUCCESS;
2407cleanup:
2408 ly_set_erase(&keys, NULL);
2409 return ret;
2410}
2411
2412/**
2413 * @brief Parse path-arg (leafref). Get tokens of the path by repetitive calls of the function.
2414 *
2415 * path-arg = absolute-path / relative-path
2416 * absolute-path = 1*("/" (node-identifier *path-predicate))
2417 * relative-path = 1*(".." "/") descendant-path
2418 *
2419 * @param[in,out] path Path to parse.
2420 * @param[out] prefix Prefix of the token, NULL if there is not any.
2421 * @param[out] pref_len Length of the prefix, 0 if there is not any.
2422 * @param[out] name Name of the token.
2423 * @param[out] nam_len Length of the name.
2424 * @param[out] parent_times Number of leading ".." in the path. Must be 0 on the first call,
2425 * must not be changed between consecutive calls. -1 if the
2426 * path is absolute.
2427 * @param[out] has_predicate Flag to mark whether there is a predicate specified.
2428 * @return LY_ERR value: LY_SUCCESS or LY_EINVAL in case of invalid character in the path.
2429 */
Radek Krejci2d7a47b2019-05-16 13:34:10 +02002430LY_ERR
Radek Krejcia3045382018-11-22 14:30:31 +01002431lys_path_token(const char **path, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len,
2432 int *parent_times, int *has_predicate)
2433{
2434 int par_times = 0;
2435
2436 assert(path && *path);
2437 assert(parent_times);
2438 assert(prefix);
2439 assert(prefix_len);
2440 assert(name);
2441 assert(name_len);
2442 assert(has_predicate);
2443
2444 *prefix = NULL;
2445 *prefix_len = 0;
2446 *name = NULL;
2447 *name_len = 0;
2448 *has_predicate = 0;
2449
2450 if (!*parent_times) {
2451 if (!strncmp(*path, "..", 2)) {
2452 *path += 2;
2453 ++par_times;
2454 while (!strncmp(*path, "/..", 3)) {
2455 *path += 3;
2456 ++par_times;
2457 }
2458 }
2459 if (par_times) {
2460 *parent_times = par_times;
2461 } else {
2462 *parent_times = -1;
2463 }
2464 }
2465
2466 if (**path != '/') {
2467 return LY_EINVAL;
2468 }
2469 /* skip '/' */
2470 ++(*path);
2471
2472 /* node-identifier ([prefix:]name) */
Radek Krejcib4a4a272019-06-10 12:44:52 +02002473 LY_CHECK_RET(ly_parse_nodeid(path, prefix, prefix_len, name, name_len));
Radek Krejcia3045382018-11-22 14:30:31 +01002474
2475 if ((**path == '/' && (*path)[1]) || !**path) {
2476 /* path continues by another token or this is the last token */
2477 return LY_SUCCESS;
2478 } else if ((*path)[0] != '[') {
2479 /* unexpected character */
2480 return LY_EINVAL;
2481 } else {
2482 /* predicate starting with [ */
2483 *has_predicate = 1;
2484 return LY_SUCCESS;
2485 }
2486}
2487
2488/**
Radek Krejci58d171e2018-11-23 13:50:55 +01002489 * @brief Check the features used in if-feature statements applicable to the leafref and its target.
2490 *
2491 * The set of features used for target must be a subset of features used for the leafref.
2492 * This is not a perfect, we should compare the truth tables but it could require too much resources
2493 * and RFC 7950 does not require it explicitely, so we simplify that.
2494 *
2495 * @param[in] refnode The leafref node.
2496 * @param[in] target Tha target node of the leafref.
2497 * @return LY_SUCCESS or LY_EVALID;
2498 */
2499static LY_ERR
2500lys_compile_leafref_features_validate(const struct lysc_node *refnode, const struct lysc_node *target)
2501{
2502 LY_ERR ret = LY_EVALID;
2503 const struct lysc_node *iter;
Radek Krejci58d171e2018-11-23 13:50:55 +01002504 unsigned int u, v, count;
2505 struct ly_set features = {0};
2506
2507 for (iter = refnode; iter; iter = iter->parent) {
Radek Krejci056d0a82018-12-06 16:57:25 +01002508 if (iter->iffeatures) {
2509 LY_ARRAY_FOR(iter->iffeatures, u) {
2510 LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
2511 LY_CHECK_GOTO(ly_set_add(&features, iter->iffeatures[u].features[v], 0) == -1, cleanup);
Radek Krejci58d171e2018-11-23 13:50:55 +01002512 }
2513 }
2514 }
2515 }
2516
2517 /* we should have, in features set, a superset of features applicable to the target node.
2518 * So when adding features applicable to the target into the features set, we should not be
2519 * able to actually add any new feature, otherwise it is not a subset of features applicable
2520 * to the leafref itself. */
2521 count = features.count;
2522 for (iter = target; iter; iter = iter->parent) {
Radek Krejci056d0a82018-12-06 16:57:25 +01002523 if (iter->iffeatures) {
2524 LY_ARRAY_FOR(iter->iffeatures, u) {
2525 LY_ARRAY_FOR(iter->iffeatures[u].features, v) {
2526 if ((unsigned int)ly_set_add(&features, iter->iffeatures[u].features[v], 0) >= count) {
Radek Krejci58d171e2018-11-23 13:50:55 +01002527 /* new feature was added (or LY_EMEM) */
2528 goto cleanup;
2529 }
2530 }
2531 }
2532 }
2533 }
2534 ret = LY_SUCCESS;
2535
2536cleanup:
2537 ly_set_erase(&features, NULL);
2538 return ret;
2539}
2540
2541/**
Radek Krejcia3045382018-11-22 14:30:31 +01002542 * @brief Validate the leafref path.
2543 * @param[in] ctx Compile context
2544 * @param[in] startnode Path context node (where the leafref path begins/is placed).
Radek Krejci412ddfa2018-11-23 11:44:11 +01002545 * @param[in] leafref Leafref to validate.
Radek Krejcia3045382018-11-22 14:30:31 +01002546 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
2547 */
2548static LY_ERR
Radek Krejci412ddfa2018-11-23 11:44:11 +01002549lys_compile_leafref_validate(struct lysc_ctx *ctx, struct lysc_node *startnode, struct lysc_type_leafref *leafref)
Radek Krejcia3045382018-11-22 14:30:31 +01002550{
2551 const struct lysc_node *node = NULL, *parent = NULL;
2552 const struct lys_module *mod;
Radek Krejci412ddfa2018-11-23 11:44:11 +01002553 struct lysc_type *type;
Radek Krejcia3045382018-11-22 14:30:31 +01002554 const char *id, *prefix, *name;
2555 size_t prefix_len, name_len;
2556 int parent_times = 0, has_predicate;
2557 unsigned int iter, u;
2558 LY_ERR ret = LY_SUCCESS;
2559
2560 assert(ctx);
2561 assert(startnode);
Radek Krejci412ddfa2018-11-23 11:44:11 +01002562 assert(leafref);
2563
Radek Krejci1c0c3442019-07-23 16:08:47 +02002564 ctx->path[0] = '\0';
2565 lysc_path(startnode, LY_PATH_LOG, ctx->path, LYSC_CTX_BUFSIZE);
2566 ctx->path_len = strlen(ctx->path);
Radek Krejci327de162019-06-14 12:52:07 +02002567
Radek Krejcia3045382018-11-22 14:30:31 +01002568 iter = 0;
Radek Krejci412ddfa2018-11-23 11:44:11 +01002569 id = leafref->path;
Radek Krejcia3045382018-11-22 14:30:31 +01002570 while(*id && (ret = lys_path_token(&id, &prefix, &prefix_len, &name, &name_len, &parent_times, &has_predicate)) == LY_SUCCESS) {
2571 if (!iter) { /* first iteration */
2572 /* precess ".." in relative paths */
2573 if (parent_times > 0) {
2574 /* move from the context node */
2575 for (u = 0, parent = startnode; u < (unsigned int)parent_times; u++) {
2576 /* path is supposed to be evaluated in data tree, so we have to skip
2577 * all schema nodes that cannot be instantiated in data tree */
2578 MOVE_PATH_PARENT(parent, u < (unsigned int)parent_times - 1, return LY_EVALID,
Radek Krejci412ddfa2018-11-23 11:44:11 +01002579 "Invalid leafref path \"%s\" - too many \"..\" in the path.", leafref->path);
Radek Krejcia3045382018-11-22 14:30:31 +01002580 }
2581 }
2582 }
2583
2584 if (prefix) {
Radek Krejci412ddfa2018-11-23 11:44:11 +01002585 mod = lys_module_find_prefix(leafref->path_context, prefix, prefix_len);
Radek Krejcia3045382018-11-22 14:30:31 +01002586 } else {
Radek Krejci4ce68932018-11-28 12:53:36 +01002587 mod = startnode->module;
Radek Krejcia3045382018-11-22 14:30:31 +01002588 }
2589 if (!mod) {
2590 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci412ddfa2018-11-23 11:44:11 +01002591 "Invalid leafref path - unable to find module connected with the prefix of the node \"%.*s\".",
2592 id - leafref->path, leafref->path);
Radek Krejcia3045382018-11-22 14:30:31 +01002593 return LY_EVALID;
2594 }
Radek Krejci3d929562019-02-21 11:25:55 +01002595 if (!mod->implemented) {
2596 /* make the module implemented */
2597 ly_ctx_module_implement_internal(ctx->ctx, (struct lys_module*)mod, 2);
2598 }
Radek Krejcia3045382018-11-22 14:30:31 +01002599
2600 node = lys_child(parent, mod, name, name_len, 0, LYS_GETNEXT_NOSTATECHECK);
2601 if (!node) {
2602 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci412ddfa2018-11-23 11:44:11 +01002603 "Invalid leafref path - unable to find \"%.*s\".", id - leafref->path, leafref->path);
Radek Krejcia3045382018-11-22 14:30:31 +01002604 return LY_EVALID;
2605 }
2606 parent = node;
2607
2608 if (has_predicate) {
2609 /* we have predicate, so the current result must be list */
2610 if (node->nodetype != LYS_LIST) {
2611 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2612 "Invalid leafref path - node \"%.*s\" is expected to be a list, but it is %s.",
Radek Krejci412ddfa2018-11-23 11:44:11 +01002613 id - leafref->path, leafref->path, lys_nodetype2str(node->nodetype));
Radek Krejcia3045382018-11-22 14:30:31 +01002614 return LY_EVALID;
2615 }
2616
Radek Krejcibade82a2018-12-05 10:13:48 +01002617 LY_CHECK_RET(lys_compile_leafref_predicate_validate(ctx, &id, startnode, (struct lysc_node_list*)node, leafref->path_context),
2618 LY_EVALID);
Radek Krejcia3045382018-11-22 14:30:31 +01002619 }
2620
2621 ++iter;
2622 }
2623 if (ret) {
2624 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejci412ddfa2018-11-23 11:44:11 +01002625 "Invalid leafref path at character %d (%s).", id - leafref->path + 1, leafref->path);
Radek Krejcia3045382018-11-22 14:30:31 +01002626 return LY_EVALID;
2627 }
2628
2629 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST))) {
2630 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2631 "Invalid leafref path \"%s\" - target node is %s instead of leaf or leaf-list.",
Radek Krejci412ddfa2018-11-23 11:44:11 +01002632 leafref->path, lys_nodetype2str(node->nodetype));
Radek Krejcia3045382018-11-22 14:30:31 +01002633 return LY_EVALID;
2634 }
2635
2636 /* check status */
2637 if (lysc_check_status(ctx, startnode->flags, startnode->module, startnode->name, node->flags, node->module, node->name)) {
2638 return LY_EVALID;
2639 }
2640
Radek Krejcib57cf1e2018-11-23 14:07:05 +01002641 /* check config */
2642 if (leafref->require_instance && (startnode->flags & LYS_CONFIG_W)) {
2643 if (node->flags & LYS_CONFIG_R) {
2644 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2645 "Invalid leafref path \"%s\" - target is supposed to represent configuration data (as the leafref does), but it does not.",
2646 leafref->path);
2647 return LY_EVALID;
2648 }
2649 }
2650
Radek Krejci412ddfa2018-11-23 11:44:11 +01002651 /* store the target's type and check for circular chain of leafrefs */
2652 leafref->realtype = ((struct lysc_node_leaf*)node)->type;
2653 for (type = leafref->realtype; type && type->basetype == LY_TYPE_LEAFREF; type = ((struct lysc_type_leafref*)type)->realtype) {
2654 if (type == (struct lysc_type*)leafref) {
2655 /* circular chain detected */
2656 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2657 "Invalid leafref path \"%s\" - circular chain of leafrefs detected.", leafref->path);
2658 return LY_EVALID;
2659 }
2660 }
2661
Radek Krejci58d171e2018-11-23 13:50:55 +01002662 /* check if leafref and its target are under common if-features */
2663 if (lys_compile_leafref_features_validate(startnode, node)) {
2664 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
2665 "Invalid leafref path \"%s\" - set of features applicable to the leafref target is not a subset of features applicable to the leafref itself.",
2666 leafref->path);
2667 return LY_EVALID;
2668 }
2669
Radek Krejci327de162019-06-14 12:52:07 +02002670 ctx->path_len = 1;
2671 ctx->path[1] = '\0';
Radek Krejcia3045382018-11-22 14:30:31 +01002672 return LY_SUCCESS;
2673}
2674
Radek Krejcicdfecd92018-11-26 11:27:32 +01002675static LY_ERR lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags, struct lysp_module *context_mod, const char *context_name,
Radek Krejciec4da802019-05-02 13:02:41 +02002676 struct lysp_type *type_p, struct lysc_type **type, const char **units);
Radek Krejcia3045382018-11-22 14:30:31 +01002677/**
2678 * @brief The core of the lys_compile_type() - compile information about the given type (from typedef or leaf/leaf-list).
2679 * @param[in] ctx Compile context.
Radek Krejcicdfecd92018-11-26 11:27:32 +01002680 * @param[in] context_node_p Schema node where the type/typedef is placed to correctly find the base types.
2681 * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2682 * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
2683 * @param[in] context_name Name of the context node or referencing typedef for logging.
Radek Krejcia3045382018-11-22 14:30:31 +01002684 * @param[in] type_p Parsed type to compile.
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002685 * @param[in] module Context module for the leafref path (to correctly resolve prefixes in path)
Radek Krejcia3045382018-11-22 14:30:31 +01002686 * @param[in] basetype Base YANG built-in type of the type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01002687 * @param[in] tpdfname Name of the type's typedef, serves as a flag - if it is leaf/leaf-list's type, it is NULL.
2688 * @param[in] base The latest base (compiled) type from which the current type is being derived.
2689 * @param[out] type Newly created type structure with the filled information about the type.
2690 * @return LY_ERR value.
2691 */
Radek Krejci19a96102018-11-15 13:38:09 +01002692static LY_ERR
Radek Krejcicdfecd92018-11-26 11:27:32 +01002693lys_compile_type_(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags, struct lysp_module *context_mod, const char *context_name,
Radek Krejciec4da802019-05-02 13:02:41 +02002694 struct lysp_type *type_p, struct lys_module *module, LY_DATA_TYPE basetype, const char *tpdfname,
Radek Krejcicdfecd92018-11-26 11:27:32 +01002695 struct lysc_type *base, struct lysc_type **type)
Radek Krejcic5c27e52018-11-15 14:38:11 +01002696{
2697 LY_ERR ret = LY_SUCCESS;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002698 unsigned int u, v, additional;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002699 struct lysc_type_bin *bin;
2700 struct lysc_type_num *num;
2701 struct lysc_type_str *str;
2702 struct lysc_type_bits *bits;
2703 struct lysc_type_enum *enumeration;
Radek Krejci6cba4292018-11-15 17:33:29 +01002704 struct lysc_type_dec *dec;
Radek Krejci555cb5b2018-11-16 14:54:33 +01002705 struct lysc_type_identityref *idref;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002706 struct lysc_type_union *un, *un_aux;
2707 void *p;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002708
2709 switch (basetype) {
2710 case LY_TYPE_BINARY:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002711 bin = (struct lysc_type_bin*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002712
2713 /* RFC 7950 9.8.1, 9.4.4 - length, number of octets it contains */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002714 if (type_p->length) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002715 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
2716 base ? ((struct lysc_type_bin*)base)->length : NULL, &bin->length));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002717 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002718 COMPILE_EXTS_GOTO(ctx, type_p->length->exts, bin->length->exts, bin->length, LYEXT_PAR_LENGTH, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002719 }
2720 }
2721
2722 if (tpdfname) {
2723 type_p->compiled = *type;
2724 *type = calloc(1, sizeof(struct lysc_type_bin));
2725 }
2726 break;
2727 case LY_TYPE_BITS:
2728 /* RFC 7950 9.7 - bits */
2729 bits = (struct lysc_type_bits*)(*type);
2730 if (type_p->bits) {
Radek Krejciec4da802019-05-02 13:02:41 +02002731 LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->bits, basetype,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002732 base ? (struct lysc_type_bitenum_item*)((struct lysc_type_bits*)base)->bits : NULL,
2733 (struct lysc_type_bitenum_item**)&bits->bits));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002734 }
2735
Radek Krejci555cb5b2018-11-16 14:54:33 +01002736 if (!base && !type_p->flags) {
Radek Krejcic5c27e52018-11-15 14:38:11 +01002737 /* type derived from bits built-in type must contain at least one bit */
Radek Krejci6cba4292018-11-15 17:33:29 +01002738 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002739 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type ", tpdfname);
Radek Krejci6cba4292018-11-15 17:33:29 +01002740 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002741 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "bit", "bits type", "");
Radek Krejci6cba4292018-11-15 17:33:29 +01002742 free(*type);
2743 *type = NULL;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002744 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002745 return LY_EVALID;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002746 }
2747
2748 if (tpdfname) {
2749 type_p->compiled = *type;
2750 *type = calloc(1, sizeof(struct lysc_type_bits));
2751 }
2752 break;
Radek Krejci6cba4292018-11-15 17:33:29 +01002753 case LY_TYPE_DEC64:
2754 dec = (struct lysc_type_dec*)(*type);
2755
2756 /* RFC 7950 9.3.4 - fraction-digits */
Radek Krejci555cb5b2018-11-16 14:54:33 +01002757 if (!base) {
Radek Krejci643c8242018-11-15 17:51:11 +01002758 if (!type_p->fraction_digits) {
2759 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002760 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type ", tpdfname);
Radek Krejci643c8242018-11-15 17:51:11 +01002761 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002762 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "fraction-digits", "decimal64 type", "");
Radek Krejci643c8242018-11-15 17:51:11 +01002763 free(*type);
2764 *type = NULL;
2765 }
2766 return LY_EVALID;
2767 }
2768 } else if (type_p->fraction_digits) {
2769 /* fraction digits is prohibited in types not directly derived from built-in decimal64 */
Radek Krejci6cba4292018-11-15 17:33:29 +01002770 if (tpdfname) {
Radek Krejci643c8242018-11-15 17:51:11 +01002771 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2772 "Invalid fraction-digits substatement for type \"%s\" not directly derived from decimal64 built-in type.",
Radek Krejci6cba4292018-11-15 17:33:29 +01002773 tpdfname);
2774 } else {
Radek Krejci643c8242018-11-15 17:51:11 +01002775 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2776 "Invalid fraction-digits substatement for type not directly derived from decimal64 built-in type.");
Radek Krejci6cba4292018-11-15 17:33:29 +01002777 free(*type);
2778 *type = NULL;
2779 }
2780 return LY_EVALID;
2781 }
2782 dec->fraction_digits = type_p->fraction_digits;
2783
2784 /* RFC 7950 9.2.4 - range */
2785 if (type_p->range) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002786 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, dec->fraction_digits,
2787 base ? ((struct lysc_type_dec*)base)->range : NULL, &dec->range));
Radek Krejci6cba4292018-11-15 17:33:29 +01002788 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002789 COMPILE_EXTS_GOTO(ctx, type_p->range->exts, dec->range->exts, dec->range, LYEXT_PAR_RANGE, ret, done);
Radek Krejci6cba4292018-11-15 17:33:29 +01002790 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002791 }
2792
2793 if (tpdfname) {
2794 type_p->compiled = *type;
2795 *type = calloc(1, sizeof(struct lysc_type_dec));
2796 }
2797 break;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002798 case LY_TYPE_STRING:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002799 str = (struct lysc_type_str*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002800
2801 /* RFC 7950 9.4.4 - length */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002802 if (type_p->length) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002803 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->length, basetype, 1, 0,
2804 base ? ((struct lysc_type_str*)base)->length : NULL, &str->length));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002805 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002806 COMPILE_EXTS_GOTO(ctx, type_p->length->exts, str->length->exts, str->length, LYEXT_PAR_LENGTH, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002807 }
2808 } else if (base && ((struct lysc_type_str*)base)->length) {
2809 str->length = lysc_range_dup(ctx->ctx, ((struct lysc_type_str*)base)->length);
2810 }
2811
2812 /* RFC 7950 9.4.5 - pattern */
2813 if (type_p->patterns) {
Radek Krejciec4da802019-05-02 13:02:41 +02002814 LY_CHECK_RET(lys_compile_type_patterns(ctx, type_p->patterns,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002815 base ? ((struct lysc_type_str*)base)->patterns : NULL, &str->patterns));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002816 } else if (base && ((struct lysc_type_str*)base)->patterns) {
2817 str->patterns = lysc_patterns_dup(ctx->ctx, ((struct lysc_type_str*)base)->patterns);
2818 }
2819
2820 if (tpdfname) {
2821 type_p->compiled = *type;
2822 *type = calloc(1, sizeof(struct lysc_type_str));
2823 }
2824 break;
2825 case LY_TYPE_ENUM:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002826 enumeration = (struct lysc_type_enum*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002827
2828 /* RFC 7950 9.6 - enum */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002829 if (type_p->enums) {
Radek Krejciec4da802019-05-02 13:02:41 +02002830 LY_CHECK_RET(lys_compile_type_enums(ctx, type_p->enums, basetype,
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002831 base ? ((struct lysc_type_enum*)base)->enums : NULL, &enumeration->enums));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002832 }
2833
Radek Krejci555cb5b2018-11-16 14:54:33 +01002834 if (!base && !type_p->flags) {
Radek Krejcic5c27e52018-11-15 14:38:11 +01002835 /* type derived from enumerations built-in type must contain at least one enum */
Radek Krejci6cba4292018-11-15 17:33:29 +01002836 if (tpdfname) {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002837 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type ", tpdfname);
Radek Krejci6cba4292018-11-15 17:33:29 +01002838 } else {
Radek Krejci555cb5b2018-11-16 14:54:33 +01002839 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "enum", "enumeration type", "");
Radek Krejci6cba4292018-11-15 17:33:29 +01002840 free(*type);
2841 *type = NULL;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002842 }
Radek Krejci6cba4292018-11-15 17:33:29 +01002843 return LY_EVALID;
Radek Krejcic5c27e52018-11-15 14:38:11 +01002844 }
2845
2846 if (tpdfname) {
2847 type_p->compiled = *type;
2848 *type = calloc(1, sizeof(struct lysc_type_enum));
2849 }
2850 break;
2851 case LY_TYPE_INT8:
2852 case LY_TYPE_UINT8:
2853 case LY_TYPE_INT16:
2854 case LY_TYPE_UINT16:
2855 case LY_TYPE_INT32:
2856 case LY_TYPE_UINT32:
2857 case LY_TYPE_INT64:
2858 case LY_TYPE_UINT64:
Radek Krejcic5c27e52018-11-15 14:38:11 +01002859 num = (struct lysc_type_num*)(*type);
Radek Krejci555cb5b2018-11-16 14:54:33 +01002860
2861 /* RFC 6020 9.2.4 - range */
Radek Krejcic5c27e52018-11-15 14:38:11 +01002862 if (type_p->range) {
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002863 LY_CHECK_RET(lys_compile_type_range(ctx, type_p->range, basetype, 0, 0,
2864 base ? ((struct lysc_type_num*)base)->range : NULL, &num->range));
Radek Krejcic5c27e52018-11-15 14:38:11 +01002865 if (!tpdfname) {
Radek Krejci0935f412019-08-20 16:15:18 +02002866 COMPILE_EXTS_GOTO(ctx, type_p->range->exts, num->range->exts, num->range, LYEXT_PAR_RANGE, ret, done);
Radek Krejcic5c27e52018-11-15 14:38:11 +01002867 }
2868 }
2869
2870 if (tpdfname) {
2871 type_p->compiled = *type;
2872 *type = calloc(1, sizeof(struct lysc_type_num));
2873 }
2874 break;
Radek Krejci555cb5b2018-11-16 14:54:33 +01002875 case LY_TYPE_IDENT:
2876 idref = (struct lysc_type_identityref*)(*type);
2877
2878 /* RFC 7950 9.10.2 - base */
2879 if (type_p->bases) {
2880 if (base) {
2881 /* only the directly derived identityrefs can contain base specification */
2882 if (tpdfname) {
2883 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejcicdfecd92018-11-26 11:27:32 +01002884 "Invalid base substatement for the type \"%s\" not directly derived from identityref built-in type.",
Radek Krejci555cb5b2018-11-16 14:54:33 +01002885 tpdfname);
2886 } else {
2887 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
Radek Krejcicdfecd92018-11-26 11:27:32 +01002888 "Invalid base substatement for the type not directly derived from identityref built-in type.");
Radek Krejci555cb5b2018-11-16 14:54:33 +01002889 free(*type);
2890 *type = NULL;
2891 }
2892 return LY_EVALID;
2893 }
Radek Krejci99b5b2a2019-04-30 16:57:04 +02002894 LY_CHECK_RET(lys_compile_identity_bases(ctx, type_p->bases, NULL, &idref->bases));
Radek Krejci555cb5b2018-11-16 14:54:33 +01002895 }
2896
2897 if (!base && !type_p->flags) {
2898 /* type derived from identityref built-in type must contain at least one base */
2899 if (tpdfname) {
2900 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type ", tpdfname);
2901 } else {
2902 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "base", "identityref type", "");
2903 free(*type);
2904 *type = NULL;
2905 }
2906 return LY_EVALID;
2907 }
2908
2909 if (tpdfname) {
2910 type_p->compiled = *type;
2911 *type = calloc(1, sizeof(struct lysc_type_identityref));
2912 }
2913 break;
Radek Krejcia3045382018-11-22 14:30:31 +01002914 case LY_TYPE_LEAFREF:
2915 /* RFC 7950 9.9.3 - require-instance */
2916 if (type_p->flags & LYS_SET_REQINST) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +01002917 if (context_mod->mod->version < LYS_VERSION_1_1) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01002918 if (tpdfname) {
2919 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
2920 "Leafref type \"%s\" can be restricted by require-instance statement only in YANG 1.1 modules.", tpdfname);
2921 } else {
2922 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
2923 "Leafref type can be restricted by require-instance statement only in YANG 1.1 modules.");
2924 free(*type);
2925 *type = NULL;
2926 }
2927 return LY_EVALID;
2928 }
Radek Krejcia3045382018-11-22 14:30:31 +01002929 ((struct lysc_type_leafref*)(*type))->require_instance = type_p->require_instance;
Radek Krejci412ddfa2018-11-23 11:44:11 +01002930 } else if (base) {
2931 /* inherit */
2932 ((struct lysc_type_leafref*)(*type))->require_instance = ((struct lysc_type_leafref*)base)->require_instance;
Radek Krejcia3045382018-11-22 14:30:31 +01002933 } else {
2934 /* default is true */
2935 ((struct lysc_type_leafref*)(*type))->require_instance = 1;
2936 }
2937 if (type_p->path) {
2938 DUP_STRING(ctx->ctx, (void*)type_p->path, ((struct lysc_type_leafref*)(*type))->path);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01002939 ((struct lysc_type_leafref*)(*type))->path_context = module;
Radek Krejcia3045382018-11-22 14:30:31 +01002940 } else if (base) {
2941 DUP_STRING(ctx->ctx, ((struct lysc_type_leafref*)base)->path, ((struct lysc_type_leafref*)(*type))->path);
Radek Krejci96a0bfd2018-11-22 15:25:06 +01002942 ((struct lysc_type_leafref*)(*type))->path_context = ((struct lysc_type_leafref*)base)->path_context;
Radek Krejcia3045382018-11-22 14:30:31 +01002943 } else if (tpdfname) {
2944 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type ", tpdfname);
2945 return LY_EVALID;
2946 } else {
2947 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "path", "leafref type", "");
2948 free(*type);
2949 *type = NULL;
2950 return LY_EVALID;
2951 }
2952 if (tpdfname) {
2953 type_p->compiled = *type;
2954 *type = calloc(1, sizeof(struct lysc_type_leafref));
2955 }
2956 break;
Radek Krejci16c0f822018-11-16 10:46:10 +01002957 case LY_TYPE_INST:
2958 /* RFC 7950 9.9.3 - require-instance */
2959 if (type_p->flags & LYS_SET_REQINST) {
2960 ((struct lysc_type_instanceid*)(*type))->require_instance = type_p->require_instance;
2961 } else {
2962 /* default is true */
2963 ((struct lysc_type_instanceid*)(*type))->require_instance = 1;
2964 }
2965
2966 if (tpdfname) {
2967 type_p->compiled = *type;
2968 *type = calloc(1, sizeof(struct lysc_type_instanceid));
2969 }
2970 break;
Radek Krejcicdfecd92018-11-26 11:27:32 +01002971 case LY_TYPE_UNION:
2972 un = (struct lysc_type_union*)(*type);
2973
2974 /* RFC 7950 7.4 - type */
2975 if (type_p->types) {
2976 if (base) {
2977 /* only the directly derived union can contain types specification */
2978 if (tpdfname) {
2979 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2980 "Invalid type substatement for the type \"%s\" not directly derived from union built-in type.",
2981 tpdfname);
2982 } else {
2983 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG,
2984 "Invalid type substatement for the type not directly derived from union built-in type.");
2985 free(*type);
2986 *type = NULL;
2987 }
2988 return LY_EVALID;
2989 }
2990 /* compile the type */
2991 additional = 0;
2992 LY_ARRAY_CREATE_RET(ctx->ctx, un->types, LY_ARRAY_SIZE(type_p->types), LY_EVALID);
2993 for (u = 0; u < LY_ARRAY_SIZE(type_p->types); ++u) {
Radek Krejciec4da802019-05-02 13:02:41 +02002994 LY_CHECK_RET(lys_compile_type(ctx, context_node_p, context_flags, context_mod, context_name, &type_p->types[u], &un->types[u + additional], NULL));
Radek Krejcicdfecd92018-11-26 11:27:32 +01002995 if (un->types[u + additional]->basetype == LY_TYPE_UNION) {
2996 /* add space for additional types from the union subtype */
2997 un_aux = (struct lysc_type_union *)un->types[u + additional];
2998 p = ly_realloc(((uint32_t*)(un->types) - 1), sizeof(uint32_t) + ((LY_ARRAY_SIZE(type_p->types) + additional + LY_ARRAY_SIZE(un_aux->types) - 1) * sizeof *(un->types)));
2999 LY_CHECK_ERR_RET(!p, LOGMEM(ctx->ctx);lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
3000 un->types = (void*)((uint32_t*)(p) + 1);
3001
3002 /* copy subtypes of the subtype union */
3003 for (v = 0; v < LY_ARRAY_SIZE(un_aux->types); ++v) {
3004 if (un_aux->types[v]->basetype == LY_TYPE_LEAFREF) {
3005 /* duplicate the whole structure because of the instance-specific path resolving for realtype */
3006 un->types[u + additional] = calloc(1, sizeof(struct lysc_type_leafref));
3007 LY_CHECK_ERR_RET(!un->types[u + additional], LOGMEM(ctx->ctx);lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux), LY_EMEM);
3008 ((struct lysc_type_leafref*)un->types[u + additional])->basetype = LY_TYPE_LEAFREF;
3009 DUP_STRING(ctx->ctx, ((struct lysc_type_leafref*)un_aux->types[v])->path, ((struct lysc_type_leafref*)un->types[u + additional])->path);
3010 ((struct lysc_type_leafref*)un->types[u + additional])->refcount = 1;
3011 ((struct lysc_type_leafref*)un->types[u + additional])->require_instance = ((struct lysc_type_leafref*)un_aux->types[v])->require_instance;
3012 ((struct lysc_type_leafref*)un->types[u + additional])->path_context = ((struct lysc_type_leafref*)un_aux->types[v])->path_context;
3013 /* TODO extensions */
3014
3015 } else {
3016 un->types[u + additional] = un_aux->types[v];
3017 ++un_aux->types[v]->refcount;
3018 }
3019 ++additional;
3020 LY_ARRAY_INCREMENT(un->types);
3021 }
3022 /* compensate u increment in main loop */
3023 --additional;
3024
3025 /* free the replaced union subtype */
3026 lysc_type_free(ctx->ctx, (struct lysc_type*)un_aux);
3027 } else {
3028 LY_ARRAY_INCREMENT(un->types);
3029 }
Radek Krejcicdfecd92018-11-26 11:27:32 +01003030 }
3031 }
3032
3033 if (!base && !type_p->flags) {
3034 /* type derived from union built-in type must contain at least one type */
3035 if (tpdfname) {
3036 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type ", tpdfname);
3037 } else {
3038 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_MISSCHILDSTMT, "type", "union type", "");
3039 free(*type);
3040 *type = NULL;
3041 }
3042 return LY_EVALID;
3043 }
3044
3045 if (tpdfname) {
3046 type_p->compiled = *type;
3047 *type = calloc(1, sizeof(struct lysc_type_union));
3048 }
3049 break;
Radek Krejcic5c27e52018-11-15 14:38:11 +01003050 case LY_TYPE_BOOL:
3051 case LY_TYPE_EMPTY:
3052 case LY_TYPE_UNKNOWN: /* just to complete switch */
3053 break;
3054 }
3055 LY_CHECK_ERR_RET(!(*type), LOGMEM(ctx->ctx), LY_EMEM);
3056done:
3057 return ret;
3058}
3059
Radek Krejcia3045382018-11-22 14:30:31 +01003060/**
3061 * @brief Compile information about the leaf/leaf-list's type.
3062 * @param[in] ctx Compile context.
Radek Krejcicdfecd92018-11-26 11:27:32 +01003063 * @param[in] context_node_p Schema node where the type/typedef is placed to correctly find the base types.
3064 * @param[in] context_flags Flags of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
3065 * @param[in] context_mod Module of the context node or the referencing typedef to correctly check status of referencing and referenced objects.
3066 * @param[in] context_name Name of the context node or referencing typedef for logging.
3067 * @param[in] type_p Parsed type to compile.
Radek Krejcia3045382018-11-22 14:30:31 +01003068 * @param[out] type Newly created (or reused with increased refcount) type structure with the filled information about the type.
Radek Krejcicdfecd92018-11-26 11:27:32 +01003069 * @param[out] units Storage for inheriting units value from the typedefs the current type derives from.
Radek Krejcia3045382018-11-22 14:30:31 +01003070 * @return LY_ERR value.
3071 */
Radek Krejcic5c27e52018-11-15 14:38:11 +01003072static LY_ERR
Radek Krejcicdfecd92018-11-26 11:27:32 +01003073lys_compile_type(struct lysc_ctx *ctx, struct lysp_node *context_node_p, uint16_t context_flags, struct lysp_module *context_mod, const char *context_name,
Radek Krejciec4da802019-05-02 13:02:41 +02003074 struct lysp_type *type_p, struct lysc_type **type, const char **units)
Radek Krejci19a96102018-11-15 13:38:09 +01003075{
3076 LY_ERR ret = LY_SUCCESS;
3077 unsigned int u;
Radek Krejcicdfecd92018-11-26 11:27:32 +01003078 int dummyloops = 0;
Radek Krejci19a96102018-11-15 13:38:09 +01003079 struct type_context {
3080 const struct lysp_tpdf *tpdf;
3081 struct lysp_node *node;
3082 struct lysp_module *mod;
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003083 } *tctx, *tctx_prev = NULL, *tctx_iter;
Radek Krejci19a96102018-11-15 13:38:09 +01003084 LY_DATA_TYPE basetype = LY_TYPE_UNKNOWN;
Radek Krejcic5c27e52018-11-15 14:38:11 +01003085 struct lysc_type *base = NULL, *prev_type;
Radek Krejci19a96102018-11-15 13:38:09 +01003086 struct ly_set tpdf_chain = {0};
Radek Krejci01342af2019-01-03 15:18:08 +01003087 const char *dflt = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02003088 struct lys_module *dflt_mod = NULL;
Radek Krejci19a96102018-11-15 13:38:09 +01003089
3090 (*type) = NULL;
3091
3092 tctx = calloc(1, sizeof *tctx);
3093 LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
Radek Krejcie86bf772018-12-14 11:39:53 +01003094 for (ret = lysp_type_find(type_p->name, context_node_p, ctx->mod_def->parsed,
Radek Krejci19a96102018-11-15 13:38:09 +01003095 &basetype, &tctx->tpdf, &tctx->node, &tctx->mod);
3096 ret == LY_SUCCESS;
3097 ret = lysp_type_find(tctx_prev->tpdf->type.name, tctx_prev->node, tctx_prev->mod,
3098 &basetype, &tctx->tpdf, &tctx->node, &tctx->mod)) {
3099 if (basetype) {
3100 break;
3101 }
3102
3103 /* check status */
Radek Krejcicdfecd92018-11-26 11:27:32 +01003104 ret = lysc_check_status(ctx, context_flags, context_mod, context_name,
3105 tctx->tpdf->flags, tctx->mod, tctx->node ? tctx->node->name : tctx->tpdf->name);
Radek Krejci19a96102018-11-15 13:38:09 +01003106 LY_CHECK_ERR_GOTO(ret, free(tctx), cleanup);
3107
Radek Krejcicdfecd92018-11-26 11:27:32 +01003108 if (units && !*units) {
3109 /* inherit units */
3110 DUP_STRING(ctx->ctx, tctx->tpdf->units, *units);
3111 }
Radek Krejci01342af2019-01-03 15:18:08 +01003112 if (!dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01003113 /* inherit default */
Radek Krejci01342af2019-01-03 15:18:08 +01003114 dflt = tctx->tpdf->dflt;
Radek Krejcia1911222019-07-22 17:24:50 +02003115 dflt_mod = tctx->mod->mod;
Radek Krejcicdfecd92018-11-26 11:27:32 +01003116 }
Radek Krejci01342af2019-01-03 15:18:08 +01003117 if (dummyloops && (!units || *units) && dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01003118 basetype = ((struct type_context*)tpdf_chain.objs[tpdf_chain.count - 1])->tpdf->type.compiled->basetype;
3119 break;
3120 }
3121
Radek Krejci19a96102018-11-15 13:38:09 +01003122 if (tctx->tpdf->type.compiled) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01003123 /* it is not necessary to continue, the rest of the chain was already compiled,
3124 * but we still may need to inherit default and units values, so start dummy loops */
Radek Krejci19a96102018-11-15 13:38:09 +01003125 basetype = tctx->tpdf->type.compiled->basetype;
3126 ly_set_add(&tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
Radek Krejci01342af2019-01-03 15:18:08 +01003127 if ((units && !*units) || !dflt) {
Radek Krejcicdfecd92018-11-26 11:27:32 +01003128 dummyloops = 1;
3129 goto preparenext;
3130 } else {
3131 tctx = NULL;
3132 break;
3133 }
Radek Krejci19a96102018-11-15 13:38:09 +01003134 }
3135
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003136 /* circular typedef reference detection */
3137 for (u = 0; u < tpdf_chain.count; u++) {
3138 /* local part */
3139 tctx_iter = (struct type_context*)tpdf_chain.objs[u];
3140 if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
3141 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3142 "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
3143 free(tctx);
3144 ret = LY_EVALID;
3145 goto cleanup;
3146 }
3147 }
3148 for (u = 0; u < ctx->tpdf_chain.count; u++) {
3149 /* global part for unions corner case */
3150 tctx_iter = (struct type_context*)ctx->tpdf_chain.objs[u];
3151 if (tctx_iter->mod == tctx->mod && tctx_iter->node == tctx->node && tctx_iter->tpdf == tctx->tpdf) {
3152 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3153 "Invalid \"%s\" type reference - circular chain of types detected.", tctx->tpdf->name);
3154 free(tctx);
3155 ret = LY_EVALID;
3156 goto cleanup;
3157 }
3158 }
3159
Radek Krejci19a96102018-11-15 13:38:09 +01003160 /* store information for the following processing */
3161 ly_set_add(&tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
3162
Radek Krejcicdfecd92018-11-26 11:27:32 +01003163preparenext:
Radek Krejci19a96102018-11-15 13:38:09 +01003164 /* prepare next loop */
3165 tctx_prev = tctx;
3166 tctx = calloc(1, sizeof *tctx);
3167 LY_CHECK_ERR_RET(!tctx, LOGMEM(ctx->ctx), LY_EMEM);
3168 }
3169 free(tctx);
3170
3171 /* allocate type according to the basetype */
3172 switch (basetype) {
3173 case LY_TYPE_BINARY:
3174 *type = calloc(1, sizeof(struct lysc_type_bin));
Radek Krejci19a96102018-11-15 13:38:09 +01003175 break;
3176 case LY_TYPE_BITS:
3177 *type = calloc(1, sizeof(struct lysc_type_bits));
Radek Krejci19a96102018-11-15 13:38:09 +01003178 break;
3179 case LY_TYPE_BOOL:
3180 case LY_TYPE_EMPTY:
3181 *type = calloc(1, sizeof(struct lysc_type));
3182 break;
3183 case LY_TYPE_DEC64:
3184 *type = calloc(1, sizeof(struct lysc_type_dec));
3185 break;
3186 case LY_TYPE_ENUM:
3187 *type = calloc(1, sizeof(struct lysc_type_enum));
Radek Krejci19a96102018-11-15 13:38:09 +01003188 break;
3189 case LY_TYPE_IDENT:
3190 *type = calloc(1, sizeof(struct lysc_type_identityref));
3191 break;
3192 case LY_TYPE_INST:
3193 *type = calloc(1, sizeof(struct lysc_type_instanceid));
3194 break;
3195 case LY_TYPE_LEAFREF:
3196 *type = calloc(1, sizeof(struct lysc_type_leafref));
3197 break;
3198 case LY_TYPE_STRING:
3199 *type = calloc(1, sizeof(struct lysc_type_str));
Radek Krejci19a96102018-11-15 13:38:09 +01003200 break;
3201 case LY_TYPE_UNION:
3202 *type = calloc(1, sizeof(struct lysc_type_union));
3203 break;
3204 case LY_TYPE_INT8:
3205 case LY_TYPE_UINT8:
3206 case LY_TYPE_INT16:
3207 case LY_TYPE_UINT16:
3208 case LY_TYPE_INT32:
3209 case LY_TYPE_UINT32:
3210 case LY_TYPE_INT64:
3211 case LY_TYPE_UINT64:
3212 *type = calloc(1, sizeof(struct lysc_type_num));
Radek Krejci19a96102018-11-15 13:38:09 +01003213 break;
3214 case LY_TYPE_UNKNOWN:
3215 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3216 "Referenced type \"%s\" not found.", tctx_prev ? tctx_prev->tpdf->type.name : type_p->name);
3217 ret = LY_EVALID;
3218 goto cleanup;
3219 }
3220 LY_CHECK_ERR_GOTO(!(*type), LOGMEM(ctx->ctx), cleanup);
Radek Krejcicdfecd92018-11-26 11:27:32 +01003221 if (~type_substmt_map[basetype] & type_p->flags) {
Radek Krejci19a96102018-11-15 13:38:09 +01003222 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type restrictions for %s type.",
3223 ly_data_type2str[basetype]);
3224 free(*type);
3225 (*type) = NULL;
3226 ret = LY_EVALID;
3227 goto cleanup;
3228 }
3229
3230 /* get restrictions from the referred typedefs */
3231 for (u = tpdf_chain.count - 1; u + 1 > 0; --u) {
3232 tctx = (struct type_context*)tpdf_chain.objs[u];
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003233
3234 /* remember the typedef context for circular check */
3235 ly_set_add(&ctx->tpdf_chain, tctx, LY_SET_OPT_USEASLIST);
3236
Radek Krejci43699232018-11-23 14:59:46 +01003237 if (tctx->tpdf->type.compiled) {
Radek Krejci19a96102018-11-15 13:38:09 +01003238 base = tctx->tpdf->type.compiled;
3239 continue;
Radek Krejci43699232018-11-23 14:59:46 +01003240 } else if (basetype != LY_TYPE_LEAFREF && (u != tpdf_chain.count - 1) && !(tctx->tpdf->type.flags)) {
Radek Krejci19a96102018-11-15 13:38:09 +01003241 /* no change, just use the type information from the base */
3242 base = ((struct lysp_tpdf*)tctx->tpdf)->type.compiled = ((struct type_context*)tpdf_chain.objs[u + 1])->tpdf->type.compiled;
3243 ++base->refcount;
3244 continue;
3245 }
3246
3247 ++(*type)->refcount;
Radek Krejci43699232018-11-23 14:59:46 +01003248 if (~type_substmt_map[basetype] & tctx->tpdf->type.flags) {
3249 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid type \"%s\" restriction(s) for %s type.",
3250 tctx->tpdf->name, ly_data_type2str[basetype]);
3251 ret = LY_EVALID;
3252 goto cleanup;
3253 } else if (basetype == LY_TYPE_EMPTY && tctx->tpdf->dflt) {
3254 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3255 "Invalid type \"%s\" - \"empty\" type must not have a default value (%s).",
3256 tctx->tpdf->name, tctx->tpdf->dflt);
3257 ret = LY_EVALID;
3258 goto cleanup;
3259 }
3260
Radek Krejci19a96102018-11-15 13:38:09 +01003261 (*type)->basetype = basetype;
Radek Krejcie7b95092019-05-15 11:03:07 +02003262 /* TODO user type plugins */
3263 (*type)->plugin = &ly_builtin_type_plugins[basetype];
Radek Krejcic5c27e52018-11-15 14:38:11 +01003264 prev_type = *type;
Radek Krejcicdfecd92018-11-26 11:27:32 +01003265 ret = lys_compile_type_(ctx, tctx->node, tctx->tpdf->flags, tctx->mod, tctx->tpdf->name, &((struct lysp_tpdf*)tctx->tpdf)->type,
Radek Krejci96a0bfd2018-11-22 15:25:06 +01003266 basetype & (LY_TYPE_LEAFREF | LY_TYPE_UNION) ? lysp_find_module(ctx->ctx, tctx->mod) : NULL,
Radek Krejciec4da802019-05-02 13:02:41 +02003267 basetype, tctx->tpdf->name, base, type);
Radek Krejcic5c27e52018-11-15 14:38:11 +01003268 LY_CHECK_GOTO(ret, cleanup);
3269 base = prev_type;
Radek Krejci19a96102018-11-15 13:38:09 +01003270 }
Radek Krejci99b5b2a2019-04-30 16:57:04 +02003271 /* remove the processed typedef contexts from the stack for circular check */
3272 ctx->tpdf_chain.count = ctx->tpdf_chain.count - tpdf_chain.count;
Radek Krejci19a96102018-11-15 13:38:09 +01003273
Radek Krejcic5c27e52018-11-15 14:38:11 +01003274 /* process the type definition in leaf */
Radek Krejcicdfecd92018-11-26 11:27:32 +01003275 if (type_p->flags || !base || basetype == LY_TYPE_LEAFREF) {
Radek Krejcia3045382018-11-22 14:30:31 +01003276 /* get restrictions from the node itself */
Radek Krejci19a96102018-11-15 13:38:09 +01003277 (*type)->basetype = basetype;
Radek Krejcie7b95092019-05-15 11:03:07 +02003278 /* TODO user type plugins */
3279 (*type)->plugin = &ly_builtin_type_plugins[basetype];
Radek Krejci19a96102018-11-15 13:38:09 +01003280 ++(*type)->refcount;
Radek Krejciec4da802019-05-02 13:02:41 +02003281 ret = lys_compile_type_(ctx, context_node_p, context_flags, context_mod, context_name, type_p, ctx->mod_def, basetype, NULL, base, type);
Radek Krejcic5c27e52018-11-15 14:38:11 +01003282 LY_CHECK_GOTO(ret, cleanup);
3283 } else {
Radek Krejci19a96102018-11-15 13:38:09 +01003284 /* no specific restriction in leaf's type definition, copy from the base */
3285 free(*type);
3286 (*type) = base;
3287 ++(*type)->refcount;
Radek Krejci19a96102018-11-15 13:38:09 +01003288 }
Radek Krejcia1911222019-07-22 17:24:50 +02003289 if (dflt && !(*type)->dflt) {
3290 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003291 (*type)->dflt_mod = dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02003292 (*type)->dflt = calloc(1, sizeof *(*type)->dflt);
3293 (*type)->dflt->realtype = (*type);
3294 ret = (*type)->plugin->store(ctx->ctx, (*type), dflt, strlen(dflt),
3295 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003296 lys_resolve_prefix, (void*)(*type)->dflt_mod, LYD_XML, NULL, NULL, (*type)->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003297 if (err) {
3298 ly_err_print(err);
3299 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3300 "Invalid type's default value \"%s\" which does not fit the type (%s).", dflt, err->msg);
3301 ly_err_free(err);
3302 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02003303 if (ret == LY_EINCOMPLETE) {
3304 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02003305 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, NULL, (*type)->dflt, (*type)->dflt_mod), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02003306
3307 /* but in general result is so far ok */
3308 ret = LY_SUCCESS;
3309 }
Radek Krejcia1911222019-07-22 17:24:50 +02003310 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci01342af2019-01-03 15:18:08 +01003311 }
Radek Krejci19a96102018-11-15 13:38:09 +01003312
Radek Krejci0935f412019-08-20 16:15:18 +02003313 COMPILE_EXTS_GOTO(ctx, type_p->exts, (*type)->exts, (*type), LYEXT_PAR_TYPE, ret, cleanup);
Radek Krejci19a96102018-11-15 13:38:09 +01003314
3315cleanup:
3316 ly_set_erase(&tpdf_chain, free);
3317 return ret;
3318}
3319
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003320/**
3321 * @brief Compile status information of the given node.
3322 *
3323 * To simplify getting status of the node, the flags are set following inheritance rules, so all the nodes
3324 * has the status correctly set during the compilation.
3325 *
3326 * @param[in] ctx Compile context
3327 * @param[in,out] node_flags Flags of the compiled node which status is supposed to be resolved.
3328 * If the status was set explicitly on the node, it is already set in the flags value and we just check
3329 * the compatibility with the parent's status value.
3330 * @param[in] parent_flags Flags of the parent node to check/inherit the status value.
3331 * @return LY_ERR value.
3332 */
3333static LY_ERR
3334lys_compile_status(struct lysc_ctx *ctx, uint16_t *node_flags, uint16_t parent_flags)
3335{
3336 /* status - it is not inherited by specification, but it does not make sense to have
3337 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
3338 if (!((*node_flags) & LYS_STATUS_MASK)) {
3339 if (parent_flags & (LYS_STATUS_DEPRC | LYS_STATUS_OBSLT)) {
3340 if ((parent_flags & 0x3) != 0x3) {
3341 /* do not print the warning when inheriting status from uses - the uses_status value has a special
3342 * combination of bits (0x3) which marks the uses_status value */
3343 LOGWRN(ctx->ctx, "Missing explicit \"%s\" status that was already specified in parent, inheriting.",
3344 (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
3345 }
3346 (*node_flags) |= parent_flags & LYS_STATUS_MASK;
3347 } else {
3348 (*node_flags) |= LYS_STATUS_CURR;
3349 }
3350 } else if (parent_flags & LYS_STATUS_MASK) {
3351 /* check status compatibility with the parent */
3352 if ((parent_flags & LYS_STATUS_MASK) > ((*node_flags) & LYS_STATUS_MASK)) {
3353 if ((*node_flags) & LYS_STATUS_CURR) {
3354 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3355 "A \"current\" status is in conflict with the parent's \"%s\" status.",
3356 (parent_flags & LYS_STATUS_DEPRC) ? "deprecated" : "obsolete");
3357 } else { /* LYS_STATUS_DEPRC */
3358 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3359 "A \"deprecated\" status is in conflict with the parent's \"obsolete\" status.");
3360 }
3361 return LY_EVALID;
3362 }
3363 }
3364 return LY_SUCCESS;
3365}
3366
Radek Krejci8cce8532019-03-05 11:27:45 +01003367/**
3368 * @brief Check uniqness of the node/action/notification name.
3369 *
3370 * Data nodes, actions/RPCs and Notifications are stored separately (in distinguish lists) in the schema
3371 * structures, but they share the namespace so we need to check their name collisions.
3372 *
3373 * @param[in] ctx Compile context.
3374 * @param[in] children List (linked list) of data nodes to go through.
3375 * @param[in] actions List (sized array) of actions or RPCs to go through.
3376 * @param[in] notifs List (sized array) of Notifications to go through.
3377 * @param[in] name Name of the item to find in the given lists.
3378 * @param[in] exclude Pointer to an object to exclude from the name checking - for the case that the object
3379 * with the @p name being checked is already inserted into one of the list so we need to skip it when searching for duplicity.
3380 * @return LY_SUCCESS in case of unique name, LY_EEXIST otherwise.
3381 */
3382static LY_ERR
3383lys_compile_node_uniqness(struct lysc_ctx *ctx, const struct lysc_node *children,
3384 const struct lysc_action *actions, const struct lysc_notif *notifs,
3385 const char *name, void *exclude)
3386{
3387 const struct lysc_node *iter;
3388 unsigned int u;
3389
3390 LY_LIST_FOR(children, iter) {
3391 if (iter != exclude && iter->module == ctx->mod && !strcmp(name, iter->name)) {
3392 goto error;
3393 }
3394 }
3395 LY_ARRAY_FOR(actions, u) {
3396 if (&actions[u] != exclude && actions[u].module == ctx->mod && !strcmp(name, actions[u].name)) {
3397 goto error;
3398 }
3399 }
3400 LY_ARRAY_FOR(notifs, u) {
3401 if (&notifs[u] != exclude && notifs[u].module == ctx->mod && !strcmp(name, notifs[u].name)) {
3402 goto error;
3403 }
3404 }
3405 return LY_SUCCESS;
3406error:
3407 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, name, "data definition/RPC/action/Notification");
3408 return LY_EEXIST;
3409}
3410
Radek Krejciec4da802019-05-02 13:02:41 +02003411static LY_ERR lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *parent, uint16_t uses_status);
Radek Krejci19a96102018-11-15 13:38:09 +01003412
Radek Krejcia3045382018-11-22 14:30:31 +01003413/**
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003414 * @brief Compile parsed RPC/action schema node information.
3415 * @param[in] ctx Compile context
Radek Krejci43981a32019-04-12 09:44:11 +02003416 * @param[in] action_p Parsed RPC/action schema node.
Radek Krejci43981a32019-04-12 09:44:11 +02003417 * @param[in] parent Parent node of the action, NULL in case of RPC (top-level action)
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003418 * @param[in,out] action Prepared (empty) compiled action structure to fill.
3419 * @param[in] uses_status If the RPC/action is being placed instead of uses, here we have the uses's status value (as node's flags).
3420 * Zero means no uses, non-zero value with no status bit set mean the default status.
3421 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3422 */
3423static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003424lys_compile_action(struct lysc_ctx *ctx, struct lysp_action *action_p,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003425 struct lysc_node *parent, struct lysc_action *action, uint16_t uses_status)
3426{
3427 LY_ERR ret = LY_SUCCESS;
3428 struct lysp_node *child_p;
3429 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02003430 int opt_prev = ctx->options;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003431
Radek Krejci327de162019-06-14 12:52:07 +02003432 lysc_update_path(ctx, parent, action_p->name);
3433
Radek Krejci8cce8532019-03-05 11:27:45 +01003434 if (lys_compile_node_uniqness(ctx, parent ? lysc_node_children(parent, 0) : ctx->mod->compiled->data,
3435 parent ? lysc_node_actions(parent) : ctx->mod->compiled->rpcs,
3436 parent ? lysc_node_notifs(parent) : ctx->mod->compiled->notifs,
3437 action_p->name, action)) {
3438 return LY_EVALID;
3439 }
3440
Radek Krejciec4da802019-05-02 13:02:41 +02003441 if (ctx->options & (LYSC_OPT_RPC_MASK | LYSC_OPT_NOTIFICATION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +01003442 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejcifc11bd72019-04-11 16:00:05 +02003443 "Action \"%s\" is placed inside %s.", action_p->name,
Radek Krejciec4da802019-05-02 13:02:41 +02003444 ctx->options & LYSC_OPT_RPC_MASK ? "another RPC/action" : "Notification");
Radek Krejci05b774b2019-02-25 13:26:18 +01003445 return LY_EVALID;
3446 }
3447
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003448 action->nodetype = LYS_ACTION;
3449 action->module = ctx->mod;
3450 action->parent = parent;
Radek Krejciec4da802019-05-02 13:02:41 +02003451 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003452 action->sp = action_p;
3453 }
3454 action->flags = action_p->flags & LYS_FLAGS_COMPILED_MASK;
3455
3456 /* status - it is not inherited by specification, but it does not make sense to have
3457 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
3458 LY_CHECK_RET(lys_compile_status(ctx, &action->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
3459
3460 DUP_STRING(ctx->ctx, action_p->name, action->name);
3461 DUP_STRING(ctx->ctx, action_p->dsc, action->dsc);
3462 DUP_STRING(ctx->ctx, action_p->ref, action->ref);
Radek Krejciec4da802019-05-02 13:02:41 +02003463 COMPILE_ARRAY_GOTO(ctx, action_p->iffeatures, action->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003464 COMPILE_EXTS_GOTO(ctx, action_p->exts, action->exts, action, LYEXT_PAR_NODE, ret, cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003465
3466 /* input */
Radek Krejci327de162019-06-14 12:52:07 +02003467 lysc_update_path(ctx, (struct lysc_node*)action, "input");
Radek Krejciec4da802019-05-02 13:02:41 +02003468 COMPILE_ARRAY_GOTO(ctx, action_p->input.musts, action->input.musts, u, lys_compile_must, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003469 COMPILE_EXTS_GOTO(ctx, action_p->input.exts, action->input_exts, &action->input, LYEXT_PAR_INPUT, ret, cleanup);
Radek Krejciec4da802019-05-02 13:02:41 +02003470 ctx->options |= LYSC_OPT_RPC_INPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003471 LY_LIST_FOR(action_p->input.data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003472 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003473 }
Radek Krejci327de162019-06-14 12:52:07 +02003474 lysc_update_path(ctx, NULL, NULL);
Radek Krejciec4da802019-05-02 13:02:41 +02003475 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003476
3477 /* output */
Radek Krejci327de162019-06-14 12:52:07 +02003478 lysc_update_path(ctx, (struct lysc_node*)action, "output");
Radek Krejciec4da802019-05-02 13:02:41 +02003479 COMPILE_ARRAY_GOTO(ctx, action_p->output.musts, action->output.musts, u, lys_compile_must, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003480 COMPILE_EXTS_GOTO(ctx, action_p->output.exts, action->output_exts, &action->output, LYEXT_PAR_OUTPUT, ret, cleanup);
Radek Krejciec4da802019-05-02 13:02:41 +02003481 ctx->options |= LYSC_OPT_RPC_OUTPUT;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003482 LY_LIST_FOR(action_p->output.data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003483 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)action, uses_status));
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003484 }
Radek Krejci327de162019-06-14 12:52:07 +02003485 lysc_update_path(ctx, NULL, NULL);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003486
Radek Krejci327de162019-06-14 12:52:07 +02003487 lysc_update_path(ctx, NULL, NULL);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003488cleanup:
Radek Krejciec4da802019-05-02 13:02:41 +02003489 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003490 return ret;
3491}
3492
3493/**
Radek Krejci43981a32019-04-12 09:44:11 +02003494 * @brief Compile parsed Notification schema node information.
Radek Krejcifc11bd72019-04-11 16:00:05 +02003495 * @param[in] ctx Compile context
Radek Krejci43981a32019-04-12 09:44:11 +02003496 * @param[in] notif_p Parsed Notification schema node.
Radek Krejci43981a32019-04-12 09:44:11 +02003497 * @param[in] parent Parent node of the Notification, NULL in case of top-level Notification
3498 * @param[in,out] notif Prepared (empty) compiled notification structure to fill.
3499 * @param[in] uses_status If the Notification is being placed instead of uses, here we have the uses's status value (as node's flags).
Radek Krejcifc11bd72019-04-11 16:00:05 +02003500 * Zero means no uses, non-zero value with no status bit set mean the default status.
3501 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3502 */
3503static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003504lys_compile_notif(struct lysc_ctx *ctx, struct lysp_notif *notif_p,
Radek Krejcifc11bd72019-04-11 16:00:05 +02003505 struct lysc_node *parent, struct lysc_notif *notif, uint16_t uses_status)
3506{
3507 LY_ERR ret = LY_SUCCESS;
3508 struct lysp_node *child_p;
3509 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02003510 int opt_prev = ctx->options;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003511
Radek Krejci327de162019-06-14 12:52:07 +02003512 lysc_update_path(ctx, parent, notif_p->name);
3513
Radek Krejcifc11bd72019-04-11 16:00:05 +02003514 if (lys_compile_node_uniqness(ctx, parent ? lysc_node_children(parent, 0) : ctx->mod->compiled->data,
3515 parent ? lysc_node_actions(parent) : ctx->mod->compiled->rpcs,
3516 parent ? lysc_node_notifs(parent) : ctx->mod->compiled->notifs,
3517 notif_p->name, notif)) {
3518 return LY_EVALID;
3519 }
3520
Radek Krejciec4da802019-05-02 13:02:41 +02003521 if (ctx->options & (LYSC_OPT_RPC_MASK | LYSC_OPT_NOTIFICATION)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02003522 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3523 "Notification \"%s\" is placed inside %s.", notif_p->name,
Radek Krejciec4da802019-05-02 13:02:41 +02003524 ctx->options & LYSC_OPT_RPC_MASK ? "RPC/action" : "another Notification");
Radek Krejcifc11bd72019-04-11 16:00:05 +02003525 return LY_EVALID;
3526 }
3527
3528 notif->nodetype = LYS_NOTIF;
3529 notif->module = ctx->mod;
3530 notif->parent = parent;
Radek Krejciec4da802019-05-02 13:02:41 +02003531 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02003532 notif->sp = notif_p;
3533 }
3534 notif->flags = notif_p->flags & LYS_FLAGS_COMPILED_MASK;
3535
3536 /* status - it is not inherited by specification, but it does not make sense to have
3537 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
3538 LY_CHECK_RET(lys_compile_status(ctx, &notif->flags, uses_status ? uses_status : (parent ? parent->flags : 0)));
3539
3540 DUP_STRING(ctx->ctx, notif_p->name, notif->name);
3541 DUP_STRING(ctx->ctx, notif_p->dsc, notif->dsc);
3542 DUP_STRING(ctx->ctx, notif_p->ref, notif->ref);
Radek Krejciec4da802019-05-02 13:02:41 +02003543 COMPILE_ARRAY_GOTO(ctx, notif_p->iffeatures, notif->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejciec4da802019-05-02 13:02:41 +02003544 COMPILE_ARRAY_GOTO(ctx, notif_p->musts, notif->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci0935f412019-08-20 16:15:18 +02003545 COMPILE_EXTS_GOTO(ctx, notif_p->exts, notif->exts, notif, LYEXT_PAR_NODE, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02003546
Radek Krejciec4da802019-05-02 13:02:41 +02003547 ctx->options |= LYSC_OPT_NOTIFICATION;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003548 LY_LIST_FOR(notif_p->data, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003549 LY_CHECK_RET(lys_compile_node(ctx, child_p, (struct lysc_node*)notif, uses_status));
Radek Krejcifc11bd72019-04-11 16:00:05 +02003550 }
3551
Radek Krejci327de162019-06-14 12:52:07 +02003552 lysc_update_path(ctx, NULL, NULL);
Radek Krejcifc11bd72019-04-11 16:00:05 +02003553cleanup:
Radek Krejciec4da802019-05-02 13:02:41 +02003554 ctx->options = opt_prev;
Radek Krejcifc11bd72019-04-11 16:00:05 +02003555 return ret;
3556}
3557
3558/**
Radek Krejcia3045382018-11-22 14:30:31 +01003559 * @brief Compile parsed container node information.
3560 * @param[in] ctx Compile context
3561 * @param[in] node_p Parsed container node.
Radek Krejcia3045382018-11-22 14:30:31 +01003562 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3563 * is enriched with the container-specific information.
3564 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3565 */
Radek Krejci19a96102018-11-15 13:38:09 +01003566static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003567lys_compile_node_container(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci19a96102018-11-15 13:38:09 +01003568{
3569 struct lysp_node_container *cont_p = (struct lysp_node_container*)node_p;
3570 struct lysc_node_container *cont = (struct lysc_node_container*)node;
3571 struct lysp_node *child_p;
3572 unsigned int u;
3573 LY_ERR ret = LY_SUCCESS;
3574
Radek Krejcife909632019-02-12 15:34:42 +01003575 if (cont_p->presence) {
3576 cont->flags |= LYS_PRESENCE;
3577 }
3578
Radek Krejci19a96102018-11-15 13:38:09 +01003579 LY_LIST_FOR(cont_p->child, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003580 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci19a96102018-11-15 13:38:09 +01003581 }
3582
Radek Krejciec4da802019-05-02 13:02:41 +02003583 COMPILE_ARRAY_GOTO(ctx, cont_p->musts, cont->musts, u, lys_compile_must, ret, done);
3584 COMPILE_ARRAY1_GOTO(ctx, cont_p->actions, cont->actions, node, u, lys_compile_action, 0, ret, done);
3585 COMPILE_ARRAY1_GOTO(ctx, cont_p->notifs, cont->notifs, node, u, lys_compile_notif, 0, ret, done);
Radek Krejci19a96102018-11-15 13:38:09 +01003586
3587done:
3588 return ret;
3589}
3590
Radek Krejci33f72892019-02-21 10:36:58 +01003591/*
3592 * @brief Compile type in leaf/leaf-list node and do all the necessary checks.
3593 * @param[in] ctx Compile context.
3594 * @param[in] context_node Schema node where the type/typedef is placed to correctly find the base types.
3595 * @param[in] type_p Parsed type to compile.
Radek Krejci33f72892019-02-21 10:36:58 +01003596 * @param[in,out] leaf Compiled leaf structure (possibly cast leaf-list) to provide node information and to store the compiled type information.
3597 * @return LY_ERR value.
3598 */
3599static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003600lys_compile_node_type(struct lysc_ctx *ctx, struct lysp_node *context_node, struct lysp_type *type_p, struct lysc_node_leaf *leaf)
Radek Krejci33f72892019-02-21 10:36:58 +01003601{
Radek Krejcia1911222019-07-22 17:24:50 +02003602 unsigned int u;
Radek Krejci33f72892019-02-21 10:36:58 +01003603 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)leaf;
3604
Radek Krejciec4da802019-05-02 13:02:41 +02003605 LY_CHECK_RET(lys_compile_type(ctx, context_node, leaf->flags, ctx->mod_def->parsed, leaf->name, type_p, &leaf->type,
Radek Krejci33f72892019-02-21 10:36:58 +01003606 leaf->units ? NULL : &leaf->units));
3607 if (leaf->nodetype == LYS_LEAFLIST) {
3608 if (llist->type->dflt && !llist->dflts && !llist->min) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003609 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts_mods, 1, LY_EMEM);
3610 llist->dflts_mods[0] = llist->type->dflt_mod;
Radek Krejci33f72892019-02-21 10:36:58 +01003611 LY_ARRAY_CREATE_RET(ctx->ctx, llist->dflts, 1, LY_EMEM);
Radek Krejcia1911222019-07-22 17:24:50 +02003612 llist->dflts[0] = calloc(1, sizeof *llist->dflts[0]);
3613 llist->dflts[0]->realtype = llist->type->dflt->realtype;
3614 llist->dflts[0]->realtype->plugin->duplicate(ctx->ctx, llist->type->dflt, llist->dflts[0]);
3615 llist->dflts[0]->realtype->refcount++;
Radek Krejci33f72892019-02-21 10:36:58 +01003616 LY_ARRAY_INCREMENT(llist->dflts);
3617 }
3618 } else {
3619 if (leaf->type->dflt && !leaf->dflt && !(leaf->flags & LYS_MAND_TRUE)) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003620 leaf->dflt_mod = leaf->type->dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02003621 leaf->dflt = calloc(1, sizeof *leaf->dflt);
3622 leaf->dflt->realtype = leaf->type->dflt->realtype;
3623 leaf->dflt->realtype->plugin->duplicate(ctx->ctx, leaf->type->dflt, leaf->dflt);
3624 leaf->dflt->realtype->refcount++;
Radek Krejci33f72892019-02-21 10:36:58 +01003625 }
3626 }
3627 if (leaf->type->basetype == LY_TYPE_LEAFREF) {
3628 /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
3629 ly_set_add(&ctx->unres, leaf, 0);
3630 } else if (leaf->type->basetype == LY_TYPE_UNION) {
3631 LY_ARRAY_FOR(((struct lysc_type_union*)leaf->type)->types, u) {
3632 if (((struct lysc_type_union*)leaf->type)->types[u]->basetype == LY_TYPE_LEAFREF) {
3633 /* store to validate the path in the current context at the end of schema compiling when all the nodes are present */
3634 ly_set_add(&ctx->unres, leaf, 0);
3635 }
3636 }
3637 } else if (leaf->type->basetype == LY_TYPE_EMPTY) {
Radek Krejci33f72892019-02-21 10:36:58 +01003638 if (leaf->nodetype == LYS_LEAFLIST && ctx->mod_def->version < LYS_VERSION_1_1) {
3639 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3640 "Leaf-list of type \"empty\" is allowed only in YANG 1.1 modules.");
3641 return LY_EVALID;
3642 }
3643 }
3644
Radek Krejci33f72892019-02-21 10:36:58 +01003645 return LY_SUCCESS;
3646}
3647
Radek Krejcia3045382018-11-22 14:30:31 +01003648/**
3649 * @brief Compile parsed leaf node information.
3650 * @param[in] ctx Compile context
3651 * @param[in] node_p Parsed leaf node.
Radek Krejcia3045382018-11-22 14:30:31 +01003652 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3653 * is enriched with the leaf-specific information.
3654 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3655 */
Radek Krejci19a96102018-11-15 13:38:09 +01003656static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003657lys_compile_node_leaf(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci19a96102018-11-15 13:38:09 +01003658{
3659 struct lysp_node_leaf *leaf_p = (struct lysp_node_leaf*)node_p;
3660 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
3661 unsigned int u;
3662 LY_ERR ret = LY_SUCCESS;
3663
Radek Krejciec4da802019-05-02 13:02:41 +02003664 COMPILE_ARRAY_GOTO(ctx, leaf_p->musts, leaf->musts, u, lys_compile_must, ret, done);
Radek Krejciccd20f12019-02-15 14:12:27 +01003665 if (leaf_p->units) {
3666 leaf->units = lydict_insert(ctx->ctx, leaf_p->units, 0);
3667 leaf->flags |= LYS_SET_UNITS;
3668 }
Radek Krejcia1911222019-07-22 17:24:50 +02003669
3670 /* the dflt member is just filled to avoid getting the default value from the type */
3671 leaf->dflt = (void*)leaf_p->dflt;
3672 ret = lys_compile_node_type(ctx, node_p, &leaf_p->type, leaf);
Radek Krejcib5bc93e2019-09-09 09:11:23 +02003673 leaf->dflt = NULL;
3674 LY_CHECK_RET(ret);
Radek Krejcia1911222019-07-22 17:24:50 +02003675
Radek Krejciccd20f12019-02-15 14:12:27 +01003676 if (leaf_p->dflt) {
Radek Krejcia1911222019-07-22 17:24:50 +02003677 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003678 leaf->dflt_mod = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02003679 leaf->dflt = calloc(1, sizeof *leaf->dflt);
3680 leaf->dflt->realtype = leaf->type;
3681 ret = leaf->type->plugin->store(ctx->ctx, leaf->type, leaf_p->dflt, strlen(leaf_p->dflt),
3682 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02003683 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, node, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003684 leaf->dflt->realtype->refcount++;
3685 if (err) {
3686 ly_err_print(err);
3687 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3688 "Invalid leaf's default value \"%s\" which does not fit the type (%s).", leaf_p->dflt, err->msg);
3689 ly_err_free(err);
3690 }
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003691 if (ret == LY_EINCOMPLETE) {
Radek Krejci1c0c3442019-07-23 16:08:47 +02003692 /* postpone default compilation when the tree is complete */
Radek Krejcib5bc93e2019-09-09 09:11:23 +02003693 LY_CHECK_RET(lysc_incomplete_dflts_add(ctx, node, leaf->dflt, leaf->dflt_mod));
Radek Krejci1c0c3442019-07-23 16:08:47 +02003694
3695 /* but in general result is so far ok */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003696 ret = LY_SUCCESS;
3697 }
Radek Krejcib5bc93e2019-09-09 09:11:23 +02003698 LY_CHECK_RET(ret);
Radek Krejci76b3e962018-12-14 17:01:25 +01003699 leaf->flags |= LYS_SET_DFLT;
3700 }
Radek Krejci43699232018-11-23 14:59:46 +01003701
Radek Krejcib1a5dcc2018-11-26 14:50:05 +01003702
Radek Krejci19a96102018-11-15 13:38:09 +01003703done:
3704 return ret;
3705}
3706
Radek Krejcia3045382018-11-22 14:30:31 +01003707/**
Radek Krejci0e5d8382018-11-28 16:37:53 +01003708 * @brief Compile parsed leaf-list node information.
3709 * @param[in] ctx Compile context
3710 * @param[in] node_p Parsed leaf-list node.
Radek Krejci0e5d8382018-11-28 16:37:53 +01003711 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3712 * is enriched with the leaf-list-specific information.
3713 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3714 */
3715static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003716lys_compile_node_leaflist(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci0e5d8382018-11-28 16:37:53 +01003717{
3718 struct lysp_node_leaflist *llist_p = (struct lysp_node_leaflist*)node_p;
3719 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)node;
Radek Krejcia1911222019-07-22 17:24:50 +02003720 unsigned int u, v;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003721 LY_ERR ret = LY_SUCCESS;
3722
Radek Krejciec4da802019-05-02 13:02:41 +02003723 COMPILE_ARRAY_GOTO(ctx, llist_p->musts, llist->musts, u, lys_compile_must, ret, done);
Radek Krejciccd20f12019-02-15 14:12:27 +01003724 if (llist_p->units) {
3725 llist->units = lydict_insert(ctx->ctx, llist_p->units, 0);
3726 llist->flags |= LYS_SET_UNITS;
3727 }
Radek Krejci0e5d8382018-11-28 16:37:53 +01003728
Radek Krejcia1911222019-07-22 17:24:50 +02003729 /* the dflts member is just filled to avoid getting the default value from the type */
3730 llist->dflts = (void*)llist_p->dflts;
3731 ret = lys_compile_node_type(ctx, node_p, &llist_p->type, (struct lysc_node_leaf*)llist);
Radek Krejci0e5d8382018-11-28 16:37:53 +01003732 if (llist_p->dflts) {
Radek Krejcia1911222019-07-22 17:24:50 +02003733 llist->dflts = NULL; /* reset the temporary llist_p->dflts */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003734 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_SIZE(llist_p->dflts), ret, done);
Radek Krejci0e5d8382018-11-28 16:37:53 +01003735 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_SIZE(llist_p->dflts), ret, done);
3736 LY_ARRAY_FOR(llist_p->dflts, u) {
Radek Krejcia1911222019-07-22 17:24:50 +02003737 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003738 LY_ARRAY_INCREMENT(llist->dflts_mods);
3739 llist->dflts_mods[u] = ctx->mod_def;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003740 LY_ARRAY_INCREMENT(llist->dflts);
Radek Krejcia1911222019-07-22 17:24:50 +02003741 llist->dflts[u] = calloc(1, sizeof *llist->dflts[u]);
3742 llist->dflts[u]->realtype = llist->type;
3743 ret = llist->type->plugin->store(ctx->ctx, llist->type, llist_p->dflts[u], strlen(llist_p->dflts[u]),
3744 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02003745 lys_resolve_prefix, (void*)llist->dflts_mods[u], LYD_XML, node, NULL, llist->dflts[u], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02003746 llist->dflts[u]->realtype->refcount++;
3747 if (err) {
3748 ly_err_print(err);
3749 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3750 "Invalid leaf-lists's default value \"%s\" which does not fit the type (%s).", llist_p->dflts[u], err->msg);
3751 ly_err_free(err);
3752 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02003753 if (ret == LY_EINCOMPLETE) {
3754 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02003755 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, llist->dflts[u], llist->dflts_mods[u]), done);
Radek Krejci1c0c3442019-07-23 16:08:47 +02003756
3757 /* but in general result is so far ok */
3758 ret = LY_SUCCESS;
3759 }
Radek Krejcia1911222019-07-22 17:24:50 +02003760 LY_CHECK_GOTO(ret, done);
Radek Krejci0e5d8382018-11-28 16:37:53 +01003761 }
Radek Krejciccd20f12019-02-15 14:12:27 +01003762 llist->flags |= LYS_SET_DFLT;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003763 }
Radek Krejcia1911222019-07-22 17:24:50 +02003764 if ((llist->flags & LYS_CONFIG_W) && llist->dflts && LY_ARRAY_SIZE(llist->dflts)) {
3765 /* configuration data values must be unique - so check the default values */
3766 LY_ARRAY_FOR(llist->dflts, u) {
3767 for (v = u + 1; v < LY_ARRAY_SIZE(llist->dflts); ++v) {
3768 if (!llist->type->plugin->compare(llist->dflts[u], llist->dflts[v])) {
3769 int dynamic = 0;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02003770 const char *val = llist->type->plugin->print(llist->dflts[v], LYD_XML, lys_get_prefix, llist->dflts_mods[v], &dynamic);
Radek Krejcia1911222019-07-22 17:24:50 +02003771 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3772 "Configuration leaf-list has multiple defaults of the same value \"%s\".", val);
3773 if (dynamic) {
3774 free((char*)val);
3775 }
3776 return LY_EVALID;
3777 }
3778 }
3779 }
3780 }
3781
3782 /* TODO validate default value according to the type, possibly postpone the check when the leafref target is known */
Radek Krejci0e5d8382018-11-28 16:37:53 +01003783
3784 llist->min = llist_p->min;
Radek Krejcife909632019-02-12 15:34:42 +01003785 if (llist->min) {
3786 llist->flags |= LYS_MAND_TRUE;
3787 }
Radek Krejcib7408632018-11-28 17:12:11 +01003788 llist->max = llist_p->max ? llist_p->max : (uint32_t)-1;
Radek Krejci0e5d8382018-11-28 16:37:53 +01003789
Radek Krejci0e5d8382018-11-28 16:37:53 +01003790done:
3791 return ret;
3792}
3793
3794/**
Radek Krejci7af64242019-02-18 13:07:53 +01003795 * @brief Compile information about list's uniques.
3796 * @param[in] ctx Compile context.
3797 * @param[in] context_module Module where the prefixes are going to be resolved.
3798 * @param[in] uniques Sized array list of unique statements.
3799 * @param[in] list Compiled list where the uniques are supposed to be resolved and stored.
3800 * @return LY_ERR value.
3801 */
3802static LY_ERR
3803lys_compile_node_list_unique(struct lysc_ctx *ctx, struct lys_module *context_module, const char **uniques, struct lysc_node_list *list)
3804{
3805 LY_ERR ret = LY_SUCCESS;
3806 struct lysc_node_leaf **key, ***unique;
3807 const char *keystr, *delim;
3808 size_t len;
3809 unsigned int v;
3810 int config;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003811 uint16_t flags;
Radek Krejci7af64242019-02-18 13:07:53 +01003812
3813 for (v = 0; v < LY_ARRAY_SIZE(uniques); ++v) {
3814 config = -1;
3815 LY_ARRAY_NEW_RET(ctx->ctx, list->uniques, unique, LY_EMEM);
3816 keystr = uniques[v];
3817 while (keystr) {
3818 delim = strpbrk(keystr, " \t\n");
3819 if (delim) {
3820 len = delim - keystr;
3821 while (isspace(*delim)) {
3822 ++delim;
3823 }
3824 } else {
3825 len = strlen(keystr);
3826 }
3827
3828 /* unique node must be present */
3829 LY_ARRAY_NEW_RET(ctx->ctx, *unique, key, LY_EMEM);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003830 ret = lys_resolve_schema_nodeid(ctx, keystr, len, (struct lysc_node*)list, context_module, LYS_LEAF, 0,
3831 (const struct lysc_node**)key, &flags);
Radek Krejci7af64242019-02-18 13:07:53 +01003832 if (ret != LY_SUCCESS) {
3833 if (ret == LY_EDENIED) {
3834 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003835 "Unique's descendant-schema-nodeid \"%.*s\" refers to %s node instead of a leaf.",
Radek Krejci7af64242019-02-18 13:07:53 +01003836 len, keystr, lys_nodetype2str((*key)->nodetype));
3837 }
3838 return LY_EVALID;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003839 } else if (flags) {
3840 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3841 "Unique's descendant-schema-nodeid \"%.*s\" refers into %s node.",
3842 len, keystr, flags & LYSC_OPT_NOTIFICATION ? "Notification" : "RPC/action");
3843 return LY_EVALID;
Radek Krejci7af64242019-02-18 13:07:53 +01003844 }
3845
Radek Krejci6eeb58f2019-02-22 16:29:37 +01003846
Radek Krejci7af64242019-02-18 13:07:53 +01003847 /* all referenced leafs must be of the same config type */
3848 if (config != -1 && ((((*key)->flags & LYS_CONFIG_W) && config == 0) || (((*key)->flags & LYS_CONFIG_R) && config == 1))) {
3849 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3850 "Unique statement \"%s\" refers to leafs with different config type.", uniques[v]);
3851 return LY_EVALID;
3852 } else if ((*key)->flags & LYS_CONFIG_W) {
3853 config = 1;
3854 } else { /* LYS_CONFIG_R */
3855 config = 0;
3856 }
3857
3858 /* check status */
3859 LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
3860 (*key)->flags, (*key)->module, (*key)->name));
3861
3862 /* mark leaf as unique */
3863 (*key)->flags |= LYS_UNIQUE;
3864
3865 /* next unique value in line */
3866 keystr = delim;
3867 }
3868 /* next unique definition */
3869 }
3870
3871 return LY_SUCCESS;
3872}
3873
3874/**
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003875 * @brief Compile parsed list node information.
3876 * @param[in] ctx Compile context
3877 * @param[in] node_p Parsed list node.
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003878 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
3879 * is enriched with the list-specific information.
3880 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
3881 */
3882static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02003883lys_compile_node_list(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003884{
3885 struct lysp_node_list *list_p = (struct lysp_node_list*)node_p;
3886 struct lysc_node_list *list = (struct lysc_node_list*)node;
3887 struct lysp_node *child_p;
Radek Krejci0fe9b512019-07-26 17:51:05 +02003888 struct lysc_node_leaf *key, *prev_key = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003889 size_t len;
Radek Krejci7af64242019-02-18 13:07:53 +01003890 unsigned int u;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003891 const char *keystr, *delim;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003892 LY_ERR ret = LY_SUCCESS;
3893
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003894 list->min = list_p->min;
Radek Krejcife909632019-02-12 15:34:42 +01003895 if (list->min) {
3896 list->flags |= LYS_MAND_TRUE;
3897 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003898 list->max = list_p->max ? list_p->max : (uint32_t)-1;
3899
3900 LY_LIST_FOR(list_p->child, child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02003901 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003902 }
3903
Radek Krejciec4da802019-05-02 13:02:41 +02003904 COMPILE_ARRAY_GOTO(ctx, list_p->musts, list->musts, u, lys_compile_must, ret, done);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003905
3906 /* keys */
3907 if ((list->flags & LYS_CONFIG_W) && (!list_p->key || !list_p->key[0])) {
3908 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Missing key in list representing configuration data.");
3909 return LY_EVALID;
3910 }
3911
3912 /* find all the keys (must be direct children) */
3913 keystr = list_p->key;
Radek Krejci0fe9b512019-07-26 17:51:05 +02003914 if (!keystr) {
3915 /* keyless list */
3916 list->flags |= LYS_KEYLESS;
3917 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003918 while (keystr) {
3919 delim = strpbrk(keystr, " \t\n");
3920 if (delim) {
3921 len = delim - keystr;
3922 while (isspace(*delim)) {
3923 ++delim;
3924 }
3925 } else {
3926 len = strlen(keystr);
3927 }
3928
3929 /* key node must be present */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003930 key = (struct lysc_node_leaf*)lys_child(node, node->module, keystr, len, LYS_LEAF, LYS_GETNEXT_NOCHOICE | LYS_GETNEXT_NOSTATECHECK);
3931 if (!(key)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003932 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
3933 "The list's key \"%.*s\" not found.", len, keystr);
3934 return LY_EVALID;
3935 }
3936 /* keys must be unique */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003937 if (key->flags & LYS_KEY) {
3938 /* the node was already marked as a key */
3939 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
3940 "Duplicated key identifier \"%.*s\".", len, keystr);
3941 return LY_EVALID;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003942 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02003943
3944 lysc_update_path(ctx, (struct lysc_node*)list, key->name);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003945 /* key must have the same config flag as the list itself */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003946 if ((list->flags & LYS_CONFIG_MASK) != (key->flags & LYS_CONFIG_MASK)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003947 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Key of the configuration list must not be status leaf.");
3948 return LY_EVALID;
3949 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01003950 if (ctx->mod_def->version < LYS_VERSION_1_1) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003951 /* YANG 1.0 denies key to be of empty type */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003952 if (key->type->basetype == LY_TYPE_EMPTY) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003953 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003954 "List's key cannot be of \"empty\" type until it is in YANG 1.1 module.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003955 return LY_EVALID;
3956 }
3957 } else {
3958 /* when and if-feature are illegal on list keys */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003959 if (key->when) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003960 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003961 "List's key must not have any \"when\" statement.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003962 return LY_EVALID;
3963 }
Radek Krejci0fe9b512019-07-26 17:51:05 +02003964 if (key->iffeatures) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003965 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02003966 "List's key must not have any \"if-feature\" statement.");
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003967 return LY_EVALID;
3968 }
3969 }
Radek Krejci76b3e962018-12-14 17:01:25 +01003970
3971 /* check status */
3972 LY_CHECK_RET(lysc_check_status(ctx, list->flags, list->module, list->name,
Radek Krejci0fe9b512019-07-26 17:51:05 +02003973 key->flags, key->module, key->name));
Radek Krejci76b3e962018-12-14 17:01:25 +01003974
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003975 /* ignore default values of the key */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003976 if (key->dflt) {
3977 key->dflt->realtype->plugin->free(ctx->ctx, key->dflt);
3978 lysc_type_free(ctx->ctx, key->dflt->realtype);
3979 free(key->dflt);
3980 key->dflt = NULL;
3981 key->dflt_mod = NULL;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01003982 }
3983 /* mark leaf as key */
Radek Krejci0fe9b512019-07-26 17:51:05 +02003984 key->flags |= LYS_KEY;
3985
3986 /* move it to the correct position */
3987 if ((prev_key && (struct lysc_node*)prev_key != key->prev) || (!prev_key && key->prev->next)) {
3988 /* fix links in closest previous siblings of the key */
3989 if (key->next) {
3990 key->next->prev = key->prev;
3991 } else {
3992 /* last child */
3993 list->child->prev = key->prev;
3994 }
3995 if (key->prev->next) {
3996 key->prev->next = key->next;
3997 }
3998 /* fix links in the key */
3999 if (prev_key) {
4000 key->prev = (struct lysc_node*)prev_key;
4001 key->next = prev_key->next;
4002 } else {
4003 key->prev = list->child->prev;
4004 key->next = list->child;
4005 }
4006 /* fix links in closes future siblings of the key */
4007 if (prev_key) {
4008 if (prev_key->next) {
4009 prev_key->next->prev = (struct lysc_node*)key;
4010 } else {
4011 list->child->prev = (struct lysc_node*)key;
4012 }
4013 prev_key->next = (struct lysc_node*)key;
4014 } else {
4015 list->child->prev = (struct lysc_node*)key;
4016 }
4017 /* fix links in parent */
4018 if (!key->prev->next) {
4019 list->child = (struct lysc_node*)key;
4020 }
4021 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004022
4023 /* next key value */
Radek Krejci0fe9b512019-07-26 17:51:05 +02004024 prev_key = key;
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004025 keystr = delim;
Radek Krejci327de162019-06-14 12:52:07 +02004026 lysc_update_path(ctx, NULL, NULL);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004027 }
4028
4029 /* uniques */
4030 if (list_p->uniques) {
Radek Krejci7af64242019-02-18 13:07:53 +01004031 LY_CHECK_RET(lys_compile_node_list_unique(ctx, list->module, list_p->uniques, list));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004032 }
4033
Radek Krejciec4da802019-05-02 13:02:41 +02004034 COMPILE_ARRAY1_GOTO(ctx, list_p->actions, list->actions, node, u, lys_compile_action, 0, ret, done);
4035 COMPILE_ARRAY1_GOTO(ctx, list_p->notifs, list->notifs, node, u, lys_compile_notif, 0, ret, done);
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004036
4037done:
4038 return ret;
4039}
4040
Radek Krejcib56c7502019-02-13 14:19:54 +01004041/**
4042 * @brief Do some checks and set the default choice's case.
4043 *
4044 * Selects (and stores into ::lysc_node_choice#dflt) the default case and set LYS_SET_DFLT flag on it.
4045 *
4046 * @param[in] ctx Compile context.
4047 * @param[in] dflt Name of the default branch. Can contain even the prefix, but it make sense only in case it is the prefix of the module itself,
4048 * not the reference to the imported module.
4049 * @param[in,out] ch The compiled choice node, its dflt member is filled to point to the default case node of the choice.
4050 * @return LY_ERR value.
4051 */
Radek Krejci76b3e962018-12-14 17:01:25 +01004052static LY_ERR
4053lys_compile_node_choice_dflt(struct lysc_ctx *ctx, const char *dflt, struct lysc_node_choice *ch)
4054{
4055 struct lysc_node *iter, *node = (struct lysc_node*)ch;
4056 const char *prefix = NULL, *name;
4057 size_t prefix_len = 0;
4058
4059 /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
4060 name = strchr(dflt, ':');
4061 if (name) {
4062 prefix = dflt;
4063 prefix_len = name - prefix;
4064 ++name;
4065 } else {
4066 name = dflt;
4067 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +01004068 if (prefix && (strncmp(prefix, node->module->prefix, prefix_len) || node->module->prefix[prefix_len] != '\0')) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004069 /* prefixed default case make sense only for the prefix of the schema itself */
4070 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
4071 "Invalid default case referencing a case from different YANG module (by prefix \"%.*s\").",
4072 prefix_len, prefix);
4073 return LY_EVALID;
4074 }
4075 ch->dflt = (struct lysc_node_case*)lys_child(node, node->module, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
4076 if (!ch->dflt) {
4077 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4078 "Default case \"%s\" not found.", dflt);
4079 return LY_EVALID;
4080 }
4081 /* no mandatory nodes directly under the default case */
4082 LY_LIST_FOR(ch->dflt->child, iter) {
Radek Krejcife13da42019-02-15 14:51:01 +01004083 if (iter->parent != (struct lysc_node*)ch->dflt) {
4084 break;
4085 }
Radek Krejci76b3e962018-12-14 17:01:25 +01004086 if (iter->flags & LYS_MAND_TRUE) {
4087 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4088 "Mandatory node \"%s\" under the default case \"%s\".", iter->name, dflt);
4089 return LY_EVALID;
4090 }
4091 }
Radek Krejci01342af2019-01-03 15:18:08 +01004092 ch->dflt->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01004093 return LY_SUCCESS;
4094}
4095
Radek Krejciccd20f12019-02-15 14:12:27 +01004096static LY_ERR
Radek Krejci327de162019-06-14 12:52:07 +02004097lys_compile_deviation_set_choice_dflt(struct lysc_ctx *ctx, const char *dflt, struct lysc_node_choice *ch)
Radek Krejciccd20f12019-02-15 14:12:27 +01004098{
4099 struct lys_module *mod;
4100 const char *prefix = NULL, *name;
4101 size_t prefix_len = 0;
4102 struct lysc_node_case *cs;
4103 struct lysc_node *node;
4104
4105 /* could use lys_parse_nodeid(), but it checks syntax which is already done in this case by the parsers */
4106 name = strchr(dflt, ':');
4107 if (name) {
4108 prefix = dflt;
4109 prefix_len = name - prefix;
4110 ++name;
4111 } else {
4112 name = dflt;
4113 }
4114 /* this code is for deviation, so we allow as the default case even the cases from other modules than the choice (augments) */
4115 if (prefix) {
4116 if (!(mod = lys_module_find_prefix(ctx->mod, prefix, prefix_len))) {
4117 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004118 "Invalid deviation adding \"default\" property \"%s\" of choice. "
4119 "The prefix does not match any imported module of the deviation module.", dflt);
Radek Krejciccd20f12019-02-15 14:12:27 +01004120 return LY_EVALID;
4121 }
4122 } else {
4123 mod = ctx->mod;
4124 }
4125 /* get the default case */
4126 cs = (struct lysc_node_case*)lys_child((struct lysc_node*)ch, mod, name, 0, LYS_CASE, LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCASE);
4127 if (!cs) {
4128 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004129 "Invalid deviation adding \"default\" property \"%s\" of choice - the specified case does not exists.", dflt);
Radek Krejciccd20f12019-02-15 14:12:27 +01004130 return LY_EVALID;
4131 }
4132
4133 /* check that there is no mandatory node */
4134 LY_LIST_FOR(cs->child, node) {
Radek Krejcife13da42019-02-15 14:51:01 +01004135 if (node->parent != (struct lysc_node*)cs) {
4136 break;
4137 }
Radek Krejciccd20f12019-02-15 14:12:27 +01004138 if (node->flags & LYS_MAND_TRUE) {
4139 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004140 "Invalid deviation adding \"default\" property \"%s\" of choice - "
4141 "mandatory node \"%s\" under the default case.", dflt, node->name);
Radek Krejciccd20f12019-02-15 14:12:27 +01004142 return LY_EVALID;
4143 }
4144 }
4145
4146 /* set the default case in choice */
4147 ch->dflt = cs;
4148 cs->flags |= LYS_SET_DFLT;
4149
4150 return LY_SUCCESS;
4151}
4152
Radek Krejci9bb94eb2018-12-04 16:48:35 +01004153/**
Radek Krejci056d0a82018-12-06 16:57:25 +01004154 * @brief Compile parsed choice node information.
4155 * @param[in] ctx Compile context
4156 * @param[in] node_p Parsed choice node.
Radek Krejci056d0a82018-12-06 16:57:25 +01004157 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
Radek Krejci76b3e962018-12-14 17:01:25 +01004158 * is enriched with the choice-specific information.
Radek Krejci056d0a82018-12-06 16:57:25 +01004159 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4160 */
4161static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004162lys_compile_node_choice(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci056d0a82018-12-06 16:57:25 +01004163{
4164 struct lysp_node_choice *ch_p = (struct lysp_node_choice*)node_p;
4165 struct lysc_node_choice *ch = (struct lysc_node_choice*)node;
4166 struct lysp_node *child_p, *case_child_p;
Radek Krejci056d0a82018-12-06 16:57:25 +01004167 LY_ERR ret = LY_SUCCESS;
4168
Radek Krejci056d0a82018-12-06 16:57:25 +01004169 LY_LIST_FOR(ch_p->child, child_p) {
4170 if (child_p->nodetype == LYS_CASE) {
4171 LY_LIST_FOR(((struct lysp_node_case*)child_p)->child, case_child_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02004172 LY_CHECK_RET(lys_compile_node(ctx, case_child_p, node, 0));
Radek Krejci056d0a82018-12-06 16:57:25 +01004173 }
4174 } else {
Radek Krejciec4da802019-05-02 13:02:41 +02004175 LY_CHECK_RET(lys_compile_node(ctx, child_p, node, 0));
Radek Krejci056d0a82018-12-06 16:57:25 +01004176 }
4177 }
4178
4179 /* default branch */
Radek Krejcia9026eb2018-12-12 16:04:47 +01004180 if (ch_p->dflt) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004181 LY_CHECK_RET(lys_compile_node_choice_dflt(ctx, ch_p->dflt, ch));
Radek Krejcia9026eb2018-12-12 16:04:47 +01004182 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004183
Radek Krejci9800fb82018-12-13 14:26:23 +01004184 return ret;
4185}
4186
4187/**
4188 * @brief Compile parsed anydata or anyxml node information.
4189 * @param[in] ctx Compile context
4190 * @param[in] node_p Parsed anydata or anyxml node.
Radek Krejci9800fb82018-12-13 14:26:23 +01004191 * @param[in,out] node Pre-prepared structure from lys_compile_node() with filled generic node information
4192 * is enriched with the any-specific information.
4193 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4194 */
4195static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004196lys_compile_node_any(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *node)
Radek Krejci9800fb82018-12-13 14:26:23 +01004197{
4198 struct lysp_node_anydata *any_p = (struct lysp_node_anydata*)node_p;
4199 struct lysc_node_anydata *any = (struct lysc_node_anydata*)node;
4200 unsigned int u;
4201 LY_ERR ret = LY_SUCCESS;
4202
Radek Krejciec4da802019-05-02 13:02:41 +02004203 COMPILE_ARRAY_GOTO(ctx, any_p->musts, any->musts, u, lys_compile_must, ret, done);
Radek Krejci9800fb82018-12-13 14:26:23 +01004204
4205 if (any->flags & LYS_CONFIG_W) {
4206 LOGWRN(ctx->ctx, "Use of %s to define configuration data is not recommended.",
Radek Krejcid6b76452019-09-03 17:03:03 +02004207 ly_stmt2str(any->nodetype == LYS_ANYDATA ? LY_STMT_ANYDATA : LY_STMT_ANYXML));
Radek Krejci9800fb82018-12-13 14:26:23 +01004208 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004209done:
4210 return ret;
4211}
4212
Radek Krejcib56c7502019-02-13 14:19:54 +01004213/**
Radek Krejci056d0a82018-12-06 16:57:25 +01004214 * @brief Connect the node into the siblings list and check its name uniqueness.
4215 *
4216 * @param[in] ctx Compile context
4217 * @param[in] parent Parent node holding the children list, in case of node from a choice's case,
4218 * the choice itself is expected instead of a specific case node.
4219 * @param[in] node Schema node to connect into the list.
4220 * @return LY_ERR value - LY_SUCCESS or LY_EEXIST.
4221 */
4222static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004223lys_compile_node_connect(struct lysc_ctx *ctx, struct lysc_node *parent, struct lysc_node *node)
Radek Krejci056d0a82018-12-06 16:57:25 +01004224{
4225 struct lysc_node **children;
4226
4227 if (node->nodetype == LYS_CASE) {
4228 children = (struct lysc_node**)&((struct lysc_node_choice*)parent)->cases;
4229 } else {
Radek Krejciec4da802019-05-02 13:02:41 +02004230 children = lysc_node_children_p(parent, ctx->options);
Radek Krejci056d0a82018-12-06 16:57:25 +01004231 }
4232 if (children) {
4233 if (!(*children)) {
4234 /* first child */
4235 *children = node;
4236 } else if (*children != node) {
4237 /* by the condition in previous branch we cover the choice/case children
4238 * - the children list is shared by the choice and the the first case, in addition
4239 * the first child of each case must be referenced from the case node. So the node is
4240 * actually always already inserted in case it is the first children - so here such
4241 * a situation actually corresponds to the first branch */
4242 /* insert at the end of the parent's children list */
4243 (*children)->prev->next = node;
4244 node->prev = (*children)->prev;
4245 (*children)->prev = node;
4246
4247 /* check the name uniqueness */
4248 if (lys_compile_node_uniqness(ctx, *children, lysc_node_actions(parent),
4249 lysc_node_notifs(parent), node->name, node)) {
4250 return LY_EEXIST;
4251 }
4252 }
4253 }
4254 return LY_SUCCESS;
4255}
4256
Radek Krejci95710c92019-02-11 15:49:55 +01004257/**
Radek Krejcib56c7502019-02-13 14:19:54 +01004258 * @brief Get the XPath context node for the given schema node.
4259 * @param[in] start The schema node where the XPath expression appears.
4260 * @return The context node to evaluate XPath expression in given schema node.
4261 * @return NULL in case the context node is the root node.
4262 */
4263static struct lysc_node *
4264lysc_xpath_context(struct lysc_node *start)
4265{
4266 for (; start && !(start->nodetype & (LYS_CONTAINER | LYS_LEAF | LYS_LEAFLIST | LYS_LIST | LYS_ANYDATA | LYS_ACTION | LYS_NOTIF));
4267 start = start->parent);
4268 return start;
4269}
4270
4271/**
4272 * @brief Prepare the case structure in choice node for the new data node.
4273 *
4274 * It is able to handle implicit as well as explicit cases and the situation when the case has multiple data nodes and the case was already
4275 * created in the choice when the first child was processed.
4276 *
4277 * @param[in] ctx Compile context.
Radek Krejci95710c92019-02-11 15:49:55 +01004278 * @param[in] node_p Node image from the parsed tree. If the case is explicit, it is the LYS_CASE node, but in case of implicit case,
4279 * it is the LYS_CHOICE node or LYS_AUGMENT node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004280 * @param[in] ch The compiled choice structure where the new case structures are created (if needed).
4281 * @param[in] child The new data node being part of a case (no matter if explicit or implicit).
4282 * @return The case structure where the child node belongs to, NULL in case of error. Note that the child is not connected into the siblings list,
4283 * it is linked from the case structure only in case it is its first child.
Radek Krejci95710c92019-02-11 15:49:55 +01004284 */
Radek Krejci056d0a82018-12-06 16:57:25 +01004285static struct lysc_node_case*
Radek Krejciec4da802019-05-02 13:02:41 +02004286lys_compile_node_case(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node_choice *ch, struct lysc_node *child)
Radek Krejci056d0a82018-12-06 16:57:25 +01004287{
4288 struct lysc_node *iter;
Radek Krejci98b1a662019-04-23 10:25:50 +02004289 struct lysc_node_case *cs = NULL;
Radek Krejci00b874b2019-02-12 10:54:50 +01004290 struct lysc_when **when;
Radek Krejci056d0a82018-12-06 16:57:25 +01004291 unsigned int u;
4292 LY_ERR ret;
4293
Radek Krejci95710c92019-02-11 15:49:55 +01004294#define UNIQUE_CHECK(NAME, MOD) \
Radek Krejci056d0a82018-12-06 16:57:25 +01004295 LY_LIST_FOR((struct lysc_node*)ch->cases, iter) { \
Radek Krejci95710c92019-02-11 15:49:55 +01004296 if (iter->module == MOD && !strcmp(iter->name, NAME)) { \
Radek Krejci056d0a82018-12-06 16:57:25 +01004297 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPIDENT, NAME, "case"); \
4298 return NULL; \
4299 } \
4300 }
4301
Radek Krejci95710c92019-02-11 15:49:55 +01004302 if (node_p->nodetype == LYS_CHOICE || node_p->nodetype == LYS_AUGMENT) {
4303 UNIQUE_CHECK(child->name, ctx->mod);
Radek Krejci056d0a82018-12-06 16:57:25 +01004304
4305 /* we have to add an implicit case node into the parent choice */
4306 cs = calloc(1, sizeof(struct lysc_node_case));
4307 DUP_STRING(ctx->ctx, child->name, cs->name);
4308 cs->flags = ch->flags & LYS_STATUS_MASK;
Radek Krejci95710c92019-02-11 15:49:55 +01004309 } else if (node_p->nodetype == LYS_CASE) {
Radek Krejci056d0a82018-12-06 16:57:25 +01004310 if (ch->cases && (node_p == ch->cases->prev->sp)) {
4311 /* the case is already present since the child is not its first children */
4312 return (struct lysc_node_case*)ch->cases->prev;
4313 }
Radek Krejci95710c92019-02-11 15:49:55 +01004314 UNIQUE_CHECK(node_p->name, ctx->mod);
Radek Krejci056d0a82018-12-06 16:57:25 +01004315
4316 /* explicit parent case is not present (this is its first child) */
4317 cs = calloc(1, sizeof(struct lysc_node_case));
4318 DUP_STRING(ctx->ctx, node_p->name, cs->name);
4319 cs->flags = LYS_STATUS_MASK & node_p->flags;
4320 cs->sp = node_p;
4321
Radek Krejcib1b59152019-01-07 13:21:56 +01004322 /* check the case's status (don't need to solve uses_status since case statement cannot be directly in grouping statement */
Radek Krejcibae745f2019-04-09 16:28:00 +02004323 LY_CHECK_GOTO(lys_compile_status(ctx, &cs->flags, ch->flags), error);
Radek Krejci00b874b2019-02-12 10:54:50 +01004324
4325 if (node_p->when) {
4326 LY_ARRAY_NEW_GOTO(ctx->ctx, cs->when, when, ret, error);
Radek Krejciec4da802019-05-02 13:02:41 +02004327 ret = lys_compile_when(ctx, node_p->when, when);
Radek Krejci00b874b2019-02-12 10:54:50 +01004328 LY_CHECK_GOTO(ret, error);
Radek Krejcib56c7502019-02-13 14:19:54 +01004329 (*when)->context = lysc_xpath_context(ch->parent);
Radek Krejci00b874b2019-02-12 10:54:50 +01004330 }
Radek Krejciec4da802019-05-02 13:02:41 +02004331 COMPILE_ARRAY_GOTO(ctx, node_p->iffeatures, cs->iffeatures, u, lys_compile_iffeature, ret, error);
Radek Krejci95710c92019-02-11 15:49:55 +01004332 } else {
4333 LOGINT(ctx->ctx);
4334 goto error;
Radek Krejci056d0a82018-12-06 16:57:25 +01004335 }
4336 cs->module = ctx->mod;
4337 cs->prev = (struct lysc_node*)cs;
4338 cs->nodetype = LYS_CASE;
Radek Krejciec4da802019-05-02 13:02:41 +02004339 lys_compile_node_connect(ctx, (struct lysc_node*)ch, (struct lysc_node*)cs);
Radek Krejci056d0a82018-12-06 16:57:25 +01004340 cs->parent = (struct lysc_node*)ch;
4341 cs->child = child;
4342
4343 return cs;
4344error:
Radek Krejci1b1e9252019-04-24 08:45:50 +02004345 if (cs) {
4346 lysc_node_free(ctx->ctx, (struct lysc_node*)cs);
4347 }
Radek Krejci056d0a82018-12-06 16:57:25 +01004348 return NULL;
4349
4350#undef UNIQUE_CHECK
4351}
4352
Radek Krejcib56c7502019-02-13 14:19:54 +01004353/**
Radek Krejci93dcc392019-02-19 10:43:38 +01004354 * @brief Apply refined or deviated config to the target node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004355 *
4356 * @param[in] ctx Compile context.
Radek Krejci93dcc392019-02-19 10:43:38 +01004357 * @param[in] node Target node where the config is supposed to be changed.
4358 * @param[in] config_flag Node's config flag to be applied to the @p node.
Radek Krejcib56c7502019-02-13 14:19:54 +01004359 * @param[in] inheriting Flag (inverted) to check the refined config compatibility with the node's parent. This is
4360 * done only on the node for which the refine was created. The function applies also recursively to apply the config change
Radek Krejci93dcc392019-02-19 10:43:38 +01004361 * to the complete subtree (except the subnodes with explicit config set) and the test is not needed for the subnodes.
4362 * @param[in] refine_flag Flag to distinguish if the change is caused by refine (flag set) or deviation (for logging).
Radek Krejcib56c7502019-02-13 14:19:54 +01004363 * @return LY_ERR value.
4364 */
Radek Krejci76b3e962018-12-14 17:01:25 +01004365static LY_ERR
Radek Krejci93dcc392019-02-19 10:43:38 +01004366lys_compile_change_config(struct lysc_ctx *ctx, struct lysc_node *node, uint16_t config_flag,
Radek Krejci327de162019-06-14 12:52:07 +02004367 int inheriting, int refine_flag)
Radek Krejci76b3e962018-12-14 17:01:25 +01004368{
4369 struct lysc_node *child;
Radek Krejci93dcc392019-02-19 10:43:38 +01004370 uint16_t config = config_flag & LYS_CONFIG_MASK;
Radek Krejci76b3e962018-12-14 17:01:25 +01004371
4372 if (config == (node->flags & LYS_CONFIG_MASK)) {
4373 /* nothing to do */
4374 return LY_SUCCESS;
4375 }
4376
4377 if (!inheriting) {
Radek Krejci93dcc392019-02-19 10:43:38 +01004378 /* explicit change */
Radek Krejci76b3e962018-12-14 17:01:25 +01004379 if (config == LYS_CONFIG_W && node->parent && (node->parent->flags & LYS_CONFIG_R)) {
4380 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004381 "Invalid %s of config - configuration node cannot be child of any state data node.",
4382 refine_flag ? "refine" : "deviation");
Radek Krejci76b3e962018-12-14 17:01:25 +01004383 return LY_EVALID;
4384 }
Radek Krejci93dcc392019-02-19 10:43:38 +01004385 node->flags |= LYS_SET_CONFIG;
4386 } else {
4387 if (node->flags & LYS_SET_CONFIG) {
4388 if ((node->flags & LYS_CONFIG_W) && (config == LYS_CONFIG_R)) {
4389 /* setting config flags, but have node with explicit config true */
4390 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004391 "Invalid %s of config - configuration node cannot be child of any state data node.",
4392 refine_flag ? "refine" : "deviation");
Radek Krejci93dcc392019-02-19 10:43:38 +01004393 return LY_EVALID;
4394 }
4395 /* do not change config on nodes where the config is explicitely set, this does not apply to
4396 * nodes, which are being changed explicitly (targets of refine or deviation) */
4397 return LY_SUCCESS;
4398 }
Radek Krejci76b3e962018-12-14 17:01:25 +01004399 }
4400 node->flags &= ~LYS_CONFIG_MASK;
4401 node->flags |= config;
4402
4403 /* inherit the change into the children */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004404 LY_LIST_FOR((struct lysc_node*)lysc_node_children(node, 0), child) {
Radek Krejci327de162019-06-14 12:52:07 +02004405 LY_CHECK_RET(lys_compile_change_config(ctx, child, config_flag, 1, refine_flag));
Radek Krejci76b3e962018-12-14 17:01:25 +01004406 }
4407
Radek Krejci76b3e962018-12-14 17:01:25 +01004408 return LY_SUCCESS;
4409}
4410
Radek Krejcib56c7502019-02-13 14:19:54 +01004411/**
4412 * @brief Set LYS_MAND_TRUE flag for the non-presence container parents.
4413 *
4414 * A non-presence container is mandatory in case it has at least one mandatory children. This function propagate
4415 * the flag to such parents from a mandatory children.
4416 *
4417 * @param[in] parent A schema node to be examined if the mandatory child make it also mandatory.
4418 * @param[in] add Flag to distinguish adding the mandatory flag (new mandatory children appeared) or removing the flag
4419 * (mandatory children was removed).
4420 */
Radek Krejcife909632019-02-12 15:34:42 +01004421void
4422lys_compile_mandatory_parents(struct lysc_node *parent, int add)
4423{
4424 struct lysc_node *iter;
4425
4426 if (add) { /* set flag */
4427 for (; parent && parent->nodetype == LYS_CONTAINER && !(parent->flags & LYS_MAND_TRUE) && !(parent->flags & LYS_PRESENCE);
4428 parent = parent->parent) {
4429 parent->flags |= LYS_MAND_TRUE;
4430 }
4431 } else { /* unset flag */
4432 for (; parent && parent->nodetype == LYS_CONTAINER && (parent->flags & LYS_MAND_TRUE); parent = parent->parent) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004433 for (iter = (struct lysc_node*)lysc_node_children(parent, 0); iter; iter = iter->next) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004434 if (iter->flags & LYS_MAND_TRUE) {
Radek Krejcife909632019-02-12 15:34:42 +01004435 /* there is another mandatory node */
4436 return;
4437 }
4438 }
4439 /* unset mandatory flag - there is no mandatory children in the non-presence container */
4440 parent->flags &= ~LYS_MAND_TRUE;
4441 }
4442 }
4443}
4444
Radek Krejci056d0a82018-12-06 16:57:25 +01004445/**
Radek Krejci3641f562019-02-13 15:38:40 +01004446 * @brief Internal sorting process for the lys_compile_augment_sort().
4447 * @param[in] aug_p The parsed augment structure to insert into the sorter sized array @p result.
4448 * @param[in,out] result Sized array to store the sorted list of augments. The array is expected
4449 * to be allocated to hold the complete list, its size is just incremented by adding another item.
4450 */
4451static void
4452lys_compile_augment_sort_(struct lysp_augment *aug_p, struct lysp_augment **result)
4453{
4454 unsigned int v;
4455 size_t len;
4456
4457 len = strlen(aug_p->nodeid);
4458 LY_ARRAY_FOR(result, v) {
4459 if (strlen(result[v]->nodeid) <= len) {
4460 continue;
4461 }
4462 if (v < LY_ARRAY_SIZE(result)) {
4463 /* move the rest of array */
4464 memmove(&result[v + 1], &result[v], (LY_ARRAY_SIZE(result) - v) * sizeof *result);
4465 break;
4466 }
4467 }
4468 result[v] = aug_p;
4469 LY_ARRAY_INCREMENT(result);
4470}
4471
4472/**
4473 * @brief Sort augments to apply /a/b before /a/b/c (where the /a/b/c was added by the first augment).
4474 *
4475 * The sorting is based only on the length of the augment's path since it guarantee the correct order
4476 * (it doesn't matter the /a/x is done before /a/b/c from the example above).
4477 *
4478 * @param[in] ctx Compile context.
4479 * @param[in] mod_p Parsed module with the global augments (also augments from the submodules are taken).
4480 * @param[in] aug_p Parsed sized array of augments to sort (no matter if global or uses's)
4481 * @param[in] inc_p In case of global augments, sized array of module includes (submodules) to get global augments from submodules.
4482 * @param[out] augments Resulting sorted sized array of pointers to the augments.
4483 * @return LY_ERR value.
4484 */
4485LY_ERR
4486lys_compile_augment_sort(struct lysc_ctx *ctx, struct lysp_augment *aug_p, struct lysp_include *inc_p, struct lysp_augment ***augments)
4487{
4488 struct lysp_augment **result = NULL;
4489 unsigned int u, v;
4490 size_t count = 0;
4491
4492 assert(augments);
4493
4494 /* get count of the augments in module and all its submodules */
4495 if (aug_p) {
4496 count += LY_ARRAY_SIZE(aug_p);
4497 }
4498 LY_ARRAY_FOR(inc_p, u) {
4499 if (inc_p[u].submodule->augments) {
4500 count += LY_ARRAY_SIZE(inc_p[u].submodule->augments);
4501 }
4502 }
4503
4504 if (!count) {
4505 *augments = NULL;
4506 return LY_SUCCESS;
4507 }
4508 LY_ARRAY_CREATE_RET(ctx->ctx, result, count, LY_EMEM);
4509
4510 /* sort by the length of schema-nodeid - we need to solve /x before /x/xy. It is not necessary to group them
4511 * together, so there can be even /z/y betwwen them. */
4512 LY_ARRAY_FOR(aug_p, u) {
4513 lys_compile_augment_sort_(&aug_p[u], result);
4514 }
4515 LY_ARRAY_FOR(inc_p, u) {
4516 LY_ARRAY_FOR(inc_p[u].submodule->augments, v) {
4517 lys_compile_augment_sort_(&inc_p[u].submodule->augments[v], result);
4518 }
4519 }
4520
4521 *augments = result;
4522 return LY_SUCCESS;
4523}
4524
4525/**
4526 * @brief Compile the parsed augment connecting it into its target.
4527 *
4528 * It is expected that all the data referenced in path are present - augments are ordered so that augment B
4529 * targeting data from augment A is being compiled after augment A. Also the modules referenced in the path
4530 * are already implemented and compiled.
4531 *
4532 * @param[in] ctx Compile context.
4533 * @param[in] aug_p Parsed augment to compile.
Radek Krejci3641f562019-02-13 15:38:40 +01004534 * @param[in] parent Parent node to provide the augment's context. It is NULL for the top level augments and a node holding uses's
4535 * children in case of the augmenting uses data.
4536 * @return LY_SUCCESS on success.
4537 * @return LY_EVALID on failure.
4538 */
4539LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004540lys_compile_augment(struct lysc_ctx *ctx, struct lysp_augment *aug_p, const struct lysc_node *parent)
Radek Krejci3641f562019-02-13 15:38:40 +01004541{
4542 LY_ERR ret = LY_SUCCESS;
4543 struct lysp_node *node_p, *case_node_p;
4544 struct lysc_node *target; /* target target of the augment */
4545 struct lysc_node *node;
Radek Krejci3641f562019-02-13 15:38:40 +01004546 struct lysc_when **when, *when_shared;
4547 int allow_mandatory = 0;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004548 uint16_t flags = 0;
4549 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02004550 int opt_prev = ctx->options;
Radek Krejci3641f562019-02-13 15:38:40 +01004551
Radek Krejci327de162019-06-14 12:52:07 +02004552 lysc_update_path(ctx, NULL, "{augment}");
4553 lysc_update_path(ctx, NULL, aug_p->nodeid);
4554
Radek Krejci7af64242019-02-18 13:07:53 +01004555 ret = lys_resolve_schema_nodeid(ctx, aug_p->nodeid, 0, parent, parent ? parent->module : ctx->mod_def,
Radek Krejci3641f562019-02-13 15:38:40 +01004556 LYS_CONTAINER | LYS_LIST | LYS_CHOICE | LYS_CASE | LYS_INOUT | LYS_NOTIF,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004557 1, (const struct lysc_node**)&target, &flags);
Radek Krejci3641f562019-02-13 15:38:40 +01004558 if (ret != LY_SUCCESS) {
4559 if (ret == LY_EDENIED) {
4560 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
4561 "Augment's %s-schema-nodeid \"%s\" refers to a %s node which is not an allowed augment's target.",
4562 parent ? "descendant" : "absolute", aug_p->nodeid, lys_nodetype2str(target->nodetype));
4563 }
4564 return LY_EVALID;
4565 }
4566
4567 /* check for mandatory nodes
4568 * - new cases augmenting some choice can have mandatory nodes
4569 * - mandatory nodes are allowed only in case the augmentation is made conditional with a when statement
4570 */
Radek Krejci733988a2019-02-15 15:12:44 +01004571 if (aug_p->when || target->nodetype == LYS_CHOICE || ctx->mod == target->module) {
Radek Krejci3641f562019-02-13 15:38:40 +01004572 allow_mandatory = 1;
4573 }
4574
4575 when_shared = NULL;
4576 LY_LIST_FOR(aug_p->child, node_p) {
4577 /* check if the subnode can be connected to the found target (e.g. case cannot be inserted into container) */
4578 if (!(target->nodetype == LYS_CHOICE && node_p->nodetype == LYS_CASE)
4579 && !((target->nodetype & (LYS_CONTAINER | LYS_LIST)) && (node_p->nodetype & (LYS_ACTION | LYS_NOTIF)))
Radek Krejci2d56a892019-02-19 09:05:26 +01004580 && !(target->nodetype != LYS_CHOICE && node_p->nodetype == LYS_USES)
4581 && !(node_p->nodetype & (LYS_ANYDATA | LYS_CONTAINER | LYS_CHOICE | LYS_LEAF | LYS_LIST | LYS_LEAFLIST))) {
Radek Krejci3641f562019-02-13 15:38:40 +01004582 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004583 "Invalid augment of %s node which is not allowed to contain %s node \"%s\".",
4584 lys_nodetype2str(target->nodetype), lys_nodetype2str(node_p->nodetype), node_p->name);
Radek Krejci3641f562019-02-13 15:38:40 +01004585 return LY_EVALID;
4586 }
4587
4588 /* compile the children */
Radek Krejciec4da802019-05-02 13:02:41 +02004589 ctx->options |= flags;
Radek Krejci3641f562019-02-13 15:38:40 +01004590 if (node_p->nodetype != LYS_CASE) {
Radek Krejciec4da802019-05-02 13:02:41 +02004591 LY_CHECK_RET(lys_compile_node(ctx, node_p, target, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01004592 } else {
4593 LY_LIST_FOR(((struct lysp_node_case *)node_p)->child, case_node_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02004594 LY_CHECK_RET(lys_compile_node(ctx, case_node_p, target, 0));
Radek Krejci3641f562019-02-13 15:38:40 +01004595 }
4596 }
Radek Krejciec4da802019-05-02 13:02:41 +02004597 ctx->options = opt_prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004598
Radek Krejcife13da42019-02-15 14:51:01 +01004599 /* since the augment node is not present in the compiled tree, we need to pass some of its statements to all its children,
4600 * here we gets the last created node as last children of our parent */
Radek Krejci3641f562019-02-13 15:38:40 +01004601 if (target->nodetype == LYS_CASE) {
Radek Krejcife13da42019-02-15 14:51:01 +01004602 /* the compiled node is the last child of the target (but it is a case, so we have to be careful and stop) */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004603 for (node = (struct lysc_node*)lysc_node_children(target, flags); node->next && node->next->parent == node->parent; node = node->next);
Radek Krejci3641f562019-02-13 15:38:40 +01004604 } else if (target->nodetype == LYS_CHOICE) {
4605 /* to pass when statement, we need the last case no matter if it is explicit or implicit case */
4606 node = ((struct lysc_node_choice*)target)->cases->prev;
4607 } else {
4608 /* the compiled node is the last child of the target */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004609 node = lysc_node_children(target, flags)->prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004610 }
4611
Radek Krejci733988a2019-02-15 15:12:44 +01004612 if (!allow_mandatory && (node->flags & LYS_CONFIG_W) && (node->flags & LYS_MAND_TRUE)) {
Radek Krejci3641f562019-02-13 15:38:40 +01004613 node->flags &= ~LYS_MAND_TRUE;
4614 lys_compile_mandatory_parents(target, 0);
4615 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004616 "Invalid augment adding mandatory node \"%s\" without making it conditional via when statement.", node->name);
Radek Krejci3641f562019-02-13 15:38:40 +01004617 return LY_EVALID;
4618 }
4619
4620 /* pass augment's when to all the children */
4621 if (aug_p->when) {
4622 LY_ARRAY_NEW_GOTO(ctx->ctx, node->when, when, ret, error);
4623 if (!when_shared) {
Radek Krejciec4da802019-05-02 13:02:41 +02004624 ret = lys_compile_when(ctx, aug_p->when, when);
Radek Krejci3641f562019-02-13 15:38:40 +01004625 LY_CHECK_GOTO(ret, error);
4626 (*when)->context = lysc_xpath_context(target);
4627 when_shared = *when;
4628 } else {
4629 ++when_shared->refcount;
4630 (*when) = when_shared;
4631 }
4632 }
4633 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004634
Radek Krejciec4da802019-05-02 13:02:41 +02004635 ctx->options |= flags;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004636 switch (target->nodetype) {
4637 case LYS_CONTAINER:
Radek Krejci05b774b2019-02-25 13:26:18 +01004638 COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_container*)target)->actions, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004639 u, lys_compile_action, 0, ret, error);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004640 COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_container*)target)->notifs, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004641 u, lys_compile_notif, 0, ret, error);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004642 break;
4643 case LYS_LIST:
Radek Krejci05b774b2019-02-25 13:26:18 +01004644 COMPILE_ARRAY1_GOTO(ctx, aug_p->actions, ((struct lysc_node_list*)target)->actions, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004645 u, lys_compile_action, 0, ret, error);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004646 COMPILE_ARRAY1_GOTO(ctx, aug_p->notifs, ((struct lysc_node_list*)target)->notifs, target,
Radek Krejciec4da802019-05-02 13:02:41 +02004647 u, lys_compile_notif, 0, ret, error);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004648 break;
4649 default:
Radek Krejciec4da802019-05-02 13:02:41 +02004650 ctx->options = opt_prev;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004651 if (aug_p->actions) {
4652 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004653 "Invalid augment of %s node which is not allowed to contain RPC/action node \"%s\".",
4654 lys_nodetype2str(target->nodetype), aug_p->actions[0].name);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004655 return LY_EVALID;
4656 }
4657 if (aug_p->notifs) {
4658 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004659 "Invalid augment of %s node which is not allowed to contain Notification node \"%s\".",
4660 lys_nodetype2str(target->nodetype), aug_p->notifs[0].name);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004661 return LY_EVALID;
4662 }
4663 }
Radek Krejci3641f562019-02-13 15:38:40 +01004664
Radek Krejci327de162019-06-14 12:52:07 +02004665 lysc_update_path(ctx, NULL, NULL);
4666 lysc_update_path(ctx, NULL, NULL);
Radek Krejci3641f562019-02-13 15:38:40 +01004667error:
Radek Krejciec4da802019-05-02 13:02:41 +02004668 ctx->options = opt_prev;
Radek Krejci3641f562019-02-13 15:38:40 +01004669 return ret;
4670}
4671
4672/**
Radek Krejcif1421c22019-02-19 13:05:20 +01004673 * @brief Apply refined or deviated mandatory flag to the target node.
4674 *
4675 * @param[in] ctx Compile context.
4676 * @param[in] node Target node where the mandatory property is supposed to be changed.
4677 * @param[in] mandatory_flag Node's mandatory flag to be applied to the @p node.
Radek Krejcif1421c22019-02-19 13:05:20 +01004678 * @param[in] refine_flag Flag to distinguish if the change is caused by refine (flag set) or deviation (for logging).
Radek Krejci551b12c2019-02-19 16:11:21 +01004679 * @param[in] It is also used as a flag for testing for compatibility with default statement. In case of deviations,
4680 * there can be some other deviations of the default properties that we are testing here. To avoid false positive failure,
4681 * the tests are skipped here, but they are supposed to be performed after all the deviations are applied.
Radek Krejcif1421c22019-02-19 13:05:20 +01004682 * @return LY_ERR value.
4683 */
4684static LY_ERR
Radek Krejci327de162019-06-14 12:52:07 +02004685lys_compile_change_mandatory(struct lysc_ctx *ctx, struct lysc_node *node, uint16_t mandatory_flag, int refine_flag)
Radek Krejcif1421c22019-02-19 13:05:20 +01004686{
4687 if (!(node->nodetype & (LYS_LEAF | LYS_ANYDATA | LYS_ANYXML | LYS_CHOICE))) {
4688 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004689 "Invalid %s of mandatory - %s cannot hold mandatory statement.",
4690 refine_flag ? "refine" : "deviation", lys_nodetype2str(node->nodetype));
Radek Krejcif1421c22019-02-19 13:05:20 +01004691 return LY_EVALID;
4692 }
4693
4694 if (mandatory_flag & LYS_MAND_TRUE) {
4695 /* check if node has default value */
4696 if (node->nodetype & LYS_LEAF) {
4697 if (node->flags & LYS_SET_DFLT) {
Radek Krejci551b12c2019-02-19 16:11:21 +01004698 if (refine_flag) {
4699 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004700 "Invalid refine of mandatory - leaf already has \"default\" statement.");
Radek Krejci551b12c2019-02-19 16:11:21 +01004701 return LY_EVALID;
4702 }
Radek Krejcia1911222019-07-22 17:24:50 +02004703 } else if (((struct lysc_node_leaf*)node)->dflt) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004704 /* remove the default value taken from the leaf's type */
Radek Krejcia1911222019-07-22 17:24:50 +02004705 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
Radek Krejci474f9b82019-07-24 11:36:37 +02004706
4707 /* update the list of incomplete default values if needed */
4708 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
4709
Radek Krejcia1911222019-07-22 17:24:50 +02004710 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
4711 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
4712 free(leaf->dflt);
4713 leaf->dflt = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004714 leaf->dflt_mod = NULL;
Radek Krejcif1421c22019-02-19 13:05:20 +01004715 }
4716 } else if ((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)node)->dflt) {
Radek Krejci551b12c2019-02-19 16:11:21 +01004717 if (refine_flag) {
4718 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004719 "Invalid refine of mandatory - choice already has \"default\" statement.");
Radek Krejci551b12c2019-02-19 16:11:21 +01004720 return LY_EVALID;
4721 }
Radek Krejcif1421c22019-02-19 13:05:20 +01004722 }
Radek Krejci551b12c2019-02-19 16:11:21 +01004723 if (refine_flag && node->parent && (node->parent->flags & LYS_SET_DFLT)) {
Radek Krejci327de162019-06-14 12:52:07 +02004724 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid refine of mandatory under the default case.");
Radek Krejcif1421c22019-02-19 13:05:20 +01004725 return LY_EVALID;
4726 }
4727
4728 node->flags &= ~LYS_MAND_FALSE;
4729 node->flags |= LYS_MAND_TRUE;
4730 lys_compile_mandatory_parents(node->parent, 1);
4731 } else {
4732 /* make mandatory false */
4733 node->flags &= ~LYS_MAND_TRUE;
4734 node->flags |= LYS_MAND_FALSE;
4735 lys_compile_mandatory_parents(node->parent, 0);
Radek Krejcia1911222019-07-22 17:24:50 +02004736 if ((node->nodetype & LYS_LEAF) && !((struct lysc_node_leaf*)node)->dflt && ((struct lysc_node_leaf*)node)->type->dflt) {
Radek Krejcif1421c22019-02-19 13:05:20 +01004737 /* get the type's default value if any */
Radek Krejcia1911222019-07-22 17:24:50 +02004738 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004739 leaf->dflt_mod = leaf->type->dflt_mod;
Radek Krejcia1911222019-07-22 17:24:50 +02004740 leaf->dflt = calloc(1, sizeof *leaf->dflt);
4741 leaf->dflt->realtype = leaf->type->dflt->realtype;
4742 leaf->dflt->realtype->plugin->duplicate(ctx->ctx, leaf->type->dflt, leaf->dflt);
4743 leaf->dflt->realtype->refcount++;
Radek Krejcif1421c22019-02-19 13:05:20 +01004744 }
4745 }
4746 return LY_SUCCESS;
4747}
4748
4749/**
Radek Krejcie86bf772018-12-14 11:39:53 +01004750 * @brief Compile parsed uses statement - resolve target grouping and connect its content into parent.
4751 * If present, also apply uses's modificators.
4752 *
4753 * @param[in] ctx Compile context
4754 * @param[in] uses_p Parsed uses schema node.
Radek Krejcie86bf772018-12-14 11:39:53 +01004755 * @param[in] parent Compiled parent node where the content of the referenced grouping is supposed to be connected. It is
4756 * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
4757 * the compile context.
4758 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
4759 */
4760static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02004761lys_compile_uses(struct lysc_ctx *ctx, struct lysp_node_uses *uses_p, struct lysc_node *parent)
Radek Krejcie86bf772018-12-14 11:39:53 +01004762{
4763 struct lysp_node *node_p;
Radek Krejci01342af2019-01-03 15:18:08 +01004764 struct lysc_node *node, *child;
Radek Krejci12fb9142019-01-08 09:45:30 +01004765 /* context_node_fake allows us to temporarily isolate the nodes inserted from the grouping instead of uses */
Radek Krejci01342af2019-01-03 15:18:08 +01004766 struct lysc_node_container context_node_fake =
4767 {.nodetype = LYS_CONTAINER,
4768 .module = ctx->mod,
4769 .flags = parent ? parent->flags : 0,
4770 .child = NULL, .next = NULL,
Radek Krejcifc11bd72019-04-11 16:00:05 +02004771 .prev = (struct lysc_node*)&context_node_fake,
4772 .actions = NULL, .notifs = NULL};
Radek Krejciec4da802019-05-02 13:02:41 +02004773 struct lysp_grp *grp = NULL;
Radek Krejci76b3e962018-12-14 17:01:25 +01004774 unsigned int u, v, grp_stack_count;
Radek Krejcie86bf772018-12-14 11:39:53 +01004775 int found;
4776 const char *id, *name, *prefix;
4777 size_t prefix_len, name_len;
4778 struct lys_module *mod, *mod_old;
Radek Krejci76b3e962018-12-14 17:01:25 +01004779 struct lysp_refine *rfn;
Radek Krejcia1911222019-07-22 17:24:50 +02004780 LY_ERR ret = LY_EVALID, rc;
Radek Krejcif2271f12019-01-07 16:42:23 +01004781 uint32_t min, max;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004782 uint16_t flags;
Radek Krejcif2271f12019-01-07 16:42:23 +01004783 struct ly_set refined = {0};
Radek Krejci00b874b2019-02-12 10:54:50 +01004784 struct lysc_when **when, *when_shared;
Radek Krejci3641f562019-02-13 15:38:40 +01004785 struct lysp_augment **augments = NULL;
Radek Krejcifc11bd72019-04-11 16:00:05 +02004786 unsigned int actions_index, notifs_index;
4787 struct lysc_notif **notifs = NULL;
4788 struct lysc_action **actions = NULL;
Radek Krejcie86bf772018-12-14 11:39:53 +01004789
4790 /* search for the grouping definition */
4791 found = 0;
4792 id = uses_p->name;
Radek Krejcib4a4a272019-06-10 12:44:52 +02004793 LY_CHECK_RET(ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len), LY_EVALID);
Radek Krejcie86bf772018-12-14 11:39:53 +01004794 if (prefix) {
4795 mod = lys_module_find_prefix(ctx->mod_def, prefix, prefix_len);
4796 if (!mod) {
4797 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02004798 "Invalid prefix used for grouping reference.", uses_p->name);
Radek Krejcie86bf772018-12-14 11:39:53 +01004799 return LY_EVALID;
4800 }
4801 } else {
4802 mod = ctx->mod_def;
4803 }
4804 if (mod == ctx->mod_def) {
4805 for (node_p = uses_p->parent; !found && node_p; node_p = node_p->parent) {
Radek Krejciec4da802019-05-02 13:02:41 +02004806 grp = (struct lysp_grp*)lysp_node_groupings(node_p);
Radek Krejcie86bf772018-12-14 11:39:53 +01004807 LY_ARRAY_FOR(grp, u) {
4808 if (!strcmp(grp[u].name, name)) {
4809 grp = &grp[u];
4810 found = 1;
4811 break;
4812 }
4813 }
4814 }
4815 }
4816 if (!found) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004817 /* search in top-level groupings of the main module ... */
Radek Krejcie86bf772018-12-14 11:39:53 +01004818 grp = mod->parsed->groupings;
Radek Krejci76b3e962018-12-14 17:01:25 +01004819 if (grp) {
4820 for (u = 0; !found && u < LY_ARRAY_SIZE(grp); ++u) {
4821 if (!strcmp(grp[u].name, name)) {
4822 grp = &grp[u];
4823 found = 1;
4824 }
4825 }
4826 }
4827 if (!found && mod->parsed->includes) {
4828 /* ... and all the submodules */
4829 for (u = 0; !found && u < LY_ARRAY_SIZE(mod->parsed->includes); ++u) {
4830 grp = mod->parsed->includes[u].submodule->groupings;
4831 if (grp) {
4832 for (v = 0; !found && v < LY_ARRAY_SIZE(grp); ++v) {
4833 if (!strcmp(grp[v].name, name)) {
4834 grp = &grp[v];
4835 found = 1;
4836 }
4837 }
4838 }
Radek Krejcie86bf772018-12-14 11:39:53 +01004839 }
4840 }
4841 }
4842 if (!found) {
4843 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4844 "Grouping \"%s\" referenced by a uses statement not found.", uses_p->name);
4845 return LY_EVALID;
4846 }
4847
4848 /* grouping must not reference themselves - stack in ctx maintains list of groupings currently being applied */
4849 grp_stack_count = ctx->groupings.count;
4850 ly_set_add(&ctx->groupings, (void*)grp, 0);
4851 if (grp_stack_count == ctx->groupings.count) {
4852 /* the target grouping is already in the stack, so we are already inside it -> circular dependency */
4853 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
4854 "Grouping \"%s\" references itself through a uses statement.", grp->name);
4855 return LY_EVALID;
4856 }
Radek Krejcif2de0ed2019-05-02 14:13:18 +02004857 if (!(ctx->options & LYSC_OPT_GROUPING)) {
4858 /* remember that the grouping is instantiated to avoid its standalone validation */
4859 grp->flags |= LYS_USED_GRP;
4860 }
Radek Krejcie86bf772018-12-14 11:39:53 +01004861
4862 /* switch context's mod_def */
4863 mod_old = ctx->mod_def;
4864 ctx->mod_def = mod;
4865
4866 /* check status */
Radek Krejcifc11bd72019-04-11 16:00:05 +02004867 LY_CHECK_GOTO(lysc_check_status(ctx, uses_p->flags, mod_old, uses_p->name, grp->flags, mod, grp->name), cleanup);
Radek Krejcie86bf772018-12-14 11:39:53 +01004868
Radek Krejcifc11bd72019-04-11 16:00:05 +02004869 /* compile data nodes */
Radek Krejcie86bf772018-12-14 11:39:53 +01004870 LY_LIST_FOR(grp->data, node_p) {
Radek Krejcib1b59152019-01-07 13:21:56 +01004871 /* 0x3 in uses_status is a special bits combination to be able to detect status flags from uses */
Radek Krejciec4da802019-05-02 13:02:41 +02004872 LY_CHECK_GOTO(lys_compile_node(ctx, node_p, parent, (uses_p->flags & LYS_STATUS_MASK) | 0x3), cleanup);
Radek Krejci00b874b2019-02-12 10:54:50 +01004873
4874 /* some preparation for applying refines */
4875 if (grp->data == node_p) {
4876 /* remember the first child */
Radek Krejci684faf22019-05-27 14:31:16 +02004877 if (parent) {
4878 child = (struct lysc_node*)lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK);
4879 } else if (ctx->mod->compiled->data) {
4880 child = ctx->mod->compiled->data;
4881 } else {
4882 child = NULL;
4883 }
4884 context_node_fake.child = child ? child->prev : NULL;
Radek Krejci01342af2019-01-03 15:18:08 +01004885 }
4886 }
Radek Krejci00b874b2019-02-12 10:54:50 +01004887 when_shared = NULL;
Radek Krejci01342af2019-01-03 15:18:08 +01004888 LY_LIST_FOR(context_node_fake.child, child) {
4889 child->parent = (struct lysc_node*)&context_node_fake;
Radek Krejci00b874b2019-02-12 10:54:50 +01004890
Radek Krejcifc11bd72019-04-11 16:00:05 +02004891 /* pass uses's when to all the data children, actions and notifications are ignored */
Radek Krejci00b874b2019-02-12 10:54:50 +01004892 if (uses_p->when) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02004893 LY_ARRAY_NEW_GOTO(ctx->ctx, child->when, when, ret, cleanup);
Radek Krejci00b874b2019-02-12 10:54:50 +01004894 if (!when_shared) {
Radek Krejciec4da802019-05-02 13:02:41 +02004895 LY_CHECK_GOTO(lys_compile_when(ctx, uses_p->when, when), cleanup);
Radek Krejcib56c7502019-02-13 14:19:54 +01004896 (*when)->context = lysc_xpath_context(parent);
Radek Krejci00b874b2019-02-12 10:54:50 +01004897 when_shared = *when;
4898 } else {
4899 ++when_shared->refcount;
4900 (*when) = when_shared;
4901 }
4902 }
Radek Krejci01342af2019-01-03 15:18:08 +01004903 }
4904 if (context_node_fake.child) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02004905 /* child is the last data node added by grouping */
Radek Krejci01342af2019-01-03 15:18:08 +01004906 child = context_node_fake.child->prev;
Radek Krejcifc11bd72019-04-11 16:00:05 +02004907 /* fix child link of our fake container to point to the first child of the original list */
Radek Krejciec4da802019-05-02 13:02:41 +02004908 context_node_fake.child->prev = parent ? lysc_node_children(parent, ctx->options & LYSC_OPT_RPC_MASK)->prev : ctx->mod->compiled->data->prev;
Radek Krejci76b3e962018-12-14 17:01:25 +01004909 }
4910
Radek Krejcifc11bd72019-04-11 16:00:05 +02004911 /* compile actions */
4912 actions = parent ? lysc_node_actions_p(parent) : &ctx->mod->compiled->rpcs;
4913 if (actions) {
4914 actions_index = *actions ? LY_ARRAY_SIZE(*actions) : 0;
Radek Krejciec4da802019-05-02 13:02:41 +02004915 COMPILE_ARRAY1_GOTO(ctx, grp->actions, *actions, parent, u, lys_compile_action, 0, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004916 if (*actions && (uses_p->augments || uses_p->refines)) {
4917 /* but for augment and refine, we need to separate the compiled grouping's actions to avoid modification of others */
4918 LY_ARRAY_CREATE_GOTO(ctx->ctx, context_node_fake.actions, LY_ARRAY_SIZE(*actions) - actions_index, ret, cleanup);
4919 LY_ARRAY_SIZE(context_node_fake.actions) = LY_ARRAY_SIZE(*actions) - actions_index;
4920 memcpy(context_node_fake.actions, &(*actions)[actions_index], LY_ARRAY_SIZE(context_node_fake.actions) * sizeof **actions);
4921 }
4922 }
4923
4924 /* compile notifications */
4925 notifs = parent ? lysc_node_notifs_p(parent) : &ctx->mod->compiled->notifs;
4926 if (notifs) {
4927 notifs_index = *notifs ? LY_ARRAY_SIZE(*notifs) : 0;
Radek Krejciec4da802019-05-02 13:02:41 +02004928 COMPILE_ARRAY1_GOTO(ctx, grp->notifs, *notifs, parent, u, lys_compile_notif, 0, ret, cleanup);
Radek Krejcifc11bd72019-04-11 16:00:05 +02004929 if (*notifs && (uses_p->augments || uses_p->refines)) {
4930 /* but for augment and refine, we need to separate the compiled grouping's notification to avoid modification of others */
4931 LY_ARRAY_CREATE_GOTO(ctx->ctx, context_node_fake.notifs, LY_ARRAY_SIZE(*notifs) - notifs_index, ret, cleanup);
4932 LY_ARRAY_SIZE(context_node_fake.notifs) = LY_ARRAY_SIZE(*notifs) - notifs_index;
4933 memcpy(context_node_fake.notifs, &(*notifs)[notifs_index], LY_ARRAY_SIZE(context_node_fake.notifs) * sizeof **notifs);
4934 }
4935 }
4936
4937
Radek Krejci3641f562019-02-13 15:38:40 +01004938 /* sort and apply augments */
Radek Krejcifc11bd72019-04-11 16:00:05 +02004939 LY_CHECK_GOTO(lys_compile_augment_sort(ctx, uses_p->augments, NULL, &augments), cleanup);
Radek Krejci3641f562019-02-13 15:38:40 +01004940 LY_ARRAY_FOR(augments, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02004941 LY_CHECK_GOTO(lys_compile_augment(ctx, augments[u], (struct lysc_node*)&context_node_fake), cleanup);
Radek Krejci3641f562019-02-13 15:38:40 +01004942 }
Radek Krejci12fb9142019-01-08 09:45:30 +01004943
Radek Krejcif0089082019-01-07 16:42:01 +01004944 /* reload previous context's mod_def */
4945 ctx->mod_def = mod_old;
Radek Krejci327de162019-06-14 12:52:07 +02004946 lysc_update_path(ctx, NULL, "{refine}");
Radek Krejcif0089082019-01-07 16:42:01 +01004947
Radek Krejci76b3e962018-12-14 17:01:25 +01004948 /* apply refine */
4949 LY_ARRAY_FOR(uses_p->refines, struct lysp_refine, rfn) {
Radek Krejci327de162019-06-14 12:52:07 +02004950 lysc_update_path(ctx, NULL, rfn->nodeid);
4951
Radek Krejci7af64242019-02-18 13:07:53 +01004952 LY_CHECK_GOTO(lys_resolve_schema_nodeid(ctx, rfn->nodeid, 0, (struct lysc_node*)&context_node_fake, ctx->mod,
Radek Krejci6eeb58f2019-02-22 16:29:37 +01004953 0, 0, (const struct lysc_node**)&node, &flags),
Radek Krejcifc11bd72019-04-11 16:00:05 +02004954 cleanup);
Radek Krejcif2271f12019-01-07 16:42:23 +01004955 ly_set_add(&refined, node, LY_SET_OPT_USEASLIST);
Radek Krejci76b3e962018-12-14 17:01:25 +01004956
4957 /* default value */
4958 if (rfn->dflts) {
Radek Krejci01342af2019-01-03 15:18:08 +01004959 if ((node->nodetype != LYS_LEAFLIST) && LY_ARRAY_SIZE(rfn->dflts) > 1) {
Radek Krejci76b3e962018-12-14 17:01:25 +01004960 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004961 "Invalid refine of default - %s cannot hold %d default values.",
4962 lys_nodetype2str(node->nodetype), LY_ARRAY_SIZE(rfn->dflts));
Radek Krejcifc11bd72019-04-11 16:00:05 +02004963 goto cleanup;
Radek Krejci76b3e962018-12-14 17:01:25 +01004964 }
4965 if (!(node->nodetype & (LYS_LEAF | LYS_LEAFLIST | LYS_CHOICE))) {
4966 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02004967 "Invalid refine of default - %s cannot hold default value(s).",
4968 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02004969 goto cleanup;
Radek Krejci76b3e962018-12-14 17:01:25 +01004970 }
4971 if (node->nodetype == LYS_LEAF) {
Radek Krejcia1911222019-07-22 17:24:50 +02004972 struct ly_err_item *err = NULL;
4973 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)node;
4974 if (leaf->dflt) {
4975 /* remove the previous default value */
Radek Krejci474f9b82019-07-24 11:36:37 +02004976 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02004977 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
4978 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
4979 } else {
4980 /* prepare a new one */
4981 leaf->dflt = calloc(1, sizeof *leaf->dflt);
4982 leaf->dflt->realtype = leaf->type;
4983 }
4984 /* parse the new one */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02004985 leaf->dflt_mod = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02004986 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, rfn->dflts[0], strlen(rfn->dflts[0]),
4987 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02004988 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, node, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02004989 leaf->dflt->realtype->refcount++;
4990 if (err) {
4991 ly_err_print(err);
4992 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
4993 "Invalid refine of default - value \"%s\" does not fit the type (%s).", rfn->dflts[0], err->msg);
4994 ly_err_free(err);
4995 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02004996 if (rc == LY_EINCOMPLETE) {
4997 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02004998 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, leaf->dflt, leaf->dflt_mod), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02004999
5000 /* but in general result is so far ok */
5001 rc = LY_SUCCESS;
5002 }
Radek Krejcia1911222019-07-22 17:24:50 +02005003 LY_CHECK_GOTO(rc, cleanup);
5004 leaf->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01005005 } else if (node->nodetype == LYS_LEAFLIST) {
Radek Krejcia1911222019-07-22 17:24:50 +02005006 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)node;
5007
Radek Krejci0bcdaed2019-01-10 10:21:34 +01005008 if (ctx->mod->version < 2) {
Radek Krejci01342af2019-01-03 15:18:08 +01005009 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5010 "Invalid refine of default in leaf-list - the default statement is allowed only in YANG 1.1 modules.");
Radek Krejcifc11bd72019-04-11 16:00:05 +02005011 goto cleanup;
Radek Krejci01342af2019-01-03 15:18:08 +01005012 }
Radek Krejcia1911222019-07-22 17:24:50 +02005013
5014 /* remove previous set of default values */
5015 LY_ARRAY_FOR(llist->dflts, u) {
Radek Krejci474f9b82019-07-24 11:36:37 +02005016 lysc_incomplete_dflts_remove(ctx, llist->dflts[u]);
Radek Krejcia1911222019-07-22 17:24:50 +02005017 llist->dflts[u]->realtype->plugin->free(ctx->ctx, llist->dflts[u]);
5018 lysc_type_free(ctx->ctx, llist->dflts[u]->realtype);
5019 free(llist->dflts[u]);
Radek Krejci76b3e962018-12-14 17:01:25 +01005020 }
Radek Krejcia1911222019-07-22 17:24:50 +02005021 LY_ARRAY_FREE(llist->dflts);
5022 llist->dflts = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005023 LY_ARRAY_FREE(llist->dflts_mods);
5024 llist->dflts_mods = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02005025
5026 /* create the new set of the default values */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005027 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_SIZE(rfn->dflts), ret, cleanup);
Radek Krejcia1911222019-07-22 17:24:50 +02005028 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_SIZE(rfn->dflts), ret, cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005029 LY_ARRAY_FOR(rfn->dflts, u) {
Radek Krejcia1911222019-07-22 17:24:50 +02005030 struct ly_err_item *err = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005031 LY_ARRAY_INCREMENT(llist->dflts_mods);
5032 llist->dflts_mods[u] = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02005033 LY_ARRAY_INCREMENT(llist->dflts);
5034 llist->dflts[u] = calloc(1, sizeof *llist->dflts[u]);
5035 llist->dflts[u]->realtype = llist->type;
Radek Krejci1c0c3442019-07-23 16:08:47 +02005036 rc = llist->type->plugin->store(ctx->ctx, llist->type, rfn->dflts[u], strlen(rfn->dflts[u]),
Radek Krejcia1911222019-07-22 17:24:50 +02005037 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02005038 lys_resolve_prefix, (void*)llist->dflts_mods[u], LYD_XML, node, NULL, llist->dflts[u], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02005039 llist->dflts[u]->realtype->refcount++;
5040 if (err) {
5041 ly_err_print(err);
5042 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5043 "Invalid refine of default in leaf-lists - value \"%s\" does not fit the type (%s).", rfn->dflts[u], err->msg);
5044 ly_err_free(err);
5045 }
Radek Krejci1c0c3442019-07-23 16:08:47 +02005046 if (rc == LY_EINCOMPLETE) {
5047 /* postpone default compilation when the tree is complete */
Radek Krejci474f9b82019-07-24 11:36:37 +02005048 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, node, llist->dflts[u], llist->dflts_mods[u]), cleanup);
Radek Krejci1c0c3442019-07-23 16:08:47 +02005049
5050 /* but in general result is so far ok */
5051 rc = LY_SUCCESS;
5052 }
5053 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005054 }
Radek Krejcia1911222019-07-22 17:24:50 +02005055 llist->flags |= LYS_SET_DFLT;
Radek Krejci76b3e962018-12-14 17:01:25 +01005056 } else if (node->nodetype == LYS_CHOICE) {
Radek Krejci01342af2019-01-03 15:18:08 +01005057 if (((struct lysc_node_choice*)node)->dflt) {
5058 /* unset LYS_SET_DFLT from the current default case */
5059 ((struct lysc_node_choice*)node)->dflt->flags &= ~LYS_SET_DFLT;
5060 }
Radek Krejcifc11bd72019-04-11 16:00:05 +02005061 LY_CHECK_GOTO(lys_compile_node_choice_dflt(ctx, rfn->dflts[0], (struct lysc_node_choice*)node), cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005062 }
5063 }
5064
Radek Krejci12fb9142019-01-08 09:45:30 +01005065 /* description */
5066 if (rfn->dsc) {
5067 FREE_STRING(ctx->ctx, node->dsc);
5068 node->dsc = lydict_insert(ctx->ctx, rfn->dsc, 0);
5069 }
5070
5071 /* reference */
5072 if (rfn->ref) {
5073 FREE_STRING(ctx->ctx, node->ref);
5074 node->ref = lydict_insert(ctx->ctx, rfn->ref, 0);
5075 }
Radek Krejci76b3e962018-12-14 17:01:25 +01005076
5077 /* config */
5078 if (rfn->flags & LYS_CONFIG_MASK) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005079 if (!flags) {
Radek Krejci327de162019-06-14 12:52:07 +02005080 LY_CHECK_GOTO(lys_compile_change_config(ctx, node, rfn->flags, 0, 1), cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005081 } else {
5082 LOGWRN(ctx->ctx, "Refining config inside %s has no effect (%s).",
5083 flags & LYSC_OPT_NOTIFICATION ? "Notification" : "RPC/action", ctx->path);
5084 }
Radek Krejci76b3e962018-12-14 17:01:25 +01005085 }
5086
5087 /* mandatory */
5088 if (rfn->flags & LYS_MAND_MASK) {
Radek Krejci327de162019-06-14 12:52:07 +02005089 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, node, rfn->flags, 1), cleanup);
Radek Krejci76b3e962018-12-14 17:01:25 +01005090 }
Radek Krejci9a54f1f2019-01-07 13:47:55 +01005091
5092 /* presence */
5093 if (rfn->presence) {
5094 if (node->nodetype != LYS_CONTAINER) {
5095 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005096 "Invalid refine of presence statement - %s cannot hold the presence statement.",
5097 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005098 goto cleanup;
Radek Krejci9a54f1f2019-01-07 13:47:55 +01005099 }
5100 node->flags |= LYS_PRESENCE;
5101 }
Radek Krejci9a564c92019-01-07 14:53:57 +01005102
5103 /* must */
5104 if (rfn->musts) {
5105 switch (node->nodetype) {
5106 case LYS_LEAF:
Radek Krejciec4da802019-05-02 13:02:41 +02005107 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaf*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005108 break;
5109 case LYS_LEAFLIST:
Radek Krejciec4da802019-05-02 13:02:41 +02005110 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_leaflist*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005111 break;
5112 case LYS_LIST:
Radek Krejciec4da802019-05-02 13:02:41 +02005113 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_list*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005114 break;
5115 case LYS_CONTAINER:
Radek Krejciec4da802019-05-02 13:02:41 +02005116 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_container*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005117 break;
5118 case LYS_ANYXML:
5119 case LYS_ANYDATA:
Radek Krejciec4da802019-05-02 13:02:41 +02005120 COMPILE_ARRAY_GOTO(ctx, rfn->musts, ((struct lysc_node_anydata*)node)->musts, u, lys_compile_must, ret, cleanup);
Radek Krejci9a564c92019-01-07 14:53:57 +01005121 break;
5122 default:
5123 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005124 "Invalid refine of must statement - %s cannot hold any must statement.",
5125 lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005126 goto cleanup;
Radek Krejci9a564c92019-01-07 14:53:57 +01005127 }
5128 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005129
5130 /* min/max-elements */
5131 if (rfn->flags & (LYS_SET_MAX | LYS_SET_MIN)) {
5132 switch (node->nodetype) {
5133 case LYS_LEAFLIST:
5134 if (rfn->flags & LYS_SET_MAX) {
5135 ((struct lysc_node_leaflist*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
5136 }
5137 if (rfn->flags & LYS_SET_MIN) {
5138 ((struct lysc_node_leaflist*)node)->min = rfn->min;
Radek Krejcife909632019-02-12 15:34:42 +01005139 if (rfn->min) {
5140 node->flags |= LYS_MAND_TRUE;
5141 lys_compile_mandatory_parents(node->parent, 1);
5142 } else {
5143 node->flags &= ~LYS_MAND_TRUE;
5144 lys_compile_mandatory_parents(node->parent, 0);
5145 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005146 }
5147 break;
5148 case LYS_LIST:
5149 if (rfn->flags & LYS_SET_MAX) {
5150 ((struct lysc_node_list*)node)->max = rfn->max ? rfn->max : (uint32_t)-1;
5151 }
5152 if (rfn->flags & LYS_SET_MIN) {
5153 ((struct lysc_node_list*)node)->min = rfn->min;
Radek Krejcife909632019-02-12 15:34:42 +01005154 if (rfn->min) {
5155 node->flags |= LYS_MAND_TRUE;
5156 lys_compile_mandatory_parents(node->parent, 1);
5157 } else {
5158 node->flags &= ~LYS_MAND_TRUE;
5159 lys_compile_mandatory_parents(node->parent, 0);
5160 }
Radek Krejci6b22ab72019-01-07 15:39:20 +01005161 }
5162 break;
5163 default:
5164 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005165 "Invalid refine of %s statement - %s cannot hold this statement.",
5166 (rfn->flags & LYS_SET_MAX) ? "max-elements" : "min-elements", lys_nodetype2str(node->nodetype));
Radek Krejcifc11bd72019-04-11 16:00:05 +02005167 goto cleanup;
Radek Krejci6b22ab72019-01-07 15:39:20 +01005168 }
5169 }
Radek Krejcif0089082019-01-07 16:42:01 +01005170
5171 /* if-feature */
5172 if (rfn->iffeatures) {
5173 /* any node in compiled tree can get additional if-feature, so do not check nodetype */
Radek Krejciec4da802019-05-02 13:02:41 +02005174 COMPILE_ARRAY_GOTO(ctx, rfn->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, cleanup);
Radek Krejcif0089082019-01-07 16:42:01 +01005175 }
Radek Krejci327de162019-06-14 12:52:07 +02005176
5177 lysc_update_path(ctx, NULL, NULL);
Radek Krejci01342af2019-01-03 15:18:08 +01005178 }
Radek Krejcie86bf772018-12-14 11:39:53 +01005179
Radek Krejcif2271f12019-01-07 16:42:23 +01005180 /* do some additional checks of the changed nodes when all the refines are applied */
5181 for (u = 0; u < refined.count; ++u) {
5182 node = (struct lysc_node*)refined.objs[u];
5183 rfn = &uses_p->refines[u];
Radek Krejci327de162019-06-14 12:52:07 +02005184 lysc_update_path(ctx, NULL, rfn->nodeid);
Radek Krejcif2271f12019-01-07 16:42:23 +01005185
5186 /* check possible conflict with default value (default added, mandatory left true) */
5187 if ((node->flags & LYS_MAND_TRUE) &&
5188 (((node->nodetype & LYS_CHOICE) && ((struct lysc_node_choice*)node)->dflt) ||
5189 ((node->nodetype & LYS_LEAF) && (node->flags & LYS_SET_DFLT)))) {
5190 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005191 "Invalid refine of default - the node is mandatory.");
Radek Krejcifc11bd72019-04-11 16:00:05 +02005192 goto cleanup;
Radek Krejcif2271f12019-01-07 16:42:23 +01005193 }
5194
5195 if (rfn->flags & (LYS_SET_MAX | LYS_SET_MIN)) {
5196 if (node->nodetype == LYS_LIST) {
5197 min = ((struct lysc_node_list*)node)->min;
5198 max = ((struct lysc_node_list*)node)->max;
5199 } else {
5200 min = ((struct lysc_node_leaflist*)node)->min;
5201 max = ((struct lysc_node_leaflist*)node)->max;
5202 }
5203 if (min > max) {
5204 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02005205 "Invalid refine of %s statement - \"min-elements\" is bigger than \"max-elements\".",
5206 (rfn->flags & LYS_SET_MAX) ? "max-elements" : "min-elements");
Radek Krejcifc11bd72019-04-11 16:00:05 +02005207 goto cleanup;
Radek Krejcif2271f12019-01-07 16:42:23 +01005208 }
5209 }
5210 }
5211
Radek Krejci327de162019-06-14 12:52:07 +02005212 lysc_update_path(ctx, NULL, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01005213 ret = LY_SUCCESS;
Radek Krejcifc11bd72019-04-11 16:00:05 +02005214
5215cleanup:
5216 /* fix connection of the children nodes from fake context node back into the parent */
5217 if (context_node_fake.child) {
5218 context_node_fake.child->prev = child;
5219 }
5220 LY_LIST_FOR(context_node_fake.child, child) {
5221 child->parent = parent;
5222 }
5223
5224 if (uses_p->augments || uses_p->refines) {
5225 /* return back actions and notifications in case they were separated for augment/refine processing */
Radek Krejci65e20e22019-04-12 09:44:37 +02005226 if (context_node_fake.actions) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02005227 memcpy(&(*actions)[actions_index], context_node_fake.actions, LY_ARRAY_SIZE(context_node_fake.actions) * sizeof **actions);
5228 LY_ARRAY_FREE(context_node_fake.actions);
5229 }
Radek Krejci65e20e22019-04-12 09:44:37 +02005230 if (context_node_fake.notifs) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02005231 memcpy(&(*notifs)[notifs_index], context_node_fake.notifs, LY_ARRAY_SIZE(context_node_fake.notifs) * sizeof **notifs);
5232 LY_ARRAY_FREE(context_node_fake.notifs);
5233 }
5234 }
5235
Radek Krejcie86bf772018-12-14 11:39:53 +01005236 /* reload previous context's mod_def */
5237 ctx->mod_def = mod_old;
5238 /* remove the grouping from the stack for circular groupings dependency check */
5239 ly_set_rm_index(&ctx->groupings, ctx->groupings.count - 1, NULL);
5240 assert(ctx->groupings.count == grp_stack_count);
Radek Krejcif2271f12019-01-07 16:42:23 +01005241 ly_set_erase(&refined, NULL);
Radek Krejci3641f562019-02-13 15:38:40 +01005242 LY_ARRAY_FREE(augments);
Radek Krejcie86bf772018-12-14 11:39:53 +01005243
5244 return ret;
5245}
5246
Radek Krejci327de162019-06-14 12:52:07 +02005247static int
5248lys_compile_grouping_pathlog(struct lysc_ctx *ctx, struct lysp_node *node, char **path)
5249{
5250 struct lysp_node *iter;
5251 int len = 0;
5252
5253 *path = NULL;
5254 for (iter = node; iter && len >= 0; iter = iter->parent) {
5255 char *s = *path;
5256 char *id;
5257
5258 switch (iter->nodetype) {
5259 case LYS_USES:
5260 asprintf(&id, "{uses='%s'}", iter->name);
5261 break;
5262 case LYS_GROUPING:
5263 asprintf(&id, "{grouping='%s'}", iter->name);
5264 break;
5265 case LYS_AUGMENT:
5266 asprintf(&id, "{augment='%s'}", iter->name);
5267 break;
5268 default:
5269 id = strdup(iter->name);
5270 break;
5271 }
5272
5273 if (!iter->parent) {
5274 /* print prefix */
5275 len = asprintf(path, "/%s:%s%s", ctx->mod->name, id, s ? s : "");
5276 } else {
5277 /* prefix is the same as in parent */
5278 len = asprintf(path, "/%s%s", id, s ? s : "");
5279 }
5280 free(s);
5281 free(id);
5282 }
5283
5284 if (len < 0) {
5285 free(*path);
5286 *path = NULL;
5287 } else if (len == 0) {
5288 *path = strdup("/");
5289 len = 1;
5290 }
5291 return len;
5292}
5293
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005294/**
5295 * @brief Validate groupings that were defined but not directly used in the schema itself.
5296 *
5297 * The grouping does not need to be compiled (and it is compiled here, but the result is forgotten immediately),
5298 * but to have the complete result of the schema validity, even such groupings are supposed to be checked.
5299 */
5300static LY_ERR
5301lys_compile_grouping(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysp_grp *grp)
5302{
5303 LY_ERR ret;
Radek Krejci327de162019-06-14 12:52:07 +02005304 char *path;
5305 int len;
5306
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005307 struct lysp_node_uses fake_uses = {
5308 .parent = node_p,
5309 .nodetype = LYS_USES,
5310 .flags = 0, .next = NULL,
5311 .name = grp->name,
5312 .dsc = NULL, .ref = NULL, .when = NULL, .iffeatures = NULL, .exts = NULL,
5313 .refines = NULL, .augments = NULL
5314 };
5315 struct lysc_node_container fake_container = {
5316 .nodetype = LYS_CONTAINER,
5317 .flags = node_p ? (node_p->flags & LYS_FLAGS_COMPILED_MASK) : 0,
5318 .module = ctx->mod,
5319 .sp = NULL, .parent = NULL, .next = NULL,
5320 .prev = (struct lysc_node*)&fake_container,
5321 .name = "fake",
5322 .dsc = NULL, .ref = NULL, .exts = NULL, .iffeatures = NULL, .when = NULL,
5323 .child = NULL, .musts = NULL, .actions = NULL, .notifs = NULL
5324 };
5325
5326 if (grp->parent) {
5327 LOGWRN(ctx->ctx, "Locally scoped grouping \"%s\" not used.", grp->name);
5328 }
Radek Krejci327de162019-06-14 12:52:07 +02005329
5330 len = lys_compile_grouping_pathlog(ctx, grp->parent, &path);
5331 if (len < 0) {
5332 LOGMEM(ctx->ctx);
5333 return LY_EMEM;
5334 }
5335 strncpy(ctx->path, path, LYSC_CTX_BUFSIZE - 1);
5336 ctx->path_len = (uint16_t)len;
5337 free(path);
5338
5339 lysc_update_path(ctx, NULL, "{grouping}");
5340 lysc_update_path(ctx, NULL, grp->name);
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005341 ret = lys_compile_uses(ctx, &fake_uses, (struct lysc_node*)&fake_container);
Radek Krejci327de162019-06-14 12:52:07 +02005342 lysc_update_path(ctx, NULL, NULL);
5343 lysc_update_path(ctx, NULL, NULL);
5344
5345 ctx->path_len = 1;
5346 ctx->path[1] = '\0';
Radek Krejcif2de0ed2019-05-02 14:13:18 +02005347
5348 /* cleanup */
5349 lysc_node_container_free(ctx->ctx, &fake_container);
5350
5351 return ret;
5352}
Radek Krejcife909632019-02-12 15:34:42 +01005353
Radek Krejcie86bf772018-12-14 11:39:53 +01005354/**
Radek Krejcia3045382018-11-22 14:30:31 +01005355 * @brief Compile parsed schema node information.
5356 * @param[in] ctx Compile context
5357 * @param[in] node_p Parsed schema node.
Radek Krejcia3045382018-11-22 14:30:31 +01005358 * @param[in] parent Compiled parent node where the current node is supposed to be connected. It is
5359 * NULL for top-level nodes, in such a case the module where the node will be connected is taken from
5360 * the compile context.
Radek Krejcib1b59152019-01-07 13:21:56 +01005361 * @param[in] uses_status If the node is being placed instead of uses, here we have the uses's status value (as node's flags).
5362 * Zero means no uses, non-zero value with no status bit set mean the default status.
Radek Krejcia3045382018-11-22 14:30:31 +01005363 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
5364 */
Radek Krejci19a96102018-11-15 13:38:09 +01005365static LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02005366lys_compile_node(struct lysc_ctx *ctx, struct lysp_node *node_p, struct lysc_node *parent, uint16_t uses_status)
Radek Krejci19a96102018-11-15 13:38:09 +01005367{
5368 LY_ERR ret = LY_EVALID;
Radek Krejci056d0a82018-12-06 16:57:25 +01005369 struct lysc_node *node;
5370 struct lysc_node_case *cs;
Radek Krejci00b874b2019-02-12 10:54:50 +01005371 struct lysc_when **when;
Radek Krejci19a96102018-11-15 13:38:09 +01005372 unsigned int u;
Radek Krejciec4da802019-05-02 13:02:41 +02005373 LY_ERR (*node_compile_spec)(struct lysc_ctx*, struct lysp_node*, struct lysc_node*);
Radek Krejci19a96102018-11-15 13:38:09 +01005374
Radek Krejci327de162019-06-14 12:52:07 +02005375 if (node_p->nodetype != LYS_USES) {
5376 lysc_update_path(ctx, parent, node_p->name);
5377 } else {
5378 lysc_update_path(ctx, NULL, "{uses}");
5379 lysc_update_path(ctx, NULL, node_p->name);
5380 }
5381
Radek Krejci19a96102018-11-15 13:38:09 +01005382 switch (node_p->nodetype) {
5383 case LYS_CONTAINER:
5384 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_container));
5385 node_compile_spec = lys_compile_node_container;
5386 break;
5387 case LYS_LEAF:
5388 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaf));
5389 node_compile_spec = lys_compile_node_leaf;
5390 break;
5391 case LYS_LIST:
5392 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_list));
Radek Krejci9bb94eb2018-12-04 16:48:35 +01005393 node_compile_spec = lys_compile_node_list;
Radek Krejci19a96102018-11-15 13:38:09 +01005394 break;
5395 case LYS_LEAFLIST:
5396 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_leaflist));
Radek Krejci0e5d8382018-11-28 16:37:53 +01005397 node_compile_spec = lys_compile_node_leaflist;
Radek Krejci19a96102018-11-15 13:38:09 +01005398 break;
Radek Krejci19a96102018-11-15 13:38:09 +01005399 case LYS_CHOICE:
5400 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_choice));
Radek Krejci056d0a82018-12-06 16:57:25 +01005401 node_compile_spec = lys_compile_node_choice;
Radek Krejci19a96102018-11-15 13:38:09 +01005402 break;
Radek Krejci19a96102018-11-15 13:38:09 +01005403 case LYS_ANYXML:
5404 case LYS_ANYDATA:
5405 node = (struct lysc_node*)calloc(1, sizeof(struct lysc_node_anydata));
Radek Krejci9800fb82018-12-13 14:26:23 +01005406 node_compile_spec = lys_compile_node_any;
Radek Krejci19a96102018-11-15 13:38:09 +01005407 break;
Radek Krejcie86bf772018-12-14 11:39:53 +01005408 case LYS_USES:
Radek Krejci327de162019-06-14 12:52:07 +02005409 ret = lys_compile_uses(ctx, (struct lysp_node_uses*)node_p, parent);
5410 lysc_update_path(ctx, NULL, NULL);
5411 lysc_update_path(ctx, NULL, NULL);
5412 return ret;
Radek Krejci19a96102018-11-15 13:38:09 +01005413 default:
5414 LOGINT(ctx->ctx);
5415 return LY_EINT;
5416 }
5417 LY_CHECK_ERR_RET(!node, LOGMEM(ctx->ctx), LY_EMEM);
5418 node->nodetype = node_p->nodetype;
5419 node->module = ctx->mod;
5420 node->prev = node;
Radek Krejci0e5d8382018-11-28 16:37:53 +01005421 node->flags = node_p->flags & LYS_FLAGS_COMPILED_MASK;
Radek Krejci19a96102018-11-15 13:38:09 +01005422
5423 /* config */
Radek Krejciec4da802019-05-02 13:02:41 +02005424 if (ctx->options & (LYSC_OPT_RPC_INPUT | LYSC_OPT_RPC_OUTPUT)) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005425 /* ignore config statements inside RPC/action data */
Radek Krejcifc11bd72019-04-11 16:00:05 +02005426 node->flags &= ~LYS_CONFIG_MASK;
Radek Krejciec4da802019-05-02 13:02:41 +02005427 node->flags |= (ctx->options & LYSC_OPT_RPC_INPUT) ? LYS_CONFIG_W : LYS_CONFIG_R;
5428 } else if (ctx->options & LYSC_OPT_NOTIFICATION) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005429 /* ignore config statements inside Notification data */
Radek Krejcifc11bd72019-04-11 16:00:05 +02005430 node->flags &= ~LYS_CONFIG_MASK;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005431 node->flags |= LYS_CONFIG_R;
5432 } else if (!(node->flags & LYS_CONFIG_MASK)) {
Radek Krejci19a96102018-11-15 13:38:09 +01005433 /* config not explicitely set, inherit it from parent */
5434 if (parent) {
5435 node->flags |= parent->flags & LYS_CONFIG_MASK;
5436 } else {
5437 /* default is config true */
5438 node->flags |= LYS_CONFIG_W;
5439 }
Radek Krejci93dcc392019-02-19 10:43:38 +01005440 } else {
5441 /* config set explicitely */
5442 node->flags |= LYS_SET_CONFIG;
Radek Krejci19a96102018-11-15 13:38:09 +01005443 }
Radek Krejci9bb94eb2018-12-04 16:48:35 +01005444 if (parent && (parent->flags & LYS_CONFIG_R) && (node->flags & LYS_CONFIG_W)) {
5445 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5446 "Configuration node cannot be child of any state data node.");
5447 goto error;
5448 }
Radek Krejci19a96102018-11-15 13:38:09 +01005449
Radek Krejcia6d57732018-11-29 13:40:37 +01005450 /* *list ordering */
5451 if (node->nodetype & (LYS_LIST | LYS_LEAFLIST)) {
5452 if ((node->flags & LYS_CONFIG_R) && (node->flags & LYS_ORDBY_MASK)) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02005453 LOGWRN(ctx->ctx, "The ordered-by statement is ignored in lists representing %s (%s).",
Radek Krejciec4da802019-05-02 13:02:41 +02005454 (ctx->options & LYSC_OPT_RPC_OUTPUT) ? "RPC/action output parameters" :
5455 (ctx->options & LYSC_OPT_NOTIFICATION) ? "notification content" : "state data", ctx->path);
Radek Krejcia6d57732018-11-29 13:40:37 +01005456 node->flags &= ~LYS_ORDBY_MASK;
5457 node->flags |= LYS_ORDBY_SYSTEM;
5458 } else if (!(node->flags & LYS_ORDBY_MASK)) {
5459 /* default ordering is system */
5460 node->flags |= LYS_ORDBY_SYSTEM;
5461 }
5462 }
5463
Radek Krejci19a96102018-11-15 13:38:09 +01005464 /* status - it is not inherited by specification, but it does not make sense to have
5465 * current in deprecated or deprecated in obsolete, so we do print warning and inherit status */
Radek Krejci056d0a82018-12-06 16:57:25 +01005466 if (!parent || parent->nodetype != LYS_CHOICE) {
5467 /* in case of choice/case's children, postpone the check to the moment we know if
5468 * the parent is choice (parent here) or some case (so we have to get its flags to check) */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005469 LY_CHECK_GOTO(lys_compile_status(ctx, &node->flags, uses_status ? uses_status : (parent ? parent->flags : 0)), error);
Radek Krejci19a96102018-11-15 13:38:09 +01005470 }
5471
Radek Krejciec4da802019-05-02 13:02:41 +02005472 if (!(ctx->options & LYSC_OPT_FREE_SP)) {
Radek Krejci19a96102018-11-15 13:38:09 +01005473 node->sp = node_p;
5474 }
5475 DUP_STRING(ctx->ctx, node_p->name, node->name);
Radek Krejci12fb9142019-01-08 09:45:30 +01005476 DUP_STRING(ctx->ctx, node_p->dsc, node->dsc);
5477 DUP_STRING(ctx->ctx, node_p->ref, node->ref);
Radek Krejci00b874b2019-02-12 10:54:50 +01005478 if (node_p->when) {
5479 LY_ARRAY_NEW_GOTO(ctx->ctx, node->when, when, ret, error);
Radek Krejciec4da802019-05-02 13:02:41 +02005480 ret = lys_compile_when(ctx, node_p->when, when);
Radek Krejci00b874b2019-02-12 10:54:50 +01005481 LY_CHECK_GOTO(ret, error);
Radek Krejcib56c7502019-02-13 14:19:54 +01005482 (*when)->context = lysc_xpath_context(node);
Radek Krejci00b874b2019-02-12 10:54:50 +01005483 }
Radek Krejciec4da802019-05-02 13:02:41 +02005484 COMPILE_ARRAY_GOTO(ctx, node_p->iffeatures, node->iffeatures, u, lys_compile_iffeature, ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01005485
5486 /* nodetype-specific part */
Radek Krejciec4da802019-05-02 13:02:41 +02005487 LY_CHECK_GOTO(node_compile_spec(ctx, node_p, node), error);
Radek Krejci19a96102018-11-15 13:38:09 +01005488
Radek Krejci0935f412019-08-20 16:15:18 +02005489 COMPILE_EXTS_GOTO(ctx, node_p->exts, node->exts, node, LYEXT_PAR_NODE, ret, error);
5490
Radek Krejcife909632019-02-12 15:34:42 +01005491 /* inherit LYS_MAND_TRUE in parent containers */
5492 if (node->flags & LYS_MAND_TRUE) {
5493 lys_compile_mandatory_parents(parent, 1);
5494 }
5495
Radek Krejci327de162019-06-14 12:52:07 +02005496 lysc_update_path(ctx, NULL, NULL);
5497
Radek Krejci19a96102018-11-15 13:38:09 +01005498 /* insert into parent's children */
Radek Krejcia3045382018-11-22 14:30:31 +01005499 if (parent) {
5500 if (parent->nodetype == LYS_CHOICE) {
Radek Krejci327de162019-06-14 12:52:07 +02005501 if (node_p->parent->nodetype == LYS_CASE) {
5502 lysc_update_path(ctx, parent, node_p->parent->name);
5503 } else {
5504 lysc_update_path(ctx, parent, node->name);
5505 }
Radek Krejciec4da802019-05-02 13:02:41 +02005506 cs = lys_compile_node_case(ctx, node_p->parent, (struct lysc_node_choice*)parent, node);
Radek Krejci056d0a82018-12-06 16:57:25 +01005507 LY_CHECK_ERR_GOTO(!cs, ret = LY_EVALID, error);
Radek Krejcib1b59152019-01-07 13:21:56 +01005508 if (uses_status) {
5509
5510 }
Radek Krejci056d0a82018-12-06 16:57:25 +01005511 /* the postponed status check of the node and its real parent - in case of implicit case,
Radek Krejcib1b59152019-01-07 13:21:56 +01005512 * it directly gets the same status flags as the choice;
5513 * uses_status cannot be applied here since uses cannot be child statement of choice */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005514 LY_CHECK_GOTO(lys_compile_status(ctx, &node->flags, cs->flags), error);
Radek Krejci056d0a82018-12-06 16:57:25 +01005515 node->parent = (struct lysc_node*)cs;
Radek Krejci327de162019-06-14 12:52:07 +02005516 lysc_update_path(ctx, parent, node->name);
Radek Krejci056d0a82018-12-06 16:57:25 +01005517 } else { /* other than choice */
Radek Krejci327de162019-06-14 12:52:07 +02005518 lysc_update_path(ctx, parent, node->name);
Radek Krejci056d0a82018-12-06 16:57:25 +01005519 node->parent = parent;
Radek Krejci19a96102018-11-15 13:38:09 +01005520 }
Radek Krejciec4da802019-05-02 13:02:41 +02005521 LY_CHECK_RET(lys_compile_node_connect(ctx, parent->nodetype == LYS_CASE ? parent->parent : parent, node), LY_EVALID);
Radek Krejci327de162019-06-14 12:52:07 +02005522
5523 if (parent->nodetype == LYS_CHOICE) {
5524 lysc_update_path(ctx, NULL, NULL);
5525 }
Radek Krejci19a96102018-11-15 13:38:09 +01005526 } else {
5527 /* top-level element */
5528 if (!ctx->mod->compiled->data) {
5529 ctx->mod->compiled->data = node;
5530 } else {
5531 /* insert at the end of the module's top-level nodes list */
5532 ctx->mod->compiled->data->prev->next = node;
5533 node->prev = ctx->mod->compiled->data->prev;
5534 ctx->mod->compiled->data->prev = node;
5535 }
Radek Krejci327de162019-06-14 12:52:07 +02005536 lysc_update_path(ctx, parent, node->name);
Radek Krejci76b3e962018-12-14 17:01:25 +01005537 if (lys_compile_node_uniqness(ctx, ctx->mod->compiled->data, ctx->mod->compiled->rpcs,
5538 ctx->mod->compiled->notifs, node->name, node)) {
5539 return LY_EVALID;
5540 }
Radek Krejci19a96102018-11-15 13:38:09 +01005541 }
Radek Krejci327de162019-06-14 12:52:07 +02005542 lysc_update_path(ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01005543
5544 return LY_SUCCESS;
5545
5546error:
5547 lysc_node_free(ctx->ctx, node);
5548 return ret;
5549}
5550
Radek Krejciccd20f12019-02-15 14:12:27 +01005551static void
5552lysc_disconnect(struct lysc_node *node)
5553{
Radek Krejci0a048dd2019-02-18 16:01:43 +01005554 struct lysc_node *parent, *child, *prev = NULL, *next;
5555 struct lysc_node_case *cs = NULL;
Radek Krejciccd20f12019-02-15 14:12:27 +01005556 int remove_cs = 0;
5557
5558 parent = node->parent;
5559
5560 /* parent's first child */
5561 if (!parent) {
5562 return;
5563 }
5564 if (parent->nodetype == LYS_CHOICE) {
Radek Krejci0a048dd2019-02-18 16:01:43 +01005565 cs = (struct lysc_node_case*)node;
5566 } else if (parent->nodetype == LYS_CASE) {
5567 /* disconnecting some node in a case */
5568 cs = (struct lysc_node_case*)parent;
5569 parent = cs->parent;
5570 for (child = cs->child; child && child->parent == (struct lysc_node*)cs; child = child->next) {
5571 if (child == node) {
5572 if (cs->child == child) {
5573 if (!child->next || child->next->parent != (struct lysc_node*)cs) {
5574 /* case with a single child -> remove also the case */
5575 child->parent = NULL;
5576 remove_cs = 1;
5577 } else {
5578 cs->child = child->next;
Radek Krejciccd20f12019-02-15 14:12:27 +01005579 }
5580 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005581 break;
Radek Krejciccd20f12019-02-15 14:12:27 +01005582 }
5583 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005584 if (!remove_cs) {
5585 cs = NULL;
5586 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005587 } else if (lysc_node_children(parent, node->flags) == node) {
5588 *lysc_node_children_p(parent, node->flags) = node->next;
Radek Krejci0a048dd2019-02-18 16:01:43 +01005589 }
5590
5591 if (cs) {
5592 if (remove_cs) {
5593 /* cs has only one child which is being also removed */
5594 lysc_disconnect((struct lysc_node*)cs);
5595 lysc_node_free(cs->module->ctx, (struct lysc_node*)cs);
5596 } else {
Radek Krejciccd20f12019-02-15 14:12:27 +01005597 if (((struct lysc_node_choice*)parent)->dflt == cs) {
5598 /* default case removed */
5599 ((struct lysc_node_choice*)parent)->dflt = NULL;
5600 }
5601 if (((struct lysc_node_choice*)parent)->cases == cs) {
5602 /* first case removed */
5603 ((struct lysc_node_choice*)parent)->cases = (struct lysc_node_case*)cs->next;
5604 }
Radek Krejci0a048dd2019-02-18 16:01:43 +01005605 if (cs->child) {
5606 /* cs will be removed and disconnected from its siblings, but we have to take care also about its children */
5607 if (cs->child->prev->parent != (struct lysc_node*)cs) {
5608 prev = cs->child->prev;
5609 } /* else all the children are under a single case */
5610 LY_LIST_FOR_SAFE(cs->child, next, child) {
5611 if (child->parent != (struct lysc_node*)cs) {
5612 break;
5613 }
5614 lysc_node_free(node->module->ctx, child);
5615 }
5616 if (prev) {
5617 if (prev->next) {
5618 prev->next = child;
5619 }
5620 if (child) {
5621 child->prev = prev;
5622 } else {
5623 /* link from the first child under the cases */
5624 ((struct lysc_node_choice*)cs->parent)->cases->child->prev = prev;
5625 }
5626 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005627 }
5628 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005629 }
5630
5631 /* siblings */
Radek Krejci0a048dd2019-02-18 16:01:43 +01005632 if (node->prev->next) {
5633 node->prev->next = node->next;
5634 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005635 if (node->next) {
5636 node->next->prev = node->prev;
Radek Krejci0a048dd2019-02-18 16:01:43 +01005637 } else if (node->nodetype != LYS_CASE) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005638 child = (struct lysc_node*)lysc_node_children(parent, node->flags);
Radek Krejci0a048dd2019-02-18 16:01:43 +01005639 if (child) {
5640 child->prev = node->prev;
5641 }
5642 } else if (((struct lysc_node_choice*)parent)->cases) {
5643 ((struct lysc_node_choice*)parent)->cases->prev = node->prev;
Radek Krejciccd20f12019-02-15 14:12:27 +01005644 }
5645}
5646
5647LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02005648lys_compile_deviations(struct lysc_ctx *ctx, struct lysp_module *mod_p)
Radek Krejciccd20f12019-02-15 14:12:27 +01005649{
Radek Krejcia1911222019-07-22 17:24:50 +02005650 LY_ERR ret = LY_EVALID, rc;
Radek Krejciccd20f12019-02-15 14:12:27 +01005651 struct ly_set devs_p = {0};
5652 struct ly_set targets = {0};
5653 struct lysc_node *target; /* target target of the deviation */
Radek Krejci7af64242019-02-18 13:07:53 +01005654 struct lysc_node_list *list;
Radek Krejcifc11bd72019-04-11 16:00:05 +02005655 struct lysc_action *rpcs;
5656 struct lysc_notif *notifs;
Radek Krejciccd20f12019-02-15 14:12:27 +01005657 struct lysp_deviation *dev;
5658 struct lysp_deviate *d, **dp_new;
5659 struct lysp_deviate_add *d_add;
5660 struct lysp_deviate_del *d_del;
5661 struct lysp_deviate_rpl *d_rpl;
Radek Krejci7af64242019-02-18 13:07:53 +01005662 unsigned int u, v, x, y, z;
Radek Krejciccd20f12019-02-15 14:12:27 +01005663 struct lysc_deviation {
5664 const char *nodeid;
5665 struct lysc_node *target; /* target node of the deviation */
5666 struct lysp_deviate** deviates;/* sized array of pointers to parsed deviate statements to apply on target */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005667 uint16_t flags; /* target's flags from lys_resolve_schema_nodeid() */
Radek Krejciccd20f12019-02-15 14:12:27 +01005668 uint8_t not_supported; /* flag if deviates contains not-supported deviate */
5669 } **devs = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02005670 int i, changed_type;
Radek Krejciccd20f12019-02-15 14:12:27 +01005671 size_t prefix_len, name_len;
Radek Krejcia1911222019-07-22 17:24:50 +02005672 const char *prefix, *name, *nodeid, *dflt;
Radek Krejciccd20f12019-02-15 14:12:27 +01005673 struct lys_module *mod;
Radek Krejci551b12c2019-02-19 16:11:21 +01005674 uint32_t min, max;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005675 uint16_t flags;
Radek Krejciccd20f12019-02-15 14:12:27 +01005676
5677 /* get all deviations from the module and all its submodules ... */
5678 LY_ARRAY_FOR(mod_p->deviations, u) {
5679 ly_set_add(&devs_p, &mod_p->deviations[u], LY_SET_OPT_USEASLIST);
5680 }
5681 LY_ARRAY_FOR(mod_p->includes, v) {
5682 LY_ARRAY_FOR(mod_p->includes[v].submodule->deviations, u) {
5683 ly_set_add(&devs_p, &mod_p->includes[v].submodule->deviations[u], LY_SET_OPT_USEASLIST);
5684 }
5685 }
5686 if (!devs_p.count) {
5687 /* nothing to do */
5688 return LY_SUCCESS;
5689 }
5690
Radek Krejci327de162019-06-14 12:52:07 +02005691 lysc_update_path(ctx, NULL, "{deviation}");
5692
Radek Krejciccd20f12019-02-15 14:12:27 +01005693 /* ... and group them by the target node */
5694 devs = calloc(devs_p.count, sizeof *devs);
5695 for (u = 0; u < devs_p.count; ++u) {
5696 dev = devs_p.objs[u];
Radek Krejci327de162019-06-14 12:52:07 +02005697 lysc_update_path(ctx, NULL, dev->nodeid);
Radek Krejciccd20f12019-02-15 14:12:27 +01005698
5699 /* resolve the target */
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005700 LY_CHECK_GOTO(lys_resolve_schema_nodeid(ctx, dev->nodeid, 0, NULL, ctx->mod, 0, 1,
5701 (const struct lysc_node**)&target, &flags), cleanup);
Radek Krejcif538ce52019-03-05 10:46:14 +01005702 if (target->nodetype == LYS_ACTION) {
5703 /* move the target pointer to input/output to make them different from the action and
5704 * between them. Before the devs[] item is being processed, the target pointer must be fixed
5705 * back to the RPC/action node due to a better compatibility and decision code in this function.
5706 * The LYSC_OPT_INTERNAL is used as a flag to this change. */
5707 if (flags & LYSC_OPT_RPC_INPUT) {
5708 target = (struct lysc_node*)&((struct lysc_action*)target)->input;
5709 flags |= LYSC_OPT_INTERNAL;
5710 } else if (flags & LYSC_OPT_RPC_OUTPUT) {
5711 target = (struct lysc_node*)&((struct lysc_action*)target)->output;
5712 flags |= LYSC_OPT_INTERNAL;
5713 }
5714 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005715 /* insert into the set of targets with duplicity detection */
5716 i = ly_set_add(&targets, target, 0);
5717 if (!devs[i]) {
5718 /* new record */
5719 devs[i] = calloc(1, sizeof **devs);
5720 devs[i]->target = target;
5721 devs[i]->nodeid = dev->nodeid;
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005722 devs[i]->flags = flags;
Radek Krejciccd20f12019-02-15 14:12:27 +01005723 }
5724 /* add deviates into the deviation's list of deviates */
5725 for (d = dev->deviates; d; d = d->next) {
5726 LY_ARRAY_NEW_GOTO(ctx->ctx, devs[i]->deviates, dp_new, ret, cleanup);
5727 *dp_new = d;
5728 if (d->mod == LYS_DEV_NOT_SUPPORTED) {
5729 devs[i]->not_supported = 1;
5730 }
5731 }
Radek Krejci327de162019-06-14 12:52:07 +02005732
5733 lysc_update_path(ctx, NULL, NULL);
Radek Krejciccd20f12019-02-15 14:12:27 +01005734 }
5735
5736 /* MACROS for deviates checking */
5737#define DEV_CHECK_NODETYPE(NODETYPES, DEVTYPE, PROPERTY) \
5738 if (!(devs[u]->target->nodetype & (NODETYPES))) { \
Radek Krejci327de162019-06-14 12:52:07 +02005739 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE, lys_nodetype2str(devs[u]->target->nodetype), DEVTYPE, PROPERTY);\
Radek Krejciccd20f12019-02-15 14:12:27 +01005740 goto cleanup; \
5741 }
5742
5743#define DEV_CHECK_CARDINALITY(ARRAY, MAX, PROPERTY) \
5744 if (LY_ARRAY_SIZE(ARRAY) > MAX) { \
Radek Krejci327de162019-06-14 12:52:07 +02005745 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid deviation of %s with too many (%u) %s properties.", \
5746 lys_nodetype2str(devs[u]->target->nodetype), LY_ARRAY_SIZE(ARRAY), PROPERTY); \
Radek Krejciccd20f12019-02-15 14:12:27 +01005747 goto cleanup; \
5748 }
5749
Radek Krejcia1911222019-07-22 17:24:50 +02005750
Radek Krejciccd20f12019-02-15 14:12:27 +01005751#define DEV_CHECK_NONPRESENCE(TYPE, COND, MEMBER, PROPERTY, VALUEMEMBER) \
Radek Krejcia1911222019-07-22 17:24:50 +02005752 if (((TYPE)devs[u]->target)->MEMBER && (COND)) { \
5753 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
5754 "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", \
5755 PROPERTY, ((TYPE)devs[u]->target)->VALUEMEMBER); \
5756 goto cleanup; \
5757 }
5758
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005759#define DEV_CHECK_NONPRESENCE_VALUE(TYPE, COND, MEMBER, PROPERTY, VALUEMEMBER, VALUEMODMEMBER) \
Radek Krejci93dcc392019-02-19 10:43:38 +01005760 if (((TYPE)devs[u]->target)->MEMBER && (COND)) { \
Radek Krejcia1911222019-07-22 17:24:50 +02005761 int dynamic_ = 0; const char *val_; \
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005762 val_ = ((TYPE)devs[u]->target)->VALUEMEMBER->realtype->plugin->print(((TYPE)devs[u]->target)->VALUEMEMBER, LYD_XML, \
5763 lys_get_prefix, ((TYPE)devs[u]->target)->VALUEMODMEMBER, &dynamic_); \
Radek Krejciccd20f12019-02-15 14:12:27 +01005764 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
Radek Krejcia1911222019-07-22 17:24:50 +02005765 "Invalid deviation adding \"%s\" property which already exists (with value \"%s\").", PROPERTY, val_); \
5766 if (dynamic_) {free((void*)val_);} \
Radek Krejciccd20f12019-02-15 14:12:27 +01005767 goto cleanup; \
5768 }
5769
Radek Krejci551b12c2019-02-19 16:11:21 +01005770#define DEV_CHECK_NONPRESENCE_UINT(TYPE, COND, MEMBER, PROPERTY) \
5771 if (((TYPE)devs[u]->target)->MEMBER COND) { \
5772 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
Radek Krejci327de162019-06-14 12:52:07 +02005773 "Invalid deviation adding \"%s\" property which already exists (with value \"%u\").", \
5774 PROPERTY, ((TYPE)devs[u]->target)->MEMBER); \
Radek Krejci551b12c2019-02-19 16:11:21 +01005775 goto cleanup; \
5776 }
5777
Radek Krejciccd20f12019-02-15 14:12:27 +01005778#define DEV_CHECK_PRESENCE(TYPE, COND, MEMBER, DEVTYPE, PROPERTY, VALUE) \
5779 if (!((TYPE)devs[u]->target)->MEMBER || COND) { \
Radek Krejci327de162019-06-14 12:52:07 +02005780 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT, DEVTYPE, PROPERTY, VALUE); \
Radek Krejciccd20f12019-02-15 14:12:27 +01005781 goto cleanup; \
5782 }
5783
Radek Krejci551b12c2019-02-19 16:11:21 +01005784#define DEV_CHECK_PRESENCE_UINT(TYPE, COND, MEMBER, PROPERTY) \
5785 if (!(((TYPE)devs[u]->target)->MEMBER COND)) { \
5786 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
Radek Krejci327de162019-06-14 12:52:07 +02005787 "Invalid deviation replacing with \"%s\" property \"%u\" which is not present.", PROPERTY, d_rpl->MEMBER); \
Radek Krejci551b12c2019-02-19 16:11:21 +01005788 goto cleanup; \
5789 }
5790
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005791#define DEV_DEL_ARRAY(TYPE, ARRAY_TRG, ARRAY_DEV, VALMEMBER, VALMEMBER_CMP, DELFUNC_DEREF, DELFUNC, PROPERTY) \
5792 DEV_CHECK_PRESENCE(TYPE, 0, ARRAY_TRG, "deleting", PROPERTY, d_del->ARRAY_DEV[0]VALMEMBER); \
5793 LY_ARRAY_FOR(d_del->ARRAY_DEV, x) { \
5794 LY_ARRAY_FOR(((TYPE)devs[u]->target)->ARRAY_TRG, y) { \
5795 if (!strcmp(((TYPE)devs[u]->target)->ARRAY_TRG[y]VALMEMBER_CMP, d_del->ARRAY_DEV[x]VALMEMBER)) { break; } \
Radek Krejciccd20f12019-02-15 14:12:27 +01005796 } \
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005797 if (y == LY_ARRAY_SIZE(((TYPE)devs[u]->target)->ARRAY_TRG)) { \
Radek Krejciccd20f12019-02-15 14:12:27 +01005798 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, \
Radek Krejci327de162019-06-14 12:52:07 +02005799 "Invalid deviation deleting \"%s\" property \"%s\" which does not match any of the target's property values.", \
5800 PROPERTY, d_del->ARRAY_DEV[x]VALMEMBER); \
Radek Krejciccd20f12019-02-15 14:12:27 +01005801 goto cleanup; \
5802 } \
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005803 LY_ARRAY_DECREMENT(((TYPE)devs[u]->target)->ARRAY_TRG); \
5804 DELFUNC(ctx->ctx, DELFUNC_DEREF((TYPE)devs[u]->target)->ARRAY_TRG[y]); \
5805 memmove(&((TYPE)devs[u]->target)->ARRAY_TRG[y], \
5806 &((TYPE)devs[u]->target)->ARRAY_TRG[y + 1], \
5807 (LY_ARRAY_SIZE(((TYPE)devs[u]->target)->ARRAY_TRG) - y) * (sizeof *((TYPE)devs[u]->target)->ARRAY_TRG)); \
Radek Krejciccd20f12019-02-15 14:12:27 +01005808 } \
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005809 if (!LY_ARRAY_SIZE(((TYPE)devs[u]->target)->ARRAY_TRG)) { \
5810 LY_ARRAY_FREE(((TYPE)devs[u]->target)->ARRAY_TRG); \
5811 ((TYPE)devs[u]->target)->ARRAY_TRG = NULL; \
Radek Krejciccd20f12019-02-15 14:12:27 +01005812 }
5813
5814 /* apply deviations */
5815 for (u = 0; u < devs_p.count && devs[u]; ++u) {
Radek Krejcia1911222019-07-22 17:24:50 +02005816 struct lysc_node_leaf *leaf = (struct lysc_node_leaf*)devs[u]->target;
5817 struct lysc_node_leaflist *llist = (struct lysc_node_leaflist*)devs[u]->target;
5818 struct ly_err_item *err = NULL;
5819
5820 dflt = NULL;
5821 changed_type = 0;
5822
Radek Krejci327de162019-06-14 12:52:07 +02005823 lysc_update_path(ctx, NULL, devs[u]->nodeid);
5824
Radek Krejcif538ce52019-03-05 10:46:14 +01005825 if (devs[u]->flags & LYSC_OPT_INTERNAL) {
5826 /* fix the target pointer in case of RPC's/action's input/output */
5827 if (devs[u]->flags & LYSC_OPT_RPC_INPUT) {
5828 devs[u]->target = (struct lysc_node*)((char*)devs[u]->target - offsetof(struct lysc_action, input));
5829 } else if (devs[u]->flags & LYSC_OPT_RPC_OUTPUT) {
5830 devs[u]->target = (struct lysc_node*)((char*)devs[u]->target - offsetof(struct lysc_action, output));
5831 }
5832 }
5833
Radek Krejciccd20f12019-02-15 14:12:27 +01005834 /* not-supported */
5835 if (devs[u]->not_supported) {
5836 if (LY_ARRAY_SIZE(devs[u]->deviates) > 1) {
5837 LOGWRN(ctx->ctx, "Useless multiple (%u) deviates on node \"%s\" since the node is not-supported.",
5838 LY_ARRAY_SIZE(devs[u]->deviates), devs[u]->nodeid);
5839 }
Radek Krejcifc11bd72019-04-11 16:00:05 +02005840
5841#define REMOVE_NONDATA(ARRAY, TYPE, GETFUNC, FREEFUNC) \
5842 if (devs[u]->target->parent) { \
5843 ARRAY = (TYPE*)GETFUNC(devs[u]->target->parent); \
5844 } else { \
5845 ARRAY = devs[u]->target->module->compiled->ARRAY; \
5846 } \
5847 LY_ARRAY_FOR(ARRAY, x) { \
5848 if (&ARRAY[x] == (TYPE*)devs[u]->target) { break; } \
5849 } \
5850 if (x < LY_ARRAY_SIZE(ARRAY)) { \
5851 FREEFUNC(ctx->ctx, &ARRAY[x]); \
5852 memmove(&ARRAY[x], &ARRAY[x + 1], (LY_ARRAY_SIZE(ARRAY) - (x + 1)) * sizeof *ARRAY); \
5853 LY_ARRAY_DECREMENT(ARRAY); \
5854 }
5855
Radek Krejcif538ce52019-03-05 10:46:14 +01005856 if (devs[u]->target->nodetype == LYS_ACTION) {
5857 if (devs[u]->flags & LYSC_OPT_RPC_INPUT) {
5858 /* remove RPC's/action's input */
5859 lysc_action_inout_free(ctx->ctx, &((struct lysc_action*)devs[u]->target)->input);
5860 memset(&((struct lysc_action*)devs[u]->target)->input, 0, sizeof ((struct lysc_action*)devs[u]->target)->input);
Radek Krejcifc11bd72019-04-11 16:00:05 +02005861 FREE_ARRAY(ctx->ctx, ((struct lysc_action*)devs[u]->target)->input_exts, lysc_ext_instance_free);
5862 ((struct lysc_action*)devs[u]->target)->input_exts = NULL;
Radek Krejcif538ce52019-03-05 10:46:14 +01005863 } else if (devs[u]->flags & LYSC_OPT_RPC_OUTPUT) {
5864 /* remove RPC's/action's output */
5865 lysc_action_inout_free(ctx->ctx, &((struct lysc_action*)devs[u]->target)->output);
5866 memset(&((struct lysc_action*)devs[u]->target)->output, 0, sizeof ((struct lysc_action*)devs[u]->target)->output);
Radek Krejcifc11bd72019-04-11 16:00:05 +02005867 FREE_ARRAY(ctx->ctx, ((struct lysc_action*)devs[u]->target)->output_exts, lysc_ext_instance_free);
5868 ((struct lysc_action*)devs[u]->target)->output_exts = NULL;
Radek Krejcif538ce52019-03-05 10:46:14 +01005869 } else {
5870 /* remove RPC/action */
Radek Krejcifc11bd72019-04-11 16:00:05 +02005871 REMOVE_NONDATA(rpcs, struct lysc_action, lysc_node_actions, lysc_action_free);
Radek Krejcif538ce52019-03-05 10:46:14 +01005872 }
5873 } else if (devs[u]->target->nodetype == LYS_NOTIF) {
Radek Krejcifc11bd72019-04-11 16:00:05 +02005874 /* remove Notification */
5875 REMOVE_NONDATA(notifs, struct lysc_notif, lysc_node_notifs, lysc_notif_free);
Radek Krejcif538ce52019-03-05 10:46:14 +01005876 } else {
5877 /* remove the target node */
5878 lysc_disconnect(devs[u]->target);
5879 lysc_node_free(ctx->ctx, devs[u]->target);
5880 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005881
Radek Krejci474f9b82019-07-24 11:36:37 +02005882 /* mark the context for later re-compilation of objects that could reference the curently removed node */
5883 ctx->ctx->flags |= LY_CTX_CHANGED_TREE;
Radek Krejciccd20f12019-02-15 14:12:27 +01005884 continue;
5885 }
5886
5887 /* list of deviates (not-supported is not present in the list) */
5888 LY_ARRAY_FOR(devs[u]->deviates, v) {
5889 d = devs[u]->deviates[v];
5890
5891 switch (d->mod) {
5892 case LYS_DEV_ADD:
5893 d_add = (struct lysp_deviate_add*)d;
5894 /* [units-stmt] */
5895 if (d_add->units) {
5896 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "add", "units");
5897 DEV_CHECK_NONPRESENCE(struct lysc_node_leaf*, (devs[u]->target->flags & LYS_SET_UNITS), units, "units", units);
5898
5899 FREE_STRING(ctx->ctx, ((struct lysc_node_leaf*)devs[u]->target)->units);
5900 DUP_STRING(ctx->ctx, d_add->units, ((struct lysc_node_leaf*)devs[u]->target)->units);
5901 }
5902
5903 /* *must-stmt */
5904 if (d_add->musts) {
5905 switch (devs[u]->target->nodetype) {
5906 case LYS_CONTAINER:
5907 case LYS_LIST:
5908 COMPILE_ARRAY_GOTO(ctx, d_add->musts, ((struct lysc_node_container*)devs[u]->target)->musts,
Radek Krejciec4da802019-05-02 13:02:41 +02005909 x, lys_compile_must, ret, cleanup);
Radek Krejciccd20f12019-02-15 14:12:27 +01005910 break;
5911 case LYS_LEAF:
5912 case LYS_LEAFLIST:
5913 case LYS_ANYDATA:
5914 COMPILE_ARRAY_GOTO(ctx, d_add->musts, ((struct lysc_node_leaf*)devs[u]->target)->musts,
Radek Krejciec4da802019-05-02 13:02:41 +02005915 x, lys_compile_must, ret, cleanup);
Radek Krejciccd20f12019-02-15 14:12:27 +01005916 break;
5917 case LYS_NOTIF:
Radek Krejcifc11bd72019-04-11 16:00:05 +02005918 COMPILE_ARRAY_GOTO(ctx, d_add->musts, ((struct lysc_notif*)devs[u]->target)->musts,
Radek Krejciec4da802019-05-02 13:02:41 +02005919 x, lys_compile_must, ret, cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005920 break;
5921 case LYS_ACTION:
5922 if (devs[u]->flags & LYSC_OPT_RPC_INPUT) {
5923 COMPILE_ARRAY_GOTO(ctx, d_add->musts, ((struct lysc_action*)devs[u]->target)->input.musts,
Radek Krejciec4da802019-05-02 13:02:41 +02005924 x, lys_compile_must, ret, cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005925 break;
5926 } else if (devs[u]->flags & LYSC_OPT_RPC_OUTPUT) {
5927 COMPILE_ARRAY_GOTO(ctx, d_add->musts, ((struct lysc_action*)devs[u]->target)->output.musts,
Radek Krejciec4da802019-05-02 13:02:41 +02005928 x, lys_compile_must, ret, cleanup);
Radek Krejci6eeb58f2019-02-22 16:29:37 +01005929 break;
5930 }
5931 /* fall through */
Radek Krejciccd20f12019-02-15 14:12:27 +01005932 default:
5933 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci327de162019-06-14 12:52:07 +02005934 lys_nodetype2str(devs[u]->target->nodetype), "add", "must");
Radek Krejciccd20f12019-02-15 14:12:27 +01005935 goto cleanup;
5936 }
5937 }
5938
5939 /* *unique-stmt */
Radek Krejci7af64242019-02-18 13:07:53 +01005940 if (d_add->uniques) {
5941 DEV_CHECK_NODETYPE(LYS_LIST, "add", "unique");
5942 LY_CHECK_GOTO(lys_compile_node_list_unique(ctx, ctx->mod, d_add->uniques, (struct lysc_node_list*)devs[u]->target), cleanup);
5943 }
Radek Krejciccd20f12019-02-15 14:12:27 +01005944
5945 /* *default-stmt */
5946 if (d_add->dflts) {
Radek Krejciccd20f12019-02-15 14:12:27 +01005947 switch (devs[u]->target->nodetype) {
5948 case LYS_LEAF:
5949 DEV_CHECK_CARDINALITY(d_add->dflts, 1, "default");
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005950 DEV_CHECK_NONPRESENCE_VALUE(struct lysc_node_leaf*, (devs[u]->target->flags & LYS_SET_DFLT), dflt, "default", dflt, dflt_mod);
Radek Krejcia1911222019-07-22 17:24:50 +02005951 if (leaf->dflt) {
Radek Krejciccd20f12019-02-15 14:12:27 +01005952 /* first, remove the default value taken from the type */
Radek Krejci474f9b82019-07-24 11:36:37 +02005953 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02005954 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
5955 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
5956 } else {
5957 /* prepare new default value storage */
5958 leaf->dflt = calloc(1, sizeof *leaf->dflt);
Radek Krejciccd20f12019-02-15 14:12:27 +01005959 }
Radek Krejcia1911222019-07-22 17:24:50 +02005960 dflt = d_add->dflts[0];
5961 /* parsing is done at the end after possible replace of the leaf's type */
5962
Radek Krejci551b12c2019-02-19 16:11:21 +01005963 /* mark the new default values as leaf's own */
5964 devs[u]->target->flags |= LYS_SET_DFLT;
Radek Krejciccd20f12019-02-15 14:12:27 +01005965 break;
5966 case LYS_LEAFLIST:
Radek Krejcia1911222019-07-22 17:24:50 +02005967 if (llist->dflts && !(devs[u]->target->flags & LYS_SET_DFLT)) {
Radek Krejciccd20f12019-02-15 14:12:27 +01005968 /* first, remove the default value taken from the type */
Radek Krejcia1911222019-07-22 17:24:50 +02005969 LY_ARRAY_FOR(llist->dflts, x) {
Radek Krejci474f9b82019-07-24 11:36:37 +02005970 lysc_incomplete_dflts_remove(ctx, llist->dflts[x]);
Radek Krejcia1911222019-07-22 17:24:50 +02005971 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
5972 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
5973 free(llist->dflts[x]);
Radek Krejciccd20f12019-02-15 14:12:27 +01005974 }
Radek Krejcia1911222019-07-22 17:24:50 +02005975 LY_ARRAY_FREE(llist->dflts);
5976 llist->dflts = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005977 LY_ARRAY_FREE(llist->dflts_mods);
5978 llist->dflts_mods = NULL;
Radek Krejciccd20f12019-02-15 14:12:27 +01005979 }
5980 /* add new default value(s) */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005981 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts_mods, LY_ARRAY_SIZE(d_add->dflts), ret, cleanup);
Radek Krejcia1911222019-07-22 17:24:50 +02005982 LY_ARRAY_CREATE_GOTO(ctx->ctx, llist->dflts, LY_ARRAY_SIZE(d_add->dflts), ret, cleanup);
5983 for (x = y = LY_ARRAY_SIZE(llist->dflts);
Radek Krejciccd20f12019-02-15 14:12:27 +01005984 x < LY_ARRAY_SIZE(d_add->dflts) + y; ++x) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02005985 LY_ARRAY_INCREMENT(llist->dflts_mods);
5986 llist->dflts_mods[x] = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02005987 LY_ARRAY_INCREMENT(llist->dflts);
5988 llist->dflts[x] = calloc(1, sizeof *llist->dflts[x]);
5989 llist->dflts[x]->realtype = llist->type;
5990 rc = llist->type->plugin->store(ctx->ctx, llist->type, d_add->dflts[x - y], strlen(d_add->dflts[x - y]),
Radek Krejci474f9b82019-07-24 11:36:37 +02005991 LY_TYPE_OPTS_INCOMPLETE_DATA |LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE, lys_resolve_prefix,
Radek Krejci1c0c3442019-07-23 16:08:47 +02005992 (void*)llist->dflts_mods[x], LYD_XML, devs[u]->target, NULL, llist->dflts[x], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02005993 llist->dflts[x]->realtype->refcount++;
5994 if (err) {
5995 ly_err_print(err);
5996 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
5997 "Invalid deviation adding \"default\" property \"%s\" which does not fit the type (%s).",
5998 d_add->dflts[x - y], err->msg);
5999 ly_err_free(err);
6000 }
Radek Krejci474f9b82019-07-24 11:36:37 +02006001 if (rc == LY_EINCOMPLETE) {
6002 /* postpone default compilation when the tree is complete */
6003 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, devs[u]->target, llist->dflts[x], llist->dflts_mods[x]), cleanup);
6004
6005 /* but in general result is so far ok */
6006 rc = LY_SUCCESS;
6007 }
Radek Krejcia1911222019-07-22 17:24:50 +02006008 LY_CHECK_GOTO(rc, cleanup);
Radek Krejciccd20f12019-02-15 14:12:27 +01006009 }
Radek Krejci551b12c2019-02-19 16:11:21 +01006010 /* mark the new default values as leaf-list's own */
Radek Krejciccd20f12019-02-15 14:12:27 +01006011 devs[u]->target->flags |= LYS_SET_DFLT;
6012 break;
6013 case LYS_CHOICE:
6014 DEV_CHECK_CARDINALITY(d_add->dflts, 1, "default");
6015 DEV_CHECK_NONPRESENCE(struct lysc_node_choice*, 1, dflt, "default", dflt->name);
6016 /* in contrast to delete, here we strictly resolve the prefix in the module of the deviation
6017 * to allow making the default case even the augmented case from the deviating module */
Radek Krejci327de162019-06-14 12:52:07 +02006018 if (lys_compile_deviation_set_choice_dflt(ctx, d_add->dflts[0], (struct lysc_node_choice*)devs[u]->target)) {
Radek Krejciccd20f12019-02-15 14:12:27 +01006019 goto cleanup;
6020 }
6021 break;
6022 default:
6023 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci327de162019-06-14 12:52:07 +02006024 lys_nodetype2str(devs[u]->target->nodetype), "add", "default");
Radek Krejciccd20f12019-02-15 14:12:27 +01006025 goto cleanup;
6026 }
6027 }
6028
6029 /* [config-stmt] */
Radek Krejci93dcc392019-02-19 10:43:38 +01006030 if (d_add->flags & LYS_CONFIG_MASK) {
6031 if (devs[u]->target->nodetype & (LYS_CASE | LYS_INOUT | LYS_ACTION | LYS_NOTIF)) {
Radek Krejci327de162019-06-14 12:52:07 +02006032 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci93dcc392019-02-19 10:43:38 +01006033 lys_nodetype2str(devs[u]->target->nodetype), "add", "config");
6034 goto cleanup;
6035 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006036 if (devs[u]->flags) {
Radek Krejci327de162019-06-14 12:52:07 +02006037 LOGWRN(ctx->ctx, "Deviating config inside %s has no effect.",
6038 devs[u]->flags & LYSC_OPT_NOTIFICATION ? "Notification" : "RPC/action");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006039 }
Radek Krejci93dcc392019-02-19 10:43:38 +01006040 if (devs[u]->target->flags & LYS_SET_CONFIG) {
6041 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006042 "Invalid deviation adding \"config\" property which already exists (with value \"config %s\").",
6043 devs[u]->target->flags & LYS_CONFIG_W ? "true" : "false");
Radek Krejci93dcc392019-02-19 10:43:38 +01006044 goto cleanup;
6045 }
Radek Krejci327de162019-06-14 12:52:07 +02006046 LY_CHECK_GOTO(lys_compile_change_config(ctx, devs[u]->target, d_add->flags, 0, 0), cleanup);
Radek Krejci93dcc392019-02-19 10:43:38 +01006047 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006048
6049 /* [mandatory-stmt] */
Radek Krejcif1421c22019-02-19 13:05:20 +01006050 if (d_add->flags & LYS_MAND_MASK) {
6051 if (devs[u]->target->flags & LYS_MAND_MASK) {
6052 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006053 "Invalid deviation adding \"mandatory\" property which already exists (with value \"mandatory %s\").",
6054 devs[u]->target->flags & LYS_MAND_TRUE ? "true" : "false");
Radek Krejcif1421c22019-02-19 13:05:20 +01006055 goto cleanup;
6056 }
Radek Krejci327de162019-06-14 12:52:07 +02006057 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, devs[u]->target, d_add->flags, 0), cleanup);
Radek Krejcif1421c22019-02-19 13:05:20 +01006058 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006059
6060 /* [min-elements-stmt] */
Radek Krejci551b12c2019-02-19 16:11:21 +01006061 if (d_add->flags & LYS_SET_MIN) {
6062 if (devs[u]->target->nodetype == LYS_LEAFLIST) {
6063 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist*, > 0, min, "min-elements");
6064 /* change value */
6065 ((struct lysc_node_leaflist*)devs[u]->target)->min = d_add->min;
6066 } else if (devs[u]->target->nodetype == LYS_LIST) {
6067 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list*, > 0, min, "min-elements");
6068 /* change value */
6069 ((struct lysc_node_list*)devs[u]->target)->min = d_add->min;
6070 } else {
Radek Krejci327de162019-06-14 12:52:07 +02006071 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci551b12c2019-02-19 16:11:21 +01006072 lys_nodetype2str(devs[u]->target->nodetype), "add", "min-elements");
6073 goto cleanup;
6074 }
6075 if (d_add->min) {
6076 devs[u]->target->flags |= LYS_MAND_TRUE;
6077 }
6078 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006079
6080 /* [max-elements-stmt] */
Radek Krejci551b12c2019-02-19 16:11:21 +01006081 if (d_add->flags & LYS_SET_MAX) {
6082 if (devs[u]->target->nodetype == LYS_LEAFLIST) {
6083 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_leaflist*, < (uint32_t)-1, max, "max-elements");
6084 /* change value */
6085 ((struct lysc_node_leaflist*)devs[u]->target)->max = d_add->max ? d_add->max : (uint32_t)-1;
6086 } else if (devs[u]->target->nodetype == LYS_LIST) {
6087 DEV_CHECK_NONPRESENCE_UINT(struct lysc_node_list*, < (uint32_t)-1, max, "max-elements");
6088 /* change value */
6089 ((struct lysc_node_list*)devs[u]->target)->max = d_add->max ? d_add->max : (uint32_t)-1;
6090 } else {
Radek Krejci327de162019-06-14 12:52:07 +02006091 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci551b12c2019-02-19 16:11:21 +01006092 lys_nodetype2str(devs[u]->target->nodetype), "add", "max-elements");
6093 goto cleanup;
6094 }
6095 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006096
6097 break;
6098 case LYS_DEV_DELETE:
6099 d_del = (struct lysp_deviate_del*)d;
6100
6101 /* [units-stmt] */
6102 if (d_del->units) {
6103 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "delete", "units");
Radek Krejcia1911222019-07-22 17:24:50 +02006104 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, 0, units, "deleting", "units", d_del->units);
6105 if (strcmp(((struct lysc_node_leaf*)devs[u]->target)->units, d_del->units)) {
6106 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
6107 "Invalid deviation deleting \"units\" property \"%s\" which does not match the target's property value \"%s\".",
6108 d_del->units, ((struct lysc_node_leaf*)devs[u]->target)->units);
6109 goto cleanup;
6110 }
6111 lydict_remove(ctx->ctx, ((struct lysc_node_leaf*)devs[u]->target)->units);
6112 ((struct lysc_node_leaf*)devs[u]->target)->units = NULL;
Radek Krejciccd20f12019-02-15 14:12:27 +01006113 }
6114
6115 /* *must-stmt */
6116 if (d_del->musts) {
6117 switch (devs[u]->target->nodetype) {
6118 case LYS_CONTAINER:
6119 case LYS_LIST:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006120 DEV_DEL_ARRAY(struct lysc_node_container*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
Radek Krejciccd20f12019-02-15 14:12:27 +01006121 break;
6122 case LYS_LEAF:
6123 case LYS_LEAFLIST:
6124 case LYS_ANYDATA:
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006125 DEV_DEL_ARRAY(struct lysc_node_leaf*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
Radek Krejciccd20f12019-02-15 14:12:27 +01006126 break;
6127 case LYS_NOTIF:
Radek Krejcifc11bd72019-04-11 16:00:05 +02006128 DEV_DEL_ARRAY(struct lysc_notif*, musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
Radek Krejci6eeb58f2019-02-22 16:29:37 +01006129 break;
6130 case LYS_ACTION:
6131 if (devs[u]->flags & LYSC_OPT_RPC_INPUT) {
6132 DEV_DEL_ARRAY(struct lysc_action*, input.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
6133 break;
6134 } else if (devs[u]->flags & LYSC_OPT_RPC_OUTPUT) {
6135 DEV_DEL_ARRAY(struct lysc_action*, output.musts, musts, .arg, .cond->expr, &, lysc_must_free, "must");
6136 break;
6137 }
6138 /* fall through */
Radek Krejciccd20f12019-02-15 14:12:27 +01006139 default:
6140 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci327de162019-06-14 12:52:07 +02006141 lys_nodetype2str(devs[u]->target->nodetype), "delete", "must");
Radek Krejciccd20f12019-02-15 14:12:27 +01006142 goto cleanup;
6143 }
6144 }
6145
6146 /* *unique-stmt */
Radek Krejci7af64242019-02-18 13:07:53 +01006147 if (d_del->uniques) {
6148 DEV_CHECK_NODETYPE(LYS_LIST, "delete", "unique");
6149 list = (struct lysc_node_list*)devs[u]->target; /* shortcut */
6150 LY_ARRAY_FOR(d_del->uniques, x) {
6151 LY_ARRAY_FOR(list->uniques, z) {
6152 for (name = d_del->uniques[x], y = 0; name; name = nodeid, ++y) {
6153 nodeid = strpbrk(name, " \t\n");
6154 if (nodeid) {
6155 if (strncmp(name, list->uniques[z][y]->name, nodeid - name)
6156 || list->uniques[z][y]->name[nodeid - name] != '\0') {
6157 break;
6158 }
6159 while (isspace(*nodeid)) {
6160 ++nodeid;
6161 }
6162 } else {
6163 if (strcmp(name, list->uniques[z][y]->name)) {
6164 break;
6165 }
6166 }
6167 }
6168 if (!name) {
6169 /* complete match - remove the unique */
6170 LY_ARRAY_DECREMENT(list->uniques);
6171 LY_ARRAY_FREE(list->uniques[z]);
6172 memmove(&list->uniques[z], &list->uniques[z + 1], (LY_ARRAY_SIZE(list->uniques) - z) * (sizeof *list->uniques));
6173 --z;
6174 break;
6175 }
6176 }
6177 if (!list->uniques || z == LY_ARRAY_SIZE(list->uniques)) {
6178 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006179 "Invalid deviation deleting \"unique\" property \"%s\" which does not match any of the target's property values.",
6180 d_del->uniques[x]);
Radek Krejci7af64242019-02-18 13:07:53 +01006181 goto cleanup;
6182 }
6183 }
6184 if (!LY_ARRAY_SIZE(list->uniques)) {
6185 LY_ARRAY_FREE(list->uniques);
6186 list->uniques = NULL;
6187 }
6188 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006189
6190 /* *default-stmt */
6191 if (d_del->dflts) {
6192 switch (devs[u]->target->nodetype) {
6193 case LYS_LEAF:
6194 DEV_CHECK_CARDINALITY(d_del->dflts, 1, "default");
6195 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, !(devs[u]->target->flags & LYS_SET_DFLT),
6196 dflt, "deleting", "default", d_del->dflts[0]);
6197
Radek Krejcia1911222019-07-22 17:24:50 +02006198 /* check that the values matches */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006199 dflt = leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, lys_get_prefix, leaf->dflt_mod, &i);
Radek Krejcia1911222019-07-22 17:24:50 +02006200 if (strcmp(dflt, d_del->dflts[0])) {
6201 if (i) {
6202 free((char*)dflt);
6203 }
6204 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
6205 "Invalid deviation deleting \"default\" property \"%s\" which does not match the target's property value \"%s\".",
6206 d_del->dflts[0], dflt);
6207 goto cleanup;
6208 }
6209 if (i) {
6210 free((char*)dflt);
6211 }
6212 dflt = NULL;
6213
Radek Krejci474f9b82019-07-24 11:36:37 +02006214 /* update the list of incomplete default values if needed */
6215 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6216
Radek Krejcia1911222019-07-22 17:24:50 +02006217 /* remove the default specification */
6218 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6219 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6220 free(leaf->dflt);
6221 leaf->dflt = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006222 leaf->dflt_mod = NULL;
Radek Krejci551b12c2019-02-19 16:11:21 +01006223 devs[u]->target->flags &= ~LYS_SET_DFLT;
Radek Krejciccd20f12019-02-15 14:12:27 +01006224 break;
6225 case LYS_LEAFLIST:
Radek Krejcia1911222019-07-22 17:24:50 +02006226 DEV_CHECK_PRESENCE(struct lysc_node_leaflist*, 0, dflts, "deleting", "default", d_del->dflts[0]);
6227 LY_ARRAY_FOR(d_del->dflts, x) {
6228 LY_ARRAY_FOR(llist->dflts, y) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006229 dflt = llist->type->plugin->print(llist->dflts[y], LYD_XML, lys_get_prefix, llist->dflts_mods[y], &i);
Radek Krejcia1911222019-07-22 17:24:50 +02006230 if (!strcmp(dflt, d_del->dflts[x])) {
6231 if (i) {
6232 free((char*)dflt);
6233 }
6234 dflt = NULL;
6235 break;
6236 }
6237 if (i) {
6238 free((char*)dflt);
6239 }
6240 dflt = NULL;
6241 }
6242 if (y == LY_ARRAY_SIZE(llist->dflts)) {
6243 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, "Invalid deviation deleting \"default\" property \"%s\" "
6244 "which does not match any of the target's property values.", d_del->dflts[x]);
6245 goto cleanup;
6246 }
Radek Krejci474f9b82019-07-24 11:36:37 +02006247
6248 /* update the list of incomplete default values if needed */
6249 lysc_incomplete_dflts_remove(ctx, llist->dflts[y]);
6250
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006251 LY_ARRAY_DECREMENT(llist->dflts_mods);
Radek Krejcia1911222019-07-22 17:24:50 +02006252 LY_ARRAY_DECREMENT(llist->dflts);
6253 llist->dflts[y]->realtype->plugin->free(ctx->ctx, llist->dflts[y]);
6254 lysc_type_free(ctx->ctx, llist->dflts[y]->realtype);
6255 free(llist->dflts[y]);
6256 memmove(&llist->dflts[y], &llist->dflts[y + 1], (LY_ARRAY_SIZE(llist->dflts) - y) * (sizeof *llist->dflts));
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006257 memmove(&llist->dflts_mods[y], &llist->dflts_mods[y + 1], (LY_ARRAY_SIZE(llist->dflts_mods) - y) * (sizeof *llist->dflts_mods));
Radek Krejcia1911222019-07-22 17:24:50 +02006258 }
6259 if (!LY_ARRAY_SIZE(llist->dflts)) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006260 LY_ARRAY_FREE(llist->dflts_mods);
6261 llist->dflts_mods = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02006262 LY_ARRAY_FREE(llist->dflts);
6263 llist->dflts = NULL;
6264 llist->flags &= ~LYS_SET_DFLT;
Radek Krejci551b12c2019-02-19 16:11:21 +01006265 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006266 break;
6267 case LYS_CHOICE:
6268 DEV_CHECK_CARDINALITY(d_del->dflts, 1, "default");
6269 DEV_CHECK_PRESENCE(struct lysc_node_choice*, 0, dflt, "deleting", "default", d_del->dflts[0]);
6270 nodeid = d_del->dflts[0];
Radek Krejcib4a4a272019-06-10 12:44:52 +02006271 LY_CHECK_GOTO(ly_parse_nodeid(&nodeid, &prefix, &prefix_len, &name, &name_len), cleanup);
Radek Krejciccd20f12019-02-15 14:12:27 +01006272 if (prefix) {
6273 /* use module prefixes from the deviation module to match the module of the default case */
6274 if (!(mod = lys_module_find_prefix(ctx->mod, prefix, prefix_len))) {
6275 LOGVAL(ctx->ctx,LY_VLOG_STR,ctx->path,LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006276 "Invalid deviation deleting \"default\" property \"%s\" of choice. "
6277 "The prefix does not match any imported module of the deviation module.", d_del->dflts[0]);
Radek Krejciccd20f12019-02-15 14:12:27 +01006278 goto cleanup;
6279 }
6280 if (mod != ((struct lysc_node_choice*)devs[u]->target)->dflt->module) {
6281 LOGVAL(ctx->ctx,LY_VLOG_STR,ctx->path,LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006282 "Invalid deviation deleting \"default\" property \"%s\" of choice. "
6283 "The prefix does not match the default case's module.", d_del->dflts[0]);
Radek Krejciccd20f12019-02-15 14:12:27 +01006284 goto cleanup;
6285 }
6286 }
6287 /* else {
6288 * strictly, the default prefix would point to the deviation module, but the value should actually
6289 * match the default string in the original module (usually unprefixed), so in this case we do not check
6290 * the module of the default case, just matching its name */
6291 if (strcmp(name, ((struct lysc_node_choice*)devs[u]->target)->dflt->name)) {
6292 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE,
Radek Krejci327de162019-06-14 12:52:07 +02006293 "Invalid deviation deleting \"default\" property \"%s\" of choice does not match the default case name \"%s\".",
6294 d_del->dflts[0], ((struct lysc_node_choice*)devs[u]->target)->dflt->name);
Radek Krejciccd20f12019-02-15 14:12:27 +01006295 goto cleanup;
6296 }
6297 ((struct lysc_node_choice*)devs[u]->target)->dflt->flags &= ~LYS_SET_DFLT;
6298 ((struct lysc_node_choice*)devs[u]->target)->dflt = NULL;
6299 break;
6300 default:
6301 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci327de162019-06-14 12:52:07 +02006302 lys_nodetype2str(devs[u]->target->nodetype), "delete", "default");
Radek Krejciccd20f12019-02-15 14:12:27 +01006303 goto cleanup;
6304 }
6305 }
6306
6307 break;
6308 case LYS_DEV_REPLACE:
6309 d_rpl = (struct lysp_deviate_rpl*)d;
6310
6311 /* [type-stmt] */
Radek Krejci33f72892019-02-21 10:36:58 +01006312 if (d_rpl->type) {
6313 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "replace", "type");
6314 /* type is mandatory, so checking for its presence is not necessary */
6315 lysc_type_free(ctx->ctx, ((struct lysc_node_leaf*)devs[u]->target)->type);
Radek Krejcia1911222019-07-22 17:24:50 +02006316
6317 if (leaf->dflt && !(devs[u]->target->flags & LYS_SET_DFLT)) {
6318 /* the target has default from the previous type - remove it */
6319 if (devs[u]->target->nodetype == LYS_LEAF) {
Radek Krejci474f9b82019-07-24 11:36:37 +02006320 /* update the list of incomplete default values if needed */
6321 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6322
Radek Krejcia1911222019-07-22 17:24:50 +02006323 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6324 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6325 free(leaf->dflt);
6326 leaf->dflt = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006327 leaf->dflt_mod = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02006328 } else { /* LYS_LEAFLIST */
6329 LY_ARRAY_FOR(llist->dflts, x) {
Radek Krejci474f9b82019-07-24 11:36:37 +02006330 lysc_incomplete_dflts_remove(ctx, llist->dflts[x]);
Radek Krejcia1911222019-07-22 17:24:50 +02006331 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
6332 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
6333 free(llist->dflts[x]);
6334 }
6335 LY_ARRAY_FREE(llist->dflts);
6336 llist->dflts = NULL;
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006337 LY_ARRAY_FREE(llist->dflts_mods);
6338 llist->dflts_mods = NULL;
Radek Krejcia1911222019-07-22 17:24:50 +02006339 }
6340 }
6341 if (!leaf->dflt) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006342 /* there is no default value, do not set changed_type after type compilation
6343 * which is used to recompile the default value */
Radek Krejcia1911222019-07-22 17:24:50 +02006344 changed_type = -1;
6345 }
Radek Krejciec4da802019-05-02 13:02:41 +02006346 LY_CHECK_GOTO(lys_compile_node_type(ctx, NULL, d_rpl->type, (struct lysc_node_leaf*)devs[u]->target), cleanup);
Radek Krejcia1911222019-07-22 17:24:50 +02006347 changed_type++;
Radek Krejci33f72892019-02-21 10:36:58 +01006348 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006349
6350 /* [units-stmt] */
6351 if (d_rpl->units) {
6352 DEV_CHECK_NODETYPE(LYS_LEAF | LYS_LEAFLIST, "replace", "units");
6353 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, !(devs[u]->target->flags & LYS_SET_UNITS),
6354 units, "replacing", "units", d_rpl->units);
6355
6356 lydict_remove(ctx->ctx, ((struct lysc_node_leaf*)devs[u]->target)->units);
6357 DUP_STRING(ctx->ctx, d_rpl->units, ((struct lysc_node_leaf*)devs[u]->target)->units);
6358 }
6359
6360 /* [default-stmt] */
6361 if (d_rpl->dflt) {
6362 switch (devs[u]->target->nodetype) {
6363 case LYS_LEAF:
6364 DEV_CHECK_PRESENCE(struct lysc_node_leaf*, !(devs[u]->target->flags & LYS_SET_DFLT),
6365 dflt, "replacing", "default", d_rpl->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02006366 /* first, remove the default value taken from the type */
Radek Krejci474f9b82019-07-24 11:36:37 +02006367 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
Radek Krejcia1911222019-07-22 17:24:50 +02006368 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6369 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6370 dflt = d_rpl->dflt;
6371 /* parsing is done at the end after possible replace of the leaf's type */
Radek Krejciccd20f12019-02-15 14:12:27 +01006372 break;
6373 case LYS_CHOICE:
6374 DEV_CHECK_PRESENCE(struct lysc_node_choice*, 0, dflt, "replacing", "default", d_rpl->dflt);
Radek Krejci327de162019-06-14 12:52:07 +02006375 if (lys_compile_deviation_set_choice_dflt(ctx, d_rpl->dflt, (struct lysc_node_choice*)devs[u]->target)) {
Radek Krejciccd20f12019-02-15 14:12:27 +01006376 goto cleanup;
6377 }
6378 break;
6379 default:
6380 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci327de162019-06-14 12:52:07 +02006381 lys_nodetype2str(devs[u]->target->nodetype), "replace", "default");
Radek Krejciccd20f12019-02-15 14:12:27 +01006382 goto cleanup;
6383 }
6384 }
6385
6386 /* [config-stmt] */
Radek Krejci93dcc392019-02-19 10:43:38 +01006387 if (d_rpl->flags & LYS_CONFIG_MASK) {
6388 if (devs[u]->target->nodetype & (LYS_CASE | LYS_INOUT | LYS_ACTION | LYS_NOTIF)) {
Radek Krejci327de162019-06-14 12:52:07 +02006389 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci93dcc392019-02-19 10:43:38 +01006390 lys_nodetype2str(devs[u]->target->nodetype), "replace", "config");
6391 goto cleanup;
6392 }
6393 if (!(devs[u]->target->flags & LYS_SET_CONFIG)) {
Radek Krejci327de162019-06-14 12:52:07 +02006394 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
Radek Krejci93dcc392019-02-19 10:43:38 +01006395 "replacing", "config", d_rpl->flags & LYS_CONFIG_W ? "config true" : "config false");
6396 goto cleanup;
6397 }
Radek Krejci327de162019-06-14 12:52:07 +02006398 LY_CHECK_GOTO(lys_compile_change_config(ctx, devs[u]->target, d_rpl->flags, 0, 0), cleanup);
Radek Krejci93dcc392019-02-19 10:43:38 +01006399 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006400
6401 /* [mandatory-stmt] */
Radek Krejcif1421c22019-02-19 13:05:20 +01006402 if (d_rpl->flags & LYS_MAND_MASK) {
6403 if (!(devs[u]->target->flags & LYS_MAND_MASK)) {
Radek Krejci327de162019-06-14 12:52:07 +02006404 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NOT_PRESENT,
Radek Krejcif1421c22019-02-19 13:05:20 +01006405 "replacing", "mandatory", d_rpl->flags & LYS_MAND_TRUE ? "mandatory true" : "mandatory false");
6406 goto cleanup;
6407 }
Radek Krejci327de162019-06-14 12:52:07 +02006408 LY_CHECK_GOTO(lys_compile_change_mandatory(ctx, devs[u]->target, d_rpl->flags, 0), cleanup);
Radek Krejcif1421c22019-02-19 13:05:20 +01006409 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006410
6411 /* [min-elements-stmt] */
Radek Krejci551b12c2019-02-19 16:11:21 +01006412 if (d_rpl->flags & LYS_SET_MIN) {
6413 if (devs[u]->target->nodetype == LYS_LEAFLIST) {
6414 DEV_CHECK_PRESENCE_UINT(struct lysc_node_leaflist*, > 0, min, "min-elements");
6415 /* change value */
6416 ((struct lysc_node_leaflist*)devs[u]->target)->min = d_rpl->min;
6417 } else if (devs[u]->target->nodetype == LYS_LIST) {
6418 DEV_CHECK_PRESENCE_UINT(struct lysc_node_list*, > 0, min, "min-elements");
6419 /* change value */
6420 ((struct lysc_node_list*)devs[u]->target)->min = d_rpl->min;
6421 } else {
Radek Krejci327de162019-06-14 12:52:07 +02006422 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci551b12c2019-02-19 16:11:21 +01006423 lys_nodetype2str(devs[u]->target->nodetype), "replace", "min-elements");
6424 goto cleanup;
6425 }
6426 if (d_rpl->min) {
6427 devs[u]->target->flags |= LYS_MAND_TRUE;
6428 }
6429 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006430
6431 /* [max-elements-stmt] */
Radek Krejci551b12c2019-02-19 16:11:21 +01006432 if (d_rpl->flags & LYS_SET_MAX) {
6433 if (devs[u]->target->nodetype == LYS_LEAFLIST) {
6434 DEV_CHECK_PRESENCE_UINT(struct lysc_node_leaflist*, < (uint32_t)-1, max, "max-elements");
6435 /* change value */
6436 ((struct lysc_node_leaflist*)devs[u]->target)->max = d_rpl->max ? d_rpl->max : (uint32_t)-1;
6437 } else if (devs[u]->target->nodetype == LYS_LIST) {
6438 DEV_CHECK_PRESENCE_UINT(struct lysc_node_list*, < (uint32_t)-1, max, "max-elements");
6439 /* change value */
6440 ((struct lysc_node_list*)devs[u]->target)->max = d_rpl->max ? d_rpl->max : (uint32_t)-1;
6441 } else {
Radek Krejci327de162019-06-14 12:52:07 +02006442 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DEV_NODETYPE,
Radek Krejci551b12c2019-02-19 16:11:21 +01006443 lys_nodetype2str(devs[u]->target->nodetype), "replace", "max-elements");
6444 goto cleanup;
6445 }
6446 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006447
6448 break;
6449 default:
6450 LOGINT(ctx->ctx);
6451 goto cleanup;
6452 }
6453 }
Radek Krejci551b12c2019-02-19 16:11:21 +01006454
Radek Krejci33f72892019-02-21 10:36:58 +01006455 /* final check when all deviations of a single target node are applied */
6456
Radek Krejci551b12c2019-02-19 16:11:21 +01006457 /* check min-max compatibility */
6458 if (devs[u]->target->nodetype == LYS_LEAFLIST) {
6459 min = ((struct lysc_node_leaflist*)devs[u]->target)->min;
6460 max = ((struct lysc_node_leaflist*)devs[u]->target)->max;
6461 } else if (devs[u]->target->nodetype == LYS_LIST) {
6462 min = ((struct lysc_node_list*)devs[u]->target)->min;
6463 max = ((struct lysc_node_list*)devs[u]->target)->max;
6464 } else {
6465 min = max = 0;
6466 }
6467 if (min > max) {
6468 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid combination of min-elements and max-elements "
Radek Krejci327de162019-06-14 12:52:07 +02006469 "after deviation: min value %u is bigger than max value %u.", min, max);
Radek Krejci551b12c2019-02-19 16:11:21 +01006470 goto cleanup;
6471 }
6472
Radek Krejcia1911222019-07-22 17:24:50 +02006473 if (dflt) {
6474 /* parse added/changed default value after possible change of the type */
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006475 leaf->dflt_mod = ctx->mod_def;
Radek Krejcia1911222019-07-22 17:24:50 +02006476 leaf->dflt->realtype = leaf->type;
Radek Krejci474f9b82019-07-24 11:36:37 +02006477 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, dflt, strlen(dflt),
6478 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02006479 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, devs[u]->target, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02006480 leaf->dflt->realtype->refcount++;
6481 if (err) {
6482 ly_err_print(err);
6483 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6484 "Invalid deviation setting \"default\" property \"%s\" which does not fit the type (%s).", dflt, err->msg);
6485 ly_err_free(err);
6486 }
Radek Krejci474f9b82019-07-24 11:36:37 +02006487 if (rc == LY_EINCOMPLETE) {
6488 /* postpone default compilation when the tree is complete */
6489 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, devs[u]->target, leaf->dflt, leaf->dflt_mod), cleanup);
6490
6491 /* but in general result is so far ok */
6492 rc = LY_SUCCESS;
6493 }
Radek Krejcia1911222019-07-22 17:24:50 +02006494 LY_CHECK_GOTO(rc, cleanup);
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006495 } else if (changed_type) {
Radek Krejcia1911222019-07-22 17:24:50 +02006496 /* the leaf/leaf-list's type has changed, but there is still a default value for the previous type */
6497 int dynamic;
6498 if (devs[u]->target->nodetype == LYS_LEAF) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006499 dflt = leaf->dflt->realtype->plugin->print(leaf->dflt, LYD_XML, lys_get_prefix, leaf->dflt_mod, &dynamic);
Radek Krejci474f9b82019-07-24 11:36:37 +02006500
6501 /* update the list of incomplete default values if needed */
6502 lysc_incomplete_dflts_remove(ctx, leaf->dflt);
6503
6504 /* remove the previous default */
Radek Krejcia1911222019-07-22 17:24:50 +02006505 leaf->dflt->realtype->plugin->free(ctx->ctx, leaf->dflt);
6506 lysc_type_free(ctx->ctx, leaf->dflt->realtype);
6507 leaf->dflt->realtype = leaf->type;
Radek Krejci474f9b82019-07-24 11:36:37 +02006508 rc = leaf->type->plugin->store(ctx->ctx, leaf->type, dflt, strlen(dflt),
6509 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02006510 lys_resolve_prefix, (void*)leaf->dflt_mod, LYD_XML, devs[u]->target, NULL, leaf->dflt, NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02006511 leaf->dflt->realtype->refcount++;
6512 if (err) {
6513 ly_err_print(err);
6514 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6515 "Invalid deviation replacing leaf's type - the leaf's default value \"%s\" does not match the type (%s).", dflt, err->msg);
6516 ly_err_free(err);
6517 }
6518 if (dynamic) {
6519 free((void*)dflt);
6520 }
Radek Krejcia1911222019-07-22 17:24:50 +02006521 dflt = NULL;
Radek Krejci474f9b82019-07-24 11:36:37 +02006522 if (rc == LY_EINCOMPLETE) {
6523 /* postpone default compilation when the tree is complete */
6524 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, devs[u]->target, leaf->dflt, leaf->dflt_mod), cleanup);
6525
6526 /* but in general result is so far ok */
6527 rc = LY_SUCCESS;
6528 }
6529 LY_CHECK_GOTO(rc, cleanup);
Radek Krejcia1911222019-07-22 17:24:50 +02006530 } else { /* LYS_LEAFLIST */
6531 LY_ARRAY_FOR(llist->dflts, x) {
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006532 dflt = llist->dflts[x]->realtype->plugin->print(llist->dflts[x], LYD_XML, lys_get_prefix, llist->dflts_mods[x], &dynamic);
Radek Krejcia1911222019-07-22 17:24:50 +02006533 llist->dflts[x]->realtype->plugin->free(ctx->ctx, llist->dflts[x]);
6534 lysc_type_free(ctx->ctx, llist->dflts[x]->realtype);
6535 llist->dflts[x]->realtype = llist->type;
Radek Krejci474f9b82019-07-24 11:36:37 +02006536 rc = llist->type->plugin->store(ctx->ctx, llist->type, dflt, strlen(dflt),
6537 LY_TYPE_OPTS_INCOMPLETE_DATA | LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE,
Radek Krejci1c0c3442019-07-23 16:08:47 +02006538 lys_resolve_prefix, (void*)llist->dflts_mods[x], LYD_XML, devs[u]->target, NULL,
6539 llist->dflts[x], NULL, &err);
Radek Krejcia1911222019-07-22 17:24:50 +02006540 llist->dflts[x]->realtype->refcount++;
6541 if (err) {
6542 ly_err_print(err);
6543 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
6544 "Invalid deviation replacing leaf-list's type - the leaf-list's default value \"%s\" does not match the type (%s).",
6545 dflt, err->msg);
6546 ly_err_free(err);
6547 }
6548 if (dynamic) {
6549 free((void*)dflt);
6550 }
Radek Krejcid0ef1af2019-07-23 12:22:05 +02006551 dflt = NULL;
Radek Krejci474f9b82019-07-24 11:36:37 +02006552 if (rc == LY_EINCOMPLETE) {
6553 /* postpone default compilation when the tree is complete */
6554 LY_CHECK_GOTO(lysc_incomplete_dflts_add(ctx, devs[u]->target, llist->dflts[x], llist->dflts_mods[x]), cleanup);
6555
6556 /* but in general result is so far ok */
6557 rc = LY_SUCCESS;
6558 }
Radek Krejcia1911222019-07-22 17:24:50 +02006559 LY_CHECK_GOTO(rc, cleanup);
6560 }
6561 }
6562 }
6563
Radek Krejci551b12c2019-02-19 16:11:21 +01006564 /* check mandatory - default compatibility */
6565 if ((devs[u]->target->nodetype & (LYS_LEAF | LYS_LEAFLIST))
6566 && (devs[u]->target->flags & LYS_SET_DFLT)
6567 && (devs[u]->target->flags & LYS_MAND_TRUE)) {
6568 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02006569 "Invalid deviation combining default value and mandatory %s.", lys_nodetype2str(devs[u]->target->nodetype));
Radek Krejci551b12c2019-02-19 16:11:21 +01006570 goto cleanup;
6571 } else if ((devs[u]->target->nodetype & LYS_CHOICE)
6572 && ((struct lysc_node_choice*)devs[u]->target)->dflt
6573 && (devs[u]->target->flags & LYS_MAND_TRUE)) {
Radek Krejci327de162019-06-14 12:52:07 +02006574 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS, "Invalid deviation combining default case and mandatory choice.");
Radek Krejci551b12c2019-02-19 16:11:21 +01006575 goto cleanup;
6576 }
6577 if (devs[u]->target->parent && (devs[u]->target->parent->flags & LYS_SET_DFLT) && (devs[u]->target->flags & LYS_MAND_TRUE)) {
6578 /* mandatory node under a default case */
6579 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SEMANTICS,
Radek Krejci327de162019-06-14 12:52:07 +02006580 "Invalid deviation combining mandatory %s \"%s\" in a default choice's case \"%s\".",
6581 lys_nodetype2str(devs[u]->target->nodetype), devs[u]->target->name, devs[u]->target->parent->name);
Radek Krejci551b12c2019-02-19 16:11:21 +01006582 goto cleanup;
6583 }
Radek Krejci33f72892019-02-21 10:36:58 +01006584
Radek Krejci327de162019-06-14 12:52:07 +02006585 lysc_update_path(ctx, NULL, NULL);
Radek Krejciccd20f12019-02-15 14:12:27 +01006586 }
6587
Radek Krejci327de162019-06-14 12:52:07 +02006588 lysc_update_path(ctx, NULL, NULL);
Radek Krejciccd20f12019-02-15 14:12:27 +01006589 ret = LY_SUCCESS;
6590
6591cleanup:
6592 for (u = 0; u < devs_p.count && devs[u]; ++u) {
6593 LY_ARRAY_FREE(devs[u]->deviates);
6594 free(devs[u]);
6595 }
6596 free(devs);
6597 ly_set_erase(&targets, NULL);
6598 ly_set_erase(&devs_p, NULL);
6599
6600 return ret;
6601}
6602
Radek Krejcib56c7502019-02-13 14:19:54 +01006603/**
Radek Krejcid05cbd92018-12-05 14:26:40 +01006604 * @brief Compile the given YANG submodule into the main module.
6605 * @param[in] ctx Compile context
6606 * @param[in] inc Include structure from the main module defining the submodule.
Radek Krejcid05cbd92018-12-05 14:26:40 +01006607 * @return LY_ERR value - LY_SUCCESS or LY_EVALID.
6608 */
6609LY_ERR
Radek Krejciec4da802019-05-02 13:02:41 +02006610lys_compile_submodule(struct lysc_ctx *ctx, struct lysp_include *inc)
Radek Krejcid05cbd92018-12-05 14:26:40 +01006611{
6612 unsigned int u;
6613 LY_ERR ret = LY_SUCCESS;
6614 /* shortcuts */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01006615 struct lysp_submodule *submod = inc->submodule;
Radek Krejcid05cbd92018-12-05 14:26:40 +01006616 struct lysc_module *mainmod = ctx->mod->compiled;
Radek Krejci474f9b82019-07-24 11:36:37 +02006617 struct lysp_node *node_p;
Radek Krejcid05cbd92018-12-05 14:26:40 +01006618
Radek Krejci0af46292019-01-11 16:02:31 +01006619 if (!mainmod->mod->off_features) {
6620 /* features are compiled directly into the compiled module structure,
6621 * but it must be done in two steps to allow forward references (via if-feature) between the features themselves.
6622 * The features compilation is finished in the main module (lys_compile()). */
Radek Krejci0935f412019-08-20 16:15:18 +02006623 ret = lys_feature_precompile(ctx, NULL, NULL, submod->features, &mainmod->features);
6624 LY_CHECK_GOTO(ret, error);
6625 }
6626 if (!mainmod->mod->off_extensions) {
6627 /* extensions are compiled directly into the compiled module structure, compilation is finished in the main module (lys_compile()). */
6628 ret = lys_extension_precompile(ctx, NULL, NULL, submod->extensions, &mainmod->extensions);
Radek Krejci0af46292019-01-11 16:02:31 +01006629 LY_CHECK_GOTO(ret, error);
6630 }
6631
Radek Krejci327de162019-06-14 12:52:07 +02006632 lysc_update_path(ctx, NULL, "{identity}");
Radek Krejciec4da802019-05-02 13:02:41 +02006633 COMPILE_ARRAY_UNIQUE_GOTO(ctx, submod->identities, mainmod->identities, u, lys_compile_identity, ret, error);
Radek Krejci327de162019-06-14 12:52:07 +02006634 lysc_update_path(ctx, NULL, NULL);
Radek Krejcid05cbd92018-12-05 14:26:40 +01006635
Radek Krejci474f9b82019-07-24 11:36:37 +02006636 /* data nodes */
6637 LY_LIST_FOR(submod->data, node_p) {
6638 ret = lys_compile_node(ctx, node_p, NULL, 0);
6639 LY_CHECK_GOTO(ret, error);
6640 }
Radek Krejci8cce8532019-03-05 11:27:45 +01006641
Radek Krejciec4da802019-05-02 13:02:41 +02006642 COMPILE_ARRAY1_GOTO(ctx, submod->rpcs, mainmod->rpcs, NULL, u, lys_compile_action, 0, ret, error);
6643 COMPILE_ARRAY1_GOTO(ctx, submod->notifs, mainmod->notifs, NULL, u, lys_compile_notif, 0, ret, error);
Radek Krejci8cce8532019-03-05 11:27:45 +01006644
Radek Krejcid05cbd92018-12-05 14:26:40 +01006645error:
6646 return ret;
6647}
6648
Radek Krejci335332a2019-09-05 13:03:35 +02006649static void *
6650lys_compile_extension_instance_storage(enum ly_stmt stmt, struct lysc_ext_substmt *substmts)
6651{
6652 for (unsigned int u = 0; substmts[u].stmt; ++u) {
6653 if (substmts[u].stmt == stmt) {
6654 return substmts[u].storage;
6655 }
6656 }
6657 return NULL;
6658}
6659
6660LY_ERR
6661lys_compile_extension_instance(struct lysc_ctx *ctx, const struct lysp_ext_instance *ext, struct lysc_ext_substmt *substmts)
6662{
6663 LY_ERR ret = LY_EVALID, r;
6664 unsigned int u;
6665 struct lysp_stmt *stmt;
6666 void *parsed = NULL, **compiled = NULL;
Radek Krejci335332a2019-09-05 13:03:35 +02006667
6668 /* check for invalid substatements */
6669 for (stmt = ext->child; stmt; stmt = stmt->next) {
6670 for (u = 0; substmts[u].stmt; ++u) {
6671 if (substmts[u].stmt == stmt->kw) {
6672 break;
6673 }
6674 }
6675 if (!substmts[u].stmt) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006676 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s%s%s\" extension instance.",
6677 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
Radek Krejci335332a2019-09-05 13:03:35 +02006678 goto cleanup;
6679 }
Radek Krejci335332a2019-09-05 13:03:35 +02006680 }
6681
Radek Krejciad5963b2019-09-06 16:03:05 +02006682 /* TODO store inherited data, e.g. status first, but mark them somehow to allow to overwrite them and not detect duplicity */
6683
Radek Krejci335332a2019-09-05 13:03:35 +02006684 /* keep order of the processing the same as the order in the defined substmts,
6685 * the order is important for some of the statements depending on others (e.g. type needs status and units) */
6686 for (u = 0; substmts[u].stmt; ++u) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006687 int stmt_present = 0;
6688
Radek Krejci335332a2019-09-05 13:03:35 +02006689 for (stmt = ext->child; stmt; stmt = stmt->next) {
6690 if (substmts[u].stmt != stmt->kw) {
6691 continue;
6692 }
6693
Radek Krejciad5963b2019-09-06 16:03:05 +02006694 stmt_present = 1;
Radek Krejci335332a2019-09-05 13:03:35 +02006695 if (substmts[u].storage) {
6696 switch (stmt->kw) {
Radek Krejciad5963b2019-09-06 16:03:05 +02006697 case LY_STMT_STATUS:
6698 assert(substmts[u].cardinality < LY_STMT_CARD_SOME);
6699 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &substmts[u].storage, /* TODO */ NULL), ret = r, cleanup);
6700 break;
6701 case LY_STMT_UNITS: {
6702 const char **units;
6703
6704 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6705 /* single item */
6706 if (*((const char **)substmts[u].storage)) {
6707 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6708 goto cleanup;
6709 }
6710 units = (const char **)substmts[u].storage;
6711 } else {
6712 /* sized array */
6713 const char ***units_array = (const char ***)substmts[u].storage;
6714 LY_ARRAY_NEW_GOTO(ctx->ctx, *units_array, units, ret, cleanup);
6715 }
6716 *units = lydict_insert(ctx->ctx, stmt->arg, 0);
6717 break;
6718 }
Radek Krejci335332a2019-09-05 13:03:35 +02006719 case LY_STMT_TYPE: {
6720 uint16_t *flags = lys_compile_extension_instance_storage(LY_STMT_STATUS, substmts);
6721 const char **units = lys_compile_extension_instance_storage(LY_STMT_UNITS, substmts);
6722
6723 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6724 /* single item */
Radek Krejciad5963b2019-09-06 16:03:05 +02006725 if (*(struct lysc_type**)substmts[u].storage) {
Radek Krejci335332a2019-09-05 13:03:35 +02006726 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6727 goto cleanup;
6728 }
6729 compiled = substmts[u].storage;
6730 } else {
6731 /* sized array */
6732 struct lysc_type ***types = (struct lysc_type***)substmts[u].storage, **type = NULL;
6733 LY_ARRAY_NEW_GOTO(ctx->ctx, *types, type, ret, cleanup);
6734 compiled = (void*)type;
6735 }
6736
Radek Krejciad5963b2019-09-06 16:03:05 +02006737 LY_CHECK_ERR_GOTO(r = lysp_stmt_parse(ctx, stmt, stmt->kw, &parsed, NULL), ret = r, cleanup);
Radek Krejci335332a2019-09-05 13:03:35 +02006738 LY_CHECK_ERR_GOTO(r = lys_compile_type(ctx, ext->parent_type == LYEXT_PAR_NODE ? ((struct lysc_node*)ext->parent)->sp : NULL,
6739 flags ? *flags : 0, ctx->mod_def->parsed, ext->name, parsed, (struct lysc_type**)compiled,
Radek Krejci38d85362019-09-05 16:26:38 +02006740 units && !*units ? units : NULL), lysp_type_free(ctx->ctx, parsed); free(parsed); ret = r, cleanup);
6741 lysp_type_free(ctx->ctx, parsed);
6742 free(parsed);
Radek Krejci335332a2019-09-05 13:03:35 +02006743 break;
6744 }
Radek Krejciad5963b2019-09-06 16:03:05 +02006745 case LY_STMT_IF_FEATURE: {
6746 struct lysc_iffeature *iff = NULL;
6747
6748 if (substmts[u].cardinality < LY_STMT_CARD_SOME) {
6749 /* single item */
6750 if (((struct lysc_iffeature*)substmts[u].storage)->features) {
6751 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LY_VCODE_DUPSTMT, stmt->stmt);
6752 goto cleanup;
6753 }
6754 iff = (struct lysc_iffeature*)substmts[u].storage;
6755 } else {
6756 /* sized array */
6757 struct lysc_iffeature **iffs = (struct lysc_iffeature**)substmts[u].storage;
6758 LY_ARRAY_NEW_GOTO(ctx->ctx, *iffs, iff, ret, cleanup);
6759 }
6760 LY_CHECK_ERR_GOTO(r = lys_compile_iffeature(ctx, &stmt->arg, iff), ret = r, cleanup);
6761 break;
6762 }
6763 /* TODO support other substatements (parse stmt to lysp and then compile lysp to lysc),
6764 * also note that in many statements their extensions are not taken into account */
Radek Krejci335332a2019-09-05 13:03:35 +02006765 default:
Radek Krejciad5963b2019-09-06 16:03:05 +02006766 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Statement \"%s\" is not supported as an extension (found in \"%s%s%s\") substatement.",
6767 stmt->stmt, ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
Radek Krejci335332a2019-09-05 13:03:35 +02006768 goto cleanup;
6769 }
6770 }
Radek Krejci335332a2019-09-05 13:03:35 +02006771 }
Radek Krejci335332a2019-09-05 13:03:35 +02006772
Radek Krejciad5963b2019-09-06 16:03:05 +02006773 if ((substmts[u].cardinality == LY_STMT_CARD_MAND || substmts[u].cardinality == LY_STMT_CARD_SOME) && !stmt_present) {
6774 LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s%s%s\".",
6775 ly_stmt2str(substmts[u].stmt), ext->name, ext->argument ? " " : "", ext->argument ? ext->argument : "");
6776 goto cleanup;
6777 }
Radek Krejci335332a2019-09-05 13:03:35 +02006778 }
6779
6780 ret = LY_SUCCESS;
6781
6782cleanup:
Radek Krejci335332a2019-09-05 13:03:35 +02006783 return ret;
6784}
6785
Radek Krejci19a96102018-11-15 13:38:09 +01006786LY_ERR
6787lys_compile(struct lys_module *mod, int options)
6788{
6789 struct lysc_ctx ctx = {0};
6790 struct lysc_module *mod_c;
Radek Krejci412ddfa2018-11-23 11:44:11 +01006791 struct lysc_type *type, *typeiter;
Radek Krejci19a96102018-11-15 13:38:09 +01006792 struct lysp_module *sp;
6793 struct lysp_node *node_p;
Radek Krejci95710c92019-02-11 15:49:55 +01006794 struct lysp_augment **augments = NULL;
Radek Krejcif2de0ed2019-05-02 14:13:18 +02006795 struct lysp_grp *grps;
Radek Krejci95710c92019-02-11 15:49:55 +01006796 struct lys_module *m;
Radek Krejcicdfecd92018-11-26 11:27:32 +01006797 unsigned int u, v;
Radek Krejcid05cbd92018-12-05 14:26:40 +01006798 LY_ERR ret = LY_SUCCESS;
Radek Krejci19a96102018-11-15 13:38:09 +01006799
Radek Krejci0bcdaed2019-01-10 10:21:34 +01006800 LY_CHECK_ARG_RET(NULL, mod, mod->parsed, mod->ctx, LY_EINVAL);
Radek Krejci096235c2019-01-11 11:12:19 +01006801
6802 if (!mod->implemented) {
6803 /* just imported modules are not compiled */
6804 return LY_SUCCESS;
6805 }
6806
Radek Krejci19a96102018-11-15 13:38:09 +01006807 sp = mod->parsed;
6808
Radek Krejci0bcdaed2019-01-10 10:21:34 +01006809 ctx.ctx = mod->ctx;
Radek Krejci19a96102018-11-15 13:38:09 +01006810 ctx.mod = mod;
Radek Krejcie86bf772018-12-14 11:39:53 +01006811 ctx.mod_def = mod;
Radek Krejciec4da802019-05-02 13:02:41 +02006812 ctx.options = options;
Radek Krejci327de162019-06-14 12:52:07 +02006813 ctx.path_len = 1;
6814 ctx.path[0] = '/';
Radek Krejci19a96102018-11-15 13:38:09 +01006815
6816 mod->compiled = mod_c = calloc(1, sizeof *mod_c);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01006817 LY_CHECK_ERR_RET(!mod_c, LOGMEM(mod->ctx), LY_EMEM);
6818 mod_c->mod = mod;
Radek Krejci19a96102018-11-15 13:38:09 +01006819
Radek Krejciec4da802019-05-02 13:02:41 +02006820 COMPILE_ARRAY_GOTO(&ctx, sp->imports, mod_c->imports, u, lys_compile_import, ret, error);
Radek Krejcid05cbd92018-12-05 14:26:40 +01006821 LY_ARRAY_FOR(sp->includes, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02006822 ret = lys_compile_submodule(&ctx, &sp->includes[u]);
Radek Krejcid05cbd92018-12-05 14:26:40 +01006823 LY_CHECK_GOTO(ret != LY_SUCCESS, error);
6824 }
Radek Krejci0935f412019-08-20 16:15:18 +02006825
6826 /* features */
Radek Krejci0af46292019-01-11 16:02:31 +01006827 if (mod->off_features) {
6828 /* there is already precompiled array of features */
6829 mod_c->features = mod->off_features;
6830 mod->off_features = NULL;
Radek Krejci0af46292019-01-11 16:02:31 +01006831 } else {
6832 /* features are compiled directly into the compiled module structure,
6833 * but it must be done in two steps to allow forward references (via if-feature) between the features themselves */
Radek Krejci327de162019-06-14 12:52:07 +02006834 ret = lys_feature_precompile(&ctx, NULL, NULL, sp->features, &mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01006835 LY_CHECK_GOTO(ret, error);
6836 }
6837 /* finish feature compilation, not only for the main module, but also for the submodules.
6838 * Due to possible forward references, it must be done when all the features (including submodules)
6839 * are present. */
6840 LY_ARRAY_FOR(sp->features, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02006841 ret = lys_feature_precompile_finish(&ctx, &sp->features[u], mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01006842 LY_CHECK_GOTO(ret != LY_SUCCESS, error);
6843 }
Radek Krejci327de162019-06-14 12:52:07 +02006844 lysc_update_path(&ctx, NULL, "{submodule}");
Radek Krejci0af46292019-01-11 16:02:31 +01006845 LY_ARRAY_FOR(sp->includes, v) {
Radek Krejci327de162019-06-14 12:52:07 +02006846 lysc_update_path(&ctx, NULL, sp->includes[v].name);
Radek Krejci0af46292019-01-11 16:02:31 +01006847 LY_ARRAY_FOR(sp->includes[v].submodule->features, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02006848 ret = lys_feature_precompile_finish(&ctx, &sp->includes[v].submodule->features[u], mod_c->features);
Radek Krejci0af46292019-01-11 16:02:31 +01006849 LY_CHECK_GOTO(ret != LY_SUCCESS, error);
6850 }
Radek Krejci327de162019-06-14 12:52:07 +02006851 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01006852 }
Radek Krejci327de162019-06-14 12:52:07 +02006853 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci0af46292019-01-11 16:02:31 +01006854
Radek Krejci0935f412019-08-20 16:15:18 +02006855 /* extensions */
6856 /* 2-steps: a) prepare compiled structures and ... */
6857 if (mod->off_extensions) {
6858 /* there is already precompiled array of extension definitions */
6859 mod_c->extensions = mod->off_extensions;
6860 mod->off_extensions = NULL;
6861 } else {
6862 /* extension definitions are compiled directly into the compiled module structure */
6863 ret = lys_extension_precompile(&ctx, NULL, NULL, sp->extensions, &mod_c->extensions);
6864 }
6865 /* ... b) connect the extension definitions with the appropriate extension plugins */
6866 lys_compile_extension_plugins(mod_c->extensions);
6867
6868 /* identities */
Radek Krejci327de162019-06-14 12:52:07 +02006869 lysc_update_path(&ctx, NULL, "{identity}");
Radek Krejciec4da802019-05-02 13:02:41 +02006870 COMPILE_ARRAY_UNIQUE_GOTO(&ctx, sp->identities, mod_c->identities, u, lys_compile_identity, ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01006871 if (sp->identities) {
6872 LY_CHECK_RET(lys_compile_identities_derived(&ctx, sp->identities, mod_c->identities));
6873 }
Radek Krejci327de162019-06-14 12:52:07 +02006874 lysc_update_path(&ctx, NULL, NULL);
Radek Krejci19a96102018-11-15 13:38:09 +01006875
Radek Krejci95710c92019-02-11 15:49:55 +01006876 /* data nodes */
Radek Krejci19a96102018-11-15 13:38:09 +01006877 LY_LIST_FOR(sp->data, node_p) {
Radek Krejciec4da802019-05-02 13:02:41 +02006878 ret = lys_compile_node(&ctx, node_p, NULL, 0);
Radek Krejci19a96102018-11-15 13:38:09 +01006879 LY_CHECK_GOTO(ret, error);
6880 }
Radek Krejci95710c92019-02-11 15:49:55 +01006881
Radek Krejciec4da802019-05-02 13:02:41 +02006882 COMPILE_ARRAY1_GOTO(&ctx, sp->rpcs, mod_c->rpcs, NULL, u, lys_compile_action, 0, ret, error);
6883 COMPILE_ARRAY1_GOTO(&ctx, sp->notifs, mod_c->notifs, NULL, u, lys_compile_notif, 0, ret, error);
Radek Krejciccd20f12019-02-15 14:12:27 +01006884
Radek Krejci95710c92019-02-11 15:49:55 +01006885 /* augments - sort first to cover augments augmenting other augments */
Radek Krejci3641f562019-02-13 15:38:40 +01006886 ret = lys_compile_augment_sort(&ctx, sp->augments, sp->includes, &augments);
Radek Krejci95710c92019-02-11 15:49:55 +01006887 LY_CHECK_GOTO(ret, error);
6888 LY_ARRAY_FOR(augments, u) {
Radek Krejciec4da802019-05-02 13:02:41 +02006889 ret = lys_compile_augment(&ctx, augments[u], NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01006890 LY_CHECK_GOTO(ret, error);
6891 }
Radek Krejciccd20f12019-02-15 14:12:27 +01006892
Radek Krejci474f9b82019-07-24 11:36:37 +02006893 /* deviations TODO cover deviations from submodules */
Radek Krejciec4da802019-05-02 13:02:41 +02006894 ret = lys_compile_deviations(&ctx, sp);
Radek Krejciccd20f12019-02-15 14:12:27 +01006895 LY_CHECK_GOTO(ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01006896
Radek Krejci0935f412019-08-20 16:15:18 +02006897 /* extension instances TODO cover extension instances from submodules */
6898 COMPILE_EXTS_GOTO(&ctx, sp->exts, mod_c->exts, mod_c, LYEXT_PAR_MODULE, ret, error);
Radek Krejci19a96102018-11-15 13:38:09 +01006899
Radek Krejcia3045382018-11-22 14:30:31 +01006900 /* validate leafref's paths and when/must xpaths */
Radek Krejci412ddfa2018-11-23 11:44:11 +01006901 /* for leafref, we need 2 rounds - first detects circular chain by storing the first referred type (which
6902 * can be also leafref, in case it is already resolved, go through the chain and check that it does not
6903 * point to the starting leafref type). The second round stores the first non-leafref type for later data validation. */
Radek Krejcia3045382018-11-22 14:30:31 +01006904 for (u = 0; u < ctx.unres.count; ++u) {
Radek Krejci0e5d8382018-11-28 16:37:53 +01006905 if (((struct lysc_node*)ctx.unres.objs[u])->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
Radek Krejcia3045382018-11-22 14:30:31 +01006906 type = ((struct lysc_node_leaf*)ctx.unres.objs[u])->type;
6907 if (type->basetype == LY_TYPE_LEAFREF) {
6908 /* validate the path */
Radek Krejci412ddfa2018-11-23 11:44:11 +01006909 ret = lys_compile_leafref_validate(&ctx, ((struct lysc_node*)ctx.unres.objs[u]), (struct lysc_type_leafref*)type);
Radek Krejcia3045382018-11-22 14:30:31 +01006910 LY_CHECK_GOTO(ret, error);
Radek Krejcicdfecd92018-11-26 11:27:32 +01006911 } else if (type->basetype == LY_TYPE_UNION) {
6912 LY_ARRAY_FOR(((struct lysc_type_union*)type)->types, v) {
6913 if (((struct lysc_type_union*)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
6914 /* validate the path */
6915 ret = lys_compile_leafref_validate(&ctx, ((struct lysc_node*)ctx.unres.objs[u]),
6916 (struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v]);
6917 LY_CHECK_GOTO(ret, error);
6918 }
6919 }
Radek Krejcia3045382018-11-22 14:30:31 +01006920 }
6921 }
6922 }
Radek Krejci412ddfa2018-11-23 11:44:11 +01006923 for (u = 0; u < ctx.unres.count; ++u) {
Radek Krejci0e5d8382018-11-28 16:37:53 +01006924 if (((struct lysc_node*)ctx.unres.objs[u])->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
Radek Krejci412ddfa2018-11-23 11:44:11 +01006925 type = ((struct lysc_node_leaf*)ctx.unres.objs[u])->type;
6926 if (type->basetype == LY_TYPE_LEAFREF) {
6927 /* store pointer to the real type */
6928 for (typeiter = ((struct lysc_type_leafref*)type)->realtype;
6929 typeiter->basetype == LY_TYPE_LEAFREF;
6930 typeiter = ((struct lysc_type_leafref*)typeiter)->realtype);
6931 ((struct lysc_type_leafref*)type)->realtype = typeiter;
Radek Krejcicdfecd92018-11-26 11:27:32 +01006932 } else if (type->basetype == LY_TYPE_UNION) {
6933 LY_ARRAY_FOR(((struct lysc_type_union*)type)->types, v) {
6934 if (((struct lysc_type_union*)type)->types[v]->basetype == LY_TYPE_LEAFREF) {
6935 /* store pointer to the real type */
6936 for (typeiter = ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype;
6937 typeiter->basetype == LY_TYPE_LEAFREF;
6938 typeiter = ((struct lysc_type_leafref*)typeiter)->realtype);
6939 ((struct lysc_type_leafref*)((struct lysc_type_union*)type)->types[v])->realtype = typeiter;
6940 }
6941 }
Radek Krejci412ddfa2018-11-23 11:44:11 +01006942 }
6943 }
6944 }
Radek Krejciec4da802019-05-02 13:02:41 +02006945
Radek Krejci474f9b82019-07-24 11:36:37 +02006946 /* finish incomplete default values compilation */
6947 for (u = 0; u < ctx.dflts.count; ++u) {
6948 struct ly_err_item *err = NULL;
6949 struct lysc_incomplete_dflt *r = ctx.dflts.objs[u];
6950 ret = r->dflt->realtype->plugin->store(ctx.ctx, r->dflt->realtype, r->dflt->canonized, strlen(r->dflt->canonized),
6951 LY_TYPE_OPTS_SCHEMA | LY_TYPE_OPTS_STORE | LY_TYPE_OPTS_SECOND_CALL, lys_resolve_prefix,
6952 (void*)r->dflt_mod, LYD_XML, r->context_node, NULL, r->dflt, NULL, &err);
6953 if (err) {
6954 ly_err_print(err);
6955 ctx.path[0] = '\0';
6956 lysc_path(r->context_node, LY_PATH_LOG, ctx.path, LYSC_CTX_BUFSIZE);
6957 LOGVAL(ctx.ctx, LY_VLOG_STR, ctx.path, LYVE_SEMANTICS,
6958 "Invalid default - value does not fit the type (%s).", err->msg);
6959 ly_err_free(err);
6960 }
6961 LY_CHECK_GOTO(ret, error);
6962 }
6963
Radek Krejcif2de0ed2019-05-02 14:13:18 +02006964 /* validate non-instantiated groupings from the parsed schema,
6965 * without it we would accept even the schemas with invalid grouping specification */
6966 ctx.options |= LYSC_OPT_GROUPING;
6967 LY_ARRAY_FOR(sp->groupings, u) {
6968 if (!(sp->groupings[u].flags & LYS_USED_GRP)) {
6969 LY_CHECK_GOTO((ret = lys_compile_grouping(&ctx, node_p, &sp->groupings[u])) != LY_SUCCESS, error);
6970 }
6971 }
6972 LY_LIST_FOR(sp->data, node_p) {
6973 grps = (struct lysp_grp*)lysp_node_groupings(node_p);
6974 LY_ARRAY_FOR(grps, u) {
6975 if (!(grps[u].flags & LYS_USED_GRP)) {
6976 LY_CHECK_GOTO((ret = lys_compile_grouping(&ctx, node_p, &grps[u])) != LY_SUCCESS, error);
6977 }
6978 }
6979 }
6980
Radek Krejci474f9b82019-07-24 11:36:37 +02006981 if (ctx.ctx->flags & LY_CTX_CHANGED_TREE) {
6982 /* TODO Deviation has changed tree of a module(s) in the context (by deviate-not-supported), it is necessary to recompile
6983 leafref paths, default values and must/when expressions in all schemas of the context to check that they are still valid */
6984 }
6985
Radek Krejci1c0c3442019-07-23 16:08:47 +02006986 ly_set_erase(&ctx.dflts, free);
Radek Krejcia3045382018-11-22 14:30:31 +01006987 ly_set_erase(&ctx.unres, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01006988 ly_set_erase(&ctx.groupings, NULL);
Radek Krejci99b5b2a2019-04-30 16:57:04 +02006989 ly_set_erase(&ctx.tpdf_chain, NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01006990 LY_ARRAY_FREE(augments);
Radek Krejcia3045382018-11-22 14:30:31 +01006991
Radek Krejciec4da802019-05-02 13:02:41 +02006992 if (ctx.options & LYSC_OPT_FREE_SP) {
Radek Krejci19a96102018-11-15 13:38:09 +01006993 lysp_module_free(mod->parsed);
6994 ((struct lys_module*)mod)->parsed = NULL;
6995 }
6996
Radek Krejciec4da802019-05-02 13:02:41 +02006997 if (!(ctx.options & LYSC_OPT_INTERNAL)) {
Radek Krejci95710c92019-02-11 15:49:55 +01006998 /* remove flag of the modules implemented by dependency */
6999 for (u = 0; u < ctx.ctx->list.count; ++u) {
7000 m = ctx.ctx->list.objs[u];
7001 if (m->implemented == 2) {
7002 m->implemented = 1;
7003 }
7004 }
7005 }
7006
Radek Krejci19a96102018-11-15 13:38:09 +01007007 ((struct lys_module*)mod)->compiled = mod_c;
7008 return LY_SUCCESS;
7009
7010error:
Radek Krejci95710c92019-02-11 15:49:55 +01007011 lys_feature_precompile_revert(&ctx, mod);
Radek Krejci1c0c3442019-07-23 16:08:47 +02007012 ly_set_erase(&ctx.dflts, free);
Radek Krejcia3045382018-11-22 14:30:31 +01007013 ly_set_erase(&ctx.unres, NULL);
Radek Krejcie86bf772018-12-14 11:39:53 +01007014 ly_set_erase(&ctx.groupings, NULL);
Radek Krejci99b5b2a2019-04-30 16:57:04 +02007015 ly_set_erase(&ctx.tpdf_chain, NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01007016 LY_ARRAY_FREE(augments);
Radek Krejci19a96102018-11-15 13:38:09 +01007017 lysc_module_free(mod_c, NULL);
Radek Krejci95710c92019-02-11 15:49:55 +01007018 mod->compiled = NULL;
7019
7020 /* revert compilation of modules implemented by dependency */
7021 for (u = 0; u < ctx.ctx->list.count; ++u) {
7022 m = ctx.ctx->list.objs[u];
7023 if (m->implemented == 2) {
7024 /* revert features list to the precompiled state */
7025 lys_feature_precompile_revert(&ctx, m);
7026 /* mark module as imported-only / not-implemented */
7027 m->implemented = 0;
7028 /* free the compiled version of the module */
7029 lysc_module_free(m->compiled, NULL);
7030 m->compiled = NULL;
7031 }
7032 }
7033
Radek Krejci19a96102018-11-15 13:38:09 +01007034 return ret;
7035}