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