]> git.proxmox.com Git - mirror_frr.git/blame - eigrpd/eigrp_northbound.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #5793 from ton31337/fix/formatting_show_bgp_summary_failed
[mirror_frr.git] / eigrpd / eigrp_northbound.c
CommitLineData
f25c244b
RZ		 1/*
2 * EIGRP daemon northbound implementation.
3 *
4 * Copyright (C) 2019 Network Device Education Foundation, Inc. ("NetDEF")
5 * Rafael Zalamena
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301 USA.
21 */
22
23#include <zebra.h>
24
25#include "lib/keychain.h"
26#include "lib/log.h"
27#include "lib/northbound.h"
28#include "lib/table.h"
29#include "lib/vrf.h"
30#include "lib/zclient.h"
31
32#include "eigrp_structs.h"
33#include "eigrpd.h"
34#include "eigrp_interface.h"
35#include "eigrp_network.h"
36#include "eigrp_zebra.h"
37
38/* Helper functions. */
39static void redistribute_get_metrics(const struct lyd_node *dnode,
40 struct eigrp_metrics *em)
41{
42 memset(em, 0, sizeof(*em));
43
44 if (yang_dnode_exists(dnode, "./bandwidth"))
45 em->bandwidth = yang_dnode_get_uint32(dnode, "./bandwidth");
46 if (yang_dnode_exists(dnode, "./delay"))
47 em->delay = yang_dnode_get_uint32(dnode, "./delay");
48#if 0 /* TODO: How does MTU work? */
49 if (yang_dnode_exists(dnode, "./mtu"))
50 em->mtu[0] = yang_dnode_get_uint32(dnode, "./mtu");
51#endif
52 if (yang_dnode_exists(dnode, "./load"))
53 em->load = yang_dnode_get_uint32(dnode, "./load");
54 if (yang_dnode_exists(dnode, "./reliability"))
55 em->reliability = yang_dnode_get_uint32(dnode, "./reliability");
56}
57
58static struct eigrp_interface *eigrp_interface_lookup(const struct eigrp *eigrp,
59 const char *ifname)
60{
61 struct eigrp_interface *eif;
62 struct listnode *ln;
63
64 for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, ln, eif)) {
65 if (strcmp(ifname, eif->ifp->name))
66 continue;
67
68 return eif;
69 }
70
71 return NULL;
72}
73
74/*
75 * XPath: /frr-eigrpd:eigrpd/instance
76 */
77static int eigrpd_instance_create(enum nb_event event,
78 const struct lyd_node *dnode,
79 union nb_resource *resource)
80{
81 struct eigrp *eigrp;
e9449961
DS		 82 const char *vrf;
83 vrf_id_t vrfid;
f25c244b
RZ		 84
85 switch (event) {
86 case NB_EV_VALIDATE:
87 /* NOTHING */
88 break;
89 case NB_EV_PREPARE:
e9449961
DS		 90 vrf = yang_dnode_get_string(dnode, "./vrf");
91 vrfid = vrf_name_to_id(vrf);
92
93 eigrp = eigrp_get(yang_dnode_get_uint16(dnode, "./asn"), vrfid);
f25c244b
RZ		 94 resource->ptr = eigrp;
95 break;
96 case NB_EV_ABORT:
97 eigrp_finish_final(resource->ptr);
98 break;
99 case NB_EV_APPLY:
100 nb_running_set_entry(dnode, resource->ptr);
101 break;
102 }
103
104 return NB_OK;
105}
106
107static int eigrpd_instance_destroy(enum nb_event event,
108 const struct lyd_node *dnode)
109{
110 struct eigrp *eigrp;
111
112 switch (event) {
113 case NB_EV_VALIDATE:
114 case NB_EV_PREPARE:
115 case NB_EV_ABORT:
116 /* NOTHING */
117 break;
118 case NB_EV_APPLY:
119 eigrp = nb_running_unset_entry(dnode);
120 eigrp_finish_final(eigrp);
121 break;
122 }
123
124 return NB_OK;
125}
126
127/*
128 * XPath: /frr-eigrpd:eigrpd/instance/router-id
129 */
130static int eigrpd_instance_router_id_modify(enum nb_event event,
131 const struct lyd_node *dnode,
132 union nb_resource *resource)
133{
134 struct eigrp *eigrp;
135
136 switch (event) {
137 case NB_EV_VALIDATE:
138 case NB_EV_PREPARE:
139 case NB_EV_ABORT:
140 /* NOTHING */
141 break;
142 case NB_EV_APPLY:
143 eigrp = nb_running_get_entry(dnode, NULL, true);
144 yang_dnode_get_ipv4(&eigrp->router_id_static, dnode, NULL);
145 break;
146 }
147
148 return NB_OK;
149}
150
151static int eigrpd_instance_router_id_destroy(enum nb_event event,
152 const struct lyd_node *dnode)
153{
154 struct eigrp *eigrp;
155
156 switch (event) {
157 case NB_EV_VALIDATE:
158 case NB_EV_PREPARE:
159 case NB_EV_ABORT:
160 /* NOTHING */
161 break;
162 case NB_EV_APPLY:
163 eigrp = nb_running_get_entry(dnode, NULL, true);
975a328e 164 eigrp->router_id_static.s_addr = INADDR_ANY;
f25c244b
RZ		 165 break;
166 }
167
168 return NB_OK;
169}
170
171/*
172 * XPath: /frr-eigrpd:eigrpd/instance/passive-interface
173 */
174static int
175eigrpd_instance_passive_interface_create(enum nb_event event,
176 const struct lyd_node *dnode,
177 union nb_resource *resource)
178{
179 struct eigrp_interface *eif;
180 struct eigrp *eigrp;
181 const char *ifname;
182
183 switch (event) {
184 case NB_EV_VALIDATE:
185 eigrp = nb_running_get_entry(dnode, NULL, false);
186 if (eigrp == NULL) {
187 /*
188 * XXX: we can't verify if the interface exists
189 * and is active until EIGRP is up.
190 */
191 break;
192 }
193
194 ifname = yang_dnode_get_string(dnode, NULL);
195 eif = eigrp_interface_lookup(eigrp, ifname);
196 if (eif == NULL)
197 return NB_ERR_INCONSISTENCY;
198 break;
199 case NB_EV_PREPARE:
200 case NB_EV_ABORT:
201 /* NOTHING */
202 break;
203 case NB_EV_APPLY:
204 eigrp = nb_running_get_entry(dnode, NULL, true);
205 ifname = yang_dnode_get_string(dnode, NULL);
206 eif = eigrp_interface_lookup(eigrp, ifname);
207 if (eif == NULL)
208 return NB_ERR_INCONSISTENCY;
209
210 eif->params.passive_interface = EIGRP_IF_PASSIVE;
211 break;
212 }
213
214 return NB_OK;
215}
216
217static int
218eigrpd_instance_passive_interface_destroy(enum nb_event event,
219 const struct lyd_node *dnode)
220{
221 struct eigrp_interface *eif;
222 struct eigrp *eigrp;
223 const char *ifname;
224
225 switch (event) {
226 case NB_EV_VALIDATE:
227 case NB_EV_PREPARE:
228 case NB_EV_ABORT:
229 /* NOTHING */
230 break;
231 case NB_EV_APPLY:
232 eigrp = nb_running_get_entry(dnode, NULL, true);
233 ifname = yang_dnode_get_string(dnode, NULL);
234 eif = eigrp_interface_lookup(eigrp, ifname);
235 if (eif == NULL)
236 break;
237
238 eif->params.passive_interface = EIGRP_IF_ACTIVE;
239 break;
240 }
241
242 return NB_OK;
243}
244
245/*
246 * XPath: /frr-eigrpd:eigrpd/instance/active-time
247 */
248static int eigrpd_instance_active_time_modify(enum nb_event event,
249 const struct lyd_node *dnode,
250 union nb_resource *resource)
251{
252 switch (event) {
253 case NB_EV_VALIDATE:
254 /* TODO: Not implemented. */
255 return NB_ERR_INCONSISTENCY;
256 case NB_EV_PREPARE:
257 case NB_EV_ABORT:
258 case NB_EV_APPLY:
259 /* NOTHING */
260 break;
261 }
262
263 return NB_OK;
264}
265
266/*
267 * XPath: /frr-eigrpd:eigrpd/instance/variance
268 */
269static int eigrpd_instance_variance_modify(enum nb_event event,
270 const struct lyd_node *dnode,
271 union nb_resource *resource)
272{
273 struct eigrp *eigrp;
274
275 switch (event) {
276 case NB_EV_VALIDATE:
277 case NB_EV_PREPARE:
278 case NB_EV_ABORT:
279 /* NOTHING */
280 break;
281 case NB_EV_APPLY:
282 eigrp = nb_running_get_entry(dnode, NULL, true);
283 eigrp->variance = yang_dnode_get_uint8(dnode, NULL);
284 break;
285 }
286
287 return NB_OK;
288}
289
290static int eigrpd_instance_variance_destroy(enum nb_event event,
291 const struct lyd_node *dnode)
292{
293 struct eigrp *eigrp;
294
295 switch (event) {
296 case NB_EV_VALIDATE:
297 case NB_EV_PREPARE:
298 case NB_EV_ABORT:
299 /* NOTHING */
300 break;
301 case NB_EV_APPLY:
302 eigrp = nb_running_get_entry(dnode, NULL, true);
303 eigrp->variance = EIGRP_VARIANCE_DEFAULT;
304 break;
305 }
306
307 return NB_OK;
308}
309
310/*
311 * XPath: /frr-eigrpd:eigrpd/instance/maximum-paths
312 */
313static int eigrpd_instance_maximum_paths_modify(enum nb_event event,
314 const struct lyd_node *dnode,
315 union nb_resource *resource)
316{
317 struct eigrp *eigrp;
318
319 switch (event) {
320 case NB_EV_VALIDATE:
321 case NB_EV_PREPARE:
322 case NB_EV_ABORT:
323 /* NOTHING */
324 break;
325 case NB_EV_APPLY:
326 eigrp = nb_running_get_entry(dnode, NULL, true);
327 eigrp->max_paths = yang_dnode_get_uint8(dnode, NULL);
328 break;
329 }
330
331 return NB_OK;
332}
333
334static int eigrpd_instance_maximum_paths_destroy(enum nb_event event,
335 const struct lyd_node *dnode)
336{
337 struct eigrp *eigrp;
338
339 switch (event) {
340 case NB_EV_VALIDATE:
341 case NB_EV_PREPARE:
342 case NB_EV_ABORT:
343 /* NOTHING */
344 break;
345 case NB_EV_APPLY:
346 eigrp = nb_running_get_entry(dnode, NULL, true);
347 eigrp->max_paths = EIGRP_MAX_PATHS_DEFAULT;
348 break;
349 }
350
351 return NB_OK;
352}
353
354/*
355 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K1
356 */
357static int
358eigrpd_instance_metric_weights_K1_modify(enum nb_event event,
359 const struct lyd_node *dnode,
360 union nb_resource *resource)
361{
362 struct eigrp *eigrp;
363
364 switch (event) {
365 case NB_EV_VALIDATE:
366 case NB_EV_PREPARE:
367 case NB_EV_ABORT:
368 /* NOTHING */
369 break;
370 case NB_EV_APPLY:
371 eigrp = nb_running_get_entry(dnode, NULL, true);
372 eigrp->k_values[0] = yang_dnode_get_uint8(dnode, NULL);
373 break;
374 }
375
376 return NB_OK;
377}
378
379static int
380eigrpd_instance_metric_weights_K1_destroy(enum nb_event event,
381 const struct lyd_node *dnode)
382{
383 struct eigrp *eigrp;
384
385 switch (event) {
386 case NB_EV_VALIDATE:
387 case NB_EV_PREPARE:
388 case NB_EV_ABORT:
389 /* NOTHING */
390 break;
391 case NB_EV_APPLY:
392 eigrp = nb_running_get_entry(dnode, NULL, true);
393 eigrp->k_values[0] = EIGRP_K1_DEFAULT;
394 break;
395 }
396
397 return NB_OK;
398}
399
400/*
401 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K2
402 */
403static int
404eigrpd_instance_metric_weights_K2_modify(enum nb_event event,
405 const struct lyd_node *dnode,
406 union nb_resource *resource)
407{
408 struct eigrp *eigrp;
409
410 switch (event) {
411 case NB_EV_VALIDATE:
412 case NB_EV_PREPARE:
413 case NB_EV_ABORT:
414 /* NOTHING */
415 break;
416 case NB_EV_APPLY:
417 eigrp = nb_running_get_entry(dnode, NULL, true);
418 eigrp->k_values[1] = yang_dnode_get_uint8(dnode, NULL);
419 break;
420 }
421
422 return NB_OK;
423}
424
425static int
426eigrpd_instance_metric_weights_K2_destroy(enum nb_event event,
427 const struct lyd_node *dnode)
428{
429 struct eigrp *eigrp;
430
431 switch (event) {
432 case NB_EV_VALIDATE:
433 case NB_EV_PREPARE:
434 case NB_EV_ABORT:
435 /* NOTHING */
436 break;
437 case NB_EV_APPLY:
438 eigrp = nb_running_get_entry(dnode, NULL, true);
439 eigrp->k_values[1] = EIGRP_K2_DEFAULT;
440 break;
441 }
442
443 return NB_OK;
444}
445
446/*
447 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K3
448 */
449static int
450eigrpd_instance_metric_weights_K3_modify(enum nb_event event,
451 const struct lyd_node *dnode,
452 union nb_resource *resource)
453{
454 struct eigrp *eigrp;
455
456 switch (event) {
457 case NB_EV_VALIDATE:
458 case NB_EV_PREPARE:
459 case NB_EV_ABORT:
460 /* NOTHING */
461 break;
462 case NB_EV_APPLY:
463 eigrp = nb_running_get_entry(dnode, NULL, true);
464 eigrp->k_values[2] = yang_dnode_get_uint8(dnode, NULL);
465 break;
466 }
467
468 return NB_OK;
469}
470
471static int
472eigrpd_instance_metric_weights_K3_destroy(enum nb_event event,
473 const struct lyd_node *dnode)
474{
475 struct eigrp *eigrp;
476
477 switch (event) {
478 case NB_EV_VALIDATE:
479 case NB_EV_PREPARE:
480 case NB_EV_ABORT:
481 /* NOTHING */
482 break;
483 case NB_EV_APPLY:
484 eigrp = nb_running_get_entry(dnode, NULL, true);
485 eigrp->k_values[2] = EIGRP_K3_DEFAULT;
486 break;
487 }
488
489 return NB_OK;
490}
491
492/*
493 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K4
494 */
495static int
496eigrpd_instance_metric_weights_K4_modify(enum nb_event event,
497 const struct lyd_node *dnode,
498 union nb_resource *resource)
499{
500 struct eigrp *eigrp;
501
502 switch (event) {
503 case NB_EV_VALIDATE:
504 case NB_EV_PREPARE:
505 case NB_EV_ABORT:
506 /* NOTHING */
507 break;
508 case NB_EV_APPLY:
509 eigrp = nb_running_get_entry(dnode, NULL, true);
510 eigrp->k_values[3] = yang_dnode_get_uint8(dnode, NULL);
511 break;
512 }
513
514 return NB_OK;
515}
516
517static int
518eigrpd_instance_metric_weights_K4_destroy(enum nb_event event,
519 const struct lyd_node *dnode)
520{
521 struct eigrp *eigrp;
522
523 switch (event) {
524 case NB_EV_VALIDATE:
525 case NB_EV_PREPARE:
526 case NB_EV_ABORT:
527 /* NOTHING */
528 break;
529 case NB_EV_APPLY:
530 eigrp = nb_running_get_entry(dnode, NULL, true);
531 eigrp->k_values[3] = EIGRP_K4_DEFAULT;
532 break;
533 }
534
535 return NB_OK;
536}
537
538/*
539 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K5
540 */
541static int
542eigrpd_instance_metric_weights_K5_modify(enum nb_event event,
543 const struct lyd_node *dnode,
544 union nb_resource *resource)
545{
546 struct eigrp *eigrp;
547
548 switch (event) {
549 case NB_EV_VALIDATE:
550 case NB_EV_PREPARE:
551 case NB_EV_ABORT:
552 /* NOTHING */
553 break;
554 case NB_EV_APPLY:
555 eigrp = nb_running_get_entry(dnode, NULL, true);
556 eigrp->k_values[4] = yang_dnode_get_uint8(dnode, NULL);
557 break;
558 }
559
560 return NB_OK;
561}
562
563static int
564eigrpd_instance_metric_weights_K5_destroy(enum nb_event event,
565 const struct lyd_node *dnode)
566{
567 struct eigrp *eigrp;
568
569 switch (event) {
570 case NB_EV_VALIDATE:
571 case NB_EV_PREPARE:
572 case NB_EV_ABORT:
573 /* NOTHING */
574 break;
575 case NB_EV_APPLY:
576 eigrp = nb_running_get_entry(dnode, NULL, true);
577 eigrp->k_values[4] = EIGRP_K5_DEFAULT;
578 break;
579 }
580
581 return NB_OK;
582}
583
584/*
585 * XPath: /frr-eigrpd:eigrpd/instance/metric-weights/K6
586 */
587static int
588eigrpd_instance_metric_weights_K6_modify(enum nb_event event,
589 const struct lyd_node *dnode,
590 union nb_resource *resource)
591{
592 struct eigrp *eigrp;
593
594 switch (event) {
595 case NB_EV_VALIDATE:
596 case NB_EV_PREPARE:
597 case NB_EV_ABORT:
598 /* NOTHING */
599 break;
600 case NB_EV_APPLY:
601 eigrp = nb_running_get_entry(dnode, NULL, true);
602 eigrp->k_values[5] = yang_dnode_get_uint8(dnode, NULL);
603 break;
604 }
605
606 return NB_OK;
607}
608
609static int
610eigrpd_instance_metric_weights_K6_destroy(enum nb_event event,
611 const struct lyd_node *dnode)
612{
613 struct eigrp *eigrp;
614
615 switch (event) {
616 case NB_EV_VALIDATE:
617 case NB_EV_PREPARE:
618 case NB_EV_ABORT:
619 /* NOTHING */
620 break;
621 case NB_EV_APPLY:
622 eigrp = nb_running_get_entry(dnode, NULL, true);
623 eigrp->k_values[5] = EIGRP_K6_DEFAULT;
624 break;
625 }
626
627 return NB_OK;
628}
629
630/*
631 * XPath: /frr-eigrpd:eigrpd/instance/network
632 */
633static int eigrpd_instance_network_create(enum nb_event event,
634 const struct lyd_node *dnode,
635 union nb_resource *resource)
636{
637 struct route_node *rnode;
638 struct prefix prefix;
639 struct eigrp *eigrp;
640 int exists;
641
642 yang_dnode_get_ipv4p(&prefix, dnode, NULL);
643
644 switch (event) {
645 case NB_EV_VALIDATE:
646 eigrp = nb_running_get_entry(dnode, NULL, false);
647 /* If entry doesn't exist it means the list is empty. */
648 if (eigrp == NULL)
649 break;
650
651 rnode = route_node_get(eigrp->networks, &prefix);
652 exists = (rnode->info != NULL);
653 route_unlock_node(rnode);
654 if (exists)
655 return NB_ERR_INCONSISTENCY;
656 break;
657 case NB_EV_PREPARE:
658 case NB_EV_ABORT:
659 /* NOTHING */
660 break;
661 case NB_EV_APPLY:
662 eigrp = nb_running_get_entry(dnode, NULL, true);
663 if (eigrp_network_set(eigrp, &prefix) == 0)
664 return NB_ERR_INCONSISTENCY;
665 break;
666 }
667
668 return NB_OK;
669}
670
671static int eigrpd_instance_network_destroy(enum nb_event event,
672 const struct lyd_node *dnode)
673{
674 struct route_node *rnode;
675 struct prefix prefix;
676 struct eigrp *eigrp;
677 int exists = 0;
678
679 yang_dnode_get_ipv4p(&prefix, dnode, NULL);
680
681 switch (event) {
682 case NB_EV_VALIDATE:
683 eigrp = nb_running_get_entry(dnode, NULL, false);
684 /* If entry doesn't exist it means the list is empty. */
685 if (eigrp == NULL)
686 break;
687
688 rnode = route_node_get(eigrp->networks, &prefix);
689 exists = (rnode->info != NULL);
690 route_unlock_node(rnode);
691 if (exists == 0)
692 return NB_ERR_INCONSISTENCY;
693 break;
694 case NB_EV_PREPARE:
695 case NB_EV_ABORT:
696 /* NOTHING */
697 break;
698 case NB_EV_APPLY:
699 eigrp = nb_running_get_entry(dnode, NULL, true);
700 eigrp_network_unset(eigrp, &prefix);
701 break;
702 }
703
704 return NB_OK;
705}
706
707/*
708 * XPath: /frr-eigrpd:eigrpd/instance/neighbor
709 */
710static int eigrpd_instance_neighbor_create(enum nb_event event,
711 const struct lyd_node *dnode,
712 union nb_resource *resource)
713{
714 switch (event) {
715 case NB_EV_VALIDATE:
716 /* TODO: Not implemented. */
717 return NB_ERR_INCONSISTENCY;
718 case NB_EV_PREPARE:
719 case NB_EV_ABORT:
720 case NB_EV_APPLY:
721 /* NOTHING */
722 break;
723 }
724
725 return NB_OK;
726}
727
728static int eigrpd_instance_neighbor_destroy(enum nb_event event,
729 const struct lyd_node *dnode)
730{
731 switch (event) {
732 case NB_EV_VALIDATE:
733 /* TODO: Not implemented. */
734 return NB_ERR_INCONSISTENCY;
735 case NB_EV_PREPARE:
736 case NB_EV_ABORT:
737 case NB_EV_APPLY:
738 /* NOTHING */
739 break;
740 }
741
742 return NB_OK;
743}
744
745/*
746 * XPath: /frr-eigrpd:eigrpd/instance/redistribute
747 */
748static int eigrpd_instance_redistribute_create(enum nb_event event,
749 const struct lyd_node *dnode,
750 union nb_resource *resource)
751{
752 struct eigrp_metrics metrics;
daa64bdf 753 const char *vrfname;
f25c244b
RZ		 754 struct eigrp *eigrp;
755 uint32_t proto;
daa64bdf 756 vrf_id_t vrfid;
f25c244b
RZ		 757
758 switch (event) {
759 case NB_EV_VALIDATE:
760 proto = yang_dnode_get_enum(dnode, "./protocol");
daa64bdf
DS		 761 vrfname = yang_dnode_get_string(dnode, "../vrf");
762 vrfid = vrf_name_to_id(vrfname);
763 if (vrf_bitmap_check(zclient->redist[AFI_IP][proto], vrfid))
f25c244b
RZ		 764 return NB_ERR_INCONSISTENCY;
765 break;
766 case NB_EV_PREPARE:
767 case NB_EV_ABORT:
768 /* NOTHING */
769 break;
770 case NB_EV_APPLY:
771 eigrp = nb_running_get_entry(dnode, NULL, true);
772 proto = yang_dnode_get_enum(dnode, "./protocol");
773 redistribute_get_metrics(dnode, &metrics);
774 eigrp_redistribute_set(eigrp, proto, metrics);
775 break;
776 }
777
778 return NB_OK;
779}
780
781static int eigrpd_instance_redistribute_destroy(enum nb_event event,
782 const struct lyd_node *dnode)
783{
784 struct eigrp *eigrp;
785 uint32_t proto;
786
787 switch (event) {
788 case NB_EV_VALIDATE:
789 case NB_EV_PREPARE:
790 case NB_EV_ABORT:
791 /* NOTHING */
792 break;
793 case NB_EV_APPLY:
794 eigrp = nb_running_get_entry(dnode, NULL, true);
795 proto = yang_dnode_get_enum(dnode, "./protocol");
796 eigrp_redistribute_unset(eigrp, proto);
797 break;
798 }
799
800 return NB_OK;
801}
802
803/*
804 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/route-map
805 */
806static int
807eigrpd_instance_redistribute_route_map_modify(enum nb_event event,
808 const struct lyd_node *dnode,
809 union nb_resource *resource)
810{
811 switch (event) {
812 case NB_EV_VALIDATE:
813 /* TODO: Not implemented. */
814 return NB_ERR_INCONSISTENCY;
815 case NB_EV_PREPARE:
816 case NB_EV_ABORT:
817 case NB_EV_APPLY:
818 /* NOTHING */
819 break;
820 }
821
822 return NB_OK;
823}
824
825static int
826eigrpd_instance_redistribute_route_map_destroy(enum nb_event event,
827 const struct lyd_node *dnode)
828{
829 switch (event) {
830 case NB_EV_VALIDATE:
831 /* TODO: Not implemented. */
832 return NB_ERR_INCONSISTENCY;
833 case NB_EV_PREPARE:
834 case NB_EV_ABORT:
835 case NB_EV_APPLY:
836 /* NOTHING */
837 break;
838 }
839
840 return NB_OK;
841}
842
843/*
844 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/metrics/bandwidth
845 */
846static int eigrpd_instance_redistribute_metrics_bandwidth_modify(
847 enum nb_event event, const struct lyd_node *dnode,
848 union nb_resource *resource)
849{
850 struct eigrp_metrics metrics;
851 struct eigrp *eigrp;
852 uint32_t proto;
853
854 switch (event) {
855 case NB_EV_VALIDATE:
856 case NB_EV_PREPARE:
857 case NB_EV_ABORT:
858 /* NOTHING */
859 break;
860 case NB_EV_APPLY:
861 eigrp = nb_running_get_entry(dnode, NULL, true);
862 proto = yang_dnode_get_enum(dnode, "../../protocol");
863 redistribute_get_metrics(dnode, &metrics);
864 eigrp_redistribute_set(eigrp, proto, metrics);
865 break;
866 }
867
868 return NB_OK;
869}
870
871static int eigrpd_instance_redistribute_metrics_bandwidth_destroy(
872 enum nb_event event, const struct lyd_node *dnode)
873{
874 struct eigrp_metrics metrics;
875 struct eigrp *eigrp;
876 uint32_t proto;
877
878 switch (event) {
879 case NB_EV_VALIDATE:
880 case NB_EV_PREPARE:
881 case NB_EV_ABORT:
882 /* NOTHING */
883 break;
884 case NB_EV_APPLY:
885 eigrp = nb_running_get_entry(dnode, NULL, true);
886 proto = yang_dnode_get_enum(dnode, "../../protocol");
887 redistribute_get_metrics(dnode, &metrics);
888 eigrp_redistribute_set(eigrp, proto, metrics);
889 break;
890 }
891
892 return NB_OK;
893}
894
895/*
896 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/metrics/delay
897 */
898static int
899eigrpd_instance_redistribute_metrics_delay_modify(enum nb_event event,
900 const struct lyd_node *dnode,
901 union nb_resource *resource)
902{
903 return eigrpd_instance_redistribute_metrics_bandwidth_modify(event,
904 dnode,
905 resource);
906}
907
908static int
909eigrpd_instance_redistribute_metrics_delay_destroy(enum nb_event event,
910 const struct lyd_node *dnode)
911{
912 return eigrpd_instance_redistribute_metrics_bandwidth_destroy(event,
913 dnode);
914}
915
916/*
917 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/metrics/reliability
918 */
919static int eigrpd_instance_redistribute_metrics_reliability_modify(
920 enum nb_event event, const struct lyd_node *dnode,
921 union nb_resource *resource)
922{
923 return eigrpd_instance_redistribute_metrics_bandwidth_modify(event,
924 dnode,
925 resource);
926}
927
928static int eigrpd_instance_redistribute_metrics_reliability_destroy(
929 enum nb_event event, const struct lyd_node *dnode)
930{
931 return eigrpd_instance_redistribute_metrics_bandwidth_destroy(event,
932 dnode);
933}
934
935/*
936 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/metrics/load
937 */
938static int
939eigrpd_instance_redistribute_metrics_load_modify(enum nb_event event,
940 const struct lyd_node *dnode,
941 union nb_resource *resource)
942{
943 return eigrpd_instance_redistribute_metrics_bandwidth_modify(event,
944 dnode,
945 resource);
946}
947
948static int
949eigrpd_instance_redistribute_metrics_load_destroy(enum nb_event event,
950 const struct lyd_node *dnode)
951{
952 return eigrpd_instance_redistribute_metrics_bandwidth_destroy(event,
953 dnode);
954}
955
956/*
957 * XPath: /frr-eigrpd:eigrpd/instance/redistribute/metrics/mtu
958 */
959static int
960eigrpd_instance_redistribute_metrics_mtu_modify(enum nb_event event,
961 const struct lyd_node *dnode,
962 union nb_resource *resource)
963{
964 return eigrpd_instance_redistribute_metrics_bandwidth_modify(event,
965 dnode,
966 resource);
967}
968
969static int
970eigrpd_instance_redistribute_metrics_mtu_destroy(enum nb_event event,
971 const struct lyd_node *dnode)
972{
973 return eigrpd_instance_redistribute_metrics_bandwidth_destroy(event,
974 dnode);
975}
976
977/*
978 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/delay
979 */
980static int lib_interface_eigrp_delay_modify(enum nb_event event,
981 const struct lyd_node *dnode,
982 union nb_resource *resource)
983{
984 struct eigrp_interface *ei;
985 struct interface *ifp;
986
987 switch (event) {
988 case NB_EV_VALIDATE:
989 ifp = nb_running_get_entry(dnode, NULL, false);
990 if (ifp == NULL) {
991 /*
992 * XXX: we can't verify if the interface exists
993 * and is active until EIGRP is up.
994 */
995 break;
996 }
997
998 ei = ifp->info;
999 if (ei == NULL)
1000 return NB_ERR_INCONSISTENCY;
1001 break;
1002 case NB_EV_PREPARE:
1003 case NB_EV_ABORT:
1004 /* NOTHING */
1005 break;
1006 case NB_EV_APPLY:
1007 ifp = nb_running_get_entry(dnode, NULL, true);
1008 ei = ifp->info;
1009 if (ei == NULL)
1010 return NB_ERR_INCONSISTENCY;
1011
1012 ei->params.delay = yang_dnode_get_uint32(dnode, NULL);
1013 eigrp_if_reset(ifp);
1014 break;
1015 }
1016
1017 return NB_OK;
1018}
1019
1020/*
1021 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/bandwidth
1022 */
1023static int lib_interface_eigrp_bandwidth_modify(enum nb_event event,
1024 const struct lyd_node *dnode,
1025 union nb_resource *resource)
1026{
1027 struct interface *ifp;
1028 struct eigrp_interface *ei;
1029
1030 switch (event) {
1031 case NB_EV_VALIDATE:
1032 ifp = nb_running_get_entry(dnode, NULL, false);
1033 if (ifp == NULL) {
1034 /*
1035 * XXX: we can't verify if the interface exists
1036 * and is active until EIGRP is up.
1037 */
1038 break;
1039 }
1040
1041 ei = ifp->info;
1042 if (ei == NULL)
1043 return NB_ERR_INCONSISTENCY;
1044 break;
1045 case NB_EV_PREPARE:
1046 case NB_EV_ABORT:
1047 /* NOTHING */
1048 break;
1049 case NB_EV_APPLY:
1050 ifp = nb_running_get_entry(dnode, NULL, true);
1051 ei = ifp->info;
1052 if (ei == NULL)
1053 return NB_ERR_INCONSISTENCY;
1054
1055 ei->params.bandwidth = yang_dnode_get_uint32(dnode, NULL);
1056 eigrp_if_reset(ifp);
1057 break;
1058 }
1059
1060 return NB_OK;
1061}
1062
1063/*
1064 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/hello-interval
1065 */
1066static int
1067lib_interface_eigrp_hello_interval_modify(enum nb_event event,
1068 const struct lyd_node *dnode,
1069 union nb_resource *resource)
1070{
1071 struct interface *ifp;
1072 struct eigrp_interface *ei;
1073
1074 switch (event) {
1075 case NB_EV_VALIDATE:
1076 ifp = nb_running_get_entry(dnode, NULL, false);
1077 if (ifp == NULL) {
1078 /*
1079 * XXX: we can't verify if the interface exists
1080 * and is active until EIGRP is up.
1081 */
1082 break;
1083 }
1084
1085 ei = ifp->info;
1086 if (ei == NULL)
1087 return NB_ERR_INCONSISTENCY;
1088 break;
1089 case NB_EV_PREPARE:
1090 case NB_EV_ABORT:
1091 /* NOTHING */
1092 break;
1093 case NB_EV_APPLY:
1094 ifp = nb_running_get_entry(dnode, NULL, true);
1095 ei = ifp->info;
1096 if (ei == NULL)
1097 return NB_ERR_INCONSISTENCY;
1098
1099 ei->params.v_hello = yang_dnode_get_uint16(dnode, NULL);
1100 break;
1101 }
1102
1103 return NB_OK;
1104}
1105
1106/*
1107 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/hold-time
1108 */
1109static int lib_interface_eigrp_hold_time_modify(enum nb_event event,
1110 const struct lyd_node *dnode,
1111 union nb_resource *resource)
1112{
1113 struct interface *ifp;
1114 struct eigrp_interface *ei;
1115
1116 switch (event) {
1117 case NB_EV_VALIDATE:
1118 ifp = nb_running_get_entry(dnode, NULL, false);
1119 if (ifp == NULL) {
1120 /*
1121 * XXX: we can't verify if the interface exists
1122 * and is active until EIGRP is up.
1123 */
1124 break;
1125 }
1126
1127 ei = ifp->info;
1128 if (ei == NULL)
1129 return NB_ERR_INCONSISTENCY;
1130 break;
1131 case NB_EV_PREPARE:
1132 case NB_EV_ABORT:
1133 /* NOTHING */
1134 break;
1135 case NB_EV_APPLY:
1136 ifp = nb_running_get_entry(dnode, NULL, true);
1137 ei = ifp->info;
1138 if (ei == NULL)
1139 return NB_ERR_INCONSISTENCY;
1140
1141 ei->params.v_wait = yang_dnode_get_uint16(dnode, NULL);
1142 break;
1143 }
1144
1145 return NB_OK;
1146}
1147
1148/*
1149 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/split-horizon
1150 */
1151static int
1152lib_interface_eigrp_split_horizon_modify(enum nb_event event,
1153 const struct lyd_node *dnode,
1154 union nb_resource *resource)
1155{
1156 switch (event) {
1157 case NB_EV_VALIDATE:
1158 /* TODO: Not implemented. */
1159 return NB_ERR_INCONSISTENCY;
1160 case NB_EV_PREPARE:
1161 case NB_EV_ABORT:
1162 case NB_EV_APPLY:
1163 /* NOTHING */
1164 break;
1165 }
1166
1167 return NB_OK;
1168}
1169
1170/*
1171 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/instance
1172 */
1173static int lib_interface_eigrp_instance_create(enum nb_event event,
1174 const struct lyd_node *dnode,
1175 union nb_resource *resource)
1176{
1177 struct eigrp_interface *eif;
1178 struct interface *ifp;
1179 struct eigrp *eigrp;
1180
1181 switch (event) {
1182 case NB_EV_VALIDATE:
1183 ifp = nb_running_get_entry(dnode, NULL, false);
1184 if (ifp == NULL) {
1185 /*
1186 * XXX: we can't verify if the interface exists
1187 * and is active until EIGRP is up.
1188 */
1189 break;
1190 }
1191
e9449961
DS		 1192 eigrp = eigrp_get(yang_dnode_get_uint16(dnode, "./asn"),
1193 ifp->vrf_id);
f25c244b
RZ		 1194 eif = eigrp_interface_lookup(eigrp, ifp->name);
1195 if (eif == NULL)
1196 return NB_ERR_INCONSISTENCY;
1197 break;
1198 case NB_EV_PREPARE:
1199 case NB_EV_ABORT:
1200 /* NOTHING */
1201 break;
1202 case NB_EV_APPLY:
1203 ifp = nb_running_get_entry(dnode, NULL, true);
e9449961
DS		 1204 eigrp = eigrp_get(yang_dnode_get_uint16(dnode, "./asn"),
1205 ifp->vrf_id);
f25c244b
RZ		 1206 eif = eigrp_interface_lookup(eigrp, ifp->name);
1207 if (eif == NULL)
1208 return NB_ERR_INCONSISTENCY;
1209
1210 nb_running_set_entry(dnode, eif);
1211 break;
1212 }
1213
1214 return NB_OK;
1215}
1216
1217static int lib_interface_eigrp_instance_destroy(enum nb_event event,
1218 const struct lyd_node *dnode)
1219{
1220 switch (event) {
1221 case NB_EV_VALIDATE:
1222 case NB_EV_PREPARE:
1223 case NB_EV_ABORT:
1224 /* NOTHING */
1225 break;
1226 case NB_EV_APPLY:
1227 nb_running_unset_entry(dnode);
1228 break;
1229 }
1230
1231 return NB_OK;
1232}
1233
1234/*
1235 * XPath:
1236 * /frr-interface:lib/interface/frr-eigrpd:eigrp/instance/summarize-addresses
1237 */
1238static int lib_interface_eigrp_instance_summarize_addresses_create(
1239 enum nb_event event, const struct lyd_node *dnode,
1240 union nb_resource *resource)
1241{
1242 switch (event) {
1243 case NB_EV_VALIDATE:
1244 /* TODO: Not implemented. */
1245 return NB_ERR_INCONSISTENCY;
1246 case NB_EV_PREPARE:
1247 case NB_EV_ABORT:
1248 case NB_EV_APPLY:
1249 /* NOTHING */
1250 break;
1251 }
1252
1253 return NB_OK;
1254}
1255
1256static int lib_interface_eigrp_instance_summarize_addresses_destroy(
1257 enum nb_event event, const struct lyd_node *dnode)
1258{
1259 switch (event) {
1260 case NB_EV_VALIDATE:
1261 /* TODO: Not implemented. */
1262 return NB_ERR_INCONSISTENCY;
1263 case NB_EV_PREPARE:
1264 case NB_EV_ABORT:
1265 case NB_EV_APPLY:
1266 /* NOTHING */
1267 break;
1268 }
1269
1270 return NB_OK;
1271}
1272
1273/*
1274 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/instance/authentication
1275 */
1276static int
1277lib_interface_eigrp_instance_authentication_modify(enum nb_event event,
1278 const struct lyd_node *dnode,
1279 union nb_resource *resource)
1280{
1281 struct eigrp_interface *eif;
1282
1283 switch (event) {
1284 case NB_EV_VALIDATE:
1285 case NB_EV_PREPARE:
1286 case NB_EV_ABORT:
1287 /* NOTHING */
1288 break;
1289 case NB_EV_APPLY:
1290 eif = nb_running_get_entry(dnode, NULL, true);
1291 eif->params.auth_type = yang_dnode_get_enum(dnode, NULL);
1292 break;
1293 }
1294
1295 return NB_OK;
1296}
1297
1298/*
1299 * XPath: /frr-interface:lib/interface/frr-eigrpd:eigrp/instance/keychain
1300 */
1301static int
1302lib_interface_eigrp_instance_keychain_modify(enum nb_event event,
1303 const struct lyd_node *dnode,
1304 union nb_resource *resource)
1305{
1306 struct eigrp_interface *eif;
1307 struct keychain *keychain;
1308
1309 switch (event) {
1310 case NB_EV_VALIDATE:
1311 keychain = keychain_lookup(yang_dnode_get_string(dnode, NULL));
1312 if (keychain == NULL)
1313 return NB_ERR_INCONSISTENCY;
1314 break;
1315 case NB_EV_PREPARE:
1316 resource->ptr = strdup(yang_dnode_get_string(dnode, NULL));
1317 if (resource->ptr == NULL)
1318 return NB_ERR_RESOURCE;
1319 break;
1320 case NB_EV_ABORT:
1321 free(resource->ptr);
1322 resource->ptr = NULL;
1323 break;
1324 case NB_EV_APPLY:
1325 eif = nb_running_get_entry(dnode, NULL, true);
1326 if (eif->params.auth_keychain)
1327 free(eif->params.auth_keychain);
1328
1329 eif->params.auth_keychain = resource->ptr;
1330 break;
1331 }
1332
1333 return NB_OK;
1334}
1335
1336static int
1337lib_interface_eigrp_instance_keychain_destroy(enum nb_event event,
1338 const struct lyd_node *dnode)
1339{
1340 struct eigrp_interface *eif;
1341
1342 switch (event) {
1343 case NB_EV_VALIDATE:
1344 case NB_EV_PREPARE:
1345 case NB_EV_ABORT:
1346 /* NOTHING */
1347 break;
1348 case NB_EV_APPLY:
1349 eif = nb_running_get_entry(dnode, NULL, true);
1350 if (eif->params.auth_keychain)
1351 free(eif->params.auth_keychain);
1352
1353 eif->params.auth_keychain = NULL;
1354 break;
1355 }
1356
1357 return NB_OK;
1358}
1359
1360/* clang-format off */
1361const struct frr_yang_module_info frr_eigrpd_info = {
1362 .name = "frr-eigrpd",
1363 .nodes = {
1364 {
1365 .xpath = "/frr-eigrpd:eigrpd/instance",
1366 .cbs = {
1367 .create = eigrpd_instance_create,
1368 .destroy = eigrpd_instance_destroy,
1369 .cli_show = eigrp_cli_show_header,
1370 .cli_show_end = eigrp_cli_show_end_header,
1371 }
1372 },
1373 {
1374 .xpath = "/frr-eigrpd:eigrpd/instance/router-id",
1375 .cbs = {
1376 .modify = eigrpd_instance_router_id_modify,
1377 .destroy = eigrpd_instance_router_id_destroy,
1378 .cli_show = eigrp_cli_show_router_id,
1379 }
1380 },
1381 {
1382 .xpath = "/frr-eigrpd:eigrpd/instance/passive-interface",
1383 .cbs = {
1384 .create = eigrpd_instance_passive_interface_create,
1385 .destroy = eigrpd_instance_passive_interface_destroy,
1386 .cli_show = eigrp_cli_show_passive_interface,
1387 }
1388 },
1389 {
1390 .xpath = "/frr-eigrpd:eigrpd/instance/active-time",
1391 .cbs = {
1392 .modify = eigrpd_instance_active_time_modify,
1393 .cli_show = eigrp_cli_show_active_time,
1394 }
1395 },
1396 {
1397 .xpath = "/frr-eigrpd:eigrpd/instance/variance",
1398 .cbs = {
1399 .modify = eigrpd_instance_variance_modify,
1400 .destroy = eigrpd_instance_variance_destroy,
1401 .cli_show = eigrp_cli_show_variance,
1402 }
1403 },
1404 {
1405 .xpath = "/frr-eigrpd:eigrpd/instance/maximum-paths",
1406 .cbs = {
1407 .modify = eigrpd_instance_maximum_paths_modify,
1408 .destroy = eigrpd_instance_maximum_paths_destroy,
1409 .cli_show = eigrp_cli_show_maximum_paths,
1410 }
1411 },
1412 {
1413 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights",
1414 .cbs = {
1415 .cli_show = eigrp_cli_show_metrics,
1416 }
1417 },
1418 {
1419 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K1",
1420 .cbs = {
1421 .modify = eigrpd_instance_metric_weights_K1_modify,
1422 .destroy = eigrpd_instance_metric_weights_K1_destroy,
1423 }
1424 },
1425 {
1426 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K2",
1427 .cbs = {
1428 .modify = eigrpd_instance_metric_weights_K2_modify,
1429 .destroy = eigrpd_instance_metric_weights_K2_destroy,
1430 }
1431 },
1432 {
1433 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K3",
1434 .cbs = {
1435 .modify = eigrpd_instance_metric_weights_K3_modify,
1436 .destroy = eigrpd_instance_metric_weights_K3_destroy,
1437 }
1438 },
1439 {
1440 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K4",
1441 .cbs = {
1442 .modify = eigrpd_instance_metric_weights_K4_modify,
1443 .destroy = eigrpd_instance_metric_weights_K4_destroy,
1444 }
1445 },
1446 {
1447 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K5",
1448 .cbs = {
1449 .modify = eigrpd_instance_metric_weights_K5_modify,
1450 .destroy = eigrpd_instance_metric_weights_K5_destroy,
1451 }
1452 },
1453 {
1454 .xpath = "/frr-eigrpd:eigrpd/instance/metric-weights/K6",
1455 .cbs = {
1456 .modify = eigrpd_instance_metric_weights_K6_modify,
1457 .destroy = eigrpd_instance_metric_weights_K6_destroy,
1458 }
1459 },
1460 {
1461 .xpath = "/frr-eigrpd:eigrpd/instance/network",
1462 .cbs = {
1463 .create = eigrpd_instance_network_create,
1464 .destroy = eigrpd_instance_network_destroy,
1465 .cli_show = eigrp_cli_show_network,
1466 }
1467 },
1468 {
1469 .xpath = "/frr-eigrpd:eigrpd/instance/neighbor",
1470 .cbs = {
1471 .create = eigrpd_instance_neighbor_create,
1472 .destroy = eigrpd_instance_neighbor_destroy,
1473 .cli_show = eigrp_cli_show_neighbor,
1474 }
1475 },
1476 {
1477 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute",
1478 .cbs = {
1479 .create = eigrpd_instance_redistribute_create,
1480 .destroy = eigrpd_instance_redistribute_destroy,
1481 .cli_show = eigrp_cli_show_redistribute,
1482 }
1483 },
1484 {
1485 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/route-map",
1486 .cbs = {
1487 .modify = eigrpd_instance_redistribute_route_map_modify,
1488 .destroy = eigrpd_instance_redistribute_route_map_destroy,
1489 }
1490 },
1491 {
1492 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/metrics/bandwidth",
1493 .cbs = {
1494 .modify = eigrpd_instance_redistribute_metrics_bandwidth_modify,
1495 .destroy = eigrpd_instance_redistribute_metrics_bandwidth_destroy,
1496 }
1497 },
1498 {
1499 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/metrics/delay",
1500 .cbs = {
1501 .modify = eigrpd_instance_redistribute_metrics_delay_modify,
1502 .destroy = eigrpd_instance_redistribute_metrics_delay_destroy,
1503 }
1504 },
1505 {
1506 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/metrics/reliability",
1507 .cbs = {
1508 .modify = eigrpd_instance_redistribute_metrics_reliability_modify,
1509 .destroy = eigrpd_instance_redistribute_metrics_reliability_destroy,
1510 }
1511 },
1512 {
1513 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/metrics/load",
1514 .cbs = {
1515 .modify = eigrpd_instance_redistribute_metrics_load_modify,
1516 .destroy = eigrpd_instance_redistribute_metrics_load_destroy,
1517 }
1518 },
1519 {
1520 .xpath = "/frr-eigrpd:eigrpd/instance/redistribute/metrics/mtu",
1521 .cbs = {
1522 .modify = eigrpd_instance_redistribute_metrics_mtu_modify,
1523 .destroy = eigrpd_instance_redistribute_metrics_mtu_destroy,
1524 }
1525 },
1526 {
1527 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/delay",
1528 .cbs = {
1529 .modify = lib_interface_eigrp_delay_modify,
1530 .cli_show = eigrp_cli_show_delay,
1531 }
1532 },
1533 {
1534 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/bandwidth",
1535 .cbs = {
1536 .modify = lib_interface_eigrp_bandwidth_modify,
1537 .cli_show = eigrp_cli_show_bandwidth,
1538 }
1539 },
1540 {
1541 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/hello-interval",
1542 .cbs = {
1543 .modify = lib_interface_eigrp_hello_interval_modify,
1544 .cli_show = eigrp_cli_show_hello_interval,
1545 }
1546 },
1547 {
1548 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/hold-time",
1549 .cbs = {
1550 .modify = lib_interface_eigrp_hold_time_modify,
1551 .cli_show = eigrp_cli_show_hold_time,
1552 }
1553 },
1554 {
1555 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/split-horizon",
1556 .cbs = {
1557 .modify = lib_interface_eigrp_split_horizon_modify,
1558 }
1559 },
1560 {
1561 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/instance",
1562 .cbs = {
1563 .create = lib_interface_eigrp_instance_create,
1564 .destroy = lib_interface_eigrp_instance_destroy,
1565 }
1566 },
1567 {
1568 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/instance/summarize-addresses",
1569 .cbs = {
1570 .create = lib_interface_eigrp_instance_summarize_addresses_create,
1571 .destroy = lib_interface_eigrp_instance_summarize_addresses_destroy,
1572 .cli_show = eigrp_cli_show_summarize_address,
1573 }
1574 },
1575 {
1576 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/instance/authentication",
1577 .cbs = {
1578 .modify = lib_interface_eigrp_instance_authentication_modify,
1579 .cli_show = eigrp_cli_show_authentication,
1580 }
1581 },
1582 {
1583 .xpath = "/frr-interface:lib/interface/frr-eigrpd:eigrp/instance/keychain",
1584 .cbs = {
1585 .modify = lib_interface_eigrp_instance_keychain_modify,
1586 .destroy = lib_interface_eigrp_instance_keychain_destroy,
1587 .cli_show = eigrp_cli_show_keychain,
1588 }
1589 },
1590 {
1591 .xpath = NULL,
1592 },
1593 }
1594};
FRRouting mirror