1: /*
2: * IS-IS Rout(e)ing protocol - isis_route.c
3: * Copyright (C) 2001,2002 Sampo Saaristo
4: * Tampere University of Technology
5: * Institute of Communications Engineering
6: *
7: * based on ../ospf6d/ospf6_route.[ch]
8: * by Yasuhiro Ohara
9: *
10: * This program is free software; you can redistribute it and/or modify it
11: * under the terms of the GNU General Public Licenseas published by the Free
12: * Software Foundation; either version 2 of the License, or (at your option)
13: * any later version.
14: *
15: * This program is distributed in the hope that it will be useful,but WITHOUT
16: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18: * more details.
19:
20: * You should have received a copy of the GNU General Public License along
21: * with this program; if not, write to the Free Software Foundation, Inc.,
22: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23: */
24:
25: #include <zebra.h>
26:
27: #include "thread.h"
28: #include "linklist.h"
29: #include "vty.h"
30: #include "log.h"
31: #include "memory.h"
32: #include "prefix.h"
33: #include "hash.h"
34: #include "if.h"
35: #include "table.h"
36:
37: #include "isis_constants.h"
38: #include "isis_common.h"
39: #include "dict.h"
40: #include "isisd.h"
41: #include "isis_misc.h"
42: #include "isis_adjacency.h"
43: #include "isis_circuit.h"
44: #include "isis_tlv.h"
45: #include "isis_pdu.h"
46: #include "isis_lsp.h"
47: #include "isis_spf.h"
48: #include "isis_route.h"
49: #include "isis_zebra.h"
50:
51: extern struct isis *isis;
52: extern struct thread_master *master;
53:
54: static struct isis_nexthop *
55: isis_nexthop_create (struct in_addr *ip, unsigned int ifindex)
56: {
57: struct listnode *node;
58: struct isis_nexthop *nexthop;
59:
60: for (ALL_LIST_ELEMENTS_RO (isis->nexthops, node, nexthop))
61: {
62: if (nexthop->ifindex != ifindex)
63: continue;
64: if (ip && memcmp (&nexthop->ip, ip, sizeof (struct in_addr)) != 0)
65: continue;
66:
67: nexthop->lock++;
68: return nexthop;
69: }
70:
71: nexthop = XCALLOC (MTYPE_ISIS_NEXTHOP, sizeof (struct isis_nexthop));
72: if (!nexthop)
73: {
74: zlog_err ("ISIS-Rte: isis_nexthop_create: out of memory!");
75: }
76:
77: nexthop->ifindex = ifindex;
78: memcpy (&nexthop->ip, ip, sizeof (struct in_addr));
79: listnode_add (isis->nexthops, nexthop);
80: nexthop->lock++;
81:
82: return nexthop;
83: }
84:
85: static void
86: isis_nexthop_delete (struct isis_nexthop *nexthop)
87: {
88: nexthop->lock--;
89: if (nexthop->lock == 0)
90: {
91: listnode_delete (isis->nexthops, nexthop);
92: XFREE (MTYPE_ISIS_NEXTHOP, nexthop);
93: }
94:
95: return;
96: }
97:
98: static int
99: nexthoplookup (struct list *nexthops, struct in_addr *ip,
100: unsigned int ifindex)
101: {
102: struct listnode *node;
103: struct isis_nexthop *nh;
104:
105: for (ALL_LIST_ELEMENTS_RO (nexthops, node, nh))
106: {
107: if (!(memcmp (ip, &nh->ip, sizeof (struct in_addr))) &&
108: ifindex == nh->ifindex)
109: return 1;
110: }
111:
112: return 0;
113: }
114:
115: #ifdef EXTREME_DEBUG
116: static void
117: nexthop_print (struct isis_nexthop *nh)
118: {
119: u_char buf[BUFSIZ];
120:
121: inet_ntop (AF_INET, &nh->ip, (char *) buf, BUFSIZ);
122:
123: zlog_debug (" %s %u", buf, nh->ifindex);
124: }
125:
126: static void
127: nexthops_print (struct list *nhs)
128: {
129: struct listnode *node;
130: struct isis_nexthop *nh;
131:
132: for (ALL_LIST_ELEMENTS_RO (nhs, node, nh))
133: nexthop_print (nh);
134: }
135: #endif /* EXTREME_DEBUG */
136:
137: #ifdef HAVE_IPV6
138: static struct isis_nexthop6 *
139: isis_nexthop6_new (struct in6_addr *ip6, unsigned int ifindex)
140: {
141: struct isis_nexthop6 *nexthop6;
142:
143: nexthop6 = XCALLOC (MTYPE_ISIS_NEXTHOP6, sizeof (struct isis_nexthop6));
144: if (!nexthop6)
145: {
146: zlog_err ("ISIS-Rte: isis_nexthop_create6: out of memory!");
147: }
148:
149: nexthop6->ifindex = ifindex;
150: memcpy (&nexthop6->ip6, ip6, sizeof (struct in6_addr));
151: nexthop6->lock++;
152:
153: return nexthop6;
154: }
155:
156: static struct isis_nexthop6 *
157: isis_nexthop6_create (struct in6_addr *ip6, unsigned int ifindex)
158: {
159: struct listnode *node;
160: struct isis_nexthop6 *nexthop6;
161:
162: for (ALL_LIST_ELEMENTS_RO (isis->nexthops6, node, nexthop6))
163: {
164: if (nexthop6->ifindex != ifindex)
165: continue;
166: if (ip6 && memcmp (&nexthop6->ip6, ip6, sizeof (struct in6_addr)) != 0)
167: continue;
168:
169: nexthop6->lock++;
170: return nexthop6;
171: }
172:
173: nexthop6 = isis_nexthop6_new (ip6, ifindex);
174:
175: return nexthop6;
176: }
177:
178: static void
179: isis_nexthop6_delete (struct isis_nexthop6 *nexthop6)
180: {
181:
182: nexthop6->lock--;
183: if (nexthop6->lock == 0)
184: {
185: listnode_delete (isis->nexthops6, nexthop6);
186: XFREE (MTYPE_ISIS_NEXTHOP6, nexthop6);
187: }
188:
189: return;
190: }
191:
192: static int
193: nexthop6lookup (struct list *nexthops6, struct in6_addr *ip6,
194: unsigned int ifindex)
195: {
196: struct listnode *node;
197: struct isis_nexthop6 *nh6;
198:
199: for (ALL_LIST_ELEMENTS_RO (nexthops6, node, nh6))
200: {
201: if (!(memcmp (ip6, &nh6->ip6, sizeof (struct in6_addr))) &&
202: ifindex == nh6->ifindex)
203: return 1;
204: }
205:
206: return 0;
207: }
208:
209: #ifdef EXTREME_DEBUG
210: static void
211: nexthop6_print (struct isis_nexthop6 *nh6)
212: {
213: u_char buf[BUFSIZ];
214:
215: inet_ntop (AF_INET6, &nh6->ip6, (char *) buf, BUFSIZ);
216:
217: zlog_debug (" %s %u", buf, nh6->ifindex);
218: }
219:
220: static void
221: nexthops6_print (struct list *nhs6)
222: {
223: struct listnode *node;
224: struct isis_nexthop6 *nh6;
225:
226: for (ALL_LIST_ELEMENTS_RO (nhs6, node, nh6))
227: nexthop6_print (nh6);
228: }
229: #endif /* EXTREME_DEBUG */
230: #endif /* HAVE_IPV6 */
231:
232: static void
233: adjinfo2nexthop (struct list *nexthops, struct isis_adjacency *adj)
234: {
235: struct isis_nexthop *nh;
236: struct listnode *node;
237: struct in_addr *ipv4_addr;
238:
239: if (adj->ipv4_addrs == NULL)
240: return;
241:
242: for (ALL_LIST_ELEMENTS_RO (adj->ipv4_addrs, node, ipv4_addr))
243: {
244: if (!nexthoplookup (nexthops, ipv4_addr,
245: adj->circuit->interface->ifindex))
246: {
247: nh = isis_nexthop_create (ipv4_addr,
248: adj->circuit->interface->ifindex);
249: listnode_add (nexthops, nh);
250: }
251: }
252: }
253:
254: #ifdef HAVE_IPV6
255: static void
256: adjinfo2nexthop6 (struct list *nexthops6, struct isis_adjacency *adj)
257: {
258: struct listnode *node;
259: struct in6_addr *ipv6_addr;
260: struct isis_nexthop6 *nh6;
261:
262: if (!adj->ipv6_addrs)
263: return;
264:
265: for (ALL_LIST_ELEMENTS_RO (adj->ipv6_addrs, node, ipv6_addr))
266: {
267: if (!nexthop6lookup (nexthops6, ipv6_addr,
268: adj->circuit->interface->ifindex))
269: {
270: nh6 = isis_nexthop6_create (ipv6_addr,
271: adj->circuit->interface->ifindex);
272: listnode_add (nexthops6, nh6);
273: }
274: }
275: }
276: #endif /* HAVE_IPV6 */
277:
278: static struct isis_route_info *
279: isis_route_info_new (uint32_t cost, uint32_t depth, u_char family,
280: struct list *adjacencies)
281: {
282: struct isis_route_info *rinfo;
283: struct isis_adjacency *adj;
284: struct listnode *node;
285:
286: rinfo = XCALLOC (MTYPE_ISIS_ROUTE_INFO, sizeof (struct isis_route_info));
287: if (!rinfo)
288: {
289: zlog_err ("ISIS-Rte: isis_route_info_new: out of memory!");
290: return NULL;
291: }
292:
293: if (family == AF_INET)
294: {
295: rinfo->nexthops = list_new ();
296: for (ALL_LIST_ELEMENTS_RO (adjacencies, node, adj))
297: adjinfo2nexthop (rinfo->nexthops, adj);
298: }
299: #ifdef HAVE_IPV6
300: if (family == AF_INET6)
301: {
302: rinfo->nexthops6 = list_new ();
303: for (ALL_LIST_ELEMENTS_RO (adjacencies, node, adj))
304: adjinfo2nexthop6 (rinfo->nexthops6, adj);
305: }
306:
307: #endif /* HAVE_IPV6 */
308:
309: rinfo->cost = cost;
310: rinfo->depth = depth;
311:
312: return rinfo;
313: }
314:
315: static void
316: isis_route_info_delete (struct isis_route_info *route_info)
317: {
318: if (route_info->nexthops)
319: {
320: route_info->nexthops->del = (void (*)(void *)) isis_nexthop_delete;
321: list_delete (route_info->nexthops);
322: }
323:
324: #ifdef HAVE_IPV6
325: if (route_info->nexthops6)
326: {
327: route_info->nexthops6->del = (void (*)(void *)) isis_nexthop6_delete;
328: list_delete (route_info->nexthops6);
329: }
330: #endif /* HAVE_IPV6 */
331:
332: XFREE (MTYPE_ISIS_ROUTE_INFO, route_info);
333: }
334:
335: static int
336: isis_route_info_same_attrib (struct isis_route_info *new,
337: struct isis_route_info *old)
338: {
339: if (new->cost != old->cost)
340: return 0;
341: if (new->depth != old->depth)
342: return 0;
343:
344: return 1;
345: }
346:
347: static int
348: isis_route_info_same (struct isis_route_info *new,
349: struct isis_route_info *old, u_char family)
350: {
351: struct listnode *node;
352: struct isis_nexthop *nexthop;
353: #ifdef HAVE_IPV6
354: struct isis_nexthop6 *nexthop6;
355: #endif /* HAVE_IPV6 */
356: if (!isis_route_info_same_attrib (new, old))
357: return 0;
358:
359: if (family == AF_INET)
360: {
361: for (ALL_LIST_ELEMENTS_RO (new->nexthops, node, nexthop))
362: if (nexthoplookup (old->nexthops, &nexthop->ip, nexthop->ifindex)
363: == 0)
364: return 0;
365:
366: for (ALL_LIST_ELEMENTS_RO (old->nexthops, node, nexthop))
367: if (nexthoplookup (new->nexthops, &nexthop->ip, nexthop->ifindex)
368: == 0)
369: return 0;
370: }
371: #ifdef HAVE_IPV6
372: else if (family == AF_INET6)
373: {
374: for (ALL_LIST_ELEMENTS_RO (new->nexthops6, node, nexthop6))
375: if (nexthop6lookup (old->nexthops6, &nexthop6->ip6,
376: nexthop6->ifindex) == 0)
377: return 0;
378:
379: for (ALL_LIST_ELEMENTS_RO (old->nexthops6, node, nexthop6))
380: if (nexthop6lookup (new->nexthops6, &nexthop6->ip6,
381: nexthop6->ifindex) == 0)
382: return 0;
383: }
384: #endif /* HAVE_IPV6 */
385:
386: return 1;
387: }
388:
389: static void
390: isis_nexthops_merge (struct list *new, struct list *old)
391: {
392: struct listnode *node;
393: struct isis_nexthop *nexthop;
394:
395: for (ALL_LIST_ELEMENTS_RO (new, node, nexthop))
396: {
397: if (nexthoplookup (old, &nexthop->ip, nexthop->ifindex))
398: continue;
399: listnode_add (old, nexthop);
400: nexthop->lock++;
401: }
402: }
403:
404: #ifdef HAVE_IPV6
405: static void
406: isis_nexthops6_merge (struct list *new, struct list *old)
407: {
408: struct listnode *node;
409: struct isis_nexthop6 *nexthop6;
410:
411: for (ALL_LIST_ELEMENTS_RO (new, node, nexthop6))
412: {
413: if (nexthop6lookup (old, &nexthop6->ip6, nexthop6->ifindex))
414: continue;
415: listnode_add (old, nexthop6);
416: nexthop6->lock++;
417: }
418: }
419: #endif /* HAVE_IPV6 */
420:
421: static void
422: isis_route_info_merge (struct isis_route_info *new,
423: struct isis_route_info *old, u_char family)
424: {
425: if (family == AF_INET)
426: isis_nexthops_merge (new->nexthops, old->nexthops);
427: #ifdef HAVE_IPV6
428: else if (family == AF_INET6)
429: isis_nexthops6_merge (new->nexthops6, old->nexthops6);
430: #endif /* HAVE_IPV6 */
431:
432: return;
433: }
434:
435: static int
436: isis_route_info_prefer_new (struct isis_route_info *new,
437: struct isis_route_info *old)
438: {
439: if (!CHECK_FLAG (old->flag, ISIS_ROUTE_FLAG_ACTIVE))
440: return 1;
441:
442: if (new->cost < old->cost)
443: return 1;
444:
445: return 0;
446: }
447:
448: struct isis_route_info *
449: isis_route_create (struct prefix *prefix, u_int32_t cost, u_int32_t depth,
450: struct list *adjacencies, struct isis_area *area,
451: int level)
452: {
453: struct route_node *route_node;
454: struct isis_route_info *rinfo_new, *rinfo_old, *route_info = NULL;
455: u_char buff[BUFSIZ];
456: u_char family;
457:
458: family = prefix->family;
459: /* for debugs */
460: prefix2str (prefix, (char *) buff, BUFSIZ);
461:
462: rinfo_new = isis_route_info_new (cost, depth, family, adjacencies);
463: if (!rinfo_new)
464: {
465: zlog_err ("ISIS-Rte (%s): isis_route_create: out of memory!",
466: area->area_tag);
467: return NULL;
468: }
469:
470: if (family == AF_INET)
471: route_node = route_node_get (area->route_table[level - 1], prefix);
472: #ifdef HAVE_IPV6
473: else if (family == AF_INET6)
474: route_node = route_node_get (area->route_table6[level - 1], prefix);
475: #endif /* HAVE_IPV6 */
476: else
477: return NULL;
478: rinfo_old = route_node->info;
479: if (!rinfo_old)
480: {
481: if (isis->debugs & DEBUG_RTE_EVENTS)
482: zlog_debug ("ISIS-Rte (%s) route created: %s", area->area_tag, buff);
483: SET_FLAG (rinfo_new->flag, ISIS_ROUTE_FLAG_ACTIVE);
484: route_node->info = rinfo_new;
485: return rinfo_new;
486: }
487:
488: if (isis->debugs & DEBUG_RTE_EVENTS)
489: zlog_debug ("ISIS-Rte (%s) route already exists: %s", area->area_tag,
490: buff);
491:
492: if (isis_route_info_same (rinfo_new, rinfo_old, family))
493: {
494: if (isis->debugs & DEBUG_RTE_EVENTS)
495: zlog_debug ("ISIS-Rte (%s) route unchanged: %s", area->area_tag, buff);
496: isis_route_info_delete (rinfo_new);
497: route_info = rinfo_old;
498: }
499: else if (isis_route_info_same_attrib (rinfo_new, rinfo_old))
500: {
501: /* merge the nexthop lists */
502: if (isis->debugs & DEBUG_RTE_EVENTS)
503: zlog_debug ("ISIS-Rte (%s) route changed (same attribs): %s",
504: area->area_tag, buff);
505: #ifdef EXTREME_DEBUG
506: if (family == AF_INET)
507: {
508: zlog_debug ("Old nexthops");
509: nexthops_print (rinfo_old->nexthops);
510: zlog_debug ("New nexthops");
511: nexthops_print (rinfo_new->nexthops);
512: }
513: else if (family == AF_INET6)
514: {
515: zlog_debug ("Old nexthops");
516: nexthops6_print (rinfo_old->nexthops6);
517: zlog_debug ("New nexthops");
518: nexthops6_print (rinfo_new->nexthops6);
519: }
520: #endif /* EXTREME_DEBUG */
521: isis_route_info_merge (rinfo_new, rinfo_old, family);
522: isis_route_info_delete (rinfo_new);
523: route_info = rinfo_old;
524: UNSET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC);
525: }
526: else
527: {
528: if (isis_route_info_prefer_new (rinfo_new, rinfo_old))
529: {
530: if (isis->debugs & DEBUG_RTE_EVENTS)
531: zlog_debug ("ISIS-Rte (%s) route changed: %s", area->area_tag,
532: buff);
533: isis_route_info_delete (rinfo_old);
534: route_info = rinfo_new;
535: }
536: else
537: {
538: if (isis->debugs & DEBUG_RTE_EVENTS)
539: zlog_debug ("ISIS-Rte (%s) route rejected: %s", area->area_tag,
540: buff);
541: isis_route_info_delete (rinfo_new);
542: route_info = rinfo_old;
543: }
544: }
545:
546: SET_FLAG (route_info->flag, ISIS_ROUTE_FLAG_ACTIVE);
547: route_node->info = route_info;
548:
549: return route_info;
550: }
551:
552: static void
553: isis_route_delete (struct prefix *prefix, struct route_table *table)
554: {
555: struct route_node *rode;
556: struct isis_route_info *rinfo;
557: char buff[BUFSIZ];
558:
559: /* for log */
560: prefix2str (prefix, buff, BUFSIZ);
561:
562:
563: rode = route_node_get (table, prefix);
564: rinfo = rode->info;
565:
566: if (rinfo == NULL)
567: {
568: if (isis->debugs & DEBUG_RTE_EVENTS)
569: zlog_debug ("ISIS-Rte: tried to delete non-existant route %s", buff);
570: return;
571: }
572:
573: if (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC))
574: {
575: UNSET_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE);
576: if (isis->debugs & DEBUG_RTE_EVENTS)
577: zlog_debug ("ISIS-Rte: route delete %s", buff);
578: isis_zebra_route_update (prefix, rinfo);
579: }
580: isis_route_info_delete (rinfo);
581: rode->info = NULL;
582:
583: return;
584: }
585:
586: /* Validating routes in particular table. */
587: static void
588: isis_route_validate_table (struct isis_area *area, struct route_table *table)
589: {
590: struct route_node *rnode, *drnode;
591: struct isis_route_info *rinfo;
592: u_char buff[BUFSIZ];
593:
594: for (rnode = route_top (table); rnode; rnode = route_next (rnode))
595: {
596: if (rnode->info == NULL)
597: continue;
598: rinfo = rnode->info;
599:
600: if (isis->debugs & DEBUG_RTE_EVENTS)
601: {
602: prefix2str (&rnode->p, (char *) buff, BUFSIZ);
603: zlog_debug ("ISIS-Rte (%s): route validate: %s %s %s",
604: area->area_tag,
605: (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ZEBRA_SYNC) ?
606: "sync'ed" : "nosync"),
607: (CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE) ?
608: "active" : "inactive"), buff);
609: }
610:
611: isis_zebra_route_update (&rnode->p, rinfo);
612: if (!CHECK_FLAG (rinfo->flag, ISIS_ROUTE_FLAG_ACTIVE))
613: {
614: /* Area is either L1 or L2 => we use level route tables directly for
615: * validating => no problems with deleting routes. */
616: if (area->is_type != IS_LEVEL_1_AND_2)
617: {
618: isis_route_delete (&rnode->p, table);
619: continue;
620: }
621: /* If area is L1L2, we work with merge table and therefore must
622: * delete node from level tables as well before deleting route info.
623: * FIXME: Is it performance problem? There has to be the better way.
624: * Like not to deal with it here at all (see the next comment)? */
625: if (rnode->p.family == AF_INET)
626: {
627: drnode = route_node_get (area->route_table[0], &rnode->p);
628: if (drnode->info == rnode->info)
629: drnode->info = NULL;
630: drnode = route_node_get (area->route_table[1], &rnode->p);
631: if (drnode->info == rnode->info)
632: drnode->info = NULL;
633: }
634:
635: #ifdef HAVE_IPV6
636: if (rnode->p.family == AF_INET6)
637: {
638: drnode = route_node_get (area->route_table6[0], &rnode->p);
639: if (drnode->info == rnode->info)
640: drnode->info = NULL;
641: drnode = route_node_get (area->route_table6[1], &rnode->p);
642: if (drnode->info == rnode->info)
643: drnode->info = NULL;
644: }
645: #endif
646:
647: isis_route_delete (&rnode->p, table);
648: }
649: }
650: }
651:
652: /* Function to validate route tables for L1L2 areas. In this case we can't use
653: * level route tables directly, we have to merge them at first. L1 routes are
654: * preferred over the L2 ones.
655: *
656: * Merge algorithm is trivial (at least for now). All L1 paths are copied into
657: * merge table at first, then L2 paths are added if L1 path for same prefix
658: * doesn't already exists there.
659: *
660: * FIXME: Is it right place to do it at all? Maybe we should push both levels
661: * to the RIB with different zebra route types and let RIB handle this? */
662: static void
663: isis_route_validate_merge (struct isis_area *area, int family)
664: {
665: struct route_table *table = NULL;
666: struct route_table *merge;
667: struct route_node *rnode, *mrnode;
668:
669: merge = route_table_init ();
670:
671: if (family == AF_INET)
672: table = area->route_table[0];
673: #ifdef HAVE_IPV6
674: else if (family == AF_INET6)
675: table = area->route_table6[0];
676: #endif
677:
678: for (rnode = route_top (table); rnode; rnode = route_next (rnode))
679: {
680: if (rnode->info == NULL)
681: continue;
682: mrnode = route_node_get (merge, &rnode->p);
683: mrnode->info = rnode->info;
684: }
685:
686: if (family == AF_INET)
687: table = area->route_table[1];
688: #ifdef HAVE_IPV6
689: else if (family == AF_INET6)
690: table = area->route_table6[1];
691: #endif
692:
693: for (rnode = route_top (table); rnode; rnode = route_next (rnode))
694: {
695: if (rnode->info == NULL)
696: continue;
697: mrnode = route_node_get (merge, &rnode->p);
698: if (mrnode->info != NULL)
699: continue;
700: mrnode->info = rnode->info;
701: }
702:
703: isis_route_validate_table (area, merge);
704: route_table_finish (merge);
705: }
706:
707: /* Walk through route tables and propagate necessary changes into RIB. In case
708: * of L1L2 area, level tables have to be merged at first. */
709: int
710: isis_route_validate (struct thread *thread)
711: {
712: struct isis_area *area;
713:
714: area = THREAD_ARG (thread);
715:
716: if (area->is_type == IS_LEVEL_1)
717: {
718: isis_route_validate_table (area, area->route_table[0]);
719: goto validate_ipv6;
720: }
721: if (area->is_type == IS_LEVEL_2)
722: {
723: isis_route_validate_table (area, area->route_table[1]);
724: goto validate_ipv6;
725: }
726:
727: isis_route_validate_merge (area, AF_INET);
728:
729: validate_ipv6:
730: #ifdef HAVE_IPV6
731: if (area->is_type == IS_LEVEL_1)
732: {
733: isis_route_validate_table (area, area->route_table6[0]);
734: return ISIS_OK;
735: }
736: if (area->is_type == IS_LEVEL_2)
737: {
738: isis_route_validate_table (area, area->route_table6[1]);
739: return ISIS_OK;
740: }
741:
742: isis_route_validate_merge (area, AF_INET6);
743: #endif
744:
745: return ISIS_OK;
746: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_route.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 / isisd