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
18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "linklist.h"
26: #include "if.h"
27: #include "prefix.h"
28: #include "memory.h"
29: #include "network.h"
30: #include "filter.h"
31: #include "log.h"
32: #include "stream.h"
33: #include "zclient.h"
34: #include "command.h"
35: #include "table.h"
36: #include "thread.h"
37: #include "privs.h"
38: #include "vrf.h"
39:
40: #include "ripngd/ripngd.h"
41: #include "ripngd/ripng_debug.h"
42:
43: /* If RFC2133 definition is used. */
44: #ifndef IPV6_JOIN_GROUP
45: #define IPV6_JOIN_GROUP IPV6_ADD_MEMBERSHIP
46: #endif
47: #ifndef IPV6_LEAVE_GROUP
48: #define IPV6_LEAVE_GROUP IPV6_DROP_MEMBERSHIP
49: #endif
50:
51: extern struct zebra_privs_t ripngd_privs;
52:
53: /* Static utility function. */
54: static void ripng_enable_apply (struct interface *);
55: static void ripng_passive_interface_apply (struct interface *);
56: static int ripng_enable_if_lookup (const char *);
57: static int ripng_enable_network_lookup2 (struct connected *);
58: static void ripng_enable_apply_all (void);
59:
60: /* Join to the all rip routers multicast group. */
61: static int
62: ripng_multicast_join (struct interface *ifp)
63: {
64: int ret;
65: struct ipv6_mreq mreq;
66: int save_errno;
67:
68: if (if_is_up (ifp) && 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: if (ripngd_privs.change (ZPRIVS_RAISE))
79: zlog_err ("ripng_multicast_join: could not raise privs");
80:
81: ret = setsockopt (ripng->sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
82: (char *) &mreq, sizeof (mreq));
83: save_errno = errno;
84:
85: if (ripngd_privs.change (ZPRIVS_LOWER))
86: zlog_err ("ripng_multicast_join: could not lower privs");
87:
88: if (ret < 0 && save_errno == EADDRINUSE)
89: {
90: /*
91: * Group is already joined. This occurs due to sloppy group
92: * management, in particular declining to leave the group on
93: * an interface that has just gone down.
94: */
95: zlog_warn ("ripng join on %s EADDRINUSE (ignoring)\n", 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 ("RIPng %s join to all-rip-routers multicast group", ifp->name);
105:
106: if (ret < 0)
107: return -1;
108: }
109: return 0;
110: }
111:
112: /* Leave from the all rip routers multicast group. */
113: static int
114: ripng_multicast_leave (struct interface *ifp)
115: {
116: int ret;
117: struct ipv6_mreq mreq;
118:
119: if (if_is_up (ifp) && if_is_multicast (ifp)) {
120: memset (&mreq, 0, sizeof (mreq));
121: inet_pton(AF_INET6, RIPNG_GROUP, &mreq.ipv6mr_multiaddr);
122: mreq.ipv6mr_interface = ifp->ifindex;
123:
124: ret = setsockopt (ripng->sock, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
125: (char *) &mreq, sizeof (mreq));
126: if (ret < 0)
127: zlog_warn ("can't setsockopt IPV6_LEAVE_GROUP: %s\n", safe_strerror (errno));
128:
129: if (IS_RIPNG_DEBUG_EVENT)
130: zlog_debug ("RIPng %s leave from all-rip-routers multicast group",
131: ifp->name);
132:
133: if (ret < 0)
134: return -1;
135: }
136:
137: return 0;
138: }
139:
140: /* How many link local IPv6 address could be used on the interface ? */
141: static int
142: ripng_if_ipv6_lladdress_check (struct interface *ifp)
143: {
144: struct listnode *nn;
145: struct connected *connected;
146: int count = 0;
147:
148: for (ALL_LIST_ELEMENTS_RO (ifp->connected, nn, connected))
149: {
150: struct prefix *p;
151: p = connected->address;
152:
153: if ((p->family == AF_INET6) &&
154: IN6_IS_ADDR_LINKLOCAL (&p->u.prefix6))
155: count++;
156: }
157:
158: return count;
159: }
160:
161: static int
162: ripng_if_down (struct interface *ifp)
163: {
164: struct route_node *rp;
165: struct ripng_info *rinfo;
166: struct ripng_interface *ri;
167: struct list *list = NULL;
168: struct listnode *listnode = NULL, *nextnode = NULL;
169:
170: if (ripng)
171: for (rp = route_top (ripng->table); rp; rp = route_next (rp))
172: if ((list = rp->info) != NULL)
173: for (ALL_LIST_ELEMENTS (list, listnode, nextnode, rinfo))
174: if (rinfo->ifindex == ifp->ifindex)
175: ripng_ecmp_delete (rinfo);
176:
177: ri = ifp->info;
178:
179: if (ri->running)
180: {
181: if (IS_RIPNG_DEBUG_EVENT)
182: zlog_debug ("turn off %s", ifp->name);
183:
184: /* Leave from multicast group. */
185: ripng_multicast_leave (ifp);
186:
187: ri->running = 0;
188: }
189:
190: return 0;
191: }
192:
193: /* Inteface link up message processing. */
194: int
195: ripng_interface_up (int command, struct zclient *zclient, zebra_size_t length,
196: vrf_id_t vrf_id)
197: {
198: struct stream *s;
199: struct interface *ifp;
200:
201: /* zebra_interface_state_read() updates interface structure in iflist. */
202: s = zclient->ibuf;
203: ifp = zebra_interface_state_read (s, vrf_id);
204:
205: if (ifp == NULL)
206: return 0;
207:
208: if (IS_RIPNG_DEBUG_ZEBRA)
209: zlog_debug ("interface up %s index %d flags %llx metric %d mtu %d",
210: ifp->name, ifp->ifindex, (unsigned long long)ifp->flags,
211: ifp->metric, ifp->mtu6);
212:
213: /* Check if this interface is RIPng enabled or not. */
214: ripng_enable_apply (ifp);
215:
216: /* Check for a passive interface. */
217: ripng_passive_interface_apply (ifp);
218:
219: /* Apply distribute list to the all interface. */
220: ripng_distribute_update_interface (ifp);
221:
222: return 0;
223: }
224:
225: /* Inteface link down message processing. */
226: int
227: ripng_interface_down (int command, struct zclient *zclient,
228: zebra_size_t length, vrf_id_t vrf_id)
229: {
230: struct stream *s;
231: struct interface *ifp;
232:
233: /* zebra_interface_state_read() updates interface structure in iflist. */
234: s = zclient->ibuf;
235: ifp = zebra_interface_state_read (s, vrf_id);
236:
237: if (ifp == NULL)
238: return 0;
239:
240: ripng_if_down (ifp);
241:
242: if (IS_RIPNG_DEBUG_ZEBRA)
243: zlog_debug ("interface down %s index %d flags %#llx metric %d mtu %d",
244: ifp->name, ifp->ifindex,
245: (unsigned long long) ifp->flags, ifp->metric, ifp->mtu6);
246:
247: return 0;
248: }
249:
250: /* Inteface addition message from zebra. */
251: int
252: ripng_interface_add (int command, struct zclient *zclient, zebra_size_t length,
253: vrf_id_t vrf_id)
254: {
255: struct interface *ifp;
256:
257: ifp = zebra_interface_add_read (zclient->ibuf, vrf_id);
258:
259: if (IS_RIPNG_DEBUG_ZEBRA)
260: zlog_debug ("RIPng interface add %s index %d flags %#llx metric %d mtu %d",
261: ifp->name, ifp->ifindex, (unsigned long long) ifp->flags,
262: ifp->metric, ifp->mtu6);
263:
264: /* Check is this interface is RIP enabled or not.*/
265: ripng_enable_apply (ifp);
266:
267: /* Apply distribute list to the interface. */
268: ripng_distribute_update_interface (ifp);
269:
270: /* Check interface routemap. */
271: ripng_if_rmap_update_interface (ifp);
272:
273: return 0;
274: }
275:
276: int
277: ripng_interface_delete (int command, struct zclient *zclient,
278: zebra_size_t length, vrf_id_t vrf_id)
279: {
280: struct interface *ifp;
281: struct stream *s;
282:
283: s = zclient->ibuf;
284: /* zebra_interface_state_read() updates interface structure in iflist */
285: ifp = zebra_interface_state_read (s, vrf_id);
286:
287: if (ifp == NULL)
288: return 0;
289:
290: if (if_is_up (ifp)) {
291: ripng_if_down(ifp);
292: }
293:
294: zlog_info("interface delete %s index %d flags %#llx metric %d mtu %d",
295: ifp->name, ifp->ifindex, (unsigned long long) ifp->flags,
296: ifp->metric, ifp->mtu6);
297:
298: /* To support pseudo interface do not free interface structure. */
299: /* if_delete(ifp); */
300: ifp->ifindex = IFINDEX_INTERNAL;
301:
302: return 0;
303: }
304:
305: void
306: ripng_interface_clean (void)
307: {
308: struct listnode *node, *nnode;
309: struct interface *ifp;
310: struct ripng_interface *ri;
311:
312: for (ALL_LIST_ELEMENTS (iflist, node, nnode, ifp))
313: {
314: ri = ifp->info;
315:
316: ri->enable_network = 0;
317: ri->enable_interface = 0;
318: ri->running = 0;
319:
320: if (ri->t_wakeup)
321: {
322: thread_cancel (ri->t_wakeup);
323: ri->t_wakeup = NULL;
324: }
325: }
326: }
327:
328: void
329: ripng_interface_reset (void)
330: {
331: struct listnode *node;
332: struct interface *ifp;
333: struct ripng_interface *ri;
334:
335: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
336: {
337: ri = ifp->info;
338:
339: ri->enable_network = 0;
340: ri->enable_interface = 0;
341: ri->running = 0;
342:
343: ri->split_horizon = RIPNG_NO_SPLIT_HORIZON;
344: ri->split_horizon_default = RIPNG_NO_SPLIT_HORIZON;
345:
346: ri->list[RIPNG_FILTER_IN] = NULL;
347: ri->list[RIPNG_FILTER_OUT] = NULL;
348:
349: ri->prefix[RIPNG_FILTER_IN] = NULL;
350: ri->prefix[RIPNG_FILTER_OUT] = NULL;
351:
352: if (ri->t_wakeup)
353: {
354: thread_cancel (ri->t_wakeup);
355: ri->t_wakeup = NULL;
356: }
357:
358: ri->passive = 0;
359: }
360: }
361:
362: static void
363: ripng_apply_address_add (struct connected *ifc) {
364: struct prefix_ipv6 address;
365: struct prefix *p;
366:
367: if (!ripng)
368: return;
369:
370: if (! if_is_up(ifc->ifp))
371: return;
372:
373: p = ifc->address;
374:
375: memset (&address, 0, sizeof (address));
376: address.family = p->family;
377: address.prefix = p->u.prefix6;
378: address.prefixlen = p->prefixlen;
379: apply_mask_ipv6(&address);
380:
381: /* Check if this interface is RIP enabled or not
382: or Check if this address's prefix is RIP enabled */
383: if ((ripng_enable_if_lookup(ifc->ifp->name) >= 0) ||
384: (ripng_enable_network_lookup2(ifc) >= 0))
385: ripng_redistribute_add(ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
386: &address, ifc->ifp->ifindex, NULL);
387:
388: }
389:
390: int
391: ripng_interface_address_add (int command, struct zclient *zclient,
392: zebra_size_t length, vrf_id_t vrf_id)
393: {
394: struct connected *c;
395: struct prefix *p;
396:
397: c = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_ADD,
398: zclient->ibuf, vrf_id);
399:
400: if (c == NULL)
401: return 0;
402:
403: p = c->address;
404:
405: if (p->family == AF_INET6)
406: {
407: struct ripng_interface *ri = c->ifp->info;
408:
409: if (IS_RIPNG_DEBUG_ZEBRA)
410: zlog_debug ("RIPng connected address %s/%d add",
411: inet6_ntoa(p->u.prefix6),
412: p->prefixlen);
413:
414: /* Check is this prefix needs to be redistributed. */
415: ripng_apply_address_add(c);
416:
417: /* Let's try once again whether the interface could be activated */
418: if (!ri->running) {
419: /* Check if this interface is RIP enabled or not.*/
420: ripng_enable_apply (c->ifp);
421:
422: /* Apply distribute list to the interface. */
423: ripng_distribute_update_interface (c->ifp);
424:
425: /* Check interface routemap. */
426: ripng_if_rmap_update_interface (c->ifp);
427: }
428:
429: }
430:
431: return 0;
432: }
433:
434: static void
435: ripng_apply_address_del (struct connected *ifc) {
436: struct prefix_ipv6 address;
437: struct prefix *p;
438:
439: if (!ripng)
440: return;
441:
442: if (! if_is_up(ifc->ifp))
443: return;
444:
445: p = ifc->address;
446:
447: memset (&address, 0, sizeof (address));
448: address.family = p->family;
449: address.prefix = p->u.prefix6;
450: address.prefixlen = p->prefixlen;
451: apply_mask_ipv6(&address);
452:
453: ripng_redistribute_delete(ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
454: &address, ifc->ifp->ifindex);
455: }
456:
457: int
458: ripng_interface_address_delete (int command, struct zclient *zclient,
459: zebra_size_t length, vrf_id_t vrf_id)
460: {
461: struct connected *ifc;
462: struct prefix *p;
463: char buf[INET6_ADDRSTRLEN];
464:
465: ifc = zebra_interface_address_read (ZEBRA_INTERFACE_ADDRESS_DELETE,
466: zclient->ibuf, vrf_id);
467:
468: if (ifc)
469: {
470: p = ifc->address;
471:
472: if (p->family == AF_INET6)
473: {
474: if (IS_RIPNG_DEBUG_ZEBRA)
475: zlog_debug ("RIPng connected address %s/%d delete",
476: inet_ntop (AF_INET6, &p->u.prefix6, buf,
477: INET6_ADDRSTRLEN),
478: p->prefixlen);
479:
480: /* Check wether this prefix needs to be removed. */
481: ripng_apply_address_del(ifc);
482: }
483: connected_free (ifc);
484: }
485:
486: return 0;
487: }
488:
489: /* RIPng enable interface vector. */
490: vector ripng_enable_if;
491:
492: /* RIPng enable network table. */
493: struct route_table *ripng_enable_network;
494:
495: /* Lookup RIPng enable network. */
496: /* Check wether the interface has at least a connected prefix that
497: * is within the ripng_enable_network table. */
498: static int
499: ripng_enable_network_lookup_if (struct interface *ifp)
500: {
501: struct listnode *node;
502: struct connected *connected;
503: struct prefix_ipv6 address;
504:
505: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, connected))
506: {
507: struct prefix *p;
508: struct route_node *node;
509:
510: p = connected->address;
511:
512: if (p->family == AF_INET6)
513: {
514: address.family = AF_INET6;
515: address.prefix = p->u.prefix6;
516: address.prefixlen = IPV6_MAX_BITLEN;
517:
518: node = route_node_match (ripng_enable_network,
519: (struct prefix *)&address);
520: if (node)
521: {
522: route_unlock_node (node);
523: return 1;
524: }
525: }
526: }
527: return -1;
528: }
529:
530: /* Check wether connected is within the ripng_enable_network table. */
531: static int
532: ripng_enable_network_lookup2 (struct connected *connected)
533: {
534: struct prefix_ipv6 address;
535: struct prefix *p;
536:
537: p = connected->address;
538:
539: if (p->family == AF_INET6) {
540: struct route_node *node;
541:
542: address.family = p->family;
543: address.prefix = p->u.prefix6;
544: address.prefixlen = IPV6_MAX_BITLEN;
545:
546: /* LPM on p->family, p->u.prefix6/IPV6_MAX_BITLEN within ripng_enable_network */
547: node = route_node_match (ripng_enable_network,
548: (struct prefix *)&address);
549:
550: if (node) {
551: route_unlock_node (node);
552: return 1;
553: }
554: }
555:
556: return -1;
557: }
558:
559: /* Add RIPng enable network. */
560: static int
561: ripng_enable_network_add (struct prefix *p)
562: {
563: struct route_node *node;
564:
565: node = route_node_get (ripng_enable_network, p);
566:
567: if (node->info)
568: {
569: route_unlock_node (node);
570: return -1;
571: }
572: else
573: node->info = (char *) "enabled";
574:
575: /* XXX: One should find a better solution than a generic one */
576: ripng_enable_apply_all();
577:
578: return 1;
579: }
580:
581: /* Delete RIPng enable network. */
582: static int
583: ripng_enable_network_delete (struct prefix *p)
584: {
585: struct route_node *node;
586:
587: node = route_node_lookup (ripng_enable_network, p);
588: if (node)
589: {
590: node->info = NULL;
591:
592: /* Unlock info lock. */
593: route_unlock_node (node);
594:
595: /* Unlock lookup lock. */
596: route_unlock_node (node);
597:
598: return 1;
599: }
600: return -1;
601: }
602:
603: /* Lookup function. */
604: static int
605: ripng_enable_if_lookup (const char *ifname)
606: {
607: unsigned int i;
608: char *str;
609:
610: for (i = 0; i < vector_active (ripng_enable_if); i++)
611: if ((str = vector_slot (ripng_enable_if, i)) != NULL)
612: if (strcmp (str, ifname) == 0)
613: return i;
614: return -1;
615: }
616:
617: /* Add interface to ripng_enable_if. */
618: static int
619: ripng_enable_if_add (const char *ifname)
620: {
621: int ret;
622:
623: ret = ripng_enable_if_lookup (ifname);
624: if (ret >= 0)
625: return -1;
626:
627: vector_set (ripng_enable_if, strdup (ifname));
628:
629: ripng_enable_apply_all();
630:
631: return 1;
632: }
633:
634: /* Delete interface from ripng_enable_if. */
635: static int
636: ripng_enable_if_delete (const char *ifname)
637: {
638: int index;
639: char *str;
640:
641: index = ripng_enable_if_lookup (ifname);
642: if (index < 0)
643: return -1;
644:
645: str = vector_slot (ripng_enable_if, index);
646: free (str);
647: vector_unset (ripng_enable_if, index);
648:
649: ripng_enable_apply_all();
650:
651: return 1;
652: }
653:
654: /* Wake up interface. */
655: static int
656: ripng_interface_wakeup (struct thread *t)
657: {
658: struct interface *ifp;
659: struct ripng_interface *ri;
660:
661: /* Get interface. */
662: ifp = THREAD_ARG (t);
663:
664: ri = ifp->info;
665: ri->t_wakeup = NULL;
666:
667: /* Join to multicast group. */
668: if (ripng_multicast_join (ifp) < 0) {
669: zlog_err ("multicast join failed, interface %s not running", ifp->name);
670: return 0;
671: }
672:
673: /* Set running flag. */
674: ri->running = 1;
675:
676: /* Send RIP request to the interface. */
677: ripng_request (ifp);
678:
679: return 0;
680: }
681:
682: static void
683: ripng_connect_set (struct interface *ifp, int set)
684: {
685: struct listnode *node, *nnode;
686: struct connected *connected;
687: struct prefix_ipv6 address;
688:
689: for (ALL_LIST_ELEMENTS (ifp->connected, node, nnode, connected))
690: {
691: struct prefix *p;
692: p = connected->address;
693:
694: if (p->family != AF_INET6)
695: continue;
696:
697: address.family = AF_INET6;
698: address.prefix = p->u.prefix6;
699: address.prefixlen = p->prefixlen;
700: apply_mask_ipv6 (&address);
701:
702: if (set) {
703: /* Check once more wether this prefix is within a "network IF_OR_PREF" one */
704: if ((ripng_enable_if_lookup(connected->ifp->name) >= 0) ||
705: (ripng_enable_network_lookup2(connected) >= 0))
706: ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
707: &address, connected->ifp->ifindex, NULL);
708: } else {
709: ripng_redistribute_delete (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
710: &address, connected->ifp->ifindex);
711: if (ripng_redistribute_check (ZEBRA_ROUTE_CONNECT))
712: ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_REDISTRIBUTE,
713: &address, connected->ifp->ifindex, NULL);
714: }
715: }
716: }
717:
718: /* Check RIPng is enabed on this interface. */
719: void
720: ripng_enable_apply (struct interface *ifp)
721: {
722: int ret;
723: struct ripng_interface *ri = NULL;
724:
725: /* Check interface. */
726: if (! if_is_up (ifp))
727: return;
728:
729: ri = ifp->info;
730:
731: /* Is this interface a candidate for RIPng ? */
732: ret = ripng_enable_network_lookup_if (ifp);
733:
734: /* If the interface is matched. */
735: if (ret > 0)
736: ri->enable_network = 1;
737: else
738: ri->enable_network = 0;
739:
740: /* Check interface name configuration. */
741: ret = ripng_enable_if_lookup (ifp->name);
742: if (ret >= 0)
743: ri->enable_interface = 1;
744: else
745: ri->enable_interface = 0;
746:
747: /* any candidate interface MUST have a link-local IPv6 address */
748: if ((! ripng_if_ipv6_lladdress_check (ifp)) &&
749: (ri->enable_network || ri->enable_interface)) {
750: ri->enable_network = 0;
751: ri->enable_interface = 0;
752: zlog_warn("Interface %s does not have any link-local address",
753: ifp->name);
754: }
755:
756: /* Update running status of the interface. */
757: if (ri->enable_network || ri->enable_interface)
758: {
759: {
760: if (IS_RIPNG_DEBUG_EVENT)
761: zlog_debug ("RIPng turn on %s", ifp->name);
762:
763: /* Add interface wake up thread. */
764: if (! ri->t_wakeup)
765: ri->t_wakeup = thread_add_timer (master, ripng_interface_wakeup,
766: ifp, 1);
767:
768: ripng_connect_set (ifp, 1);
769: }
770: }
771: else
772: {
773: if (ri->running)
774: {
775: /* Might as well clean up the route table as well
776: * ripng_if_down sets to 0 ri->running, and displays "turn off %s"
777: **/
778: ripng_if_down(ifp);
779:
780: ripng_connect_set (ifp, 0);
781: }
782: }
783: }
784:
785: /* Set distribute list to all interfaces. */
786: static void
787: ripng_enable_apply_all (void)
788: {
789: struct interface *ifp;
790: struct listnode *node;
791:
792: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
793: ripng_enable_apply (ifp);
794: }
795:
796: /* Clear all network and neighbor configuration */
797: void
798: ripng_clean_network ()
799: {
800: unsigned int i;
801: char *str;
802: struct route_node *rn;
803:
804: /* ripng_enable_network */
805: for (rn = route_top (ripng_enable_network); rn; rn = route_next (rn))
806: if (rn->info) {
807: rn->info = NULL;
808: route_unlock_node(rn);
809: }
810:
811: /* ripng_enable_if */
812: for (i = 0; i < vector_active (ripng_enable_if); i++)
813: if ((str = vector_slot (ripng_enable_if, i)) != NULL) {
814: free (str);
815: vector_slot (ripng_enable_if, i) = NULL;
816: }
817: }
818:
819: /* Vector to store passive-interface name. */
820: vector Vripng_passive_interface;
821:
822: /* Utility function for looking up passive interface settings. */
823: static int
824: ripng_passive_interface_lookup (const char *ifname)
825: {
826: unsigned int i;
827: char *str;
828:
829: for (i = 0; i < vector_active (Vripng_passive_interface); i++)
830: if ((str = vector_slot (Vripng_passive_interface, i)) != NULL)
831: if (strcmp (str, ifname) == 0)
832: return i;
833: return -1;
834: }
835:
836: void
837: ripng_passive_interface_apply (struct interface *ifp)
838: {
839: int ret;
840: struct ripng_interface *ri;
841:
842: ri = ifp->info;
843:
844: ret = ripng_passive_interface_lookup (ifp->name);
845: if (ret < 0)
846: ri->passive = 0;
847: else
848: ri->passive = 1;
849: }
850:
851: static void
852: ripng_passive_interface_apply_all (void)
853: {
854: struct interface *ifp;
855: struct listnode *node;
856:
857: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
858: ripng_passive_interface_apply (ifp);
859: }
860:
861: /* Passive interface. */
862: static int
863: ripng_passive_interface_set (struct vty *vty, const char *ifname)
864: {
865: if (ripng_passive_interface_lookup (ifname) >= 0)
866: return CMD_WARNING;
867:
868: vector_set (Vripng_passive_interface, strdup (ifname));
869:
870: ripng_passive_interface_apply_all ();
871:
872: return CMD_SUCCESS;
873: }
874:
875: static int
876: ripng_passive_interface_unset (struct vty *vty, const char *ifname)
877: {
878: int i;
879: char *str;
880:
881: i = ripng_passive_interface_lookup (ifname);
882: if (i < 0)
883: return CMD_WARNING;
884:
885: str = vector_slot (Vripng_passive_interface, i);
886: free (str);
887: vector_unset (Vripng_passive_interface, i);
888:
889: ripng_passive_interface_apply_all ();
890:
891: return CMD_SUCCESS;
892: }
893:
894: /* Free all configured RIP passive-interface settings. */
895: void
896: ripng_passive_interface_clean (void)
897: {
898: unsigned int i;
899: char *str;
900:
901: for (i = 0; i < vector_active (Vripng_passive_interface); i++)
902: if ((str = vector_slot (Vripng_passive_interface, i)) != NULL)
903: {
904: free (str);
905: vector_slot (Vripng_passive_interface, i) = NULL;
906: }
907: ripng_passive_interface_apply_all ();
908: }
909:
910: /* Write RIPng enable network and interface to the vty. */
911: int
912: ripng_network_write (struct vty *vty, int config_mode)
913: {
914: unsigned int i;
915: const char *ifname;
916: struct route_node *node;
917: char buf[BUFSIZ];
918:
919: /* Write enable network. */
920: for (node = route_top (ripng_enable_network); node; node = route_next (node))
921: if (node->info)
922: {
923: struct prefix *p = &node->p;
924: vty_out (vty, "%s%s/%d%s",
925: config_mode ? " network " : " ",
926: inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
927: p->prefixlen,
928: VTY_NEWLINE);
929:
930: }
931:
932: /* Write enable interface. */
933: for (i = 0; i < vector_active (ripng_enable_if); i++)
934: if ((ifname = vector_slot (ripng_enable_if, i)) != NULL)
935: vty_out (vty, "%s%s%s",
936: config_mode ? " network " : " ",
937: ifname,
938: VTY_NEWLINE);
939:
940: /* Write passive interface. */
941: if (config_mode)
942: for (i = 0; i < vector_active (Vripng_passive_interface); i++)
943: if ((ifname = vector_slot (Vripng_passive_interface, i)) != NULL)
944: vty_out (vty, " passive-interface %s%s", ifname, VTY_NEWLINE);
945:
946: return 0;
947: }
948:
949: /* RIPng enable on specified interface or matched network. */
950: DEFUN (ripng_network,
951: ripng_network_cmd,
952: "network IF_OR_ADDR",
953: "RIPng enable on specified interface or network.\n"
954: "Interface or address")
955: {
956: int ret;
957: struct prefix p;
958:
959: ret = str2prefix (argv[0], &p);
960:
961: /* Given string is IPv6 network or interface name. */
962: if (ret)
963: ret = ripng_enable_network_add (&p);
964: else
965: ret = ripng_enable_if_add (argv[0]);
966:
967: if (ret < 0)
968: {
969: vty_out (vty, "There is same network configuration %s%s", argv[0],
970: VTY_NEWLINE);
971: return CMD_WARNING;
972: }
973:
974: return CMD_SUCCESS;
975: }
976:
977: /* RIPng enable on specified interface or matched network. */
978: DEFUN (no_ripng_network,
979: no_ripng_network_cmd,
980: "no network IF_OR_ADDR",
981: NO_STR
982: "RIPng enable on specified interface or network.\n"
983: "Interface or address")
984: {
985: int ret;
986: struct prefix p;
987:
988: ret = str2prefix (argv[0], &p);
989:
990: /* Given string is interface name. */
991: if (ret)
992: ret = ripng_enable_network_delete (&p);
993: else
994: ret = ripng_enable_if_delete (argv[0]);
995:
996: if (ret < 0)
997: {
998: vty_out (vty, "can't find network %s%s", argv[0],
999: VTY_NEWLINE);
1000: return CMD_WARNING;
1001: }
1002:
1003: return CMD_SUCCESS;
1004: }
1005:
1006: DEFUN (ipv6_ripng_split_horizon,
1007: ipv6_ripng_split_horizon_cmd,
1008: "ipv6 ripng split-horizon",
1009: IPV6_STR
1010: "Routing Information Protocol\n"
1011: "Perform split horizon\n")
1012: {
1013: struct interface *ifp;
1014: struct ripng_interface *ri;
1015:
1016: ifp = vty->index;
1017: ri = ifp->info;
1018:
1019: ri->split_horizon = RIPNG_SPLIT_HORIZON;
1020: return CMD_SUCCESS;
1021: }
1022:
1023: DEFUN (ipv6_ripng_split_horizon_poisoned_reverse,
1024: ipv6_ripng_split_horizon_poisoned_reverse_cmd,
1025: "ipv6 ripng split-horizon poisoned-reverse",
1026: IPV6_STR
1027: "Routing Information Protocol\n"
1028: "Perform split horizon\n"
1029: "With poisoned-reverse\n")
1030: {
1031: struct interface *ifp;
1032: struct ripng_interface *ri;
1033:
1034: ifp = vty->index;
1035: ri = ifp->info;
1036:
1037: ri->split_horizon = RIPNG_SPLIT_HORIZON_POISONED_REVERSE;
1038: return CMD_SUCCESS;
1039: }
1040:
1041: DEFUN (no_ipv6_ripng_split_horizon,
1042: no_ipv6_ripng_split_horizon_cmd,
1043: "no ipv6 ripng split-horizon",
1044: NO_STR
1045: IPV6_STR
1046: "Routing Information Protocol\n"
1047: "Perform split horizon\n")
1048: {
1049: struct interface *ifp;
1050: struct ripng_interface *ri;
1051:
1052: ifp = vty->index;
1053: ri = ifp->info;
1054:
1055: ri->split_horizon = RIPNG_NO_SPLIT_HORIZON;
1056: return CMD_SUCCESS;
1057: }
1058:
1059: ALIAS (no_ipv6_ripng_split_horizon,
1060: no_ipv6_ripng_split_horizon_poisoned_reverse_cmd,
1061: "no ipv6 ripng split-horizon poisoned-reverse",
1062: NO_STR
1063: IPV6_STR
1064: "Routing Information Protocol\n"
1065: "Perform split horizon\n"
1066: "With poisoned-reverse\n")
1067:
1068: DEFUN (ripng_passive_interface,
1069: ripng_passive_interface_cmd,
1070: "passive-interface IFNAME",
1071: "Suppress routing updates on an interface\n"
1072: "Interface name\n")
1073: {
1074: return ripng_passive_interface_set (vty, argv[0]);
1075: }
1076:
1077: DEFUN (no_ripng_passive_interface,
1078: no_ripng_passive_interface_cmd,
1079: "no passive-interface IFNAME",
1080: NO_STR
1081: "Suppress routing updates on an interface\n"
1082: "Interface name\n")
1083: {
1084: return ripng_passive_interface_unset (vty, argv[0]);
1085: }
1086:
1087: static struct ripng_interface *
1088: ri_new (void)
1089: {
1090: struct ripng_interface *ri;
1091: ri = XCALLOC (MTYPE_IF, sizeof (struct ripng_interface));
1092:
1093: /* Set default split-horizon behavior. If the interface is Frame
1094: Relay or SMDS is enabled, the default value for split-horizon is
1095: off. But currently Zebra does detect Frame Relay or SMDS
1096: interface. So all interface is set to split horizon. */
1097: ri->split_horizon_default = RIPNG_SPLIT_HORIZON;
1098: ri->split_horizon = ri->split_horizon_default;
1099:
1100: return ri;
1101: }
1102:
1103: static int
1104: ripng_if_new_hook (struct interface *ifp)
1105: {
1106: ifp->info = ri_new ();
1107: return 0;
1108: }
1109:
1110: /* Called when interface structure deleted. */
1111: static int
1112: ripng_if_delete_hook (struct interface *ifp)
1113: {
1114: XFREE (MTYPE_IF, ifp->info);
1115: ifp->info = NULL;
1116: return 0;
1117: }
1118:
1119: /* Configuration write function for ripngd. */
1120: static int
1121: interface_config_write (struct vty *vty)
1122: {
1123: struct listnode *node;
1124: struct interface *ifp;
1125: struct ripng_interface *ri;
1126: int write = 0;
1127:
1128: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
1129: {
1130: ri = ifp->info;
1131:
1132: /* Do not display the interface if there is no
1133: * configuration about it.
1134: **/
1135: if ((!ifp->desc) &&
1136: (ri->split_horizon == ri->split_horizon_default))
1137: continue;
1138:
1139: vty_out (vty, "interface %s%s", ifp->name,
1140: VTY_NEWLINE);
1141: if (ifp->desc)
1142: vty_out (vty, " description %s%s", ifp->desc,
1143: VTY_NEWLINE);
1144:
1145: /* Split horizon. */
1146: if (ri->split_horizon != ri->split_horizon_default)
1147: {
1148: switch (ri->split_horizon) {
1149: case RIPNG_SPLIT_HORIZON:
1150: vty_out (vty, " ipv6 ripng split-horizon%s", VTY_NEWLINE);
1151: break;
1152: case RIPNG_SPLIT_HORIZON_POISONED_REVERSE:
1153: vty_out (vty, " ipv6 ripng split-horizon poisoned-reverse%s",
1154: VTY_NEWLINE);
1155: break;
1156: case RIPNG_NO_SPLIT_HORIZON:
1157: default:
1158: vty_out (vty, " no ipv6 ripng split-horizon%s", VTY_NEWLINE);
1159: break;
1160: }
1161: }
1162:
1163: vty_out (vty, "!%s", VTY_NEWLINE);
1164:
1165: write++;
1166: }
1167: return write;
1168: }
1169:
1170: /* ripngd's interface node. */
1171: static struct cmd_node interface_node =
1172: {
1173: INTERFACE_NODE,
1174: "%s(config-if)# ",
1175: 1 /* VTYSH */
1176: };
1177:
1178: /* Initialization of interface. */
1179: void
1180: ripng_if_init ()
1181: {
1182: /* Interface initialize. */
1183: if_add_hook (IF_NEW_HOOK, ripng_if_new_hook);
1184: if_add_hook (IF_DELETE_HOOK, ripng_if_delete_hook);
1185:
1186: /* RIPng enable network init. */
1187: ripng_enable_network = route_table_init ();
1188:
1189: /* RIPng enable interface init. */
1190: ripng_enable_if = vector_init (1);
1191:
1192: /* RIPng passive interface. */
1193: Vripng_passive_interface = vector_init (1);
1194:
1195: /* Install interface node. */
1196: install_node (&interface_node, interface_config_write);
1197:
1198: /* Install commands. */
1199: install_element (CONFIG_NODE, &interface_cmd);
1200: install_element (CONFIG_NODE, &no_interface_cmd);
1201: install_default (INTERFACE_NODE);
1202: install_element (INTERFACE_NODE, &interface_desc_cmd);
1203: install_element (INTERFACE_NODE, &no_interface_desc_cmd);
1204:
1205: install_element (RIPNG_NODE, &ripng_network_cmd);
1206: install_element (RIPNG_NODE, &no_ripng_network_cmd);
1207: install_element (RIPNG_NODE, &ripng_passive_interface_cmd);
1208: install_element (RIPNG_NODE, &no_ripng_passive_interface_cmd);
1209:
1210: install_element (INTERFACE_NODE, &ipv6_ripng_split_horizon_cmd);
1211: install_element (INTERFACE_NODE, &ipv6_ripng_split_horizon_poisoned_reverse_cmd);
1212: install_element (INTERFACE_NODE, &no_ipv6_ripng_split_horizon_cmd);
1213: install_element (INTERFACE_NODE, &no_ipv6_ripng_split_horizon_poisoned_reverse_cmd);
1214: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ripng_interface.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / ripngd