2 * IS-IS Rout(e)ing protocol - isis_redist.c
4 * Copyright (C) 2013-2015 Christian Franke <chris@opensourcerouting.org>
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)
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
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "isis_memory.h"
33 #include "srcdest_table.h"
35 #include "isisd/dict.h"
36 #include "isisd/isis_constants.h"
37 #include "isisd/isis_common.h"
38 #include "isisd/isis_flags.h"
39 #include "isisd/isis_misc.h"
40 #include "isisd/isis_circuit.h"
41 #include "isisd/isisd.h"
42 #include "isisd/isis_lsp.h"
43 #include "isisd/isis_route.h"
44 #include "isisd/isis_zebra.h"
46 static int redist_protocol(int family
)
48 if (family
== AF_INET
)
50 if (family
== AF_INET6
)
53 assert(!"Unsupported address family!");
57 static afi_t
afi_for_redist_protocol(int protocol
)
64 assert(!"Unknown redist protocol!");
68 static struct route_table
*get_ext_info(struct isis
*i
, int family
)
70 int protocol
= redist_protocol(family
);
72 return i
->ext_info
[protocol
];
75 static struct isis_redist
*get_redist_settings(struct isis_area
*area
,
76 int family
, int type
, int level
)
78 int protocol
= redist_protocol(family
);
80 return &area
->redist_settings
[protocol
][type
][level
- 1];
83 struct route_table
*get_ext_reach(struct isis_area
*area
, int family
, int level
)
85 int protocol
= redist_protocol(family
);
87 return area
->ext_reach
[protocol
][level
- 1];
90 /* Install external reachability information into a
91 * specific area for a specific level.
92 * Schedule an lsp regenerate if necessary */
93 static void isis_redist_install(struct isis_area
*area
, int level
,
94 const struct prefix
*p
,
95 const struct prefix_ipv6
*src_p
,
96 struct isis_ext_info
*info
)
98 int family
= p
->family
;
99 struct route_table
*er_table
= get_ext_reach(area
, family
, level
);
100 struct route_node
*er_node
;
104 "%s: External reachability table of area %s"
105 " is not initialized.",
106 __func__
, area
->area_tag
);
110 er_node
= srcdest_rnode_get(er_table
, p
, src_p
);
112 route_unlock_node(er_node
);
114 /* Don't update/reschedule lsp generation if nothing changed. */
115 if (!memcmp(er_node
->info
, info
, sizeof(*info
)))
118 er_node
->info
= XMALLOC(MTYPE_ISIS_EXT_INFO
, sizeof(*info
));
121 memcpy(er_node
->info
, info
, sizeof(*info
));
122 lsp_regenerate_schedule(area
, level
, 0);
125 /* Remove external reachability information from a
126 * specific area for a specific level.
127 * Schedule an lsp regenerate if necessary. */
128 static void isis_redist_uninstall(struct isis_area
*area
, int level
,
129 const struct prefix
*p
,
130 const struct prefix_ipv6
*src_p
)
132 int family
= p
->family
;
133 struct route_table
*er_table
= get_ext_reach(area
, family
, level
);
134 struct route_node
*er_node
;
138 "%s: External reachability table of area %s"
139 " is not initialized.",
140 __func__
, area
->area_tag
);
144 er_node
= srcdest_rnode_lookup(er_table
, p
, src_p
);
148 route_unlock_node(er_node
);
153 XFREE(MTYPE_ISIS_EXT_INFO
, er_node
->info
);
154 route_unlock_node(er_node
);
155 lsp_regenerate_schedule(area
, level
, 0);
158 /* Update external reachability info of area for a given level
159 * and prefix, using the given redistribution settings. */
160 static void isis_redist_update_ext_reach(struct isis_area
*area
, int level
,
161 struct isis_redist
*redist
,
162 const struct prefix
*p
,
163 const struct prefix_ipv6
*src_p
,
164 struct isis_ext_info
*info
)
166 struct isis_ext_info area_info
;
167 route_map_result_t map_ret
;
169 memcpy(&area_info
, info
, sizeof(area_info
));
170 area_info
.metric
= redist
->metric
;
172 if (redist
->map_name
) {
174 route_map_apply(redist
->map
, p
, RMAP_ISIS
, &area_info
);
175 if (map_ret
== RMAP_DENYMATCH
)
176 area_info
.distance
= 255;
179 /* Allow synthesized default routes only on always orignate */
180 if (area_info
.origin
== DEFAULT_ROUTE
181 && redist
->redist
!= DEFAULT_ORIGINATE_ALWAYS
)
182 area_info
.distance
= 255;
184 if (area_info
.distance
< 255)
185 isis_redist_install(area
, level
, p
, src_p
, &area_info
);
187 isis_redist_uninstall(area
, level
, p
, src_p
);
190 static void isis_redist_ensure_default(struct isis
*isis
, int family
)
193 struct route_table
*ei_table
= get_ext_info(isis
, family
);
194 struct route_node
*ei_node
;
195 struct isis_ext_info
*info
;
197 if (family
== AF_INET
) {
200 memset(&p
.u
.prefix4
, 0, sizeof(p
.u
.prefix4
));
201 } else if (family
== AF_INET6
) {
204 memset(&p
.u
.prefix6
, 0, sizeof(p
.u
.prefix6
));
206 assert(!"Unknown family!");
208 ei_node
= srcdest_rnode_get(ei_table
, &p
, NULL
);
210 route_unlock_node(ei_node
);
215 XCALLOC(MTYPE_ISIS_EXT_INFO
, sizeof(struct isis_ext_info
));
217 info
= ei_node
->info
;
218 info
->origin
= DEFAULT_ROUTE
;
219 info
->distance
= 254;
220 info
->metric
= MAX_WIDE_PATH_METRIC
;
223 /* Handle notification about route being added */
224 void isis_redist_add(int type
, struct prefix
*p
, struct prefix_ipv6
*src_p
,
225 uint8_t distance
, uint32_t metric
)
227 int family
= p
->family
;
228 struct route_table
*ei_table
= get_ext_info(isis
, family
);
229 struct route_node
*ei_node
;
230 struct isis_ext_info
*info
;
231 struct listnode
*node
;
232 struct isis_area
*area
;
234 struct isis_redist
*redist
;
236 char debug_buf
[BUFSIZ
];
237 prefix2str(p
, debug_buf
, sizeof(debug_buf
));
239 zlog_debug("%s: New route %s from %s: distance %d.", __func__
,
240 debug_buf
, zebra_route_string(type
), distance
);
243 zlog_warn("%s: External information table not initialized.",
248 ei_node
= srcdest_rnode_get(ei_table
, p
, src_p
);
250 route_unlock_node(ei_node
);
252 ei_node
->info
= XCALLOC(MTYPE_ISIS_EXT_INFO
,
253 sizeof(struct isis_ext_info
));
255 info
= ei_node
->info
;
257 info
->distance
= distance
;
258 info
->metric
= metric
;
260 if (is_default_prefix(p
)
261 && (!src_p
|| !src_p
->prefixlen
)) {
262 type
= DEFAULT_ROUTE
;
265 for (ALL_LIST_ELEMENTS_RO(isis
->area_list
, node
, area
))
266 for (level
= 1; level
<= ISIS_LEVELS
; level
++) {
267 redist
= get_redist_settings(area
, family
, type
, level
);
271 isis_redist_update_ext_reach(area
, level
, redist
, p
,
276 void isis_redist_delete(int type
, struct prefix
*p
, struct prefix_ipv6
*src_p
)
278 int family
= p
->family
;
279 struct route_table
*ei_table
= get_ext_info(isis
, family
);
280 struct route_node
*ei_node
;
281 struct listnode
*node
;
282 struct isis_area
*area
;
284 struct isis_redist
*redist
;
286 char debug_buf
[BUFSIZ
];
287 prefix2str(p
, debug_buf
, sizeof(debug_buf
));
289 zlog_debug("%s: Removing route %s from %s.", __func__
, debug_buf
,
290 zebra_route_string(type
));
292 if (is_default_prefix(p
)
293 && (!src_p
|| !src_p
->prefixlen
)) {
294 /* Don't remove default route but add synthetic route for use
295 * by "default-information originate always". Areas without the
296 * "always" setting will ignore routes with origin
298 isis_redist_add(DEFAULT_ROUTE
, p
, NULL
,
299 254, MAX_WIDE_PATH_METRIC
);
304 zlog_warn("%s: External information table not initialized.",
309 ei_node
= srcdest_rnode_lookup(ei_table
, p
, src_p
);
310 if (!ei_node
|| !ei_node
->info
) {
312 prefix2str(p
, buf
, sizeof(buf
));
314 "%s: Got a delete for %s route %s, but that route"
316 __func__
, zebra_route_string(type
), buf
);
318 route_unlock_node(ei_node
);
321 route_unlock_node(ei_node
);
323 for (ALL_LIST_ELEMENTS_RO(isis
->area_list
, node
, area
))
324 for (level
= ISIS_LEVEL1
; level
<= ISIS_LEVEL2
; level
++) {
325 redist
= get_redist_settings(area
, family
, type
, level
);
329 isis_redist_uninstall(area
, level
, p
, src_p
);
332 XFREE(MTYPE_ISIS_EXT_INFO
, ei_node
->info
);
333 route_unlock_node(ei_node
);
336 static void isis_redist_routemap_set(struct isis_redist
*redist
,
337 const char *routemap
)
339 if (redist
->map_name
) {
340 XFREE(MTYPE_ISIS
, redist
->map_name
);
341 route_map_counter_decrement(redist
->map
);
345 if (routemap
&& strlen(routemap
)) {
346 redist
->map_name
= XSTRDUP(MTYPE_ISIS
, routemap
);
347 redist
->map
= route_map_lookup_by_name(routemap
);
348 route_map_counter_increment(redist
->map
);
352 static void isis_redist_update_zebra_subscriptions(struct isis
*isis
)
354 struct listnode
*node
;
355 struct isis_area
*area
;
360 char do_subscribe
[REDIST_PROTOCOL_COUNT
][ZEBRA_ROUTE_MAX
+ 1];
362 memset(do_subscribe
, 0, sizeof(do_subscribe
));
364 for (ALL_LIST_ELEMENTS_RO(isis
->area_list
, node
, area
))
365 for (protocol
= 0; protocol
< REDIST_PROTOCOL_COUNT
; protocol
++)
366 for (type
= 0; type
< ZEBRA_ROUTE_MAX
+ 1; type
++)
367 for (level
= 0; level
< ISIS_LEVELS
; level
++)
368 if (area
->redist_settings
[protocol
]
371 do_subscribe
[protocol
][type
] =
374 for (protocol
= 0; protocol
< REDIST_PROTOCOL_COUNT
; protocol
++)
375 for (type
= 0; type
< ZEBRA_ROUTE_MAX
+ 1; type
++) {
376 /* This field is actually controlling transmission of
378 * routes to Zebra and has nothing to do with
381 if (type
== PROTO_TYPE
)
384 afi_t afi
= afi_for_redist_protocol(protocol
);
386 if (do_subscribe
[protocol
][type
])
387 isis_zebra_redistribute_set(afi
, type
);
389 isis_zebra_redistribute_unset(afi
, type
);
393 void isis_redist_set(struct isis_area
*area
, int level
, int family
, int type
,
394 uint32_t metric
, const char *routemap
, int originate_type
)
396 int protocol
= redist_protocol(family
);
397 struct isis_redist
*redist
=
398 get_redist_settings(area
, family
, type
, level
);
400 struct route_table
*ei_table
;
401 struct route_node
*rn
;
402 struct isis_ext_info
*info
;
404 redist
->redist
= (type
== DEFAULT_ROUTE
) ? originate_type
: 1;
405 redist
->metric
= metric
;
406 isis_redist_routemap_set(redist
, routemap
);
408 if (!area
->ext_reach
[protocol
][level
- 1]) {
409 area
->ext_reach
[protocol
][level
- 1] = srcdest_table_init();
412 for (i
= 0; i
< REDIST_PROTOCOL_COUNT
; i
++) {
413 if (!area
->isis
->ext_info
[i
]) {
414 area
->isis
->ext_info
[i
] = srcdest_table_init();
418 isis_redist_update_zebra_subscriptions(area
->isis
);
420 if (type
== DEFAULT_ROUTE
&& originate_type
== DEFAULT_ORIGINATE_ALWAYS
)
421 isis_redist_ensure_default(area
->isis
, family
);
423 ei_table
= get_ext_info(area
->isis
, family
);
424 for (rn
= route_top(ei_table
); rn
; rn
= srcdest_route_next(rn
)) {
429 const struct prefix
*p
, *src_p
;
431 srcdest_rnode_prefixes(rn
, &p
, &src_p
);
433 if (type
== DEFAULT_ROUTE
) {
434 if (!is_default_prefix(p
)
435 || (src_p
&& src_p
->prefixlen
)) {
439 if (info
->origin
!= type
)
443 isis_redist_update_ext_reach(area
, level
, redist
, p
,
444 (const struct prefix_ipv6
*)src_p
,
449 void isis_redist_unset(struct isis_area
*area
, int level
, int family
, int type
)
451 struct isis_redist
*redist
=
452 get_redist_settings(area
, family
, type
, level
);
453 struct route_table
*er_table
= get_ext_reach(area
, family
, level
);
454 struct route_node
*rn
;
455 struct isis_ext_info
*info
;
462 zlog_warn("%s: External reachability table uninitialized.",
467 for (rn
= route_top(er_table
); rn
; rn
= srcdest_route_next(rn
)) {
472 const struct prefix
*p
, *src_p
;
473 srcdest_rnode_prefixes(rn
, &p
, &src_p
);
475 if (type
== DEFAULT_ROUTE
) {
476 if (!is_default_prefix(p
)
477 || (src_p
&& src_p
->prefixlen
)) {
481 if (info
->origin
!= type
)
485 XFREE(MTYPE_ISIS_EXT_INFO
, rn
->info
);
486 route_unlock_node(rn
);
489 lsp_regenerate_schedule(area
, level
, 0);
490 isis_redist_update_zebra_subscriptions(area
->isis
);
493 void isis_redist_area_finish(struct isis_area
*area
)
499 for (protocol
= 0; protocol
< REDIST_PROTOCOL_COUNT
; protocol
++)
500 for (level
= 0; level
< ISIS_LEVELS
; level
++) {
501 for (type
= 0; type
< ZEBRA_ROUTE_MAX
+ 1; type
++) {
502 struct isis_redist
*redist
;
504 redist
= &area
->redist_settings
[protocol
][type
]
507 XFREE(MTYPE_ISIS
, redist
->map_name
);
509 route_table_finish(area
->ext_reach
[protocol
][level
]);
512 isis_redist_update_zebra_subscriptions(area
->isis
);
516 DEFUN (isis_redistribute
,
517 isis_redistribute_cmd
,
518 "redistribute <ipv4|ipv6> " PROTO_REDIST_STR
519 " [<metric (0-16777215)|route-map WORD>]",
521 "Redistribute IPv4 routes\n"
522 "Redistribute IPv6 routes\n"
524 "Metric for redistributed routes\n"
525 "ISIS default metric\n"
526 "Route map reference\n"
527 "Pointer to route-map entries\n")
530 int idx_protocol
= 2;
531 int idx_metric_rmap
= fabricd
? 3 : 4;
532 VTY_DECLVAR_CONTEXT(isis_area
, area
);
537 unsigned long metric
= 0;
538 const char *routemap
= NULL
;
540 family
= str2family(argv
[idx_afi
]->text
);
542 return CMD_WARNING_CONFIG_FAILED
;
544 afi
= family2afi(family
);
546 return CMD_WARNING_CONFIG_FAILED
;
548 type
= proto_redistnum(afi
, argv
[idx_protocol
]->text
);
550 return CMD_WARNING_CONFIG_FAILED
;
554 if ((area
->is_type
& level
) != level
) {
555 vty_out(vty
, "Node is not a level-%d IS\n", level
);
556 return CMD_WARNING_CONFIG_FAILED
;
559 if (argc
> idx_metric_rmap
+ 1) {
560 if (argv
[idx_metric_rmap
+ 1]->arg
[0] == '\0')
561 return CMD_WARNING_CONFIG_FAILED
;
563 if (strmatch(argv
[idx_metric_rmap
]->text
, "metric")) {
565 metric
= strtoul(argv
[idx_metric_rmap
+ 1]->arg
, &endp
,
569 return CMD_WARNING_CONFIG_FAILED
;
571 routemap
= argv
[idx_metric_rmap
+ 1]->arg
;
575 isis_redist_set(area
, level
, family
, type
, metric
, routemap
, 0);
579 DEFUN (no_isis_redistribute
,
580 no_isis_redistribute_cmd
,
581 "no redistribute <ipv4|ipv6> " PROTO_REDIST_STR
,
584 "Redistribute IPv4 routes\n"
585 "Redistribute IPv6 routes\n"
589 int idx_protocol
= 3;
590 VTY_DECLVAR_CONTEXT(isis_area
, area
);
596 family
= str2family(argv
[idx_afi
]->arg
);
598 return CMD_WARNING_CONFIG_FAILED
;
600 afi
= family2afi(family
);
602 return CMD_WARNING_CONFIG_FAILED
;
604 type
= proto_redistnum(afi
, argv
[idx_protocol
]->text
);
606 return CMD_WARNING_CONFIG_FAILED
;
610 isis_redist_unset(area
, level
, family
, type
);
614 DEFUN (isis_default_originate
,
615 isis_default_originate_cmd
,
616 "default-information originate <ipv4|ipv6>"
617 " [always] [<metric (0-16777215)|route-map WORD>]",
618 "Control distribution of default information\n"
619 "Distribute a default route\n"
620 "Distribute default route for IPv4\n"
621 "Distribute default route for IPv6\n"
622 "Always advertise default route\n"
623 "Metric for default route\n"
624 "ISIS default metric\n"
625 "Route map reference\n"
626 "Pointer to route-map entries\n")
629 int idx_always
= fabricd
? 3 : 4;
630 int idx_metric_rmap
= fabricd
? 3 : 4;
631 VTY_DECLVAR_CONTEXT(isis_area
, area
);
633 int originate_type
= DEFAULT_ORIGINATE
;
635 unsigned long metric
= 0;
636 const char *routemap
= NULL
;
638 family
= str2family(argv
[idx_afi
]->text
);
640 return CMD_WARNING_CONFIG_FAILED
;
644 if ((area
->is_type
& level
) != level
) {
645 vty_out(vty
, "Node is not a level-%d IS\n", level
);
646 return CMD_WARNING_CONFIG_FAILED
;
649 if (argc
> idx_always
&& strmatch(argv
[idx_always
]->text
, "always")) {
650 originate_type
= DEFAULT_ORIGINATE_ALWAYS
;
654 if (argc
> idx_metric_rmap
) {
655 if (strmatch(argv
[idx_metric_rmap
]->text
, "metric"))
656 metric
= strtoul(argv
[idx_metric_rmap
+ 1]->arg
, NULL
,
659 routemap
= argv
[idx_metric_rmap
+ 1]->arg
;
662 if (family
== AF_INET6
&& originate_type
!= DEFAULT_ORIGINATE_ALWAYS
) {
664 "Zebra doesn't implement default-originate for IPv6 yet\n");
666 "so use with care or use default-originate always.\n");
669 isis_redist_set(area
, level
, family
, DEFAULT_ROUTE
, metric
, routemap
,
674 DEFUN (no_isis_default_originate
,
675 no_isis_default_originate_cmd
,
676 "no default-information originate <ipv4|ipv6>",
678 "Control distribution of default information\n"
679 "Distribute a default route\n"
680 "Distribute default route for IPv4\n"
681 "Distribute default route for IPv6\n")
684 VTY_DECLVAR_CONTEXT(isis_area
, area
);
688 family
= str2family(argv
[idx_afi
]->text
);
690 return CMD_WARNING_CONFIG_FAILED
;
694 isis_redist_unset(area
, level
, family
, DEFAULT_ROUTE
);
697 #endif /* ifdef FABRICD */
699 int isis_redist_config_write(struct vty
*vty
, struct isis_area
*area
,
705 struct isis_redist
*redist
;
706 const char *family_str
;
708 if (family
== AF_INET
)
710 else if (family
== AF_INET6
)
715 for (type
= 0; type
< ZEBRA_ROUTE_MAX
; type
++) {
716 if (type
== PROTO_TYPE
)
719 for (level
= 1; level
<= ISIS_LEVELS
; level
++) {
720 redist
= get_redist_settings(area
, family
, type
, level
);
723 vty_out(vty
, " redistribute %s %s", family_str
,
724 zebra_route_string(type
));
726 vty_out(vty
, " level-%d", level
);
728 vty_out(vty
, " metric %u", redist
->metric
);
729 if (redist
->map_name
)
730 vty_out(vty
, " route-map %s", redist
->map_name
);
736 for (level
= 1; level
<= ISIS_LEVELS
; level
++) {
738 get_redist_settings(area
, family
, DEFAULT_ROUTE
, level
);
741 vty_out(vty
, " default-information originate %s",
744 vty_out(vty
, " level-%d", level
);
745 if (redist
->redist
== DEFAULT_ORIGINATE_ALWAYS
)
746 vty_out(vty
, " always");
748 vty_out(vty
, " metric %u", redist
->metric
);
749 if (redist
->map_name
)
750 vty_out(vty
, " route-map %s", redist
->map_name
);
758 void isis_redist_init(void)
761 install_element(ROUTER_NODE
, &isis_redistribute_cmd
);
762 install_element(ROUTER_NODE
, &no_isis_redistribute_cmd
);
764 install_element(ROUTER_NODE
, &isis_default_originate_cmd
);
765 install_element(ROUTER_NODE
, &no_isis_default_originate_cmd
);
766 #endif /* ifdef FABRICD */