Annotation of embedaddon/quagga/lib/if.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Interface functions.
4: * Copyright (C) 1997, 98 Kunihiro Ishiguro
5: *
6: * This file is part of GNU Zebra.
7: *
8: * GNU Zebra is free software; you can redistribute it and/or modify
9: * it under the terms of the GNU General Public License as published
10: * by the Free Software Foundation; either version 2, or (at your
11: * option) any later version.
12: *
13: * GNU Zebra is distributed in the hope that it will be useful, but
14: * WITHOUT ANY WARRANTY; without even the implied warranty of
15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: * General Public License for more details.
17: *
18: * You should have received a copy of the GNU General Public License
19: * along with GNU Zebra; see the file COPYING. If not, write to the
20: * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21: * Boston, MA 02111-1307, USA.
22: */
23:
24: #include <zebra.h>
25:
26: #include "linklist.h"
27: #include "vector.h"
28: #include "vty.h"
29: #include "command.h"
30: #include "if.h"
31: #include "sockunion.h"
32: #include "prefix.h"
33: #include "memory.h"
34: #include "table.h"
35: #include "buffer.h"
36: #include "str.h"
37: #include "log.h"
38:
39: /* Master list of interfaces. */
40: struct list *iflist;
41:
42: /* One for each program. This structure is needed to store hooks. */
43: struct if_master
44: {
45: int (*if_new_hook) (struct interface *);
46: int (*if_delete_hook) (struct interface *);
47: } if_master;
48:
49: /* Compare interface names, returning an integer greater than, equal to, or
50: * less than 0, (following the strcmp convention), according to the
51: * relationship between ifp1 and ifp2. Interface names consist of an
52: * alphabetic prefix and a numeric suffix. The primary sort key is
53: * lexicographic by name, and then numeric by number. No number sorts
54: * before all numbers. Examples: de0 < de1, de100 < fxp0 < xl0, devpty <
55: * devpty0, de0 < del0
56: */
57: int
58: if_cmp_func (struct interface *ifp1, struct interface *ifp2)
59: {
60: unsigned int l1, l2;
61: long int x1, x2;
62: char *p1, *p2;
63: int res;
64:
65: p1 = ifp1->name;
66: p2 = ifp2->name;
67:
68: while (*p1 && *p2) {
69: /* look up to any number */
70: l1 = strcspn(p1, "0123456789");
71: l2 = strcspn(p2, "0123456789");
72:
73: /* name lengths are different -> compare names */
74: if (l1 != l2)
75: return (strcmp(p1, p2));
76:
77: /* Note that this relies on all numbers being less than all letters, so
78: * that de0 < del0.
79: */
80: res = strncmp(p1, p2, l1);
81:
82: /* names are different -> compare them */
83: if (res)
84: return res;
85:
86: /* with identical name part, go to numeric part */
87: p1 += l1;
88: p2 += l1;
89:
90: if (!*p1)
91: return -1;
92: if (!*p2)
93: return 1;
94:
95: x1 = strtol(p1, &p1, 10);
96: x2 = strtol(p2, &p2, 10);
97:
98: /* let's compare numbers now */
99: if (x1 < x2)
100: return -1;
101: if (x1 > x2)
102: return 1;
103:
104: /* numbers were equal, lets do it again..
105: (it happens with name like "eth123.456:789") */
106: }
107: if (*p1)
108: return 1;
109: if (*p2)
110: return -1;
111: return 0;
112: }
113:
114: /* Create new interface structure. */
115: struct interface *
116: if_create (const char *name, int namelen)
117: {
118: struct interface *ifp;
119:
120: ifp = XCALLOC (MTYPE_IF, sizeof (struct interface));
121: ifp->ifindex = IFINDEX_INTERNAL;
122:
123: assert (name);
124: assert (namelen <= INTERFACE_NAMSIZ); /* Need space for '\0' at end. */
125: strncpy (ifp->name, name, namelen);
126: ifp->name[namelen] = '\0';
127: if (if_lookup_by_name(ifp->name) == NULL)
128: listnode_add_sort (iflist, ifp);
129: else
130: zlog_err("if_create(%s): corruption detected -- interface with this "
131: "name exists already!", ifp->name);
132: ifp->connected = list_new ();
133: ifp->connected->del = (void (*) (void *)) connected_free;
134:
135: if (if_master.if_new_hook)
136: (*if_master.if_new_hook) (ifp);
137:
138: return ifp;
139: }
140:
141: /* Delete interface structure. */
142: void
143: if_delete_retain (struct interface *ifp)
144: {
145: if (if_master.if_delete_hook)
146: (*if_master.if_delete_hook) (ifp);
147:
148: /* Free connected address list */
149: list_delete (ifp->connected);
150: }
151:
152: /* Delete and free interface structure. */
153: void
154: if_delete (struct interface *ifp)
155: {
156: listnode_delete (iflist, ifp);
157:
158: if_delete_retain(ifp);
159:
160: XFREE (MTYPE_IF, ifp);
161: }
162:
163: /* Add hook to interface master. */
164: void
165: if_add_hook (int type, int (*func)(struct interface *ifp))
166: {
167: switch (type) {
168: case IF_NEW_HOOK:
169: if_master.if_new_hook = func;
170: break;
171: case IF_DELETE_HOOK:
172: if_master.if_delete_hook = func;
173: break;
174: default:
175: break;
176: }
177: }
178:
179: /* Interface existance check by index. */
180: struct interface *
181: if_lookup_by_index (unsigned int index)
182: {
183: struct listnode *node;
184: struct interface *ifp;
185:
186: for (ALL_LIST_ELEMENTS_RO(iflist, node, ifp))
187: {
188: if (ifp->ifindex == index)
189: return ifp;
190: }
191: return NULL;
192: }
193:
194: const char *
195: ifindex2ifname (unsigned int index)
196: {
197: struct interface *ifp;
198:
199: return ((ifp = if_lookup_by_index(index)) != NULL) ?
200: ifp->name : "unknown";
201: }
202:
203: unsigned int
204: ifname2ifindex (const char *name)
205: {
206: struct interface *ifp;
207:
208: return ((ifp = if_lookup_by_name(name)) != NULL) ? ifp->ifindex
209: : IFINDEX_INTERNAL;
210: }
211:
212: /* Interface existance check by interface name. */
213: struct interface *
214: if_lookup_by_name (const char *name)
215: {
216: struct listnode *node;
217: struct interface *ifp;
218:
219: if (name)
220: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
221: {
222: if (strcmp(name, ifp->name) == 0)
223: return ifp;
224: }
225: return NULL;
226: }
227:
228: struct interface *
229: if_lookup_by_name_len(const char *name, size_t namelen)
230: {
231: struct listnode *node;
232: struct interface *ifp;
233:
234: if (namelen > INTERFACE_NAMSIZ)
235: return NULL;
236:
237: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
238: {
239: if (!memcmp(name, ifp->name, namelen) && (ifp->name[namelen] == '\0'))
240: return ifp;
241: }
242: return NULL;
243: }
244:
245: /* Lookup interface by IPv4 address. */
246: struct interface *
247: if_lookup_exact_address (struct in_addr src)
248: {
249: struct listnode *node;
250: struct listnode *cnode;
251: struct interface *ifp;
252: struct prefix *p;
253: struct connected *c;
254:
255: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
256: {
257: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
258: {
259: p = c->address;
260:
261: if (p && p->family == AF_INET)
262: {
263: if (IPV4_ADDR_SAME (&p->u.prefix4, &src))
264: return ifp;
265: }
266: }
267: }
268: return NULL;
269: }
270:
271: /* Lookup interface by IPv4 address. */
272: struct interface *
273: if_lookup_address (struct in_addr src)
274: {
275: struct listnode *node;
276: struct prefix addr;
277: int bestlen = 0;
278: struct listnode *cnode;
279: struct interface *ifp;
280: struct connected *c;
281: struct interface *match;
282:
283: addr.family = AF_INET;
284: addr.u.prefix4 = src;
285: addr.prefixlen = IPV4_MAX_BITLEN;
286:
287: match = NULL;
288:
289: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
290: {
291: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
292: {
293: if (c->address && (c->address->family == AF_INET) &&
294: prefix_match(CONNECTED_PREFIX(c), &addr) &&
295: (c->address->prefixlen > bestlen))
296: {
297: bestlen = c->address->prefixlen;
298: match = ifp;
299: }
300: }
301: }
302: return match;
303: }
304:
305: /* Get interface by name if given name interface doesn't exist create
306: one. */
307: struct interface *
308: if_get_by_name (const char *name)
309: {
310: struct interface *ifp;
311:
312: return ((ifp = if_lookup_by_name(name)) != NULL) ? ifp :
313: if_create(name, strlen(name));
314: }
315:
316: struct interface *
317: if_get_by_name_len(const char *name, size_t namelen)
318: {
319: struct interface *ifp;
320:
321: return ((ifp = if_lookup_by_name_len(name, namelen)) != NULL) ? ifp :
322: if_create(name, namelen);
323: }
324:
325: /* Does interface up ? */
326: int
327: if_is_up (struct interface *ifp)
328: {
329: return ifp->flags & IFF_UP;
330: }
331:
332: /* Is interface running? */
333: int
334: if_is_running (struct interface *ifp)
335: {
336: return ifp->flags & IFF_RUNNING;
337: }
338:
339: /* Is the interface operative, eg. either UP & RUNNING
340: or UP & !ZEBRA_INTERFACE_LINK_DETECTION */
341: int
342: if_is_operative (struct interface *ifp)
343: {
344: return ((ifp->flags & IFF_UP) &&
345: (ifp->flags & IFF_RUNNING || !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION)));
346: }
347:
348: /* Is this loopback interface ? */
349: int
350: if_is_loopback (struct interface *ifp)
351: {
352: /* XXX: Do this better, eg what if IFF_WHATEVER means X on platform M
353: * but Y on platform N?
354: */
355: return (ifp->flags & (IFF_LOOPBACK|IFF_NOXMIT|IFF_VIRTUAL));
356: }
357:
358: /* Does this interface support broadcast ? */
359: int
360: if_is_broadcast (struct interface *ifp)
361: {
362: return ifp->flags & IFF_BROADCAST;
363: }
364:
365: /* Does this interface support broadcast ? */
366: int
367: if_is_pointopoint (struct interface *ifp)
368: {
369: return ifp->flags & IFF_POINTOPOINT;
370: }
371:
372: /* Does this interface support multicast ? */
373: int
374: if_is_multicast (struct interface *ifp)
375: {
376: return ifp->flags & IFF_MULTICAST;
377: }
378:
379: /* Printout flag information into log */
380: const char *
381: if_flag_dump (unsigned long flag)
382: {
383: int separator = 0;
384: static char logbuf[BUFSIZ];
385:
386: #define IFF_OUT_LOG(X,STR) \
387: if (flag & (X)) \
388: { \
389: if (separator) \
390: strlcat (logbuf, ",", BUFSIZ); \
391: else \
392: separator = 1; \
393: strlcat (logbuf, STR, BUFSIZ); \
394: }
395:
396: strlcpy (logbuf, "<", BUFSIZ);
397: IFF_OUT_LOG (IFF_UP, "UP");
398: IFF_OUT_LOG (IFF_BROADCAST, "BROADCAST");
399: IFF_OUT_LOG (IFF_DEBUG, "DEBUG");
400: IFF_OUT_LOG (IFF_LOOPBACK, "LOOPBACK");
401: IFF_OUT_LOG (IFF_POINTOPOINT, "POINTOPOINT");
402: IFF_OUT_LOG (IFF_NOTRAILERS, "NOTRAILERS");
403: IFF_OUT_LOG (IFF_RUNNING, "RUNNING");
404: IFF_OUT_LOG (IFF_NOARP, "NOARP");
405: IFF_OUT_LOG (IFF_PROMISC, "PROMISC");
406: IFF_OUT_LOG (IFF_ALLMULTI, "ALLMULTI");
407: IFF_OUT_LOG (IFF_OACTIVE, "OACTIVE");
408: IFF_OUT_LOG (IFF_SIMPLEX, "SIMPLEX");
409: IFF_OUT_LOG (IFF_LINK0, "LINK0");
410: IFF_OUT_LOG (IFF_LINK1, "LINK1");
411: IFF_OUT_LOG (IFF_LINK2, "LINK2");
412: IFF_OUT_LOG (IFF_MULTICAST, "MULTICAST");
413: IFF_OUT_LOG (IFF_NOXMIT, "NOXMIT");
414: IFF_OUT_LOG (IFF_NORTEXCH, "NORTEXCH");
415: IFF_OUT_LOG (IFF_VIRTUAL, "VIRTUAL");
416: IFF_OUT_LOG (IFF_IPV4, "IPv4");
417: IFF_OUT_LOG (IFF_IPV6, "IPv6");
418:
419: strlcat (logbuf, ">", BUFSIZ);
420:
421: return logbuf;
422: #undef IFF_OUT_LOG
423: }
424:
425: /* For debugging */
426: static void
427: if_dump (const struct interface *ifp)
428: {
429: struct listnode *node;
430: struct connected *c;
431:
432: zlog_info ("Interface %s index %d metric %d mtu %d "
433: #ifdef HAVE_IPV6
434: "mtu6 %d "
435: #endif /* HAVE_IPV6 */
436: "%s",
437: ifp->name, ifp->ifindex, ifp->metric, ifp->mtu,
438: #ifdef HAVE_IPV6
439: ifp->mtu6,
440: #endif /* HAVE_IPV6 */
441: if_flag_dump (ifp->flags));
442:
443: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, c))
444: ;
445: }
446:
447: /* Interface printing for all interface. */
448: void
449: if_dump_all (void)
450: {
451: struct listnode *node;
452: void *p;
453:
454: for (ALL_LIST_ELEMENTS_RO (iflist, node, p))
455: if_dump (p);
456: }
457:
458: DEFUN (interface_desc,
459: interface_desc_cmd,
460: "description .LINE",
461: "Interface specific description\n"
462: "Characters describing this interface\n")
463: {
464: struct interface *ifp;
465:
466: if (argc == 0)
467: return CMD_SUCCESS;
468:
469: ifp = vty->index;
470: if (ifp->desc)
471: XFREE (MTYPE_TMP, ifp->desc);
472: ifp->desc = argv_concat(argv, argc, 0);
473:
474: return CMD_SUCCESS;
475: }
476:
477: DEFUN (no_interface_desc,
478: no_interface_desc_cmd,
479: "no description",
480: NO_STR
481: "Interface specific description\n")
482: {
483: struct interface *ifp;
484:
485: ifp = vty->index;
486: if (ifp->desc)
487: XFREE (MTYPE_TMP, ifp->desc);
488: ifp->desc = NULL;
489:
490: return CMD_SUCCESS;
491: }
492:
493: #ifdef SUNOS_5
494: /* Need to handle upgrade from SUNWzebra to Quagga. SUNWzebra created
495: * a seperate struct interface for each logical interface, so config
496: * file may be full of 'interface fooX:Y'. Solaris however does not
497: * expose logical interfaces via PF_ROUTE, so trying to track logical
498: * interfaces can be fruitless, for that reason Quagga only tracks
499: * the primary IP interface.
500: *
501: * We try accomodate SUNWzebra by:
502: * - looking up the interface name, to see whether it exists, if so
503: * its useable
504: * - for protocol daemons, this could only because zebra told us of
505: * the interface
506: * - for zebra, only because it learnt from kernel
507: * - if not:
508: * - search the name to see if it contains a sub-ipif / logical interface
509: * seperator, the ':' char. If it does:
510: * - text up to that char must be the primary name - get that name.
511: * if not:
512: * - no idea, just get the name in its entirety.
513: */
514: static struct interface *
515: if_sunwzebra_get (const char *name, size_t nlen)
516: {
517: struct interface *ifp;
518: size_t seppos = 0;
519:
520: if ( (ifp = if_lookup_by_name_len(name, nlen)) != NULL)
521: return ifp;
522:
523: /* hunt the primary interface name... */
524: while (seppos < nlen && name[seppos] != ':')
525: seppos++;
526:
527: /* Wont catch seperator as last char, e.g. 'foo0:' but thats invalid */
528: if (seppos < nlen)
529: return if_get_by_name_len (name, seppos);
530: else
531: return if_get_by_name_len (name, nlen);
532: }
533: #endif /* SUNOS_5 */
534:
535: DEFUN (interface,
536: interface_cmd,
537: "interface IFNAME",
538: "Select an interface to configure\n"
539: "Interface's name\n")
540: {
541: struct interface *ifp;
542: size_t sl;
543:
544: if ((sl = strlen(argv[0])) > INTERFACE_NAMSIZ)
545: {
546: vty_out (vty, "%% Interface name %s is invalid: length exceeds "
547: "%d characters%s",
548: argv[0], INTERFACE_NAMSIZ, VTY_NEWLINE);
549: return CMD_WARNING;
550: }
551:
552: #ifdef SUNOS_5
553: ifp = if_sunwzebra_get (argv[0], sl);
554: #else
555: ifp = if_get_by_name_len(argv[0], sl);
556: #endif /* SUNOS_5 */
557:
558: vty->index = ifp;
559: vty->node = INTERFACE_NODE;
560:
561: return CMD_SUCCESS;
562: }
563:
564: DEFUN_NOSH (no_interface,
565: no_interface_cmd,
566: "no interface IFNAME",
567: NO_STR
568: "Delete a pseudo interface's configuration\n"
569: "Interface's name\n")
570: {
571: // deleting interface
572: struct interface *ifp;
573:
574: ifp = if_lookup_by_name (argv[0]);
575:
576: if (ifp == NULL)
577: {
578: vty_out (vty, "%% Interface %s does not exist%s", argv[0], VTY_NEWLINE);
579: return CMD_WARNING;
580: }
581:
582: if (CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
583: {
584: vty_out (vty, "%% Only inactive interfaces can be deleted%s",
585: VTY_NEWLINE);
586: return CMD_WARNING;
587: }
588:
589: if_delete(ifp);
590:
591: return CMD_SUCCESS;
592: }
593:
594: /* For debug purpose. */
595: DEFUN (show_address,
596: show_address_cmd,
597: "show address",
598: SHOW_STR
599: "address\n")
600: {
601: struct listnode *node;
602: struct listnode *node2;
603: struct interface *ifp;
604: struct connected *ifc;
605: struct prefix *p;
606:
607: for (ALL_LIST_ELEMENTS_RO (iflist, node, ifp))
608: {
609: for (ALL_LIST_ELEMENTS_RO (ifp->connected, node2, ifc))
610: {
611: p = ifc->address;
612:
613: if (p->family == AF_INET)
614: vty_out (vty, "%s/%d%s", inet_ntoa (p->u.prefix4), p->prefixlen,
615: VTY_NEWLINE);
616: }
617: }
618: return CMD_SUCCESS;
619: }
620:
621: /* Allocate connected structure. */
622: struct connected *
623: connected_new (void)
624: {
625: return XCALLOC (MTYPE_CONNECTED, sizeof (struct connected));
626: }
627:
628: /* Free connected structure. */
629: void
630: connected_free (struct connected *connected)
631: {
632: if (connected->address)
633: prefix_free (connected->address);
634:
635: if (connected->destination)
636: prefix_free (connected->destination);
637:
638: if (connected->label)
639: XFREE (MTYPE_CONNECTED_LABEL, connected->label);
640:
641: XFREE (MTYPE_CONNECTED, connected);
642: }
643:
644: /* Print if_addr structure. */
645: static void __attribute__ ((unused))
646: connected_log (struct connected *connected, char *str)
647: {
648: struct prefix *p;
649: struct interface *ifp;
650: char logbuf[BUFSIZ];
651: char buf[BUFSIZ];
652:
653: ifp = connected->ifp;
654: p = connected->address;
655:
656: snprintf (logbuf, BUFSIZ, "%s interface %s %s %s/%d ",
657: str, ifp->name, prefix_family_str (p),
658: inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
659: p->prefixlen);
660:
661: p = connected->destination;
662: if (p)
663: {
664: strncat (logbuf, inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ),
665: BUFSIZ - strlen(logbuf));
666: }
667: zlog (NULL, LOG_INFO, "%s", logbuf);
668: }
669:
670: /* If two connected address has same prefix return 1. */
671: static int
672: connected_same_prefix (struct prefix *p1, struct prefix *p2)
673: {
674: if (p1->family == p2->family)
675: {
676: if (p1->family == AF_INET &&
677: IPV4_ADDR_SAME (&p1->u.prefix4, &p2->u.prefix4))
678: return 1;
679: #ifdef HAVE_IPV6
680: if (p1->family == AF_INET6 &&
681: IPV6_ADDR_SAME (&p1->u.prefix6, &p2->u.prefix6))
682: return 1;
683: #endif /* HAVE_IPV6 */
684: }
685: return 0;
686: }
687:
688: struct connected *
689: connected_delete_by_prefix (struct interface *ifp, struct prefix *p)
690: {
691: struct listnode *node;
692: struct listnode *next;
693: struct connected *ifc;
694:
695: /* In case of same prefix come, replace it with new one. */
696: for (node = listhead (ifp->connected); node; node = next)
697: {
698: ifc = listgetdata (node);
699: next = node->next;
700:
701: if (connected_same_prefix (ifc->address, p))
702: {
703: listnode_delete (ifp->connected, ifc);
704: return ifc;
705: }
706: }
707: return NULL;
708: }
709:
710: /* Find the IPv4 address on our side that will be used when packets
711: are sent to dst. */
712: struct connected *
713: connected_lookup_address (struct interface *ifp, struct in_addr dst)
714: {
715: struct prefix addr;
716: struct listnode *cnode;
717: struct connected *c;
718: struct connected *match;
719:
720: addr.family = AF_INET;
721: addr.u.prefix4 = dst;
722: addr.prefixlen = IPV4_MAX_BITLEN;
723:
724: match = NULL;
725:
726: for (ALL_LIST_ELEMENTS_RO (ifp->connected, cnode, c))
727: {
728: if (c->address && (c->address->family == AF_INET) &&
729: prefix_match(CONNECTED_PREFIX(c), &addr) &&
730: (!match || (c->address->prefixlen > match->address->prefixlen)))
731: match = c;
732: }
733: return match;
734: }
735:
736: struct connected *
737: connected_add_by_prefix (struct interface *ifp, struct prefix *p,
738: struct prefix *destination)
739: {
740: struct connected *ifc;
741:
742: /* Allocate new connected address. */
743: ifc = connected_new ();
744: ifc->ifp = ifp;
745:
746: /* Fetch interface address */
747: ifc->address = prefix_new();
748: memcpy (ifc->address, p, sizeof(struct prefix));
749:
750: /* Fetch dest address */
751: if (destination)
752: {
753: ifc->destination = prefix_new();
754: memcpy (ifc->destination, destination, sizeof(struct prefix));
755: }
756:
757: /* Add connected address to the interface. */
758: listnode_add (ifp->connected, ifc);
759: return ifc;
760: }
761:
762: #ifndef HAVE_IF_NAMETOINDEX
763: unsigned int
764: if_nametoindex (const char *name)
765: {
766: struct interface *ifp;
767:
768: return ((ifp = if_lookup_by_name_len(name, strnlen(name, IFNAMSIZ))) != NULL)
769: ? ifp->ifindex : 0;
770: }
771: #endif
772:
773: #ifndef HAVE_IF_INDEXTONAME
774: char *
775: if_indextoname (unsigned int ifindex, char *name)
776: {
777: struct interface *ifp;
778:
779: if (!(ifp = if_lookup_by_index(ifindex)))
780: return NULL;
781: strncpy (name, ifp->name, IFNAMSIZ);
782: return ifp->name;
783: }
784: #endif
785:
786: #if 0 /* this route_table of struct connected's is unused
787: * however, it would be good to use a route_table rather than
788: * a list..
789: */
790: /* Interface looking up by interface's address. */
791: /* Interface's IPv4 address reverse lookup table. */
792: struct route_table *ifaddr_ipv4_table;
793: /* struct route_table *ifaddr_ipv6_table; */
794:
795: static void
796: ifaddr_ipv4_add (struct in_addr *ifaddr, struct interface *ifp)
797: {
798: struct route_node *rn;
799: struct prefix_ipv4 p;
800:
801: p.family = AF_INET;
802: p.prefixlen = IPV4_MAX_PREFIXLEN;
803: p.prefix = *ifaddr;
804:
805: rn = route_node_get (ifaddr_ipv4_table, (struct prefix *) &p);
806: if (rn)
807: {
808: route_unlock_node (rn);
809: zlog_info ("ifaddr_ipv4_add(): address %s is already added",
810: inet_ntoa (*ifaddr));
811: return;
812: }
813: rn->info = ifp;
814: }
815:
816: static void
817: ifaddr_ipv4_delete (struct in_addr *ifaddr, struct interface *ifp)
818: {
819: struct route_node *rn;
820: struct prefix_ipv4 p;
821:
822: p.family = AF_INET;
823: p.prefixlen = IPV4_MAX_PREFIXLEN;
824: p.prefix = *ifaddr;
825:
826: rn = route_node_lookup (ifaddr_ipv4_table, (struct prefix *) &p);
827: if (! rn)
828: {
829: zlog_info ("ifaddr_ipv4_delete(): can't find address %s",
830: inet_ntoa (*ifaddr));
831: return;
832: }
833: rn->info = NULL;
834: route_unlock_node (rn);
835: route_unlock_node (rn);
836: }
837:
838: /* Lookup interface by interface's IP address or interface index. */
839: static struct interface *
840: ifaddr_ipv4_lookup (struct in_addr *addr, unsigned int ifindex)
841: {
842: struct prefix_ipv4 p;
843: struct route_node *rn;
844: struct interface *ifp;
845:
846: if (addr)
847: {
848: p.family = AF_INET;
849: p.prefixlen = IPV4_MAX_PREFIXLEN;
850: p.prefix = *addr;
851:
852: rn = route_node_lookup (ifaddr_ipv4_table, (struct prefix *) &p);
853: if (! rn)
854: return NULL;
855:
856: ifp = rn->info;
857: route_unlock_node (rn);
858: return ifp;
859: }
860: else
861: return if_lookup_by_index(ifindex);
862: }
863: #endif /* ifaddr_ipv4_table */
864:
865: /* Initialize interface list. */
866: void
867: if_init (void)
868: {
869: iflist = list_new ();
870: #if 0
871: ifaddr_ipv4_table = route_table_init ();
872: #endif /* ifaddr_ipv4_table */
873:
874: if (iflist) {
875: iflist->cmp = (int (*)(void *, void *))if_cmp_func;
876: return;
877: }
878:
879: memset (&if_master, 0, sizeof if_master);
880: }
881:
882: void
883: if_terminate (void)
884: {
885: for (;;)
886: {
887: struct interface *ifp;
888:
889: ifp = listnode_head (iflist);
890: if (ifp == NULL)
891: break;
892:
893: if_delete (ifp);
894: }
895:
896: list_delete (iflist);
897: iflist = NULL;
898: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to if.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 / lib