Annotation of embedaddon/quagga/isisd/isis_redist.c, revision 1.1.1.1
1.1 misho 1: /*
2: * IS-IS Rout(e)ing protocol - isis_redist.c
3: *
4: * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the Free
8: * Software Foundation; either version 2 of the License, or (at your option)
9: * any later version.
10: *
11: * This program is distributed in the hope that it will be useful,but WITHOUT
12: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14: * more details.
15:
16: * You should have received a copy of the GNU General Public License along
17: * with this program; if not, write to the Free Software Foundation, Inc.,
18: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19: */
20:
21: #include <zebra.h>
22:
23: #include "command.h"
24: #include "if.h"
25: #include "linklist.h"
26: #include "memory.h"
27: #include "memtypes.h"
28: #include "prefix.h"
29: #include "routemap.h"
30: #include "stream.h"
31: #include "table.h"
32: #include "vty.h"
33:
34: #include "isisd/dict.h"
35: #include "isisd/isis_constants.h"
36: #include "isisd/isis_common.h"
37: #include "isisd/isis_flags.h"
38: #include "isisd/isis_misc.h"
39: #include "isisd/isis_circuit.h"
40: #include "isisd/isis_tlv.h"
41: #include "isisd/isisd.h"
42: #include "isisd/isis_lsp.h"
43: #include "isisd/isis_route.h"
44: #include "isisd/isis_zebra.h"
45:
46: static int
47: redist_protocol(int family)
48: {
49: if (family == AF_INET)
50: return 0;
51: if (family == AF_INET6)
52: return 1;
53:
54: assert(!"Unsupported address family!");
55: }
56:
57: static int
58: is_default(struct prefix *p)
59: {
60: if (p->family == AF_INET)
61: if (p->u.prefix4.s_addr == 0 && p->prefixlen == 0)
62: return 1;
63: if (p->family == AF_INET6)
64: if (IN6_IS_ADDR_UNSPECIFIED(&p->u.prefix6) && p->prefixlen == 0)
65: return 1;
66: return 0;
67: }
68:
69: static struct route_table*
70: get_ext_info(struct isis *i, int family)
71: {
72: int protocol = redist_protocol(family);
73:
74: return i->ext_info[protocol];
75: }
76:
77: static struct isis_redist*
78: get_redist_settings(struct isis_area *area, int family, int type, int level)
79: {
80: int protocol = redist_protocol(family);
81:
82: return &area->redist_settings[protocol][type][level-1];
83: }
84:
85: struct route_table*
86: get_ext_reach(struct isis_area *area, int family, int level)
87: {
88: int protocol = redist_protocol(family);
89:
90: return area->ext_reach[protocol][level-1];
91: }
92:
93: static struct route_node *
94: isis_redist_route_node_create(route_table_delegate_t *delegate,
95: struct route_table *table)
96: {
97: struct route_node *node;
98: node = XCALLOC(MTYPE_ROUTE_NODE, sizeof(*node));
99: return node;
100: }
101:
102: static void
103: isis_redist_route_node_destroy(route_table_delegate_t *delegate,
104: struct route_table *table,
105: struct route_node *node)
106: {
107: if (node->info)
108: XFREE(MTYPE_ISIS, node->info);
109: XFREE (MTYPE_ROUTE_NODE, node);
110: }
111:
112: static route_table_delegate_t isis_redist_rt_delegate = {
113: .create_node = isis_redist_route_node_create,
114: .destroy_node = isis_redist_route_node_destroy
115: };
116:
117: /* Install external reachability information into a
118: * specific area for a specific level.
119: * Schedule an lsp regenerate if necessary */
120: static void
121: isis_redist_install(struct isis_area *area, int level,
122: struct prefix *p, struct isis_ext_info *info)
123: {
124: int family = p->family;
125: struct route_table *er_table = get_ext_reach(area, family, level);
126: struct route_node *er_node;
127:
128: if (!er_table)
129: {
130: zlog_warn("%s: External reachability table of area %s"
131: " is not initialized.", __func__, area->area_tag);
132: return;
133: }
134:
135: er_node = route_node_get(er_table, p);
136: if (er_node->info)
137: {
138: route_unlock_node(er_node);
139:
140: /* Don't update/reschedule lsp generation if nothing changed. */
141: if (!memcmp(er_node->info, info, sizeof(*info)))
142: return;
143: }
144: else
145: {
146: er_node->info = XMALLOC(MTYPE_ISIS, sizeof(*info));
147: }
148:
149: memcpy(er_node->info, info, sizeof(*info));
150: lsp_regenerate_schedule(area, level, 0);
151: }
152:
153: /* Remove external reachability information from a
154: * specific area for a specific level.
155: * Schedule an lsp regenerate if necessary. */
156: static void
157: isis_redist_uninstall(struct isis_area *area, int level, struct prefix *p)
158: {
159: int family = p->family;
160: struct route_table *er_table = get_ext_reach(area, family, level);
161: struct route_node *er_node;
162:
163: if (!er_table)
164: {
165: zlog_warn("%s: External reachability table of area %s"
166: " is not initialized.", __func__, area->area_tag);
167: return;
168: }
169:
170: er_node = route_node_lookup(er_table, p);
171: if (!er_node)
172: return;
173: else
174: route_unlock_node(er_node);
175:
176: if (!er_node->info)
177: return;
178:
179: route_unlock_node(er_node);
180: lsp_regenerate_schedule(area, level, 0);
181: }
182:
183: /* Update external reachability info of area for a given level
184: * and prefix, using the given redistribution settings. */
185: static void
186: isis_redist_update_ext_reach(struct isis_area *area, int level,
187: struct isis_redist *redist, struct prefix *p,
188: struct isis_ext_info *info)
189: {
190: struct isis_ext_info area_info;
191: route_map_result_t map_ret;
192:
193: memcpy(&area_info, info, sizeof(area_info));
194: if (redist->metric != 0xffffffff)
195: area_info.metric = redist->metric;
196:
197: if (redist->map_name)
198: {
199: map_ret = route_map_apply(redist->map, p, RMAP_ISIS, &area_info);
200: if (map_ret == RMAP_DENYMATCH)
201: area_info.distance = 255;
202: }
203:
204: /* Allow synthesized default routes only on always orignate */
205: if (area_info.origin == DEFAULT_ROUTE
206: && redist->redist != DEFAULT_ORIGINATE_ALWAYS)
207: area_info.distance = 255;
208:
209: if (area_info.distance < 255)
210: isis_redist_install(area, level, p, &area_info);
211: else
212: isis_redist_uninstall(area, level, p);
213: }
214:
215: static void
216: isis_redist_ensure_default(struct isis *isis, int family)
217: {
218: struct prefix p;
219: struct route_table *ei_table = get_ext_info(isis, family);
220: struct route_node *ei_node;
221: struct isis_ext_info *info;
222:
223: if (family == AF_INET)
224: {
225: p.family = AF_INET;
226: p.prefixlen = 0;
227: memset(&p.u.prefix4, 0, sizeof(p.u.prefix4));
228: }
229: else if (family == AF_INET6)
230: {
231: p.family = AF_INET6;
232: p.prefixlen = 0;
233: memset(&p.u.prefix6, 0, sizeof(p.u.prefix6));
234: }
235: else
236: assert(!"Unknown family!");
237:
238: ei_node = route_node_get(ei_table, &p);
239: if (ei_node->info)
240: {
241: route_unlock_node(ei_node);
242: return;
243: }
244:
245: ei_node->info = XCALLOC(MTYPE_ISIS, sizeof(struct isis_ext_info));
246:
247: info = ei_node->info;
248: info->origin = DEFAULT_ROUTE;
249: info->distance = 254;
250: info->metric = MAX_WIDE_PATH_METRIC;
251: }
252:
253: /* Handle notification about route being added */
254: void
255: isis_redist_add(int type, struct prefix *p, u_char distance, uint32_t metric)
256: {
257: int family = p->family;
258: struct route_table *ei_table = get_ext_info(isis, family);
259: struct route_node *ei_node;
260: struct isis_ext_info *info;
261: struct listnode *node;
262: struct isis_area *area;
263: int level;
264: struct isis_redist *redist;
265:
266: char debug_buf[BUFSIZ];
267: prefix2str(p, debug_buf, sizeof(debug_buf));
268:
269: zlog_debug("%s: New route %s from %s.", __func__, debug_buf,
270: zebra_route_string(type));
271:
272: if (!ei_table)
273: {
274: zlog_warn("%s: External information table not initialized.",
275: __func__);
276: return;
277: }
278:
279: ei_node = route_node_get(ei_table, p);
280: if (ei_node->info)
281: route_unlock_node(ei_node);
282: else
283: ei_node->info = XCALLOC(MTYPE_ISIS, sizeof(struct isis_ext_info));
284:
285: info = ei_node->info;
286: info->origin = type;
287: info->distance = distance;
288: info->metric = metric;
289:
290: if (is_default(p))
291: type = DEFAULT_ROUTE;
292:
293: for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
294: for (level = 1; level <= ISIS_LEVELS; level++)
295: {
296: redist = get_redist_settings(area, family, type, level);
297: if (!redist->redist)
298: continue;
299:
300: isis_redist_update_ext_reach(area, level, redist, p, info);
301: }
302: }
303:
304: void
305: isis_redist_delete(int type, struct prefix *p)
306: {
307: int family = p->family;
308: struct route_table *ei_table = get_ext_info(isis, family);
309: struct route_node *ei_node;
310: struct listnode *node;
311: struct isis_area *area;
312: int level;
313: struct isis_redist *redist;
314:
315: char debug_buf[BUFSIZ];
316: prefix2str(p, debug_buf, sizeof(debug_buf));
317:
318: zlog_debug("%s: Removing route %s from %s.", __func__, debug_buf,
319: zebra_route_string(type));
320:
321: if (is_default(p))
322: {
323: /* Don't remove default route but add synthetic route for use
324: * by "default-information originate always". Areas without the
325: * "always" setting will ignore routes with origin DEFAULT_ROUTE. */
326: isis_redist_add(DEFAULT_ROUTE, p, 254, MAX_WIDE_PATH_METRIC);
327: return;
328: }
329:
330: if (!ei_table)
331: {
332: zlog_warn("%s: External information table not initialized.",
333: __func__);
334: return;
335: }
336:
337: ei_node = route_node_lookup(ei_table, p);
338: if (!ei_node || !ei_node->info)
339: {
340: char buf[BUFSIZ];
341: prefix2str(p, buf, sizeof(buf));
342: zlog_warn("%s: Got a delete for %s route %s, but that route"
343: " was never added.", __func__, zebra_route_string(type),
344: buf);
345: if (ei_node)
346: route_unlock_node(ei_node);
347: return;
348: }
349: route_unlock_node(ei_node);
350:
351: for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
352: for (level = 1; level < ISIS_LEVELS; level++)
353: {
354: redist = get_redist_settings(area, family, type, level);
355: if (!redist->redist)
356: continue;
357:
358: isis_redist_uninstall(area, level, p);
359: }
360:
361: route_unlock_node(ei_node);
362: }
363:
364: static void
365: isis_redist_routemap_set(struct isis_redist *redist, const char *routemap)
366: {
367: if (redist->map_name) {
368: XFREE(MTYPE_ISIS, redist->map_name);
369: redist->map = NULL;
370: }
371:
372: if (routemap && strlen(routemap)) {
373: redist->map_name = XSTRDUP(MTYPE_ISIS, routemap);
374: redist->map = route_map_lookup_by_name(routemap);
375: }
376: }
377:
378: static void
379: isis_redist_update_zebra_subscriptions(struct isis *isis)
380: {
381: struct listnode *node;
382: struct isis_area *area;
383: int type;
384: int level;
385: int protocol;
386:
387: char do_subscribe[ZEBRA_ROUTE_MAX + 1];
388:
389: memset(do_subscribe, 0, sizeof(do_subscribe));
390:
391: for (ALL_LIST_ELEMENTS_RO(isis->area_list, node, area))
392: for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
393: for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++)
394: for (level = 0; level < ISIS_LEVELS; level++)
395: if (area->redist_settings[protocol][type][level].redist)
396: do_subscribe[type] = 1;
397:
398: for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++)
399: {
400: /* This field is actually controlling transmission of the IS-IS
401: * routes to Zebra and has nothing to do with redistribution,
402: * so skip it. */
403: if (type == ZEBRA_ROUTE_ISIS)
404: continue;
405:
406: if (do_subscribe[type])
407: isis_zebra_redistribute_set(type);
408: else
409: isis_zebra_redistribute_unset(type);
410: }
411: }
412:
413: static void
414: isis_redist_set(struct isis_area *area, int level,
415: int family, int type, uint32_t metric,
416: const char *routemap, int originate_type)
417: {
418: int protocol = redist_protocol(family);
419: struct isis_redist *redist = get_redist_settings(area, family, type, level);
420: int i;
421: struct route_table *ei_table;
422: struct route_node *rn;
423: struct isis_ext_info *info;
424:
425: redist->redist = (type == DEFAULT_ROUTE) ? originate_type : 1;
426: redist->metric = metric;
427: isis_redist_routemap_set(redist, routemap);
428:
429: if (!area->ext_reach[protocol][level-1])
430: {
431: area->ext_reach[protocol][level-1] =
432: route_table_init_with_delegate(&isis_redist_rt_delegate);
433: }
434:
435: for (i = 0; i < REDIST_PROTOCOL_COUNT; i++)
436: if (!area->isis->ext_info[i])
437: {
438: area->isis->ext_info[i] =
439: route_table_init_with_delegate(&isis_redist_rt_delegate);
440: }
441:
442: isis_redist_update_zebra_subscriptions(area->isis);
443:
444: if (type == DEFAULT_ROUTE && originate_type == DEFAULT_ORIGINATE_ALWAYS)
445: isis_redist_ensure_default(area->isis, family);
446:
447: ei_table = get_ext_info(area->isis, family);
448: for (rn = route_top(ei_table); rn; rn = route_next(rn))
449: {
450: if (!rn->info)
451: continue;
452: info = rn->info;
453:
454: if (type == DEFAULT_ROUTE)
455: {
456: if (!is_default(&rn->p))
457: continue;
458: }
459: else
460: {
461: if (info->origin != type)
462: continue;
463: }
464:
465: isis_redist_update_ext_reach(area, level, redist, &rn->p, info);
466: }
467: }
468:
469: static void
470: isis_redist_unset(struct isis_area *area, int level,
471: int family, int type)
472: {
473: struct isis_redist *redist = get_redist_settings(area, family, type, level);
474: struct route_table *er_table = get_ext_reach(area, family, level);
475: struct route_node *rn;
476: struct isis_ext_info *info;
477:
478: if (!redist->redist)
479: return;
480:
481: redist->redist = 0;
482: if (!er_table)
483: {
484: zlog_warn("%s: External reachability table uninitialized.", __func__);
485: return;
486: }
487:
488: for (rn = route_top(er_table); rn; rn = route_next(rn))
489: {
490: if (!rn->info)
491: continue;
492: info = rn->info;
493:
494: if (type == DEFAULT_ROUTE)
495: {
496: if (!is_default(&rn->p))
497: continue;
498: }
499: else
500: {
501: if (info->origin != type)
502: continue;
503: }
504:
505: route_unlock_node(rn);
506: }
507:
508: lsp_regenerate_schedule(area, level, 0);
509: isis_redist_update_zebra_subscriptions(area->isis);
510: }
511:
512: void
513: isis_redist_area_finish(struct isis_area *area)
514: {
515: int protocol;
516: int level;
517: int type;
518:
519: for (protocol = 0; protocol < REDIST_PROTOCOL_COUNT; protocol++)
520: for (level = 0; level < ISIS_LEVELS; level++)
521: {
522: for (type = 0; type < ZEBRA_ROUTE_MAX + 1; type++)
523: {
524: struct isis_redist *redist;
525:
526: redist = &area->redist_settings[protocol][type][level];
527: redist->redist = 0;
528: if (redist->map_name)
529: XFREE(MTYPE_ISIS, redist->map_name);
530: }
531: route_table_finish(area->ext_reach[protocol][level]);
532: }
533:
534: isis_redist_update_zebra_subscriptions(area->isis);
535: }
536:
537: DEFUN(isis_redistribute,
538: isis_redistribute_cmd,
539: "redistribute (ipv4|ipv6) " QUAGGA_REDIST_STR_ISISD
540: " (level-1|level-2) {metric <0-16777215>|route-map WORD}",
541: REDIST_STR
542: "Redistribute IPv4 routes\n"
543: "Redistribute IPv6 routes\n"
544: QUAGGA_REDIST_HELP_STR_ISISD
545: "Redistribute into level-1\n"
546: "Redistribute into level-2\n"
547: "Metric for redistributed routes\n"
548: "ISIS default metric\n"
549: "Route map reference\n"
550: "Pointer to route-map entries\n")
551: {
552: struct isis_area *area = vty->index;
553: int family;
554: int afi;
555: int type;
556: int level;
557: unsigned long metric;
558: const char *routemap;
559:
560: if (argc < 5)
561: return CMD_WARNING;
562:
563: family = str2family(argv[0]);
564: if (family < 0)
565: return CMD_WARNING;
566:
567: afi = family2afi(family);
568: if (!afi)
569: return CMD_WARNING;
570:
571: type = proto_redistnum(afi, argv[1]);
572: if (type < 0 || type == ZEBRA_ROUTE_ISIS)
573: return CMD_WARNING;
574:
575: if (!strcmp("level-1", argv[2]))
576: level = 1;
577: else if (!strcmp("level-2", argv[2]))
578: level = 2;
579: else
580: return CMD_WARNING;
581:
582: if ((area->is_type & level) != level)
583: {
584: vty_out(vty, "Node is not a level-%d IS%s", level, VTY_NEWLINE);
585: return CMD_WARNING;
586: }
587:
588: if (argv[3])
589: {
590: char *endp;
591: metric = strtoul(argv[3], &endp, 10);
592: if (argv[3][0] == '\0' || *endp != '\0')
593: return CMD_WARNING;
594: }
595: else
596: {
597: metric = 0xffffffff;
598: }
599:
600: routemap = argv[4];
601:
602: isis_redist_set(area, level, family, type, metric, routemap, 0);
603: return 0;
604: }
605:
606: DEFUN(no_isis_redistribute,
607: no_isis_redistribute_cmd,
608: "no redistribute (ipv4|ipv6) " QUAGGA_REDIST_STR_ISISD
609: " (level-1|level-2)",
610: NO_STR
611: REDIST_STR
612: "Redistribute IPv4 routes\n"
613: "Redistribute IPv6 routes\n"
614: QUAGGA_REDIST_HELP_STR_ISISD
615: "Redistribute into level-1\n"
616: "Redistribute into level-2\n")
617: {
618: struct isis_area *area = vty->index;
619: int type;
620: int level;
621: int family;
622: int afi;
623:
624: if (argc < 3)
625: return CMD_WARNING;
626:
627: family = str2family(argv[0]);
628: if (family < 0)
629: return CMD_WARNING;
630:
631: afi = family2afi(family);
632: if (!afi)
633: return CMD_WARNING;
634:
635: type = proto_redistnum(afi, argv[1]);
636: if (type < 0 || type == ZEBRA_ROUTE_ISIS)
637: return CMD_WARNING;
638:
639: if (!strcmp("level-1", argv[2]))
640: level = 1;
641: else if (!strcmp("level-2", argv[2]))
642: level = 2;
643: else
644: return CMD_WARNING;
645:
646: isis_redist_unset(area, level, family, type);
647: return 0;
648: }
649:
650: DEFUN(isis_default_originate,
651: isis_default_originate_cmd,
652: "default-information originate (ipv4|ipv6) (level-1|level-2) "
653: "{always|metric <0-16777215>|route-map WORD}",
654: "Control distribution of default information\n"
655: "Distribute a default route\n"
656: "Distribute default route for IPv4\n"
657: "Distribute default route for IPv6\n"
658: "Distribute default route into level-1\n"
659: "Distribute default route into level-2\n"
660: "Always advertise default route\n"
661: "Metric for default route\n"
662: "ISIS default metric\n"
663: "Route map reference\n"
664: "Pointer to route-map entries\n")
665: {
666: struct isis_area *area = vty->index;
667: int family;
668: int originate_type;
669: int level;
670: unsigned long metric;
671: const char *routemap;
672:
673: if (argc < 5)
674: return CMD_WARNING;
675:
676: family = str2family(argv[0]);
677: if (family < 0)
678: return CMD_WARNING;
679:
680: if (!strcmp("level-1", argv[1]))
681: level = 1;
682: else if (!strcmp("level-2", argv[1]))
683: level = 2;
684: else
685: return CMD_WARNING;
686:
687: if ((area->is_type & level) != level)
688: {
689: vty_out(vty, "Node is not a level-%d IS%s", level, VTY_NEWLINE);
690: return CMD_WARNING;
691: }
692:
693: if (argv[2] && *argv[2] != '\0')
694: originate_type = DEFAULT_ORIGINATE_ALWAYS;
695: else
696: originate_type = DEFAULT_ORIGINATE;
697:
698: if (family == AF_INET6 && originate_type != DEFAULT_ORIGINATE_ALWAYS)
699: {
700: vty_out(vty, "Zebra doesn't implement default-originate for IPv6 yet%s", VTY_NEWLINE);
701: vty_out(vty, "so use with care or use default-originate always.%s", VTY_NEWLINE);
702: }
703:
704: if (argv[3])
705: {
706: char *endp;
707: metric = strtoul(argv[3], &endp, 10);
708: if (argv[3][0] == '\0' || *endp != '\0')
709: return CMD_WARNING;
710: }
711: else
712: {
713: metric = 0xffffffff;
714: }
715:
716: routemap = argv[4];
717:
718: isis_redist_set(area, level, family, DEFAULT_ROUTE, metric, routemap, originate_type);
719: return 0;
720: }
721:
722: DEFUN(no_isis_default_originate,
723: no_isis_default_originate_cmd,
724: "no default-information originate (ipv4|ipv6) (level-1|level-2)",
725: NO_STR
726: "Control distribution of default information\n"
727: "Distribute a default route\n"
728: "Distribute default route for IPv4\n"
729: "Distribute default route for IPv6\n"
730: "Distribute default route into level-1\n"
731: "Distribute default route into level-2\n")
732: {
733: struct isis_area *area = vty->index;
734:
735: int family;
736: int level;
737:
738: if (argc < 2)
739: return CMD_WARNING;
740:
741: family = str2family(argv[0]);
742: if (family < 0)
743: return CMD_WARNING;
744:
745: if (!strcmp("level-1", argv[1]))
746: level = 1;
747: else if (!strcmp("level-2", argv[1]))
748: level = 2;
749: else
750: return CMD_WARNING;
751:
752: isis_redist_unset(area, level, family, DEFAULT_ROUTE);
753: return 0;
754: }
755:
756: int
757: isis_redist_config_write(struct vty *vty, struct isis_area *area,
758: int family)
759: {
760: int type;
761: int level;
762: int write = 0;
763: struct isis_redist *redist;
764: const char *family_str;
765:
766: if (family == AF_INET)
767: family_str = "ipv4";
768: else if (family == AF_INET6)
769: family_str = "ipv6";
770: else
771: return 0;
772:
773: for (type = 0; type < ZEBRA_ROUTE_MAX; type++)
774: {
775: if (type == ZEBRA_ROUTE_ISIS)
776: continue;
777:
778: for (level = 1; level <= ISIS_LEVELS; level++)
779: {
780: redist = get_redist_settings(area, family, type, level);
781: if (!redist->redist)
782: continue;
783: vty_out(vty, " redistribute %s %s level-%d",
784: family_str, zebra_route_string(type), level);
785: if (redist->metric != 0xffffffff)
786: vty_out(vty, " metric %u", redist->metric);
787: if (redist->map_name)
788: vty_out(vty, " route-map %s", redist->map_name);
789: vty_out(vty, "%s", VTY_NEWLINE);
790: write++;
791: }
792: }
793:
794: for (level = 1; level <= ISIS_LEVELS; level++)
795: {
796: redist = get_redist_settings(area, family, DEFAULT_ROUTE, level);
797: if (!redist->redist)
798: continue;
799: vty_out(vty, " default-information originate %s level-%d",
800: family_str, level);
801: if (redist->redist == DEFAULT_ORIGINATE_ALWAYS)
802: vty_out(vty, " always");
803: if (redist->metric != 0xffffffff)
804: vty_out(vty, " metric %u", redist->metric);
805: if (redist->map_name)
806: vty_out(vty, " route-map %s", redist->map_name);
807: vty_out(vty, "%s", VTY_NEWLINE);
808: write++;
809: }
810:
811: return write;
812: }
813:
814: void
815: isis_redist_init(void)
816: {
817: install_element(ISIS_NODE, &isis_redistribute_cmd);
818: install_element(ISIS_NODE, &no_isis_redistribute_cmd);
819: install_element(ISIS_NODE, &isis_default_originate_cmd);
820: install_element(ISIS_NODE, &no_isis_default_originate_cmd);
821: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_redist.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