2 * Copyright (C) 2006 IBM Corporation
4 * This file is part of GNU Zebra.
6 * GNU Zebra 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
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
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
24 #include "zebra_memory.h"
36 #include "zebra/zebra_router.h"
37 #include "zebra/redistribute.h"
38 #include "zebra/debug.h"
39 #include "zebra/zebra_rnh.h"
40 #include "zebra/zebra_routemap.h"
42 #ifndef VTYSH_EXTRACT_PL
43 #include "zebra/zebra_routemap_clippy.c"
46 static uint32_t zebra_rmap_update_timer
= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
;
47 static struct thread
*zebra_t_rmap_update
= NULL
;
48 char *zebra_import_table_routemap
[AFI_MAX
][ZEBRA_KERNEL_TABLE_MAX
];
51 struct nexthop
*nexthop
;
53 uint32_t source_protocol
;
59 static void zebra_route_map_set_delay_timer(uint32_t value
);
62 /* Add zebra route map rule */
63 static int zebra_route_match_add(struct vty
*vty
, const char *command
,
64 const char *arg
, route_map_event_t type
)
66 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
68 int retval
= CMD_SUCCESS
;
70 ret
= route_map_add_match(index
, command
, arg
, type
);
72 case RMAP_RULE_MISSING
:
73 vty_out(vty
, "%% Zebra Can't find rule.\n");
74 retval
= CMD_WARNING_CONFIG_FAILED
;
76 case RMAP_COMPILE_ERROR
:
77 vty_out(vty
, "%% Zebra Argument is malformed.\n");
78 retval
= CMD_WARNING_CONFIG_FAILED
;
80 case RMAP_COMPILE_SUCCESS
:
81 if (type
!= RMAP_EVENT_MATCH_ADDED
) {
82 route_map_upd8_dependency(type
, arg
, index
->map
->name
);
90 /* Delete zebra route map rule. */
91 static int zebra_route_match_delete(struct vty
*vty
, const char *command
,
92 const char *arg
, route_map_event_t type
)
94 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
96 int retval
= CMD_SUCCESS
;
97 char *dep_name
= NULL
;
99 char *rmap_name
= NULL
;
101 if (type
!= RMAP_EVENT_MATCH_DELETED
) {
102 /* ignore the mundane, the types without any dependency */
104 if ((tmpstr
= route_map_get_match_arg(index
, command
))
107 XSTRDUP(MTYPE_ROUTE_MAP_RULE
, tmpstr
);
109 dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_RULE
, arg
);
111 rmap_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, index
->map
->name
);
114 ret
= route_map_delete_match(index
, command
, arg
);
116 case RMAP_RULE_MISSING
:
117 vty_out(vty
, "%% Zebra Can't find rule.\n");
118 retval
= CMD_WARNING_CONFIG_FAILED
;
120 case RMAP_COMPILE_ERROR
:
121 vty_out(vty
, "%% Zebra Argument is malformed.\n");
122 retval
= CMD_WARNING_CONFIG_FAILED
;
124 case RMAP_COMPILE_SUCCESS
:
125 if (type
!= RMAP_EVENT_MATCH_DELETED
&& dep_name
)
126 route_map_upd8_dependency(type
, dep_name
, rmap_name
);
130 XFREE(MTYPE_ROUTE_MAP_RULE
, dep_name
);
131 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
137 * Match function return 1 if match is success else return 0
139 static route_map_result_t
route_match_tag(void *rule
,
140 const struct prefix
*prefix
,
141 route_map_object_t type
, void *object
)
144 struct nh_rmap_obj
*nh_data
;
146 if (type
== RMAP_ZEBRA
) {
150 if (nh_data
->tag
== *tag
)
156 /* Route map commands for tag matching */
157 static struct route_map_rule_cmd route_match_tag_cmd
= {
158 "tag", route_match_tag
, route_map_rule_tag_compile
,
159 route_map_rule_tag_free
,
163 /* `match interface IFNAME' */
164 /* Match function return 1 if match is success else return zero. */
165 static route_map_result_t
route_match_interface(void *rule
,
166 const struct prefix
*prefix
,
167 route_map_object_t type
,
170 struct nh_rmap_obj
*nh_data
;
174 if (type
== RMAP_ZEBRA
) {
175 if (strcasecmp(ifname
, "any") == 0)
178 if (!nh_data
|| !nh_data
->nexthop
)
180 ifindex
= ifname2ifindex(ifname
, nh_data
->vrf_id
);
183 if (nh_data
->nexthop
->ifindex
== ifindex
)
189 /* Route map `match interface' match statement. `arg' is IFNAME value */
190 static void *route_match_interface_compile(const char *arg
)
192 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
195 /* Free route map's compiled `match interface' value. */
196 static void route_match_interface_free(void *rule
)
198 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
201 static void show_vrf_proto_rm(struct vty
*vty
, struct zebra_vrf
*zvrf
,
206 vty_out(vty
, "Protocol : route-map\n");
207 vty_out(vty
, "------------------------\n");
209 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
210 if (PROTO_RM_NAME(zvrf
, af_type
, i
))
211 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
212 PROTO_RM_NAME(zvrf
, af_type
, i
));
214 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
217 if (PROTO_RM_NAME(zvrf
, af_type
, i
))
218 vty_out(vty
, "%-10s : %-10s\n", "any",
219 PROTO_RM_NAME(zvrf
, af_type
, i
));
221 vty_out(vty
, "%-10s : none\n", "any");
224 static void show_vrf_nht_rm(struct vty
*vty
, struct zebra_vrf
*zvrf
,
229 vty_out(vty
, "Protocol : route-map\n");
230 vty_out(vty
, "------------------------\n");
232 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
233 if (NHT_RM_NAME(zvrf
, af_type
, i
))
234 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
235 NHT_RM_NAME(zvrf
, af_type
, i
));
237 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
240 if (NHT_RM_NAME(zvrf
, af_type
, i
))
241 vty_out(vty
, "%-10s : %-10s\n", "any",
242 NHT_RM_NAME(zvrf
, af_type
, i
));
244 vty_out(vty
, "%-10s : none\n", "any");
247 static int show_proto_rm(struct vty
*vty
, int af_type
, const char *vrf_all
,
248 const char *vrf_name
)
250 struct zebra_vrf
*zvrf
;
255 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
256 zvrf
= (struct zebra_vrf
*)vrf
->info
;
259 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
260 show_vrf_proto_rm(vty
, zvrf
, af_type
);
263 vrf_id_t vrf_id
= VRF_DEFAULT
;
266 VRF_GET_ID(vrf_id
, vrf_name
, false);
268 zvrf
= zebra_vrf_lookup_by_id(vrf_id
);
272 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
273 show_vrf_proto_rm(vty
, zvrf
, af_type
);
279 static int show_nht_rm(struct vty
*vty
, int af_type
, const char *vrf_all
,
280 const char *vrf_name
)
282 struct zebra_vrf
*zvrf
;
287 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
288 zvrf
= (struct zebra_vrf
*)vrf
->info
;
292 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
293 show_vrf_nht_rm(vty
, zvrf
, af_type
);
296 vrf_id_t vrf_id
= VRF_DEFAULT
;
299 VRF_GET_ID(vrf_id
, vrf_name
, false);
301 zvrf
= zebra_vrf_lookup_by_id(vrf_id
);
305 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
306 show_vrf_nht_rm(vty
, zvrf
, af_type
);
312 /* Route map commands for interface matching */
313 struct route_map_rule_cmd route_match_interface_cmd
= {
314 "interface", route_match_interface
, route_match_interface_compile
,
315 route_match_interface_free
};
317 static int ip_protocol_rm_add(struct zebra_vrf
*zvrf
, const char *rmap
,
318 int rtype
, afi_t afi
, safi_t safi
)
320 struct route_table
*table
;
322 if (PROTO_RM_NAME(zvrf
, afi
, rtype
)) {
323 if (strcmp(PROTO_RM_NAME(zvrf
, afi
, rtype
), rmap
) == 0)
326 XFREE(MTYPE_ROUTE_MAP_NAME
, PROTO_RM_NAME(zvrf
, afi
, rtype
));
328 route_map_counter_decrement(PROTO_RM_MAP(zvrf
, afi
, rtype
));
329 PROTO_RM_NAME(zvrf
, afi
, rtype
) = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
330 PROTO_RM_MAP(zvrf
, afi
, rtype
) =
331 route_map_lookup_by_name(PROTO_RM_NAME(zvrf
, afi
, rtype
));
332 route_map_counter_increment(PROTO_RM_MAP(zvrf
, afi
, rtype
));
334 if (PROTO_RM_MAP(zvrf
, afi
, rtype
)) {
336 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
338 "%u: IPv4 Routemap config for protocol %d scheduling RIB processing",
339 zvrf
->vrf
->vrf_id
, rtype
);
340 /* Process routes of interested address-families. */
341 table
= zebra_vrf_table(afi
, safi
, zvrf
->vrf
->vrf_id
);
343 rib_update_table(table
, RIB_UPDATE_RMAP_CHANGE
);
349 static int ip_protocol_rm_del(struct zebra_vrf
*zvrf
, const char *rmap
,
350 int rtype
, afi_t afi
, safi_t safi
)
352 struct route_table
*table
;
354 if (!PROTO_RM_NAME(zvrf
, afi
, rtype
))
357 if (!rmap
|| strcmp(rmap
, PROTO_RM_NAME(zvrf
, afi
, rtype
)) == 0) {
359 route_map_counter_decrement(PROTO_RM_MAP(zvrf
, afi
, rtype
));
360 if (PROTO_RM_MAP(zvrf
, afi
, rtype
)) {
361 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
363 "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
364 zvrf
->vrf
->vrf_id
, rtype
);
365 PROTO_RM_MAP(zvrf
, afi
, rtype
) = NULL
;
367 /* Process routes of interested address-families. */
368 table
= zebra_vrf_table(afi
, safi
, zvrf
->vrf
->vrf_id
);
370 rib_update_table(table
, RIB_UPDATE_RMAP_CHANGE
);
372 XFREE(MTYPE_ROUTE_MAP_NAME
, PROTO_RM_NAME(zvrf
, afi
, rtype
));
377 static int ip_nht_rm_add(struct zebra_vrf
*zvrf
, const char *rmap
, int rtype
,
381 if (NHT_RM_NAME(zvrf
, afi
, rtype
)) {
382 if (strcmp(NHT_RM_NAME(zvrf
, afi
, rtype
), rmap
) == 0)
385 XFREE(MTYPE_ROUTE_MAP_NAME
, NHT_RM_NAME(zvrf
, afi
, rtype
));
387 route_map_counter_decrement(NHT_RM_MAP(zvrf
, afi
, rtype
));
388 NHT_RM_NAME(zvrf
, afi
, rtype
) = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
389 NHT_RM_MAP(zvrf
, afi
, rtype
) =
390 route_map_lookup_by_name(NHT_RM_NAME(zvrf
, afi
, rtype
));
391 route_map_counter_increment(NHT_RM_MAP(zvrf
, afi
, rtype
));
393 if (NHT_RM_MAP(zvrf
, afi
, rtype
))
394 zebra_evaluate_rnh(zvrf
, AFI_IP
, 1, RNH_NEXTHOP_TYPE
, NULL
);
399 static int ip_nht_rm_del(struct zebra_vrf
*zvrf
, const char *rmap
, int rtype
,
403 if (!NHT_RM_NAME(zvrf
, afi
, rtype
))
406 if (!rmap
|| strcmp(rmap
, NHT_RM_NAME(zvrf
, afi
, rtype
)) == 0) {
407 route_map_counter_decrement(NHT_RM_MAP(zvrf
, afi
, rtype
));
408 if (NHT_RM_MAP(zvrf
, afi
, rtype
)) {
409 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
411 "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
412 zvrf
->vrf
->vrf_id
, rtype
);
413 NHT_RM_MAP(zvrf
, afi
, rtype
) = NULL
;
415 zebra_evaluate_rnh(zvrf
, AFI_IP
, 1, RNH_NEXTHOP_TYPE
,
418 XFREE(MTYPE_ROUTE_MAP_NAME
, NHT_RM_NAME(zvrf
, afi
, rtype
));
423 DEFUN (match_ip_address_prefix_len
,
424 match_ip_address_prefix_len_cmd
,
425 "match ip address prefix-len (0-32)",
428 "Match prefix length of ip address\n"
429 "Match prefix length of ip address\n"
432 return zebra_route_match_add(vty
, "ip address prefix-len", argv
[4]->arg
,
433 RMAP_EVENT_MATCH_ADDED
);
436 DEFUN (no_match_ip_address_prefix_len
,
437 no_match_ip_address_prefix_len_cmd
,
438 "no match ip address prefix-len [(0-32)]",
442 "Match prefix length of ip address\n"
443 "Match prefix length of ip address\n"
446 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
447 return zebra_route_match_delete(vty
, "ip address prefix-len", plen
,
448 RMAP_EVENT_MATCH_DELETED
);
451 DEFUN (match_ipv6_address_prefix_len
,
452 match_ipv6_address_prefix_len_cmd
,
453 "match ipv6 address prefix-len (0-128)",
456 "Match prefix length of ipv6 address\n"
457 "Match prefix length of ipv6 address\n"
460 return zebra_route_match_add(vty
, "ipv6 address prefix-len",
461 argv
[4]->arg
, RMAP_EVENT_MATCH_ADDED
);
464 DEFUN (no_match_ipv6_address_prefix_len
,
465 no_match_ipv6_address_prefix_len_cmd
,
466 "no match ipv6 address prefix-len [(0-128)]",
470 "Match prefix length of ip address\n"
471 "Match prefix length of ip address\n"
474 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
475 return zebra_route_match_delete(vty
, "ipv6 address prefix-len", plen
,
476 RMAP_EVENT_MATCH_DELETED
);
479 DEFUN (match_ip_nexthop_prefix_len
,
480 match_ip_nexthop_prefix_len_cmd
,
481 "match ip next-hop prefix-len (0-32)",
484 "Match prefixlen of nexthop ip address\n"
485 "Match prefixlen of given nexthop\n"
488 return zebra_route_match_add(vty
, "ip next-hop prefix-len",
489 argv
[4]->arg
, RMAP_EVENT_MATCH_ADDED
);
492 DEFUN (no_match_ip_nexthop_prefix_len
,
493 no_match_ip_nexthop_prefix_len_cmd
,
494 "no match ip next-hop prefix-len [(0-32)]",
498 "Match prefixlen of nexthop ip address\n"
499 "Match prefix length of nexthop\n"
502 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
503 return zebra_route_match_delete(vty
, "ip next-hop prefix-len", plen
,
504 RMAP_EVENT_MATCH_DELETED
);
507 DEFUN (match_source_protocol
,
508 match_source_protocol_cmd
,
509 "match source-protocol <bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>",
511 "Match protocol via which the route was learnt\n"
522 "Routes from directly connected peer\n"
523 "Routes from system configuration\n"
524 "Routes from kernel\n"
525 "Statically configured routes\n"
528 char *proto
= argv
[2]->text
;
531 i
= proto_name2num(proto
);
533 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
534 return CMD_WARNING_CONFIG_FAILED
;
536 return zebra_route_match_add(vty
, "source-protocol", proto
,
537 RMAP_EVENT_MATCH_ADDED
);
540 DEFUN (no_match_source_protocol
,
541 no_match_source_protocol_cmd
,
542 "no match source-protocol [<bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>]",
545 "No match protocol via which the route was learnt\n"
556 "Routes from directly connected peer\n"
557 "Routes from system configuration\n"
558 "Routes from kernel\n"
559 "Statically configured routes\n"
562 char *proto
= (argc
== 4) ? argv
[3]->text
: NULL
;
563 return zebra_route_match_delete(vty
, "source-protocol", proto
,
564 RMAP_EVENT_MATCH_DELETED
);
567 DEFUN (match_source_instance
,
568 match_source_instance_cmd
,
569 "match source-instance (0-255)",
571 "Match the protocol's instance number\n"
572 "The instance number\n")
574 char *instance
= argv
[2]->arg
;
576 return zebra_route_match_add(vty
, "source-instance", instance
,
577 RMAP_EVENT_MATCH_ADDED
);
580 DEFUN (no_match_source_instance
,
581 no_match_source_instance_cmd
,
582 "no match source-instance [(0-255)]",
584 "Match the protocol's instance number\n"
585 "The instance number\n")
587 char *instance
= (argc
== 4) ? argv
[3]->arg
: NULL
;
589 return zebra_route_match_delete(vty
, "source-instance", instance
,
590 RMAP_EVENT_MATCH_ADDED
);
597 "set src <A.B.C.D|X:X::X:X>",
599 "src address for route\n"
601 "IPv6 src address\n")
605 struct interface
*pif
= NULL
;
610 if (inet_pton(AF_INET
, argv
[idx_ip
]->arg
, &src
.ipv4
) != 1) {
611 if (inet_pton(AF_INET6
, argv
[idx_ip
]->arg
, &src
.ipv6
) != 1) {
612 vty_out(vty
, "%% not a valid IPv4/v6 address\n");
613 return CMD_WARNING_CONFIG_FAILED
;
616 p
.family
= family
= AF_INET6
;
617 p
.u
.prefix6
= src
.ipv6
;
618 p
.prefixlen
= IPV6_MAX_BITLEN
;
620 p
.family
= family
= AF_INET
;
621 p
.u
.prefix4
= src
.ipv4
;
622 p
.prefixlen
= IPV4_MAX_BITLEN
;
625 if (!zebra_check_addr(&p
)) {
626 vty_out(vty
, "%% not a valid source IPv4/v6 address\n");
627 return CMD_WARNING_CONFIG_FAILED
;
630 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
631 if (family
== AF_INET
)
632 pif
= if_lookup_exact_address((void *)&src
.ipv4
,
633 AF_INET
, vrf
->vrf_id
);
634 else if (family
== AF_INET6
)
635 pif
= if_lookup_exact_address((void *)&src
.ipv6
,
636 AF_INET6
, vrf
->vrf_id
);
643 vty_out(vty
, "%% not a local address\n");
644 return CMD_WARNING_CONFIG_FAILED
;
647 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
648 return generic_set_add(vty
, index
, "src", argv
[idx_ip
]->arg
);
653 "no set src [<A.B.C.D|X:X::X:X>]",
656 "Source address for route\n"
660 char *ip
= (argc
== 4) ? argv
[3]->arg
: NULL
;
661 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
662 return generic_set_delete(vty
, index
, "src", ip
);
665 DEFUN (zebra_route_map_timer
,
666 zebra_route_map_timer_cmd
,
667 "zebra route-map delay-timer (0-600)",
669 "Set route-map parameters\n"
670 "Time to wait before route-map updates are processed\n"
671 "0 means event-driven updates are disabled\n")
674 uint32_t rmap_delay_timer
;
676 rmap_delay_timer
= strtoul(argv
[idx_number
]->arg
, NULL
, 10);
677 zebra_route_map_set_delay_timer(rmap_delay_timer
);
679 return (CMD_SUCCESS
);
682 DEFUN (no_zebra_route_map_timer
,
683 no_zebra_route_map_timer_cmd
,
684 "no zebra route-map delay-timer [(0-600)]",
687 "Set route-map parameters\n"
688 "Reset delay-timer to default value, 30 secs\n"
689 "0 means event-driven updates are disabled\n")
691 zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
);
693 return (CMD_SUCCESS
);
698 "ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
699 " $proto route-map ROUTE-MAP$rmap",
701 "Filter routing info exchanged between zebra and protocol\n"
702 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
703 "Specify route-map\n"
711 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
716 if (strcasecmp(proto
, "any") == 0)
717 rtype
= ZEBRA_ROUTE_MAX
;
719 rtype
= proto_name2num(proto
);
721 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
722 return CMD_WARNING_CONFIG_FAILED
;
725 ret
= ip_protocol_rm_add(zvrf
, rmap
, rtype
, AFI_IP
, SAFI_UNICAST
);
730 DEFPY (no_ip_protocol
,
732 "no ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
733 " $proto [route-map ROUTE-MAP$rmap]",
736 "Stop filtering routing info between zebra and protocol\n"
737 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
738 "Specify route-map\n"
745 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
750 if (strcasecmp(proto
, "any") == 0)
751 rtype
= ZEBRA_ROUTE_MAX
;
753 rtype
= proto_name2num(proto
);
755 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
756 return CMD_WARNING_CONFIG_FAILED
;
759 ret
= ip_protocol_rm_del(zvrf
, rmap
, rtype
, AFI_IP
, SAFI_UNICAST
);
764 DEFPY (show_ip_protocol
,
765 show_ip_protocol_cmd
,
766 "show ip protocol [vrf <NAME$vrf_name|all$vrf_all>]",
769 "IP protocol filtering status\n"
770 VRF_FULL_CMD_HELP_STR
)
772 int ret
= show_proto_rm(vty
, AFI_IP
, vrf_all
, vrf_name
);
777 DEFPY (ipv6_protocol
,
779 "ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
780 " $proto route-map ROUTE-MAP$rmap",
782 "Filter IPv6 routing info exchanged between zebra and protocol\n"
783 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
784 "Specify route-map\n"
792 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
797 if (strcasecmp(proto
, "any") == 0)
798 rtype
= ZEBRA_ROUTE_MAX
;
800 rtype
= proto_name2num(proto
);
802 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
803 return CMD_WARNING_CONFIG_FAILED
;
806 ret
= ip_protocol_rm_add(zvrf
, rmap
, rtype
, AFI_IP6
, SAFI_UNICAST
);
811 DEFPY (no_ipv6_protocol
,
812 no_ipv6_protocol_cmd
,
813 "no ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
814 " $proto [route-map ROUTE-MAP$rmap]",
817 "Stop filtering IPv6 routing info between zebra and protocol\n"
818 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
819 "Specify route-map\n"
826 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
831 if (strcasecmp(proto
, "any") == 0)
832 rtype
= ZEBRA_ROUTE_MAX
;
834 rtype
= proto_name2num(proto
);
836 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
837 return CMD_WARNING_CONFIG_FAILED
;
840 ret
= ip_protocol_rm_del(zvrf
, rmap
, rtype
, AFI_IP6
, SAFI_UNICAST
);
845 DEFPY (show_ipv6_protocol
,
846 show_ipv6_protocol_cmd
,
847 "show ipv6 protocol [vrf <NAME$vrf_name|all$vrf_all>]",
850 "IPv6 protocol filtering status\n"
851 VRF_FULL_CMD_HELP_STR
)
853 int ret
= show_proto_rm(vty
, AFI_IP6
, vrf_all
, vrf_name
);
858 DEFPY (ip_protocol_nht_rmap
,
859 ip_protocol_nht_rmap_cmd
,
860 "ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
861 " $proto route-map ROUTE-MAP$rmap",
863 "Filter Next Hop tracking route resolution\n"
864 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
865 "Specify route map\n"
874 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
879 if (strcasecmp(proto
, "any") == 0)
880 rtype
= ZEBRA_ROUTE_MAX
;
882 rtype
= proto_name2num(proto
);
884 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
885 return CMD_WARNING_CONFIG_FAILED
;
888 ret
= ip_nht_rm_add(zvrf
, rmap
, rtype
, AFI_IP
);
893 DEFPY (no_ip_protocol_nht_rmap
,
894 no_ip_protocol_nht_rmap_cmd
,
895 "no ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
896 " $proto route-map [ROUTE-MAP$rmap]",
899 "Filter Next Hop tracking route resolution\n"
900 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
901 "Specify route map\n"
908 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
913 if (strcasecmp(proto
, "any") == 0)
914 rtype
= ZEBRA_ROUTE_MAX
;
916 rtype
= proto_name2num(proto
);
918 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
919 return CMD_WARNING_CONFIG_FAILED
;
922 ret
= ip_nht_rm_del(zvrf
, rmap
, rtype
, AFI_IP
);
927 DEFPY (show_ip_protocol_nht
,
928 show_ip_protocol_nht_cmd
,
929 "show ip nht route-map [vrf <NAME$vrf_name|all$vrf_all>]",
932 "IP nexthop tracking table\n"
933 "IP Next Hop tracking filtering status\n"
934 VRF_FULL_CMD_HELP_STR
)
936 int ret
= show_nht_rm(vty
, AFI_IP
, vrf_all
, vrf_name
);
941 DEFPY (ipv6_protocol_nht_rmap
,
942 ipv6_protocol_nht_rmap_cmd
,
943 "ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
944 " $proto route-map ROUTE-MAP$rmap",
946 "Filter Next Hop tracking route resolution\n"
947 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
948 "Specify route map\n"
956 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
961 if (strcasecmp(proto
, "any") == 0)
962 rtype
= ZEBRA_ROUTE_MAX
;
964 rtype
= proto_name2num(proto
);
966 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
967 return CMD_WARNING_CONFIG_FAILED
;
970 ret
= ip_nht_rm_add(zvrf
, rmap
, rtype
, AFI_IP6
);
975 DEFPY (no_ipv6_protocol_nht_rmap
,
976 no_ipv6_protocol_nht_rmap_cmd
,
977 "no ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
978 " $proto [route-map ROUTE-MAP$rmap]",
981 "Filter Next Hop tracking route resolution\n"
982 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
983 "Specify route map\n"
990 ZEBRA_DECLVAR_CONTEXT(vrf
, zvrf
);
995 if (strcasecmp(proto
, "any") == 0)
996 rtype
= ZEBRA_ROUTE_MAX
;
998 rtype
= proto_name2num(proto
);
1000 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
1001 return CMD_WARNING_CONFIG_FAILED
;
1004 ret
= ip_nht_rm_del(zvrf
, rmap
, rtype
, AFI_IP6
);
1009 DEFPY (show_ipv6_protocol_nht
,
1010 show_ipv6_protocol_nht_cmd
,
1011 "show ipv6 nht route-map [vrf <NAME$vrf_name|all$vrf_all>]",
1014 "Next Hop filtering status\n"
1016 VRF_FULL_CMD_HELP_STR
)
1018 int ret
= show_nht_rm(vty
, AFI_IP6
, vrf_all
, vrf_name
);
1023 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
1025 /* `match ip next-hop IP_ACCESS_LIST' */
1027 /* Match function return 1 if match is success else return zero. */
1028 static route_map_result_t
route_match_ip_next_hop(void *rule
,
1029 const struct prefix
*prefix
,
1030 route_map_object_t type
,
1033 struct access_list
*alist
;
1034 struct nh_rmap_obj
*nh_data
;
1035 struct prefix_ipv4 p
;
1037 if (type
== RMAP_ZEBRA
) {
1040 return RMAP_DENYMATCH
;
1042 switch (nh_data
->nexthop
->type
) {
1043 case NEXTHOP_TYPE_IFINDEX
:
1044 /* Interface routes can't match ip next-hop */
1045 return RMAP_NOMATCH
;
1046 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1047 case NEXTHOP_TYPE_IPV4
:
1049 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
1050 p
.prefixlen
= IPV4_MAX_BITLEN
;
1053 return RMAP_NOMATCH
;
1055 alist
= access_list_lookup(AFI_IP
, (char *)rule
);
1057 return RMAP_NOMATCH
;
1059 return (access_list_apply(alist
, &p
) == FILTER_DENY
1063 return RMAP_NOMATCH
;
1066 /* Route map `ip next-hop' match statement. `arg' should be
1067 access-list name. */
1068 static void *route_match_ip_next_hop_compile(const char *arg
)
1070 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1073 /* Free route map's compiled `. */
1074 static void route_match_ip_next_hop_free(void *rule
)
1076 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1079 /* Route map commands for ip next-hop matching. */
1080 static struct route_map_rule_cmd route_match_ip_next_hop_cmd
= {
1081 "ip next-hop", route_match_ip_next_hop
, route_match_ip_next_hop_compile
,
1082 route_match_ip_next_hop_free
};
1084 /* `match ip next-hop prefix-list PREFIX_LIST' */
1086 static route_map_result_t
1087 route_match_ip_next_hop_prefix_list(void *rule
, const struct prefix
*prefix
,
1088 route_map_object_t type
, void *object
)
1090 struct prefix_list
*plist
;
1091 struct nh_rmap_obj
*nh_data
;
1092 struct prefix_ipv4 p
;
1094 if (type
== RMAP_ZEBRA
) {
1095 nh_data
= (struct nh_rmap_obj
*)object
;
1097 return RMAP_DENYMATCH
;
1099 switch (nh_data
->nexthop
->type
) {
1100 case NEXTHOP_TYPE_IFINDEX
:
1101 /* Interface routes can't match ip next-hop */
1102 return RMAP_NOMATCH
;
1103 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1104 case NEXTHOP_TYPE_IPV4
:
1106 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
1107 p
.prefixlen
= IPV4_MAX_BITLEN
;
1110 return RMAP_NOMATCH
;
1112 plist
= prefix_list_lookup(AFI_IP
, (char *)rule
);
1114 return RMAP_NOMATCH
;
1116 return (prefix_list_apply(plist
, &p
) == PREFIX_DENY
1120 return RMAP_NOMATCH
;
1123 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg
)
1125 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1128 static void route_match_ip_next_hop_prefix_list_free(void *rule
)
1130 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1133 static struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd
= {
1134 "ip next-hop prefix-list", route_match_ip_next_hop_prefix_list
,
1135 route_match_ip_next_hop_prefix_list_compile
,
1136 route_match_ip_next_hop_prefix_list_free
};
1138 /* `match ip address IP_ACCESS_LIST' */
1140 /* Match function should return 1 if match is success else return
1142 static route_map_result_t
route_match_address(afi_t afi
, void *rule
,
1143 const struct prefix
*prefix
,
1144 route_map_object_t type
,
1147 struct access_list
*alist
;
1149 if (type
== RMAP_ZEBRA
) {
1150 alist
= access_list_lookup(afi
, (char *)rule
);
1152 return RMAP_NOMATCH
;
1154 return (access_list_apply(alist
, prefix
) == FILTER_DENY
1158 return RMAP_NOMATCH
;
1161 static route_map_result_t
route_match_ip_address(void *rule
,
1162 const struct prefix
*prefix
,
1163 route_map_object_t type
,
1166 return route_match_address(AFI_IP
, rule
, prefix
, type
, object
);
1169 static route_map_result_t
route_match_ipv6_address(void *rule
,
1170 const struct prefix
*prefix
,
1171 route_map_object_t type
,
1175 return route_match_address(AFI_IP6
, rule
, prefix
, type
, object
);
1178 /* Route map `ip address' match statement. `arg' should be
1179 access-list name. */
1180 static void *route_match_address_compile(const char *arg
)
1182 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1185 /* Free route map's compiled `ip address' value. */
1186 static void route_match_address_free(void *rule
)
1188 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1191 /* Route map commands for ip address matching. */
1192 static struct route_map_rule_cmd route_match_ip_address_cmd
= {
1193 "ip address", route_match_ip_address
, route_match_address_compile
,
1194 route_match_address_free
};
1196 /* Route map commands for ipv6 address matching. */
1197 static struct route_map_rule_cmd route_match_ipv6_address_cmd
= {
1198 "ipv6 address", route_match_ipv6_address
, route_match_address_compile
,
1199 route_match_address_free
};
1201 /* `match ip address prefix-list PREFIX_LIST' */
1203 static route_map_result_t
1204 route_match_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1205 route_map_object_t type
, void *object
, afi_t afi
)
1207 struct prefix_list
*plist
;
1209 if (type
== RMAP_ZEBRA
) {
1210 plist
= prefix_list_lookup(afi
, (char *)rule
);
1212 return RMAP_NOMATCH
;
1214 return (prefix_list_apply(plist
, prefix
) == PREFIX_DENY
1218 return RMAP_NOMATCH
;
1221 static route_map_result_t
1222 route_match_ip_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1223 route_map_object_t type
, void *object
)
1225 return (route_match_address_prefix_list(rule
, prefix
, type
, object
,
1229 static void *route_match_address_prefix_list_compile(const char *arg
)
1231 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1234 static void route_match_address_prefix_list_free(void *rule
)
1236 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1239 static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd
= {
1240 "ip address prefix-list", route_match_ip_address_prefix_list
,
1241 route_match_address_prefix_list_compile
,
1242 route_match_address_prefix_list_free
};
1244 static route_map_result_t
1245 route_match_ipv6_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1246 route_map_object_t type
, void *object
)
1248 return (route_match_address_prefix_list(rule
, prefix
, type
, object
,
1252 static struct route_map_rule_cmd route_match_ipv6_address_prefix_list_cmd
= {
1253 "ipv6 address prefix-list", route_match_ipv6_address_prefix_list
,
1254 route_match_address_prefix_list_compile
,
1255 route_match_address_prefix_list_free
};
1257 /* `match ipv6 next-hop type <TYPE>' */
1259 static route_map_result_t
1260 route_match_ipv6_next_hop_type(void *rule
, const struct prefix
*prefix
,
1261 route_map_object_t type
, void *object
)
1263 struct nh_rmap_obj
*nh_data
;
1265 if (type
== RMAP_ZEBRA
&& prefix
->family
== AF_INET6
) {
1266 nh_data
= (struct nh_rmap_obj
*)object
;
1268 return RMAP_DENYMATCH
;
1270 if (nh_data
->nexthop
->type
== NEXTHOP_TYPE_BLACKHOLE
)
1273 return RMAP_NOMATCH
;
1276 static void *route_match_ipv6_next_hop_type_compile(const char *arg
)
1278 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1281 static void route_match_ipv6_next_hop_type_free(void *rule
)
1283 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1286 struct route_map_rule_cmd route_match_ipv6_next_hop_type_cmd
= {
1287 "ipv6 next-hop type", route_match_ipv6_next_hop_type
,
1288 route_match_ipv6_next_hop_type_compile
,
1289 route_match_ipv6_next_hop_type_free
};
1291 /* `match ip address prefix-len PREFIXLEN' */
1293 static route_map_result_t
1294 route_match_address_prefix_len(void *rule
, const struct prefix
*prefix
,
1295 route_map_object_t type
, void *object
)
1297 uint32_t *prefixlen
= (uint32_t *)rule
;
1299 if (type
== RMAP_ZEBRA
) {
1300 return ((prefix
->prefixlen
== *prefixlen
) ? RMAP_MATCH
1303 return RMAP_NOMATCH
;
1306 static void *route_match_address_prefix_len_compile(const char *arg
)
1308 uint32_t *prefix_len
;
1309 char *endptr
= NULL
;
1310 unsigned long tmpval
;
1312 /* prefix len value shoud be integer. */
1313 if (!all_digit(arg
))
1317 tmpval
= strtoul(arg
, &endptr
, 10);
1318 if (*endptr
!= '\0' || errno
|| tmpval
> UINT32_MAX
)
1321 prefix_len
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1323 *prefix_len
= tmpval
;
1327 static void route_match_address_prefix_len_free(void *rule
)
1329 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1332 static struct route_map_rule_cmd route_match_ip_address_prefix_len_cmd
= {
1333 "ip address prefix-len", route_match_address_prefix_len
,
1334 route_match_address_prefix_len_compile
,
1335 route_match_address_prefix_len_free
};
1337 static struct route_map_rule_cmd route_match_ipv6_address_prefix_len_cmd
= {
1338 "ipv6 address prefix-len", route_match_address_prefix_len
,
1339 route_match_address_prefix_len_compile
,
1340 route_match_address_prefix_len_free
};
1342 /* `match ip nexthop prefix-len PREFIXLEN' */
1344 static route_map_result_t
1345 route_match_ip_nexthop_prefix_len(void *rule
, const struct prefix
*prefix
,
1346 route_map_object_t type
, void *object
)
1348 uint32_t *prefixlen
= (uint32_t *)rule
;
1349 struct nh_rmap_obj
*nh_data
;
1350 struct prefix_ipv4 p
;
1352 if (type
== RMAP_ZEBRA
) {
1353 nh_data
= (struct nh_rmap_obj
*)object
;
1354 if (!nh_data
|| !nh_data
->nexthop
)
1355 return RMAP_DENYMATCH
;
1357 switch (nh_data
->nexthop
->type
) {
1358 case NEXTHOP_TYPE_IFINDEX
:
1359 /* Interface routes can't match ip next-hop */
1360 return RMAP_NOMATCH
;
1361 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1362 case NEXTHOP_TYPE_IPV4
:
1364 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
1365 p
.prefixlen
= IPV4_MAX_BITLEN
;
1368 return RMAP_NOMATCH
;
1370 return ((p
.prefixlen
== *prefixlen
) ? RMAP_MATCH
1373 return RMAP_NOMATCH
;
1376 static struct route_map_rule_cmd route_match_ip_nexthop_prefix_len_cmd
= {
1377 "ip next-hop prefix-len", route_match_ip_nexthop_prefix_len
,
1378 route_match_address_prefix_len_compile
, /* reuse */
1379 route_match_address_prefix_len_free
/* reuse */
1382 /* `match ip next-hop type <blackhole>' */
1384 static route_map_result_t
1385 route_match_ip_next_hop_type(void *rule
, const struct prefix
*prefix
,
1386 route_map_object_t type
, void *object
)
1388 struct nh_rmap_obj
*nh_data
;
1390 if (type
== RMAP_ZEBRA
&& prefix
->family
== AF_INET
) {
1391 nh_data
= (struct nh_rmap_obj
*)object
;
1393 return RMAP_DENYMATCH
;
1395 if (nh_data
->nexthop
->type
== NEXTHOP_TYPE_BLACKHOLE
)
1398 return RMAP_NOMATCH
;
1401 static void *route_match_ip_next_hop_type_compile(const char *arg
)
1403 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1406 static void route_match_ip_next_hop_type_free(void *rule
)
1408 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1411 static struct route_map_rule_cmd route_match_ip_next_hop_type_cmd
= {
1412 "ip next-hop type", route_match_ip_next_hop_type
,
1413 route_match_ip_next_hop_type_compile
,
1414 route_match_ip_next_hop_type_free
};
1416 /* `match source-protocol PROTOCOL' */
1418 static route_map_result_t
route_match_source_protocol(void *rule
,
1419 const struct prefix
*p
,
1420 route_map_object_t type
,
1423 uint32_t *rib_type
= (uint32_t *)rule
;
1424 struct nh_rmap_obj
*nh_data
;
1426 if (type
== RMAP_ZEBRA
) {
1427 nh_data
= (struct nh_rmap_obj
*)object
;
1429 return RMAP_DENYMATCH
;
1431 return ((nh_data
->source_protocol
== *rib_type
) ? RMAP_MATCH
1434 return RMAP_NOMATCH
;
1437 static void *route_match_source_protocol_compile(const char *arg
)
1442 i
= proto_name2num(arg
);
1443 rib_type
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1450 static void route_match_source_protocol_free(void *rule
)
1452 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1455 static struct route_map_rule_cmd route_match_source_protocol_cmd
= {
1456 "source-protocol", route_match_source_protocol
,
1457 route_match_source_protocol_compile
, route_match_source_protocol_free
};
1459 /* `source-instance` */
1460 static route_map_result_t
route_match_source_instance(void *rule
,
1461 const struct prefix
*p
,
1462 route_map_object_t type
,
1465 uint8_t *instance
= (uint8_t *)rule
;
1466 struct nh_rmap_obj
*nh_data
;
1468 if (type
!= RMAP_ZEBRA
)
1469 return RMAP_NOMATCH
;
1471 nh_data
= (struct nh_rmap_obj
*)object
;
1473 return RMAP_DENYMATCH
;
1475 return (nh_data
->instance
== *instance
) ? RMAP_MATCH
: RMAP_NOMATCH
;
1478 static void *route_match_source_instance_compile(const char *arg
)
1484 instance
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint8_t));
1491 static void route_match_source_instance_free(void *rule
)
1493 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1496 static struct route_map_rule_cmd route_match_source_instance_cmd
= {
1497 "source-instance", route_match_source_instance
,
1498 route_match_source_instance_compile
, route_match_source_instance_free
};
1500 /* `set src A.B.C.D' */
1503 static route_map_result_t
route_set_src(void *rule
, const struct prefix
*prefix
,
1504 route_map_object_t type
, void *object
)
1506 struct nh_rmap_obj
*nh_data
;
1508 if (type
== RMAP_ZEBRA
) {
1509 nh_data
= (struct nh_rmap_obj
*)object
;
1510 nh_data
->nexthop
->rmap_src
= *(union g_addr
*)rule
;
1515 /* set src compilation. */
1516 static void *route_set_src_compile(const char *arg
)
1518 union g_addr src
, *psrc
;
1520 if ((inet_pton(AF_INET6
, arg
, &src
.ipv6
) == 1)
1521 || (inet_pton(AF_INET
, arg
, &src
.ipv4
) == 1)) {
1522 psrc
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(union g_addr
));
1529 /* Free route map's compiled `set src' value. */
1530 static void route_set_src_free(void *rule
)
1532 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1535 /* Set src rule structure. */
1536 static struct route_map_rule_cmd route_set_src_cmd
= {
1537 "src", route_set_src
, route_set_src_compile
, route_set_src_free
,
1540 /* The function checks if the changed routemap specified by parameter rmap
1541 * matches the configured protocol routemaps in proto_rm table. If there is
1542 * a match then rib_update_table() to process the routes.
1544 static void zebra_rib_table_rm_update(const char *rmap
)
1547 struct route_table
*table
;
1548 struct vrf
*vrf
= NULL
;
1549 struct zebra_vrf
*zvrf
= NULL
;
1553 struct route_map
*old
= NULL
;
1555 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
1559 for (i
= 0; i
<= ZEBRA_ROUTE_MAX
; i
++) {
1560 rmap_name
= PROTO_RM_NAME(zvrf
, AFI_IP
, i
);
1561 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1562 if (IS_ZEBRA_DEBUG_EVENT
)
1564 "%s : AFI_IP rmap %s, route type %s",
1566 zebra_route_string(i
));
1568 old
= PROTO_RM_MAP(zvrf
, AFI_IP
, i
);
1570 PROTO_RM_MAP(zvrf
, AFI_IP
, i
) =
1571 route_map_lookup_by_name(rmap_name
);
1572 /* old is NULL. i.e Route map creation event.
1573 * So update applied_counter.
1574 * If Old is not NULL, i.e It may be routemap
1575 * updation or deletion.
1576 * So no need to update the counter.
1579 route_map_counter_increment(
1580 PROTO_RM_MAP(zvrf
, AFI_IP
, i
));
1581 /* There is single rib table for all protocols
1584 table
= zvrf
->table
[AFI_IP
]
1591 RIB_UPDATE_RMAP_CHANGE
);
1595 rmap_name
= PROTO_RM_NAME(zvrf
, AFI_IP6
, i
);
1596 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1597 if (IS_ZEBRA_DEBUG_EVENT
)
1599 "%s : AFI_IP6 rmap %s, route type %s",
1601 zebra_route_string(i
));
1603 old
= PROTO_RM_MAP(zvrf
, AFI_IP6
, i
);
1605 PROTO_RM_MAP(zvrf
, AFI_IP6
, i
) =
1606 route_map_lookup_by_name(rmap_name
);
1608 route_map_counter_increment(
1609 PROTO_RM_MAP(zvrf
, AFI_IP6
, i
));
1610 /* There is single rib table for all protocols
1612 if (afi_ipv6
== 0) {
1613 table
= zvrf
->table
[AFI_IP6
]
1620 RIB_UPDATE_RMAP_CHANGE
);
1628 /* The function checks if the changed routemap specified by parameter rmap
1629 * matches the configured protocol routemaps in nht_rm table. If there is
1630 * a match then zebra_evaluate_rnh() to process the nexthops.
1632 static void zebra_nht_rm_update(const char *rmap
)
1635 struct route_table
*table
;
1636 struct vrf
*vrf
= NULL
;
1637 struct zebra_vrf
*zvrf
= NULL
;
1641 struct route_map
*old
= NULL
;
1643 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
1647 for (i
= 0; i
<= ZEBRA_ROUTE_MAX
; i
++) {
1648 rmap_name
= NHT_RM_NAME(zvrf
, AFI_IP
, i
);
1649 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1650 if (IS_ZEBRA_DEBUG_EVENT
)
1652 "%s : AFI_IP rmap %s, route type %s",
1654 zebra_route_string(i
));
1656 old
= NHT_RM_MAP(zvrf
, AFI_IP
, i
);
1658 NHT_RM_MAP(zvrf
, AFI_IP
, i
) =
1659 route_map_lookup_by_name(rmap_name
);
1661 route_map_counter_increment(
1662 NHT_RM_MAP(zvrf
, AFI_IP
, i
));
1663 /* There is single rib table for all protocols
1666 table
= zvrf
->table
[AFI_IP
]
1674 RNH_NEXTHOP_TYPE
, NULL
);
1679 rmap_name
= NHT_RM_NAME(zvrf
, AFI_IP6
, i
);
1680 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1681 if (IS_ZEBRA_DEBUG_EVENT
)
1683 "%s : AFI_IP6 rmap %s, route type %s",
1685 zebra_route_string(i
));
1687 old
= NHT_RM_MAP(zvrf
, AFI_IP6
, i
);
1689 NHT_RM_MAP(zvrf
, AFI_IP6
, i
) =
1690 route_map_lookup_by_name(rmap_name
);
1692 route_map_counter_increment(
1693 NHT_RM_MAP(zvrf
, AFI_IP6
, i
));
1694 /* There is single rib table for all protocols
1696 if (afi_ipv6
== 0) {
1697 table
= zvrf
->table
[AFI_IP6
]
1705 RNH_NEXTHOP_TYPE
, NULL
);
1713 static void zebra_route_map_process_update_cb(char *rmap_name
)
1715 if (IS_ZEBRA_DEBUG_EVENT
)
1716 zlog_debug("Event handler for route-map: %s",
1718 zebra_import_table_rm_update(rmap_name
);
1719 zebra_rib_table_rm_update(rmap_name
);
1720 zebra_nht_rm_update(rmap_name
);
1723 static int zebra_route_map_update_timer(struct thread
*thread
)
1725 zebra_t_rmap_update
= NULL
;
1727 if (IS_ZEBRA_DEBUG_EVENT
)
1728 zlog_debug("Event driven route-map update triggered");
1730 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
1732 "%u: Routemap update-timer fired, scheduling RIB processing",
1735 route_map_walk_update_list(zebra_route_map_process_update_cb
);
1738 * This code needs to be updated to be:
1739 * 1) VRF Aware <sigh>
1740 * 2) Route-map aware
1745 static void zebra_route_map_set_delay_timer(uint32_t value
)
1747 zebra_rmap_update_timer
= value
;
1748 if (!value
&& zebra_t_rmap_update
) {
1749 /* Event driven route map updates is being disabled */
1750 /* But there's a pending timer. Fire it off now */
1751 thread_cancel(zebra_t_rmap_update
);
1752 zebra_route_map_update_timer(zebra_t_rmap_update
);
1756 void zebra_route_map_write_delay_timer(struct vty
*vty
)
1758 if (vty
&& (zebra_rmap_update_timer
!= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
))
1759 vty_out(vty
, "zebra route-map delay-timer %d\n",
1760 zebra_rmap_update_timer
);
1765 zebra_route_map_check(int family
, int rib_type
, uint8_t instance
,
1766 const struct prefix
*p
, struct nexthop
*nexthop
,
1767 struct zebra_vrf
*zvrf
, route_tag_t tag
)
1769 struct route_map
*rmap
= NULL
;
1770 route_map_result_t ret
= RMAP_MATCH
;
1771 struct nh_rmap_obj nh_obj
;
1773 nh_obj
.nexthop
= nexthop
;
1774 nh_obj
.vrf_id
= nexthop
->vrf_id
;
1775 nh_obj
.source_protocol
= rib_type
;
1776 nh_obj
.instance
= instance
;
1780 if (rib_type
>= 0 && rib_type
< ZEBRA_ROUTE_MAX
)
1781 rmap
= PROTO_RM_MAP(zvrf
, family
, rib_type
);
1782 if (!rmap
&& PROTO_RM_NAME(zvrf
, family
, ZEBRA_ROUTE_MAX
))
1783 rmap
= PROTO_RM_MAP(zvrf
, family
, ZEBRA_ROUTE_MAX
);
1785 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1791 char *zebra_get_import_table_route_map(afi_t afi
, uint32_t table
)
1793 return zebra_import_table_routemap
[afi
][table
];
1796 void zebra_add_import_table_route_map(afi_t afi
, const char *rmap_name
,
1799 zebra_import_table_routemap
[afi
][table
] =
1800 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1803 void zebra_del_import_table_route_map(afi_t afi
, uint32_t table
)
1805 XFREE(MTYPE_ROUTE_MAP_NAME
, zebra_import_table_routemap
[afi
][table
]);
1809 zebra_import_table_route_map_check(int family
, int re_type
, uint8_t instance
,
1810 const struct prefix
*p
,
1811 struct nexthop
*nexthop
,
1812 vrf_id_t vrf_id
, route_tag_t tag
,
1813 const char *rmap_name
)
1815 struct route_map
*rmap
= NULL
;
1816 route_map_result_t ret
= RMAP_DENYMATCH
;
1817 struct nh_rmap_obj nh_obj
;
1819 nh_obj
.nexthop
= nexthop
;
1820 nh_obj
.vrf_id
= vrf_id
;
1821 nh_obj
.source_protocol
= re_type
;
1822 nh_obj
.instance
= instance
;
1826 if (re_type
>= 0 && re_type
< ZEBRA_ROUTE_MAX
)
1827 rmap
= route_map_lookup_by_name(rmap_name
);
1829 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1835 route_map_result_t
zebra_nht_route_map_check(afi_t afi
, int client_proto
,
1836 const struct prefix
*p
,
1837 struct zebra_vrf
*zvrf
,
1838 struct route_entry
*re
,
1839 struct nexthop
*nexthop
)
1841 struct route_map
*rmap
= NULL
;
1842 route_map_result_t ret
= RMAP_MATCH
;
1843 struct nh_rmap_obj nh_obj
;
1845 nh_obj
.nexthop
= nexthop
;
1846 nh_obj
.vrf_id
= nexthop
->vrf_id
;
1847 nh_obj
.source_protocol
= re
->type
;
1848 nh_obj
.instance
= re
->instance
;
1849 nh_obj
.metric
= re
->metric
;
1850 nh_obj
.tag
= re
->tag
;
1852 if (client_proto
>= 0 && client_proto
< ZEBRA_ROUTE_MAX
)
1853 rmap
= NHT_RM_MAP(zvrf
, afi
, client_proto
);
1854 if (!rmap
&& NHT_RM_MAP(zvrf
, afi
, ZEBRA_ROUTE_MAX
))
1855 rmap
= NHT_RM_MAP(zvrf
, afi
, ZEBRA_ROUTE_MAX
);
1857 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1862 static void zebra_route_map_mark_update(const char *rmap_name
)
1864 /* rmap_update_timer of 0 means don't do route updates */
1865 if (zebra_rmap_update_timer
&& !zebra_t_rmap_update
) {
1866 zebra_t_rmap_update
= NULL
;
1867 thread_add_timer(zrouter
.master
, zebra_route_map_update_timer
,
1868 NULL
, zebra_rmap_update_timer
,
1869 &zebra_t_rmap_update
);
1873 static void zebra_route_map_add(const char *rmap_name
)
1875 if (route_map_mark_updated(rmap_name
) == 0)
1876 zebra_route_map_mark_update(rmap_name
);
1878 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1881 static void zebra_route_map_delete(const char *rmap_name
)
1883 if (route_map_mark_updated(rmap_name
) == 0)
1884 zebra_route_map_mark_update(rmap_name
);
1886 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_DELETED
);
1889 static void zebra_route_map_event(const char *rmap_name
)
1891 if (route_map_mark_updated(rmap_name
) == 0)
1892 zebra_route_map_mark_update(rmap_name
);
1894 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1897 /* ip protocol configuration write function */
1898 void zebra_routemap_config_write_protocol(struct vty
*vty
,
1899 struct zebra_vrf
*zvrf
)
1904 memset(space
, 0, sizeof(space
));
1906 if (zvrf_id(zvrf
) != VRF_DEFAULT
)
1907 sprintf(space
, "%s", " ");
1909 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
1910 if (PROTO_RM_NAME(zvrf
, AFI_IP
, i
))
1911 vty_out(vty
, "%sip protocol %s route-map %s\n", space
,
1912 zebra_route_string(i
),
1913 PROTO_RM_NAME(zvrf
, AFI_IP
, i
));
1915 if (PROTO_RM_NAME(zvrf
, AFI_IP6
, i
))
1916 vty_out(vty
, "%sipv6 protocol %s route-map %s\n", space
,
1917 zebra_route_string(i
),
1918 PROTO_RM_NAME(zvrf
, AFI_IP6
, i
));
1920 if (NHT_RM_NAME(zvrf
, AFI_IP
, i
))
1921 vty_out(vty
, "%sip nht %s route-map %s\n", space
,
1922 zebra_route_string(i
),
1923 NHT_RM_NAME(zvrf
, AFI_IP
, i
));
1925 if (NHT_RM_NAME(zvrf
, AFI_IP6
, i
))
1926 vty_out(vty
, "%sipv6 nht %s route-map %s\n", space
,
1927 zebra_route_string(i
),
1928 NHT_RM_NAME(zvrf
, AFI_IP6
, i
));
1931 if (PROTO_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
))
1932 vty_out(vty
, "%sip protocol %s route-map %s\n", space
, "any",
1933 PROTO_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
));
1935 if (PROTO_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
))
1936 vty_out(vty
, "%sipv6 protocol %s route-map %s\n", space
, "any",
1937 PROTO_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
));
1939 if (NHT_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
))
1940 vty_out(vty
, "%sip nht %s route-map %s\n", space
, "any",
1941 NHT_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
));
1943 if (NHT_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
))
1944 vty_out(vty
, "%sipv6 nht %s route-map %s\n", space
, "any",
1945 NHT_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
));
1947 if (zebra_rmap_update_timer
!= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
)
1948 vty_out(vty
, "zebra route-map delay-timer %d\n",
1949 zebra_rmap_update_timer
);
1952 void zebra_route_map_init(void)
1954 install_element(CONFIG_NODE
, &ip_protocol_cmd
);
1955 install_element(CONFIG_NODE
, &no_ip_protocol_cmd
);
1956 install_element(VRF_NODE
, &ip_protocol_cmd
);
1957 install_element(VRF_NODE
, &no_ip_protocol_cmd
);
1958 install_element(VIEW_NODE
, &show_ip_protocol_cmd
);
1959 install_element(CONFIG_NODE
, &ipv6_protocol_cmd
);
1960 install_element(CONFIG_NODE
, &no_ipv6_protocol_cmd
);
1961 install_element(VRF_NODE
, &ipv6_protocol_cmd
);
1962 install_element(VRF_NODE
, &no_ipv6_protocol_cmd
);
1963 install_element(VIEW_NODE
, &show_ipv6_protocol_cmd
);
1964 install_element(CONFIG_NODE
, &ip_protocol_nht_rmap_cmd
);
1965 install_element(CONFIG_NODE
, &no_ip_protocol_nht_rmap_cmd
);
1966 install_element(VRF_NODE
, &ip_protocol_nht_rmap_cmd
);
1967 install_element(VRF_NODE
, &no_ip_protocol_nht_rmap_cmd
);
1968 install_element(VIEW_NODE
, &show_ip_protocol_nht_cmd
);
1969 install_element(CONFIG_NODE
, &ipv6_protocol_nht_rmap_cmd
);
1970 install_element(CONFIG_NODE
, &no_ipv6_protocol_nht_rmap_cmd
);
1971 install_element(VRF_NODE
, &ipv6_protocol_nht_rmap_cmd
);
1972 install_element(VRF_NODE
, &no_ipv6_protocol_nht_rmap_cmd
);
1973 install_element(VIEW_NODE
, &show_ipv6_protocol_nht_cmd
);
1974 install_element(CONFIG_NODE
, &zebra_route_map_timer_cmd
);
1975 install_element(CONFIG_NODE
, &no_zebra_route_map_timer_cmd
);
1979 route_map_add_hook(zebra_route_map_add
);
1980 route_map_delete_hook(zebra_route_map_delete
);
1981 route_map_event_hook(zebra_route_map_event
);
1983 route_map_match_interface_hook(generic_match_add
);
1984 route_map_no_match_interface_hook(generic_match_delete
);
1986 route_map_match_ip_address_hook(generic_match_add
);
1987 route_map_no_match_ip_address_hook(generic_match_delete
);
1989 route_map_match_ip_address_prefix_list_hook(generic_match_add
);
1990 route_map_no_match_ip_address_prefix_list_hook(generic_match_delete
);
1992 route_map_match_ip_next_hop_hook(generic_match_add
);
1993 route_map_no_match_ip_next_hop_hook(generic_match_delete
);
1995 route_map_match_ip_next_hop_prefix_list_hook(generic_match_add
);
1996 route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete
);
1998 route_map_match_ip_next_hop_type_hook(generic_match_add
);
1999 route_map_no_match_ip_next_hop_type_hook(generic_match_delete
);
2001 route_map_match_tag_hook(generic_match_add
);
2002 route_map_no_match_tag_hook(generic_match_delete
);
2004 route_map_match_ipv6_address_hook(generic_match_add
);
2005 route_map_no_match_ipv6_address_hook(generic_match_delete
);
2007 route_map_match_ipv6_address_prefix_list_hook(generic_match_add
);
2008 route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete
);
2010 route_map_match_ipv6_next_hop_type_hook(generic_match_add
);
2011 route_map_no_match_ipv6_next_hop_type_hook(generic_match_delete
);
2013 route_map_install_match(&route_match_tag_cmd
);
2014 route_map_install_match(&route_match_interface_cmd
);
2015 route_map_install_match(&route_match_ip_next_hop_cmd
);
2016 route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd
);
2017 route_map_install_match(&route_match_ip_address_cmd
);
2018 route_map_install_match(&route_match_ipv6_address_cmd
);
2019 route_map_install_match(&route_match_ip_address_prefix_list_cmd
);
2020 route_map_install_match(&route_match_ipv6_address_prefix_list_cmd
);
2021 route_map_install_match(&route_match_ip_address_prefix_len_cmd
);
2022 route_map_install_match(&route_match_ipv6_address_prefix_len_cmd
);
2023 route_map_install_match(&route_match_ip_nexthop_prefix_len_cmd
);
2024 route_map_install_match(&route_match_ip_next_hop_type_cmd
);
2025 route_map_install_match(&route_match_ipv6_next_hop_type_cmd
);
2026 route_map_install_match(&route_match_source_protocol_cmd
);
2027 route_map_install_match(&route_match_source_instance_cmd
);
2030 route_map_install_set(&route_set_src_cmd
);
2032 install_element(RMAP_NODE
, &match_ip_nexthop_prefix_len_cmd
);
2033 install_element(RMAP_NODE
, &no_match_ip_nexthop_prefix_len_cmd
);
2034 install_element(RMAP_NODE
, &match_ip_address_prefix_len_cmd
);
2035 install_element(RMAP_NODE
, &match_ipv6_address_prefix_len_cmd
);
2036 install_element(RMAP_NODE
, &no_match_ipv6_address_prefix_len_cmd
);
2037 install_element(RMAP_NODE
, &no_match_ip_address_prefix_len_cmd
);
2038 install_element(RMAP_NODE
, &match_source_protocol_cmd
);
2039 install_element(RMAP_NODE
, &no_match_source_protocol_cmd
);
2040 install_element(RMAP_NODE
, &match_source_instance_cmd
);
2041 install_element(RMAP_NODE
, &no_match_source_instance_cmd
);
2044 install_element(RMAP_NODE
, &set_src_cmd
);
2045 install_element(RMAP_NODE
, &no_set_src_cmd
);