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
32 #include "northbound_cli.h"
33 #include "lib/route_types.h"
37 #include "zebra/zebra_router.h"
38 #include "zebra/redistribute.h"
39 #include "zebra/debug.h"
40 #include "zebra/zebra_rnh.h"
41 #include "zebra/zebra_routemap.h"
43 #include "zebra/zebra_routemap_clippy.c"
45 static uint32_t zebra_rmap_update_timer
= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
;
46 static struct thread
*zebra_t_rmap_update
= NULL
;
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 * Match function return 1 if match is success else return 0
63 static enum route_map_cmd_result_t
64 route_match_tag(void *rule
, const struct prefix
*prefix
, void *object
)
67 struct nh_rmap_obj
*nh_data
;
72 if (nh_data
->tag
== *tag
)
78 /* Route map commands for tag matching */
79 static const struct route_map_rule_cmd route_match_tag_cmd
= {
82 route_map_rule_tag_compile
,
83 route_map_rule_tag_free
,
87 /* `match interface IFNAME' */
88 /* Match function return 1 if match is success else return zero. */
89 static enum route_map_cmd_result_t
90 route_match_interface(void *rule
, const struct prefix
*prefix
, void *object
)
92 struct nh_rmap_obj
*nh_data
;
96 if (strcasecmp(ifname
, "any") == 0)
99 if (!nh_data
|| !nh_data
->nexthop
)
101 ifindex
= ifname2ifindex(ifname
, nh_data
->vrf_id
);
104 if (nh_data
->nexthop
->ifindex
== ifindex
)
110 /* Route map `match interface' match statement. `arg' is IFNAME value */
111 static void *route_match_interface_compile(const char *arg
)
113 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
116 /* Free route map's compiled `match interface' value. */
117 static void route_match_interface_free(void *rule
)
119 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
122 static void show_vrf_proto_rm(struct vty
*vty
, struct zebra_vrf
*zvrf
,
127 vty_out(vty
, "Protocol : route-map\n");
128 vty_out(vty
, "-------------------------------------\n");
130 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
131 if (PROTO_RM_NAME(zvrf
, af_type
, i
))
132 vty_out(vty
, "%-24s : %-10s\n", zebra_route_string(i
),
133 PROTO_RM_NAME(zvrf
, af_type
, i
));
135 vty_out(vty
, "%-24s : none\n", zebra_route_string(i
));
138 if (PROTO_RM_NAME(zvrf
, af_type
, i
))
139 vty_out(vty
, "%-24s : %-10s\n", "any",
140 PROTO_RM_NAME(zvrf
, af_type
, i
));
142 vty_out(vty
, "%-24s : none\n", "any");
145 static void show_vrf_nht_rm(struct vty
*vty
, struct zebra_vrf
*zvrf
,
146 int af_type
, json_object
*json
)
151 vty_out(vty
, "Protocol : route-map\n");
152 vty_out(vty
, "-------------------------------------\n");
155 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
157 if (NHT_RM_NAME(zvrf
, af_type
, i
))
158 json_object_string_add(
159 json
, zebra_route_string(i
),
160 NHT_RM_NAME(zvrf
, af_type
, i
));
162 json_object_string_add(
163 json
, zebra_route_string(i
), "none");
165 if (NHT_RM_NAME(zvrf
, af_type
, i
))
166 vty_out(vty
, "%-24s : %-10s\n",
167 zebra_route_string(i
),
168 NHT_RM_NAME(zvrf
, af_type
, i
));
170 vty_out(vty
, "%-24s : none\n",
171 zebra_route_string(i
));
176 if (NHT_RM_NAME(zvrf
, af_type
, i
))
177 json_object_string_add(json
, "any",
178 NHT_RM_NAME(zvrf
, af_type
, i
));
180 json_object_string_add(json
, "any", "none");
182 if (NHT_RM_NAME(zvrf
, af_type
, i
))
183 vty_out(vty
, "%-24s : %-10s\n", "any",
184 NHT_RM_NAME(zvrf
, af_type
, i
));
186 vty_out(vty
, "%-24s : none\n", "any");
190 static int show_proto_rm(struct vty
*vty
, int af_type
, const char *vrf_all
,
191 const char *vrf_name
)
193 struct zebra_vrf
*zvrf
;
198 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
199 zvrf
= (struct zebra_vrf
*)vrf
->info
;
202 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
203 show_vrf_proto_rm(vty
, zvrf
, af_type
);
206 vrf_id_t vrf_id
= VRF_DEFAULT
;
209 VRF_GET_ID(vrf_id
, vrf_name
, false);
211 zvrf
= zebra_vrf_lookup_by_id(vrf_id
);
215 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
216 show_vrf_proto_rm(vty
, zvrf
, af_type
);
222 static int show_nht_rm(struct vty
*vty
, int af_type
, const char *vrf_all
,
223 const char *vrf_name
, bool use_json
)
225 struct zebra_vrf
*zvrf
;
226 json_object
*json
= NULL
;
227 json_object
*json_vrfs
= NULL
;
230 json
= json_object_new_object();
231 json_vrfs
= json_object_new_object();
232 json_object_string_add(json
, "afi",
233 (af_type
== AFI_IP
) ? "ipv4" : "ipv6");
240 json_object_object_add(json
, "vrfs", json_vrfs
);
242 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
243 zvrf
= (struct zebra_vrf
*)vrf
->info
;
248 json_object
*json_proto
= NULL
;
249 json_object
*json_vrf
= NULL
;
250 json_vrf
= json_object_new_object();
251 json_object_object_add(
252 json_vrfs
, zvrf
->vrf
->name
, json_vrf
);
253 json_proto
= json_object_new_object();
254 json_object_object_add(json_vrf
, "protocols",
256 show_vrf_nht_rm(vty
, zvrf
, af_type
, json_proto
);
258 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
259 show_vrf_nht_rm(vty
, zvrf
, af_type
, NULL
);
263 json_object
*json_proto
= NULL
;
264 json_object
*json_vrf
= NULL
;
265 vrf_id_t vrf_id
= VRF_DEFAULT
;
268 VRF_GET_ID(vrf_id
, vrf_name
, false);
270 zvrf
= zebra_vrf_lookup_by_id(vrf_id
);
272 json_object_free(json
);
273 json_object_free(json_vrfs
);
278 json_object_object_add(json
, "vrfs", json_vrfs
);
279 json_vrf
= json_object_new_object();
280 json_object_object_add(json_vrfs
, zvrf
->vrf
->name
,
282 json_proto
= json_object_new_object();
283 json_object_object_add(json_vrf
, "protocols",
285 show_vrf_nht_rm(vty
, zvrf
, af_type
, json_proto
);
287 vty_out(vty
, "VRF: %s\n", zvrf
->vrf
->name
);
288 show_vrf_nht_rm(vty
, zvrf
, af_type
, NULL
);
298 /* Route map commands for interface matching */
299 static const struct route_map_rule_cmd route_match_interface_cmd
= {
301 route_match_interface
,
302 route_match_interface_compile
,
303 route_match_interface_free
306 static int ip_protocol_rm_add(struct zebra_vrf
*zvrf
, const char *rmap
,
307 int rtype
, afi_t afi
, safi_t safi
)
309 struct route_table
*table
;
311 if (PROTO_RM_NAME(zvrf
, afi
, rtype
)) {
312 if (strcmp(PROTO_RM_NAME(zvrf
, afi
, rtype
), rmap
) == 0)
315 XFREE(MTYPE_ROUTE_MAP_NAME
, PROTO_RM_NAME(zvrf
, afi
, rtype
));
317 route_map_counter_decrement(PROTO_RM_MAP(zvrf
, afi
, rtype
));
318 PROTO_RM_NAME(zvrf
, afi
, rtype
) = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
319 PROTO_RM_MAP(zvrf
, afi
, rtype
) =
320 route_map_lookup_by_name(PROTO_RM_NAME(zvrf
, afi
, rtype
));
321 route_map_counter_increment(PROTO_RM_MAP(zvrf
, afi
, rtype
));
323 if (PROTO_RM_MAP(zvrf
, afi
, rtype
)) {
325 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
327 "%u: IPv4 Routemap config for protocol %d scheduling RIB processing",
328 zvrf
->vrf
->vrf_id
, rtype
);
329 /* Process routes of interested address-families. */
330 table
= zebra_vrf_table(afi
, safi
, zvrf
->vrf
->vrf_id
);
332 rib_update_table(table
, RIB_UPDATE_RMAP_CHANGE
,
339 static int ip_protocol_rm_del(struct zebra_vrf
*zvrf
, const char *rmap
,
340 int rtype
, afi_t afi
, safi_t safi
)
342 struct route_table
*table
;
344 if (!PROTO_RM_NAME(zvrf
, afi
, rtype
))
347 if (!rmap
|| strcmp(rmap
, PROTO_RM_NAME(zvrf
, afi
, rtype
)) == 0) {
349 route_map_counter_decrement(PROTO_RM_MAP(zvrf
, afi
, rtype
));
350 if (PROTO_RM_MAP(zvrf
, afi
, rtype
)) {
351 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
353 "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
354 zvrf
->vrf
->vrf_id
, rtype
);
355 PROTO_RM_MAP(zvrf
, afi
, rtype
) = NULL
;
357 /* Process routes of interested address-families. */
358 table
= zebra_vrf_table(afi
, safi
, zvrf
->vrf
->vrf_id
);
360 rib_update_table(table
, RIB_UPDATE_RMAP_CHANGE
,
363 XFREE(MTYPE_ROUTE_MAP_NAME
, PROTO_RM_NAME(zvrf
, afi
, rtype
));
368 static int ip_nht_rm_add(struct zebra_vrf
*zvrf
, const char *rmap
, int rtype
,
372 if (NHT_RM_NAME(zvrf
, afi
, rtype
)) {
373 if (strcmp(NHT_RM_NAME(zvrf
, afi
, rtype
), rmap
) == 0)
376 XFREE(MTYPE_ROUTE_MAP_NAME
, NHT_RM_NAME(zvrf
, afi
, rtype
));
378 route_map_counter_decrement(NHT_RM_MAP(zvrf
, afi
, rtype
));
379 NHT_RM_NAME(zvrf
, afi
, rtype
) = XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
380 NHT_RM_MAP(zvrf
, afi
, rtype
) =
381 route_map_lookup_by_name(NHT_RM_NAME(zvrf
, afi
, rtype
));
382 route_map_counter_increment(NHT_RM_MAP(zvrf
, afi
, rtype
));
384 if (NHT_RM_MAP(zvrf
, afi
, rtype
))
385 zebra_evaluate_rnh(zvrf
, AFI_IP
, 1, NULL
, SAFI_UNICAST
);
390 static int ip_nht_rm_del(struct zebra_vrf
*zvrf
, const char *rmap
, int rtype
,
394 if (!NHT_RM_NAME(zvrf
, afi
, rtype
))
397 if (!rmap
|| strcmp(rmap
, NHT_RM_NAME(zvrf
, afi
, rtype
)) == 0) {
398 route_map_counter_decrement(NHT_RM_MAP(zvrf
, afi
, rtype
));
399 if (NHT_RM_MAP(zvrf
, afi
, rtype
)) {
400 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
402 "%u: IPv4 Routemap unconfig for protocol %d, scheduling RIB processing",
403 zvrf
->vrf
->vrf_id
, rtype
);
404 NHT_RM_MAP(zvrf
, afi
, rtype
) = NULL
;
406 zebra_evaluate_rnh(zvrf
, AFI_IP
, 1, NULL
, SAFI_UNICAST
);
408 XFREE(MTYPE_ROUTE_MAP_NAME
, NHT_RM_NAME(zvrf
, afi
, rtype
));
414 match_ip_address_prefix_len
, match_ip_address_prefix_len_cmd
,
415 "match ip address prefix-len (0-32)$length",
418 "Match prefix length of IP address\n"
419 "Match prefix length of IP address\n"
423 "./match-condition[condition='frr-zebra-route-map:ipv4-prefix-length']";
424 char xpath_value
[XPATH_MAXLEN
];
426 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
428 xpath_value
, sizeof(xpath_value
),
429 "%s/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length",
431 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
, length_str
);
433 return nb_cli_apply_changes(vty
, NULL
);
437 no_match_ip_address_prefix_len
, 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"
447 "./match-condition[condition='frr-zebra-route-map:ipv4-prefix-length']";
449 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
451 return nb_cli_apply_changes(vty
, NULL
);
455 match_ipv6_address_prefix_len
, match_ipv6_address_prefix_len_cmd
,
456 "match ipv6 address prefix-len (0-128)$length",
459 "Match prefix length of IPv6 address\n"
460 "Match prefix length of IPv6 address\n"
464 "./match-condition[condition='frr-zebra-route-map:ipv6-prefix-length']";
465 char xpath_value
[XPATH_MAXLEN
];
467 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
469 xpath_value
, sizeof(xpath_value
),
470 "%s/rmap-match-condition/frr-zebra-route-map:ipv6-prefix-length",
472 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
, length_str
);
474 return nb_cli_apply_changes(vty
, NULL
);
478 no_match_ipv6_address_prefix_len
, no_match_ipv6_address_prefix_len_cmd
,
479 "no match ipv6 address prefix-len [(0-128)]",
483 "Match prefix length of IPv6 address\n"
484 "Match prefix length of IPv6 address\n"
488 "./match-condition[condition='frr-zebra-route-map:ipv6-prefix-length']";
490 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
492 return nb_cli_apply_changes(vty
, NULL
);
496 match_ip_nexthop_prefix_len
, match_ip_nexthop_prefix_len_cmd
,
497 "match ip next-hop prefix-len (0-32)$length",
500 "Match prefixlen of nexthop IP address\n"
501 "Match prefixlen of given nexthop\n"
505 "./match-condition[condition='frr-zebra-route-map:ipv4-next-hop-prefix-length']";
506 char xpath_value
[XPATH_MAXLEN
];
508 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
510 xpath_value
, sizeof(xpath_value
),
511 "%s/rmap-match-condition/frr-zebra-route-map:ipv4-prefix-length",
513 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
, length_str
);
515 return nb_cli_apply_changes(vty
, NULL
);
519 no_match_ip_nexthop_prefix_len
, no_match_ip_nexthop_prefix_len_cmd
,
520 "no match ip next-hop prefix-len [(0-32)]",
524 "Match prefixlen of nexthop IP address\n"
525 "Match prefix length of nexthop\n"
529 "./match-condition[condition='frr-zebra-route-map:ipv4-next-hop-prefix-length']";
531 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
533 return nb_cli_apply_changes(vty
, NULL
);
537 match_source_protocol
, match_source_protocol_cmd
,
538 "match source-protocol " FRR_REDIST_STR_ZEBRA
"$proto",
540 "Match protocol via which the route was learnt\n"
541 FRR_REDIST_HELP_STR_ZEBRA
)
544 "./match-condition[condition='frr-zebra-route-map:source-protocol']";
545 char xpath_value
[XPATH_MAXLEN
];
547 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
548 snprintf(xpath_value
, sizeof(xpath_value
),
549 "%s/rmap-match-condition/frr-zebra-route-map:source-protocol",
551 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
, proto
);
553 return nb_cli_apply_changes(vty
, NULL
);
557 no_match_source_protocol
, no_match_source_protocol_cmd
,
558 "no match source-protocol [" FRR_REDIST_STR_ZEBRA
"]",
561 "Match protocol via which the route was learnt\n"
562 FRR_REDIST_HELP_STR_ZEBRA
)
565 "./match-condition[condition='frr-zebra-route-map:source-protocol']";
567 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
569 return nb_cli_apply_changes(vty
, NULL
);
573 match_source_instance
, match_source_instance_cmd
,
574 "match source-instance (0-255)$instance",
576 "Match the protocol's instance number\n"
577 "The instance number\n")
580 "./match-condition[condition='frr-zebra-route-map:source-instance']";
581 char xpath_value
[XPATH_MAXLEN
];
583 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
584 snprintf(xpath_value
, sizeof(xpath_value
),
585 "%s/rmap-match-condition/frr-zebra-route-map:source-instance",
587 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
, instance_str
);
589 return nb_cli_apply_changes(vty
, NULL
);
593 no_match_source_instance
, no_match_source_instance_cmd
,
594 "no match source-instance [(0-255)]",
596 "Match the protocol's instance number\n"
597 "The instance number\n")
600 "./match-condition[condition='frr-zebra-route-map:source-instance']";
602 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
604 return nb_cli_apply_changes(vty
, NULL
);
610 set_src
, set_src_cmd
,
611 "set src <A.B.C.D$addrv4|X:X::X:X$addrv6>",
613 "src address for route\n"
615 "IPv6 src address\n")
618 "./set-action[action='frr-zebra-route-map:src-address']";
619 char xpath_value
[XPATH_MAXLEN
];
621 nb_cli_enqueue_change(vty
, xpath
, NB_OP_CREATE
, NULL
);
624 xpath_value
, sizeof(xpath_value
),
625 "%s/rmap-set-action/frr-zebra-route-map:ipv4-src-address",
627 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
,
631 xpath_value
, sizeof(xpath_value
),
632 "%s/rmap-set-action/frr-zebra-route-map:ipv6-src-address",
634 nb_cli_enqueue_change(vty
, xpath_value
, NB_OP_MODIFY
,
638 return nb_cli_apply_changes(vty
, NULL
);
642 no_set_src
, no_set_src_cmd
,
643 "no set src [<A.B.C.D|X:X::X:X>]",
646 "Source address for route\n"
651 "./set-action[action='frr-zebra-route-map:src-address']";
653 nb_cli_enqueue_change(vty
, xpath
, NB_OP_DESTROY
, NULL
);
655 return nb_cli_apply_changes(vty
, NULL
);
658 DEFUN_YANG (zebra_route_map_timer
,
659 zebra_route_map_timer_cmd
,
660 "zebra route-map delay-timer (0-600)",
662 "Set route-map parameters\n"
663 "Time to wait before route-map updates are processed\n"
664 "0 means route-map changes are run immediately instead of delaying\n")
667 uint32_t rmap_delay_timer
;
669 rmap_delay_timer
= strtoul(argv
[idx_number
]->arg
, NULL
, 10);
670 zebra_route_map_set_delay_timer(rmap_delay_timer
);
672 return (CMD_SUCCESS
);
675 DEFUN_YANG (no_zebra_route_map_timer
,
676 no_zebra_route_map_timer_cmd
,
677 "no zebra route-map delay-timer [(0-600)]",
680 "Set route-map parameters\n"
681 "Reset delay-timer to default value, 30 secs\n"
682 "0 means route-map changes are run immediately instead of delaying\n")
684 zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
);
686 return (CMD_SUCCESS
);
689 DEFPY_YANG (ip_protocol
,
691 "ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
692 " $proto route-map ROUTE-MAP$rmap",
694 "Filter routing info exchanged between zebra and protocol\n"
695 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
696 "Specify route-map\n"
704 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
709 if (strcasecmp(proto
, "any") == 0)
710 rtype
= ZEBRA_ROUTE_MAX
;
712 rtype
= proto_name2num(proto
);
714 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
715 return CMD_WARNING_CONFIG_FAILED
;
718 ret
= ip_protocol_rm_add(zvrf
, rmap
, rtype
, AFI_IP
, SAFI_UNICAST
);
723 DEFPY_YANG (no_ip_protocol
,
725 "no ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
726 " $proto [route-map ROUTE-MAP$rmap]",
729 "Stop filtering routing info between zebra and protocol\n"
730 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
731 "Specify route-map\n"
738 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
743 if (strcasecmp(proto
, "any") == 0)
744 rtype
= ZEBRA_ROUTE_MAX
;
746 rtype
= proto_name2num(proto
);
748 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
749 return CMD_WARNING_CONFIG_FAILED
;
752 ret
= ip_protocol_rm_del(zvrf
, rmap
, rtype
, AFI_IP
, SAFI_UNICAST
);
757 DEFPY_YANG (show_ip_protocol
,
758 show_ip_protocol_cmd
,
759 "show ip protocol [vrf <NAME$vrf_name|all$vrf_all>]",
762 "IP protocol filtering status\n"
763 VRF_FULL_CMD_HELP_STR
)
765 int ret
= show_proto_rm(vty
, AFI_IP
, vrf_all
, vrf_name
);
770 DEFPY_YANG (ipv6_protocol
,
772 "ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
773 " $proto route-map ROUTE-MAP$rmap",
775 "Filter IPv6 routing info exchanged between zebra and protocol\n"
776 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
777 "Specify route-map\n"
785 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
790 if (strcasecmp(proto
, "any") == 0)
791 rtype
= ZEBRA_ROUTE_MAX
;
793 rtype
= proto_name2num(proto
);
795 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
796 return CMD_WARNING_CONFIG_FAILED
;
799 ret
= ip_protocol_rm_add(zvrf
, rmap
, rtype
, AFI_IP6
, SAFI_UNICAST
);
804 DEFPY_YANG (no_ipv6_protocol
,
805 no_ipv6_protocol_cmd
,
806 "no ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
807 " $proto [route-map ROUTE-MAP$rmap]",
810 "Stop filtering IPv6 routing info between zebra and protocol\n"
811 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
812 "Specify route-map\n"
819 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
824 if (strcasecmp(proto
, "any") == 0)
825 rtype
= ZEBRA_ROUTE_MAX
;
827 rtype
= proto_name2num(proto
);
829 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
830 return CMD_WARNING_CONFIG_FAILED
;
833 ret
= ip_protocol_rm_del(zvrf
, rmap
, rtype
, AFI_IP6
, SAFI_UNICAST
);
838 DEFPY_YANG (show_ipv6_protocol
,
839 show_ipv6_protocol_cmd
,
840 "show ipv6 protocol [vrf <NAME$vrf_name|all$vrf_all>]",
843 "IPv6 protocol filtering status\n"
844 VRF_FULL_CMD_HELP_STR
)
846 int ret
= show_proto_rm(vty
, AFI_IP6
, vrf_all
, vrf_name
);
851 DEFPY_YANG (ip_protocol_nht_rmap
,
852 ip_protocol_nht_rmap_cmd
,
853 "ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
854 " $proto route-map ROUTE-MAP$rmap",
856 "Filter Next Hop tracking route resolution\n"
857 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
858 "Specify route map\n"
867 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
872 if (strcasecmp(proto
, "any") == 0)
873 rtype
= ZEBRA_ROUTE_MAX
;
875 rtype
= proto_name2num(proto
);
877 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
878 return CMD_WARNING_CONFIG_FAILED
;
881 ret
= ip_nht_rm_add(zvrf
, rmap
, rtype
, AFI_IP
);
886 DEFPY_YANG (no_ip_protocol_nht_rmap
,
887 no_ip_protocol_nht_rmap_cmd
,
888 "no ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA
889 " $proto route-map [ROUTE-MAP$rmap]",
892 "Filter Next Hop tracking route resolution\n"
893 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
894 "Specify route map\n"
901 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
906 if (strcasecmp(proto
, "any") == 0)
907 rtype
= ZEBRA_ROUTE_MAX
;
909 rtype
= proto_name2num(proto
);
911 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
912 return CMD_WARNING_CONFIG_FAILED
;
915 ret
= ip_nht_rm_del(zvrf
, rmap
, rtype
, AFI_IP
);
920 DEFPY_YANG (show_ip_protocol_nht
,
921 show_ip_protocol_nht_cmd
,
922 "show ip nht route-map [vrf <NAME$vrf_name|all$vrf_all>] [json]",
925 "IPv4 nexthop tracking table\n"
926 "IPv4 Next Hop tracking filtering status\n"
932 bool uj
= use_json(argc
, argv
);
934 ret
= show_nht_rm(vty
, AFI_IP
, vrf_all
, vrf_name
, uj
);
939 DEFPY_YANG (ipv6_protocol_nht_rmap
,
940 ipv6_protocol_nht_rmap_cmd
,
941 "ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
942 " $proto route-map ROUTE-MAP$rmap",
944 "Filter Next Hop tracking route resolution\n"
945 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
946 "Specify route map\n"
954 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
959 if (strcasecmp(proto
, "any") == 0)
960 rtype
= ZEBRA_ROUTE_MAX
;
962 rtype
= proto_name2num(proto
);
964 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
965 return CMD_WARNING_CONFIG_FAILED
;
968 ret
= ip_nht_rm_add(zvrf
, rmap
, rtype
, AFI_IP6
);
973 DEFPY_YANG (no_ipv6_protocol_nht_rmap
,
974 no_ipv6_protocol_nht_rmap_cmd
,
975 "no ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA
976 " $proto [route-map ROUTE-MAP$rmap]",
979 "Filter Next Hop tracking route resolution\n"
980 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
981 "Specify route map\n"
988 ZEBRA_DECLVAR_CONTEXT_VRF(vrf
, zvrf
);
993 if (strcasecmp(proto
, "any") == 0)
994 rtype
= ZEBRA_ROUTE_MAX
;
996 rtype
= proto_name2num(proto
);
998 vty_out(vty
, "invalid protocol name \"%s\"\n", proto
);
999 return CMD_WARNING_CONFIG_FAILED
;
1002 ret
= ip_nht_rm_del(zvrf
, rmap
, rtype
, AFI_IP6
);
1007 DEFPY_YANG (show_ipv6_protocol_nht
,
1008 show_ipv6_protocol_nht_cmd
,
1009 "show ipv6 nht route-map [vrf <NAME$vrf_name|all$vrf_all>] [json]",
1012 "IPv6 nexthop tracking table\n"
1013 "IPv6 Next Hop tracking filtering status\n"
1019 bool uj
= use_json(argc
, argv
);
1021 ret
= show_nht_rm(vty
, AFI_IP6
, vrf_all
, vrf_name
, uj
);
1026 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
1028 /* `match ip next-hop IP_ACCESS_LIST' */
1030 /* Match function return 1 if match is success else return zero. */
1031 static enum route_map_cmd_result_t
1032 route_match_ip_next_hop(void *rule
, const struct prefix
*prefix
, void *object
)
1034 struct access_list
*alist
;
1035 struct nh_rmap_obj
*nh_data
;
1036 struct prefix_ipv4 p
;
1040 return RMAP_NOMATCH
;
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
? RMAP_NOMATCH
1063 /* Route map `ip next-hop' match statement. `arg' should be
1064 access-list name. */
1065 static void *route_match_ip_next_hop_compile(const char *arg
)
1067 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1070 /* Free route map's compiled `. */
1071 static void route_match_ip_next_hop_free(void *rule
)
1073 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1076 /* Route map commands for ip next-hop matching. */
1077 static const struct route_map_rule_cmd route_match_ip_next_hop_cmd
= {
1079 route_match_ip_next_hop
,
1080 route_match_ip_next_hop_compile
,
1081 route_match_ip_next_hop_free
1084 /* `match ip next-hop prefix-list PREFIX_LIST' */
1086 static enum route_map_cmd_result_t
1087 route_match_ip_next_hop_prefix_list(void *rule
, const struct prefix
*prefix
,
1090 struct prefix_list
*plist
;
1091 struct nh_rmap_obj
*nh_data
;
1092 struct prefix_ipv4 p
;
1094 nh_data
= (struct nh_rmap_obj
*)object
;
1096 return RMAP_NOMATCH
;
1098 switch (nh_data
->nexthop
->type
) {
1099 case NEXTHOP_TYPE_IFINDEX
:
1100 /* Interface routes can't match ip next-hop */
1101 return RMAP_NOMATCH
;
1102 case NEXTHOP_TYPE_IPV4_IFINDEX
:
1103 case NEXTHOP_TYPE_IPV4
:
1105 p
.prefix
= nh_data
->nexthop
->gate
.ipv4
;
1106 p
.prefixlen
= IPV4_MAX_BITLEN
;
1109 return RMAP_NOMATCH
;
1111 plist
= prefix_list_lookup(AFI_IP
, (char *)rule
);
1113 return RMAP_NOMATCH
;
1115 return (prefix_list_apply(plist
, &p
) == PREFIX_DENY
? RMAP_NOMATCH
1119 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg
)
1121 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1124 static void route_match_ip_next_hop_prefix_list_free(void *rule
)
1126 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1129 static const struct route_map_rule_cmd
1130 route_match_ip_next_hop_prefix_list_cmd
= {
1131 "ip next-hop prefix-list",
1132 route_match_ip_next_hop_prefix_list
,
1133 route_match_ip_next_hop_prefix_list_compile
,
1134 route_match_ip_next_hop_prefix_list_free
1137 /* `match ip address IP_ACCESS_LIST' */
1139 /* Match function should return 1 if match is success else return
1141 static enum route_map_cmd_result_t
1142 route_match_address(afi_t afi
, void *rule
, const struct prefix
*prefix
,
1145 struct access_list
*alist
;
1147 alist
= access_list_lookup(afi
, (char *)rule
);
1149 return RMAP_NOMATCH
;
1151 return (access_list_apply(alist
, prefix
) == FILTER_DENY
? RMAP_NOMATCH
1155 static enum route_map_cmd_result_t
1156 route_match_ip_address(void *rule
, const struct prefix
*prefix
, void *object
)
1158 return route_match_address(AFI_IP
, rule
, prefix
, object
);
1161 static enum route_map_cmd_result_t
1162 route_match_ipv6_address(void *rule
, const struct prefix
*prefix
, void *object
)
1164 return route_match_address(AFI_IP6
, rule
, prefix
, object
);
1167 /* Route map `ip address' match statement. `arg' should be
1168 access-list name. */
1169 static void *route_match_address_compile(const char *arg
)
1171 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1174 /* Free route map's compiled `ip address' value. */
1175 static void route_match_address_free(void *rule
)
1177 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1180 /* Route map commands for ip address matching. */
1181 static const struct route_map_rule_cmd route_match_ip_address_cmd
= {
1183 route_match_ip_address
,
1184 route_match_address_compile
,
1185 route_match_address_free
1188 /* Route map commands for ipv6 address matching. */
1189 static const struct route_map_rule_cmd route_match_ipv6_address_cmd
= {
1191 route_match_ipv6_address
,
1192 route_match_address_compile
,
1193 route_match_address_free
1196 /* `match ip address prefix-list PREFIX_LIST' */
1198 static enum route_map_cmd_result_t
1199 route_match_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1200 void *object
, afi_t afi
)
1202 struct prefix_list
*plist
;
1204 plist
= prefix_list_lookup(afi
, (char *)rule
);
1206 return RMAP_NOMATCH
;
1208 return (prefix_list_apply(plist
, prefix
) == PREFIX_DENY
? RMAP_NOMATCH
1212 static enum route_map_cmd_result_t
1213 route_match_ip_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1216 return (route_match_address_prefix_list(rule
, prefix
, object
, AFI_IP
));
1219 static void *route_match_address_prefix_list_compile(const char *arg
)
1221 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1224 static void route_match_address_prefix_list_free(void *rule
)
1226 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1229 static const struct route_map_rule_cmd
1230 route_match_ip_address_prefix_list_cmd
= {
1231 "ip address prefix-list",
1232 route_match_ip_address_prefix_list
,
1233 route_match_address_prefix_list_compile
,
1234 route_match_address_prefix_list_free
1237 static enum route_map_cmd_result_t
1238 route_match_ipv6_address_prefix_list(void *rule
, const struct prefix
*prefix
,
1241 return (route_match_address_prefix_list(rule
, prefix
, object
, AFI_IP6
));
1244 static const struct route_map_rule_cmd
1245 route_match_ipv6_address_prefix_list_cmd
= {
1246 "ipv6 address prefix-list",
1247 route_match_ipv6_address_prefix_list
,
1248 route_match_address_prefix_list_compile
,
1249 route_match_address_prefix_list_free
1252 /* `match ipv6 next-hop type <TYPE>' */
1254 static enum route_map_cmd_result_t
1255 route_match_ipv6_next_hop_type(void *rule
, const struct prefix
*prefix
,
1258 struct nh_rmap_obj
*nh_data
;
1260 if (prefix
->family
== AF_INET6
) {
1261 nh_data
= (struct nh_rmap_obj
*)object
;
1263 return RMAP_NOMATCH
;
1265 if (nh_data
->nexthop
->type
== NEXTHOP_TYPE_BLACKHOLE
)
1269 return RMAP_NOMATCH
;
1272 static void *route_match_ipv6_next_hop_type_compile(const char *arg
)
1274 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED
, arg
);
1277 static void route_match_ipv6_next_hop_type_free(void *rule
)
1279 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1282 static const struct route_map_rule_cmd
1283 route_match_ipv6_next_hop_type_cmd
= {
1284 "ipv6 next-hop type",
1285 route_match_ipv6_next_hop_type
,
1286 route_match_ipv6_next_hop_type_compile
,
1287 route_match_ipv6_next_hop_type_free
1290 /* `match ip address prefix-len PREFIXLEN' */
1292 static enum route_map_cmd_result_t
1293 route_match_address_prefix_len(void *rule
, const struct prefix
*prefix
,
1296 uint32_t *prefixlen
= (uint32_t *)rule
;
1298 return ((prefix
->prefixlen
== *prefixlen
) ? RMAP_MATCH
: RMAP_NOMATCH
);
1301 static void *route_match_address_prefix_len_compile(const char *arg
)
1303 uint32_t *prefix_len
;
1304 char *endptr
= NULL
;
1305 unsigned long tmpval
;
1307 /* prefix len value shoud be integer. */
1308 if (!all_digit(arg
))
1312 tmpval
= strtoul(arg
, &endptr
, 10);
1313 if (*endptr
!= '\0' || errno
|| tmpval
> UINT32_MAX
)
1316 prefix_len
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1318 *prefix_len
= tmpval
;
1322 static void route_match_address_prefix_len_free(void *rule
)
1324 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1327 static const struct route_map_rule_cmd
1328 route_match_ip_address_prefix_len_cmd
= {
1329 "ip address prefix-len",
1330 route_match_address_prefix_len
,
1331 route_match_address_prefix_len_compile
,
1332 route_match_address_prefix_len_free
1335 static const struct route_map_rule_cmd
1336 route_match_ipv6_address_prefix_len_cmd
= {
1337 "ipv6 address prefix-len",
1338 route_match_address_prefix_len
,
1339 route_match_address_prefix_len_compile
,
1340 route_match_address_prefix_len_free
1343 /* `match ip nexthop prefix-len PREFIXLEN' */
1345 static enum route_map_cmd_result_t
1346 route_match_ip_nexthop_prefix_len(void *rule
, const struct prefix
*prefix
,
1349 uint32_t *prefixlen
= (uint32_t *)rule
;
1350 struct nh_rmap_obj
*nh_data
;
1351 struct prefix_ipv4 p
;
1353 nh_data
= (struct nh_rmap_obj
*)object
;
1354 if (!nh_data
|| !nh_data
->nexthop
)
1355 return RMAP_NOMATCH
;
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
: RMAP_NOMATCH
);
1373 static const struct route_map_rule_cmd
1374 route_match_ip_nexthop_prefix_len_cmd
= {
1375 "ip next-hop prefix-len",
1376 route_match_ip_nexthop_prefix_len
,
1377 route_match_address_prefix_len_compile
, /* reuse */
1378 route_match_address_prefix_len_free
/* reuse */
1381 /* `match ip next-hop type <blackhole>' */
1383 static enum route_map_cmd_result_t
1384 route_match_ip_next_hop_type(void *rule
, const struct prefix
*prefix
,
1387 struct nh_rmap_obj
*nh_data
;
1389 if (prefix
->family
== AF_INET
) {
1390 nh_data
= (struct nh_rmap_obj
*)object
;
1392 return RMAP_NOMATCH
;
1394 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 const struct route_map_rule_cmd
1412 route_match_ip_next_hop_type_cmd
= {
1414 route_match_ip_next_hop_type
,
1415 route_match_ip_next_hop_type_compile
,
1416 route_match_ip_next_hop_type_free
1419 /* `match source-protocol PROTOCOL' */
1421 static enum route_map_cmd_result_t
1422 route_match_source_protocol(void *rule
, const struct prefix
*p
, void *object
)
1424 uint32_t *rib_type
= (uint32_t *)rule
;
1425 struct nh_rmap_obj
*nh_data
;
1427 nh_data
= (struct nh_rmap_obj
*)object
;
1429 return RMAP_NOMATCH
;
1431 return ((nh_data
->source_protocol
== *rib_type
) ? RMAP_MATCH
1435 static void *route_match_source_protocol_compile(const char *arg
)
1440 i
= proto_name2num(arg
);
1441 rib_type
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint32_t));
1448 static void route_match_source_protocol_free(void *rule
)
1450 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1453 static const struct route_map_rule_cmd route_match_source_protocol_cmd
= {
1455 route_match_source_protocol
,
1456 route_match_source_protocol_compile
,
1457 route_match_source_protocol_free
1460 /* `source-instance` */
1461 static enum route_map_cmd_result_t
1462 route_match_source_instance(void *rule
, const struct prefix
*p
, void *object
)
1464 uint8_t *instance
= (uint8_t *)rule
;
1465 struct nh_rmap_obj
*nh_data
;
1467 nh_data
= (struct nh_rmap_obj
*)object
;
1469 return RMAP_NOMATCH
;
1471 return (nh_data
->instance
== *instance
) ? RMAP_MATCH
: RMAP_NOMATCH
;
1474 static void *route_match_source_instance_compile(const char *arg
)
1480 instance
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(uint8_t));
1487 static void route_match_source_instance_free(void *rule
)
1489 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1492 static const struct route_map_rule_cmd route_match_source_instance_cmd
= {
1494 route_match_source_instance
,
1495 route_match_source_instance_compile
,
1496 route_match_source_instance_free
1499 /* `set src A.B.C.D' */
1502 static enum route_map_cmd_result_t
1503 route_set_src(void *rule
, const struct prefix
*prefix
, void *object
)
1505 struct nh_rmap_obj
*nh_data
;
1507 nh_data
= (struct nh_rmap_obj
*)object
;
1508 nh_data
->nexthop
->rmap_src
= *(union g_addr
*)rule
;
1513 /* set src compilation. */
1514 static void *route_set_src_compile(const char *arg
)
1516 union g_addr src
, *psrc
;
1518 if ((inet_pton(AF_INET6
, arg
, &src
.ipv6
) == 1)
1519 || (inet_pton(AF_INET
, arg
, &src
.ipv4
) == 1)) {
1520 psrc
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(union g_addr
));
1527 /* Free route map's compiled `set src' value. */
1528 static void route_set_src_free(void *rule
)
1530 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
1533 /* Set src rule structure. */
1534 static const struct route_map_rule_cmd route_set_src_cmd
= {
1537 route_set_src_compile
,
1541 /* The function checks if the changed routemap specified by parameter rmap
1542 * matches the configured protocol routemaps in proto_rm table. If there is
1543 * a match then rib_update_table() to process the routes.
1545 static void zebra_rib_table_rm_update(const char *rmap
)
1548 struct route_table
*table
;
1549 struct vrf
*vrf
= NULL
;
1550 struct zebra_vrf
*zvrf
= NULL
;
1552 struct route_map
*old
= NULL
;
1554 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
1558 for (i
= 0; i
<= ZEBRA_ROUTE_MAX
; i
++) {
1559 rmap_name
= PROTO_RM_NAME(zvrf
, AFI_IP
, i
);
1560 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1561 if (IS_ZEBRA_DEBUG_EVENT
)
1563 "%s : AFI_IP rmap %s, route type %s",
1565 zebra_route_string(i
));
1567 old
= PROTO_RM_MAP(zvrf
, AFI_IP
, i
);
1569 PROTO_RM_MAP(zvrf
, AFI_IP
, i
) =
1570 route_map_lookup_by_name(rmap_name
);
1571 /* old is NULL. i.e Route map creation event.
1572 * So update applied_counter.
1573 * If Old is not NULL, i.e It may be routemap
1574 * updation or deletion.
1575 * So no need to update the counter.
1578 route_map_counter_increment(
1579 PROTO_RM_MAP(zvrf
, AFI_IP
, i
));
1580 /* There is single rib table for all protocols
1582 table
= zvrf
->table
[AFI_IP
][SAFI_UNICAST
];
1586 RIB_UPDATE_RMAP_CHANGE
,
1590 rmap_name
= PROTO_RM_NAME(zvrf
, AFI_IP6
, i
);
1591 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1592 if (IS_ZEBRA_DEBUG_EVENT
)
1594 "%s : AFI_IP6 rmap %s, route type %s",
1596 zebra_route_string(i
));
1598 old
= PROTO_RM_MAP(zvrf
, AFI_IP6
, i
);
1600 PROTO_RM_MAP(zvrf
, AFI_IP6
, i
) =
1601 route_map_lookup_by_name(rmap_name
);
1603 route_map_counter_increment(
1604 PROTO_RM_MAP(zvrf
, AFI_IP6
, i
));
1605 /* There is single rib table for all protocols
1607 table
= zvrf
->table
[AFI_IP6
][SAFI_UNICAST
];
1611 RIB_UPDATE_RMAP_CHANGE
,
1619 /* The function checks if the changed routemap specified by parameter rmap
1620 * matches the configured protocol routemaps in nht_rm table. If there is
1621 * a match then zebra_evaluate_rnh() to process the nexthops.
1623 static void zebra_nht_rm_update(const char *rmap
)
1626 struct route_table
*table
;
1627 struct vrf
*vrf
= NULL
;
1628 struct zebra_vrf
*zvrf
= NULL
;
1632 struct route_map
*old
= NULL
;
1634 RB_FOREACH (vrf
, vrf_name_head
, &vrfs_by_name
) {
1638 for (i
= 0; i
<= ZEBRA_ROUTE_MAX
; i
++) {
1639 rmap_name
= NHT_RM_NAME(zvrf
, AFI_IP
, i
);
1640 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1641 if (IS_ZEBRA_DEBUG_EVENT
)
1643 "%s : AFI_IP rmap %s, route type %s",
1645 zebra_route_string(i
));
1647 old
= NHT_RM_MAP(zvrf
, AFI_IP
, i
);
1649 NHT_RM_MAP(zvrf
, AFI_IP
, i
) =
1650 route_map_lookup_by_name(rmap_name
);
1652 route_map_counter_increment(
1653 NHT_RM_MAP(zvrf
, AFI_IP
, i
));
1654 /* There is single rib table for all protocols
1657 table
= zvrf
->table
[AFI_IP
]
1664 zvrf
, AFI_IP
, 1, NULL
,
1670 rmap_name
= NHT_RM_NAME(zvrf
, AFI_IP6
, i
);
1671 if (rmap_name
&& (strcmp(rmap_name
, rmap
) == 0)) {
1672 if (IS_ZEBRA_DEBUG_EVENT
)
1674 "%s : AFI_IP6 rmap %s, route type %s",
1676 zebra_route_string(i
));
1678 old
= NHT_RM_MAP(zvrf
, AFI_IP6
, i
);
1680 NHT_RM_MAP(zvrf
, AFI_IP6
, i
) =
1681 route_map_lookup_by_name(rmap_name
);
1683 route_map_counter_increment(
1684 NHT_RM_MAP(zvrf
, AFI_IP6
, i
));
1685 /* There is single rib table for all protocols
1687 if (afi_ipv6
== 0) {
1688 table
= zvrf
->table
[AFI_IP6
]
1695 zvrf
, AFI_IP
, 1, NULL
,
1704 static void zebra_route_map_process_update_cb(char *rmap_name
)
1706 if (IS_ZEBRA_DEBUG_EVENT
)
1707 zlog_debug("Event handler for route-map: %s",
1709 zebra_import_table_rm_update(rmap_name
);
1710 zebra_rib_table_rm_update(rmap_name
);
1711 zebra_nht_rm_update(rmap_name
);
1714 static void zebra_route_map_update_timer(struct thread
*thread
)
1716 if (IS_ZEBRA_DEBUG_EVENT
)
1717 zlog_debug("Event driven route-map update triggered");
1719 if (IS_ZEBRA_DEBUG_RIB_DETAILED
)
1721 "%u: Routemap update-timer fired, scheduling RIB processing",
1724 route_map_walk_update_list(zebra_route_map_process_update_cb
);
1727 * This code needs to be updated to be:
1728 * 1) VRF Aware <sigh>
1729 * 2) Route-map aware
1733 static void zebra_route_map_set_delay_timer(uint32_t value
)
1735 zebra_rmap_update_timer
= value
;
1736 if (!value
&& zebra_t_rmap_update
) {
1737 /* Event driven route map updates is being disabled */
1738 /* But there's a pending timer. Fire it off now */
1739 THREAD_OFF(zebra_t_rmap_update
);
1740 zebra_route_map_update_timer(NULL
);
1744 void zebra_routemap_finish(void)
1746 /* Set zebra_rmap_update_timer to 0 so that it wont schedule again */
1747 zebra_rmap_update_timer
= 0;
1748 /* Thread off if any scheduled already */
1749 THREAD_OFF(zebra_t_rmap_update
);
1754 zebra_route_map_check(afi_t family
, int rib_type
, uint8_t instance
,
1755 const struct prefix
*p
, struct nexthop
*nexthop
,
1756 struct zebra_vrf
*zvrf
, route_tag_t tag
)
1758 struct route_map
*rmap
= NULL
;
1760 route_map_result_t ret
= RMAP_PERMITMATCH
;
1761 struct nh_rmap_obj nh_obj
;
1763 nh_obj
.nexthop
= nexthop
;
1764 nh_obj
.vrf_id
= nexthop
->vrf_id
;
1765 nh_obj
.source_protocol
= rib_type
;
1766 nh_obj
.instance
= instance
;
1770 if (rib_type
>= 0 && rib_type
< ZEBRA_ROUTE_MAX
) {
1771 rm_name
= PROTO_RM_NAME(zvrf
, family
, rib_type
);
1772 rmap
= PROTO_RM_MAP(zvrf
, family
, rib_type
);
1774 if (rm_name
&& !rmap
)
1775 return RMAP_DENYMATCH
;
1778 rm_name
= PROTO_RM_NAME(zvrf
, family
, ZEBRA_ROUTE_MAX
);
1779 rmap
= PROTO_RM_MAP(zvrf
, family
, ZEBRA_ROUTE_MAX
);
1781 if (rm_name
&& !rmap
)
1782 return RMAP_DENYMATCH
;
1785 ret
= route_map_apply(rmap
, p
, &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
, &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_PERMITMATCH
;
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
, &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
)
1866 THREAD_OFF(zebra_t_rmap_update
);
1868 thread_add_timer(zrouter
.master
, zebra_route_map_update_timer
,
1869 NULL
, zebra_rmap_update_timer
, &zebra_t_rmap_update
);
1872 static void zebra_route_map_add(const char *rmap_name
)
1874 if (route_map_mark_updated(rmap_name
) == 0)
1875 zebra_route_map_mark_update(rmap_name
);
1877 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1880 static void zebra_route_map_delete(const char *rmap_name
)
1882 if (route_map_mark_updated(rmap_name
) == 0)
1883 zebra_route_map_mark_update(rmap_name
);
1885 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_DELETED
);
1888 static void zebra_route_map_event(const char *rmap_name
)
1890 if (route_map_mark_updated(rmap_name
) == 0)
1891 zebra_route_map_mark_update(rmap_name
);
1893 route_map_notify_dependencies(rmap_name
, RMAP_EVENT_MATCH_ADDED
);
1896 void zebra_routemap_vrf_delete(struct zebra_vrf
*zvrf
)
1901 for (afi
= AFI_IP
; afi
< AFI_MAX
; afi
++) {
1902 for (type
= 0; type
<= ZEBRA_ROUTE_MAX
; type
++) {
1903 if (PROTO_RM_NAME(zvrf
, afi
, type
))
1904 XFREE(MTYPE_ROUTE_MAP_NAME
,
1905 PROTO_RM_NAME(zvrf
, afi
, type
));
1906 if (NHT_RM_NAME(zvrf
, afi
, type
))
1907 XFREE(MTYPE_ROUTE_MAP_NAME
,
1908 NHT_RM_NAME(zvrf
, afi
, type
));
1913 /* ip protocol configuration write function */
1914 void zebra_routemap_config_write_protocol(struct vty
*vty
,
1915 struct zebra_vrf
*zvrf
)
1920 memset(space
, 0, sizeof(space
));
1922 if (zvrf_id(zvrf
) != VRF_DEFAULT
)
1923 snprintf(space
, sizeof(space
), "%s", " ");
1925 for (i
= 0; i
< ZEBRA_ROUTE_MAX
; i
++) {
1926 if (PROTO_RM_NAME(zvrf
, AFI_IP
, i
))
1927 vty_out(vty
, "%sip protocol %s route-map %s\n", space
,
1928 zebra_route_string(i
),
1929 PROTO_RM_NAME(zvrf
, AFI_IP
, i
));
1931 if (PROTO_RM_NAME(zvrf
, AFI_IP6
, i
))
1932 vty_out(vty
, "%sipv6 protocol %s route-map %s\n", space
,
1933 zebra_route_string(i
),
1934 PROTO_RM_NAME(zvrf
, AFI_IP6
, i
));
1936 if (NHT_RM_NAME(zvrf
, AFI_IP
, i
))
1937 vty_out(vty
, "%sip nht %s route-map %s\n", space
,
1938 zebra_route_string(i
),
1939 NHT_RM_NAME(zvrf
, AFI_IP
, i
));
1941 if (NHT_RM_NAME(zvrf
, AFI_IP6
, i
))
1942 vty_out(vty
, "%sipv6 nht %s route-map %s\n", space
,
1943 zebra_route_string(i
),
1944 NHT_RM_NAME(zvrf
, AFI_IP6
, i
));
1947 if (PROTO_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
))
1948 vty_out(vty
, "%sip protocol %s route-map %s\n", space
, "any",
1949 PROTO_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
));
1951 if (PROTO_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
))
1952 vty_out(vty
, "%sipv6 protocol %s route-map %s\n", space
, "any",
1953 PROTO_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
));
1955 if (NHT_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
))
1956 vty_out(vty
, "%sip nht %s route-map %s\n", space
, "any",
1957 NHT_RM_NAME(zvrf
, AFI_IP
, ZEBRA_ROUTE_MAX
));
1959 if (NHT_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
))
1960 vty_out(vty
, "%sipv6 nht %s route-map %s\n", space
, "any",
1961 NHT_RM_NAME(zvrf
, AFI_IP6
, ZEBRA_ROUTE_MAX
));
1963 if (zvrf_id(zvrf
) == VRF_DEFAULT
1964 && zebra_rmap_update_timer
!= ZEBRA_RMAP_DEFAULT_UPDATE_TIMER
)
1965 vty_out(vty
, "zebra route-map delay-timer %d\n",
1966 zebra_rmap_update_timer
);
1969 void zebra_route_map_init(void)
1971 install_element(CONFIG_NODE
, &ip_protocol_cmd
);
1972 install_element(CONFIG_NODE
, &no_ip_protocol_cmd
);
1973 install_element(VRF_NODE
, &ip_protocol_cmd
);
1974 install_element(VRF_NODE
, &no_ip_protocol_cmd
);
1975 install_element(VIEW_NODE
, &show_ip_protocol_cmd
);
1976 install_element(CONFIG_NODE
, &ipv6_protocol_cmd
);
1977 install_element(CONFIG_NODE
, &no_ipv6_protocol_cmd
);
1978 install_element(VRF_NODE
, &ipv6_protocol_cmd
);
1979 install_element(VRF_NODE
, &no_ipv6_protocol_cmd
);
1980 install_element(VIEW_NODE
, &show_ipv6_protocol_cmd
);
1981 install_element(CONFIG_NODE
, &ip_protocol_nht_rmap_cmd
);
1982 install_element(CONFIG_NODE
, &no_ip_protocol_nht_rmap_cmd
);
1983 install_element(VRF_NODE
, &ip_protocol_nht_rmap_cmd
);
1984 install_element(VRF_NODE
, &no_ip_protocol_nht_rmap_cmd
);
1985 install_element(VIEW_NODE
, &show_ip_protocol_nht_cmd
);
1986 install_element(CONFIG_NODE
, &ipv6_protocol_nht_rmap_cmd
);
1987 install_element(CONFIG_NODE
, &no_ipv6_protocol_nht_rmap_cmd
);
1988 install_element(VRF_NODE
, &ipv6_protocol_nht_rmap_cmd
);
1989 install_element(VRF_NODE
, &no_ipv6_protocol_nht_rmap_cmd
);
1990 install_element(VIEW_NODE
, &show_ipv6_protocol_nht_cmd
);
1991 install_element(CONFIG_NODE
, &zebra_route_map_timer_cmd
);
1992 install_element(CONFIG_NODE
, &no_zebra_route_map_timer_cmd
);
1996 route_map_add_hook(zebra_route_map_add
);
1997 route_map_delete_hook(zebra_route_map_delete
);
1998 route_map_event_hook(zebra_route_map_event
);
2000 route_map_match_interface_hook(generic_match_add
);
2001 route_map_no_match_interface_hook(generic_match_delete
);
2003 route_map_match_ip_address_hook(generic_match_add
);
2004 route_map_no_match_ip_address_hook(generic_match_delete
);
2006 route_map_match_ip_address_prefix_list_hook(generic_match_add
);
2007 route_map_no_match_ip_address_prefix_list_hook(generic_match_delete
);
2009 route_map_match_ip_next_hop_hook(generic_match_add
);
2010 route_map_no_match_ip_next_hop_hook(generic_match_delete
);
2012 route_map_match_ip_next_hop_prefix_list_hook(generic_match_add
);
2013 route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete
);
2015 route_map_match_ip_next_hop_type_hook(generic_match_add
);
2016 route_map_no_match_ip_next_hop_type_hook(generic_match_delete
);
2018 route_map_match_tag_hook(generic_match_add
);
2019 route_map_no_match_tag_hook(generic_match_delete
);
2021 route_map_match_ipv6_address_hook(generic_match_add
);
2022 route_map_no_match_ipv6_address_hook(generic_match_delete
);
2024 route_map_match_ipv6_address_prefix_list_hook(generic_match_add
);
2025 route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete
);
2027 route_map_match_ipv6_next_hop_type_hook(generic_match_add
);
2028 route_map_no_match_ipv6_next_hop_type_hook(generic_match_delete
);
2030 route_map_install_match(&route_match_tag_cmd
);
2031 route_map_install_match(&route_match_interface_cmd
);
2032 route_map_install_match(&route_match_ip_next_hop_cmd
);
2033 route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd
);
2034 route_map_install_match(&route_match_ip_address_cmd
);
2035 route_map_install_match(&route_match_ipv6_address_cmd
);
2036 route_map_install_match(&route_match_ip_address_prefix_list_cmd
);
2037 route_map_install_match(&route_match_ipv6_address_prefix_list_cmd
);
2038 route_map_install_match(&route_match_ip_address_prefix_len_cmd
);
2039 route_map_install_match(&route_match_ipv6_address_prefix_len_cmd
);
2040 route_map_install_match(&route_match_ip_nexthop_prefix_len_cmd
);
2041 route_map_install_match(&route_match_ip_next_hop_type_cmd
);
2042 route_map_install_match(&route_match_ipv6_next_hop_type_cmd
);
2043 route_map_install_match(&route_match_source_protocol_cmd
);
2044 route_map_install_match(&route_match_source_instance_cmd
);
2047 route_map_install_set(&route_set_src_cmd
);
2049 install_element(RMAP_NODE
, &match_ip_nexthop_prefix_len_cmd
);
2050 install_element(RMAP_NODE
, &no_match_ip_nexthop_prefix_len_cmd
);
2051 install_element(RMAP_NODE
, &match_ip_address_prefix_len_cmd
);
2052 install_element(RMAP_NODE
, &match_ipv6_address_prefix_len_cmd
);
2053 install_element(RMAP_NODE
, &no_match_ipv6_address_prefix_len_cmd
);
2054 install_element(RMAP_NODE
, &no_match_ip_address_prefix_len_cmd
);
2055 install_element(RMAP_NODE
, &match_source_protocol_cmd
);
2056 install_element(RMAP_NODE
, &no_match_source_protocol_cmd
);
2057 install_element(RMAP_NODE
, &match_source_instance_cmd
);
2058 install_element(RMAP_NODE
, &no_match_source_instance_cmd
);
2061 install_element(RMAP_NODE
, &set_src_cmd
);
2062 install_element(RMAP_NODE
, &no_set_src_cmd
);