blob: fc6843a3ab18a06340ff5963bbc4ab3a2ba01c88 [file] [log] [blame]
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001/**
2 * @file schema_features.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema feature handling
5 *
6 * Copyright (c) 2015 - 2020 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#define _GNU_SOURCE
16
17#include "schema_features.h"
18
19#include <assert.h>
20#include <ctype.h>
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010021#include <stdint.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010025
26#include "common.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010027#include "log.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010028#include "set.h"
29#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010030#include "tree_edit.h"
Radek Krejci47fab892020-11-05 17:02:41 +010031#include "tree_schema.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010032#include "tree_schema_internal.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010033
Radek Krejcif13b87b2020-12-01 22:02:17 +010034#define IFF_RECORDS_IN_BYTE 4
35#define IFF_RECORD_BITS 2
36#define IFF_RECORD_MASK 0x3
37
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010038uint8_t
39lysc_iff_getop(uint8_t *list, size_t pos)
40{
41 uint8_t *item;
Radek Krejcif13b87b2020-12-01 22:02:17 +010042 uint8_t mask = IFF_RECORD_MASK, result;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010043
Radek Krejcif13b87b2020-12-01 22:02:17 +010044 item = &list[pos / IFF_RECORDS_IN_BYTE];
45 result = (*item) & (mask << IFF_RECORD_BITS * (pos % IFF_RECORDS_IN_BYTE));
46 return result >> IFF_RECORD_BITS * (pos % IFF_RECORDS_IN_BYTE);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010047}
48
49static LY_ERR
50lysc_iffeature_value_(const struct lysc_iffeature *iff, size_t *index_e, size_t *index_f)
51{
52 uint8_t op;
53 LY_ERR a, b;
54
55 op = lysc_iff_getop(iff->expr, *index_e);
56 (*index_e)++;
57
58 switch (op) {
59 case LYS_IFF_F:
60 /* resolve feature */
61 return (iff->features[(*index_f)++]->flags & LYS_FENABLED) ? LY_SUCCESS : LY_ENOT;
62 case LYS_IFF_NOT:
63 /* invert result */
64 return lysc_iffeature_value_(iff, index_e, index_f) == LY_SUCCESS ? LY_ENOT : LY_SUCCESS;
65 case LYS_IFF_AND:
66 case LYS_IFF_OR:
67 a = lysc_iffeature_value_(iff, index_e, index_f);
68 b = lysc_iffeature_value_(iff, index_e, index_f);
69 if (op == LYS_IFF_AND) {
70 if ((a == LY_SUCCESS) && (b == LY_SUCCESS)) {
71 return LY_SUCCESS;
72 } else {
73 return LY_ENOT;
74 }
75 } else { /* LYS_IFF_OR */
76 if ((a == LY_SUCCESS) || (b == LY_SUCCESS)) {
77 return LY_SUCCESS;
78 } else {
79 return LY_ENOT;
80 }
81 }
82 }
83
84 return LY_ENOT;
85}
86
Jan Kundrátc6e39de2021-12-09 16:01:19 +010087LIBYANG_API_DEF LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010088lysc_iffeature_value(const struct lysc_iffeature *iff)
89{
90 size_t index_e = 0, index_f = 0;
91
92 LY_CHECK_ARG_RET(NULL, iff, LY_EINVAL);
93
94 if (iff->expr) {
95 return lysc_iffeature_value_(iff, &index_e, &index_f);
96 }
97 return LY_ENOT;
98}
99
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100100LIBYANG_API_DEF LY_ERR
aPiecekf4a0a192021-08-03 15:14:17 +0200101lys_identity_iffeature_value(const struct lysc_ident *ident)
102{
aPiecekf3e2db82021-08-05 10:18:43 +0200103 LY_ARRAY_COUNT_TYPE u, v;
aPiecekf4a0a192021-08-03 15:14:17 +0200104 ly_bool enabled;
aPiecekf3e2db82021-08-05 10:18:43 +0200105 const struct lysp_ident *idents_p, *found_ident = NULL;
106 struct lysp_include *includes;
aPiecekf4a0a192021-08-03 15:14:17 +0200107
108 assert(ident);
109
aPiecekf3e2db82021-08-05 10:18:43 +0200110 /* Search parsed identity in the module. */
aPiecekf4a0a192021-08-03 15:14:17 +0200111 idents_p = ident->module->parsed->identities;
112 LY_ARRAY_FOR(idents_p, u) {
113 if (idents_p[u].name == ident->name) {
aPiecekf3e2db82021-08-05 10:18:43 +0200114 found_ident = &idents_p[u];
aPiecekf4a0a192021-08-03 15:14:17 +0200115 break;
116 }
117 }
aPiecekf4a0a192021-08-03 15:14:17 +0200118
aPiecekf3e2db82021-08-05 10:18:43 +0200119 if (!found_ident) {
120 /* It is not in the module, so it must be in some submodule. */
121 includes = ident->module->parsed->includes;
122 LY_ARRAY_FOR(includes, u) {
123 idents_p = includes[u].submodule->identities;
124 LY_ARRAY_FOR(idents_p, v) {
125 if (idents_p[v].name == ident->name) {
126 found_ident = &idents_p[v];
127 break;
128 }
129 }
130 }
131 }
132
133 assert(found_ident);
134
135 /* Evaluate its if-feature. */
136 LY_CHECK_RET(lys_eval_iffeatures(ident->module->ctx, found_ident->iffeatures, &enabled));
aPiecekf4a0a192021-08-03 15:14:17 +0200137 if (!enabled) {
138 return LY_ENOT;
139 }
140
141 return LY_SUCCESS;
142}
143
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100144LIBYANG_API_DEF struct lysp_feature *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100145lysp_feature_next(const struct lysp_feature *last, const struct lysp_module *pmod, uint32_t *idx)
146{
147 struct lysp_feature *features;
148
149 if (!*idx) {
150 /* module features */
151 features = pmod->features;
Radek Krejcic7d13e32020-12-09 12:32:24 +0100152 } else if ((*idx - 1) < LY_ARRAY_COUNT(pmod->includes)) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100153 /* submodule features */
154 features = pmod->includes[*idx - 1].submodule->features;
155 } else {
156 /* no more features */
157 return NULL;
158 }
159
160 /* get the next feature */
161 if (features && (!last || (&features[LY_ARRAY_COUNT(features) - 1] != last))) {
162 return !last ? &features[0] : (struct lysp_feature *)last + 1;
163 }
164
165 /* no more features in current (sub)module */
166 ++(*idx);
167 return lysp_feature_next(NULL, pmod, idx);
168}
169
170/**
171 * @brief Find a feature of the given name and referenced in the given module.
172 *
173 * @param[in] pmod Module where the feature was referenced (used to resolve prefix of the feature).
174 * @param[in] name Name of the feature including possible prefix.
175 * @param[in] len Length of the string representing the feature identifier in the name variable (mandatory!).
176 * @param[in] prefixed Whether the feature name can be prefixed.
177 * @return Pointer to the feature structure if found, NULL otherwise.
178 */
179static struct lysp_feature *
180lysp_feature_find(const struct lysp_module *pmod, const char *name, size_t len, ly_bool prefixed)
181{
182 const struct lys_module *mod;
183 const char *ptr;
184 struct lysp_feature *f = NULL;
185 uint32_t idx = 0;
186
187 assert(pmod);
188
189 if (prefixed && (ptr = ly_strnchr(name, ':', len))) {
190 /* we have a prefixed feature */
Radek Krejci8df109d2021-04-23 12:19:08 +0200191 mod = ly_resolve_prefix(pmod->mod->ctx, name, ptr - name, LY_VALUE_SCHEMA, (void *)pmod);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100192 LY_CHECK_RET(!mod, NULL);
193
194 pmod = mod->parsed;
195 len = len - (ptr - name) - 1;
196 name = ptr + 1;
197 }
198
Michal Vaskoecd94572020-12-03 14:15:58 +0100199 /* feature without prefix, look in main module and all submodules */
200 if (pmod->is_submod) {
201 pmod = pmod->mod->parsed;
202 }
203
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100204 /* we have the correct module, get the feature */
205 while ((f = lysp_feature_next(f, pmod, &idx))) {
206 if (!ly_strncmp(f->name, name, len)) {
207 return f;
208 }
209 }
210
211 return NULL;
212}
213
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100214LIBYANG_API_DEF LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100215lys_feature_value(const struct lys_module *module, const char *feature)
216{
217 const struct lysp_feature *f;
218
219 LY_CHECK_ARG_RET(NULL, module, module->parsed, feature, LY_EINVAL);
220
221 /* search for the specified feature */
222 f = lysp_feature_find(module->parsed, feature, strlen(feature), 0);
223 LY_CHECK_RET(!f, LY_ENOTFOUND);
224
225 /* feature disabled */
226 if (!(f->flags & LYS_FENABLED)) {
227 return LY_ENOT;
228 }
229
230 /* feature enabled */
231 return LY_SUCCESS;
232}
233
234/**
235 * @brief Stack for processing if-feature expressions.
236 */
237struct iff_stack {
238 size_t size; /**< number of items in the stack */
239 size_t index; /**< first empty item */
240 uint8_t *stack; /**< stack - array of @ref ifftokens to create the if-feature expression in prefix format */
241};
Radek Krejcif13b87b2020-12-01 22:02:17 +0100242#define IFF_STACK_SIZE_STEP 4
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100243
244/**
245 * @brief Add @ref ifftokens into the stack.
246 * @param[in] stack The if-feature stack to use.
247 * @param[in] value One of the @ref ifftokens to store in the stack.
248 * @return LY_EMEM in case of memory allocation error
249 * @return LY_ESUCCESS if the value successfully stored.
250 */
251static LY_ERR
252iff_stack_push(struct iff_stack *stack, uint8_t value)
253{
254 if (stack->index == stack->size) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100255 stack->size += IFF_STACK_SIZE_STEP;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100256 stack->stack = ly_realloc(stack->stack, stack->size * sizeof *stack->stack);
257 LY_CHECK_ERR_RET(!stack->stack, LOGMEM(NULL); stack->size = 0, LY_EMEM);
258 }
259 stack->stack[stack->index++] = value;
260 return LY_SUCCESS;
261}
262
263/**
264 * @brief Get (and remove) the last item form the stack.
265 * @param[in] stack The if-feature stack to use.
266 * @return The value from the top of the stack.
267 */
268static uint8_t
269iff_stack_pop(struct iff_stack *stack)
270{
271 assert(stack && stack->index);
272
273 stack->index--;
274 return stack->stack[stack->index];
275}
276
277/**
278 * @brief Clean up the stack.
279 * @param[in] stack The if-feature stack to use.
280 */
281static void
282iff_stack_clean(struct iff_stack *stack)
283{
284 stack->size = 0;
285 free(stack->stack);
286}
287
288/**
289 * @brief Store the @ref ifftokens (@p op) on the given position in the 2bits array
290 * (libyang format of the if-feature expression).
291 * @param[in,out] list The 2bits array to modify.
292 * @param[in] op The operand (@ref ifftokens) to store.
293 * @param[in] pos Position (0-based) where to store the given @p op.
294 */
295static void
296iff_setop(uint8_t *list, uint8_t op, size_t pos)
297{
298 uint8_t *item;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100299 uint8_t mask = IFF_RECORD_MASK;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100300
Radek Krejcif13b87b2020-12-01 22:02:17 +0100301 assert(op <= IFF_RECORD_MASK); /* max 2 bits */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100302
Radek Krejcif13b87b2020-12-01 22:02:17 +0100303 item = &list[pos / IFF_RECORDS_IN_BYTE];
304 mask = mask << IFF_RECORD_BITS * (pos % IFF_RECORDS_IN_BYTE);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100305 *item = (*item) & ~mask;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100306 *item = (*item) | (op << IFF_RECORD_BITS * (pos % IFF_RECORDS_IN_BYTE));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100307}
308
309#define LYS_IFF_LP 0x04 /**< Additional, temporary, value of @ref ifftokens: ( */
310#define LYS_IFF_RP 0x08 /**< Additional, temporary, value of @ref ifftokens: ) */
311
312static LY_ERR
313lys_compile_iffeature(const struct ly_ctx *ctx, struct lysp_qname *qname, struct lysc_iffeature *iff)
314{
315 LY_ERR rc = LY_SUCCESS;
316 const char *c = qname->str;
317 int64_t i, j;
318 int8_t op_len, last_not = 0, checkversion = 0;
319 LY_ARRAY_COUNT_TYPE f_size = 0, expr_size = 0, f_exp = 1;
320 uint8_t op;
321 struct iff_stack stack = {0, 0, NULL};
322 struct lysp_feature *f;
323
324 assert(c);
325
326 /* pre-parse the expression to get sizes for arrays, also do some syntax checks of the expression */
327 for (i = j = 0; c[i]; i++) {
328 if (c[i] == '(') {
329 j++;
330 checkversion = 1;
331 continue;
332 } else if (c[i] == ')') {
333 j--;
334 continue;
335 } else if (isspace(c[i])) {
336 checkversion = 1;
337 continue;
338 }
339
Radek Krejcif13b87b2020-12-01 22:02:17 +0100340 if (!strncmp(&c[i], "not", op_len = ly_strlen_const("not")) ||
341 !strncmp(&c[i], "and", op_len = ly_strlen_const("and")) ||
342 !strncmp(&c[i], "or", op_len = ly_strlen_const("or"))) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100343 uint64_t spaces;
344 for (spaces = 0; c[i + op_len + spaces] && isspace(c[i + op_len + spaces]); spaces++) {}
345 if (c[i + op_len + spaces] == '\0') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100346 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - unexpected end of expression.", qname->str);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100347 return LY_EVALID;
348 } else if (!isspace(c[i + op_len])) {
349 /* feature name starting with the not/and/or */
350 last_not = 0;
351 f_size++;
352 } else if (c[i] == 'n') { /* not operation */
353 if (last_not) {
354 /* double not */
355 expr_size = expr_size - 2;
356 last_not = 0;
357 } else {
358 last_not = 1;
359 }
360 } else { /* and, or */
361 if (f_exp != f_size) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100362 LOGVAL(ctx, LYVE_SYNTAX_YANG,
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100363 "Invalid value \"%s\" of if-feature - missing feature/expression before \"%.*s\" operation.",
364 qname->str, op_len, &c[i]);
365 return LY_EVALID;
366 }
367 f_exp++;
368
369 /* not a not operation */
370 last_not = 0;
371 }
372 i += op_len;
373 } else {
374 f_size++;
375 last_not = 0;
376 }
377 expr_size++;
378
379 while (!isspace(c[i])) {
380 if (!c[i] || (c[i] == ')') || (c[i] == '(')) {
381 i--;
382 break;
383 }
384 i++;
385 }
386 }
387 if (j) {
388 /* not matching count of ( and ) */
Michal Vasko45092a92022-02-08 15:07:44 +0100389 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - non-matching opening and closing parentheses.",
390 qname->str);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100391 return LY_EVALID;
392 }
393 if (f_exp != f_size) {
394 /* features do not match the needed arguments for the logical operations */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100395 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - number of features in expression does not match "
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100396 "the required number of operands for the operations.", qname->str);
397 return LY_EVALID;
398 }
399
400 if (checkversion || (expr_size > 1)) {
401 /* check that we have 1.1 module */
402 if (qname->mod->version != LYS_VERSION_1_1) {
Michal Vasko45092a92022-02-08 15:07:44 +0100403 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - YANG 1.1 expression in YANG 1.0 module.",
404 qname->str);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100405 return LY_EVALID;
406 }
407 }
408
409 /* allocate the memory */
410 LY_ARRAY_CREATE_RET(ctx, iff->features, f_size, LY_EMEM);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100411 iff->expr = calloc((j = (expr_size / IFF_RECORDS_IN_BYTE) + ((expr_size % IFF_RECORDS_IN_BYTE) ? 1 : 0)), sizeof *iff->expr);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100412 stack.stack = malloc(expr_size * sizeof *stack.stack);
413 LY_CHECK_ERR_GOTO(!stack.stack || !iff->expr, LOGMEM(ctx); rc = LY_EMEM, error);
414
415 stack.size = expr_size;
416 f_size--; expr_size--; /* used as indexes from now */
417
418 for (i--; i >= 0; i--) {
419 if (c[i] == ')') {
420 /* push it on stack */
421 iff_stack_push(&stack, LYS_IFF_RP);
422 continue;
423 } else if (c[i] == '(') {
424 /* pop from the stack into result all operators until ) */
425 while ((op = iff_stack_pop(&stack)) != LYS_IFF_RP) {
426 iff_setop(iff->expr, op, expr_size--);
427 }
428 continue;
429 } else if (isspace(c[i])) {
430 continue;
431 }
432
433 /* end of operator or operand -> find beginning and get what is it */
434 j = i + 1;
435 while (i >= 0 && !isspace(c[i]) && c[i] != '(') {
436 i--;
437 }
438 i++; /* go back by one step */
439
Radek Krejcif13b87b2020-12-01 22:02:17 +0100440 if (!strncmp(&c[i], "not", ly_strlen_const("not")) && isspace(c[i + ly_strlen_const("not")])) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100441 if (stack.index && (stack.stack[stack.index - 1] == LYS_IFF_NOT)) {
442 /* double not */
443 iff_stack_pop(&stack);
444 } else {
445 /* not has the highest priority, so do not pop from the stack
446 * as in case of AND and OR */
447 iff_stack_push(&stack, LYS_IFF_NOT);
448 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100449 } else if (!strncmp(&c[i], "and", ly_strlen_const("and")) && isspace(c[i + ly_strlen_const("and")])) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100450 /* as for OR - pop from the stack all operators with the same or higher
451 * priority and store them to the result, then push the AND to the stack */
452 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_AND) {
453 op = iff_stack_pop(&stack);
454 iff_setop(iff->expr, op, expr_size--);
455 }
456 iff_stack_push(&stack, LYS_IFF_AND);
457 } else if (!strncmp(&c[i], "or", 2) && isspace(c[i + 2])) {
458 while (stack.index && stack.stack[stack.index - 1] <= LYS_IFF_OR) {
459 op = iff_stack_pop(&stack);
460 iff_setop(iff->expr, op, expr_size--);
461 }
462 iff_stack_push(&stack, LYS_IFF_OR);
463 } else {
464 /* feature name, length is j - i */
465
466 /* add it to the expression */
467 iff_setop(iff->expr, LYS_IFF_F, expr_size--);
468
469 /* now get the link to the feature definition */
470 f = lysp_feature_find(qname->mod, &c[i], j - i, 1);
471 if (!f) {
Radek Krejci422afb12021-03-04 16:38:16 +0100472 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - unable to find feature \"%.*s\".",
473 qname->str, (int)(j - i), &c[i]);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100474 rc = LY_EVALID;
475 goto error;
476 }
477 iff->features[f_size] = f;
478 LY_ARRAY_INCREMENT(iff->features);
479 f_size--;
480 }
481 }
482 while (stack.index) {
483 op = iff_stack_pop(&stack);
484 iff_setop(iff->expr, op, expr_size--);
485 }
486
487 if (++expr_size || ++f_size) {
488 /* not all expected operators and operands found */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100489 LOGVAL(ctx, LYVE_SYNTAX_YANG, "Invalid value \"%s\" of if-feature - processing error.", qname->str);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100490 rc = LY_EINT;
491 } else {
492 rc = LY_SUCCESS;
493 }
494
495error:
496 /* cleanup */
497 iff_stack_clean(&stack);
498
499 return rc;
500}
501
502LY_ERR
503lys_eval_iffeatures(const struct ly_ctx *ctx, struct lysp_qname *iffeatures, ly_bool *enabled)
504{
505 LY_ERR ret;
Michal Vaskoc3f55732021-07-29 10:03:17 +0200506 LY_ARRAY_COUNT_TYPE u;
507 struct lysc_iffeature iff;
508
509 /* enabled by default */
510 *enabled = 1;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100511
512 if (!iffeatures) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100513 return LY_SUCCESS;
514 }
515
Michal Vaskoc3f55732021-07-29 10:03:17 +0200516 /* evaluate all if-feature conditions or until an unsatisfied one is found */
517 LY_ARRAY_FOR(iffeatures, u) {
518 memset(&iff, 0, sizeof iff);
519 LY_CHECK_RET(lys_compile_iffeature(ctx, &iffeatures[u], &iff));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100520
Michal Vaskoc3f55732021-07-29 10:03:17 +0200521 ret = lysc_iffeature_value(&iff);
522 lysc_iffeature_free((struct ly_ctx *)ctx, &iff);
523 if (ret == LY_ENOT) {
524 *enabled = 0;
525 break;
526 } else if (ret) {
527 return ret;
528 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100529 }
530
531 return LY_SUCCESS;
532}
533
Michal Vasko45092a92022-02-08 15:07:44 +0100534LY_ERR
535lys_check_features(const struct lysp_module *pmod)
Michal Vasko08c8b272020-11-24 18:11:30 +0100536{
537 LY_ERR r;
538 uint32_t i = 0;
539 struct lysp_feature *f = NULL;
540
541 while ((f = lysp_feature_next(f, pmod, &i))) {
542 if (!(f->flags & LYS_FENABLED) || !f->iffeatures) {
543 /* disabled feature or no if-features to check */
544 continue;
545 }
546
547 assert(f->iffeatures_c);
548 r = lysc_iffeature_value(f->iffeatures_c);
549 if (r == LY_ENOT) {
Michal Vasko45092a92022-02-08 15:07:44 +0100550 LOGERR(pmod->mod->ctx, LY_EDENIED, "Feature \"%s\" cannot be enabled because its \"if-feature\" is not satisfied.",
Michal Vasko08c8b272020-11-24 18:11:30 +0100551 f->name);
Michal Vasko45092a92022-02-08 15:07:44 +0100552 return LY_EDENIED;
Michal Vasko08c8b272020-11-24 18:11:30 +0100553 } else if (r) {
554 return r;
555 } /* else if-feature satisfied */
556 }
557
558 return LY_SUCCESS;
559}
560
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100561LY_ERR
Michal Vasko08c8b272020-11-24 18:11:30 +0100562lys_set_features(struct lysp_module *pmod, const char **features)
563{
564 uint32_t i = 0, j;
565 struct lysp_feature *f = 0;
566 ly_bool change = 0;
567
568 if (!features) {
Radek Krejci2415f882021-01-20 16:27:09 +0100569 /* do not touch the features */
570
571 } else if (!features[0]) {
Michal Vasko08c8b272020-11-24 18:11:30 +0100572 /* disable all the features */
573 while ((f = lysp_feature_next(f, pmod, &i))) {
574 if (f->flags & LYS_FENABLED) {
575 f->flags &= ~LYS_FENABLED;
576 change = 1;
577 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100578 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100579 } else if (!strcmp(features[0], "*")) {
580 /* enable all the features */
581 while ((f = lysp_feature_next(f, pmod, &i))) {
582 if (!(f->flags & LYS_FENABLED)) {
583 f->flags |= LYS_FENABLED;
584 change = 1;
585 }
586 }
587 } else {
Michal Vaskoc8997c52021-08-23 15:38:34 +0200588 /* check that all the features exist */
589 for (j = 0; features[j]; ++j) {
590 if (!lysp_feature_find(pmod, features[j], strlen(features[j]), 0)) {
591 LOGERR(pmod->mod->ctx, LY_EINVAL, "Feature \"%s\" not found in module \"%s\".", features[j], pmod->mod->name);
592 return LY_EINVAL;
593 }
594 }
595
Michal Vasko08c8b272020-11-24 18:11:30 +0100596 /* enable specific features, disable the rest */
597 while ((f = lysp_feature_next(f, pmod, &i))) {
598 for (j = 0; features[j]; ++j) {
599 if (!strcmp(f->name, features[j])) {
600 break;
601 }
602 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100603
Michal Vasko08c8b272020-11-24 18:11:30 +0100604 if (features[j] && !(f->flags & LYS_FENABLED)) {
605 /* enable */
606 f->flags |= LYS_FENABLED;
607 change = 1;
608 } else if (!features[j] && (f->flags & LYS_FENABLED)) {
609 /* disable */
610 f->flags &= ~LYS_FENABLED;
611 change = 1;
612 }
613 }
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100614 }
615
Michal Vasko08c8b272020-11-24 18:11:30 +0100616 if (!change) {
617 /* features already set correctly */
618 return LY_EEXIST;
619 }
620
Michal Vasko45092a92022-02-08 15:07:44 +0100621 return LY_SUCCESS;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100622}
623
624/**
625 * @brief Check circular dependency of features - feature MUST NOT reference itself (via their if-feature statement).
626 *
627 * The function works in the same way as lys_compile_identity_circular_check() with different structures and error messages.
628 *
629 * @param[in] ctx Compile context for logging.
630 * @param[in] feature The feature referenced in if-feature statement (its depfeatures list is being extended by the feature
631 * being currently processed).
632 * @param[in] depfeatures The list of depending features of the feature being currently processed (not the one provided as @p feature)
633 * @return LY_SUCCESS if everything is ok.
634 * @return LY_EVALID if the feature references indirectly itself.
635 */
636static LY_ERR
637lys_compile_feature_circular_check(const struct ly_ctx *ctx, struct lysp_feature *feature, struct lysp_feature **depfeatures)
638{
639 LY_ERR ret = LY_SUCCESS;
640 LY_ARRAY_COUNT_TYPE u, v;
641 struct ly_set recursion = {0};
642 struct lysp_feature *drv;
643
644 if (!depfeatures) {
645 return LY_SUCCESS;
646 }
647
648 for (u = 0; u < LY_ARRAY_COUNT(depfeatures); ++u) {
649 if (feature == depfeatures[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100650 LOGVAL(ctx, LYVE_REFERENCE, "Feature \"%s\" is indirectly referenced from itself.", feature->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100651 ret = LY_EVALID;
652 goto cleanup;
653 }
654 ret = ly_set_add(&recursion, depfeatures[u], 0, NULL);
655 LY_CHECK_GOTO(ret, cleanup);
656 }
657
658 for (v = 0; v < recursion.count; ++v) {
659 drv = recursion.objs[v];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100660 for (u = 0; u < LY_ARRAY_COUNT(drv->depfeatures); ++u) {
661 if (feature == drv->depfeatures[u]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100662 LOGVAL(ctx, LYVE_REFERENCE, "Feature \"%s\" is indirectly referenced from itself.", feature->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100663 ret = LY_EVALID;
664 goto cleanup;
665 }
666 ly_set_add(&recursion, drv->depfeatures[u], 0, NULL);
667 LY_CHECK_GOTO(ret, cleanup);
668 }
669 }
670
671cleanup:
672 ly_set_erase(&recursion, NULL);
673 return ret;
674}
675
676LY_ERR
677lys_compile_feature_iffeatures(struct lysp_module *pmod)
678{
679 LY_ARRAY_COUNT_TYPE u, v;
680 struct lysp_feature *f = NULL, **df;
681 uint32_t idx = 0;
682
683 while ((f = lysp_feature_next(f, pmod, &idx))) {
684 if (!f->iffeatures) {
685 continue;
686 }
687
688 /* compile if-features */
689 LY_ARRAY_CREATE_RET(pmod->mod->ctx, f->iffeatures_c, LY_ARRAY_COUNT(f->iffeatures), LY_EMEM);
690 LY_ARRAY_FOR(f->iffeatures, u) {
691 LY_ARRAY_INCREMENT(f->iffeatures_c);
692 LY_CHECK_RET(lys_compile_iffeature(pmod->mod->ctx, &(f->iffeatures)[u], &(f->iffeatures_c)[u]));
693 }
694 LY_ARRAY_FOR(f->iffeatures_c, u) {
695 LY_ARRAY_FOR(f->iffeatures_c[u].features, v) {
696 /* check for circular dependency - direct reference first,... */
697 if (f == f->iffeatures_c[u].features[v]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100698 LOGVAL(pmod->mod->ctx, LYVE_REFERENCE, "Feature \"%s\" is referenced from itself.", f->name);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100699 return LY_EVALID;
700 }
701 /* ... and indirect circular reference */
702 LY_CHECK_RET(lys_compile_feature_circular_check(pmod->mod->ctx, f->iffeatures_c[u].features[v], f->depfeatures));
703
704 /* add itself into the dependants list */
705 LY_ARRAY_NEW_RET(pmod->mod->ctx, f->iffeatures_c[u].features[v]->depfeatures, df, LY_EMEM);
706 *df = f;
707 }
708 }
709 }
710
711 return LY_SUCCESS;
712}