2 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
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
34 DEFINE_MTYPE_STATIC(LIB
, ROUTE_MAP
, "Route map")
35 DEFINE_MTYPE(LIB
, ROUTE_MAP_NAME
, "Route map name")
36 DEFINE_MTYPE_STATIC(LIB
, ROUTE_MAP_INDEX
, "Route map index")
37 DEFINE_MTYPE(LIB
, ROUTE_MAP_RULE
, "Route map rule")
38 DEFINE_MTYPE_STATIC(LIB
, ROUTE_MAP_RULE_STR
, "Route map rule str")
39 DEFINE_MTYPE(LIB
, ROUTE_MAP_COMPILED
, "Route map compiled")
40 DEFINE_MTYPE_STATIC(LIB
, ROUTE_MAP_DEP
, "Route map dependency")
42 DEFINE_QOBJ_TYPE(route_map_index
)
43 DEFINE_QOBJ_TYPE(route_map
)
45 /* Vector for route match rules. */
46 static vector route_match_vec
;
48 /* Vector for route set rules. */
49 static vector route_set_vec
;
51 struct route_map_match_set_hooks
{
53 int (*match_interface
)(struct vty
*vty
, struct route_map_index
*index
,
54 const char *command
, const char *arg
,
55 route_map_event_t type
);
57 /* no match interface */
58 int (*no_match_interface
)(struct vty
*vty
,
59 struct route_map_index
*index
,
60 const char *command
, const char *arg
,
61 route_map_event_t type
);
63 /* match ip address */
64 int (*match_ip_address
)(struct vty
*vty
, struct route_map_index
*index
,
65 const char *command
, const char *arg
,
66 route_map_event_t type
);
68 /* no match ip address */
69 int (*no_match_ip_address
)(struct vty
*vty
,
70 struct route_map_index
*index
,
71 const char *command
, const char *arg
,
72 route_map_event_t type
);
74 /* match ip address prefix list */
75 int (*match_ip_address_prefix_list
)(struct vty
*vty
,
76 struct route_map_index
*index
,
79 route_map_event_t type
);
81 /* no match ip address prefix list */
82 int (*no_match_ip_address_prefix_list
)(struct vty
*vty
,
83 struct route_map_index
*index
,
86 route_map_event_t type
);
88 /* match ip next hop */
89 int (*match_ip_next_hop
)(struct vty
*vty
, struct route_map_index
*index
,
90 const char *command
, const char *arg
,
91 route_map_event_t type
);
93 /* no match ip next hop */
94 int (*no_match_ip_next_hop
)(struct vty
*vty
,
95 struct route_map_index
*index
,
96 const char *command
, const char *arg
,
97 route_map_event_t type
);
99 /* match ip next hop prefix list */
100 int (*match_ip_next_hop_prefix_list
)(struct vty
*vty
,
101 struct route_map_index
*index
,
104 route_map_event_t type
);
106 /* no match ip next hop prefix list */
107 int (*no_match_ip_next_hop_prefix_list
)(struct vty
*vty
,
108 struct route_map_index
*index
,
111 route_map_event_t type
);
113 /* match ipv6 address */
114 int (*match_ipv6_address
)(struct vty
*vty
,
115 struct route_map_index
*index
,
116 const char *command
, const char *arg
,
117 route_map_event_t type
);
119 /* no match ipv6 address */
120 int (*no_match_ipv6_address
)(struct vty
*vty
,
121 struct route_map_index
*index
,
122 const char *command
, const char *arg
,
123 route_map_event_t type
);
126 /* match ipv6 address prefix list */
127 int (*match_ipv6_address_prefix_list
)(struct vty
*vty
,
128 struct route_map_index
*index
,
131 route_map_event_t type
);
133 /* no match ipv6 address prefix list */
134 int (*no_match_ipv6_address_prefix_list
)(struct vty
*vty
,
135 struct route_map_index
*index
,
138 route_map_event_t type
);
141 int (*match_metric
)(struct vty
*vty
, struct route_map_index
*index
,
142 const char *command
, const char *arg
,
143 route_map_event_t type
);
145 /* no match metric */
146 int (*no_match_metric
)(struct vty
*vty
, struct route_map_index
*index
,
147 const char *command
, const char *arg
,
148 route_map_event_t type
);
151 int (*match_tag
)(struct vty
*vty
, struct route_map_index
*index
,
152 const char *command
, const char *arg
,
153 route_map_event_t type
);
156 int (*no_match_tag
)(struct vty
*vty
, struct route_map_index
*index
,
157 const char *command
, const char *arg
,
158 route_map_event_t type
);
161 int (*set_ip_nexthop
)(struct vty
*vty
, struct route_map_index
*index
,
162 const char *command
, const char *arg
);
164 /* no set ip nexthop */
165 int (*no_set_ip_nexthop
)(struct vty
*vty
, struct route_map_index
*index
,
166 const char *command
, const char *arg
);
168 /* set ipv6 nexthop local */
169 int (*set_ipv6_nexthop_local
)(struct vty
*vty
,
170 struct route_map_index
*index
,
171 const char *command
, const char *arg
);
173 /* no set ipv6 nexthop local */
174 int (*no_set_ipv6_nexthop_local
)(struct vty
*vty
,
175 struct route_map_index
*index
,
176 const char *command
, const char *arg
);
179 int (*set_metric
)(struct vty
*vty
, struct route_map_index
*index
,
180 const char *command
, const char *arg
);
183 int (*no_set_metric
)(struct vty
*vty
, struct route_map_index
*index
,
184 const char *command
, const char *arg
);
187 int (*set_tag
)(struct vty
*vty
, struct route_map_index
*index
,
188 const char *command
, const char *arg
);
191 int (*no_set_tag
)(struct vty
*vty
, struct route_map_index
*index
,
192 const char *command
, const char *arg
);
195 struct route_map_match_set_hooks rmap_match_set_hook
;
197 /* match interface */
198 void route_map_match_interface_hook(int (*func
)(
199 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
200 const char *arg
, route_map_event_t type
))
202 rmap_match_set_hook
.match_interface
= func
;
205 /* no match interface */
206 void route_map_no_match_interface_hook(int (*func
)(
207 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
208 const char *arg
, route_map_event_t type
))
210 rmap_match_set_hook
.no_match_interface
= func
;
213 /* match ip address */
214 void route_map_match_ip_address_hook(int (*func
)(
215 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
216 const char *arg
, route_map_event_t type
))
218 rmap_match_set_hook
.match_ip_address
= func
;
221 /* no match ip address */
222 void route_map_no_match_ip_address_hook(int (*func
)(
223 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
224 const char *arg
, route_map_event_t type
))
226 rmap_match_set_hook
.no_match_ip_address
= func
;
229 /* match ip address prefix list */
230 void route_map_match_ip_address_prefix_list_hook(int (*func
)(
231 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
232 const char *arg
, route_map_event_t type
))
234 rmap_match_set_hook
.match_ip_address_prefix_list
= func
;
237 /* no match ip address prefix list */
238 void route_map_no_match_ip_address_prefix_list_hook(int (*func
)(
239 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
240 const char *arg
, route_map_event_t type
))
242 rmap_match_set_hook
.no_match_ip_address_prefix_list
= func
;
245 /* match ip next hop */
246 void route_map_match_ip_next_hop_hook(int (*func
)(
247 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
248 const char *arg
, route_map_event_t type
))
250 rmap_match_set_hook
.match_ip_next_hop
= func
;
253 /* no match ip next hop */
254 void route_map_no_match_ip_next_hop_hook(int (*func
)(
255 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
256 const char *arg
, route_map_event_t type
))
258 rmap_match_set_hook
.no_match_ip_next_hop
= func
;
261 /* match ip next hop prefix list */
262 void route_map_match_ip_next_hop_prefix_list_hook(int (*func
)(
263 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
264 const char *arg
, route_map_event_t type
))
266 rmap_match_set_hook
.match_ip_next_hop_prefix_list
= func
;
269 /* no match ip next hop prefix list */
270 void route_map_no_match_ip_next_hop_prefix_list_hook(int (*func
)(
271 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
272 const char *arg
, route_map_event_t type
))
274 rmap_match_set_hook
.no_match_ip_next_hop_prefix_list
= func
;
277 /* match ipv6 address */
278 void route_map_match_ipv6_address_hook(int (*func
)(
279 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
280 const char *arg
, route_map_event_t type
))
282 rmap_match_set_hook
.match_ipv6_address
= func
;
285 /* no match ipv6 address */
286 void route_map_no_match_ipv6_address_hook(int (*func
)(
287 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
288 const char *arg
, route_map_event_t type
))
290 rmap_match_set_hook
.no_match_ipv6_address
= func
;
294 /* match ipv6 address prefix list */
295 void route_map_match_ipv6_address_prefix_list_hook(int (*func
)(
296 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
297 const char *arg
, route_map_event_t type
))
299 rmap_match_set_hook
.match_ipv6_address_prefix_list
= func
;
302 /* no match ipv6 address prefix list */
303 void route_map_no_match_ipv6_address_prefix_list_hook(int (*func
)(
304 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
305 const char *arg
, route_map_event_t type
))
307 rmap_match_set_hook
.no_match_ipv6_address_prefix_list
= func
;
311 void route_map_match_metric_hook(int (*func
)(
312 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
313 const char *arg
, route_map_event_t type
))
315 rmap_match_set_hook
.match_metric
= func
;
318 /* no match metric */
319 void route_map_no_match_metric_hook(int (*func
)(
320 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
321 const char *arg
, route_map_event_t type
))
323 rmap_match_set_hook
.no_match_metric
= func
;
327 void route_map_match_tag_hook(int (*func
)(struct vty
*vty
,
328 struct route_map_index
*index
,
329 const char *command
, const char *arg
,
330 route_map_event_t type
))
332 rmap_match_set_hook
.match_tag
= func
;
336 void route_map_no_match_tag_hook(int (*func
)(
337 struct vty
*vty
, struct route_map_index
*index
, const char *command
,
338 const char *arg
, route_map_event_t type
))
340 rmap_match_set_hook
.no_match_tag
= func
;
344 void route_map_set_ip_nexthop_hook(int (*func
)(struct vty
*vty
,
345 struct route_map_index
*index
,
349 rmap_match_set_hook
.set_ip_nexthop
= func
;
352 /* no set ip nexthop */
353 void route_map_no_set_ip_nexthop_hook(int (*func
)(struct vty
*vty
,
354 struct route_map_index
*index
,
358 rmap_match_set_hook
.no_set_ip_nexthop
= func
;
361 /* set ipv6 nexthop local */
362 void route_map_set_ipv6_nexthop_local_hook(
363 int (*func
)(struct vty
*vty
, struct route_map_index
*index
,
364 const char *command
, const char *arg
))
366 rmap_match_set_hook
.set_ipv6_nexthop_local
= func
;
369 /* no set ipv6 nexthop local */
370 void route_map_no_set_ipv6_nexthop_local_hook(
371 int (*func
)(struct vty
*vty
, struct route_map_index
*index
,
372 const char *command
, const char *arg
))
374 rmap_match_set_hook
.no_set_ipv6_nexthop_local
= func
;
378 void route_map_set_metric_hook(int (*func
)(struct vty
*vty
,
379 struct route_map_index
*index
,
383 rmap_match_set_hook
.set_metric
= func
;
387 void route_map_no_set_metric_hook(int (*func
)(struct vty
*vty
,
388 struct route_map_index
*index
,
392 rmap_match_set_hook
.no_set_metric
= func
;
396 void route_map_set_tag_hook(int (*func
)(struct vty
*vty
,
397 struct route_map_index
*index
,
398 const char *command
, const char *arg
))
400 rmap_match_set_hook
.set_tag
= func
;
404 void route_map_no_set_tag_hook(int (*func
)(struct vty
*vty
,
405 struct route_map_index
*index
,
409 rmap_match_set_hook
.no_set_tag
= func
;
412 int generic_match_add(struct vty
*vty
, struct route_map_index
*index
,
413 const char *command
, const char *arg
,
414 route_map_event_t type
)
418 ret
= route_map_add_match(index
, command
, arg
);
420 case RMAP_COMPILE_SUCCESS
:
421 if (type
!= RMAP_EVENT_MATCH_ADDED
) {
422 route_map_upd8_dependency(type
, arg
, index
->map
->name
);
425 case RMAP_RULE_MISSING
:
426 vty_out(vty
, "%% [%s] Can't find rule.\n", frr_protonameinst
);
427 return CMD_WARNING_CONFIG_FAILED
;
429 case RMAP_COMPILE_ERROR
:
431 "%% [%s] Argument form is unsupported or malformed.\n",
433 return CMD_WARNING_CONFIG_FAILED
;
440 int generic_match_delete(struct vty
*vty
, struct route_map_index
*index
,
441 const char *command
, const char *arg
,
442 route_map_event_t type
)
445 int retval
= CMD_SUCCESS
;
446 char *dep_name
= NULL
;
448 char *rmap_name
= NULL
;
450 if (type
!= RMAP_EVENT_MATCH_DELETED
) {
451 /* ignore the mundane, the types without any dependency */
453 if ((tmpstr
= route_map_get_match_arg(index
, command
))
456 XSTRDUP(MTYPE_ROUTE_MAP_RULE
, tmpstr
);
458 dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_RULE
, arg
);
460 rmap_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, index
->map
->name
);
463 ret
= route_map_delete_match(index
, command
, dep_name
);
465 case RMAP_RULE_MISSING
:
466 vty_out(vty
, "%% [%s] Can't find rule.\n", frr_protonameinst
);
467 retval
= CMD_WARNING_CONFIG_FAILED
;
469 case RMAP_COMPILE_ERROR
:
471 "%% [%s] Argument form is unsupported or malformed.\n",
473 retval
= CMD_WARNING_CONFIG_FAILED
;
475 case RMAP_COMPILE_SUCCESS
:
476 if (type
!= RMAP_EVENT_MATCH_DELETED
&& dep_name
)
477 route_map_upd8_dependency(type
, dep_name
, rmap_name
);
482 XFREE(MTYPE_ROUTE_MAP_RULE
, dep_name
);
484 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
489 int generic_set_add(struct vty
*vty
, struct route_map_index
*index
,
490 const char *command
, const char *arg
)
494 ret
= route_map_add_set(index
, command
, arg
);
496 case RMAP_RULE_MISSING
:
497 vty_out(vty
, "%% [%s] Can't find rule.\n", frr_protonameinst
);
498 return CMD_WARNING_CONFIG_FAILED
;
500 case RMAP_COMPILE_ERROR
:
502 "%% [%s] Argument form is unsupported or malformed.\n",
504 return CMD_WARNING_CONFIG_FAILED
;
506 case RMAP_COMPILE_SUCCESS
:
513 int generic_set_delete(struct vty
*vty
, struct route_map_index
*index
,
514 const char *command
, const char *arg
)
518 ret
= route_map_delete_set(index
, command
, arg
);
520 case RMAP_RULE_MISSING
:
521 vty_out(vty
, "%% [%s] Can't find rule.\n", frr_protonameinst
);
522 return CMD_WARNING_CONFIG_FAILED
;
524 case RMAP_COMPILE_ERROR
:
526 "%% [%s] Argument form is unsupported or malformed.\n",
528 return CMD_WARNING_CONFIG_FAILED
;
530 case RMAP_COMPILE_SUCCESS
:
538 /* Route map rule. This rule has both `match' rule and `set' rule. */
539 struct route_map_rule
{
541 struct route_map_rule_cmd
*cmd
;
543 /* For pretty printing. */
546 /* Pre-compiled match rule. */
550 struct route_map_rule
*next
;
551 struct route_map_rule
*prev
;
554 /* Making route map list. */
555 struct route_map_list
{
556 struct route_map
*head
;
557 struct route_map
*tail
;
559 void (*add_hook
)(const char *);
560 void (*delete_hook
)(const char *);
561 void (*event_hook
)(route_map_event_t
, const char *);
564 /* Master list of route map. */
565 static struct route_map_list route_map_master
= {NULL
, NULL
, NULL
, NULL
, NULL
};
566 struct hash
*route_map_master_hash
= NULL
;
568 static unsigned int route_map_hash_key_make(void *p
)
570 const struct route_map
*map
= p
;
571 return string_hash_make(map
->name
);
574 static int route_map_hash_cmp(const void *p1
, const void *p2
)
576 const struct route_map
*map1
= p1
;
577 const struct route_map
*map2
= p2
;
579 if (map1
->deleted
== map2
->deleted
) {
580 if (map1
->name
&& map2
->name
) {
581 if (!strcmp(map1
->name
, map2
->name
)) {
584 } else if (!map1
->name
&& !map2
->name
) {
592 enum route_map_upd8_type
{
597 /* all possible route-map dependency types */
598 enum route_map_dep_type
{
599 ROUTE_MAP_DEP_RMAP
= 1,
601 ROUTE_MAP_DEP_ECLIST
,
602 ROUTE_MAP_DEP_LCLIST
,
604 ROUTE_MAP_DEP_ASPATH
,
605 ROUTE_MAP_DEP_FILTER
,
609 struct route_map_dep
{
611 struct hash
*dep_rmap_hash
;
612 struct hash
*this_hash
; /* ptr to the hash structure this is part of */
615 /* Hashes maintaining dependency between various sublists used by route maps */
616 struct hash
*route_map_dep_hash
[ROUTE_MAP_DEP_MAX
];
618 static unsigned int route_map_dep_hash_make_key(void *p
);
619 static int route_map_dep_hash_cmp(const void *p1
, const void *p2
);
620 static void route_map_clear_all_references(char *rmap_name
);
621 static void route_map_rule_delete(struct route_map_rule_list
*,
622 struct route_map_rule
*);
623 static int rmap_debug
= 0;
625 static void route_map_index_delete(struct route_map_index
*, int);
627 /* New route map allocation. Please note route map's name must be
629 static struct route_map
*route_map_new(const char *name
)
631 struct route_map
*new;
633 new = XCALLOC(MTYPE_ROUTE_MAP
, sizeof(struct route_map
));
634 new->name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
635 QOBJ_REG(new, route_map
);
639 /* Add new name to route_map. */
640 static struct route_map
*route_map_add(const char *name
)
642 struct route_map
*map
;
643 struct route_map_list
*list
;
645 map
= route_map_new(name
);
646 list
= &route_map_master
;
648 /* Add map to the hash */
649 hash_get(route_map_master_hash
, map
, hash_alloc_intern
);
651 /* Add new entry to the head of the list to match how it is added in the
652 * hash table. This is to ensure that if the same route-map has been
653 * created more than once and then marked for deletion (which can happen
654 * if prior deletions haven't completed as BGP hasn't yet done the
655 * route-map processing), the order of the entities is the same in both
656 * the list and the hash table. Otherwise, since there is nothing to
657 * distinguish between the two entries, the wrong entry could get freed.
658 * TODO: This needs to be re-examined to handle it better - e.g., revive
659 * a deleted entry if the route-map is created again.
662 map
->next
= list
->head
;
664 list
->head
->prev
= map
;
670 if (route_map_master
.add_hook
) {
671 (*route_map_master
.add_hook
)(name
);
672 route_map_notify_dependencies(name
, RMAP_EVENT_CALL_ADDED
);
677 /* this is supposed to be called post processing by
678 * the delete hook function. Don't invoke delete_hook
679 * again in this routine.
681 static void route_map_free_map(struct route_map
*map
)
683 struct route_map_list
*list
;
684 struct route_map_index
*index
;
689 while ((index
= map
->head
) != NULL
)
690 route_map_index_delete(index
, 0);
692 list
= &route_map_master
;
697 map
->next
->prev
= map
->prev
;
699 list
->tail
= map
->prev
;
702 map
->prev
->next
= map
->next
;
704 list
->head
= map
->next
;
706 hash_release(route_map_master_hash
, map
);
707 XFREE(MTYPE_ROUTE_MAP_NAME
, map
->name
);
708 XFREE(MTYPE_ROUTE_MAP
, map
);
711 /* Route map delete from list. */
712 static void route_map_delete(struct route_map
*map
)
714 struct route_map_index
*index
;
717 while ((index
= map
->head
) != NULL
)
718 route_map_index_delete(index
, 0);
723 /* Clear all dependencies */
724 route_map_clear_all_references(name
);
726 /* Execute deletion hook. */
727 if (route_map_master
.delete_hook
) {
728 (*route_map_master
.delete_hook
)(name
);
729 route_map_notify_dependencies(name
, RMAP_EVENT_CALL_DELETED
);
732 if (!map
->to_be_processed
) {
733 route_map_free_map(map
);
737 /* Lookup route map by route map name string. */
738 struct route_map
*route_map_lookup_by_name(const char *name
)
740 struct route_map
*map
;
741 struct route_map tmp_map
;
746 // map.deleted is 0 via memset
747 memset(&tmp_map
, 0, sizeof(struct route_map
));
748 tmp_map
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
749 map
= hash_lookup(route_map_master_hash
, &tmp_map
);
750 XFREE(MTYPE_ROUTE_MAP_NAME
, tmp_map
.name
);
754 int route_map_mark_updated(const char *name
)
756 struct route_map
*map
;
758 struct route_map tmp_map
;
763 map
= route_map_lookup_by_name(name
);
765 /* If we did not find the routemap with deleted=false try again
769 memset(&tmp_map
, 0, sizeof(struct route_map
));
770 tmp_map
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
771 tmp_map
.deleted
= true;
772 map
= hash_lookup(route_map_master_hash
, &tmp_map
);
773 XFREE(MTYPE_ROUTE_MAP_NAME
, tmp_map
.name
);
777 map
->to_be_processed
= true;
784 static int route_map_clear_updated(struct route_map
*map
)
789 map
->to_be_processed
= false;
791 route_map_free_map(map
);
797 /* Lookup route map. If there isn't route map create one and return
799 static struct route_map
*route_map_get(const char *name
)
801 struct route_map
*map
;
803 map
= route_map_lookup_by_name(name
);
805 map
= route_map_add(name
);
810 void route_map_walk_update_list(void (*route_map_update_fn
)(char *name
))
812 struct route_map
*node
;
813 struct route_map
*nnode
= NULL
;
815 for (node
= route_map_master
.head
; node
; node
= nnode
) {
816 if (node
->to_be_processed
) {
817 /* DD: Should we add any thread yield code here */
818 route_map_update_fn(node
->name
);
820 route_map_clear_updated(node
);
826 /* Return route map's type string. */
827 static const char *route_map_type_str(enum route_map_type type
)
842 static int route_map_empty(struct route_map
*map
)
844 if (map
->head
== NULL
&& map
->tail
== NULL
)
851 static void vty_show_route_map_entry(struct vty
*vty
, struct route_map
*map
)
853 struct route_map_index
*index
;
854 struct route_map_rule
*rule
;
856 vty_out(vty
, "%s:\n", frr_protonameinst
);
858 for (index
= map
->head
; index
; index
= index
->next
) {
859 vty_out(vty
, "route-map %s, %s, sequence %d\n", map
->name
,
860 route_map_type_str(index
->type
), index
->pref
);
863 if (index
->description
)
864 vty_out(vty
, " Description:\n %s\n",
868 vty_out(vty
, " Match clauses:\n");
869 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
870 vty_out(vty
, " %s %s\n", rule
->cmd
->str
,
873 vty_out(vty
, " Set clauses:\n");
874 for (rule
= index
->set_list
.head
; rule
; rule
= rule
->next
)
875 vty_out(vty
, " %s %s\n", rule
->cmd
->str
,
879 vty_out(vty
, " Call clause:\n");
881 vty_out(vty
, " Call %s\n", index
->nextrm
);
884 vty_out(vty
, " Action:\n");
885 if (index
->exitpolicy
== RMAP_GOTO
)
886 vty_out(vty
, " Goto %d\n", index
->nextpref
);
887 else if (index
->exitpolicy
== RMAP_NEXT
)
888 vty_out(vty
, " Continue to next entry\n");
889 else if (index
->exitpolicy
== RMAP_EXIT
)
890 vty_out(vty
, " Exit routemap\n");
894 static int sort_route_map(const void **map1
, const void **map2
)
896 const struct route_map
*m1
= *map1
;
897 const struct route_map
*m2
= *map2
;
899 return strcmp(m1
->name
, m2
->name
);
902 static int vty_show_route_map(struct vty
*vty
, const char *name
)
904 struct route_map
*map
;
907 map
= route_map_lookup_by_name(name
);
910 vty_show_route_map_entry(vty
, map
);
913 vty_out(vty
, "%s: 'route-map %s' not found\n",
914 frr_protonameinst
, name
);
919 struct list
*maplist
= list_new();
922 for (map
= route_map_master
.head
; map
; map
= map
->next
)
923 listnode_add(maplist
, map
);
925 list_sort(maplist
, sort_route_map
);
927 for (ALL_LIST_ELEMENTS_RO(maplist
, ln
, map
))
928 vty_show_route_map_entry(vty
, map
);
930 list_delete_and_null(&maplist
);
936 /* New route map allocation. Please note route map's name must be
938 static struct route_map_index
*route_map_index_new(void)
940 struct route_map_index
*new;
942 new = XCALLOC(MTYPE_ROUTE_MAP_INDEX
, sizeof(struct route_map_index
));
943 new->exitpolicy
= RMAP_EXIT
; /* Default to Cisco-style */
944 QOBJ_REG(new, route_map_index
);
948 /* Free route map index. */
949 static void route_map_index_delete(struct route_map_index
*index
, int notify
)
951 struct route_map_rule
*rule
;
955 /* Free route match. */
956 while ((rule
= index
->match_list
.head
) != NULL
)
957 route_map_rule_delete(&index
->match_list
, rule
);
959 /* Free route set. */
960 while ((rule
= index
->set_list
.head
) != NULL
)
961 route_map_rule_delete(&index
->set_list
, rule
);
963 /* Remove index from route map list. */
965 index
->next
->prev
= index
->prev
;
967 index
->map
->tail
= index
->prev
;
970 index
->prev
->next
= index
->next
;
972 index
->map
->head
= index
->next
;
974 /* Free 'char *nextrm' if not NULL */
976 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
978 /* Execute event hook. */
979 if (route_map_master
.event_hook
&& notify
) {
980 (*route_map_master
.event_hook
)(RMAP_EVENT_INDEX_DELETED
,
982 route_map_notify_dependencies(index
->map
->name
,
983 RMAP_EVENT_CALL_ADDED
);
985 XFREE(MTYPE_ROUTE_MAP_INDEX
, index
);
988 /* Lookup index from route map. */
989 static struct route_map_index
*route_map_index_lookup(struct route_map
*map
,
990 enum route_map_type type
,
993 struct route_map_index
*index
;
995 for (index
= map
->head
; index
; index
= index
->next
)
996 if ((index
->type
== type
|| type
== RMAP_ANY
)
997 && index
->pref
== pref
)
1002 /* Add new index to route map. */
1003 static struct route_map_index
*
1004 route_map_index_add(struct route_map
*map
, enum route_map_type type
, int pref
)
1006 struct route_map_index
*index
;
1007 struct route_map_index
*point
;
1009 /* Allocate new route map inex. */
1010 index
= route_map_index_new();
1015 /* Compare preference. */
1016 for (point
= map
->head
; point
; point
= point
->next
)
1017 if (point
->pref
>= pref
)
1020 if (map
->head
== NULL
) {
1021 map
->head
= map
->tail
= index
;
1022 } else if (point
== NULL
) {
1023 index
->prev
= map
->tail
;
1024 map
->tail
->next
= index
;
1026 } else if (point
== map
->head
) {
1027 index
->next
= map
->head
;
1028 map
->head
->prev
= index
;
1031 index
->next
= point
;
1032 index
->prev
= point
->prev
;
1034 point
->prev
->next
= index
;
1035 point
->prev
= index
;
1038 /* Execute event hook. */
1039 if (route_map_master
.event_hook
) {
1040 (*route_map_master
.event_hook
)(RMAP_EVENT_INDEX_ADDED
,
1042 route_map_notify_dependencies(map
->name
, RMAP_EVENT_CALL_ADDED
);
1047 /* Get route map index. */
1048 static struct route_map_index
*
1049 route_map_index_get(struct route_map
*map
, enum route_map_type type
, int pref
)
1051 struct route_map_index
*index
;
1053 index
= route_map_index_lookup(map
, RMAP_ANY
, pref
);
1054 if (index
&& index
->type
!= type
) {
1055 /* Delete index from route map. */
1056 route_map_index_delete(index
, 1);
1060 index
= route_map_index_add(map
, type
, pref
);
1064 /* New route map rule */
1065 static struct route_map_rule
*route_map_rule_new(void)
1067 struct route_map_rule
*new;
1069 new = XCALLOC(MTYPE_ROUTE_MAP_RULE
, sizeof(struct route_map_rule
));
1073 /* Install rule command to the match list. */
1074 void route_map_install_match(struct route_map_rule_cmd
*cmd
)
1076 vector_set(route_match_vec
, cmd
);
1079 /* Install rule command to the set list. */
1080 void route_map_install_set(struct route_map_rule_cmd
*cmd
)
1082 vector_set(route_set_vec
, cmd
);
1085 /* Lookup rule command from match list. */
1086 static struct route_map_rule_cmd
*route_map_lookup_match(const char *name
)
1089 struct route_map_rule_cmd
*rule
;
1091 for (i
= 0; i
< vector_active(route_match_vec
); i
++)
1092 if ((rule
= vector_slot(route_match_vec
, i
)) != NULL
)
1093 if (strcmp(rule
->str
, name
) == 0)
1098 /* Lookup rule command from set list. */
1099 static struct route_map_rule_cmd
*route_map_lookup_set(const char *name
)
1102 struct route_map_rule_cmd
*rule
;
1104 for (i
= 0; i
< vector_active(route_set_vec
); i
++)
1105 if ((rule
= vector_slot(route_set_vec
, i
)) != NULL
)
1106 if (strcmp(rule
->str
, name
) == 0)
1111 /* Add match and set rule to rule list. */
1112 static void route_map_rule_add(struct route_map_rule_list
*list
,
1113 struct route_map_rule
*rule
)
1116 rule
->prev
= list
->tail
;
1118 list
->tail
->next
= rule
;
1124 /* Delete rule from rule list. */
1125 static void route_map_rule_delete(struct route_map_rule_list
*list
,
1126 struct route_map_rule
*rule
)
1128 if (rule
->cmd
->func_free
)
1129 (*rule
->cmd
->func_free
)(rule
->value
);
1132 XFREE(MTYPE_ROUTE_MAP_RULE_STR
, rule
->rule_str
);
1135 rule
->next
->prev
= rule
->prev
;
1137 list
->tail
= rule
->prev
;
1139 rule
->prev
->next
= rule
->next
;
1141 list
->head
= rule
->next
;
1143 XFREE(MTYPE_ROUTE_MAP_RULE
, rule
);
1146 /* strcmp wrapper function which don't crush even argument is NULL. */
1147 static int rulecmp(const char *dst
, const char *src
)
1158 return strcmp(dst
, src
);
1163 /* Use this to return the already specified argument for this match. This is
1164 * useful to get the specified argument with a route map match rule when the
1165 * rule is being deleted and the argument is not provided.
1167 const char *route_map_get_match_arg(struct route_map_index
*index
,
1168 const char *match_name
)
1170 struct route_map_rule
*rule
;
1171 struct route_map_rule_cmd
*cmd
;
1173 /* First lookup rule for add match statement. */
1174 cmd
= route_map_lookup_match(match_name
);
1178 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
1179 if (rule
->cmd
== cmd
&& rule
->rule_str
!= NULL
)
1180 return (rule
->rule_str
);
1185 /* Add match statement to route map. */
1186 int route_map_add_match(struct route_map_index
*index
, const char *match_name
,
1187 const char *match_arg
)
1189 struct route_map_rule
*rule
;
1190 struct route_map_rule
*next
;
1191 struct route_map_rule_cmd
*cmd
;
1195 /* First lookup rule for add match statement. */
1196 cmd
= route_map_lookup_match(match_name
);
1198 return RMAP_RULE_MISSING
;
1200 /* Next call compile function for this match statement. */
1201 if (cmd
->func_compile
) {
1202 compile
= (*cmd
->func_compile
)(match_arg
);
1203 if (compile
== NULL
)
1204 return RMAP_COMPILE_ERROR
;
1208 /* If argument is completely same ignore it. */
1209 for (rule
= index
->match_list
.head
; rule
; rule
= next
) {
1211 if (rule
->cmd
== cmd
) {
1212 route_map_rule_delete(&index
->match_list
, rule
);
1217 /* Add new route map match rule. */
1218 rule
= route_map_rule_new();
1220 rule
->value
= compile
;
1222 rule
->rule_str
= XSTRDUP(MTYPE_ROUTE_MAP_RULE_STR
, match_arg
);
1224 rule
->rule_str
= NULL
;
1226 /* Add new route match rule to linked list. */
1227 route_map_rule_add(&index
->match_list
, rule
);
1229 /* Execute event hook. */
1230 if (route_map_master
.event_hook
) {
1231 (*route_map_master
.event_hook
)(
1232 replaced
? RMAP_EVENT_MATCH_REPLACED
1233 : RMAP_EVENT_MATCH_ADDED
,
1235 route_map_notify_dependencies(index
->map
->name
,
1236 RMAP_EVENT_CALL_ADDED
);
1239 return RMAP_COMPILE_SUCCESS
;
1242 /* Delete specified route match rule. */
1243 int route_map_delete_match(struct route_map_index
*index
,
1244 const char *match_name
, const char *match_arg
)
1246 struct route_map_rule
*rule
;
1247 struct route_map_rule_cmd
*cmd
;
1249 cmd
= route_map_lookup_match(match_name
);
1253 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
1254 if (rule
->cmd
== cmd
&& (rulecmp(rule
->rule_str
, match_arg
) == 0
1255 || match_arg
== NULL
)) {
1256 route_map_rule_delete(&index
->match_list
, rule
);
1257 /* Execute event hook. */
1258 if (route_map_master
.event_hook
) {
1259 (*route_map_master
.event_hook
)(
1260 RMAP_EVENT_MATCH_DELETED
,
1262 route_map_notify_dependencies(
1264 RMAP_EVENT_CALL_ADDED
);
1268 /* Can't find matched rule. */
1272 /* Add route-map set statement to the route map. */
1273 int route_map_add_set(struct route_map_index
*index
, const char *set_name
,
1274 const char *set_arg
)
1276 struct route_map_rule
*rule
;
1277 struct route_map_rule
*next
;
1278 struct route_map_rule_cmd
*cmd
;
1282 cmd
= route_map_lookup_set(set_name
);
1284 return RMAP_RULE_MISSING
;
1286 /* Next call compile function for this match statement. */
1287 if (cmd
->func_compile
) {
1288 compile
= (*cmd
->func_compile
)(set_arg
);
1289 if (compile
== NULL
)
1290 return RMAP_COMPILE_ERROR
;
1294 /* Add by WJL. if old set command of same kind exist, delete it first
1295 to ensure only one set command of same kind exist under a
1297 for (rule
= index
->set_list
.head
; rule
; rule
= next
) {
1299 if (rule
->cmd
== cmd
) {
1300 route_map_rule_delete(&index
->set_list
, rule
);
1305 /* Add new route map match rule. */
1306 rule
= route_map_rule_new();
1308 rule
->value
= compile
;
1310 rule
->rule_str
= XSTRDUP(MTYPE_ROUTE_MAP_RULE_STR
, set_arg
);
1312 rule
->rule_str
= NULL
;
1314 /* Add new route match rule to linked list. */
1315 route_map_rule_add(&index
->set_list
, rule
);
1317 /* Execute event hook. */
1318 if (route_map_master
.event_hook
) {
1319 (*route_map_master
.event_hook
)(replaced
1320 ? RMAP_EVENT_SET_REPLACED
1321 : RMAP_EVENT_SET_ADDED
,
1323 route_map_notify_dependencies(index
->map
->name
,
1324 RMAP_EVENT_CALL_ADDED
);
1326 return RMAP_COMPILE_SUCCESS
;
1329 /* Delete route map set rule. */
1330 int route_map_delete_set(struct route_map_index
*index
, const char *set_name
,
1331 const char *set_arg
)
1333 struct route_map_rule
*rule
;
1334 struct route_map_rule_cmd
*cmd
;
1336 cmd
= route_map_lookup_set(set_name
);
1340 for (rule
= index
->set_list
.head
; rule
; rule
= rule
->next
)
1341 if ((rule
->cmd
== cmd
) && (rulecmp(rule
->rule_str
, set_arg
) == 0
1342 || set_arg
== NULL
)) {
1343 route_map_rule_delete(&index
->set_list
, rule
);
1344 /* Execute event hook. */
1345 if (route_map_master
.event_hook
) {
1346 (*route_map_master
.event_hook
)(
1347 RMAP_EVENT_SET_DELETED
,
1349 route_map_notify_dependencies(
1351 RMAP_EVENT_CALL_ADDED
);
1355 /* Can't find matched rule. */
1359 /* Apply route map's each index to the object.
1361 The matrix for a route-map looks like this:
1362 (note, this includes the description for the "NEXT"
1363 and "GOTO" frobs now
1367 permit action | cont
1369 ------------------+---------------
1375 -Apply Set statements, accept route
1376 -If Call statement is present jump to the specified route-map, if it
1377 denies the route we finish.
1378 -If NEXT is specified, goto NEXT statement
1379 -If GOTO is specified, goto the first clause where pref > nextpref
1380 -If nothing is specified, do as Cisco and finish
1382 -Route is denied by route-map.
1386 If we get no matches after we've processed all updates, then the route
1389 Some notes on the new "CALL", "NEXT" and "GOTO"
1390 call WORD - If this clause is matched, then the set statements
1391 are executed and then we jump to route-map 'WORD'. If
1392 this route-map denies the route, we finish, in other
1394 do whatever the exit policy (EXIT, NEXT or GOTO) tells.
1395 on-match next - If this clause is matched, then the set statements
1396 are executed and then we drop through to the next clause
1397 on-match goto n - If this clause is matched, then the set statments
1398 are executed and then we goto the nth clause, or the
1399 first clause greater than this. In order to ensure
1400 route-maps *always* exit, you cannot jump backwards.
1403 We need to make sure our route-map processing matches the above
1406 static route_map_result_t
1407 route_map_apply_match(struct route_map_rule_list
*match_list
,
1408 const struct prefix
*prefix
, route_map_object_t type
,
1411 route_map_result_t ret
= RMAP_NOMATCH
;
1412 struct route_map_rule
*match
;
1415 /* Check all match rule and if there is no match rule, go to the
1417 if (!match_list
->head
)
1420 for (match
= match_list
->head
; match
; match
= match
->next
) {
1421 /* Try each match statement in turn, If any do not
1423 RMAP_MATCH, return, otherwise continue on to next
1425 statement. All match statements must match for
1428 ret
= (*match
->cmd
->func_apply
)(match
->value
, prefix
,
1430 if (ret
!= RMAP_MATCH
)
1437 /* Apply route map to the object. */
1438 route_map_result_t
route_map_apply(struct route_map
*map
,
1439 const struct prefix
*prefix
,
1440 route_map_object_t type
, void *object
)
1442 static int recursion
= 0;
1444 struct route_map_index
*index
;
1445 struct route_map_rule
*set
;
1447 if (recursion
> RMAP_RECURSION_LIMIT
) {
1449 "route-map recursion limit (%d) reached, discarding route",
1450 RMAP_RECURSION_LIMIT
);
1452 return RMAP_DENYMATCH
;
1456 return RMAP_DENYMATCH
;
1458 for (index
= map
->head
; index
; index
= index
->next
) {
1459 /* Apply this index. */
1460 ret
= route_map_apply_match(&index
->match_list
, prefix
, type
,
1463 /* Now we apply the matrix from above */
1464 if (ret
== RMAP_NOMATCH
)
1465 /* 'cont' from matrix - continue to next route-map
1468 else if (ret
== RMAP_MATCH
) {
1469 if (index
->type
== RMAP_PERMIT
)
1472 /* permit+match must execute sets */
1473 for (set
= index
->set_list
.head
; set
;
1475 ret
= (*set
->cmd
->func_apply
)(
1476 set
->value
, prefix
, type
,
1479 /* Call another route-map if available */
1480 if (index
->nextrm
) {
1481 struct route_map
*nextrm
=
1482 route_map_lookup_by_name(
1485 if (nextrm
) /* Target route-map found,
1489 ret
= route_map_apply(
1490 nextrm
, prefix
, type
,
1495 /* If nextrm returned 'deny', finish. */
1496 if (ret
== RMAP_DENYMATCH
)
1500 switch (index
->exitpolicy
) {
1506 /* Find the next clause to jump to */
1507 struct route_map_index
*next
=
1509 int nextpref
= index
->nextpref
;
1511 while (next
&& next
->pref
< nextpref
) {
1516 /* No clauses match! */
1521 } else if (index
->type
== RMAP_DENY
)
1524 return RMAP_DENYMATCH
;
1528 /* Finally route-map does not match at all. */
1529 return RMAP_DENYMATCH
;
1532 void route_map_add_hook(void (*func
)(const char *))
1534 route_map_master
.add_hook
= func
;
1537 void route_map_delete_hook(void (*func
)(const char *))
1539 route_map_master
.delete_hook
= func
;
1542 void route_map_event_hook(void (*func
)(route_map_event_t
, const char *))
1544 route_map_master
.event_hook
= func
;
1547 /* Routines for route map dependency lists and dependency processing */
1548 static int route_map_rmap_hash_cmp(const void *p1
, const void *p2
)
1550 return (strcmp((const char *)p1
, (const char *)p2
) == 0);
1553 static int route_map_dep_hash_cmp(const void *p1
, const void *p2
)
1556 return (strcmp(((const struct route_map_dep
*)p1
)->dep_name
,
1561 static void route_map_clear_reference(struct hash_backet
*backet
, void *arg
)
1563 struct route_map_dep
*dep
= (struct route_map_dep
*)backet
->data
;
1568 (char *)hash_release(dep
->dep_rmap_hash
, (void *)arg
);
1570 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1572 if (!dep
->dep_rmap_hash
->count
) {
1573 dep
= hash_release(dep
->this_hash
,
1574 (void *)dep
->dep_name
);
1575 hash_free(dep
->dep_rmap_hash
);
1576 XFREE(MTYPE_ROUTE_MAP_NAME
, dep
->dep_name
);
1577 XFREE(MTYPE_ROUTE_MAP_DEP
, dep
);
1582 static void route_map_clear_all_references(char *rmap_name
)
1586 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++) {
1587 hash_iterate(route_map_dep_hash
[i
], route_map_clear_reference
,
1592 static void *route_map_dep_hash_alloc(void *p
)
1594 char *dep_name
= (char *)p
;
1595 struct route_map_dep
*dep_entry
;
1597 dep_entry
= XCALLOC(MTYPE_ROUTE_MAP_DEP
, sizeof(struct route_map_dep
));
1598 dep_entry
->dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, dep_name
);
1599 dep_entry
->dep_rmap_hash
=
1600 hash_create_size(8, route_map_dep_hash_make_key
,
1601 route_map_rmap_hash_cmp
, "Route Map Dep Hash");
1602 dep_entry
->this_hash
= NULL
;
1604 return ((void *)dep_entry
);
1607 static void *route_map_name_hash_alloc(void *p
)
1609 return ((void *)XSTRDUP(MTYPE_ROUTE_MAP_NAME
, (const char *)p
));
1612 static unsigned int route_map_dep_hash_make_key(void *p
)
1614 return (string_hash_make((char *)p
));
1617 static void route_map_print_dependency(struct hash_backet
*backet
, void *data
)
1619 char *rmap_name
= (char *)backet
->data
;
1620 char *dep_name
= (char *)data
;
1622 zlog_debug("%s: Dependency for %s: %s", __FUNCTION__
, dep_name
,
1626 static int route_map_dep_update(struct hash
*dephash
, const char *dep_name
,
1627 const char *rmap_name
, route_map_event_t type
)
1629 struct route_map_dep
*dep
= NULL
;
1631 char *dname
, *rname
;
1634 dname
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, dep_name
);
1635 rname
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1638 case RMAP_EVENT_PLIST_ADDED
:
1639 case RMAP_EVENT_CLIST_ADDED
:
1640 case RMAP_EVENT_ECLIST_ADDED
:
1641 case RMAP_EVENT_ASLIST_ADDED
:
1642 case RMAP_EVENT_LLIST_ADDED
:
1643 case RMAP_EVENT_CALL_ADDED
:
1644 case RMAP_EVENT_FILTER_ADDED
:
1646 zlog_debug("%s: Adding dependency for %s in %s",
1647 __FUNCTION__
, dep_name
, rmap_name
);
1648 dep
= (struct route_map_dep
*)hash_get(
1649 dephash
, dname
, route_map_dep_hash_alloc
);
1655 if (!dep
->this_hash
)
1656 dep
->this_hash
= dephash
;
1658 hash_get(dep
->dep_rmap_hash
, rname
, route_map_name_hash_alloc
);
1660 case RMAP_EVENT_PLIST_DELETED
:
1661 case RMAP_EVENT_CLIST_DELETED
:
1662 case RMAP_EVENT_ECLIST_DELETED
:
1663 case RMAP_EVENT_ASLIST_DELETED
:
1664 case RMAP_EVENT_LLIST_DELETED
:
1665 case RMAP_EVENT_CALL_DELETED
:
1666 case RMAP_EVENT_FILTER_DELETED
:
1668 zlog_debug("%s: Deleting dependency for %s in %s",
1669 __FUNCTION__
, dep_name
, rmap_name
);
1670 dep
= (struct route_map_dep
*)hash_get(dephash
, dname
, NULL
);
1675 ret_map_name
= (char *)hash_release(dep
->dep_rmap_hash
, rname
);
1677 XFREE(MTYPE_ROUTE_MAP_NAME
, ret_map_name
);
1679 if (!dep
->dep_rmap_hash
->count
) {
1680 dep
= hash_release(dephash
, dname
);
1681 hash_free(dep
->dep_rmap_hash
);
1682 XFREE(MTYPE_ROUTE_MAP_NAME
, dep
->dep_name
);
1683 XFREE(MTYPE_ROUTE_MAP_DEP
, dep
);
1693 hash_iterate(dep
->dep_rmap_hash
,
1694 route_map_print_dependency
, dname
);
1698 XFREE(MTYPE_ROUTE_MAP_NAME
, rname
);
1699 XFREE(MTYPE_ROUTE_MAP_NAME
, dname
);
1703 static struct hash
*route_map_get_dep_hash(route_map_event_t event
)
1705 struct hash
*upd8_hash
= NULL
;
1708 case RMAP_EVENT_PLIST_ADDED
:
1709 case RMAP_EVENT_PLIST_DELETED
:
1710 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_PLIST
];
1712 case RMAP_EVENT_CLIST_ADDED
:
1713 case RMAP_EVENT_CLIST_DELETED
:
1714 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_CLIST
];
1716 case RMAP_EVENT_ECLIST_ADDED
:
1717 case RMAP_EVENT_ECLIST_DELETED
:
1718 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_ECLIST
];
1720 case RMAP_EVENT_ASLIST_ADDED
:
1721 case RMAP_EVENT_ASLIST_DELETED
:
1722 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_ASPATH
];
1724 case RMAP_EVENT_LLIST_ADDED
:
1725 case RMAP_EVENT_LLIST_DELETED
:
1726 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_LCLIST
];
1728 case RMAP_EVENT_CALL_ADDED
:
1729 case RMAP_EVENT_CALL_DELETED
:
1730 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_RMAP
];
1732 case RMAP_EVENT_FILTER_ADDED
:
1733 case RMAP_EVENT_FILTER_DELETED
:
1734 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_FILTER
];
1743 static void route_map_process_dependency(struct hash_backet
*backet
, void *data
)
1745 char *rmap_name
= (char *)backet
->data
;
1746 route_map_event_t type
= (route_map_event_t
)(ptrdiff_t)data
;
1749 zlog_debug("%s: Notifying %s of dependency",
1750 __FUNCTION__
, rmap_name
);
1751 if (route_map_master
.event_hook
)
1752 (*route_map_master
.event_hook
)(type
, rmap_name
);
1755 void route_map_upd8_dependency(route_map_event_t type
, const char *arg
,
1756 const char *rmap_name
)
1758 struct hash
*upd8_hash
= NULL
;
1760 if ((upd8_hash
= route_map_get_dep_hash(type
)))
1761 route_map_dep_update(upd8_hash
, arg
, rmap_name
, type
);
1764 void route_map_notify_dependencies(const char *affected_name
,
1765 route_map_event_t event
)
1767 struct route_map_dep
*dep
;
1768 struct hash
*upd8_hash
;
1774 name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, affected_name
);
1776 if ((upd8_hash
= route_map_get_dep_hash(event
)) == NULL
) {
1777 XFREE(MTYPE_ROUTE_MAP_NAME
, name
);
1781 dep
= (struct route_map_dep
*)hash_get(upd8_hash
, name
, NULL
);
1783 if (!dep
->this_hash
)
1784 dep
->this_hash
= upd8_hash
;
1786 hash_iterate(dep
->dep_rmap_hash
, route_map_process_dependency
,
1790 XFREE(MTYPE_ROUTE_MAP_NAME
, name
);
1794 /* VTY related functions. */
1795 DEFUN (match_interface
,
1796 match_interface_cmd
,
1797 "match interface WORD",
1799 "match first hop interface of route\n"
1803 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1805 if (rmap_match_set_hook
.match_interface
)
1806 return rmap_match_set_hook
.match_interface(
1807 vty
, index
, "interface", argv
[idx_word
]->arg
,
1808 RMAP_EVENT_MATCH_ADDED
);
1812 DEFUN (no_match_interface
,
1813 no_match_interface_cmd
,
1814 "no match interface [WORD]",
1817 "Match first hop interface of route\n"
1820 char *iface
= (argc
== 4) ? argv
[3]->arg
: NULL
;
1821 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1823 if (rmap_match_set_hook
.no_match_interface
)
1824 return rmap_match_set_hook
.no_match_interface(
1825 vty
, index
, "interface", iface
,
1826 RMAP_EVENT_MATCH_DELETED
);
1831 DEFUN (match_ip_address
,
1832 match_ip_address_cmd
,
1833 "match ip address <(1-199)|(1300-2699)|WORD>",
1836 "Match address of route\n"
1837 "IP access-list number\n"
1838 "IP access-list number (expanded range)\n"
1839 "IP Access-list name\n")
1842 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1844 if (rmap_match_set_hook
.match_ip_address
)
1845 return rmap_match_set_hook
.match_ip_address(
1846 vty
, index
, "ip address", argv
[idx_acl
]->arg
,
1847 RMAP_EVENT_FILTER_ADDED
);
1852 DEFUN (no_match_ip_address
,
1853 no_match_ip_address_cmd
,
1854 "no match ip address [<(1-199)|(1300-2699)|WORD>]",
1858 "Match address of route\n"
1859 "IP access-list number\n"
1860 "IP access-list number (expanded range)\n"
1861 "IP Access-list name\n")
1864 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1866 if (rmap_match_set_hook
.no_match_ip_address
) {
1867 if (argc
<= idx_word
)
1868 return rmap_match_set_hook
.no_match_ip_address(
1869 vty
, index
, "ip address", NULL
,
1870 RMAP_EVENT_FILTER_DELETED
);
1871 return rmap_match_set_hook
.no_match_ip_address(
1872 vty
, index
, "ip address", argv
[idx_word
]->arg
,
1873 RMAP_EVENT_FILTER_DELETED
);
1879 DEFUN (match_ip_address_prefix_list
,
1880 match_ip_address_prefix_list_cmd
,
1881 "match ip address prefix-list WORD",
1884 "Match address of route\n"
1885 "Match entries of prefix-lists\n"
1886 "IP prefix-list name\n")
1889 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1891 if (rmap_match_set_hook
.match_ip_address_prefix_list
)
1892 return rmap_match_set_hook
.match_ip_address_prefix_list(
1893 vty
, index
, "ip address prefix-list",
1894 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
1899 DEFUN (no_match_ip_address_prefix_list
,
1900 no_match_ip_address_prefix_list_cmd
,
1901 "no match ip address prefix-list [WORD]",
1905 "Match address of route\n"
1906 "Match entries of prefix-lists\n"
1907 "IP prefix-list name\n")
1910 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1912 if (rmap_match_set_hook
.no_match_ip_address_prefix_list
) {
1913 if (argc
<= idx_word
)
1914 return rmap_match_set_hook
1915 .no_match_ip_address_prefix_list(
1916 vty
, index
, "ip address prefix-list",
1917 NULL
, RMAP_EVENT_PLIST_DELETED
);
1918 return rmap_match_set_hook
.no_match_ip_address_prefix_list(
1919 vty
, index
, "ip address prefix-list",
1920 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
1926 DEFUN (match_ip_next_hop
,
1927 match_ip_next_hop_cmd
,
1928 "match ip next-hop <(1-199)|(1300-2699)|WORD>",
1931 "Match next-hop address of route\n"
1932 "IP access-list number\n"
1933 "IP access-list number (expanded range)\n"
1934 "IP Access-list name\n")
1937 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1939 if (rmap_match_set_hook
.match_ip_next_hop
)
1940 return rmap_match_set_hook
.match_ip_next_hop(
1941 vty
, index
, "ip next-hop", argv
[idx_acl
]->arg
,
1942 RMAP_EVENT_FILTER_ADDED
);
1947 DEFUN (no_match_ip_next_hop
,
1948 no_match_ip_next_hop_cmd
,
1949 "no match ip next-hop [<(1-199)|(1300-2699)|WORD>]",
1953 "Match next-hop address of route\n"
1954 "IP access-list number\n"
1955 "IP access-list number (expanded range)\n"
1956 "IP Access-list name\n")
1959 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1961 if (rmap_match_set_hook
.no_match_ip_next_hop
) {
1962 if (argc
<= idx_word
)
1963 return rmap_match_set_hook
.no_match_ip_next_hop(
1964 vty
, index
, "ip next-hop", NULL
,
1965 RMAP_EVENT_FILTER_DELETED
);
1966 return rmap_match_set_hook
.no_match_ip_next_hop(
1967 vty
, index
, "ip next-hop", argv
[idx_word
]->arg
,
1968 RMAP_EVENT_FILTER_DELETED
);
1974 DEFUN (match_ip_next_hop_prefix_list
,
1975 match_ip_next_hop_prefix_list_cmd
,
1976 "match ip next-hop prefix-list WORD",
1979 "Match next-hop address of route\n"
1980 "Match entries of prefix-lists\n"
1981 "IP prefix-list name\n")
1984 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1986 if (rmap_match_set_hook
.match_ip_next_hop_prefix_list
)
1987 return rmap_match_set_hook
.match_ip_next_hop_prefix_list(
1988 vty
, index
, "ip next-hop prefix-list",
1989 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
1993 DEFUN (no_match_ip_next_hop_prefix_list
,
1994 no_match_ip_next_hop_prefix_list_cmd
,
1995 "no match ip next-hop prefix-list [WORD]",
1999 "Match next-hop address of route\n"
2000 "Match entries of prefix-lists\n"
2001 "IP prefix-list name\n")
2004 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2006 if (rmap_match_set_hook
.no_match_ip_next_hop
) {
2007 if (argc
<= idx_word
)
2008 return rmap_match_set_hook
.no_match_ip_next_hop(
2009 vty
, index
, "ip next-hop prefix-list", NULL
,
2010 RMAP_EVENT_PLIST_DELETED
);
2011 return rmap_match_set_hook
.no_match_ip_next_hop(
2012 vty
, index
, "ip next-hop prefix-list",
2013 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
2019 DEFUN (match_ipv6_address
,
2020 match_ipv6_address_cmd
,
2021 "match ipv6 address WORD",
2024 "Match IPv6 address of route\n"
2025 "IPv6 access-list name\n")
2028 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2030 if (rmap_match_set_hook
.match_ipv6_address
)
2031 return rmap_match_set_hook
.match_ipv6_address(
2032 vty
, index
, "ipv6 address", argv
[idx_word
]->arg
,
2033 RMAP_EVENT_FILTER_ADDED
);
2037 DEFUN (no_match_ipv6_address
,
2038 no_match_ipv6_address_cmd
,
2039 "no match ipv6 address WORD",
2043 "Match IPv6 address of route\n"
2044 "IPv6 access-list name\n")
2047 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2049 if (rmap_match_set_hook
.no_match_ipv6_address
)
2050 return rmap_match_set_hook
.no_match_ipv6_address(
2051 vty
, index
, "ipv6 address", argv
[idx_word
]->arg
,
2052 RMAP_EVENT_FILTER_DELETED
);
2057 DEFUN (match_ipv6_address_prefix_list
,
2058 match_ipv6_address_prefix_list_cmd
,
2059 "match ipv6 address prefix-list WORD",
2062 "Match address of route\n"
2063 "Match entries of prefix-lists\n"
2064 "IP prefix-list name\n")
2067 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2069 if (rmap_match_set_hook
.match_ipv6_address_prefix_list
)
2070 return rmap_match_set_hook
.match_ipv6_address_prefix_list(
2071 vty
, index
, "ipv6 address prefix-list",
2072 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
2076 DEFUN (no_match_ipv6_address_prefix_list
,
2077 no_match_ipv6_address_prefix_list_cmd
,
2078 "no match ipv6 address prefix-list WORD",
2082 "Match address of route\n"
2083 "Match entries of prefix-lists\n"
2084 "IP prefix-list name\n")
2087 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2089 if (rmap_match_set_hook
.no_match_ipv6_address_prefix_list
)
2090 return rmap_match_set_hook
.no_match_ipv6_address_prefix_list(
2091 vty
, index
, "ipv6 address prefix-list",
2092 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
2097 DEFUN (match_metric
,
2099 "match metric (0-4294967295)",
2101 "Match metric of route\n"
2105 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2107 if (rmap_match_set_hook
.match_metric
)
2108 return rmap_match_set_hook
.match_metric(vty
, index
, "metric",
2109 argv
[idx_number
]->arg
,
2110 RMAP_EVENT_MATCH_ADDED
);
2115 DEFUN (no_match_metric
,
2116 no_match_metric_cmd
,
2117 "no match metric [(0-4294967295)]",
2120 "Match metric of route\n"
2124 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2126 if (rmap_match_set_hook
.no_match_metric
) {
2127 if (argc
<= idx_number
)
2128 return rmap_match_set_hook
.no_match_metric(
2129 vty
, index
, "metric", NULL
,
2130 RMAP_EVENT_MATCH_DELETED
);
2131 return rmap_match_set_hook
.no_match_metric(
2132 vty
, index
, "metric", argv
[idx_number
]->arg
,
2133 RMAP_EVENT_MATCH_DELETED
);
2141 "match tag (1-4294967295)",
2143 "Match tag of route\n"
2147 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2149 if (rmap_match_set_hook
.match_tag
)
2150 return rmap_match_set_hook
.match_tag(vty
, index
, "tag",
2151 argv
[idx_number
]->arg
,
2152 RMAP_EVENT_MATCH_ADDED
);
2157 DEFUN (no_match_tag
,
2159 "no match tag [(1-4294967295)]",
2162 "Match tag of route\n"
2165 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2168 char *arg
= argv_find(argv
, argc
, "(1-4294967295)", &idx
)
2172 if (rmap_match_set_hook
.no_match_tag
)
2173 return rmap_match_set_hook
.no_match_tag(
2174 vty
, index
, "tag", arg
, RMAP_EVENT_MATCH_DELETED
);
2179 DEFUN (set_ip_nexthop
,
2181 "set ip next-hop A.B.C.D",
2184 "Next hop address\n"
2185 "IP address of next hop\n")
2190 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2192 ret
= str2sockunion(argv
[idx_ipv4
]->arg
, &su
);
2194 vty_out(vty
, "%% Malformed nexthop address\n");
2195 return CMD_WARNING_CONFIG_FAILED
;
2197 if (su
.sin
.sin_addr
.s_addr
== 0
2198 || IPV4_CLASS_DE(ntohl(su
.sin
.sin_addr
.s_addr
))) {
2200 "%% nexthop address cannot be 0.0.0.0, multicast or reserved\n");
2201 return CMD_WARNING_CONFIG_FAILED
;
2204 if (rmap_match_set_hook
.set_ip_nexthop
)
2205 return rmap_match_set_hook
.set_ip_nexthop(
2206 vty
, index
, "ip next-hop", argv
[idx_ipv4
]->arg
);
2211 DEFUN (no_set_ip_nexthop
,
2212 no_set_ip_nexthop_cmd
,
2213 "no set ip next-hop [A.B.C.D]",
2217 "Next hop address\n"
2218 "IP address of next hop\n")
2221 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2222 const char *arg
= NULL
;
2224 if (argv_find(argv
, argc
, "A.B.C.D", &idx
))
2225 arg
= argv
[idx
]->arg
;
2227 if (rmap_match_set_hook
.no_set_ip_nexthop
)
2228 return rmap_match_set_hook
.no_set_ip_nexthop(
2229 vty
, index
, "ip next-hop", arg
);
2235 DEFUN (set_ipv6_nexthop_local
,
2236 set_ipv6_nexthop_local_cmd
,
2237 "set ipv6 next-hop local X:X::X:X",
2240 "IPv6 next-hop address\n"
2241 "IPv6 local address\n"
2242 "IPv6 address of next hop\n")
2245 struct in6_addr addr
;
2247 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2249 ret
= inet_pton(AF_INET6
, argv
[idx_ipv6
]->arg
, &addr
);
2251 vty_out(vty
, "%% Malformed nexthop address\n");
2252 return CMD_WARNING_CONFIG_FAILED
;
2254 if (!IN6_IS_ADDR_LINKLOCAL(&addr
)) {
2255 vty_out(vty
, "%% Invalid link-local nexthop address\n");
2256 return CMD_WARNING_CONFIG_FAILED
;
2259 if (rmap_match_set_hook
.set_ipv6_nexthop_local
)
2260 return rmap_match_set_hook
.set_ipv6_nexthop_local(
2261 vty
, index
, "ipv6 next-hop local", argv
[idx_ipv6
]->arg
);
2266 DEFUN (no_set_ipv6_nexthop_local
,
2267 no_set_ipv6_nexthop_local_cmd
,
2268 "no set ipv6 next-hop local [X:X::X:X]",
2272 "IPv6 next-hop address\n"
2273 "IPv6 local address\n"
2274 "IPv6 address of next hop\n")
2277 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2279 if (rmap_match_set_hook
.no_set_ipv6_nexthop_local
) {
2280 if (argc
<= idx_ipv6
)
2281 return rmap_match_set_hook
.no_set_ipv6_nexthop_local(
2282 vty
, index
, "ipv6 next-hop local", NULL
);
2283 return rmap_match_set_hook
.no_set_ipv6_nexthop_local(
2284 vty
, index
, "ipv6 next-hop local", argv
[5]->arg
);
2291 "set metric <(0-4294967295)|rtt|+rtt|-rtt|+metric|-metric>",
2293 "Metric value for destination routing protocol\n"
2295 "Assign round trip time\n"
2296 "Add round trip time\n"
2297 "Subtract round trip time\n"
2299 "Subtract metric\n")
2302 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2304 const char *pass
= (argv
[idx_number
]->type
== RANGE_TKN
)
2305 ? argv
[idx_number
]->arg
2306 : argv
[idx_number
]->text
;
2308 if (rmap_match_set_hook
.set_metric
)
2309 return rmap_match_set_hook
.set_metric(vty
, index
, "metric",
2315 DEFUN (no_set_metric
,
2317 "no set metric [(0-4294967295)]",
2320 "Metric value for destination routing protocol\n"
2324 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2326 if (rmap_match_set_hook
.no_set_metric
) {
2327 if (argc
<= idx_number
)
2328 return rmap_match_set_hook
.no_set_metric(
2329 vty
, index
, "metric", NULL
);
2330 return rmap_match_set_hook
.no_set_metric(vty
, index
, "metric",
2331 argv
[idx_number
]->arg
);
2339 "set tag (1-4294967295)",
2341 "Tag value for routing protocol\n"
2344 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2347 if (rmap_match_set_hook
.set_tag
)
2348 return rmap_match_set_hook
.set_tag(vty
, index
, "tag",
2349 argv
[idx_number
]->arg
);
2356 "no set tag [(1-4294967295)]",
2359 "Tag value for routing protocol\n"
2362 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2365 if (rmap_match_set_hook
.no_set_tag
) {
2366 if (argc
<= idx_number
)
2367 return rmap_match_set_hook
.no_set_tag(vty
, index
, "tag",
2369 return rmap_match_set_hook
.no_set_tag(vty
, index
, "tag",
2370 argv
[idx_number
]->arg
);
2376 DEFUN_NOSH (route_map
,
2378 "route-map WORD <deny|permit> (1-65535)",
2379 "Create route-map or enter route-map command mode\n"
2381 "Route map denies set operations\n"
2382 "Route map permits set operations\n"
2383 "Sequence to insert to/delete from existing route-map entry\n")
2386 int idx_permit_deny
= 2;
2388 struct route_map
*map
;
2389 struct route_map_index
*index
;
2390 char *endptr
= NULL
;
2392 argv
[idx_permit_deny
]->arg
[0] == 'p' ? RMAP_PERMIT
: RMAP_DENY
;
2393 unsigned long pref
= strtoul(argv
[idx_number
]->arg
, &endptr
, 10);
2394 const char *mapname
= argv
[idx_word
]->arg
;
2396 /* Get route map. */
2397 map
= route_map_get(mapname
);
2398 index
= route_map_index_get(map
, permit
, pref
);
2400 VTY_PUSH_CONTEXT(RMAP_NODE
, index
);
2404 DEFUN (no_route_map_all
,
2405 no_route_map_all_cmd
,
2406 "no route-map WORD",
2408 "Create route-map or enter route-map command mode\n"
2412 const char *mapname
= argv
[idx_word
]->arg
;
2413 struct route_map
*map
;
2415 map
= route_map_lookup_by_name(mapname
);
2417 vty_out(vty
, "%% Could not find route-map %s\n", mapname
);
2418 return CMD_WARNING_CONFIG_FAILED
;
2421 route_map_delete(map
);
2426 DEFUN (no_route_map
,
2428 "no route-map WORD <deny|permit> (1-65535)",
2430 "Create route-map or enter route-map command mode\n"
2432 "Route map denies set operations\n"
2433 "Route map permits set operations\n"
2434 "Sequence to insert to/delete from existing route-map entry\n")
2437 int idx_permit_deny
= 3;
2439 struct route_map
*map
;
2440 struct route_map_index
*index
;
2441 char *endptr
= NULL
;
2442 int permit
= strmatch(argv
[idx_permit_deny
]->text
, "permit")
2445 const char *prefstr
= argv
[idx_number
]->arg
;
2446 const char *mapname
= argv
[idx_word
]->arg
;
2447 unsigned long pref
= strtoul(prefstr
, &endptr
, 10);
2449 /* Existence check. */
2450 map
= route_map_lookup_by_name(mapname
);
2452 vty_out(vty
, "%% Could not find route-map %s\n", mapname
);
2453 return CMD_WARNING_CONFIG_FAILED
;
2456 /* Lookup route map index. */
2457 index
= route_map_index_lookup(map
, permit
, pref
);
2458 if (index
== NULL
) {
2459 vty_out(vty
, "%% Could not find route-map entry %s %s\n",
2461 return CMD_WARNING_CONFIG_FAILED
;
2464 /* Delete index from route map. */
2465 route_map_index_delete(index
, 1);
2467 /* If this route rule is the last one, delete route map itself. */
2468 if (route_map_empty(map
))
2469 route_map_delete(map
);
2474 DEFUN (rmap_onmatch_next
,
2475 rmap_onmatch_next_cmd
,
2477 "Exit policy on matches\n"
2480 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2483 if (index
->type
== RMAP_DENY
) {
2484 /* Under a deny clause, match means it's finished. No
2485 * need to set next */
2487 "on-match next not supported under route-map deny\n");
2488 return CMD_WARNING_CONFIG_FAILED
;
2490 index
->exitpolicy
= RMAP_NEXT
;
2495 DEFUN (no_rmap_onmatch_next
,
2496 no_rmap_onmatch_next_cmd
,
2499 "Exit policy on matches\n"
2502 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2505 index
->exitpolicy
= RMAP_EXIT
;
2510 DEFUN (rmap_onmatch_goto
,
2511 rmap_onmatch_goto_cmd
,
2512 "on-match goto (1-65535)",
2513 "Exit policy on matches\n"
2514 "Goto Clause number\n"
2518 char *num
= argv_find(argv
, argc
, "(1-65535)", &idx
) ? argv
[idx
]->arg
2521 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2525 if (index
->type
== RMAP_DENY
) {
2526 /* Under a deny clause, match means it's finished. No
2527 * need to go anywhere */
2529 "on-match goto not supported under route-map deny\n");
2530 return CMD_WARNING_CONFIG_FAILED
;
2534 d
= strtoul(num
, NULL
, 10);
2536 d
= index
->pref
+ 1;
2538 if (d
<= index
->pref
) {
2539 /* Can't allow you to do that, Dave */
2540 vty_out(vty
, "can't jump backwards in route-maps\n");
2541 return CMD_WARNING_CONFIG_FAILED
;
2543 index
->exitpolicy
= RMAP_GOTO
;
2544 index
->nextpref
= d
;
2550 DEFUN (no_rmap_onmatch_goto
,
2551 no_rmap_onmatch_goto_cmd
,
2554 "Exit policy on matches\n"
2555 "Goto Clause number\n")
2557 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2560 index
->exitpolicy
= RMAP_EXIT
;
2565 /* Cisco/GNU Zebra compatibility aliases */
2567 DEFUN (rmap_continue
,
2569 "continue (1-65535)",
2570 "Continue on a different entry within the route-map\n"
2571 "Route-map entry sequence number\n")
2573 return rmap_onmatch_goto(self
, vty
, argc
, argv
);
2577 DEFUN (no_rmap_continue
,
2578 no_rmap_continue_cmd
,
2579 "no continue [(1-65535)]",
2581 "Continue on a different entry within the route-map\n"
2582 "Route-map entry sequence number\n")
2584 return no_rmap_onmatch_goto(self
, vty
, argc
, argv
);
2588 DEFUN (rmap_show_name
,
2590 "show route-map [WORD]",
2592 "route-map information\n"
2596 const char *name
= (argc
== 3) ? argv
[idx_word
]->arg
: NULL
;
2597 return vty_show_route_map(vty
, name
);
2603 "Jump to another Route-Map after match+set\n"
2604 "Target route-map name\n")
2607 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2608 const char *rmap
= argv
[idx_word
]->arg
;
2612 if (index
->nextrm
) {
2613 route_map_upd8_dependency(RMAP_EVENT_CALL_DELETED
,
2614 index
->nextrm
, index
->map
->name
);
2615 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
2617 index
->nextrm
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
2619 /* Execute event hook. */
2620 route_map_upd8_dependency(RMAP_EVENT_CALL_ADDED
, index
->nextrm
,
2625 DEFUN (no_rmap_call
,
2629 "Jump to another Route-Map after match+set\n")
2631 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2633 if (index
->nextrm
) {
2634 route_map_upd8_dependency(RMAP_EVENT_CALL_DELETED
,
2635 index
->nextrm
, index
->map
->name
);
2636 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
2637 index
->nextrm
= NULL
;
2643 DEFUN (rmap_description
,
2644 rmap_description_cmd
,
2645 "description LINE...",
2646 "Route-map comment\n"
2647 "Comment describing this route-map rule\n")
2650 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2653 if (index
->description
)
2654 XFREE(MTYPE_TMP
, index
->description
);
2655 index
->description
= argv_concat(argv
, argc
, idx_line
);
2660 DEFUN (no_rmap_description
,
2661 no_rmap_description_cmd
,
2664 "Route-map comment\n")
2666 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2669 if (index
->description
)
2670 XFREE(MTYPE_TMP
, index
->description
);
2671 index
->description
= NULL
;
2676 /* Configuration write function. */
2677 static int route_map_config_write(struct vty
*vty
)
2679 struct route_map
*map
;
2680 struct route_map_index
*index
;
2681 struct route_map_rule
*rule
;
2685 for (map
= route_map_master
.head
; map
; map
= map
->next
)
2686 for (index
= map
->head
; index
; index
= index
->next
) {
2688 vty_out(vty
, "!\n");
2692 vty_out(vty
, "route-map %s %s %d\n", map
->name
,
2693 route_map_type_str(index
->type
), index
->pref
);
2695 if (index
->description
)
2696 vty_out(vty
, " description %s\n",
2697 index
->description
);
2699 for (rule
= index
->match_list
.head
; rule
;
2701 vty_out(vty
, " match %s %s\n", rule
->cmd
->str
,
2702 rule
->rule_str
? rule
->rule_str
: "");
2704 for (rule
= index
->set_list
.head
; rule
;
2706 vty_out(vty
, " set %s %s\n", rule
->cmd
->str
,
2707 rule
->rule_str
? rule
->rule_str
: "");
2709 vty_out(vty
, " call %s\n", index
->nextrm
);
2710 if (index
->exitpolicy
== RMAP_GOTO
)
2711 vty_out(vty
, " on-match goto %d\n",
2713 if (index
->exitpolicy
== RMAP_NEXT
)
2714 vty_out(vty
, " on-match next\n");
2721 /* Route map node structure. */
2722 static struct cmd_node rmap_node
= {RMAP_NODE
, "%s(config-route-map)# ", 1};
2724 /* Common route map rules */
2726 void *route_map_rule_tag_compile(const char *arg
)
2728 unsigned long int tmp
;
2733 tmp
= strtoul(arg
, &endptr
, 0);
2734 if (arg
[0] == '\0' || *endptr
!= '\0' || errno
|| tmp
> ROUTE_TAG_MAX
)
2737 tag
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(*tag
));
2743 void route_map_rule_tag_free(void *rule
)
2745 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
2748 void route_map_finish(void)
2752 vector_free(route_match_vec
);
2753 route_match_vec
= NULL
;
2754 vector_free(route_set_vec
);
2755 route_set_vec
= NULL
;
2758 * All protocols are setting these to NULL
2759 * by default on shutdown( route_map_finish )
2760 * Why are we making them do this work?
2762 route_map_master
.add_hook
= NULL
;
2763 route_map_master
.delete_hook
= NULL
;
2764 route_map_master
.event_hook
= NULL
;
2766 /* cleanup route_map */
2767 while (route_map_master
.head
) {
2768 struct route_map
*map
= route_map_master
.head
;
2769 map
->to_be_processed
= false;
2770 route_map_delete(map
);
2773 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++) {
2774 hash_free(route_map_dep_hash
[i
]);
2775 route_map_dep_hash
[i
] = NULL
;
2778 hash_free(route_map_master_hash
);
2779 route_map_master_hash
= NULL
;
2782 static void rmap_autocomplete(vector comps
, struct cmd_token
*token
)
2784 struct route_map
*map
;
2786 for (map
= route_map_master
.head
; map
; map
= map
->next
)
2787 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, map
->name
));
2790 static const struct cmd_variable_handler rmap_var_handlers
[] = {
2791 {/* "route-map WORD" */
2792 .varname
= "route_map",
2793 .completions
= rmap_autocomplete
},
2794 {.tokenname
= "ROUTEMAP_NAME", .completions
= rmap_autocomplete
},
2795 {.tokenname
= "RMAP_NAME", .completions
= rmap_autocomplete
},
2796 {.completions
= NULL
}};
2798 /* Initialization of route map vector. */
2799 void route_map_init(void)
2803 /* Make vector for match and set. */
2804 route_match_vec
= vector_init(1);
2805 route_set_vec
= vector_init(1);
2806 route_map_master_hash
=
2807 hash_create_size(8, route_map_hash_key_make
, route_map_hash_cmp
,
2808 "Route Map Master Hash");
2810 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++)
2811 route_map_dep_hash
[i
] = hash_create_size(
2812 8, route_map_dep_hash_make_key
, route_map_dep_hash_cmp
,
2813 "Route Map Dep Hash");
2815 cmd_variable_handler_register(rmap_var_handlers
);
2817 /* Install route map top node. */
2818 install_node(&rmap_node
, route_map_config_write
);
2820 /* Install route map commands. */
2821 install_default(RMAP_NODE
);
2822 install_element(CONFIG_NODE
, &route_map_cmd
);
2823 install_element(CONFIG_NODE
, &no_route_map_cmd
);
2824 install_element(CONFIG_NODE
, &no_route_map_all_cmd
);
2826 /* Install the on-match stuff */
2827 install_element(RMAP_NODE
, &route_map_cmd
);
2828 install_element(RMAP_NODE
, &rmap_onmatch_next_cmd
);
2829 install_element(RMAP_NODE
, &no_rmap_onmatch_next_cmd
);
2830 install_element(RMAP_NODE
, &rmap_onmatch_goto_cmd
);
2831 install_element(RMAP_NODE
, &no_rmap_onmatch_goto_cmd
);
2832 install_element(RMAP_NODE
, &rmap_continue_cmd
);
2833 install_element(RMAP_NODE
, &no_rmap_continue_cmd
);
2835 /* Install the continue stuff (ALIAS of on-match). */
2837 /* Install the call stuff. */
2838 install_element(RMAP_NODE
, &rmap_call_cmd
);
2839 install_element(RMAP_NODE
, &no_rmap_call_cmd
);
2841 /* Install description commands. */
2842 install_element(RMAP_NODE
, &rmap_description_cmd
);
2843 install_element(RMAP_NODE
, &no_rmap_description_cmd
);
2845 /* Install show command */
2846 install_element(ENABLE_NODE
, &rmap_show_name_cmd
);
2848 install_element(RMAP_NODE
, &match_interface_cmd
);
2849 install_element(RMAP_NODE
, &no_match_interface_cmd
);
2851 install_element(RMAP_NODE
, &match_ip_address_cmd
);
2852 install_element(RMAP_NODE
, &no_match_ip_address_cmd
);
2854 install_element(RMAP_NODE
, &match_ip_address_prefix_list_cmd
);
2855 install_element(RMAP_NODE
, &no_match_ip_address_prefix_list_cmd
);
2857 install_element(RMAP_NODE
, &match_ip_next_hop_cmd
);
2858 install_element(RMAP_NODE
, &no_match_ip_next_hop_cmd
);
2860 install_element(RMAP_NODE
, &match_ip_next_hop_prefix_list_cmd
);
2861 install_element(RMAP_NODE
, &no_match_ip_next_hop_prefix_list_cmd
);
2863 install_element(RMAP_NODE
, &match_ipv6_address_cmd
);
2864 install_element(RMAP_NODE
, &no_match_ipv6_address_cmd
);
2866 install_element(RMAP_NODE
, &match_ipv6_address_prefix_list_cmd
);
2867 install_element(RMAP_NODE
, &no_match_ipv6_address_prefix_list_cmd
);
2869 install_element(RMAP_NODE
, &match_metric_cmd
);
2870 install_element(RMAP_NODE
, &no_match_metric_cmd
);
2872 install_element(RMAP_NODE
, &match_tag_cmd
);
2873 install_element(RMAP_NODE
, &no_match_tag_cmd
);
2875 install_element(RMAP_NODE
, &set_ip_nexthop_cmd
);
2876 install_element(RMAP_NODE
, &no_set_ip_nexthop_cmd
);
2878 install_element(RMAP_NODE
, &set_ipv6_nexthop_local_cmd
);
2879 install_element(RMAP_NODE
, &no_set_ipv6_nexthop_local_cmd
);
2881 install_element(RMAP_NODE
, &set_metric_cmd
);
2882 install_element(RMAP_NODE
, &no_set_metric_cmd
);
2884 install_element(RMAP_NODE
, &set_tag_cmd
);
2885 install_element(RMAP_NODE
, &no_set_tag_cmd
);