Line data Source code
1 : /*
2 : * Copyright (C) 2018 NetDEF, Inc.
3 : * Renato Westphal
4 : *
5 : * This program is free software; you can redistribute it and/or modify it
6 : * under the terms of the GNU General Public License as published by the Free
7 : * Software Foundation; either version 2 of the License, or (at your option)
8 : * any later version.
9 : *
10 : * This program is distributed in the hope that it will be useful, but WITHOUT
11 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 : * more details.
14 : *
15 : * You should have received a copy of the GNU General Public License along
16 : * with this program; see the file COPYING; if not, write to the Free Software
17 : * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 : */
19 :
20 : #include <zebra.h>
21 :
22 : #include "log.h"
23 : #include "lib_errors.h"
24 : #include "yang.h"
25 : #include "yang_translator.h"
26 : #include "northbound.h"
27 :
28 586 : DEFINE_MTYPE_STATIC(LIB, YANG_MODULE, "YANG module");
29 586 : DEFINE_MTYPE_STATIC(LIB, YANG_DATA, "YANG data structure");
30 :
31 : /* libyang container. */
32 : struct ly_ctx *ly_native_ctx;
33 :
34 : static struct yang_module_embed *embeds, **embedupd = &embeds;
35 :
36 2906 : void yang_module_embed(struct yang_module_embed *embed)
37 : {
38 2906 : embed->next = NULL;
39 2906 : *embedupd = embed;
40 2906 : embedupd = &embed->next;
41 2906 : }
42 :
43 2013 : static LY_ERR yang_module_imp_clb(const char *mod_name, const char *mod_rev,
44 : const char *submod_name,
45 : const char *submod_rev, void *user_data,
46 : LYS_INFORMAT *format,
47 : const char **module_data,
48 : void (**free_module_data)(void *, void *))
49 : {
50 2013 : struct yang_module_embed *e;
51 :
52 2013 : if (!strcmp(mod_name, "ietf-inet-types") ||
53 2013 : !strcmp(mod_name, "ietf-yang-types"))
54 : /* libyang has these built in, don't try finding them here */
55 : return LY_ENOTFOUND;
56 :
57 14571 : for (e = embeds; e; e = e->next) {
58 14571 : if (e->sub_mod_name && submod_name) {
59 0 : if (strcmp(e->sub_mod_name, submod_name))
60 0 : continue;
61 :
62 0 : if (submod_rev && strcmp(e->sub_mod_rev, submod_rev))
63 0 : continue;
64 : } else {
65 14571 : if (strcmp(e->mod_name, mod_name))
66 12558 : continue;
67 :
68 2013 : if (mod_rev && strcmp(e->mod_rev, mod_rev))
69 0 : continue;
70 : }
71 :
72 2013 : *format = e->format;
73 2013 : *module_data = e->data;
74 2013 : return LY_SUCCESS;
75 : }
76 :
77 : /* We get here for indirect modules like ietf-inet-types */
78 0 : zlog_debug(
79 : "YANG model \"%s@%s\" \"%s@%s\"not embedded, trying external file",
80 : mod_name, mod_rev ? mod_rev : "*",
81 : submod_name ? submod_name : "*", submod_rev ? submod_rev : "*");
82 :
83 0 : return LY_ENOTFOUND;
84 : }
85 :
86 : /* clang-format off */
87 : static const char *const frr_native_modules[] = {
88 : "frr-interface",
89 : "frr-vrf",
90 : "frr-routing",
91 : "frr-route-map",
92 : "frr-nexthop",
93 : "frr-ripd",
94 : "frr-ripngd",
95 : "frr-isisd",
96 : "frr-vrrpd",
97 : "frr-zebra",
98 : "frr-pathd",
99 : };
100 : /* clang-format on */
101 :
102 : /* Generate the yang_modules tree. */
103 2190 : static inline int yang_module_compare(const struct yang_module *a,
104 : const struct yang_module *b)
105 : {
106 2190 : return strcmp(a->name, b->name);
107 : }
108 2190 : RB_GENERATE(yang_modules, yang_module, entry, yang_module_compare)
109 :
110 : struct yang_modules yang_modules = RB_INITIALIZER(&yang_modules);
111 :
112 1194 : struct yang_module *yang_module_load(const char *module_name)
113 : {
114 1194 : struct yang_module *module;
115 1194 : const struct lys_module *module_info;
116 :
117 1194 : module_info =
118 1194 : ly_ctx_load_module(ly_native_ctx, module_name, NULL, NULL);
119 1194 : if (!module_info) {
120 0 : flog_err(EC_LIB_YANG_MODULE_LOAD,
121 : "%s: failed to load data model: %s", __func__,
122 : module_name);
123 0 : exit(1);
124 : }
125 :
126 1194 : module = XCALLOC(MTYPE_YANG_MODULE, sizeof(*module));
127 1194 : module->name = module_name;
128 1194 : module->info = module_info;
129 :
130 1194 : if (RB_INSERT(yang_modules, &yang_modules, module) != NULL) {
131 0 : flog_err(EC_LIB_YANG_MODULE_LOADED_ALREADY,
132 : "%s: YANG module is loaded already: %s", __func__,
133 : module_name);
134 0 : exit(1);
135 : }
136 :
137 1194 : return module;
138 : }
139 :
140 0 : void yang_module_load_all(void)
141 : {
142 0 : for (size_t i = 0; i < array_size(frr_native_modules); i++)
143 0 : yang_module_load(frr_native_modules[i]);
144 0 : }
145 :
146 0 : struct yang_module *yang_module_find(const char *module_name)
147 : {
148 0 : struct yang_module s;
149 :
150 0 : s.name = module_name;
151 0 : return RB_FIND(yang_modules, &yang_modules, &s);
152 : }
153 :
154 883707 : int yang_snodes_iterate_subtree(const struct lysc_node *snode,
155 : const struct lys_module *module,
156 : yang_iterate_cb cb, uint16_t flags, void *arg)
157 : {
158 883707 : const struct lysc_node *child;
159 883707 : int ret = YANG_ITER_CONTINUE;
160 :
161 883707 : if (module && snode->module != module)
162 420943 : goto next;
163 :
164 462764 : switch (snode->nodetype) {
165 31577 : case LYS_CONTAINER:
166 31577 : if (CHECK_FLAG(flags, YANG_ITER_FILTER_NPCONTAINERS)) {
167 0 : if (!CHECK_FLAG(snode->flags, LYS_PRESENCE))
168 0 : goto next;
169 : }
170 : break;
171 277643 : case LYS_LEAF:
172 277643 : if (CHECK_FLAG(flags, YANG_ITER_FILTER_LIST_KEYS)) {
173 : /* Ignore list keys. */
174 0 : if (lysc_is_key(snode))
175 0 : goto next;
176 : }
177 : break;
178 8896 : case LYS_INPUT:
179 : case LYS_OUTPUT:
180 8896 : if (CHECK_FLAG(flags, YANG_ITER_FILTER_INPUT_OUTPUT))
181 0 : goto next;
182 : break;
183 144648 : default:
184 144648 : assert(snode->nodetype != LYS_AUGMENT
185 : && snode->nodetype != LYS_GROUPING
186 : && snode->nodetype != LYS_USES);
187 : break;
188 : }
189 :
190 462764 : ret = (*cb)(snode, arg);
191 462764 : if (ret == YANG_ITER_STOP)
192 : return ret;
193 :
194 460499 : next:
195 : /*
196 : * YANG leafs and leaf-lists can't have child nodes.
197 : */
198 881442 : if (CHECK_FLAG(snode->nodetype, LYS_LEAF | LYS_LEAFLIST))
199 : return YANG_ITER_CONTINUE;
200 :
201 1196762 : LY_LIST_FOR (lysc_node_child(snode), child) {
202 853623 : ret = yang_snodes_iterate_subtree(child, module, cb, flags,
203 : arg);
204 853623 : if (ret == YANG_ITER_STOP)
205 : return ret;
206 : }
207 : return ret;
208 : }
209 :
210 1764 : int yang_snodes_iterate(const struct lys_module *module, yang_iterate_cb cb,
211 : uint16_t flags, void *arg)
212 : {
213 1764 : const struct lys_module *module_iter;
214 1764 : uint32_t idx = 0;
215 1764 : int ret = YANG_ITER_CONTINUE;
216 :
217 1764 : idx = ly_ctx_internal_modules_count(ly_native_ctx);
218 19008 : while ((module_iter = ly_ctx_get_module_iter(ly_native_ctx, &idx))) {
219 17244 : struct lysc_node *snode;
220 :
221 17244 : if (!module_iter->implemented)
222 5762 : continue;
223 :
224 20874 : LY_LIST_FOR (module_iter->compiled->data, snode) {
225 9392 : ret = yang_snodes_iterate_subtree(snode, module, cb,
226 : flags, arg);
227 9392 : if (ret == YANG_ITER_STOP)
228 : return ret;
229 : }
230 22590 : LY_LIST_FOR (&module_iter->compiled->rpcs->node, snode) {
231 11108 : ret = yang_snodes_iterate_subtree(snode, module, cb,
232 : flags, arg);
233 11108 : if (ret == YANG_ITER_STOP)
234 : return ret;
235 : }
236 11562 : LY_LIST_FOR (&module_iter->compiled->notifs->node, snode) {
237 80 : ret = yang_snodes_iterate_subtree(snode, module, cb,
238 : flags, arg);
239 80 : if (ret == YANG_ITER_STOP)
240 : return ret;
241 : }
242 : }
243 :
244 : return ret;
245 : }
246 :
247 73169 : void yang_snode_get_path(const struct lysc_node *snode,
248 : enum yang_path_type type, char *xpath,
249 : size_t xpath_len)
250 : {
251 73169 : switch (type) {
252 0 : case YANG_PATH_SCHEMA:
253 0 : (void)lysc_path(snode, LYSC_PATH_LOG, xpath, xpath_len);
254 0 : break;
255 73169 : case YANG_PATH_DATA:
256 73169 : (void)lysc_path(snode, LYSC_PATH_DATA, xpath, xpath_len);
257 73169 : break;
258 0 : default:
259 0 : flog_err(EC_LIB_DEVELOPMENT, "%s: unknown yang path type: %u",
260 : __func__, type);
261 0 : exit(1);
262 : }
263 73169 : }
264 :
265 73169 : struct lysc_node *yang_snode_real_parent(const struct lysc_node *snode)
266 : {
267 73169 : struct lysc_node *parent = snode->parent;
268 :
269 192990 : while (parent) {
270 173608 : switch (parent->nodetype) {
271 25327 : case LYS_CONTAINER:
272 25327 : if (CHECK_FLAG(parent->flags, LYS_PRESENCE))
273 291 : return parent;
274 : break;
275 : case LYS_LIST:
276 : return parent;
277 : default:
278 : break;
279 : }
280 119821 : parent = parent->parent;
281 : }
282 :
283 : return NULL;
284 : }
285 :
286 73169 : struct lysc_node *yang_snode_parent_list(const struct lysc_node *snode)
287 : {
288 73169 : struct lysc_node *parent = snode->parent;
289 :
290 193313 : while (parent) {
291 173899 : switch (parent->nodetype) {
292 : case LYS_LIST:
293 : return parent;
294 : default:
295 120144 : break;
296 : }
297 120144 : parent = parent->parent;
298 : }
299 :
300 : return NULL;
301 : }
302 :
303 0 : bool yang_snode_is_typeless_data(const struct lysc_node *snode)
304 : {
305 0 : const struct lysc_node_leaf *sleaf;
306 :
307 0 : switch (snode->nodetype) {
308 0 : case LYS_LEAF:
309 0 : sleaf = (struct lysc_node_leaf *)snode;
310 0 : if (sleaf->type->basetype == LY_TYPE_EMPTY)
311 : return true;
312 : return false;
313 : case LYS_LEAFLIST:
314 : return false;
315 : default:
316 : return true;
317 : }
318 : }
319 :
320 708 : const char *yang_snode_get_default(const struct lysc_node *snode)
321 : {
322 708 : const struct lysc_node_leaf *sleaf;
323 :
324 708 : switch (snode->nodetype) {
325 340 : case LYS_LEAF:
326 340 : sleaf = (const struct lysc_node_leaf *)snode;
327 322 : return sleaf->dflt ? lyd_value_get_canonical(sleaf->module->ctx,
328 : sleaf->dflt)
329 340 : : NULL;
330 : case LYS_LEAFLIST:
331 : /* TODO: check leaf-list default values */
332 : return NULL;
333 : default:
334 : return NULL;
335 : }
336 : }
337 :
338 0 : const struct lysc_type *yang_snode_get_type(const struct lysc_node *snode)
339 : {
340 0 : struct lysc_node_leaf *sleaf = (struct lysc_node_leaf *)snode;
341 0 : struct lysc_type *type;
342 :
343 0 : if (!CHECK_FLAG(sleaf->nodetype, LYS_LEAF | LYS_LEAFLIST))
344 : return NULL;
345 :
346 0 : type = sleaf->type;
347 0 : while (type->basetype == LY_TYPE_LEAFREF)
348 0 : type = ((struct lysc_type_leafref *)type)->realtype;
349 :
350 : return type;
351 : }
352 :
353 4747 : unsigned int yang_snode_num_keys(const struct lysc_node *snode)
354 : {
355 4747 : const struct lysc_node_leaf *skey;
356 4747 : uint count = 0;
357 :
358 4747 : if (!CHECK_FLAG(snode->nodetype, LYS_LIST))
359 : return 0;
360 :
361 : /* Walk list of children */
362 10045 : LY_FOR_KEYS (snode, skey) {
363 5298 : count++;
364 : }
365 : return count;
366 : }
367 :
368 1835 : void yang_dnode_get_path(const struct lyd_node *dnode, char *xpath,
369 : size_t xpath_len)
370 : {
371 1835 : lyd_path(dnode, LYD_PATH_STD, xpath, xpath_len);
372 1835 : }
373 :
374 0 : const char *yang_dnode_get_schema_name(const struct lyd_node *dnode,
375 : const char *xpath_fmt, ...)
376 : {
377 0 : if (xpath_fmt) {
378 0 : va_list ap;
379 0 : char xpath[XPATH_MAXLEN];
380 :
381 0 : va_start(ap, xpath_fmt);
382 0 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
383 0 : va_end(ap);
384 :
385 0 : dnode = yang_dnode_get(dnode, xpath);
386 0 : if (!dnode) {
387 0 : flog_err(EC_LIB_YANG_DNODE_NOT_FOUND,
388 : "%s: couldn't find %s", __func__, xpath);
389 0 : zlog_backtrace(LOG_ERR);
390 0 : abort();
391 : }
392 : }
393 :
394 0 : return dnode->schema->name;
395 : }
396 :
397 1958 : struct lyd_node *yang_dnode_get(const struct lyd_node *dnode, const char *xpath)
398 : {
399 1958 : struct ly_set *set = NULL;
400 1958 : struct lyd_node *dnode_ret = NULL;
401 :
402 : /*
403 : * XXX a lot of the code uses this for style I guess. It shouldn't, as
404 : * it adds to the xpath parsing complexity in libyang.
405 : */
406 1958 : if (xpath[0] == '.' && xpath[1] == '/')
407 1174 : xpath += 2;
408 :
409 1958 : if (lyd_find_xpath(dnode, xpath, &set)) {
410 0 : assert(0); /* XXX replicates old libyang1 base code */
411 : goto exit;
412 : }
413 1958 : if (set->count == 0)
414 80 : goto exit;
415 :
416 1878 : if (set->count > 1) {
417 0 : flog_warn(EC_LIB_YANG_DNODE_NOT_FOUND,
418 : "%s: found %u elements (expected 0 or 1) [xpath %s]",
419 : __func__, set->count, xpath);
420 0 : goto exit;
421 : }
422 :
423 1878 : dnode_ret = set->dnodes[0];
424 :
425 1958 : exit:
426 1958 : ly_set_free(set, NULL);
427 :
428 1958 : return dnode_ret;
429 : }
430 :
431 62 : struct lyd_node *yang_dnode_getf(const struct lyd_node *dnode,
432 : const char *xpath_fmt, ...)
433 : {
434 62 : va_list ap;
435 62 : char xpath[XPATH_MAXLEN];
436 :
437 62 : va_start(ap, xpath_fmt);
438 62 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
439 62 : va_end(ap);
440 :
441 62 : return yang_dnode_get(dnode, xpath);
442 : }
443 :
444 121 : bool yang_dnode_exists(const struct lyd_node *dnode, const char *xpath)
445 : {
446 121 : struct ly_set *set = NULL;
447 121 : bool exists = false;
448 :
449 121 : if (xpath[0] == '.' && xpath[1] == '/')
450 50 : xpath += 2;
451 121 : if (lyd_find_xpath(dnode, xpath, &set))
452 : return false;
453 121 : exists = set->count > 0;
454 121 : ly_set_free(set, NULL);
455 121 : return exists;
456 : }
457 :
458 0 : bool yang_dnode_existsf(const struct lyd_node *dnode, const char *xpath_fmt,
459 : ...)
460 : {
461 0 : va_list ap;
462 0 : char xpath[XPATH_MAXLEN];
463 :
464 0 : va_start(ap, xpath_fmt);
465 0 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
466 0 : va_end(ap);
467 :
468 0 : return yang_dnode_exists(dnode, xpath);
469 : }
470 :
471 58 : void yang_dnode_iterate(yang_dnode_iter_cb cb, void *arg,
472 : const struct lyd_node *dnode, const char *xpath_fmt,
473 : ...)
474 : {
475 58 : va_list ap;
476 58 : char xpath[XPATH_MAXLEN];
477 58 : struct ly_set *set;
478 :
479 58 : va_start(ap, xpath_fmt);
480 58 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
481 58 : va_end(ap);
482 :
483 58 : if (lyd_find_xpath(dnode, xpath, &set)) {
484 0 : assert(0); /* XXX libyang2: ly1 code asserted success */
485 : return;
486 : }
487 96 : for (unsigned int i = 0; i < set->count; i++) {
488 38 : int ret;
489 :
490 38 : ret = (*cb)(set->dnodes[i], arg);
491 38 : if (ret == YANG_ITER_STOP)
492 : break;
493 : }
494 :
495 58 : ly_set_free(set, NULL);
496 : }
497 :
498 0 : bool yang_dnode_is_default(const struct lyd_node *dnode, const char *xpath)
499 : {
500 0 : const struct lysc_node *snode;
501 0 : struct lysc_node_leaf *sleaf;
502 :
503 0 : if (xpath)
504 0 : dnode = yang_dnode_get(dnode, xpath);
505 :
506 0 : assert(dnode);
507 0 : snode = dnode->schema;
508 0 : switch (snode->nodetype) {
509 0 : case LYS_LEAF:
510 0 : sleaf = (struct lysc_node_leaf *)snode;
511 0 : if (sleaf->type->basetype == LY_TYPE_EMPTY)
512 : return false;
513 0 : return lyd_is_default(dnode);
514 : case LYS_LEAFLIST:
515 : /* TODO: check leaf-list default values */
516 : return false;
517 0 : case LYS_CONTAINER:
518 0 : if (CHECK_FLAG(snode->flags, LYS_PRESENCE))
519 0 : return false;
520 : return true;
521 : default:
522 : return false;
523 : }
524 : }
525 :
526 0 : bool yang_dnode_is_defaultf(const struct lyd_node *dnode, const char *xpath_fmt,
527 : ...)
528 : {
529 0 : if (!xpath_fmt)
530 0 : return yang_dnode_is_default(dnode, NULL);
531 : else {
532 0 : va_list ap;
533 0 : char xpath[XPATH_MAXLEN];
534 :
535 0 : va_start(ap, xpath_fmt);
536 0 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
537 0 : va_end(ap);
538 :
539 0 : return yang_dnode_is_default(dnode, xpath);
540 : }
541 : }
542 :
543 0 : bool yang_dnode_is_default_recursive(const struct lyd_node *dnode)
544 : {
545 0 : struct lyd_node *root, *dnode_iter;
546 :
547 0 : if (!yang_dnode_is_default(dnode, NULL))
548 : return false;
549 :
550 0 : if (CHECK_FLAG(dnode->schema->nodetype, LYS_LEAF | LYS_LEAFLIST))
551 : return true;
552 :
553 0 : LY_LIST_FOR (lyd_child(dnode), root) {
554 0 : LYD_TREE_DFS_BEGIN (root, dnode_iter) {
555 0 : if (!yang_dnode_is_default(dnode_iter, NULL))
556 : return false;
557 :
558 0 : LYD_TREE_DFS_END(root, dnode_iter);
559 : }
560 : }
561 :
562 : return true;
563 : }
564 :
565 0 : void yang_dnode_change_leaf(struct lyd_node *dnode, const char *value)
566 : {
567 0 : assert(dnode->schema->nodetype == LYS_LEAF);
568 0 : lyd_change_term(dnode, value);
569 0 : }
570 :
571 380 : struct lyd_node *yang_dnode_new(struct ly_ctx *ly_ctx, bool config_only)
572 : {
573 380 : struct lyd_node *dnode = NULL;
574 380 : int options = config_only ? LYD_VALIDATE_NO_STATE : 0;
575 :
576 380 : if (lyd_validate_all(&dnode, ly_ctx, options, NULL) != 0) {
577 : /* Should never happen. */
578 0 : flog_err(EC_LIB_LIBYANG, "%s: lyd_validate() failed", __func__);
579 0 : exit(1);
580 : }
581 :
582 380 : return dnode;
583 : }
584 :
585 473 : struct lyd_node *yang_dnode_dup(const struct lyd_node *dnode)
586 : {
587 473 : struct lyd_node *dup = NULL;
588 473 : LY_ERR err;
589 473 : err = lyd_dup_siblings(dnode, NULL, LYD_DUP_RECURSIVE, &dup);
590 473 : assert(!err);
591 473 : return dup;
592 : }
593 :
594 1233 : void yang_dnode_free(struct lyd_node *dnode)
595 : {
596 1233 : while (dnode->parent)
597 0 : dnode = lyd_parent(dnode);
598 1233 : lyd_free_all(dnode);
599 1233 : }
600 :
601 792 : struct yang_data *yang_data_new(const char *xpath, const char *value)
602 : {
603 792 : struct yang_data *data;
604 :
605 792 : data = XCALLOC(MTYPE_YANG_DATA, sizeof(*data));
606 792 : strlcpy(data->xpath, xpath, sizeof(data->xpath));
607 792 : if (value)
608 406 : data->value = strdup(value);
609 :
610 792 : return data;
611 : }
612 :
613 792 : void yang_data_free(struct yang_data *data)
614 : {
615 792 : if (data->value)
616 406 : free(data->value);
617 792 : XFREE(MTYPE_YANG_DATA, data);
618 792 : }
619 :
620 0 : struct list *yang_data_list_new(void)
621 : {
622 0 : struct list *list;
623 :
624 0 : list = list_new();
625 0 : list->del = (void (*)(void *))yang_data_free;
626 :
627 0 : return list;
628 : }
629 :
630 0 : struct yang_data *yang_data_list_find(const struct list *list,
631 : const char *xpath_fmt, ...)
632 : {
633 0 : char xpath[XPATH_MAXLEN];
634 0 : struct yang_data *data;
635 0 : struct listnode *node;
636 0 : va_list ap;
637 :
638 0 : va_start(ap, xpath_fmt);
639 0 : vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
640 0 : va_end(ap);
641 :
642 0 : for (ALL_LIST_ELEMENTS_RO(list, node, data))
643 0 : if (strmatch(data->xpath, xpath))
644 0 : return data;
645 :
646 : return NULL;
647 : }
648 :
649 : /* Make libyang log its errors using FRR logging infrastructure. */
650 0 : static void ly_log_cb(LY_LOG_LEVEL level, const char *msg, const char *path)
651 : {
652 0 : int priority = LOG_ERR;
653 :
654 0 : switch (level) {
655 : case LY_LLERR:
656 : priority = LOG_ERR;
657 : break;
658 0 : case LY_LLWRN:
659 0 : priority = LOG_WARNING;
660 0 : break;
661 0 : case LY_LLVRB:
662 : case LY_LLDBG:
663 0 : priority = LOG_DEBUG;
664 0 : break;
665 : }
666 :
667 0 : if (path)
668 0 : zlog(priority, "libyang: %s (%s)", msg, path);
669 : else
670 0 : zlog(priority, "libyang: %s", msg);
671 0 : }
672 :
673 0 : const char *yang_print_errors(struct ly_ctx *ly_ctx, char *buf, size_t buf_len)
674 : {
675 0 : struct ly_err_item *ei;
676 0 : const char *path;
677 :
678 0 : ei = ly_err_first(ly_ctx);
679 0 : if (!ei)
680 : return "";
681 :
682 0 : strlcpy(buf, "YANG error(s):\n", buf_len);
683 0 : for (; ei; ei = ei->next) {
684 0 : strlcat(buf, " ", buf_len);
685 0 : strlcat(buf, ei->msg, buf_len);
686 0 : strlcat(buf, "\n", buf_len);
687 : }
688 :
689 0 : path = ly_errpath(ly_ctx);
690 0 : if (path) {
691 0 : strlcat(buf, " YANG path: ", buf_len);
692 0 : strlcat(buf, path, buf_len);
693 0 : strlcat(buf, "\n", buf_len);
694 : }
695 :
696 0 : ly_err_clean(ly_ctx, NULL);
697 :
698 0 : return buf;
699 : }
700 :
701 0 : void yang_debugging_set(bool enable)
702 : {
703 0 : if (enable) {
704 0 : ly_log_level(LY_LLDBG);
705 0 : ly_log_dbg_groups(0xFF);
706 : } else {
707 0 : ly_log_level(LY_LLERR);
708 0 : ly_log_dbg_groups(0);
709 : }
710 0 : }
711 :
712 380 : struct ly_ctx *yang_ctx_new_setup(bool embedded_modules, bool explicit_compile)
713 : {
714 380 : struct ly_ctx *ctx = NULL;
715 380 : const char *yang_models_path = YANG_MODELS_PATH;
716 380 : LY_ERR err;
717 :
718 380 : if (access(yang_models_path, R_OK | X_OK)) {
719 0 : yang_models_path = NULL;
720 0 : if (errno == ENOENT)
721 0 : zlog_info("yang model directory \"%s\" does not exist",
722 : YANG_MODELS_PATH);
723 : else
724 0 : flog_err_sys(EC_LIB_LIBYANG,
725 : "cannot access yang model directory \"%s\"",
726 : YANG_MODELS_PATH);
727 : }
728 :
729 380 : uint options = LY_CTX_NO_YANGLIBRARY | LY_CTX_DISABLE_SEARCHDIR_CWD;
730 380 : if (explicit_compile)
731 0 : options |= LY_CTX_EXPLICIT_COMPILE;
732 380 : err = ly_ctx_new(yang_models_path, options, &ctx);
733 380 : if (err)
734 : return NULL;
735 :
736 380 : if (embedded_modules)
737 380 : ly_ctx_set_module_imp_clb(ctx, yang_module_imp_clb, NULL);
738 :
739 380 : return ctx;
740 : }
741 :
742 190 : void yang_init(bool embedded_modules, bool defer_compile)
743 : {
744 : /* Initialize libyang global parameters that affect all containers. */
745 190 : ly_set_log_clb(ly_log_cb, 1);
746 190 : ly_log_options(LY_LOLOG | LY_LOSTORE);
747 :
748 : /* Initialize libyang container for native models. */
749 190 : ly_native_ctx = yang_ctx_new_setup(embedded_modules, defer_compile);
750 190 : if (!ly_native_ctx) {
751 0 : flog_err(EC_LIB_LIBYANG, "%s: ly_ctx_new() failed", __func__);
752 0 : exit(1);
753 : }
754 :
755 190 : yang_translator_init();
756 190 : }
757 :
758 0 : void yang_init_loading_complete(void)
759 : {
760 : /* Compile everything */
761 0 : if (ly_ctx_compile(ly_native_ctx) != LY_SUCCESS) {
762 0 : flog_err(EC_LIB_YANG_MODULE_LOAD,
763 : "%s: failed to compile loaded modules: %s", __func__,
764 : ly_errmsg(ly_native_ctx));
765 0 : exit(1);
766 : }
767 0 : }
768 :
769 380 : void yang_terminate(void)
770 : {
771 380 : struct yang_module *module;
772 :
773 380 : yang_translator_terminate();
774 :
775 380 : while (!RB_EMPTY(yang_modules, &yang_modules)) {
776 2388 : module = RB_ROOT(yang_modules, &yang_modules);
777 :
778 : /*
779 : * We shouldn't call ly_ctx_remove_module() here because this
780 : * function also removes other modules that depend on it.
781 : *
782 : * ly_ctx_destroy() will release all memory for us.
783 : */
784 2388 : RB_REMOVE(yang_modules, &yang_modules, module);
785 2768 : XFREE(MTYPE_YANG_MODULE, module);
786 : }
787 :
788 380 : ly_ctx_destroy(ly_native_ctx);
789 380 : }
790 :
791 172 : const struct lyd_node *yang_dnode_get_parent(const struct lyd_node *dnode,
792 : const char *name)
793 : {
794 172 : const struct lyd_node *orig_dnode = dnode;
795 :
796 774 : while (orig_dnode) {
797 602 : switch (orig_dnode->schema->nodetype) {
798 505 : case LYS_LIST:
799 : case LYS_CONTAINER:
800 505 : if (!strcmp(orig_dnode->schema->name, name))
801 172 : return orig_dnode;
802 : break;
803 : default:
804 : break;
805 : }
806 :
807 : orig_dnode = lyd_parent(orig_dnode);
808 : }
809 :
810 : return NULL;
811 : }
812 :
813 0 : bool yang_is_last_list_dnode(const struct lyd_node *dnode)
814 : {
815 0 : return (((dnode->next == NULL)
816 0 : || (dnode->next
817 0 : && (strcmp(dnode->next->schema->name, dnode->schema->name)
818 : != 0)))
819 0 : && dnode->prev
820 0 : && ((dnode->prev == dnode)
821 0 : || (strcmp(dnode->prev->schema->name, dnode->schema->name)
822 : != 0)));
823 : }
824 :
825 0 : bool yang_is_last_level_dnode(const struct lyd_node *dnode)
826 : {
827 0 : const struct lyd_node *parent;
828 0 : const struct lyd_node *key_leaf;
829 0 : uint8_t keys_size;
830 :
831 0 : switch (dnode->schema->nodetype) {
832 0 : case LYS_LIST:
833 0 : assert(dnode->parent);
834 0 : parent = lyd_parent(dnode);
835 0 : uint snode_num_keys = yang_snode_num_keys(parent->schema);
836 : /* XXX libyang2: q: really don't understand this code. */
837 0 : key_leaf = dnode->prev;
838 0 : for (keys_size = 1; keys_size < snode_num_keys; keys_size++)
839 0 : key_leaf = key_leaf->prev;
840 0 : if (key_leaf->prev == dnode)
841 : return true;
842 : break;
843 : case LYS_CONTAINER:
844 : return true;
845 : default:
846 : break;
847 : }
848 :
849 : return false;
850 : }
851 :
852 : const struct lyd_node *
853 0 : yang_get_subtree_with_no_sibling(const struct lyd_node *dnode)
854 : {
855 0 : bool parent = true;
856 0 : const struct lyd_node *node;
857 :
858 0 : node = dnode;
859 0 : if (node->schema->nodetype != LYS_LIST)
860 : return node;
861 :
862 0 : while (parent) {
863 0 : switch (node->schema->nodetype) {
864 0 : case LYS_CONTAINER:
865 0 : if (!CHECK_FLAG(node->schema->flags, LYS_PRESENCE)) {
866 0 : if (node->parent
867 0 : && (node->parent->schema->module
868 0 : == dnode->schema->module))
869 0 : node = lyd_parent(node);
870 : else
871 : parent = false;
872 : } else
873 : parent = false;
874 : break;
875 0 : case LYS_LIST:
876 0 : if (yang_is_last_list_dnode(node)
877 0 : && yang_is_last_level_dnode(node)) {
878 0 : if (node->parent
879 0 : && (node->parent->schema->module
880 0 : == dnode->schema->module))
881 0 : node = lyd_parent(node);
882 : else
883 : parent = false;
884 : } else
885 : parent = false;
886 : break;
887 : default:
888 : parent = false;
889 : break;
890 : }
891 : }
892 : return node;
893 : }
894 :
895 0 : uint32_t yang_get_list_pos(const struct lyd_node *node)
896 : {
897 0 : return lyd_list_pos(node);
898 : }
899 :
900 108 : uint32_t yang_get_list_elements_count(const struct lyd_node *node)
901 : {
902 108 : unsigned int count;
903 108 : const struct lysc_node *schema;
904 :
905 108 : if (!node
906 74 : || ((node->schema->nodetype != LYS_LIST)
907 74 : && (node->schema->nodetype != LYS_LEAFLIST))) {
908 : return 0;
909 : }
910 :
911 : schema = node->schema;
912 : count = 0;
913 80 : do {
914 80 : if (node->schema == schema)
915 80 : ++count;
916 80 : node = node->next;
917 80 : } while (node);
918 : return count;
919 : }
|
