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/zserv.h"
37 #include "zebra/redistribute.h"
38 #include "zebra/debug.h"
39 #include "zebra/zebra_rnh.h"
40 #include "zebra/zebra_routemap.h"
42 static uint32_t zebra_rmap_update_timer
= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
;
43 static struct thread
*zebra_t_rmap_update
= NULL
;
44 char *proto_rm
[AFI_MAX
][ZEBRA_ROUTE_MAX
+ 1]; /* "any" == ZEBRA_ROUTE_MAX */
45 /* NH Tracking route map */
46 char *nht_rm
[AFI_MAX
][ZEBRA_ROUTE_MAX
+ 1]; /* "any" == ZEBRA_ROUTE_MAX */
47 char *zebra_import_table_routemap
[AFI_MAX
][ZEBRA_KERNEL_TABLE_MAX
];
50 struct nexthop
*nexthop
;
52 uint32_t source_protocol
;
58 static void zebra_route_map_set_delay_timer(uint32_t value
);
61 /* Add zebra route map rule */
62 static int zebra_route_match_add(struct vty
*vty
, const char *command
,
63 const char *arg
, route_map_event_t type
)
65 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
67 int retval
= CMD_SUCCESS
;
69 ret
= route_map_add_match(index
, command
, arg
);
71 case RMAP_RULE_MISSING
:
72 vty_out(vty
, "%% Zebra Can't find rule.\n");
73 retval
= CMD_WARNING_CONFIG_FAILED
;
75 case RMAP_COMPILE_ERROR
:
76 vty_out(vty
, "%% Zebra Argument is malformed.\n");
77 retval
= CMD_WARNING_CONFIG_FAILED
;
79 case RMAP_COMPILE_SUCCESS
:
80 if (type
!= RMAP_EVENT_MATCH_ADDED
) {
81 route_map_upd8_dependency(type
, arg
, index
->map
->name
);
89 /* Delete zebra route map rule. */
90 static int zebra_route_match_delete(struct vty
*vty
, const char *command
,
91 const char *arg
, route_map_event_t type
)
93 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
95 int retval
= CMD_SUCCESS
;
96 char *dep_name
= NULL
;
98 char *rmap_name
= NULL
;
100 if (type
!= RMAP_EVENT_MATCH_DELETED
) {
101 /* ignore the mundane, the types without any dependency */
103 if ((tmpstr
= route_map_get_match_arg(index
, command
))
106 XSTRDUP(MTYPE_ROUTE_MAP_RULE
, tmpstr
);
108 dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_RULE
, arg
);
110 rmap_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, index
->map
->name
);
113 ret
= route_map_delete_match(index
, command
, arg
);
115 case RMAP_RULE_MISSING
:
116 vty_out(vty
, "%% Zebra Can't find rule.\n");
117 retval
= CMD_WARNING_CONFIG_FAILED
;
119 case RMAP_COMPILE_ERROR
:
120 vty_out(vty
, "%% Zebra Argument is malformed.\n");
121 retval
= CMD_WARNING_CONFIG_FAILED
;
123 case RMAP_COMPILE_SUCCESS
:
124 if (type
!= RMAP_EVENT_MATCH_DELETED
&& dep_name
)
125 route_map_upd8_dependency(type
, dep_name
, rmap_name
);
130 XFREE(MTYPE_ROUTE_MAP_RULE
, dep_name
);
132 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
138 * Match function return 1 if match is success else return 0
140 static route_map_result_t
route_match_tag(void *rule
,
141 const struct prefix
*prefix
,
142 route_map_object_t type
, void *object
)
145 struct nh_rmap_obj
*nh_data
;
147 if (type
== RMAP_ZEBRA
) {
151 if (nh_data
->tag
== *tag
)
157 /* Route map commands for tag matching */
158 static struct route_map_rule_cmd route_match_tag_cmd
= {
159 "tag", route_match_tag
, route_map_rule_tag_compile
,
160 route_map_rule_tag_free
,
164 /* `match interface IFNAME' */
165 /* Match function return 1 if match is success else return zero. */
166 static route_map_result_t
route_match_interface(void *rule
,
167 const struct prefix
*prefix
,
168 route_map_object_t type
,
171 struct nh_rmap_obj
*nh_data
;
175 if (type
== RMAP_ZEBRA
) {
176 if (strcasecmp(ifname
, "any") == 0)
179 if (!nh_data
|| !nh_data
->nexthop
)
181 ifindex
= ifname2ifindex(ifname
, nh_data
->vrf_id
);
184 if (nh_data
->nexthop
->ifindex
== ifindex
)
190 /* Route map `match interface' match statement. `arg' is IFNAME value */
191 static void *route_match_interface_compile(const char *arg
)
193 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
196 /* Free route map's compiled `match interface' value. */
197 static void route_match_interface_free(void *rule
)
199 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
202 /* Route map commands for interface matching */
203 struct route_map_rule_cmd route_match_interface_cmd
= {
204 "interface", route_match_interface
, route_match_interface_compile
,
205 route_match_interface_free
};
207 DEFUN (match_ip_address_prefix_len
,
208 match_ip_address_prefix_len_cmd
,
209 "match ip address prefix-len (0-32)",
212 "Match prefix length of ip address\n"
213 "Match prefix length of ip address\n"
216 return zebra_route_match_add(vty
, "ip address prefix-len", argv
[4]->arg
,
217 RMAP_EVENT_MATCH_ADDED
);
220 DEFUN (no_match_ip_address_prefix_len
,
221 no_match_ip_address_prefix_len_cmd
,
222 "no match ip address prefix-len [(0-32)]",
226 "Match prefix length of ip address\n"
227 "Match prefix length of ip address\n"
230 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
231 return zebra_route_match_delete(vty
, "ip address prefix-len", plen
,
232 RMAP_EVENT_MATCH_DELETED
);
235 DEFUN (match_ipv6_address_prefix_len
,
236 match_ipv6_address_prefix_len_cmd
,
237 "match ipv6 address prefix-len (0-128)",
240 "Match prefix length of ipv6 address\n"
241 "Match prefix length of ipv6 address\n"
244 return zebra_route_match_add(vty
, "ipv6 address prefix-len",
245 argv
[4]->arg
, RMAP_EVENT_MATCH_ADDED
);
248 DEFUN (no_match_ipv6_address_prefix_len
,
249 no_match_ipv6_address_prefix_len_cmd
,
250 "no match ipv6 address prefix-len [(0-128)]",
254 "Match prefix length of ip address\n"
255 "Match prefix length of ip address\n"
258 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
259 return zebra_route_match_delete(vty
, "ipv6 address prefix-len", plen
,
260 RMAP_EVENT_MATCH_DELETED
);
263 DEFUN (match_ip_nexthop_prefix_len
,
264 match_ip_nexthop_prefix_len_cmd
,
265 "match ip next-hop prefix-len (0-32)",
268 "Match prefixlen of nexthop ip address\n"
269 "Match prefixlen of given nexthop\n"
272 return zebra_route_match_add(vty
, "ip next-hop prefix-len",
273 argv
[4]->arg
, RMAP_EVENT_MATCH_ADDED
);
276 DEFUN (no_match_ip_nexthop_prefix_len
,
277 no_match_ip_nexthop_prefix_len_cmd
,
278 "no match ip next-hop prefix-len [(0-32)]",
282 "Match prefixlen of nexthop ip address\n"
283 "Match prefix length of nexthop\n"
286 char *plen
= (argc
== 6) ? argv
[5]->arg
: NULL
;
287 return zebra_route_match_delete(vty
, "ip next-hop prefix-len", plen
,
288 RMAP_EVENT_MATCH_DELETED
);
291 DEFUN (match_source_protocol
,
292 match_source_protocol_cmd
,
293 "match source-protocol <bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>",
295 "Match protocol via which the route was learnt\n"
306 "Routes from directly connected peer\n"
307 "Routes from system configuration\n"
308 "Routes from kernel\n"
309 "Statically configured routes\n"
312 char *proto
= argv
[2]->text
;
315 i
= proto_name2num(proto
);
317 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
318 return CMD_WARNING_CONFIG_FAILED
;
320 return zebra_route_match_add(vty
, "source-protocol", proto
,
321 RMAP_EVENT_MATCH_ADDED
);
324 DEFUN (no_match_source_protocol
,
325 no_match_source_protocol_cmd
,
326 "no match source-protocol [<bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>]",
329 "No match protocol via which the route was learnt\n"
340 "Routes from directly connected peer\n"
341 "Routes from system configuration\n"
342 "Routes from kernel\n"
343 "Statically configured routes\n"
346 char *proto
= (argc
== 4) ? argv
[3]->text
: NULL
;
347 return zebra_route_match_delete(vty
, "source-protocol", proto
,
348 RMAP_EVENT_MATCH_DELETED
);
351 DEFUN (match_source_instance
,
352 match_source_instance_cmd
,
353 "match source-instance (0-255)",
355 "Match the protocol's instance number\n"
356 "The instance number\n")
358 char *instance
= argv
[2]->arg
;
360 return zebra_route_match_add(vty
, "source-instance", instance
,
361 RMAP_EVENT_MATCH_ADDED
);
364 DEFUN (no_match_source_instance
,
365 no_match_source_instance_cmd
,
366 "no match source-instance [(0-255)]",
368 "Match the protocol's instance number\n"
369 "The instance number\n")
371 char *instance
= (argc
== 4) ? argv
[3]->arg
: NULL
;
373 return zebra_route_match_delete(vty
, "source-instance", instance
,
374 RMAP_EVENT_MATCH_ADDED
);
381 "set src <A.B.C.D|X:X::X:X>",
383 "src address for route\n"
385 "IPv6 src address\n")
389 struct interface
*pif
= NULL
;
394 if (inet_pton(AF_INET
, argv
[idx_ip
]->arg
, &src
.ipv4
) != 1) {
395 if (inet_pton(AF_INET6
, argv
[idx_ip
]->arg
, &src
.ipv6
) != 1) {
396 vty_out(vty
, "%% not a valid IPv4/v6 address\n");
397 return CMD_WARNING_CONFIG_FAILED
;
400 p
.family
= family
= AF_INET6
;
401 p
.u
.prefix6
= src
.ipv6
;
402 p
.prefixlen
= IPV6_MAX_BITLEN
;
404 p
.family
= family
= AF_INET
;
405 p
.u
.prefix4
= src
.ipv4
;
406 p
.prefixlen
= IPV4_MAX_BITLEN
;
409 if (!zebra_check_addr(&p
)) {
410 vty_out(vty
, "%% not a valid source IPv4/v6 address\n");
411 return CMD_WARNING_CONFIG_FAILED
;
414 RB_FOREACH (vrf
, vrf_id_head
, &vrfs_by_id
) {
415 if (family
== AF_INET
)
416 pif
= if_lookup_exact_address((void *)&src
.ipv4
,
417 AF_INET
, vrf
->vrf_id
);
418 else if (family
== AF_INET6
)
419 pif
= if_lookup_exact_address((void *)&src
.ipv6
,
420 AF_INET6
, vrf
->vrf_id
);
427 vty_out(vty
, "%% not a local address\n");
428 return CMD_WARNING_CONFIG_FAILED
;
431 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
432 return generic_set_add(vty
, index
, "src", argv
[idx_ip
]->arg
);
437 "no set src [<A.B.C.D|X:X::X:X>]",
440 "Source address for route\n"
444 char *ip
= (argc
== 4) ? argv
[3]->arg
: NULL
;
445 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
446 return generic_set_delete(vty
, index
, "src", ip
);
449 DEFUN (zebra_route_map_timer
,
450 zebra_route_map_timer_cmd
,
451 "zebra route-map delay-timer (0-600)",
453 "Set route-map parameters\n"
454 "Time to wait before route-map updates are processed\n"
455 "0 means event-driven updates are disabled\n")
458 uint32_t rmap_delay_timer
;
460 rmap_delay_timer
= strtoul(argv
[idx_number
]->arg
, NULL
, 10);
461 zebra_route_map_set_delay_timer(rmap_delay_timer
);
463 return (CMD_SUCCESS
);
466 DEFUN (no_zebra_route_map_timer
,
467 no_zebra_route_map_timer_cmd
,
468 "no zebra route-map delay-timer [(0-600)]",
471 "Set route-map parameters\n"
472 "Reset delay-timer to default value, 30 secs\n"
473 "0 means event-driven updates are disabled\n")
475 zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
);
477 return (CMD_SUCCESS
);
483 "ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
" route-map ROUTE-MAP",
485 "Filter routing info exchanged between zebra and protocol\n"
486 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
487 "Specify route-map\n"
490 char *proto
= argv
[2]->text
;
491 char *rmap
= argv
[4]->arg
;
494 if (strcasecmp(proto
, "any") == 0)
497 i
= proto_name2num(proto
);
499 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
500 return CMD_WARNING_CONFIG_FAILED
;
502 if (proto_rm
[AFI_IP
][i
]) {
503 if (strcmp(proto_rm
[AFI_IP
][i
], rmap
) == 0)
506 XFREE(MTYPE_ROUTE_MAP_NAME
, proto_rm
[AFI_IP
][i
]);
508 proto_rm
[AFI_IP
][i
] = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
510 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
512 "%u: IPv4 Routemap config for protocol %s, scheduling RIB processing",
515 rib_update(VRF_DEFAULT
, RIB_UPDATE_RMAP_CHANGE
);
519 DEFUN (no_ip_protocol
,
521 "no ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
" [route-map ROUTE-MAP]",
524 "Stop filtering routing info between zebra and protocol\n"
525 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
526 "Specify route map\n"
529 char *proto
= argv
[3]->text
;
530 char *rmap
= (argc
== 6) ? argv
[5]->arg
: NULL
;
533 if (strcasecmp(proto
, "any") == 0)
536 i
= proto_name2num(proto
);
539 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
540 return CMD_WARNING_CONFIG_FAILED
;
543 if (!proto_rm
[AFI_IP
][i
])
546 if (!rmap
|| strcmp(rmap
, proto_rm
[AFI_IP
][i
]) == 0) {
547 XFREE(MTYPE_ROUTE_MAP_NAME
, proto_rm
[AFI_IP
][i
]);
548 proto_rm
[AFI_IP
][i
] = NULL
;
550 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
552 "%u: IPv4 Routemap unconfig for protocol %s, scheduling RIB processing",
554 rib_update(VRF_DEFAULT
, RIB_UPDATE_RMAP_CHANGE
);
559 DEFUN (show_ip_protocol
,
560 show_ip_protocol_cmd
,
564 "IP protocol filtering status\n")
568 vty_out(vty
, "Protocol : route-map \n");
569 vty_out(vty
, "------------------------\n");
570 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
571 if (proto_rm
[AFI_IP
][i
])
572 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
573 proto_rm
[AFI_IP
][i
]);
575 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
577 if (proto_rm
[AFI_IP
][i
])
578 vty_out(vty
, "%-10s : %-10s\n", "any", proto_rm
[AFI_IP
][i
]);
580 vty_out(vty
, "%-10s : none\n", "any");
585 DEFUN (ipv6_protocol
,
587 "ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
" route-map ROUTE-MAP",
589 "Filter IPv6 routing info exchanged between zebra and protocol\n"
590 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
591 "Specify route map\n"
594 char *proto
= argv
[2]->text
;
595 char *rmap
= argv
[4]->arg
;
598 if (strcasecmp(proto
, "any") == 0)
601 i
= proto_name2num(proto
);
603 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
604 return CMD_WARNING_CONFIG_FAILED
;
606 if (proto_rm
[AFI_IP6
][i
]) {
607 if (strcmp(proto_rm
[AFI_IP6
][i
], rmap
) == 0)
610 XFREE(MTYPE_ROUTE_MAP_NAME
, proto_rm
[AFI_IP6
][i
]);
612 proto_rm
[AFI_IP6
][i
] = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
614 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
616 "%u: IPv6 Routemap config for protocol %s, scheduling RIB processing",
619 rib_update(VRF_DEFAULT
, RIB_UPDATE_RMAP_CHANGE
);
623 DEFUN (no_ipv6_protocol
,
624 no_ipv6_protocol_cmd
,
625 "no ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
" [route-map ROUTE-MAP]",
628 "Stop filtering IPv6 routing info between zebra and protocol\n"
629 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
630 "Specify route map\n"
633 const char *proto
= argv
[3]->text
;
634 const char *rmap
= (argc
== 6) ? argv
[5]->arg
: NULL
;
637 if (strcasecmp(proto
, "any") == 0)
640 i
= proto_name2num(proto
);
642 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
643 return CMD_WARNING_CONFIG_FAILED
;
645 if (!proto_rm
[AFI_IP6
][i
])
648 if (!rmap
|| strcmp(rmap
, proto_rm
[AFI_IP6
][i
]) == 0) {
649 XFREE(MTYPE_ROUTE_MAP_NAME
, proto_rm
[AFI_IP6
][i
]);
650 proto_rm
[AFI_IP6
][i
] = NULL
;
652 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
654 "%u: IPv6 Routemap unconfig for protocol %s, scheduling RIB processing",
657 rib_update(VRF_DEFAULT
, RIB_UPDATE_RMAP_CHANGE
);
662 DEFUN (show_ipv6_protocol
,
663 show_ipv6_protocol_cmd
,
664 "show ipv6 protocol",
667 "IPv6 protocol filtering status\n")
671 vty_out(vty
, "Protocol : route-map \n");
672 vty_out(vty
, "------------------------\n");
673 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
674 if (proto_rm
[AFI_IP6
][i
])
675 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
676 proto_rm
[AFI_IP6
][i
]);
678 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
680 if (proto_rm
[AFI_IP6
][i
])
681 vty_out(vty
, "%-10s : %-10s\n", "any", proto_rm
[AFI_IP6
][i
]);
683 vty_out(vty
, "%-10s : none\n", "any");
688 DEFUN (ip_protocol_nht_rmap
,
689 ip_protocol_nht_rmap_cmd
,
690 "ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
" route-map ROUTE-MAP",
692 "Filter Next Hop tracking route resolution\n"
693 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
694 "Specify route map\n"
697 char *proto
= argv
[2]->text
;
698 char *rmap
= argv
[4]->arg
;
701 if (strcasecmp(proto
, "any") == 0)
704 i
= proto_name2num(proto
);
706 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
707 return CMD_WARNING_CONFIG_FAILED
;
709 if (nht_rm
[AFI_IP
][i
]) {
710 if (strcmp(nht_rm
[AFI_IP
][i
], rmap
) == 0)
713 XFREE(MTYPE_ROUTE_MAP_NAME
, nht_rm
[AFI_IP
][i
]);
716 nht_rm
[AFI_IP
][i
] = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
717 zebra_evaluate_rnh(0, AF_INET
, 1, RNH_NEXTHOP_TYPE
, NULL
);
722 DEFUN (no_ip_protocol_nht_rmap
,
723 no_ip_protocol_nht_rmap_cmd
,
724 "no ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
" [route-map ROUTE-MAP]",
727 "Filter Next Hop tracking route resolution\n"
728 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
729 "Specify route map\n"
733 char *proto
= argv
[3]->text
;
734 char *rmap
= argv_find(argv
, argc
, "ROUTE-MAP", &idx
) ? argv
[idx
]->arg
737 int i
= strmatch(proto
, "any") ? ZEBRA_ROUTE_MAX
738 : proto_name2num(proto
);
741 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
742 return CMD_WARNING_CONFIG_FAILED
;
745 if (!nht_rm
[AFI_IP
][i
])
748 if (!rmap
|| strcmp(rmap
, nht_rm
[AFI_IP
][i
]) == 0) {
749 XFREE(MTYPE_ROUTE_MAP_NAME
, nht_rm
[AFI_IP
][i
]);
750 nht_rm
[AFI_IP
][i
] = NULL
;
751 zebra_evaluate_rnh(0, AF_INET
, 1, RNH_NEXTHOP_TYPE
, NULL
);
756 DEFUN (show_ip_protocol_nht
,
757 show_ip_protocol_nht_cmd
,
758 "show ip nht route-map",
761 "IP nexthop tracking table\n"
762 "IP Next Hop tracking filtering status\n")
766 vty_out(vty
, "Protocol : route-map \n");
767 vty_out(vty
, "------------------------\n");
768 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
769 if (nht_rm
[AFI_IP
][i
])
770 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
773 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
775 if (nht_rm
[AFI_IP
][i
])
776 vty_out(vty
, "%-10s : %-10s\n", "any", nht_rm
[AFI_IP
][i
]);
778 vty_out(vty
, "%-10s : none\n", "any");
783 DEFUN (ipv6_protocol_nht_rmap
,
784 ipv6_protocol_nht_rmap_cmd
,
785 "ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
" route-map ROUTE-MAP",
787 "Filter Next Hop tracking route resolution\n"
788 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
789 "Specify route map\n"
792 char *proto
= argv
[2]->text
;
793 char *rmap
= argv
[4]->arg
;
796 if (strcasecmp(proto
, "any") == 0)
799 i
= proto_name2num(proto
);
801 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
802 return CMD_WARNING_CONFIG_FAILED
;
804 if (nht_rm
[AFI_IP6
][i
])
805 XFREE(MTYPE_ROUTE_MAP_NAME
, nht_rm
[AFI_IP6
][i
]);
806 nht_rm
[AFI_IP6
][i
] = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
807 zebra_evaluate_rnh(0, AF_INET6
, 1, RNH_NEXTHOP_TYPE
, NULL
);
812 DEFUN (no_ipv6_protocol_nht_rmap
,
813 no_ipv6_protocol_nht_rmap_cmd
,
814 "no ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
" [route-map ROUTE-MAP]",
817 "Filter Next Hop tracking route resolution\n"
818 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
819 "Specify route map\n"
822 char *proto
= argv
[3]->text
;
823 char *rmap
= (argc
== 6) ? argv
[5]->arg
: NULL
;
826 if (strcasecmp(proto
, "any") == 0)
829 i
= proto_name2num(proto
);
831 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
832 return CMD_WARNING_CONFIG_FAILED
;
835 if (nht_rm
[AFI_IP6
][i
] && rmap
&& strcmp(rmap
, nht_rm
[AFI_IP6
][i
])) {
836 vty_out(vty
, "invalid route-map \"%s\"\n", rmap
);
837 return CMD_WARNING_CONFIG_FAILED
;
840 if (nht_rm
[AFI_IP6
][i
]) {
841 XFREE(MTYPE_ROUTE_MAP_NAME
, nht_rm
[AFI_IP6
][i
]);
842 nht_rm
[AFI_IP6
][i
] = NULL
;
845 zebra_evaluate_rnh(0, AF_INET6
, 1, RNH_NEXTHOP_TYPE
, NULL
);
850 DEFUN (show_ipv6_protocol_nht
,
851 show_ipv6_protocol_nht_cmd
,
852 "show ipv6 nht route-map",
855 "Next Hop filtering status\n"
860 vty_out(vty
, "Protocol : route-map \n");
861 vty_out(vty
, "------------------------\n");
862 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
863 if (nht_rm
[AFI_IP6
][i
])
864 vty_out(vty
, "%-10s : %-10s\n", zebra_route_string(i
),
867 vty_out(vty
, "%-10s : none\n", zebra_route_string(i
));
869 if (nht_rm
[AFI_IP
][i
])
870 vty_out(vty
, "%-10s : %-10s\n", "any", nht_rm
[AFI_IP6
][i
]);
872 vty_out(vty
, "%-10s : none\n", "any");
877 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
879 /* `match ip next-hop IP_ACCESS_LIST' */
881 /* Match function return 1 if match is success else return zero. */
882 static route_map_result_t
route_match_ip_next_hop(void *rule
,
883 const struct prefix
*prefix
,
884 route_map_object_t type
,
887 struct access_list
*alist
;
888 struct nh_rmap_obj
*nh_data
;
889 struct prefix_ipv4 p
;
891 if (type
== RMAP_ZEBRA
) {
894 return RMAP_DENYMATCH
;
896 switch (nh_data
->nexthop
->type
) {
897 case NEXTHOP_TYPE_IFINDEX
:
898 /* Interface routes can't match ip next-hop */
900 case NEXTHOP_TYPE_IPV4_IFINDEX
:
901 case NEXTHOP_TYPE_IPV4
:
903 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
904 p
.prefixlen
= IPV4_MAX_BITLEN
;
909 alist
= access_list_lookup(AFI_IP
, (char *)rule
);
913 return (access_list_apply(alist
, &p
) == FILTER_DENY
920 /* Route map `ip next-hop' match statement. `arg' should be
922 static void *route_match_ip_next_hop_compile(const char *arg
)
924 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
927 /* Free route map's compiled `. */
928 static void route_match_ip_next_hop_free(void *rule
)
930 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
933 /* Route map commands for ip next-hop matching. */
934 static struct route_map_rule_cmd route_match_ip_next_hop_cmd
= {
935 "ip next-hop", route_match_ip_next_hop
, route_match_ip_next_hop_compile
,
936 route_match_ip_next_hop_free
};
938 /* `match ip next-hop prefix-list PREFIX_LIST' */
940 static route_map_result_t
941 route_match_ip_next_hop_prefix_list(void *rule
, const struct prefix
*prefix
,
942 route_map_object_t type
, void *object
)
944 struct prefix_list
*plist
;
945 struct nh_rmap_obj
*nh_data
;
946 struct prefix_ipv4 p
;
948 if (type
== RMAP_ZEBRA
) {
949 nh_data
= (struct nh_rmap_obj
*)object
;
951 return RMAP_DENYMATCH
;
953 switch (nh_data
->nexthop
->type
) {
954 case NEXTHOP_TYPE_IFINDEX
:
955 /* Interface routes can't match ip next-hop */
957 case NEXTHOP_TYPE_IPV4_IFINDEX
:
958 case NEXTHOP_TYPE_IPV4
:
960 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
961 p
.prefixlen
= IPV4_MAX_BITLEN
;
966 plist
= prefix_list_lookup(AFI_IP
, (char *)rule
);
970 return (prefix_list_apply(plist
, &p
) == PREFIX_DENY
977 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg
)
979 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
982 static void route_match_ip_next_hop_prefix_list_free(void *rule
)
984 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
987 static struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd
= {
988 "ip next-hop prefix-list", route_match_ip_next_hop_prefix_list
,
989 route_match_ip_next_hop_prefix_list_compile
,
990 route_match_ip_next_hop_prefix_list_free
};
992 /* `match ip address IP_ACCESS_LIST' */
994 /* Match function should return 1 if match is success else return
996 static route_map_result_t
route_match_ip_address(void *rule
,
997 const struct prefix
*prefix
,
998 route_map_object_t type
,
1001 struct access_list
*alist
;
1003 if (type
== RMAP_ZEBRA
) {
1004 alist
= access_list_lookup(AFI_IP
, (char *)rule
);
1006 return RMAP_NOMATCH
;
1008 return (access_list_apply(alist
, prefix
) == FILTER_DENY
1012 return RMAP_NOMATCH
;
1015 /* Route map `ip address' match statement. `arg' should be
1016 access-list name. */
1017 static void *route_match_ip_address_compile(const char *arg
)
1019 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1022 /* Free route map's compiled `ip address' value. */
1023 static void route_match_ip_address_free(void *rule
)
1025 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1028 /* Route map commands for ip address matching. */
1029 static struct route_map_rule_cmd route_match_ip_address_cmd
= {
1030 "ip address", route_match_ip_address
, route_match_ip_address_compile
,
1031 route_match_ip_address_free
};
1033 /* `match ip address prefix-list PREFIX_LIST' */
1035 static route_map_result_t
1036 route_match_ip_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1037 route_map_object_t type
, void *object
)
1039 struct prefix_list
*plist
;
1041 if (type
== RMAP_ZEBRA
) {
1042 plist
= prefix_list_lookup(AFI_IP
, (char *)rule
);
1044 return RMAP_NOMATCH
;
1046 return (prefix_list_apply(plist
, prefix
) == PREFIX_DENY
1050 return RMAP_NOMATCH
;
1053 static void *route_match_ip_address_prefix_list_compile(const char *arg
)
1055 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1058 static void route_match_ip_address_prefix_list_free(void *rule
)
1060 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1063 static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd
= {
1064 "ip address prefix-list", route_match_ip_address_prefix_list
,
1065 route_match_ip_address_prefix_list_compile
,
1066 route_match_ip_address_prefix_list_free
};
1069 /* `match ip address prefix-len PREFIXLEN' */
1071 static route_map_result_t
1072 route_match_address_prefix_len(void *rule
, const struct prefix
*prefix
,
1073 route_map_object_t type
, void *object
)
1075 uint32_t *prefixlen
= (uint32_t *)rule
;
1077 if (type
== RMAP_ZEBRA
) {
1078 return ((prefix
->prefixlen
== *prefixlen
) ? RMAP_MATCH
1081 return RMAP_NOMATCH
;
1084 static void *route_match_address_prefix_len_compile(const char *arg
)
1086 uint32_t *prefix_len
;
1087 char *endptr
= NULL
;
1088 unsigned long tmpval
;
1090 /* prefix len value shoud be integer. */
1091 if (!all_digit(arg
))
1095 tmpval
= strtoul(arg
, &endptr
, 10);
1096 if (*endptr
!= '\0' || errno
|| tmpval
> UINT32_MAX
)
1099 prefix_len
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1104 *prefix_len
= tmpval
;
1108 static void route_match_address_prefix_len_free(void *rule
)
1110 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1113 static struct route_map_rule_cmd route_match_ip_address_prefix_len_cmd
= {
1114 "ip address prefix-len", route_match_address_prefix_len
,
1115 route_match_address_prefix_len_compile
,
1116 route_match_address_prefix_len_free
};
1118 static struct route_map_rule_cmd route_match_ipv6_address_prefix_len_cmd
= {
1119 "ipv6 address prefix-len", route_match_address_prefix_len
,
1120 route_match_address_prefix_len_compile
,
1121 route_match_address_prefix_len_free
};
1123 /* `match ip nexthop prefix-len PREFIXLEN' */
1125 static route_map_result_t
1126 route_match_ip_nexthop_prefix_len(void *rule
, const struct prefix
*prefix
,
1127 route_map_object_t type
, void *object
)
1129 uint32_t *prefixlen
= (uint32_t *)rule
;
1130 struct nh_rmap_obj
*nh_data
;
1131 struct prefix_ipv4 p
;
1133 if (type
== RMAP_ZEBRA
) {
1134 nh_data
= (struct nh_rmap_obj
*)object
;
1135 if (!nh_data
|| !nh_data
->nexthop
)
1136 return RMAP_DENYMATCH
;
1138 switch (nh_data
->nexthop
->type
) {
1139 case NEXTHOP_TYPE_IFINDEX
:
1140 /* Interface routes can't match ip next-hop */
1141 return RMAP_NOMATCH
;
1142 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1143 case NEXTHOP_TYPE_IPV4
:
1145 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
1146 p
.prefixlen
= IPV4_MAX_BITLEN
;
1149 return RMAP_NOMATCH
;
1151 return ((p
.prefixlen
== *prefixlen
) ? RMAP_MATCH
1154 return RMAP_NOMATCH
;
1157 static struct route_map_rule_cmd route_match_ip_nexthop_prefix_len_cmd
= {
1158 "ip next-hop prefix-len", route_match_ip_nexthop_prefix_len
,
1159 route_match_address_prefix_len_compile
, /* reuse */
1160 route_match_address_prefix_len_free
/* reuse */
1163 /* `match source-protocol PROTOCOL' */
1165 static route_map_result_t
route_match_source_protocol(void *rule
,
1166 const struct prefix
*p
,
1167 route_map_object_t type
,
1170 uint32_t *rib_type
= (uint32_t *)rule
;
1171 struct nh_rmap_obj
*nh_data
;
1173 if (type
== RMAP_ZEBRA
) {
1174 nh_data
= (struct nh_rmap_obj
*)object
;
1176 return RMAP_DENYMATCH
;
1178 return ((nh_data
->source_protocol
== *rib_type
) ? RMAP_MATCH
1181 return RMAP_NOMATCH
;
1184 static void *route_match_source_protocol_compile(const char *arg
)
1189 i
= proto_name2num(arg
);
1190 rib_type
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1197 static void route_match_source_protocol_free(void *rule
)
1199 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1202 static struct route_map_rule_cmd route_match_source_protocol_cmd
= {
1203 "source-protocol", route_match_source_protocol
,
1204 route_match_source_protocol_compile
, route_match_source_protocol_free
};
1206 /* `source-instance` */
1207 static route_map_result_t
route_match_source_instance(void *rule
,
1208 const struct prefix
*p
,
1209 route_map_object_t type
,
1212 uint8_t *instance
= (uint8_t *)rule
;
1213 struct nh_rmap_obj
*nh_data
;
1215 if (type
!= RMAP_ZEBRA
)
1216 return RMAP_NOMATCH
;
1218 nh_data
= (struct nh_rmap_obj
*)object
;
1220 return RMAP_DENYMATCH
;
1222 return (nh_data
->instance
== *instance
) ? RMAP_MATCH
: RMAP_NOMATCH
;
1225 static void *route_match_source_instance_compile(const char *arg
)
1231 instance
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint8_t));
1238 static void route_match_source_instance_free(void *rule
)
1240 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1243 static struct route_map_rule_cmd route_match_source_instance_cmd
= {
1244 "source-instance", route_match_source_instance
,
1245 route_match_source_instance_compile
, route_match_source_instance_free
};
1247 /* `set src A.B.C.D' */
1250 static route_map_result_t
route_set_src(void *rule
, const struct prefix
*prefix
,
1251 route_map_object_t type
, void *object
)
1253 struct nh_rmap_obj
*nh_data
;
1255 if (type
== RMAP_ZEBRA
) {
1256 nh_data
= (struct nh_rmap_obj
*)object
;
1257 nh_data
->nexthop
->rmap_src
= *(union g_addr
*)rule
;
1262 /* set src compilation. */
1263 static void *route_set_src_compile(const char *arg
)
1265 union g_addr src
, *psrc
;
1267 if ((inet_pton(AF_INET6
, arg
, &src
.ipv6
) == 1)
1268 || (inet_pton(AF_INET
, arg
, &src
.ipv4
) == 1)) {
1269 psrc
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(union g_addr
));
1276 /* Free route map's compiled `set src' value. */
1277 static void route_set_src_free(void *rule
)
1279 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1282 /* Set src rule structure. */
1283 static struct route_map_rule_cmd route_set_src_cmd
= {
1284 "src", route_set_src
, route_set_src_compile
, route_set_src_free
,
1287 static void zebra_route_map_process_update_cb(char *rmap_name
)
1289 if (IS_ZEBRA_DEBUG_EVENT
)
1290 zlog_debug("Event handler for route-map: %s",
1294 static int zebra_route_map_update_timer(struct thread
*thread
)
1296 zebra_t_rmap_update
= NULL
;
1298 if (IS_ZEBRA_DEBUG_EVENT
)
1299 zlog_debug("Event driven route-map update triggered");
1301 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
1303 "%u: Routemap update-timer fired, scheduling RIB processing",
1306 route_map_walk_update_list(zebra_route_map_process_update_cb
);
1309 * This code needs to be updated to be:
1310 * 1) VRF Aware <sigh>
1311 * 2) Route-map aware
1313 zebra_import_table_rm_update();
1314 rib_update(VRF_DEFAULT
, RIB_UPDATE_RMAP_CHANGE
);
1315 zebra_evaluate_rnh(0, AF_INET
, 1, RNH_NEXTHOP_TYPE
, NULL
);
1316 zebra_evaluate_rnh(0, AF_INET6
, 1, RNH_NEXTHOP_TYPE
, NULL
);
1321 static void zebra_route_map_set_delay_timer(uint32_t value
)
1323 zebra_rmap_update_timer
= value
;
1324 if (!value
&& zebra_t_rmap_update
) {
1325 /* Event driven route map updates is being disabled */
1326 /* But there's a pending timer. Fire it off now */
1327 thread_cancel(zebra_t_rmap_update
);
1328 zebra_route_map_update_timer(zebra_t_rmap_update
);
1332 void zebra_route_map_write_delay_timer(struct vty
*vty
)
1334 if (vty
&& (zebra_rmap_update_timer
!= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
))
1335 vty_out(vty
, "zebra route-map delay-timer %d\n",
1336 zebra_rmap_update_timer
);
1340 route_map_result_t
zebra_route_map_check(int family
, int rib_type
,
1342 const struct prefix
*p
,
1343 struct nexthop
*nexthop
,
1344 vrf_id_t vrf_id
, route_tag_t tag
)
1346 struct route_map
*rmap
= NULL
;
1347 route_map_result_t ret
= RMAP_MATCH
;
1348 struct nh_rmap_obj nh_obj
;
1350 nh_obj
.nexthop
= nexthop
;
1351 nh_obj
.vrf_id
= vrf_id
;
1352 nh_obj
.source_protocol
= rib_type
;
1353 nh_obj
.instance
= instance
;
1357 if (rib_type
>= 0 && rib_type
< ZEBRA_ROUTE_MAX
)
1358 rmap
= route_map_lookup_by_name(proto_rm
[family
][rib_type
]);
1359 if (!rmap
&& proto_rm
[family
][ZEBRA_ROUTE_MAX
])
1360 rmap
= route_map_lookup_by_name(
1361 proto_rm
[family
][ZEBRA_ROUTE_MAX
]);
1363 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1369 char *zebra_get_import_table_route_map(afi_t afi
, uint32_t table
)
1371 return zebra_import_table_routemap
[afi
][table
];
1374 void zebra_add_import_table_route_map(afi_t afi
, const char *rmap_name
,
1377 zebra_import_table_routemap
[afi
][table
] =
1378 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1381 void zebra_del_import_table_route_map(afi_t afi
, uint32_t table
)
1383 XFREE(MTYPE_ROUTE_MAP_NAME
, zebra_import_table_routemap
[afi
][table
]);
1387 zebra_import_table_route_map_check(int family
, int re_type
, uint8_t instance
,
1388 const struct prefix
*p
,
1389 struct nexthop
*nexthop
,
1390 vrf_id_t vrf_id
, route_tag_t tag
,
1391 const char *rmap_name
)
1393 struct route_map
*rmap
= NULL
;
1394 route_map_result_t ret
= RMAP_DENYMATCH
;
1395 struct nh_rmap_obj nh_obj
;
1397 nh_obj
.nexthop
= nexthop
;
1398 nh_obj
.vrf_id
= vrf_id
;
1399 nh_obj
.source_protocol
= re_type
;
1400 nh_obj
.instance
= instance
;
1404 if (re_type
>= 0 && re_type
< ZEBRA_ROUTE_MAX
)
1405 rmap
= route_map_lookup_by_name(rmap_name
);
1407 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1413 route_map_result_t
zebra_nht_route_map_check(int family
, int client_proto
,
1414 const struct prefix
*p
,
1415 struct route_entry
*re
,
1416 struct nexthop
*nexthop
)
1418 struct route_map
*rmap
= NULL
;
1419 route_map_result_t ret
= RMAP_MATCH
;
1420 struct nh_rmap_obj nh_obj
;
1422 nh_obj
.nexthop
= nexthop
;
1423 nh_obj
.vrf_id
= nexthop
->vrf_id
;
1424 nh_obj
.source_protocol
= re
->type
;
1425 nh_obj
.instance
= re
->instance
;
1426 nh_obj
.metric
= re
->metric
;
1427 nh_obj
.tag
= re
->tag
;
1429 if (client_proto
>= 0 && client_proto
< ZEBRA_ROUTE_MAX
)
1430 rmap
= route_map_lookup_by_name(nht_rm
[family
][client_proto
]);
1431 if (!rmap
&& nht_rm
[family
][ZEBRA_ROUTE_MAX
])
1432 rmap
= route_map_lookup_by_name(
1433 nht_rm
[family
][ZEBRA_ROUTE_MAX
]);
1435 ret
= route_map_apply(rmap
, p
, RMAP_ZEBRA
, &nh_obj
);
1440 static void zebra_route_map_mark_update(const char *rmap_name
)
1442 /* rmap_update_timer of 0 means don't do route updates */
1443 if (zebra_rmap_update_timer
&& !zebra_t_rmap_update
) {
1444 zebra_t_rmap_update
= NULL
;
1445 thread_add_timer(zebrad
.master
, zebra_route_map_update_timer
,
1446 NULL
, zebra_rmap_update_timer
,
1447 &zebra_t_rmap_update
);
1451 static void zebra_route_map_add(const char *rmap_name
)
1453 if (route_map_mark_updated(rmap_name
) == 0)
1454 zebra_route_map_mark_update(rmap_name
);
1456 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1459 static void zebra_route_map_delete(const char *rmap_name
)
1461 if (route_map_mark_updated(rmap_name
) == 0)
1462 zebra_route_map_mark_update(rmap_name
);
1464 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_DELETED
);
1467 static void zebra_route_map_event(route_map_event_t event
,
1468 const char *rmap_name
)
1470 if (route_map_mark_updated(rmap_name
) == 0)
1471 zebra_route_map_mark_update(rmap_name
);
1473 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1476 /* ip protocol configuration write function */
1477 void zebra_routemap_config_write_protocol(struct vty
*vty
)
1481 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
1482 if (proto_rm
[AFI_IP
][i
])
1483 vty_out(vty
, "ip protocol %s route-map %s\n",
1484 zebra_route_string(i
), proto_rm
[AFI_IP
][i
]);
1486 if (proto_rm
[AFI_IP6
][i
])
1487 vty_out(vty
, "ipv6 protocol %s route-map %s\n",
1488 zebra_route_string(i
), proto_rm
[AFI_IP6
][i
]);
1490 if (nht_rm
[AFI_IP
][i
])
1491 vty_out(vty
, "ip nht %s route-map %s\n",
1492 zebra_route_string(i
), nht_rm
[AFI_IP
][i
]);
1494 if (nht_rm
[AFI_IP6
][i
])
1495 vty_out(vty
, "ipv6 nht %s route-map %s\n",
1496 zebra_route_string(i
), nht_rm
[AFI_IP6
][i
]);
1499 if (proto_rm
[AFI_IP
][ZEBRA_ROUTE_MAX
])
1500 vty_out(vty
, "ip protocol %s route-map %s\n", "any",
1501 proto_rm
[AFI_IP
][ZEBRA_ROUTE_MAX
]);
1503 if (proto_rm
[AFI_IP6
][ZEBRA_ROUTE_MAX
])
1504 vty_out(vty
, "ipv6 protocol %s route-map %s\n", "any",
1505 proto_rm
[AFI_IP6
][ZEBRA_ROUTE_MAX
]);
1507 if (nht_rm
[AFI_IP
][ZEBRA_ROUTE_MAX
])
1508 vty_out(vty
, "ip nht %s route-map %s\n", "any",
1509 nht_rm
[AFI_IP
][ZEBRA_ROUTE_MAX
]);
1511 if (nht_rm
[AFI_IP6
][ZEBRA_ROUTE_MAX
])
1512 vty_out(vty
, "ipv6 nht %s route-map %s\n", "any",
1513 nht_rm
[AFI_IP6
][ZEBRA_ROUTE_MAX
]);
1515 if (zebra_rmap_update_timer
!= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
)
1516 vty_out(vty
, "zebra route-map delay-timer %d\n",
1517 zebra_rmap_update_timer
);
1520 void zebra_route_map_init()
1522 install_element(CONFIG_NODE
, &ip_protocol_cmd
);
1523 install_element(CONFIG_NODE
, &no_ip_protocol_cmd
);
1524 install_element(VIEW_NODE
, &show_ip_protocol_cmd
);
1525 install_element(CONFIG_NODE
, &ipv6_protocol_cmd
);
1526 install_element(CONFIG_NODE
, &no_ipv6_protocol_cmd
);
1527 install_element(VIEW_NODE
, &show_ipv6_protocol_cmd
);
1528 install_element(CONFIG_NODE
, &ip_protocol_nht_rmap_cmd
);
1529 install_element(CONFIG_NODE
, &no_ip_protocol_nht_rmap_cmd
);
1530 install_element(VIEW_NODE
, &show_ip_protocol_nht_cmd
);
1531 install_element(CONFIG_NODE
, &ipv6_protocol_nht_rmap_cmd
);
1532 install_element(CONFIG_NODE
, &no_ipv6_protocol_nht_rmap_cmd
);
1533 install_element(VIEW_NODE
, &show_ipv6_protocol_nht_cmd
);
1534 install_element(CONFIG_NODE
, &zebra_route_map_timer_cmd
);
1535 install_element(CONFIG_NODE
, &no_zebra_route_map_timer_cmd
);
1539 route_map_add_hook(zebra_route_map_add
);
1540 route_map_delete_hook(zebra_route_map_delete
);
1541 route_map_event_hook(zebra_route_map_event
);
1543 route_map_match_interface_hook(generic_match_add
);
1544 route_map_no_match_interface_hook(generic_match_delete
);
1546 route_map_match_ip_address_hook(generic_match_add
);
1547 route_map_no_match_ip_address_hook(generic_match_delete
);
1549 route_map_match_ip_address_prefix_list_hook(generic_match_add
);
1550 route_map_no_match_ip_address_prefix_list_hook(generic_match_delete
);
1552 route_map_match_ip_next_hop_hook(generic_match_add
);
1553 route_map_no_match_ip_next_hop_hook(generic_match_delete
);
1555 route_map_match_ip_next_hop_prefix_list_hook(generic_match_add
);
1556 route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete
);
1558 route_map_match_tag_hook(generic_match_add
);
1559 route_map_no_match_tag_hook(generic_match_delete
);
1561 route_map_install_match(&route_match_tag_cmd
);
1562 route_map_install_match(&route_match_interface_cmd
);
1563 route_map_install_match(&route_match_ip_next_hop_cmd
);
1564 route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd
);
1565 route_map_install_match(&route_match_ip_address_cmd
);
1566 route_map_install_match(&route_match_ip_address_prefix_list_cmd
);
1567 route_map_install_match(&route_match_ip_address_prefix_len_cmd
);
1568 route_map_install_match(&route_match_ipv6_address_prefix_len_cmd
);
1569 route_map_install_match(&route_match_ip_nexthop_prefix_len_cmd
);
1570 route_map_install_match(&route_match_source_protocol_cmd
);
1571 route_map_install_match(&route_match_source_instance_cmd
);
1574 route_map_install_set(&route_set_src_cmd
);
1576 install_element(RMAP_NODE
, &match_ip_nexthop_prefix_len_cmd
);
1577 install_element(RMAP_NODE
, &no_match_ip_nexthop_prefix_len_cmd
);
1578 install_element(RMAP_NODE
, &match_ip_address_prefix_len_cmd
);
1579 install_element(RMAP_NODE
, &match_ipv6_address_prefix_len_cmd
);
1580 install_element(RMAP_NODE
, &no_match_ipv6_address_prefix_len_cmd
);
1581 install_element(RMAP_NODE
, &no_match_ip_address_prefix_len_cmd
);
1582 install_element(RMAP_NODE
, &match_source_protocol_cmd
);
1583 install_element(RMAP_NODE
, &no_match_source_protocol_cmd
);
1584 install_element(RMAP_NODE
, &match_source_instance_cmd
);
1585 install_element(RMAP_NODE
, &no_match_source_instance_cmd
);
1588 install_element(RMAP_NODE
, &set_src_cmd
);
1589 install_element(RMAP_NODE
, &no_set_src_cmd
);