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 if (redist
->map_name
)
508 XFREE(MTYPE_ISIS
, redist
->map_name
);
510 route_table_finish(area
->ext_reach
[protocol
][level
]);
513 isis_redist_update_zebra_subscriptions(area
->isis
);
517 DEFUN (isis_redistribute
,
518 isis_redistribute_cmd
,
519 "redistribute <ipv4|ipv6> " PROTO_REDIST_STR
520 " [<metric (0-16777215)|route-map WORD>]",
522 "Redistribute IPv4 routes\n"
523 "Redistribute IPv6 routes\n"
525 "Metric for redistributed routes\n"
526 "ISIS default metric\n"
527 "Route map reference\n"
528 "Pointer to route-map entries\n")
531 int idx_protocol
= 2;
532 int idx_metric_rmap
= fabricd
? 3 : 4;
533 VTY_DECLVAR_CONTEXT(isis_area
, area
);
538 unsigned long metric
= 0;
539 const char *routemap
= NULL
;
541 family
= str2family(argv
[idx_afi
]->text
);
543 return CMD_WARNING_CONFIG_FAILED
;
545 afi
= family2afi(family
);
547 return CMD_WARNING_CONFIG_FAILED
;
549 type
= proto_redistnum(afi
, argv
[idx_protocol
]->text
);
551 return CMD_WARNING_CONFIG_FAILED
;
555 if ((area
->is_type
& level
) != level
) {
556 vty_out(vty
, "Node is not a level-%d IS\n", level
);
557 return CMD_WARNING_CONFIG_FAILED
;
560 if (argc
> idx_metric_rmap
+ 1) {
561 if (argv
[idx_metric_rmap
+ 1]->arg
[0] == '\0')
562 return CMD_WARNING_CONFIG_FAILED
;
564 if (strmatch(argv
[idx_metric_rmap
]->text
, "metric")) {
566 metric
= strtoul(argv
[idx_metric_rmap
+ 1]->arg
, &endp
,
570 return CMD_WARNING_CONFIG_FAILED
;
572 routemap
= argv
[idx_metric_rmap
+ 1]->arg
;
576 isis_redist_set(area
, level
, family
, type
, metric
, routemap
, 0);
580 DEFUN (no_isis_redistribute
,
581 no_isis_redistribute_cmd
,
582 "no redistribute <ipv4|ipv6> " PROTO_REDIST_STR
,
585 "Redistribute IPv4 routes\n"
586 "Redistribute IPv6 routes\n"
590 int idx_protocol
= 3;
591 VTY_DECLVAR_CONTEXT(isis_area
, area
);
597 family
= str2family(argv
[idx_afi
]->arg
);
599 return CMD_WARNING_CONFIG_FAILED
;
601 afi
= family2afi(family
);
603 return CMD_WARNING_CONFIG_FAILED
;
605 type
= proto_redistnum(afi
, argv
[idx_protocol
]->text
);
607 return CMD_WARNING_CONFIG_FAILED
;
611 isis_redist_unset(area
, level
, family
, type
);
615 DEFUN (isis_default_originate
,
616 isis_default_originate_cmd
,
617 "default-information originate <ipv4|ipv6>"
618 " [always] [<metric (0-16777215)|route-map WORD>]",
619 "Control distribution of default information\n"
620 "Distribute a default route\n"
621 "Distribute default route for IPv4\n"
622 "Distribute default route for IPv6\n"
623 "Always advertise default route\n"
624 "Metric for default route\n"
625 "ISIS default metric\n"
626 "Route map reference\n"
627 "Pointer to route-map entries\n")
630 int idx_always
= fabricd
? 3 : 4;
631 int idx_metric_rmap
= fabricd
? 3 : 4;
632 VTY_DECLVAR_CONTEXT(isis_area
, area
);
634 int originate_type
= DEFAULT_ORIGINATE
;
636 unsigned long metric
= 0;
637 const char *routemap
= NULL
;
639 family
= str2family(argv
[idx_afi
]->text
);
641 return CMD_WARNING_CONFIG_FAILED
;
645 if ((area
->is_type
& level
) != level
) {
646 vty_out(vty
, "Node is not a level-%d IS\n", level
);
647 return CMD_WARNING_CONFIG_FAILED
;
650 if (argc
> idx_always
&& strmatch(argv
[idx_always
]->text
, "always")) {
651 originate_type
= DEFAULT_ORIGINATE_ALWAYS
;
655 if (argc
> idx_metric_rmap
) {
656 if (strmatch(argv
[idx_metric_rmap
]->text
, "metric"))
657 metric
= strtoul(argv
[idx_metric_rmap
+ 1]->arg
, NULL
,
660 routemap
= argv
[idx_metric_rmap
+ 1]->arg
;
663 if (family
== AF_INET6
&& originate_type
!= DEFAULT_ORIGINATE_ALWAYS
) {
665 "Zebra doesn't implement default-originate for IPv6 yet\n");
667 "so use with care or use default-originate always.\n");
670 isis_redist_set(area
, level
, family
, DEFAULT_ROUTE
, metric
, routemap
,
675 DEFUN (no_isis_default_originate
,
676 no_isis_default_originate_cmd
,
677 "no default-information originate <ipv4|ipv6>",
679 "Control distribution of default information\n"
680 "Distribute a default route\n"
681 "Distribute default route for IPv4\n"
682 "Distribute default route for IPv6\n")
685 VTY_DECLVAR_CONTEXT(isis_area
, area
);
689 family
= str2family(argv
[idx_afi
]->text
);
691 return CMD_WARNING_CONFIG_FAILED
;
695 isis_redist_unset(area
, level
, family
, DEFAULT_ROUTE
);
698 #endif /* ifdef FABRICD */
700 int isis_redist_config_write(struct vty
*vty
, struct isis_area
*area
,
706 struct isis_redist
*redist
;
707 const char *family_str
;
709 if (family
== AF_INET
)
711 else if (family
== AF_INET6
)
716 for (type
= 0; type
< ZEBRA_ROUTE_MAX
; type
++) {
717 if (type
== PROTO_TYPE
)
720 for (level
= 1; level
<= ISIS_LEVELS
; level
++) {
721 redist
= get_redist_settings(area
, family
, type
, level
);
724 vty_out(vty
, " redistribute %s %s", family_str
,
725 zebra_route_string(type
));
727 vty_out(vty
, " level-%d", level
);
729 vty_out(vty
, " metric %u", redist
->metric
);
730 if (redist
->map_name
)
731 vty_out(vty
, " route-map %s", redist
->map_name
);
737 for (level
= 1; level
<= ISIS_LEVELS
; level
++) {
739 get_redist_settings(area
, family
, DEFAULT_ROUTE
, level
);
742 vty_out(vty
, " default-information originate %s",
745 vty_out(vty
, " level-%d", level
);
746 if (redist
->redist
== DEFAULT_ORIGINATE_ALWAYS
)
747 vty_out(vty
, " always");
749 vty_out(vty
, " metric %u", redist
->metric
);
750 if (redist
->map_name
)
751 vty_out(vty
, " route-map %s", redist
->map_name
);
759 void isis_redist_init(void)
762 install_element(ROUTER_NODE
, &isis_redistribute_cmd
);
763 install_element(ROUTER_NODE
, &no_isis_redistribute_cmd
);
765 install_element(ROUTER_NODE
, &isis_default_originate_cmd
);
766 install_element(ROUTER_NODE
, &no_isis_default_originate_cmd
);
767 #endif /* ifdef FABRICD */