]> git.proxmox.com Git - mirror_frr.git/blame - lib/northbound.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #3770 from donaldsharp/detailed_debugs
[mirror_frr.git] / lib / northbound.c
CommitLineData
1c2facd1
RW		 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 "libfrr.h"
23#include "log.h"
24#include "lib_errors.h"
25#include "command.h"
26#include "db.h"
27#include "northbound.h"
28#include "northbound_cli.h"
29#include "northbound_db.h"
30
31DEFINE_MTYPE_STATIC(LIB, NB_NODE, "Northbound Node")
32DEFINE_MTYPE_STATIC(LIB, NB_CONFIG, "Northbound Configuration")
33
34/* Running configuration - shouldn't be modified directly. */
35struct nb_config *running_config;
36
37/*
38 * Global lock used to prevent multiple configuration transactions from
39 * happening concurrently.
40 */
41static bool transaction_in_progress;
42
43static int nb_configuration_callback(const enum nb_event event,
44 struct nb_config_change *change);
45static struct nb_transaction *nb_transaction_new(struct nb_config *config,
46 struct nb_config_cbs *changes,
47 enum nb_client client,
48 const char *comment);
49static void nb_transaction_free(struct nb_transaction *transaction);
50static int nb_transaction_process(enum nb_event event,
51 struct nb_transaction *transaction);
52static void nb_transaction_apply_finish(struct nb_transaction *transaction);
1a4bc045
RW		 53static int nb_oper_data_iter_node(const struct lys_node *snode,
54 const char *xpath, const void *list_entry,
55 const struct yang_list_keys *list_keys,
56 struct yang_translator *translator,
57 bool first, uint32_t flags,
58 nb_oper_data_cb cb, void *arg);
1c2facd1 59
544ca69a
RW		 60static int nb_node_check_config_only(const struct lys_node *snode, void *arg)
61{
62 bool *config_only = arg;
63
64 if (CHECK_FLAG(snode->flags, LYS_CONFIG_R)) {
65 *config_only = false;
66 return YANG_ITER_STOP;
67 }
68
69 return YANG_ITER_CONTINUE;
70}
71
e0ccfad2 72static int nb_node_new_cb(const struct lys_node *snode, void *arg)
1c2facd1
RW		 73{
74 struct nb_node *nb_node;
75 struct lys_node *sparent, *sparent_list;
76
77 nb_node = XCALLOC(MTYPE_NB_NODE, sizeof(*nb_node));
78 yang_snode_get_path(snode, YANG_PATH_DATA, nb_node->xpath,
79 sizeof(nb_node->xpath));
80 nb_node->priority = NB_DFLT_PRIORITY;
81 sparent = yang_snode_real_parent(snode);
82 if (sparent)
83 nb_node->parent = sparent->priv;
84 sparent_list = yang_snode_parent_list(snode);
85 if (sparent_list)
86 nb_node->parent_list = sparent_list->priv;
87
544ca69a
RW		 88 /* Set flags. */
89 if (CHECK_FLAG(snode->nodetype, LYS_CONTAINER | LYS_LIST)) {
90 bool config_only = true;
91
92 yang_snodes_iterate_subtree(snode, nb_node_check_config_only,
93 YANG_ITER_ALLOW_AUGMENTATIONS,
94 &config_only);
95 if (config_only)
96 SET_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY);
97 }
99fb518f
RW		 98 if (CHECK_FLAG(snode->nodetype, LYS_LIST)) {
99 struct lys_node_list *slist;
100
101 slist = (struct lys_node_list *)snode;
102 if (slist->keys_size == 0)
103 SET_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST);
104 }
544ca69a 105
1c2facd1
RW		 106 /*
107 * Link the northbound node and the libyang schema node with one
108 * another.
109 */
110 nb_node->snode = snode;
111 lys_set_private(snode, nb_node);
e0ccfad2
RW		 112
113 return YANG_ITER_CONTINUE;
1c2facd1
RW		 114}
115
e0ccfad2 116static int nb_node_del_cb(const struct lys_node *snode, void *arg)
1c2facd1
RW		 117{
118 struct nb_node *nb_node;
119
120 nb_node = snode->priv;
121 lys_set_private(snode, NULL);
122 XFREE(MTYPE_NB_NODE, nb_node);
e0ccfad2
RW		 123
124 return YANG_ITER_CONTINUE;
1c2facd1
RW		 125}
126
544ca69a
RW		 127void nb_nodes_create(void)
128{
129 yang_snodes_iterate_all(nb_node_new_cb, 0, NULL);
130}
131
132void nb_nodes_delete(void)
133{
134 yang_snodes_iterate_all(nb_node_del_cb, 0, NULL);
135}
136
1c2facd1
RW		 137struct nb_node *nb_node_find(const char *xpath)
138{
139 const struct lys_node *snode;
140
141 /*
142 * Use libyang to find the schema node associated to the xpath and get
143 * the northbound node from there (snode private pointer).
144 */
145 snode = ly_ctx_get_node(ly_native_ctx, NULL, xpath, 0);
146 if (!snode)
147 return NULL;
148
149 return snode->priv;
150}
151
152static int nb_node_validate_cb(const struct nb_node *nb_node,
153 enum nb_operation operation,
154 int callback_implemented, bool optional)
155{
156 bool valid;
157
158 valid = nb_operation_is_valid(operation, nb_node->snode);
159
160 if (!valid && callback_implemented)
161 flog_warn(EC_LIB_NB_CB_UNNEEDED,
162 "unneeded '%s' callback for '%s'",
163 nb_operation_name(operation), nb_node->xpath);
164
165 if (!optional && valid && !callback_implemented) {
166 flog_err(EC_LIB_NB_CB_MISSING, "missing '%s' callback for '%s'",
167 nb_operation_name(operation), nb_node->xpath);
168 return 1;
169 }
170
171 return 0;
172}
173
174/*
175 * Check if the required callbacks were implemented for the given northbound
176 * node.
177 */
178static unsigned int nb_node_validate_cbs(const struct nb_node *nb_node)
179
180{
181 unsigned int error = 0;
182
183 error += nb_node_validate_cb(nb_node, NB_OP_CREATE,
184 !!nb_node->cbs.create, false);
185 error += nb_node_validate_cb(nb_node, NB_OP_MODIFY,
186 !!nb_node->cbs.modify, false);
187 error += nb_node_validate_cb(nb_node, NB_OP_DELETE,
188 !!nb_node->cbs.delete, false);
189 error += nb_node_validate_cb(nb_node, NB_OP_MOVE, !!nb_node->cbs.move,
190 false);
191 error += nb_node_validate_cb(nb_node, NB_OP_APPLY_FINISH,
192 !!nb_node->cbs.apply_finish, true);
193 error += nb_node_validate_cb(nb_node, NB_OP_GET_ELEM,
194 !!nb_node->cbs.get_elem, false);
195 error += nb_node_validate_cb(nb_node, NB_OP_GET_NEXT,
196 !!nb_node->cbs.get_next, false);
197 error += nb_node_validate_cb(nb_node, NB_OP_GET_KEYS,
198 !!nb_node->cbs.get_keys, false);
199 error += nb_node_validate_cb(nb_node, NB_OP_LOOKUP_ENTRY,
200 !!nb_node->cbs.lookup_entry, false);
201 error += nb_node_validate_cb(nb_node, NB_OP_RPC, !!nb_node->cbs.rpc,
202 false);
203
204 return error;
205}
206
207static unsigned int nb_node_validate_priority(const struct nb_node *nb_node)
208{
209 /* Top-level nodes can have any priority. */
210 if (!nb_node->parent)
211 return 0;
212
213 if (nb_node->priority < nb_node->parent->priority) {
214 flog_err(EC_LIB_NB_CB_INVALID_PRIO,
215 "node has higher priority than its parent [xpath %s]",
216 nb_node->xpath);
217 return 1;
218 }
219
220 return 0;
221}
222
e0ccfad2 223static int nb_node_validate(const struct lys_node *snode, void *arg)
1c2facd1
RW		 224{
225 struct nb_node *nb_node = snode->priv;
e0ccfad2 226 unsigned int *errors = arg;
1c2facd1
RW		 227
228 /* Validate callbacks and priority. */
229 *errors += nb_node_validate_cbs(nb_node);
230 *errors += nb_node_validate_priority(nb_node);
e0ccfad2
RW		 231
232 return YANG_ITER_CONTINUE;
1c2facd1
RW		 233}
234
235struct nb_config *nb_config_new(struct lyd_node *dnode)
236{
237 struct nb_config *config;
238
239 config = XCALLOC(MTYPE_NB_CONFIG, sizeof(*config));
240 if (dnode)
241 config->dnode = dnode;
242 else
5e02643a 243 config->dnode = yang_dnode_new(ly_native_ctx, true);
1c2facd1
RW		 244 config->version = 0;
245
246 return config;
247}
248
249void nb_config_free(struct nb_config *config)
250{
251 if (config->dnode)
252 yang_dnode_free(config->dnode);
253 XFREE(MTYPE_NB_CONFIG, config);
254}
255
256struct nb_config *nb_config_dup(const struct nb_config *config)
257{
258 struct nb_config *dup;
259
260 dup = XCALLOC(MTYPE_NB_CONFIG, sizeof(*dup));
261 dup->dnode = yang_dnode_dup(config->dnode);
262 dup->version = config->version;
263
264 return dup;
265}
266
267int nb_config_merge(struct nb_config *config_dst, struct nb_config *config_src,
268 bool preserve_source)
269{
270 int ret;
271
272 ret = lyd_merge(config_dst->dnode, config_src->dnode, LYD_OPT_EXPLICIT);
273 if (ret != 0)
274 flog_warn(EC_LIB_LIBYANG, "%s: lyd_merge() failed", __func__);
275
276 if (!preserve_source)
277 nb_config_free(config_src);
278
279 return (ret == 0) ? NB_OK : NB_ERR;
280}
281
282void nb_config_replace(struct nb_config *config_dst,
283 struct nb_config *config_src, bool preserve_source)
284{
285 /* Update version. */
286 if (config_src->version != 0)
287 config_dst->version = config_src->version;
288
289 /* Update dnode. */
e5dc8a44
RW		 290 if (config_dst->dnode)
291 yang_dnode_free(config_dst->dnode);
1c2facd1
RW		 292 if (preserve_source) {
293 config_dst->dnode = yang_dnode_dup(config_src->dnode);
294 } else {
295 config_dst->dnode = config_src->dnode;
296 config_src->dnode = NULL;
297 nb_config_free(config_src);
298 }
299}
300
301/* Generate the nb_config_cbs tree. */
302static inline int nb_config_cb_compare(const struct nb_config_cb *a,
303 const struct nb_config_cb *b)
304{
305 /* Sort by priority first. */
306 if (a->nb_node->priority < b->nb_node->priority)
307 return -1;
308 if (a->nb_node->priority > b->nb_node->priority)
309 return 1;
310
311 /*
312 * Use XPath as a tie-breaker. This will naturally sort parent nodes
313 * before their children.
314 */
315 return strcmp(a->xpath, b->xpath);
316}
317RB_GENERATE(nb_config_cbs, nb_config_cb, entry, nb_config_cb_compare);
318
319static void nb_config_diff_add_change(struct nb_config_cbs *changes,
320 enum nb_operation operation,
321 const struct lyd_node *dnode)
322{
323 struct nb_config_change *change;
324
325 change = XCALLOC(MTYPE_TMP, sizeof(*change));
326 change->cb.operation = operation;
327 change->cb.nb_node = dnode->schema->priv;
328 yang_dnode_get_path(dnode, change->cb.xpath, sizeof(change->cb.xpath));
329 change->cb.dnode = dnode;
330
331 RB_INSERT(nb_config_cbs, changes, &change->cb);
332}
333
334static void nb_config_diff_del_changes(struct nb_config_cbs *changes)
335{
336 while (!RB_EMPTY(nb_config_cbs, changes)) {
337 struct nb_config_change *change;
338
339 change = (struct nb_config_change *)RB_ROOT(nb_config_cbs,
340 changes);
341 RB_REMOVE(nb_config_cbs, changes, &change->cb);
342 XFREE(MTYPE_TMP, change);
343 }
344}
345
346/*
347 * Helper function used when calculating the delta between two different
348 * configurations. Given a new subtree, calculate all new YANG data nodes,
349 * excluding default leafs and leaf-lists. This is a recursive function.
350 */
351static void nb_config_diff_new_subtree(const struct lyd_node *dnode,
352 struct nb_config_cbs *changes)
353{
354 struct lyd_node *child;
355
356 LY_TREE_FOR (dnode->child, child) {
357 enum nb_operation operation;
358
359 switch (child->schema->nodetype) {
360 case LYS_LEAF:
361 case LYS_LEAFLIST:
362 if (lyd_wd_default((struct lyd_node_leaf_list *)child))
363 break;
364
365 if (nb_operation_is_valid(NB_OP_CREATE, child->schema))
366 operation = NB_OP_CREATE;
367 else if (nb_operation_is_valid(NB_OP_MODIFY,
368 child->schema))
369 operation = NB_OP_MODIFY;
370 else
371 continue;
372
373 nb_config_diff_add_change(changes, operation, child);
374 break;
375 case LYS_CONTAINER:
376 case LYS_LIST:
377 if (nb_operation_is_valid(NB_OP_CREATE, child->schema))
378 nb_config_diff_add_change(changes, NB_OP_CREATE,
379 child);
380 nb_config_diff_new_subtree(child, changes);
381 break;
382 default:
383 break;
384 }
385 }
386}
387
388/* Calculate the delta between two different configurations. */
389static void nb_config_diff(const struct nb_config *config1,
390 const struct nb_config *config2,
391 struct nb_config_cbs *changes)
392{
393 struct lyd_difflist *diff;
394
395 diff = lyd_diff(config1->dnode, config2->dnode,
396 LYD_DIFFOPT_WITHDEFAULTS);
397 assert(diff);
398
399 for (int i = 0; diff->type[i] != LYD_DIFF_END; i++) {
400 LYD_DIFFTYPE type;
401 struct lyd_node *dnode;
402 enum nb_operation operation;
403
404 type = diff->type[i];
405
406 switch (type) {
407 case LYD_DIFF_CREATED:
408 dnode = diff->second[i];
409
410 if (nb_operation_is_valid(NB_OP_CREATE, dnode->schema))
411 operation = NB_OP_CREATE;
412 else if (nb_operation_is_valid(NB_OP_MODIFY,
413 dnode->schema))
414 operation = NB_OP_MODIFY;
415 else
416 continue;
417 break;
418 case LYD_DIFF_DELETED:
419 dnode = diff->first[i];
420 operation = NB_OP_DELETE;
421 break;
422 case LYD_DIFF_CHANGED:
423 dnode = diff->second[i];
424 operation = NB_OP_MODIFY;
425 break;
426 case LYD_DIFF_MOVEDAFTER1:
427 case LYD_DIFF_MOVEDAFTER2:
428 default:
429 continue;
430 }
431
432 nb_config_diff_add_change(changes, operation, dnode);
433
434 if (type == LYD_DIFF_CREATED
db452508
RW		 435 && CHECK_FLAG(dnode->schema->nodetype,
436 LYS_CONTAINER | LYS_LIST))
1c2facd1
RW		 437 nb_config_diff_new_subtree(dnode, changes);
438 }
439
440 lyd_free_diff(diff);
441}
442
443int nb_candidate_edit(struct nb_config *candidate,
444 const struct nb_node *nb_node,
445 enum nb_operation operation, const char *xpath,
446 const struct yang_data *previous,
447 const struct yang_data *data)
448{
449 struct lyd_node *dnode;
450 char xpath_edit[XPATH_MAXLEN];
451
452 if (!nb_operation_is_valid(operation, nb_node->snode)) {
453 flog_warn(EC_LIB_NB_CANDIDATE_EDIT_ERROR,
454 "%s: %s operation not valid for %s", __func__,
455 nb_operation_name(operation), xpath);
456 return NB_ERR;
457 }
458
459 /* Use special notation for leaf-lists (RFC 6020, section 9.13.5). */
460 if (nb_node->snode->nodetype == LYS_LEAFLIST)
461 snprintf(xpath_edit, sizeof(xpath_edit), "%s[.='%s']", xpath,
462 data->value);
463 else
464 strlcpy(xpath_edit, xpath, sizeof(xpath_edit));
465
466 switch (operation) {
467 case NB_OP_CREATE:
468 case NB_OP_MODIFY:
469 ly_errno = 0;
470 dnode = lyd_new_path(candidate->dnode, ly_native_ctx,
471 xpath_edit, (void *)data->value, 0,
472 LYD_PATH_OPT_UPDATE);
473 if (!dnode && ly_errno) {
474 flog_warn(EC_LIB_LIBYANG, "%s: lyd_new_path() failed",
475 __func__);
476 return NB_ERR;
477 }
478
479 /*
480 * If a new node was created, call lyd_validate() only to create
481 * default child nodes.
482 */
483 if (dnode) {
484 lyd_schema_sort(dnode, 0);
485 lyd_validate(&dnode, LYD_OPT_CONFIG, ly_native_ctx);
486 }
487 break;
488 case NB_OP_DELETE:
489 dnode = yang_dnode_get(candidate->dnode, xpath_edit);
490 if (!dnode)
491 /*
492 * Return a special error code so the caller can choose
493 * whether to ignore it or not.
494 */
495 return NB_ERR_NOT_FOUND;
496 lyd_free(dnode);
497 break;
498 case NB_OP_MOVE:
499 /* TODO: update configuration. */
500 break;
501 default:
502 flog_warn(EC_LIB_DEVELOPMENT,
503 "%s: unknown operation (%u) [xpath %s]", __func__,
504 operation, xpath_edit);
505 return NB_ERR;
506 }
507
508 return NB_OK;
509}
510
511bool nb_candidate_needs_update(const struct nb_config *candidate)
512{
513 if (candidate->version < running_config->version)
514 return true;
515
516 return false;
517}
518
519int nb_candidate_update(struct nb_config *candidate)
520{
521 struct nb_config *updated_config;
522
523 updated_config = nb_config_dup(running_config);
524 if (nb_config_merge(updated_config, candidate, true) != NB_OK)
525 return NB_ERR;
526
527 nb_config_replace(candidate, updated_config, false);
528
529 return NB_OK;
530}
531
532/*
533 * The northbound configuration callbacks use the 'priv' pointer present in the
534 * libyang lyd_node structure to store pointers to FRR internal variables
535 * associated to YANG lists and presence containers. Before commiting a
536 * candidate configuration, we must restore the 'priv' pointers stored in the
537 * running configuration since they might be lost while editing the candidate.
538 */
539static void nb_candidate_restore_priv_pointers(struct nb_config *candidate)
540{
541 struct lyd_node *root, *next, *dnode_iter;
542
543 LY_TREE_FOR (running_config->dnode, root) {
544 LY_TREE_DFS_BEGIN (root, next, dnode_iter) {
545 struct lyd_node *dnode_candidate;
546 char xpath[XPATH_MAXLEN];
547
548 if (!dnode_iter->priv)
549 goto next;
550
551 yang_dnode_get_path(dnode_iter, xpath, sizeof(xpath));
552 dnode_candidate =
553 yang_dnode_get(candidate->dnode, xpath);
554 if (dnode_candidate)
555 yang_dnode_set_entry(dnode_candidate,
556 dnode_iter->priv);
557
558 next:
559 LY_TREE_DFS_END(root, next, dnode_iter);
560 }
561 }
562}
563
564/*
565 * Perform YANG syntactic and semantic validation.
566 *
567 * WARNING: lyd_validate() can change the configuration as part of the
568 * validation process.
569 */
570static int nb_candidate_validate_yang(struct nb_config *candidate)
571{
572 if (lyd_validate(&candidate->dnode, LYD_OPT_STRICT | LYD_OPT_CONFIG,
573 ly_native_ctx)
574 != 0)
575 return NB_ERR_VALIDATION;
576
577 return NB_OK;
578}
579
580/* Perform code-level validation using the northbound callbacks. */
581static int nb_candidate_validate_changes(struct nb_config *candidate,
582 struct nb_config_cbs *changes)
583{
584 struct nb_config_cb *cb;
585
586 nb_candidate_restore_priv_pointers(candidate);
587 RB_FOREACH (cb, nb_config_cbs, changes) {
588 struct nb_config_change *change = (struct nb_config_change *)cb;
589 int ret;
590
591 ret = nb_configuration_callback(NB_EV_VALIDATE, change);
592 if (ret != NB_OK)
593 return NB_ERR_VALIDATION;
594 }
595
596 return NB_OK;
597}
598
599int nb_candidate_validate(struct nb_config *candidate)
600{
601 struct nb_config_cbs changes;
602 int ret;
603
604 if (nb_candidate_validate_yang(candidate) != NB_OK)
605 return NB_ERR_VALIDATION;
606
607 RB_INIT(nb_config_cbs, &changes);
608 nb_config_diff(running_config, candidate, &changes);
609 ret = nb_candidate_validate_changes(candidate, &changes);
610 nb_config_diff_del_changes(&changes);
611
612 return ret;
613}
614
615int nb_candidate_commit_prepare(struct nb_config *candidate,
616 enum nb_client client, const char *comment,
617 struct nb_transaction **transaction)
618{
619 struct nb_config_cbs changes;
620
621 if (nb_candidate_validate_yang(candidate) != NB_OK) {
622 flog_warn(EC_LIB_NB_CANDIDATE_INVALID,
623 "%s: failed to validate candidate configuration",
624 __func__);
625 return NB_ERR_VALIDATION;
626 }
627
628 RB_INIT(nb_config_cbs, &changes);
629 nb_config_diff(running_config, candidate, &changes);
630 if (RB_EMPTY(nb_config_cbs, &changes))
631 return NB_ERR_NO_CHANGES;
632
633 if (nb_candidate_validate_changes(candidate, &changes) != NB_OK) {
634 flog_warn(EC_LIB_NB_CANDIDATE_INVALID,
635 "%s: failed to validate candidate configuration",
636 __func__);
637 nb_config_diff_del_changes(&changes);
638 return NB_ERR_VALIDATION;
639 }
640
641 *transaction = nb_transaction_new(candidate, &changes, client, comment);
642 if (*transaction == NULL) {
643 flog_warn(EC_LIB_NB_TRANSACTION_CREATION_FAILED,
644 "%s: failed to create transaction", __func__);
645 nb_config_diff_del_changes(&changes);
646 return NB_ERR_LOCKED;
647 }
648
649 return nb_transaction_process(NB_EV_PREPARE, *transaction);
650}
651
652void nb_candidate_commit_abort(struct nb_transaction *transaction)
653{
654 (void)nb_transaction_process(NB_EV_ABORT, transaction);
655 nb_transaction_free(transaction);
656}
657
658void nb_candidate_commit_apply(struct nb_transaction *transaction,
659 bool save_transaction, uint32_t *transaction_id)
660{
661 (void)nb_transaction_process(NB_EV_APPLY, transaction);
662 nb_transaction_apply_finish(transaction);
663
664 /* Replace running by candidate. */
665 transaction->config->version++;
666 nb_config_replace(running_config, transaction->config, true);
667
668 /* Record transaction. */
669 if (save_transaction
670 && nb_db_transaction_save(transaction, transaction_id) != NB_OK)
671 flog_warn(EC_LIB_NB_TRANSACTION_RECORD_FAILED,
672 "%s: failed to record transaction", __func__);
673
674 nb_transaction_free(transaction);
675}
676
677int nb_candidate_commit(struct nb_config *candidate, enum nb_client client,
678 bool save_transaction, const char *comment,
679 uint32_t *transaction_id)
680{
681 struct nb_transaction *transaction = NULL;
682 int ret;
683
684 ret = nb_candidate_commit_prepare(candidate, client, comment,
685 &transaction);
686 /*
687 * Apply the changes if the preparation phase succeeded. Otherwise abort
688 * the transaction.
689 */
690 if (ret == NB_OK)
691 nb_candidate_commit_apply(transaction, save_transaction,
692 transaction_id);
693 else if (transaction != NULL)
694 nb_candidate_commit_abort(transaction);
695
696 return ret;
697}
698
699static void nb_log_callback(const enum nb_event event,
700 enum nb_operation operation, const char *xpath,
701 const char *value)
702{
703 zlog_debug(
704 "northbound callback: event [%s] op [%s] xpath [%s] value [%s]",
705 nb_event_name(event), nb_operation_name(operation), xpath,
706 value);
707}
708
709/*
710 * Call the northbound configuration callback associated to a given
711 * configuration change.
712 */
713static int nb_configuration_callback(const enum nb_event event,
714 struct nb_config_change *change)
715{
716 enum nb_operation operation = change->cb.operation;
717 const char *xpath = change->cb.xpath;
718 const struct nb_node *nb_node = change->cb.nb_node;
719 const struct lyd_node *dnode = change->cb.dnode;
720 union nb_resource *resource;
721 int ret = NB_ERR;
722
723 if (debug_northbound) {
724 const char *value = "(none)";
725
726 if (dnode && !yang_snode_is_typeless_data(dnode->schema))
727 value = yang_dnode_get_string(dnode, NULL);
728
729 nb_log_callback(event, operation, xpath, value);
730 }
731
732 if (event == NB_EV_VALIDATE)
733 resource = NULL;
734 else
735 resource = &change->resource;
736
737 switch (operation) {
738 case NB_OP_CREATE:
739 ret = (*nb_node->cbs.create)(event, dnode, resource);
740 break;
741 case NB_OP_MODIFY:
742 ret = (*nb_node->cbs.modify)(event, dnode, resource);
743 break;
744 case NB_OP_DELETE:
745 ret = (*nb_node->cbs.delete)(event, dnode);
746 break;
747 case NB_OP_MOVE:
748 ret = (*nb_node->cbs.move)(event, dnode);
749 break;
750 default:
751 break;
752 }
753
625b70e3 754 if (ret != NB_OK) {
ec348d43
RW		 755 enum lib_log_refs ref = 0;
756
625b70e3
EDP		 757 switch (event) {
758 case NB_EV_VALIDATE:
759 ref = EC_LIB_NB_CB_CONFIG_VALIDATE;
760 break;
761 case NB_EV_PREPARE:
762 ref = EC_LIB_NB_CB_CONFIG_PREPARE;
763 break;
764 case NB_EV_ABORT:
765 ref = EC_LIB_NB_CB_CONFIG_ABORT;
766 break;
767 case NB_EV_APPLY:
768 ref = EC_LIB_NB_CB_CONFIG_APPLY;
769 break;
770 }
771 if (event == NB_EV_VALIDATE || event == NB_EV_PREPARE)
772 flog_warn(
773 ref,
774 "%s: error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]",
775 __func__, nb_err_name(ret),
776 nb_event_name(event),
777 nb_operation_name(operation), xpath);
778 else
779 flog_err(
780 ref,
781 "%s: error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]",
782 __func__, nb_err_name(ret),
783 nb_event_name(event),
784 nb_operation_name(operation), xpath);
785 }
1c2facd1
RW		 786
787 return ret;
788}
789
790static struct nb_transaction *nb_transaction_new(struct nb_config *config,
791 struct nb_config_cbs *changes,
792 enum nb_client client,
793 const char *comment)
794{
795 struct nb_transaction *transaction;
796
797 if (transaction_in_progress) {
798 flog_warn(
799 EC_LIB_NB_TRANSACTION_CREATION_FAILED,
800 "%s: error - there's already another transaction in progress",
801 __func__);
802 return NULL;
803 }
804 transaction_in_progress = true;
805
806 transaction = XCALLOC(MTYPE_TMP, sizeof(*transaction));
807 transaction->client = client;
808 if (comment)
809 strlcpy(transaction->comment, comment,
810 sizeof(transaction->comment));
811 transaction->config = config;
812 transaction->changes = *changes;
813
814 return transaction;
815}
816
817static void nb_transaction_free(struct nb_transaction *transaction)
818{
819 nb_config_diff_del_changes(&transaction->changes);
820 XFREE(MTYPE_TMP, transaction);
821 transaction_in_progress = false;
822}
823
824/* Process all configuration changes associated to a transaction. */
825static int nb_transaction_process(enum nb_event event,
826 struct nb_transaction *transaction)
827{
828 struct nb_config_cb *cb;
829
830 RB_FOREACH (cb, nb_config_cbs, &transaction->changes) {
831 struct nb_config_change *change = (struct nb_config_change *)cb;
832 int ret;
833
834 /*
835 * Only try to release resources that were allocated
836 * successfully.
837 */
838 if (event == NB_EV_ABORT && change->prepare_ok == false)
839 break;
840
841 /* Call the appropriate callback. */
842 ret = nb_configuration_callback(event, change);
843 switch (event) {
844 case NB_EV_PREPARE:
845 if (ret != NB_OK)
846 return ret;
847 change->prepare_ok = true;
848 break;
849 case NB_EV_ABORT:
850 case NB_EV_APPLY:
851 /*
852 * At this point it's not possible to reject the
853 * transaction anymore, so any failure here can lead to
854 * inconsistencies and should be treated as a bug.
855 * Operations prone to errors, like validations and
856 * resource allocations, should be performed during the
857 * 'prepare' phase.
858 */
859 break;
860 default:
861 break;
862 }
863 }
864
865 return NB_OK;
866}
867
868static struct nb_config_cb *
869nb_apply_finish_cb_new(struct nb_config_cbs *cbs, const char *xpath,
870 const struct nb_node *nb_node,
871 const struct lyd_node *dnode)
872{
873 struct nb_config_cb *cb;
874
875 cb = XCALLOC(MTYPE_TMP, sizeof(*cb));
876 strlcpy(cb->xpath, xpath, sizeof(cb->xpath));
877 cb->nb_node = nb_node;
878 cb->dnode = dnode;
879 RB_INSERT(nb_config_cbs, cbs, cb);
880
881 return cb;
882}
883
884static struct nb_config_cb *
885nb_apply_finish_cb_find(struct nb_config_cbs *cbs, const char *xpath,
886 const struct nb_node *nb_node)
887{
888 struct nb_config_cb s;
889
890 strlcpy(s.xpath, xpath, sizeof(s.xpath));
891 s.nb_node = nb_node;
892 return RB_FIND(nb_config_cbs, cbs, &s);
893}
894
895/* Call the 'apply_finish' callbacks. */
896static void nb_transaction_apply_finish(struct nb_transaction *transaction)
897{
898 struct nb_config_cbs cbs;
899 struct nb_config_cb *cb;
900
901 /* Initialize tree of 'apply_finish' callbacks. */
902 RB_INIT(nb_config_cbs, &cbs);
903
904 /* Identify the 'apply_finish' callbacks that need to be called. */
905 RB_FOREACH (cb, nb_config_cbs, &transaction->changes) {
906 struct nb_config_change *change = (struct nb_config_change *)cb;
907 const struct lyd_node *dnode = change->cb.dnode;
908
909 /*
910 * Iterate up to the root of the data tree. When a node is being
911 * deleted, skip its 'apply_finish' callback if one is defined
912 * (the 'apply_finish' callbacks from the node ancestors should
913 * be called though).
914 */
915 if (change->cb.operation == NB_OP_DELETE) {
916 char xpath[XPATH_MAXLEN];
917
918 dnode = dnode->parent;
919 if (!dnode)
920 break;
921
922 /*
923 * The dnode from 'delete' callbacks point to elements
924 * from the running configuration. Use yang_dnode_get()
925 * to get the corresponding dnode from the candidate
926 * configuration that is being committed.
927 */
928 yang_dnode_get_path(dnode, xpath, sizeof(xpath));
929 dnode = yang_dnode_get(transaction->config->dnode,
930 xpath);
931 }
932 while (dnode) {
933 char xpath[XPATH_MAXLEN];
934 struct nb_node *nb_node;
935
936 nb_node = dnode->schema->priv;
937 if (!nb_node->cbs.apply_finish)
938 goto next;
939
940 /*
941 * Don't call the callback more than once for the same
942 * data node.
943 */
944 yang_dnode_get_path(dnode, xpath, sizeof(xpath));
945 if (nb_apply_finish_cb_find(&cbs, xpath, nb_node))
946 goto next;
947
948 nb_apply_finish_cb_new(&cbs, xpath, nb_node, dnode);
949
950 next:
951 dnode = dnode->parent;
952 }
953 }
954
955 /* Call the 'apply_finish' callbacks, sorted by their priorities. */
956 RB_FOREACH (cb, nb_config_cbs, &cbs) {
957 if (debug_northbound)
958 nb_log_callback(NB_EV_APPLY, NB_OP_APPLY_FINISH,
959 cb->xpath, NULL);
960
961 (*cb->nb_node->cbs.apply_finish)(cb->dnode);
962 }
963
964 /* Release memory. */
965 while (!RB_EMPTY(nb_config_cbs, &cbs)) {
966 cb = RB_ROOT(nb_config_cbs, &cbs);
967 RB_REMOVE(nb_config_cbs, &cbs, cb);
968 XFREE(MTYPE_TMP, cb);
969 }
970}
971
1a4bc045
RW		 972static int nb_oper_data_iter_children(const struct lys_node *snode,
973 const char *xpath, const void *list_entry,
974 const struct yang_list_keys *list_keys,
975 struct yang_translator *translator,
976 bool first, uint32_t flags,
977 nb_oper_data_cb cb, void *arg)
978{
979 struct lys_node *child;
980
981 LY_TREE_FOR (snode->child, child) {
982 int ret;
983
984 ret = nb_oper_data_iter_node(child, xpath, list_entry,
985 list_keys, translator, false,
986 flags, cb, arg);
987 if (ret != NB_OK)
988 return ret;
989 }
990
991 return NB_OK;
992}
993
994static int nb_oper_data_iter_leaf(const struct nb_node *nb_node,
995 const char *xpath, const void *list_entry,
996 const struct yang_list_keys *list_keys,
997 struct yang_translator *translator,
998 uint32_t flags, nb_oper_data_cb cb, void *arg)
999{
1000 struct yang_data *data;
1001
1002 if (CHECK_FLAG(nb_node->snode->flags, LYS_CONFIG_W))
1003 return NB_OK;
1004
1005 /* Ignore list keys. */
1006 if (lys_is_key((struct lys_node_leaf *)nb_node->snode, NULL))
1007 return NB_OK;
1008
1009 data = nb_node->cbs.get_elem(xpath, list_entry);
1010 if (data == NULL)
1011 /* Leaf of type "empty" is not present. */
1012 return NB_OK;
1013
1014 return (*cb)(nb_node->snode, translator, data, arg);
1015}
1016
1017static int nb_oper_data_iter_container(const struct nb_node *nb_node,
1018 const char *xpath,
1019 const void *list_entry,
1020 const struct yang_list_keys *list_keys,
1021 struct yang_translator *translator,
1022 uint32_t flags, nb_oper_data_cb cb,
1023 void *arg)
1024{
1025 if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
1026 return NB_OK;
1027
1028 /* Presence containers. */
1029 if (nb_node->cbs.get_elem) {
1030 struct yang_data *data;
1031 int ret;
1032
1033 data = nb_node->cbs.get_elem(xpath, list_entry);
1034 if (data == NULL)
1035 /* Presence container is not present. */
1036 return NB_OK;
1037
1038 ret = (*cb)(nb_node->snode, translator, data, arg);
1039 if (ret != NB_OK)
1040 return ret;
1041 }
1042
1043 /* Iterate over the child nodes. */
1044 return nb_oper_data_iter_children(nb_node->snode, xpath, list_entry,
1045 list_keys, translator, false, flags,
1046 cb, arg);
1047}
1048
1049static int
1050nb_oper_data_iter_leaflist(const struct nb_node *nb_node, const char *xpath,
1051 const void *parent_list_entry,
1052 const struct yang_list_keys *parent_list_keys,
1053 struct yang_translator *translator, uint32_t flags,
1054 nb_oper_data_cb cb, void *arg)
1055{
1056 const void *list_entry = NULL;
1057
1058 if (CHECK_FLAG(nb_node->snode->flags, LYS_CONFIG_W))
1059 return NB_OK;
1060
1061 do {
1062 struct yang_data *data;
1063 int ret;
1064
1065 list_entry =
1066 nb_node->cbs.get_next(parent_list_entry, list_entry);
1067 if (!list_entry)
1068 /* End of the list. */
1069 break;
1070
1071 data = nb_node->cbs.get_elem(xpath, list_entry);
1072 if (data == NULL)
1073 continue;
1074
1075 ret = (*cb)(nb_node->snode, translator, data, arg);
1076 if (ret != NB_OK)
1077 return ret;
1078 } while (list_entry);
1079
1080 return NB_OK;
1081}
1082
1083static int nb_oper_data_iter_list(const struct nb_node *nb_node,
1084 const char *xpath_list,
1085 const void *parent_list_entry,
1086 const struct yang_list_keys *parent_list_keys,
1087 struct yang_translator *translator,
1088 uint32_t flags, nb_oper_data_cb cb, void *arg)
1089{
1090 struct lys_node_list *slist = (struct lys_node_list *)nb_node->snode;
1091 const void *list_entry = NULL;
99fb518f 1092 uint32_t position = 1;
1a4bc045
RW		 1093
1094 if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
1095 return NB_OK;
1096
1097 /* Iterate over all list entries. */
1098 do {
1099 struct yang_list_keys list_keys;
f999f11e 1100 char xpath[XPATH_MAXLEN * 2];
1a4bc045
RW		 1101 int ret;
1102
1103 /* Obtain list entry. */
1104 list_entry =
1105 nb_node->cbs.get_next(parent_list_entry, list_entry);
1106 if (!list_entry)
1107 /* End of the list. */
1108 break;
1109
99fb518f
RW		 1110 if (!CHECK_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST)) {
1111 /* Obtain the list entry keys. */
1112 if (nb_node->cbs.get_keys(list_entry, &list_keys)
1113 != NB_OK) {
1114 flog_warn(EC_LIB_NB_CB_STATE,
1115 "%s: failed to get list keys",
1116 __func__);
1117 return NB_ERR;
1118 }
1119
1120 /* Build XPath of the list entry. */
1121 strlcpy(xpath, xpath_list, sizeof(xpath));
1122 for (unsigned int i = 0; i < list_keys.num; i++) {
1123 snprintf(xpath + strlen(xpath),
1124 sizeof(xpath) - strlen(xpath),
1125 "[%s='%s']", slist->keys[i]->name,
1126 list_keys.key[i]);
1127 }
1128 } else {
1129 /*
1130 * Keyless list - build XPath using a positional index.
1131 */
1132 snprintf(xpath, sizeof(xpath), "%s[%u]", xpath_list,
1133 position);
1134 position++;
1a4bc045
RW		 1135 }
1136
1137 /* Iterate over the child nodes. */
1138 ret = nb_oper_data_iter_children(
1139 nb_node->snode, xpath, list_entry, &list_keys,
1140 translator, false, flags, cb, arg);
1141 if (ret != NB_OK)
1142 return ret;
1143 } while (list_entry);
1144
1145 return NB_OK;
1146}
1147
1148static int nb_oper_data_iter_node(const struct lys_node *snode,
1149 const char *xpath_parent,
1150 const void *list_entry,
1151 const struct yang_list_keys *list_keys,
1152 struct yang_translator *translator,
1153 bool first, uint32_t flags,
1154 nb_oper_data_cb cb, void *arg)
1155{
1156 struct nb_node *nb_node;
1157 char xpath[XPATH_MAXLEN];
1158 int ret = NB_OK;
1159
1160 if (!first && CHECK_FLAG(flags, NB_OPER_DATA_ITER_NORECURSE)
1161 && CHECK_FLAG(snode->nodetype, LYS_CONTAINER | LYS_LIST))
1162 return NB_OK;
1163
1164 /* Update XPath. */
1165 strlcpy(xpath, xpath_parent, sizeof(xpath));
1166 if (!first && snode->nodetype != LYS_USES)
1167 snprintf(xpath + strlen(xpath), sizeof(xpath) - strlen(xpath),
1168 "/%s", snode->name);
1169
1170 nb_node = snode->priv;
1171 switch (snode->nodetype) {
1172 case LYS_CONTAINER:
1173 ret = nb_oper_data_iter_container(nb_node, xpath, list_entry,
1174 list_keys, translator, flags,
1175 cb, arg);
1176 break;
1177 case LYS_LEAF:
1178 ret = nb_oper_data_iter_leaf(nb_node, xpath, list_entry,
1179 list_keys, translator, flags, cb,
1180 arg);
1181 break;
1182 case LYS_LEAFLIST:
1183 ret = nb_oper_data_iter_leaflist(nb_node, xpath, list_entry,
1184 list_keys, translator, flags,
1185 cb, arg);
1186 break;
1187 case LYS_LIST:
1188 ret = nb_oper_data_iter_list(nb_node, xpath, list_entry,
1189 list_keys, translator, flags, cb,
1190 arg);
1191 break;
1192 case LYS_USES:
1193 ret = nb_oper_data_iter_children(snode, xpath, list_entry,
1194 list_keys, translator, false,
1195 flags, cb, arg);
1196 break;
1197 default:
1198 break;
1199 }
1200
1201 return ret;
1202}
1203
1204int nb_oper_data_iterate(const char *xpath, struct yang_translator *translator,
1205 uint32_t flags, nb_oper_data_cb cb, void *arg)
1206{
1207 struct nb_node *nb_node;
1208 const void *list_entry = NULL;
1209 struct yang_list_keys list_keys;
1210 struct list *list_dnodes;
1211 struct lyd_node *dnode, *dn;
1212 struct listnode *ln;
1213 int ret;
1214
1215 nb_node = nb_node_find(xpath);
1216 if (!nb_node) {
1217 flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH,
1218 "%s: unknown data path: %s", __func__, xpath);
1219 return NB_ERR;
1220 }
1221
1222 /* For now this function works only with containers and lists. */
1223 if (!CHECK_FLAG(nb_node->snode->nodetype, LYS_CONTAINER | LYS_LIST)) {
1224 flog_warn(
1225 EC_LIB_NB_OPERATIONAL_DATA,
1226 "%s: can't iterate over YANG leaf or leaf-list [xpath %s]",
1227 __func__, xpath);
1228 return NB_ERR;
1229 }
1230
1231 /*
1232 * Create a data tree from the XPath so that we can parse the keys of
1233 * all YANG lists (if any).
1234 */
1235 ly_errno = 0;
1236 dnode = lyd_new_path(NULL, ly_native_ctx, xpath, NULL, 0,
1237 LYD_PATH_OPT_UPDATE);
1238 if (!dnode && ly_errno) {
1239 flog_warn(EC_LIB_LIBYANG, "%s: lyd_new_path() failed",
1240 __func__);
1241 return NB_ERR;
1242 }
1243 /*
1244 * We can remove the following two lines once we depend on
1245 * libyang-v0.16-r2, which has the LYD_PATH_OPT_NOPARENTRET flag for
1246 * lyd_new_path().
1247 */
1248 dnode = yang_dnode_get(dnode, xpath);
1249 assert(dnode);
1250
1251 /*
1252 * Create a linked list to sort the data nodes starting from the root.
1253 */
1254 list_dnodes = list_new();
1255 for (dn = dnode; dn; dn = dn->parent) {
1256 if (dn->schema->nodetype != LYS_LIST || !dn->child)
1257 continue;
1258 listnode_add_head(list_dnodes, dn);
1259 }
1260 /*
1261 * Use the northbound callbacks to find list entry pointer corresponding
1262 * to the given XPath.
1263 */
1264 for (ALL_LIST_ELEMENTS_RO(list_dnodes, ln, dn)) {
1265 struct lyd_node *child;
1266 struct nb_node *nn;
1267 unsigned int n = 0;
1268
1269 /* Obtain the list entry keys. */
1270 memset(&list_keys, 0, sizeof(list_keys));
1271 LY_TREE_FOR (dn->child, child) {
1272 if (!lys_is_key((struct lys_node_leaf *)child->schema,
1273 NULL))
1274 continue;
1275 strlcpy(list_keys.key[n],
1276 yang_dnode_get_string(child, NULL),
1277 sizeof(list_keys.key[n]));
1278 n++;
1279 }
1280 list_keys.num = n;
9f6de299
RW		 1281 if (list_keys.num
1282 != ((struct lys_node_list *)dn->schema)->keys_size) {
1283 list_delete(&list_dnodes);
1284 yang_dnode_free(dnode);
1285 return NB_ERR_NOT_FOUND;
1286 }
1a4bc045
RW		 1287
1288 /* Find the list entry pointer. */
1289 nn = dn->schema->priv;
1290 list_entry = nn->cbs.lookup_entry(list_entry, &list_keys);
1291 if (list_entry == NULL) {
1292 list_delete(&list_dnodes);
1293 yang_dnode_free(dnode);
1294 return NB_ERR_NOT_FOUND;
1295 }
1296 }
1297
1298 /* If a list entry was given, iterate over that list entry only. */
1299 if (dnode->schema->nodetype == LYS_LIST && dnode->child)
1300 ret = nb_oper_data_iter_children(
1301 nb_node->snode, xpath, list_entry, &list_keys,
1302 translator, true, flags, cb, arg);
1303 else
1304 ret = nb_oper_data_iter_node(nb_node->snode, xpath, list_entry,
1305 &list_keys, translator, true,
1306 flags, cb, arg);
1307
1308 list_delete(&list_dnodes);
1309 yang_dnode_free(dnode);
1310
1311 return ret;
1312}
1313
1c2facd1
RW		 1314bool nb_operation_is_valid(enum nb_operation operation,
1315 const struct lys_node *snode)
1316{
544ca69a 1317 struct nb_node *nb_node = snode->priv;
1c2facd1
RW		 1318 struct lys_node_container *scontainer;
1319 struct lys_node_leaf *sleaf;
1320
1321 switch (operation) {
1322 case NB_OP_CREATE:
db452508 1323 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1c2facd1
RW		 1324 return false;
1325
1326 switch (snode->nodetype) {
1327 case LYS_LEAF:
1328 sleaf = (struct lys_node_leaf *)snode;
1329 if (sleaf->type.base != LY_TYPE_EMPTY)
1330 return false;
1331 break;
1332 case LYS_CONTAINER:
1333 scontainer = (struct lys_node_container *)snode;
1334 if (!scontainer->presence)
1335 return false;
1336 break;
1337 case LYS_LIST:
1338 case LYS_LEAFLIST:
1339 break;
1340 default:
1341 return false;
1342 }
1343 return true;
1344 case NB_OP_MODIFY:
db452508 1345 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1c2facd1
RW		 1346 return false;
1347
1348 switch (snode->nodetype) {
1349 case LYS_LEAF:
1350 sleaf = (struct lys_node_leaf *)snode;
1351 if (sleaf->type.base == LY_TYPE_EMPTY)
1352 return false;
1353
1354 /* List keys can't be modified. */
1355 if (lys_is_key(sleaf, NULL))
1356 return false;
1357 break;
1358 default:
1359 return false;
1360 }
1361 return true;
1362 case NB_OP_DELETE:
db452508 1363 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1c2facd1
RW		 1364 return false;
1365
1366 switch (snode->nodetype) {
1367 case LYS_LEAF:
1368 sleaf = (struct lys_node_leaf *)snode;
1369
1370 /* List keys can't be deleted. */
1371 if (lys_is_key(sleaf, NULL))
1372 return false;
1373
1374 /*
1375 * Only optional leafs can be deleted, or leafs whose
1376 * parent is a case statement.
1377 */
1378 if (snode->parent->nodetype == LYS_CASE)
1379 return true;
1380 if (sleaf->when)
1381 return true;
db452508
RW		 1382 if (CHECK_FLAG(sleaf->flags, LYS_MAND_TRUE)
1383 || sleaf->dflt)
1c2facd1
RW		 1384 return false;
1385 break;
1386 case LYS_CONTAINER:
1387 scontainer = (struct lys_node_container *)snode;
1388 if (!scontainer->presence)
1389 return false;
1390 break;
1391 case LYS_LIST:
1392 case LYS_LEAFLIST:
1393 break;
1394 default:
1395 return false;
1396 }
1397 return true;
1398 case NB_OP_MOVE:
db452508 1399 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1c2facd1
RW		 1400 return false;
1401
1402 switch (snode->nodetype) {
1403 case LYS_LIST:
1404 case LYS_LEAFLIST:
db452508 1405 if (!CHECK_FLAG(snode->flags, LYS_USERORDERED))
1c2facd1
RW		 1406 return false;
1407 break;
1408 default:
1409 return false;
1410 }
1411 return true;
1412 case NB_OP_APPLY_FINISH:
db452508 1413 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1c2facd1
RW		 1414 return false;
1415 return true;
1416 case NB_OP_GET_ELEM:
db452508 1417 if (!CHECK_FLAG(snode->flags, LYS_CONFIG_R))
1c2facd1
RW		 1418 return false;
1419
1420 switch (snode->nodetype) {
1421 case LYS_LEAF:
1a4bc045 1422 case LYS_LEAFLIST:
1c2facd1
RW		 1423 break;
1424 case LYS_CONTAINER:
1425 scontainer = (struct lys_node_container *)snode;
1426 if (!scontainer->presence)
1427 return false;
1428 break;
1429 default:
1430 return false;
1431 }
1432 return true;
1433 case NB_OP_GET_NEXT:
1a4bc045
RW		 1434 switch (snode->nodetype) {
1435 case LYS_LIST:
1436 if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
1437 return false;
1438 break;
1439 case LYS_LEAFLIST:
1440 if (CHECK_FLAG(snode->flags, LYS_CONFIG_W))
1441 return false;
1442 break;
1443 default:
1444 return false;
1445 }
1446 return true;
1c2facd1
RW		 1447 case NB_OP_GET_KEYS:
1448 case NB_OP_LOOKUP_ENTRY:
1c2facd1
RW		 1449 switch (snode->nodetype) {
1450 case LYS_LIST:
544ca69a
RW		 1451 if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
1452 return false;
99fb518f
RW		 1453 if (CHECK_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST))
1454 return false;
1c2facd1
RW		 1455 break;
1456 default:
1457 return false;
1458 }
1459 return true;
1460 case NB_OP_RPC:
db452508 1461 if (CHECK_FLAG(snode->flags, LYS_CONFIG_W | LYS_CONFIG_R))
1c2facd1
RW		 1462 return false;
1463
1464 switch (snode->nodetype) {
1465 case LYS_RPC:
1466 case LYS_ACTION:
1467 break;
1468 default:
1469 return false;
1470 }
1471 return true;
1472 default:
1473 return false;
1474 }
1475}
1476
1477DEFINE_HOOK(nb_notification_send, (const char *xpath, struct list *arguments),
1478 (xpath, arguments));
1479
1480int nb_notification_send(const char *xpath, struct list *arguments)
1481{
1482 int ret;
1483
1484 ret = hook_call(nb_notification_send, xpath, arguments);
1485 if (arguments)
1486 list_delete(&arguments);
1487
1488 return ret;
1489}
1490
1491const char *nb_event_name(enum nb_event event)
1492{
1493 switch (event) {
1494 case NB_EV_VALIDATE:
1495 return "validate";
1496 case NB_EV_PREPARE:
1497 return "prepare";
1498 case NB_EV_ABORT:
1499 return "abort";
1500 case NB_EV_APPLY:
1501 return "apply";
1502 default:
1503 return "unknown";
1504 }
1505}
1506
1507const char *nb_operation_name(enum nb_operation operation)
1508{
1509 switch (operation) {
1510 case NB_OP_CREATE:
1511 return "create";
1512 case NB_OP_MODIFY:
1513 return "modify";
1514 case NB_OP_DELETE:
1515 return "delete";
1516 case NB_OP_MOVE:
1517 return "move";
1518 case NB_OP_APPLY_FINISH:
1519 return "apply_finish";
1520 case NB_OP_GET_ELEM:
1521 return "get_elem";
1522 case NB_OP_GET_NEXT:
1523 return "get_next";
1524 case NB_OP_GET_KEYS:
1525 return "get_keys";
1526 case NB_OP_LOOKUP_ENTRY:
1527 return "lookup_entry";
1528 case NB_OP_RPC:
1529 return "rpc";
1530 default:
1531 return "unknown";
1532 }
1533}
1534
1535const char *nb_err_name(enum nb_error error)
1536{
1537 switch (error) {
1538 case NB_OK:
1539 return "ok";
1540 case NB_ERR:
1541 return "generic error";
1542 case NB_ERR_NO_CHANGES:
1543 return "no changes";
1544 case NB_ERR_NOT_FOUND:
1545 return "element not found";
1546 case NB_ERR_LOCKED:
1547 return "resource is locked";
1548 case NB_ERR_VALIDATION:
1549 return "validation error";
1550 case NB_ERR_RESOURCE:
1551 return "failed to allocate resource";
1552 case NB_ERR_INCONSISTENCY:
1553 return "internal inconsistency";
1554 default:
1555 return "unknown";
1556 }
1557}
1558
1559const char *nb_client_name(enum nb_client client)
1560{
1561 switch (client) {
1562 case NB_CLIENT_CLI:
1563 return "CLI";
5bce33b3
RW		 1564 case NB_CLIENT_CONFD:
1565 return "ConfD";
a7ca2199
RW		 1566 case NB_CLIENT_SYSREPO:
1567 return "Sysrepo";
1c2facd1
RW		 1568 default:
1569 return "unknown";
1570 }
1571}
1572
1573static void nb_load_callbacks(const struct frr_yang_module_info *module)
1574{
1575 for (size_t i = 0; module->nodes[i].xpath; i++) {
1576 struct nb_node *nb_node;
1577 uint32_t priority;
1578
1579 nb_node = nb_node_find(module->nodes[i].xpath);
1580 if (!nb_node) {
1581 flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH,
1582 "%s: unknown data path: %s", __func__,
1583 module->nodes[i].xpath);
1584 continue;
1585 }
1586
1587 nb_node->cbs = module->nodes[i].cbs;
1588 priority = module->nodes[i].priority;
1589 if (priority != 0)
1590 nb_node->priority = priority;
1591 }
1592}
1593
fbdc1c0a
RW		 1594void nb_init(struct thread_master *tm,
1595 const struct frr_yang_module_info *modules[], size_t nmodules)
1c2facd1
RW		 1596{
1597 unsigned int errors = 0;
1598
1599 /* Load YANG modules. */
1600 for (size_t i = 0; i < nmodules; i++)
1601 yang_module_load(modules[i]->name);
1602
1603 /* Create a nb_node for all YANG schema nodes. */
544ca69a 1604 nb_nodes_create();
1c2facd1
RW		 1605
1606 /* Load northbound callbacks. */
1607 for (size_t i = 0; i < nmodules; i++)
1608 nb_load_callbacks(modules[i]);
1609
1610 /* Validate northbound callbacks. */
e0ccfad2 1611 yang_snodes_iterate_all(nb_node_validate, 0, &errors);
1c2facd1
RW		 1612 if (errors > 0) {
1613 flog_err(
1614 EC_LIB_NB_CBS_VALIDATION,
1615 "%s: failed to validate northbound callbacks: %u error(s)",
1616 __func__, errors);
1617 exit(1);
1618 }
1619
1620 /* Initialize the northbound database (used for the rollback log). */
1621 if (nb_db_init() != NB_OK)
1622 flog_warn(EC_LIB_NB_DATABASE,
1623 "%s: failed to initialize northbound database",
1624 __func__);
1625
1626 /* Create an empty running configuration. */
1627 running_config = nb_config_new(NULL);
1628
1629 /* Initialize the northbound CLI. */
fbdc1c0a 1630 nb_cli_init(tm);
1c2facd1
RW		 1631}
1632
1633void nb_terminate(void)
1634{
1635 /* Terminate the northbound CLI. */
1636 nb_cli_terminate();
1637
1638 /* Delete all nb_node's from all YANG modules. */
544ca69a 1639 nb_nodes_delete();
1c2facd1
RW		 1640
1641 /* Delete the running configuration. */
1642 nb_config_free(running_config);
1643}
FRRouting mirror