]> git.proxmox.com Git - mirror_frr.git/blob - ripngd/ripng_interface.c
ospfd: Cleanup ospf->redist and ospf->external on shutdown
[mirror_frr.git] / ripngd / ripng_interface.c
1 /*
2 * Interface related function for RIPng.
3 * Copyright (C) 1998 Kunihiro Ishiguro
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include "linklist.h"
25 #include "if.h"
26 #include "prefix.h"
27 #include "memory.h"
28 #include "network.h"
29 #include "filter.h"
30 #include "log.h"
31 #include "stream.h"
32 #include "zclient.h"
33 #include "command.h"
34 #include "agg_table.h"
35 #include "thread.h"
36 #include "privs.h"
37 #include "vrf.h"
38 #include "lib_errors.h"
39 #include "northbound_cli.h"
40
41 #include "ripngd/ripngd.h"
42 #include "ripngd/ripng_debug.h"
43
44 /* If RFC2133 definition is used. */
45 #ifndef IPV6_JOIN_GROUP
46 #define IPV6_JOIN_GROUP IPV6_ADD_MEMBERSHIP
47 #endif
48 #ifndef IPV6_LEAVE_GROUP
49 #define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP
50 #endif
51
52 DEFINE_MTYPE_STATIC(RIPNGD, RIPNG_IF, "ripng interface")
53
54 /* Static utility function. */
55 static void ripng_enable_apply(struct interface *);
56 static void ripng_passive_interface_apply(struct interface *);
57 static int ripng_enable_if_lookup(struct ripng *ripng, const char *ifname);
58 static int ripng_enable_network_lookup2(struct connected *);
59 static void ripng_enable_apply_all(struct ripng *ripng);
60
61 /* Join to the all rip routers multicast group. */
62 static int ripng_multicast_join(struct interface *ifp, int sock)
63 {
64 int ret;
65 struct ipv6_mreq mreq;
66 int save_errno;
67
68 if (if_is_multicast(ifp)) {
69 memset(&mreq, 0, sizeof(mreq));
70 inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
71 mreq.ipv6mr_interface = ifp->ifindex;
72
73 /*
74 * NetBSD 1.6.2 requires root to join groups on gif(4).
75 * While this is bogus, privs are available and easy to use
76 * for this call as a workaround.
77 */
78 frr_elevate_privs(&ripngd_privs) {
79
80 ret = setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
81 (char *)&mreq, sizeof(mreq));
82 save_errno = errno;
83
84 }
85
86 if (ret < 0 && save_errno == EADDRINUSE) {
87 /*
88 * Group is already joined. This occurs due to sloppy
89 * group
90 * management, in particular declining to leave the
91 * group on
92 * an interface that has just gone down.
93 */
94 zlog_warn("ripng join on %s EADDRINUSE (ignoring)",
95 ifp->name);
96 return 0; /* not an error */
97 }
98
99 if (ret < 0)
100 zlog_warn("can't setsockopt IPV6_JOIN_GROUP: %s",
101 safe_strerror(save_errno));
102
103 if (IS_RIPNG_DEBUG_EVENT)
104 zlog_debug(
105 "RIPng %s join to all-rip-routers multicast group",
106 ifp->name);
107
108 if (ret < 0)
109 return -1;
110 }
111 return 0;
112 }
113
114 /* Leave from the all rip routers multicast group. */
115 static int ripng_multicast_leave(struct interface *ifp, int sock)
116 {
117 int ret;
118 struct ipv6_mreq mreq;
119
120 if (if_is_multicast(ifp)) {
121 memset(&mreq, 0, sizeof(mreq));
122 inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
123 mreq.ipv6mr_interface = ifp->ifindex;
124
125 ret = setsockopt(sock, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
126 (char *)&mreq, sizeof(mreq));
127 if (ret < 0)
128 zlog_warn("can't setsockopt IPV6_LEAVE_GROUP: %s",
129 safe_strerror(errno));
130
131 if (IS_RIPNG_DEBUG_EVENT)
132 zlog_debug(
133 "RIPng %s leave from all-rip-routers multicast group",
134 ifp->name);
135
136 if (ret < 0)
137 return -1;
138 }
139
140 return 0;
141 }
142
143 /* How many link local IPv6 address could be used on the interface ? */
144 static int ripng_if_ipv6_lladdress_check(struct interface *ifp)
145 {
146 struct listnode *nn;
147 struct connected *connected;
148 int count = 0;
149
150 for (ALL_LIST_ELEMENTS_RO(ifp->connected, nn, connected)) {
151 struct prefix *p;
152 p = connected->address;
153
154 if ((p->family == AF_INET6)
155 && IN6_IS_ADDR_LINKLOCAL(&p->u.prefix6))
156 count++;
157 }
158
159 return count;
160 }
161
162 static int ripng_if_down(struct interface *ifp)
163 {
164 struct agg_node *rp;
165 struct ripng_info *rinfo;
166 struct ripng_interface *ri;
167 struct ripng *ripng;
168 struct list *list = NULL;
169 struct listnode *listnode = NULL, *nextnode = NULL;
170
171 ri = ifp->info;
172 ripng = ri->ripng;
173
174 if (ripng)
175 for (rp = agg_route_top(ripng->table); rp;
176 rp = agg_route_next(rp))
177 if ((list = rp->info) != NULL)
178 for (ALL_LIST_ELEMENTS(list, listnode, nextnode,
179 rinfo))
180 if (rinfo->ifindex == ifp->ifindex)
181 ripng_ecmp_delete(ripng, rinfo);
182
183
184 if (ri->running) {
185 if (IS_RIPNG_DEBUG_EVENT)
186 zlog_debug("turn off %s", ifp->name);
187
188 /* Leave from multicast group. */
189 if (ripng)
190 ripng_multicast_leave(ifp, ripng->sock);
191
192 ri->running = 0;
193 }
194
195 return 0;
196 }
197
198 /* Inteface link up message processing. */
199 int ripng_interface_up(ZAPI_CALLBACK_ARGS)
200 {
201 struct stream *s;
202 struct interface *ifp;
203
204 /* zebra_interface_state_read() updates interface structure in iflist.
205 */
206 s = zclient->ibuf;
207 ifp = zebra_interface_state_read(s, vrf_id);
208
209 if (ifp == NULL)
210 return 0;
211
212 if (IS_RIPNG_DEBUG_ZEBRA)
213 zlog_debug(
214 "interface up %s vrf %u index %d flags %llx metric %d mtu %d",
215 ifp->name, ifp->vrf->vrf_id, ifp->ifindex,
216 (unsigned long long)ifp->flags, ifp->metric, ifp->mtu6);
217
218 ripng_interface_sync(ifp);
219
220 /* Check if this interface is RIPng enabled or not. */
221 ripng_enable_apply(ifp);
222
223 /* Check for a passive interface. */
224 ripng_passive_interface_apply(ifp);
225
226 /* Apply distribute list to the all interface. */
227 ripng_distribute_update_interface(ifp);
228
229 return 0;
230 }
231
232 /* Inteface link down message processing. */
233 int ripng_interface_down(ZAPI_CALLBACK_ARGS)
234 {
235 struct stream *s;
236 struct interface *ifp;
237
238 /* zebra_interface_state_read() updates interface structure in iflist.
239 */
240 s = zclient->ibuf;
241 ifp = zebra_interface_state_read(s, vrf_id);
242
243 if (ifp == NULL)
244 return 0;
245
246 ripng_interface_sync(ifp);
247 ripng_if_down(ifp);
248
249 if (IS_RIPNG_DEBUG_ZEBRA)
250 zlog_debug(
251 "interface down %s vrf %u index %d flags %#llx metric %d mtu %d",
252 ifp->name, ifp->vrf->vrf_id, ifp->ifindex,
253 (unsigned long long)ifp->flags, ifp->metric, ifp->mtu6);
254
255 return 0;
256 }
257
258 /* Inteface addition message from zebra. */
259 int ripng_interface_add(ZAPI_CALLBACK_ARGS)
260 {
261 struct interface *ifp;
262
263 ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
264 ripng_interface_sync(ifp);
265
266 if (IS_RIPNG_DEBUG_ZEBRA)
267 zlog_debug(
268 "RIPng interface add %s vrf %u index %d flags %#llx metric %d mtu %d",
269 ifp->name, ifp->vrf->vrf_id, ifp->ifindex,
270 (unsigned long long)ifp->flags, ifp->metric, ifp->mtu6);
271
272 /* Check is this interface is RIP enabled or not.*/
273 ripng_enable_apply(ifp);
274
275 /* Apply distribute list to the interface. */
276 ripng_distribute_update_interface(ifp);
277
278 /* Check interface routemap. */
279 ripng_if_rmap_update_interface(ifp);
280
281 return 0;
282 }
283
284 int ripng_interface_delete(ZAPI_CALLBACK_ARGS)
285 {
286 struct interface *ifp;
287 struct stream *s;
288
289 s = zclient->ibuf;
290 /* zebra_interface_state_read() updates interface structure in iflist
291 */
292 ifp = zebra_interface_state_read(s, vrf_id);
293
294 if (ifp == NULL)
295 return 0;
296
297 ripng_interface_sync(ifp);
298 if (if_is_up(ifp)) {
299 ripng_if_down(ifp);
300 }
301
302 zlog_info(
303 "interface delete %s vrf %u index %d flags %#llx metric %d mtu %d",
304 ifp->name, ifp->vrf->vrf_id, ifp->ifindex,
305 (unsigned long long)ifp->flags, ifp->metric, ifp->mtu6);
306
307 /* To support pseudo interface do not free interface structure. */
308 /* if_delete(ifp); */
309 if_set_index(ifp, IFINDEX_INTERNAL);
310
311 return 0;
312 }
313
314 /* VRF update for an interface. */
315 int ripng_interface_vrf_update(ZAPI_CALLBACK_ARGS)
316 {
317 struct interface *ifp;
318 vrf_id_t new_vrf_id;
319 struct vrf *new_vrf;
320
321 ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
322 &new_vrf_id);
323 if (!ifp)
324 return 0;
325
326 new_vrf = vrf_lookup_by_id(new_vrf_id);
327
328 if (IS_RIPNG_DEBUG_ZEBRA)
329 zlog_debug("interface %s VRF change vrf_id %u new vrf id %u",
330 ifp->name, vrf_id, new_vrf_id);
331
332 if_update_to_new_vrf(ifp, new_vrf);
333
334 ripng_interface_sync(ifp);
335
336 return 0;
337 }
338
339 void ripng_interface_clean(struct ripng *ripng)
340 {
341 struct interface *ifp;
342 struct ripng_interface *ri;
343
344 FOR_ALL_INTERFACES (ripng->vrf, ifp) {
345 ri = ifp->info;
346
347 ri->enable_network = 0;
348 ri->enable_interface = 0;
349 ri->running = 0;
350
351 if (ri->t_wakeup) {
352 thread_cancel(ri->t_wakeup);
353 ri->t_wakeup = NULL;
354 }
355 }
356 }
357
358 static void ripng_apply_address_add(struct connected *ifc)
359 {
360 struct ripng_interface *ri = ifc->ifp->info;
361 struct ripng *ripng = ri->ripng;
362 struct prefix_ipv6 address;
363 struct prefix *p;
364
365 if (!ripng)
366 return;
367
368 if (!if_is_up(ifc->ifp))
369 return;
370
371 p = ifc->address;
372
373 memset(&address, 0, sizeof(address));
374 address.family = p->family;
375 address.prefix = p->u.prefix6;
376 address.prefixlen = p->prefixlen;
377 apply_mask_ipv6(&address);
378
379 /* Check if this interface is RIP enabled or not
380 or Check if this address's prefix is RIP enabled */
381 if ((ripng_enable_if_lookup(ripng, ifc->ifp->name) >= 0)
382 || (ripng_enable_network_lookup2(ifc) >= 0))
383 ripng_redistribute_add(ripng, ZEBRA_ROUTE_CONNECT,
384 RIPNG_ROUTE_INTERFACE, &address,
385 ifc->ifp->ifindex, NULL, 0);
386 }
387
388 int ripng_interface_address_add(ZAPI_CALLBACK_ARGS)
389 {
390 struct connected *c;
391 struct prefix *p;
392
393 c = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_ADD,
394 zclient->ibuf, vrf_id);
395
396 if (c == NULL)
397 return 0;
398
399 p = c->address;
400
401 if (p->family == AF_INET6) {
402 struct ripng_interface *ri = c->ifp->info;
403
404 if (IS_RIPNG_DEBUG_ZEBRA)
405 zlog_debug("RIPng connected address %s/%d add",
406 inet6_ntoa(p->u.prefix6), p->prefixlen);
407
408 /* Check is this prefix needs to be redistributed. */
409 ripng_apply_address_add(c);
410
411 /* Let's try once again whether the interface could be activated
412 */
413 if (!ri->running) {
414 /* Check if this interface is RIP enabled or not.*/
415 ripng_enable_apply(c->ifp);
416
417 /* Apply distribute list to the interface. */
418 ripng_distribute_update_interface(c->ifp);
419
420 /* Check interface routemap. */
421 ripng_if_rmap_update_interface(c->ifp);
422 }
423 }
424
425 return 0;
426 }
427
428 static void ripng_apply_address_del(struct connected *ifc)
429 {
430 struct ripng_interface *ri = ifc->ifp->info;
431 struct ripng *ripng = ri->ripng;
432 struct prefix_ipv6 address;
433 struct prefix *p;
434
435 if (!ripng)
436 return;
437
438 if (!if_is_up(ifc->ifp))
439 return;
440
441 p = ifc->address;
442
443 memset(&address, 0, sizeof(address));
444 address.family = p->family;
445 address.prefix = p->u.prefix6;
446 address.prefixlen = p->prefixlen;
447 apply_mask_ipv6(&address);
448
449 ripng_redistribute_delete(ripng, ZEBRA_ROUTE_CONNECT,
450 RIPNG_ROUTE_INTERFACE, &address,
451 ifc->ifp->ifindex);
452 }
453
454 int ripng_interface_address_delete(ZAPI_CALLBACK_ARGS)
455 {
456 struct connected *ifc;
457 struct prefix *p;
458 char buf[INET6_ADDRSTRLEN];
459
460 ifc = zebra_interface_address_read(ZEBRA_INTERFACE_ADDRESS_DELETE,
461 zclient->ibuf, vrf_id);
462
463 if (ifc) {
464 p = ifc->address;
465
466 if (p->family == AF_INET6) {
467 if (IS_RIPNG_DEBUG_ZEBRA)
468 zlog_debug(
469 "RIPng connected address %s/%d delete",
470 inet_ntop(AF_INET6, &p->u.prefix6, buf,
471 INET6_ADDRSTRLEN),
472 p->prefixlen);
473
474 /* Check wether this prefix needs to be removed. */
475 ripng_apply_address_del(ifc);
476 }
477 connected_free(ifc);
478 }
479
480 return 0;
481 }
482
483 /* Lookup RIPng enable network. */
484 /* Check wether the interface has at least a connected prefix that
485 * is within the ripng->enable_network table. */
486 static int ripng_enable_network_lookup_if(struct interface *ifp)
487 {
488 struct ripng_interface *ri = ifp->info;
489 struct ripng *ripng = ri->ripng;
490 struct listnode *node;
491 struct connected *connected;
492 struct prefix_ipv6 address;
493
494 if (!ripng)
495 return -1;
496
497 for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, connected)) {
498 struct prefix *p;
499 struct agg_node *n;
500
501 p = connected->address;
502
503 if (p->family == AF_INET6) {
504 address.family = AF_INET6;
505 address.prefix = p->u.prefix6;
506 address.prefixlen = IPV6_MAX_BITLEN;
507
508 n = agg_node_match(ripng->enable_network,
509 (struct prefix *)&address);
510 if (n) {
511 agg_unlock_node(n);
512 return 1;
513 }
514 }
515 }
516 return -1;
517 }
518
519 /* Check wether connected is within the ripng->enable_network table. */
520 static int ripng_enable_network_lookup2(struct connected *connected)
521 {
522 struct ripng_interface *ri = connected->ifp->info;
523 struct ripng *ripng = ri->ripng;
524 struct prefix_ipv6 address;
525 struct prefix *p;
526
527 if (!ripng)
528 return -1;
529
530 p = connected->address;
531
532 if (p->family == AF_INET6) {
533 struct agg_node *node;
534
535 address.family = p->family;
536 address.prefix = p->u.prefix6;
537 address.prefixlen = IPV6_MAX_BITLEN;
538
539 /* LPM on p->family, p->u.prefix6/IPV6_MAX_BITLEN within
540 * ripng->enable_network */
541 node = agg_node_match(ripng->enable_network,
542 (struct prefix *)&address);
543
544 if (node) {
545 agg_unlock_node(node);
546 return 1;
547 }
548 }
549
550 return -1;
551 }
552
553 /* Add RIPng enable network. */
554 int ripng_enable_network_add(struct ripng *ripng, struct prefix *p)
555 {
556 struct agg_node *node;
557
558 node = agg_node_get(ripng->enable_network, p);
559
560 if (node->info) {
561 agg_unlock_node(node);
562 return NB_ERR_INCONSISTENCY;
563 } else
564 node->info = (void *)1;
565
566 /* XXX: One should find a better solution than a generic one */
567 ripng_enable_apply_all(ripng);
568
569 return NB_OK;
570 }
571
572 /* Delete RIPng enable network. */
573 int ripng_enable_network_delete(struct ripng *ripng, struct prefix *p)
574 {
575 struct agg_node *node;
576
577 node = agg_node_lookup(ripng->enable_network, p);
578 if (node) {
579 node->info = NULL;
580
581 /* Unlock info lock. */
582 agg_unlock_node(node);
583
584 /* Unlock lookup lock. */
585 agg_unlock_node(node);
586
587 return NB_OK;
588 }
589
590 return NB_ERR_INCONSISTENCY;
591 }
592
593 /* Lookup function. */
594 static int ripng_enable_if_lookup(struct ripng *ripng, const char *ifname)
595 {
596 unsigned int i;
597 char *str;
598
599 if (!ripng)
600 return -1;
601
602 for (i = 0; i < vector_active(ripng->enable_if); i++)
603 if ((str = vector_slot(ripng->enable_if, i)) != NULL)
604 if (strcmp(str, ifname) == 0)
605 return i;
606 return -1;
607 }
608
609 int ripng_enable_if_add(struct ripng *ripng, const char *ifname)
610 {
611 int ret;
612
613 ret = ripng_enable_if_lookup(ripng, ifname);
614 if (ret >= 0)
615 return NB_ERR_INCONSISTENCY;
616
617 vector_set(ripng->enable_if, strdup(ifname));
618
619 ripng_enable_apply_all(ripng);
620
621 return NB_OK;
622 }
623
624 int ripng_enable_if_delete(struct ripng *ripng, const char *ifname)
625 {
626 int index;
627 char *str;
628
629 index = ripng_enable_if_lookup(ripng, ifname);
630 if (index < 0)
631 return NB_ERR_INCONSISTENCY;
632
633 str = vector_slot(ripng->enable_if, index);
634 free(str);
635 vector_unset(ripng->enable_if, index);
636
637 ripng_enable_apply_all(ripng);
638
639 return NB_OK;
640 }
641
642 /* Wake up interface. */
643 static int ripng_interface_wakeup(struct thread *t)
644 {
645 struct interface *ifp;
646 struct ripng_interface *ri;
647
648 /* Get interface. */
649 ifp = THREAD_ARG(t);
650
651 ri = ifp->info;
652 ri->t_wakeup = NULL;
653
654 /* Join to multicast group. */
655 if (ripng_multicast_join(ifp, ri->ripng->sock) < 0) {
656 flog_err_sys(EC_LIB_SOCKET,
657 "multicast join failed, interface %s not running",
658 ifp->name);
659 return 0;
660 }
661
662 /* Set running flag. */
663 ri->running = 1;
664
665 /* Send RIP request to the interface. */
666 ripng_request(ifp);
667
668 return 0;
669 }
670
671 static void ripng_connect_set(struct interface *ifp, int set)
672 {
673 struct ripng_interface *ri = ifp->info;
674 struct ripng *ripng = ri->ripng;
675 struct listnode *node, *nnode;
676 struct connected *connected;
677 struct prefix_ipv6 address;
678
679 for (ALL_LIST_ELEMENTS(ifp->connected, node, nnode, connected)) {
680 struct prefix *p;
681 p = connected->address;
682
683 if (p->family != AF_INET6)
684 continue;
685
686 address.family = AF_INET6;
687 address.prefix = p->u.prefix6;
688 address.prefixlen = p->prefixlen;
689 apply_mask_ipv6(&address);
690
691 if (set) {
692 /* Check once more wether this prefix is within a
693 * "network IF_OR_PREF" one */
694 if ((ripng_enable_if_lookup(ripng, connected->ifp->name)
695 >= 0)
696 || (ripng_enable_network_lookup2(connected) >= 0))
697 ripng_redistribute_add(
698 ripng, ZEBRA_ROUTE_CONNECT,
699 RIPNG_ROUTE_INTERFACE, &address,
700 connected->ifp->ifindex, NULL, 0);
701 } else {
702 ripng_redistribute_delete(ripng, ZEBRA_ROUTE_CONNECT,
703 RIPNG_ROUTE_INTERFACE,
704 &address,
705 connected->ifp->ifindex);
706 if (ripng_redistribute_check(ripng,
707 ZEBRA_ROUTE_CONNECT))
708 ripng_redistribute_add(
709 ripng, ZEBRA_ROUTE_CONNECT,
710 RIPNG_ROUTE_REDISTRIBUTE, &address,
711 connected->ifp->ifindex, NULL, 0);
712 }
713 }
714 }
715
716 /* Check RIPng is enabed on this interface. */
717 void ripng_enable_apply(struct interface *ifp)
718 {
719 int ret;
720 struct ripng_interface *ri = NULL;
721
722 /* Check interface. */
723 if (!if_is_up(ifp))
724 return;
725
726 ri = ifp->info;
727
728 /* Is this interface a candidate for RIPng ? */
729 ret = ripng_enable_network_lookup_if(ifp);
730
731 /* If the interface is matched. */
732 if (ret > 0)
733 ri->enable_network = 1;
734 else
735 ri->enable_network = 0;
736
737 /* Check interface name configuration. */
738 ret = ripng_enable_if_lookup(ri->ripng, ifp->name);
739 if (ret >= 0)
740 ri->enable_interface = 1;
741 else
742 ri->enable_interface = 0;
743
744 /* any candidate interface MUST have a link-local IPv6 address */
745 if ((!ripng_if_ipv6_lladdress_check(ifp))
746 && (ri->enable_network || ri->enable_interface)) {
747 ri->enable_network = 0;
748 ri->enable_interface = 0;
749 zlog_warn("Interface %s does not have any link-local address",
750 ifp->name);
751 }
752
753 /* Update running status of the interface. */
754 if (ri->enable_network || ri->enable_interface) {
755 zlog_info("RIPng INTERFACE ON %s", ifp->name);
756
757 /* Add interface wake up thread. */
758 thread_add_timer(master, ripng_interface_wakeup, ifp, 1,
759 &ri->t_wakeup);
760
761 ripng_connect_set(ifp, 1);
762 } else {
763 if (ri->running) {
764 /* Might as well clean up the route table as well
765 * ripng_if_down sets to 0 ri->running, and displays
766 *"turn off %s"
767 **/
768 ripng_if_down(ifp);
769
770 ripng_connect_set(ifp, 0);
771 }
772 }
773 }
774
775 /* Set distribute list to all interfaces. */
776 static void ripng_enable_apply_all(struct ripng *ripng)
777 {
778 struct interface *ifp;
779
780 FOR_ALL_INTERFACES (ripng->vrf, ifp)
781 ripng_enable_apply(ifp);
782 }
783
784 /* Clear all network and neighbor configuration */
785 void ripng_clean_network(struct ripng *ripng)
786 {
787 unsigned int i;
788 char *str;
789 struct agg_node *rn;
790
791 /* ripng->enable_network */
792 for (rn = agg_route_top(ripng->enable_network); rn;
793 rn = agg_route_next(rn))
794 if (rn->info) {
795 rn->info = NULL;
796 agg_unlock_node(rn);
797 }
798
799 /* ripng->enable_if */
800 for (i = 0; i < vector_active(ripng->enable_if); i++)
801 if ((str = vector_slot(ripng->enable_if, i)) != NULL) {
802 free(str);
803 vector_slot(ripng->enable_if, i) = NULL;
804 }
805 }
806
807 /* Utility function for looking up passive interface settings. */
808 static int ripng_passive_interface_lookup(struct ripng *ripng,
809 const char *ifname)
810 {
811 unsigned int i;
812 char *str;
813
814 for (i = 0; i < vector_active(ripng->passive_interface); i++)
815 if ((str = vector_slot(ripng->passive_interface, i)) != NULL)
816 if (strcmp(str, ifname) == 0)
817 return i;
818 return -1;
819 }
820
821 void ripng_passive_interface_apply(struct interface *ifp)
822 {
823 int ret;
824 struct ripng_interface *ri;
825 struct ripng *ripng;
826
827 ri = ifp->info;
828 ripng = ri->ripng;
829 if (!ripng)
830 return;
831
832 ret = ripng_passive_interface_lookup(ripng, ifp->name);
833 if (ret < 0)
834 ri->passive = 0;
835 else
836 ri->passive = 1;
837 }
838
839 static void ripng_passive_interface_apply_all(struct ripng *ripng)
840 {
841 struct interface *ifp;
842
843 FOR_ALL_INTERFACES (ripng->vrf, ifp)
844 ripng_passive_interface_apply(ifp);
845 }
846
847 /* Passive interface. */
848 int ripng_passive_interface_set(struct ripng *ripng, const char *ifname)
849 {
850 if (ripng_passive_interface_lookup(ripng, ifname) >= 0)
851 return NB_ERR_INCONSISTENCY;
852
853 vector_set(ripng->passive_interface, strdup(ifname));
854
855 ripng_passive_interface_apply_all(ripng);
856
857 return NB_OK;
858 }
859
860 int ripng_passive_interface_unset(struct ripng *ripng, const char *ifname)
861 {
862 int i;
863 char *str;
864
865 i = ripng_passive_interface_lookup(ripng, ifname);
866 if (i < 0)
867 return NB_ERR_INCONSISTENCY;
868
869 str = vector_slot(ripng->passive_interface, i);
870 free(str);
871 vector_unset(ripng->passive_interface, i);
872
873 ripng_passive_interface_apply_all(ripng);
874
875 return NB_OK;
876 }
877
878 /* Free all configured RIP passive-interface settings. */
879 void ripng_passive_interface_clean(struct ripng *ripng)
880 {
881 unsigned int i;
882 char *str;
883
884 for (i = 0; i < vector_active(ripng->passive_interface); i++)
885 if ((str = vector_slot(ripng->passive_interface, i)) != NULL) {
886 free(str);
887 vector_slot(ripng->passive_interface, i) = NULL;
888 }
889 ripng_passive_interface_apply_all(ripng);
890 }
891
892 /* Write RIPng enable network and interface to the vty. */
893 int ripng_network_write(struct vty *vty, struct ripng *ripng)
894 {
895 unsigned int i;
896 const char *ifname;
897 struct agg_node *node;
898 char buf[BUFSIZ];
899
900 /* Write enable network. */
901 for (node = agg_route_top(ripng->enable_network); node;
902 node = agg_route_next(node))
903 if (node->info) {
904 struct prefix *p = &node->p;
905 vty_out(vty, " %s/%d\n",
906 inet_ntop(p->family, &p->u.prefix, buf, BUFSIZ),
907 p->prefixlen);
908 }
909
910 /* Write enable interface. */
911 for (i = 0; i < vector_active(ripng->enable_if); i++)
912 if ((ifname = vector_slot(ripng->enable_if, i)) != NULL)
913 vty_out(vty, " %s\n", ifname);
914
915 return 0;
916 }
917
918 static struct ripng_interface *ri_new(void)
919 {
920 struct ripng_interface *ri;
921
922 ri = XCALLOC(MTYPE_RIPNG_IF, sizeof(struct ripng_interface));
923
924 /* Set default split-horizon behavior. If the interface is Frame
925 Relay or SMDS is enabled, the default value for split-horizon is
926 off. But currently Zebra does detect Frame Relay or SMDS
927 interface. So all interface is set to split horizon. */
928 ri->split_horizon =
929 yang_get_default_enum("%s/split-horizon", RIPNG_IFACE);
930
931 return ri;
932 }
933
934 void ripng_interface_sync(struct interface *ifp)
935 {
936 struct vrf *vrf;
937
938 vrf = ifp->vrf;
939 if (vrf) {
940 struct ripng_interface *ri;
941
942 ri = ifp->info;
943 if (ri)
944 ri->ripng = vrf->info;
945 }
946 }
947
948 static int ripng_if_new_hook(struct interface *ifp)
949 {
950 ifp->info = ri_new();
951 ripng_interface_sync(ifp);
952
953 return 0;
954 }
955
956 /* Called when interface structure deleted. */
957 static int ripng_if_delete_hook(struct interface *ifp)
958 {
959 XFREE(MTYPE_RIPNG_IF, ifp->info);
960 ifp->info = NULL;
961 return 0;
962 }
963
964 /* Configuration write function for ripngd. */
965 static int interface_config_write(struct vty *vty)
966 {
967 struct vrf *vrf;
968 int write = 0;
969
970 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
971 struct interface *ifp;
972
973 FOR_ALL_INTERFACES (vrf, ifp) {
974 struct lyd_node *dnode;
975
976 dnode = yang_dnode_get(
977 running_config->dnode,
978 "/frr-interface:lib/interface[name='%s'][vrf='%s']",
979 ifp->name, vrf->name);
980 if (dnode == NULL)
981 continue;
982
983 write = 1;
984 nb_cli_show_dnode_cmds(vty, dnode, false);
985 }
986 }
987
988 return write;
989 }
990
991 /* ripngd's interface node. */
992 static struct cmd_node interface_node = {
993 INTERFACE_NODE, "%s(config-if)# ", 1 /* VTYSH */
994 };
995
996 /* Initialization of interface. */
997 void ripng_if_init(void)
998 {
999 /* Interface initialize. */
1000 hook_register_prio(if_add, 0, ripng_if_new_hook);
1001 hook_register_prio(if_del, 0, ripng_if_delete_hook);
1002
1003 /* Install interface node. */
1004 install_node(&interface_node, interface_config_write);
1005 if_cmd_init();
1006 }