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
);
421 case RMAP_RULE_MISSING
:
422 vty_out(vty
, "%% [%s] Can't find rule.\n",
424 return CMD_WARNING_CONFIG_FAILED
;
425 case RMAP_COMPILE_ERROR
:
427 "%% [%s] Argument form is unsupported or malformed.\n",
429 return CMD_WARNING_CONFIG_FAILED
;
433 if (type
!= RMAP_EVENT_MATCH_ADDED
) {
434 route_map_upd8_dependency(type
, arg
, index
->map
->name
);
439 int generic_match_delete(struct vty
*vty
, struct route_map_index
*index
,
440 const char *command
, const char *arg
,
441 route_map_event_t type
)
444 char *dep_name
= NULL
;
446 char *rmap_name
= NULL
;
448 if (type
!= RMAP_EVENT_MATCH_DELETED
) {
449 /* ignore the mundane, the types without any dependency */
451 if ((tmpstr
= route_map_get_match_arg(index
, command
))
454 XSTRDUP(MTYPE_ROUTE_MAP_RULE
, tmpstr
);
456 dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_RULE
, arg
);
458 rmap_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, index
->map
->name
);
461 ret
= route_map_delete_match(index
, command
, dep_name
);
464 case RMAP_RULE_MISSING
:
465 vty_out(vty
, "%% [%s] Can't find rule.\n",
468 case RMAP_COMPILE_ERROR
:
470 "%% [%s] Argument form is unsupported or malformed.\n",
475 XFREE(MTYPE_ROUTE_MAP_RULE
, dep_name
);
477 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
478 return CMD_WARNING_CONFIG_FAILED
;
481 if (type
!= RMAP_EVENT_MATCH_DELETED
&& dep_name
)
482 route_map_upd8_dependency(type
, dep_name
, rmap_name
);
485 XFREE(MTYPE_ROUTE_MAP_RULE
, dep_name
);
487 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
492 int generic_set_add(struct vty
*vty
, struct route_map_index
*index
,
493 const char *command
, const char *arg
)
497 ret
= route_map_add_set(index
, command
, arg
);
500 case RMAP_RULE_MISSING
:
501 vty_out(vty
, "%% [%s] Can't find rule.\n",
503 return CMD_WARNING_CONFIG_FAILED
;
504 case RMAP_COMPILE_ERROR
:
506 "%% [%s] Argument form is unsupported or malformed.\n",
508 return CMD_WARNING_CONFIG_FAILED
;
514 int generic_set_delete(struct vty
*vty
, struct route_map_index
*index
,
515 const char *command
, const char *arg
)
519 ret
= route_map_delete_set(index
, command
, arg
);
522 case RMAP_RULE_MISSING
:
523 vty_out(vty
, "%% [%s] Can't find rule.\n",
525 return CMD_WARNING_CONFIG_FAILED
;
526 case RMAP_COMPILE_ERROR
:
528 "%% [%s] Argument form is unsupported or malformed.\n",
530 return CMD_WARNING_CONFIG_FAILED
;
537 /* Route map rule. This rule has both `match' rule and `set' rule. */
538 struct route_map_rule
{
540 struct route_map_rule_cmd
*cmd
;
542 /* For pretty printing. */
545 /* Pre-compiled match rule. */
549 struct route_map_rule
*next
;
550 struct route_map_rule
*prev
;
553 /* Making route map list. */
554 struct route_map_list
{
555 struct route_map
*head
;
556 struct route_map
*tail
;
558 void (*add_hook
)(const char *);
559 void (*delete_hook
)(const char *);
560 void (*event_hook
)(route_map_event_t
, const char *);
563 /* Master list of route map. */
564 static struct route_map_list route_map_master
= {NULL
, NULL
, NULL
, NULL
, NULL
};
565 struct hash
*route_map_master_hash
= NULL
;
567 static unsigned int route_map_hash_key_make(void *p
)
569 const struct route_map
*map
= p
;
570 return string_hash_make(map
->name
);
573 static int route_map_hash_cmp(const void *p1
, const void *p2
)
575 const struct route_map
*map1
= p1
;
576 const struct route_map
*map2
= p2
;
578 if (map1
->deleted
== map2
->deleted
) {
579 if (map1
->name
&& map2
->name
) {
580 if (!strcmp(map1
->name
, map2
->name
)) {
583 } else if (!map1
->name
&& !map2
->name
) {
591 enum route_map_upd8_type
{
596 /* all possible route-map dependency types */
597 enum route_map_dep_type
{
598 ROUTE_MAP_DEP_RMAP
= 1,
600 ROUTE_MAP_DEP_ECLIST
,
601 ROUTE_MAP_DEP_LCLIST
,
603 ROUTE_MAP_DEP_ASPATH
,
604 ROUTE_MAP_DEP_FILTER
,
608 struct route_map_dep
{
610 struct hash
*dep_rmap_hash
;
611 struct hash
*this_hash
; /* ptr to the hash structure this is part of */
614 /* Hashes maintaining dependency between various sublists used by route maps */
615 struct hash
*route_map_dep_hash
[ROUTE_MAP_DEP_MAX
];
617 static unsigned int route_map_dep_hash_make_key(void *p
);
618 static int route_map_dep_hash_cmp(const void *p1
, const void *p2
);
619 static void route_map_clear_all_references(char *rmap_name
);
620 static void route_map_rule_delete(struct route_map_rule_list
*,
621 struct route_map_rule
*);
622 static int rmap_debug
= 0;
624 static void route_map_index_delete(struct route_map_index
*, int);
626 /* New route map allocation. Please note route map's name must be
628 static struct route_map
*route_map_new(const char *name
)
630 struct route_map
*new;
632 new = XCALLOC(MTYPE_ROUTE_MAP
, sizeof(struct route_map
));
633 new->name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
634 QOBJ_REG(new, route_map
);
638 /* Add new name to route_map. */
639 static struct route_map
*route_map_add(const char *name
)
641 struct route_map
*map
;
642 struct route_map_list
*list
;
644 map
= route_map_new(name
);
645 list
= &route_map_master
;
647 /* Add map to the hash */
648 hash_get(route_map_master_hash
, map
, hash_alloc_intern
);
650 /* Add new entry to the head of the list to match how it is added in the
651 * hash table. This is to ensure that if the same route-map has been
652 * created more than once and then marked for deletion (which can happen
653 * if prior deletions haven't completed as BGP hasn't yet done the
654 * route-map processing), the order of the entities is the same in both
655 * the list and the hash table. Otherwise, since there is nothing to
656 * distinguish between the two entries, the wrong entry could get freed.
657 * TODO: This needs to be re-examined to handle it better - e.g., revive
658 * a deleted entry if the route-map is created again.
661 map
->next
= list
->head
;
663 list
->head
->prev
= map
;
669 if (route_map_master
.add_hook
) {
670 (*route_map_master
.add_hook
)(name
);
671 route_map_notify_dependencies(name
, RMAP_EVENT_CALL_ADDED
);
676 /* this is supposed to be called post processing by
677 * the delete hook function. Don't invoke delete_hook
678 * again in this routine.
680 static void route_map_free_map(struct route_map
*map
)
682 struct route_map_list
*list
;
683 struct route_map_index
*index
;
688 while ((index
= map
->head
) != NULL
)
689 route_map_index_delete(index
, 0);
691 list
= &route_map_master
;
696 map
->next
->prev
= map
->prev
;
698 list
->tail
= map
->prev
;
701 map
->prev
->next
= map
->next
;
703 list
->head
= map
->next
;
705 hash_release(route_map_master_hash
, map
);
706 XFREE(MTYPE_ROUTE_MAP_NAME
, map
->name
);
707 XFREE(MTYPE_ROUTE_MAP
, map
);
710 /* Route map delete from list. */
711 static void route_map_delete(struct route_map
*map
)
713 struct route_map_index
*index
;
716 while ((index
= map
->head
) != NULL
)
717 route_map_index_delete(index
, 0);
722 /* Clear all dependencies */
723 route_map_clear_all_references(name
);
725 /* Execute deletion hook. */
726 if (route_map_master
.delete_hook
) {
727 (*route_map_master
.delete_hook
)(name
);
728 route_map_notify_dependencies(name
, RMAP_EVENT_CALL_DELETED
);
731 if (!map
->to_be_processed
) {
732 route_map_free_map(map
);
736 /* Lookup route map by route map name string. */
737 struct route_map
*route_map_lookup_by_name(const char *name
)
739 struct route_map
*map
;
740 struct route_map tmp_map
;
745 // map.deleted is 0 via memset
746 memset(&tmp_map
, 0, sizeof(struct route_map
));
747 tmp_map
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
748 map
= hash_lookup(route_map_master_hash
, &tmp_map
);
749 XFREE(MTYPE_ROUTE_MAP_NAME
, tmp_map
.name
);
753 int route_map_mark_updated(const char *name
, int del_later
)
755 struct route_map
*map
;
757 struct route_map tmp_map
;
762 map
= route_map_lookup_by_name(name
);
764 /* If we did not find the routemap with deleted=0 try again
768 memset(&tmp_map
, 0, sizeof(struct route_map
));
769 tmp_map
.name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, name
);
771 map
= hash_lookup(route_map_master_hash
, &tmp_map
);
772 XFREE(MTYPE_ROUTE_MAP_NAME
, tmp_map
.name
);
776 map
->to_be_processed
= 1;
783 int route_map_clear_updated(struct route_map
*map
)
788 map
->to_be_processed
= 0;
790 route_map_free_map(map
);
796 /* Lookup route map. If there isn't route map create one and return
798 static struct route_map
*route_map_get(const char *name
)
800 struct route_map
*map
;
802 map
= route_map_lookup_by_name(name
);
804 map
= route_map_add(name
);
809 void route_map_walk_update_list(int (*route_map_update_fn
)(char *name
))
811 struct route_map
*node
;
812 struct route_map
*nnode
= NULL
;
814 for (node
= route_map_master
.head
; node
; node
= nnode
) {
815 if (node
->to_be_processed
) {
816 /* DD: Should we add any thread yield code here */
817 route_map_update_fn(node
->name
);
819 route_map_clear_updated(node
);
825 /* Return route map's type string. */
826 static const char *route_map_type_str(enum route_map_type type
)
841 static int route_map_empty(struct route_map
*map
)
843 if (map
->head
== NULL
&& map
->tail
== NULL
)
850 static void vty_show_route_map_entry(struct vty
*vty
, struct route_map
*map
)
852 struct route_map_index
*index
;
853 struct route_map_rule
*rule
;
855 vty_out(vty
, "%s:\n", frr_protonameinst
);
857 for (index
= map
->head
; index
; index
= index
->next
) {
858 vty_out(vty
, "route-map %s, %s, sequence %d\n", map
->name
,
859 route_map_type_str(index
->type
), index
->pref
);
862 if (index
->description
)
863 vty_out(vty
, " Description:\n %s\n",
867 vty_out(vty
, " Match clauses:\n");
868 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
869 vty_out(vty
, " %s %s\n", rule
->cmd
->str
,
872 vty_out(vty
, " Set clauses:\n");
873 for (rule
= index
->set_list
.head
; rule
; rule
= rule
->next
)
874 vty_out(vty
, " %s %s\n", rule
->cmd
->str
,
878 vty_out(vty
, " Call clause:\n");
880 vty_out(vty
, " Call %s\n", index
->nextrm
);
883 vty_out(vty
, " Action:\n");
884 if (index
->exitpolicy
== RMAP_GOTO
)
885 vty_out(vty
, " Goto %d\n", index
->nextpref
);
886 else if (index
->exitpolicy
== RMAP_NEXT
)
887 vty_out(vty
, " Continue to next entry\n");
888 else if (index
->exitpolicy
== RMAP_EXIT
)
889 vty_out(vty
, " Exit routemap\n");
893 static int vty_show_route_map(struct vty
*vty
, const char *name
)
895 struct route_map
*map
;
898 map
= route_map_lookup_by_name(name
);
901 vty_show_route_map_entry(vty
, map
);
904 vty_out(vty
, "%s: 'route-map %s' not found\n",
905 frr_protonameinst
, name
);
909 for (map
= route_map_master
.head
; map
; map
= map
->next
)
911 vty_show_route_map_entry(vty
, map
);
917 /* New route map allocation. Please note route map's name must be
919 static struct route_map_index
*route_map_index_new(void)
921 struct route_map_index
*new;
923 new = XCALLOC(MTYPE_ROUTE_MAP_INDEX
, sizeof(struct route_map_index
));
924 new->exitpolicy
= RMAP_EXIT
; /* Default to Cisco-style */
925 QOBJ_REG(new, route_map_index
);
929 /* Free route map index. */
930 static void route_map_index_delete(struct route_map_index
*index
, int notify
)
932 struct route_map_rule
*rule
;
936 /* Free route match. */
937 while ((rule
= index
->match_list
.head
) != NULL
)
938 route_map_rule_delete(&index
->match_list
, rule
);
940 /* Free route set. */
941 while ((rule
= index
->set_list
.head
) != NULL
)
942 route_map_rule_delete(&index
->set_list
, rule
);
944 /* Remove index from route map list. */
946 index
->next
->prev
= index
->prev
;
948 index
->map
->tail
= index
->prev
;
951 index
->prev
->next
= index
->next
;
953 index
->map
->head
= index
->next
;
955 /* Free 'char *nextrm' if not NULL */
957 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
959 /* Execute event hook. */
960 if (route_map_master
.event_hook
&& notify
) {
961 (*route_map_master
.event_hook
)(RMAP_EVENT_INDEX_DELETED
,
963 route_map_notify_dependencies(index
->map
->name
,
964 RMAP_EVENT_CALL_ADDED
);
966 XFREE(MTYPE_ROUTE_MAP_INDEX
, index
);
969 /* Lookup index from route map. */
970 static struct route_map_index
*route_map_index_lookup(struct route_map
*map
,
971 enum route_map_type type
,
974 struct route_map_index
*index
;
976 for (index
= map
->head
; index
; index
= index
->next
)
977 if ((index
->type
== type
|| type
== RMAP_ANY
)
978 && index
->pref
== pref
)
983 /* Add new index to route map. */
984 static struct route_map_index
*
985 route_map_index_add(struct route_map
*map
, enum route_map_type type
, int pref
)
987 struct route_map_index
*index
;
988 struct route_map_index
*point
;
990 /* Allocate new route map inex. */
991 index
= route_map_index_new();
996 /* Compare preference. */
997 for (point
= map
->head
; point
; point
= point
->next
)
998 if (point
->pref
>= pref
)
1001 if (map
->head
== NULL
) {
1002 map
->head
= map
->tail
= index
;
1003 } else if (point
== NULL
) {
1004 index
->prev
= map
->tail
;
1005 map
->tail
->next
= index
;
1007 } else if (point
== map
->head
) {
1008 index
->next
= map
->head
;
1009 map
->head
->prev
= index
;
1012 index
->next
= point
;
1013 index
->prev
= point
->prev
;
1015 point
->prev
->next
= index
;
1016 point
->prev
= index
;
1019 /* Execute event hook. */
1020 if (route_map_master
.event_hook
) {
1021 (*route_map_master
.event_hook
)(RMAP_EVENT_INDEX_ADDED
,
1023 route_map_notify_dependencies(map
->name
, RMAP_EVENT_CALL_ADDED
);
1028 /* Get route map index. */
1029 static struct route_map_index
*
1030 route_map_index_get(struct route_map
*map
, enum route_map_type type
, int pref
)
1032 struct route_map_index
*index
;
1034 index
= route_map_index_lookup(map
, RMAP_ANY
, pref
);
1035 if (index
&& index
->type
!= type
) {
1036 /* Delete index from route map. */
1037 route_map_index_delete(index
, 1);
1041 index
= route_map_index_add(map
, type
, pref
);
1045 /* New route map rule */
1046 static struct route_map_rule
*route_map_rule_new(void)
1048 struct route_map_rule
*new;
1050 new = XCALLOC(MTYPE_ROUTE_MAP_RULE
, sizeof(struct route_map_rule
));
1054 /* Install rule command to the match list. */
1055 void route_map_install_match(struct route_map_rule_cmd
*cmd
)
1057 vector_set(route_match_vec
, cmd
);
1060 /* Install rule command to the set list. */
1061 void route_map_install_set(struct route_map_rule_cmd
*cmd
)
1063 vector_set(route_set_vec
, cmd
);
1066 /* Lookup rule command from match list. */
1067 static struct route_map_rule_cmd
*route_map_lookup_match(const char *name
)
1070 struct route_map_rule_cmd
*rule
;
1072 for (i
= 0; i
< vector_active(route_match_vec
); i
++)
1073 if ((rule
= vector_slot(route_match_vec
, i
)) != NULL
)
1074 if (strcmp(rule
->str
, name
) == 0)
1079 /* Lookup rule command from set list. */
1080 static struct route_map_rule_cmd
*route_map_lookup_set(const char *name
)
1083 struct route_map_rule_cmd
*rule
;
1085 for (i
= 0; i
< vector_active(route_set_vec
); i
++)
1086 if ((rule
= vector_slot(route_set_vec
, i
)) != NULL
)
1087 if (strcmp(rule
->str
, name
) == 0)
1092 /* Add match and set rule to rule list. */
1093 static void route_map_rule_add(struct route_map_rule_list
*list
,
1094 struct route_map_rule
*rule
)
1097 rule
->prev
= list
->tail
;
1099 list
->tail
->next
= rule
;
1105 /* Delete rule from rule list. */
1106 static void route_map_rule_delete(struct route_map_rule_list
*list
,
1107 struct route_map_rule
*rule
)
1109 if (rule
->cmd
->func_free
)
1110 (*rule
->cmd
->func_free
)(rule
->value
);
1113 XFREE(MTYPE_ROUTE_MAP_RULE_STR
, rule
->rule_str
);
1116 rule
->next
->prev
= rule
->prev
;
1118 list
->tail
= rule
->prev
;
1120 rule
->prev
->next
= rule
->next
;
1122 list
->head
= rule
->next
;
1124 XFREE(MTYPE_ROUTE_MAP_RULE
, rule
);
1127 /* strcmp wrapper function which don't crush even argument is NULL. */
1128 static int rulecmp(const char *dst
, const char *src
)
1139 return strcmp(dst
, src
);
1144 /* Use this to return the already specified argument for this match. This is
1145 * useful to get the specified argument with a route map match rule when the
1146 * rule is being deleted and the argument is not provided.
1148 const char *route_map_get_match_arg(struct route_map_index
*index
,
1149 const char *match_name
)
1151 struct route_map_rule
*rule
;
1152 struct route_map_rule_cmd
*cmd
;
1154 /* First lookup rule for add match statement. */
1155 cmd
= route_map_lookup_match(match_name
);
1159 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
1160 if (rule
->cmd
== cmd
&& rule
->rule_str
!= NULL
)
1161 return (rule
->rule_str
);
1166 /* Add match statement to route map. */
1167 int route_map_add_match(struct route_map_index
*index
, const char *match_name
,
1168 const char *match_arg
)
1170 struct route_map_rule
*rule
;
1171 struct route_map_rule
*next
;
1172 struct route_map_rule_cmd
*cmd
;
1176 /* First lookup rule for add match statement. */
1177 cmd
= route_map_lookup_match(match_name
);
1179 return RMAP_RULE_MISSING
;
1181 /* Next call compile function for this match statement. */
1182 if (cmd
->func_compile
) {
1183 compile
= (*cmd
->func_compile
)(match_arg
);
1184 if (compile
== NULL
)
1185 return RMAP_COMPILE_ERROR
;
1189 /* If argument is completely same ignore it. */
1190 for (rule
= index
->match_list
.head
; rule
; rule
= next
) {
1192 if (rule
->cmd
== cmd
) {
1193 route_map_rule_delete(&index
->match_list
, rule
);
1198 /* Add new route map match rule. */
1199 rule
= route_map_rule_new();
1201 rule
->value
= compile
;
1203 rule
->rule_str
= XSTRDUP(MTYPE_ROUTE_MAP_RULE_STR
, match_arg
);
1205 rule
->rule_str
= NULL
;
1207 /* Add new route match rule to linked list. */
1208 route_map_rule_add(&index
->match_list
, rule
);
1210 /* Execute event hook. */
1211 if (route_map_master
.event_hook
) {
1212 (*route_map_master
.event_hook
)(
1213 replaced
? RMAP_EVENT_MATCH_REPLACED
1214 : RMAP_EVENT_MATCH_ADDED
,
1216 route_map_notify_dependencies(index
->map
->name
,
1217 RMAP_EVENT_CALL_ADDED
);
1223 /* Delete specified route match rule. */
1224 int route_map_delete_match(struct route_map_index
*index
,
1225 const char *match_name
, const char *match_arg
)
1227 struct route_map_rule
*rule
;
1228 struct route_map_rule_cmd
*cmd
;
1230 cmd
= route_map_lookup_match(match_name
);
1234 for (rule
= index
->match_list
.head
; rule
; rule
= rule
->next
)
1235 if (rule
->cmd
== cmd
&& (rulecmp(rule
->rule_str
, match_arg
) == 0
1236 || match_arg
== NULL
)) {
1237 route_map_rule_delete(&index
->match_list
, rule
);
1238 /* Execute event hook. */
1239 if (route_map_master
.event_hook
) {
1240 (*route_map_master
.event_hook
)(
1241 RMAP_EVENT_MATCH_DELETED
,
1243 route_map_notify_dependencies(
1245 RMAP_EVENT_CALL_ADDED
);
1249 /* Can't find matched rule. */
1253 /* Add route-map set statement to the route map. */
1254 int route_map_add_set(struct route_map_index
*index
, const char *set_name
,
1255 const char *set_arg
)
1257 struct route_map_rule
*rule
;
1258 struct route_map_rule
*next
;
1259 struct route_map_rule_cmd
*cmd
;
1263 cmd
= route_map_lookup_set(set_name
);
1265 return RMAP_RULE_MISSING
;
1267 /* Next call compile function for this match statement. */
1268 if (cmd
->func_compile
) {
1269 compile
= (*cmd
->func_compile
)(set_arg
);
1270 if (compile
== NULL
)
1271 return RMAP_COMPILE_ERROR
;
1275 /* Add by WJL. if old set command of same kind exist, delete it first
1276 to ensure only one set command of same kind exist under a
1278 for (rule
= index
->set_list
.head
; rule
; rule
= next
) {
1280 if (rule
->cmd
== cmd
) {
1281 route_map_rule_delete(&index
->set_list
, rule
);
1286 /* Add new route map match rule. */
1287 rule
= route_map_rule_new();
1289 rule
->value
= compile
;
1291 rule
->rule_str
= XSTRDUP(MTYPE_ROUTE_MAP_RULE_STR
, set_arg
);
1293 rule
->rule_str
= NULL
;
1295 /* Add new route match rule to linked list. */
1296 route_map_rule_add(&index
->set_list
, rule
);
1298 /* Execute event hook. */
1299 if (route_map_master
.event_hook
) {
1300 (*route_map_master
.event_hook
)(replaced
1301 ? RMAP_EVENT_SET_REPLACED
1302 : RMAP_EVENT_SET_ADDED
,
1304 route_map_notify_dependencies(index
->map
->name
,
1305 RMAP_EVENT_CALL_ADDED
);
1310 /* Delete route map set rule. */
1311 int route_map_delete_set(struct route_map_index
*index
, const char *set_name
,
1312 const char *set_arg
)
1314 struct route_map_rule
*rule
;
1315 struct route_map_rule_cmd
*cmd
;
1317 cmd
= route_map_lookup_set(set_name
);
1321 for (rule
= index
->set_list
.head
; rule
; rule
= rule
->next
)
1322 if ((rule
->cmd
== cmd
) && (rulecmp(rule
->rule_str
, set_arg
) == 0
1323 || set_arg
== NULL
)) {
1324 route_map_rule_delete(&index
->set_list
, rule
);
1325 /* Execute event hook. */
1326 if (route_map_master
.event_hook
) {
1327 (*route_map_master
.event_hook
)(
1328 RMAP_EVENT_SET_DELETED
,
1330 route_map_notify_dependencies(
1332 RMAP_EVENT_CALL_ADDED
);
1336 /* Can't find matched rule. */
1340 /* Apply route map's each index to the object.
1342 The matrix for a route-map looks like this:
1343 (note, this includes the description for the "NEXT"
1344 and "GOTO" frobs now
1348 permit action | cont
1350 ------------------+---------------
1356 -Apply Set statements, accept route
1357 -If Call statement is present jump to the specified route-map, if it
1358 denies the route we finish.
1359 -If NEXT is specified, goto NEXT statement
1360 -If GOTO is specified, goto the first clause where pref > nextpref
1361 -If nothing is specified, do as Cisco and finish
1363 -Route is denied by route-map.
1367 If we get no matches after we've processed all updates, then the route
1370 Some notes on the new "CALL", "NEXT" and "GOTO"
1371 call WORD - If this clause is matched, then the set statements
1372 are executed and then we jump to route-map 'WORD'. If
1373 this route-map denies the route, we finish, in other
1375 do whatever the exit policy (EXIT, NEXT or GOTO) tells.
1376 on-match next - If this clause is matched, then the set statements
1377 are executed and then we drop through to the next clause
1378 on-match goto n - If this clause is matched, then the set statments
1379 are executed and then we goto the nth clause, or the
1380 first clause greater than this. In order to ensure
1381 route-maps *always* exit, you cannot jump backwards.
1384 We need to make sure our route-map processing matches the above
1387 static route_map_result_t
1388 route_map_apply_match(struct route_map_rule_list
*match_list
,
1389 struct prefix
*prefix
, route_map_object_t type
,
1392 route_map_result_t ret
= RMAP_NOMATCH
;
1393 struct route_map_rule
*match
;
1396 /* Check all match rule and if there is no match rule, go to the
1398 if (!match_list
->head
)
1401 for (match
= match_list
->head
; match
; match
= match
->next
) {
1402 /* Try each match statement in turn, If any do not
1404 RMAP_MATCH, return, otherwise continue on to next
1406 statement. All match statements must match for
1409 ret
= (*match
->cmd
->func_apply
)(match
->value
, prefix
,
1411 if (ret
!= RMAP_MATCH
)
1418 /* Apply route map to the object. */
1419 route_map_result_t
route_map_apply(struct route_map
*map
, struct prefix
*prefix
,
1420 route_map_object_t type
, void *object
)
1422 static int recursion
= 0;
1424 struct route_map_index
*index
;
1425 struct route_map_rule
*set
;
1427 if (recursion
> RMAP_RECURSION_LIMIT
) {
1429 "route-map recursion limit (%d) reached, discarding route",
1430 RMAP_RECURSION_LIMIT
);
1432 return RMAP_DENYMATCH
;
1436 return RMAP_DENYMATCH
;
1438 for (index
= map
->head
; index
; index
= index
->next
) {
1439 /* Apply this index. */
1440 ret
= route_map_apply_match(&index
->match_list
, prefix
, type
,
1443 /* Now we apply the matrix from above */
1444 if (ret
== RMAP_NOMATCH
)
1445 /* 'cont' from matrix - continue to next route-map
1448 else if (ret
== RMAP_MATCH
) {
1449 if (index
->type
== RMAP_PERMIT
)
1452 /* permit+match must execute sets */
1453 for (set
= index
->set_list
.head
; set
;
1455 ret
= (*set
->cmd
->func_apply
)(
1456 set
->value
, prefix
, type
,
1459 /* Call another route-map if available */
1460 if (index
->nextrm
) {
1461 struct route_map
*nextrm
=
1462 route_map_lookup_by_name(
1465 if (nextrm
) /* Target route-map found,
1469 ret
= route_map_apply(
1470 nextrm
, prefix
, type
,
1475 /* If nextrm returned 'deny', finish. */
1476 if (ret
== RMAP_DENYMATCH
)
1480 switch (index
->exitpolicy
) {
1486 /* Find the next clause to jump to */
1487 struct route_map_index
*next
=
1489 int nextpref
= index
->nextpref
;
1491 while (next
&& next
->pref
< nextpref
) {
1496 /* No clauses match! */
1501 } else if (index
->type
== RMAP_DENY
)
1504 return RMAP_DENYMATCH
;
1508 /* Finally route-map does not match at all. */
1509 return RMAP_DENYMATCH
;
1512 void route_map_add_hook(void (*func
)(const char *))
1514 route_map_master
.add_hook
= func
;
1517 void route_map_delete_hook(void (*func
)(const char *))
1519 route_map_master
.delete_hook
= func
;
1522 void route_map_event_hook(void (*func
)(route_map_event_t
, const char *))
1524 route_map_master
.event_hook
= func
;
1527 /* Routines for route map dependency lists and dependency processing */
1528 static int route_map_rmap_hash_cmp(const void *p1
, const void *p2
)
1530 return (strcmp((const char *)p1
, (const char *)p2
) == 0);
1533 static int route_map_dep_hash_cmp(const void *p1
, const void *p2
)
1536 return (strcmp(((const struct route_map_dep
*)p1
)->dep_name
,
1541 static void route_map_clear_reference(struct hash_backet
*backet
, void *arg
)
1543 struct route_map_dep
*dep
= (struct route_map_dep
*)backet
->data
;
1548 (char *)hash_release(dep
->dep_rmap_hash
, (void *)arg
);
1550 XFREE(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1552 if (!dep
->dep_rmap_hash
->count
) {
1553 dep
= hash_release(dep
->this_hash
,
1554 (void *)dep
->dep_name
);
1555 hash_free(dep
->dep_rmap_hash
);
1556 XFREE(MTYPE_ROUTE_MAP_NAME
, dep
->dep_name
);
1557 XFREE(MTYPE_ROUTE_MAP_DEP
, dep
);
1562 static void route_map_clear_all_references(char *rmap_name
)
1566 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++) {
1567 hash_iterate(route_map_dep_hash
[i
], route_map_clear_reference
,
1572 static void *route_map_dep_hash_alloc(void *p
)
1574 char *dep_name
= (char *)p
;
1575 struct route_map_dep
*dep_entry
;
1577 dep_entry
= XCALLOC(MTYPE_ROUTE_MAP_DEP
, sizeof(struct route_map_dep
));
1578 dep_entry
->dep_name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, dep_name
);
1579 dep_entry
->dep_rmap_hash
= hash_create(route_map_dep_hash_make_key
,
1580 route_map_rmap_hash_cmp
, NULL
);
1581 dep_entry
->this_hash
= NULL
;
1583 return ((void *)dep_entry
);
1586 static void *route_map_name_hash_alloc(void *p
)
1588 return ((void *)XSTRDUP(MTYPE_ROUTE_MAP_NAME
, (const char *)p
));
1591 static unsigned int route_map_dep_hash_make_key(void *p
)
1593 return (string_hash_make((char *)p
));
1596 static void route_map_print_dependency(struct hash_backet
*backet
, void *data
)
1598 char *rmap_name
= (char *)backet
->data
;
1599 char *dep_name
= (char *)data
;
1602 zlog_debug("%s: Dependency for %s: %s", __FUNCTION__
, dep_name
,
1606 static int route_map_dep_update(struct hash
*dephash
, const char *dep_name
,
1607 const char *rmap_name
, route_map_event_t type
)
1609 struct route_map_dep
*dep
= NULL
;
1611 char *dname
, *rname
;
1614 dname
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, dep_name
);
1615 rname
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap_name
);
1618 case RMAP_EVENT_PLIST_ADDED
:
1619 case RMAP_EVENT_CLIST_ADDED
:
1620 case RMAP_EVENT_ECLIST_ADDED
:
1621 case RMAP_EVENT_ASLIST_ADDED
:
1622 case RMAP_EVENT_LLIST_ADDED
:
1623 case RMAP_EVENT_CALL_ADDED
:
1624 case RMAP_EVENT_FILTER_ADDED
:
1626 zlog_debug("%s: Adding dependency for %s in %s",
1627 __FUNCTION__
, dep_name
, rmap_name
);
1628 dep
= (struct route_map_dep
*)hash_get(
1629 dephash
, dname
, route_map_dep_hash_alloc
);
1635 if (!dep
->this_hash
)
1636 dep
->this_hash
= dephash
;
1638 hash_get(dep
->dep_rmap_hash
, rname
, route_map_name_hash_alloc
);
1640 case RMAP_EVENT_PLIST_DELETED
:
1641 case RMAP_EVENT_CLIST_DELETED
:
1642 case RMAP_EVENT_ECLIST_DELETED
:
1643 case RMAP_EVENT_ASLIST_DELETED
:
1644 case RMAP_EVENT_LLIST_DELETED
:
1645 case RMAP_EVENT_CALL_DELETED
:
1646 case RMAP_EVENT_FILTER_DELETED
:
1648 zlog_debug("%s: Deleting dependency for %s in %s",
1649 __FUNCTION__
, dep_name
, rmap_name
);
1650 dep
= (struct route_map_dep
*)hash_get(dephash
, dname
, NULL
);
1655 ret_map_name
= (char *)hash_release(dep
->dep_rmap_hash
, rname
);
1657 XFREE(MTYPE_ROUTE_MAP_NAME
, ret_map_name
);
1659 if (!dep
->dep_rmap_hash
->count
) {
1660 dep
= hash_release(dephash
, dname
);
1661 hash_free(dep
->dep_rmap_hash
);
1662 XFREE(MTYPE_ROUTE_MAP_NAME
, dep
->dep_name
);
1663 XFREE(MTYPE_ROUTE_MAP_DEP
, dep
);
1673 hash_iterate(dep
->dep_rmap_hash
,
1674 route_map_print_dependency
, dname
);
1678 XFREE(MTYPE_ROUTE_MAP_NAME
, rname
);
1679 XFREE(MTYPE_ROUTE_MAP_NAME
, dname
);
1683 static struct hash
*route_map_get_dep_hash(route_map_event_t event
)
1685 struct hash
*upd8_hash
= NULL
;
1688 case RMAP_EVENT_PLIST_ADDED
:
1689 case RMAP_EVENT_PLIST_DELETED
:
1690 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_PLIST
];
1692 case RMAP_EVENT_CLIST_ADDED
:
1693 case RMAP_EVENT_CLIST_DELETED
:
1694 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_CLIST
];
1696 case RMAP_EVENT_ECLIST_ADDED
:
1697 case RMAP_EVENT_ECLIST_DELETED
:
1698 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_ECLIST
];
1700 case RMAP_EVENT_ASLIST_ADDED
:
1701 case RMAP_EVENT_ASLIST_DELETED
:
1702 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_ASPATH
];
1704 case RMAP_EVENT_LLIST_ADDED
:
1705 case RMAP_EVENT_LLIST_DELETED
:
1706 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_LCLIST
];
1708 case RMAP_EVENT_CALL_ADDED
:
1709 case RMAP_EVENT_CALL_DELETED
:
1710 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_RMAP
];
1712 case RMAP_EVENT_FILTER_ADDED
:
1713 case RMAP_EVENT_FILTER_DELETED
:
1714 upd8_hash
= route_map_dep_hash
[ROUTE_MAP_DEP_FILTER
];
1723 static void route_map_process_dependency(struct hash_backet
*backet
, void *data
)
1726 route_map_event_t type
= (route_map_event_t
)(ptrdiff_t)data
;
1728 rmap_name
= (char *)backet
->data
;
1732 zlog_debug("%s: Notifying %s of dependency",
1733 __FUNCTION__
, rmap_name
);
1734 if (route_map_master
.event_hook
)
1735 (*route_map_master
.event_hook
)(type
, rmap_name
);
1739 void route_map_upd8_dependency(route_map_event_t type
, const char *arg
,
1740 const char *rmap_name
)
1742 struct hash
*upd8_hash
= NULL
;
1744 if ((upd8_hash
= route_map_get_dep_hash(type
)))
1745 route_map_dep_update(upd8_hash
, arg
, rmap_name
, type
);
1748 void route_map_notify_dependencies(const char *affected_name
,
1749 route_map_event_t event
)
1751 struct route_map_dep
*dep
;
1752 struct hash
*upd8_hash
;
1758 name
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, affected_name
);
1760 if ((upd8_hash
= route_map_get_dep_hash(event
)) == NULL
) {
1761 XFREE(MTYPE_ROUTE_MAP_NAME
, name
);
1765 dep
= (struct route_map_dep
*)hash_get(upd8_hash
, name
, NULL
);
1767 if (!dep
->this_hash
)
1768 dep
->this_hash
= upd8_hash
;
1770 hash_iterate(dep
->dep_rmap_hash
, route_map_process_dependency
,
1774 XFREE(MTYPE_ROUTE_MAP_NAME
, name
);
1778 /* VTY related functions. */
1779 DEFUN (match_interface
,
1780 match_interface_cmd
,
1781 "match interface WORD",
1783 "match first hop interface of route\n"
1787 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1789 if (rmap_match_set_hook
.match_interface
)
1790 return rmap_match_set_hook
.match_interface(
1791 vty
, index
, "interface", argv
[idx_word
]->arg
,
1792 RMAP_EVENT_MATCH_ADDED
);
1796 DEFUN (no_match_interface
,
1797 no_match_interface_cmd
,
1798 "no match interface [WORD]",
1801 "Match first hop interface of route\n"
1804 char *iface
= (argc
== 4) ? argv
[3]->arg
: NULL
;
1805 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1807 if (rmap_match_set_hook
.no_match_interface
)
1808 return rmap_match_set_hook
.no_match_interface(
1809 vty
, index
, "interface", iface
,
1810 RMAP_EVENT_MATCH_DELETED
);
1815 DEFUN (match_ip_address
,
1816 match_ip_address_cmd
,
1817 "match ip address <(1-199)|(1300-2699)|WORD>",
1820 "Match address of route\n"
1821 "IP access-list number\n"
1822 "IP access-list number (expanded range)\n"
1823 "IP Access-list name\n")
1826 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1828 if (rmap_match_set_hook
.match_ip_address
)
1829 return rmap_match_set_hook
.match_ip_address(
1830 vty
, index
, "ip address", argv
[idx_acl
]->arg
,
1831 RMAP_EVENT_FILTER_ADDED
);
1836 DEFUN (no_match_ip_address
,
1837 no_match_ip_address_cmd
,
1838 "no match ip address [<(1-199)|(1300-2699)|WORD>]",
1842 "Match address of route\n"
1843 "IP access-list number\n"
1844 "IP access-list number (expanded range)\n"
1845 "IP Access-list name\n")
1848 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1850 if (rmap_match_set_hook
.no_match_ip_address
) {
1851 if (argc
<= idx_word
)
1852 return rmap_match_set_hook
.no_match_ip_address(
1853 vty
, index
, "ip address", NULL
,
1854 RMAP_EVENT_FILTER_DELETED
);
1855 return rmap_match_set_hook
.no_match_ip_address(
1856 vty
, index
, "ip address", argv
[idx_word
]->arg
,
1857 RMAP_EVENT_FILTER_DELETED
);
1863 DEFUN (match_ip_address_prefix_list
,
1864 match_ip_address_prefix_list_cmd
,
1865 "match ip address prefix-list WORD",
1868 "Match address of route\n"
1869 "Match entries of prefix-lists\n"
1870 "IP prefix-list name\n")
1873 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1875 if (rmap_match_set_hook
.match_ip_address_prefix_list
)
1876 return rmap_match_set_hook
.match_ip_address_prefix_list(
1877 vty
, index
, "ip address prefix-list",
1878 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
1883 DEFUN (no_match_ip_address_prefix_list
,
1884 no_match_ip_address_prefix_list_cmd
,
1885 "no match ip address prefix-list [WORD]",
1889 "Match address of route\n"
1890 "Match entries of prefix-lists\n"
1891 "IP prefix-list name\n")
1894 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1896 if (rmap_match_set_hook
.no_match_ip_address_prefix_list
) {
1897 if (argc
<= idx_word
)
1898 return rmap_match_set_hook
1899 .no_match_ip_address_prefix_list(
1900 vty
, index
, "ip address prefix-list",
1901 NULL
, RMAP_EVENT_PLIST_DELETED
);
1902 return rmap_match_set_hook
.no_match_ip_address_prefix_list(
1903 vty
, index
, "ip address prefix-list",
1904 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
1910 DEFUN (match_ip_next_hop
,
1911 match_ip_next_hop_cmd
,
1912 "match ip next-hop <(1-199)|(1300-2699)|WORD>",
1915 "Match next-hop address of route\n"
1916 "IP access-list number\n"
1917 "IP access-list number (expanded range)\n"
1918 "IP Access-list name\n")
1921 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1923 if (rmap_match_set_hook
.match_ip_next_hop
)
1924 return rmap_match_set_hook
.match_ip_next_hop(
1925 vty
, index
, "ip next-hop", argv
[idx_acl
]->arg
,
1926 RMAP_EVENT_FILTER_ADDED
);
1931 DEFUN (no_match_ip_next_hop
,
1932 no_match_ip_next_hop_cmd
,
1933 "no match ip next-hop [<(1-199)|(1300-2699)|WORD>]",
1937 "Match next-hop address of route\n"
1938 "IP access-list number\n"
1939 "IP access-list number (expanded range)\n"
1940 "IP Access-list name\n")
1943 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1945 if (rmap_match_set_hook
.no_match_ip_next_hop
) {
1946 if (argc
<= idx_word
)
1947 return rmap_match_set_hook
.no_match_ip_next_hop(
1948 vty
, index
, "ip next-hop", NULL
,
1949 RMAP_EVENT_FILTER_DELETED
);
1950 return rmap_match_set_hook
.no_match_ip_next_hop(
1951 vty
, index
, "ip next-hop", argv
[idx_word
]->arg
,
1952 RMAP_EVENT_FILTER_DELETED
);
1958 DEFUN (match_ip_next_hop_prefix_list
,
1959 match_ip_next_hop_prefix_list_cmd
,
1960 "match ip next-hop prefix-list WORD",
1963 "Match next-hop address of route\n"
1964 "Match entries of prefix-lists\n"
1965 "IP prefix-list name\n")
1968 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1970 if (rmap_match_set_hook
.match_ip_next_hop_prefix_list
)
1971 return rmap_match_set_hook
.match_ip_next_hop_prefix_list(
1972 vty
, index
, "ip next-hop prefix-list",
1973 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
1977 DEFUN (no_match_ip_next_hop_prefix_list
,
1978 no_match_ip_next_hop_prefix_list_cmd
,
1979 "no match ip next-hop prefix-list [WORD]",
1983 "Match next-hop address of route\n"
1984 "Match entries of prefix-lists\n"
1985 "IP prefix-list name\n")
1988 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
1990 if (rmap_match_set_hook
.no_match_ip_next_hop
) {
1991 if (argc
<= idx_word
)
1992 return rmap_match_set_hook
.no_match_ip_next_hop(
1993 vty
, index
, "ip next-hop prefix-list", NULL
,
1994 RMAP_EVENT_PLIST_DELETED
);
1995 return rmap_match_set_hook
.no_match_ip_next_hop(
1996 vty
, index
, "ip next-hop prefix-list",
1997 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
2003 DEFUN (match_ipv6_address
,
2004 match_ipv6_address_cmd
,
2005 "match ipv6 address WORD",
2008 "Match IPv6 address of route\n"
2009 "IPv6 access-list name\n")
2012 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2014 if (rmap_match_set_hook
.match_ipv6_address
)
2015 return rmap_match_set_hook
.match_ipv6_address(
2016 vty
, index
, "ipv6 address", argv
[idx_word
]->arg
,
2017 RMAP_EVENT_FILTER_ADDED
);
2021 DEFUN (no_match_ipv6_address
,
2022 no_match_ipv6_address_cmd
,
2023 "no match ipv6 address WORD",
2027 "Match IPv6 address of route\n"
2028 "IPv6 access-list name\n")
2031 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2033 if (rmap_match_set_hook
.no_match_ipv6_address
)
2034 return rmap_match_set_hook
.no_match_ipv6_address(
2035 vty
, index
, "ipv6 address", argv
[idx_word
]->arg
,
2036 RMAP_EVENT_FILTER_DELETED
);
2041 DEFUN (match_ipv6_address_prefix_list
,
2042 match_ipv6_address_prefix_list_cmd
,
2043 "match ipv6 address prefix-list WORD",
2046 "Match address of route\n"
2047 "Match entries of prefix-lists\n"
2048 "IP prefix-list name\n")
2051 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2053 if (rmap_match_set_hook
.match_ipv6_address_prefix_list
)
2054 return rmap_match_set_hook
.match_ipv6_address_prefix_list(
2055 vty
, index
, "ipv6 address prefix-list",
2056 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_ADDED
);
2060 DEFUN (no_match_ipv6_address_prefix_list
,
2061 no_match_ipv6_address_prefix_list_cmd
,
2062 "no match ipv6 address prefix-list WORD",
2066 "Match address of route\n"
2067 "Match entries of prefix-lists\n"
2068 "IP prefix-list name\n")
2071 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2073 if (rmap_match_set_hook
.no_match_ipv6_address_prefix_list
)
2074 return rmap_match_set_hook
.no_match_ipv6_address_prefix_list(
2075 vty
, index
, "ipv6 address prefix-list",
2076 argv
[idx_word
]->arg
, RMAP_EVENT_PLIST_DELETED
);
2081 DEFUN (match_metric
,
2083 "match metric (0-4294967295)",
2085 "Match metric of route\n"
2089 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2091 if (rmap_match_set_hook
.match_metric
)
2092 return rmap_match_set_hook
.match_metric(vty
, index
, "metric",
2093 argv
[idx_number
]->arg
,
2094 RMAP_EVENT_MATCH_ADDED
);
2099 DEFUN (no_match_metric
,
2100 no_match_metric_cmd
,
2101 "no match metric [(0-4294967295)]",
2104 "Match metric of route\n"
2108 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2110 if (rmap_match_set_hook
.no_match_metric
) {
2111 if (argc
<= idx_number
)
2112 return rmap_match_set_hook
.no_match_metric(
2113 vty
, index
, "metric", NULL
,
2114 RMAP_EVENT_MATCH_DELETED
);
2115 return rmap_match_set_hook
.no_match_metric(
2116 vty
, index
, "metric", argv
[idx_number
]->arg
,
2117 RMAP_EVENT_MATCH_DELETED
);
2125 "match tag (1-4294967295)",
2127 "Match tag of route\n"
2131 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2133 if (rmap_match_set_hook
.match_tag
)
2134 return rmap_match_set_hook
.match_tag(vty
, index
, "tag",
2135 argv
[idx_number
]->arg
,
2136 RMAP_EVENT_MATCH_ADDED
);
2141 DEFUN (no_match_tag
,
2143 "no match tag [(1-4294967295)]",
2146 "Match tag of route\n"
2149 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2152 char *arg
= argv_find(argv
, argc
, "(1-4294967295)", &idx
)
2156 if (rmap_match_set_hook
.no_match_tag
)
2157 return rmap_match_set_hook
.no_match_tag(
2158 vty
, index
, "tag", arg
, RMAP_EVENT_MATCH_DELETED
);
2163 DEFUN (set_ip_nexthop
,
2165 "set ip next-hop A.B.C.D",
2168 "Next hop address\n"
2169 "IP address of next hop\n")
2174 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2176 ret
= str2sockunion(argv
[idx_ipv4
]->arg
, &su
);
2178 vty_out(vty
, "%% Malformed nexthop address\n");
2179 return CMD_WARNING_CONFIG_FAILED
;
2181 if (su
.sin
.sin_addr
.s_addr
== 0
2182 || IPV4_CLASS_DE(su
.sin
.sin_addr
.s_addr
)) {
2184 "%% nexthop address cannot be 0.0.0.0, multicast or reserved\n");
2185 return CMD_WARNING_CONFIG_FAILED
;
2188 if (rmap_match_set_hook
.set_ip_nexthop
)
2189 return rmap_match_set_hook
.set_ip_nexthop(
2190 vty
, index
, "ip next-hop", argv
[idx_ipv4
]->arg
);
2195 DEFUN (no_set_ip_nexthop
,
2196 no_set_ip_nexthop_cmd
,
2197 "no set ip next-hop [<peer-address|A.B.C.D>]",
2201 "Next hop address\n"
2202 "Use peer address (for BGP only)\n"
2203 "IP address of next hop\n")
2206 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2208 if (rmap_match_set_hook
.no_set_ip_nexthop
) {
2209 if (argc
<= idx_peer
)
2210 return rmap_match_set_hook
.no_set_ip_nexthop(
2211 vty
, index
, "ip next-hop", NULL
);
2212 return rmap_match_set_hook
.no_set_ip_nexthop(
2213 vty
, index
, "ip next-hop", argv
[idx_peer
]->arg
);
2219 DEFUN (set_ipv6_nexthop_local
,
2220 set_ipv6_nexthop_local_cmd
,
2221 "set ipv6 next-hop local X:X::X:X",
2224 "IPv6 next-hop address\n"
2225 "IPv6 local address\n"
2226 "IPv6 address of next hop\n")
2229 struct in6_addr addr
;
2231 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2233 ret
= inet_pton(AF_INET6
, argv
[idx_ipv6
]->arg
, &addr
);
2235 vty_out(vty
, "%% Malformed nexthop address\n");
2236 return CMD_WARNING_CONFIG_FAILED
;
2238 if (!IN6_IS_ADDR_LINKLOCAL(&addr
)) {
2239 vty_out(vty
, "%% Invalid link-local nexthop address\n");
2240 return CMD_WARNING_CONFIG_FAILED
;
2243 if (rmap_match_set_hook
.set_ipv6_nexthop_local
)
2244 return rmap_match_set_hook
.set_ipv6_nexthop_local(
2245 vty
, index
, "ipv6 next-hop local", argv
[idx_ipv6
]->arg
);
2250 DEFUN (no_set_ipv6_nexthop_local
,
2251 no_set_ipv6_nexthop_local_cmd
,
2252 "no set ipv6 next-hop local [X:X::X:X]",
2256 "IPv6 next-hop address\n"
2257 "IPv6 local address\n"
2258 "IPv6 address of next hop\n")
2261 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2263 if (rmap_match_set_hook
.no_set_ipv6_nexthop_local
) {
2264 if (argc
<= idx_ipv6
)
2265 return rmap_match_set_hook
.no_set_ipv6_nexthop_local(
2266 vty
, index
, "ipv6 next-hop local", NULL
);
2267 return rmap_match_set_hook
.no_set_ipv6_nexthop_local(
2268 vty
, index
, "ipv6 next-hop local", argv
[5]->arg
);
2275 "set metric <(0-4294967295)|rtt|+rtt|-rtt|+metric|-metric>",
2277 "Metric value for destination routing protocol\n"
2279 "Assign round trip time\n"
2280 "Add round trip time\n"
2281 "Subtract round trip time\n"
2283 "Subtract metric\n")
2286 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2288 const char *pass
= (argv
[idx_number
]->type
== RANGE_TKN
)
2289 ? argv
[idx_number
]->arg
2290 : argv
[idx_number
]->text
;
2292 if (rmap_match_set_hook
.set_metric
)
2293 return rmap_match_set_hook
.set_metric(vty
, index
, "metric",
2299 DEFUN (no_set_metric
,
2301 "no set metric [(0-4294967295)]",
2304 "Metric value for destination routing protocol\n"
2308 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2310 if (rmap_match_set_hook
.no_set_metric
) {
2311 if (argc
<= idx_number
)
2312 return rmap_match_set_hook
.no_set_metric(
2313 vty
, index
, "metric", NULL
);
2314 return rmap_match_set_hook
.no_set_metric(vty
, index
, "metric",
2315 argv
[idx_number
]->arg
);
2323 "set tag (1-4294967295)",
2325 "Tag value for routing protocol\n"
2328 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2331 if (rmap_match_set_hook
.set_tag
)
2332 return rmap_match_set_hook
.set_tag(vty
, index
, "tag",
2333 argv
[idx_number
]->arg
);
2340 "no set tag [(1-4294967295)]",
2343 "Tag value for routing protocol\n"
2346 VTY_DECLVAR_CONTEXT(route_map_index
, index
);
2349 if (rmap_match_set_hook
.no_set_tag
) {
2350 if (argc
<= idx_number
)
2351 return rmap_match_set_hook
.no_set_tag(vty
, index
, "tag",
2353 return rmap_match_set_hook
.no_set_tag(vty
, index
, "tag",
2354 argv
[idx_number
]->arg
);
2360 DEFUN_NOSH (route_map
,
2362 "route-map WORD <deny|permit> (1-65535)",
2363 "Create route-map or enter route-map command mode\n"
2365 "Route map denies set operations\n"
2366 "Route map permits set operations\n"
2367 "Sequence to insert to/delete from existing route-map entry\n")
2370 int idx_permit_deny
= 2;
2372 struct route_map
*map
;
2373 struct route_map_index
*index
;
2374 char *endptr
= NULL
;
2376 argv
[idx_permit_deny
]->arg
[0] == 'p' ? RMAP_PERMIT
: RMAP_DENY
;
2377 unsigned long pref
= strtoul(argv
[idx_number
]->arg
, &endptr
, 10);
2378 const char *mapname
= argv
[idx_word
]->arg
;
2380 /* Get route map. */
2381 map
= route_map_get(mapname
);
2382 index
= route_map_index_get(map
, permit
, pref
);
2384 VTY_PUSH_CONTEXT(RMAP_NODE
, index
);
2388 DEFUN (no_route_map_all
,
2389 no_route_map_all_cmd
,
2390 "no route-map WORD",
2392 "Create route-map or enter route-map command mode\n"
2396 const char *mapname
= argv
[idx_word
]->arg
;
2397 struct route_map
*map
;
2399 map
= route_map_lookup_by_name(mapname
);
2401 vty_out(vty
, "%% Could not find route-map %s\n", mapname
);
2402 return CMD_WARNING_CONFIG_FAILED
;
2405 route_map_delete(map
);
2410 DEFUN (no_route_map
,
2412 "no route-map WORD <deny|permit> (1-65535)",
2414 "Create route-map or enter route-map command mode\n"
2416 "Route map denies set operations\n"
2417 "Route map permits set operations\n"
2418 "Sequence to insert to/delete from existing route-map entry\n")
2421 int idx_permit_deny
= 3;
2423 struct route_map
*map
;
2424 struct route_map_index
*index
;
2425 char *endptr
= NULL
;
2426 int permit
= strmatch(argv
[idx_permit_deny
]->text
, "permit")
2429 const char *prefstr
= argv
[idx_number
]->arg
;
2430 const char *mapname
= argv
[idx_word
]->arg
;
2431 unsigned long pref
= strtoul(prefstr
, &endptr
, 10);
2433 /* Existence check. */
2434 map
= route_map_lookup_by_name(mapname
);
2436 vty_out(vty
, "%% Could not find route-map %s\n", mapname
);
2437 return CMD_WARNING_CONFIG_FAILED
;
2440 /* Lookup route map index. */
2441 index
= route_map_index_lookup(map
, permit
, pref
);
2442 if (index
== NULL
) {
2443 vty_out(vty
, "%% Could not find route-map entry %s %s\n",
2445 return CMD_WARNING_CONFIG_FAILED
;
2448 /* Delete index from route map. */
2449 route_map_index_delete(index
, 1);
2451 /* If this route rule is the last one, delete route map itself. */
2452 if (route_map_empty(map
))
2453 route_map_delete(map
);
2458 DEFUN (rmap_onmatch_next
,
2459 rmap_onmatch_next_cmd
,
2461 "Exit policy on matches\n"
2464 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2467 if (index
->type
== RMAP_DENY
) {
2468 /* Under a deny clause, match means it's finished. No
2469 * need to set next */
2471 "on-match next not supported under route-map deny\n");
2472 return CMD_WARNING_CONFIG_FAILED
;
2474 index
->exitpolicy
= RMAP_NEXT
;
2479 DEFUN (no_rmap_onmatch_next
,
2480 no_rmap_onmatch_next_cmd
,
2483 "Exit policy on matches\n"
2486 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2489 index
->exitpolicy
= RMAP_EXIT
;
2494 DEFUN (rmap_onmatch_goto
,
2495 rmap_onmatch_goto_cmd
,
2496 "on-match goto (1-65535)",
2497 "Exit policy on matches\n"
2498 "Goto Clause number\n"
2502 char *num
= argv_find(argv
, argc
, "(1-65535)", &idx
) ? argv
[idx
]->arg
2505 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2509 if (index
->type
== RMAP_DENY
) {
2510 /* Under a deny clause, match means it's finished. No
2511 * need to go anywhere */
2513 "on-match goto not supported under route-map deny\n");
2514 return CMD_WARNING_CONFIG_FAILED
;
2518 d
= strtoul(num
, NULL
, 10);
2520 d
= index
->pref
+ 1;
2522 if (d
<= index
->pref
) {
2523 /* Can't allow you to do that, Dave */
2524 vty_out(vty
, "can't jump backwards in route-maps\n");
2525 return CMD_WARNING_CONFIG_FAILED
;
2527 index
->exitpolicy
= RMAP_GOTO
;
2528 index
->nextpref
= d
;
2534 DEFUN (no_rmap_onmatch_goto
,
2535 no_rmap_onmatch_goto_cmd
,
2538 "Exit policy on matches\n"
2539 "Goto Clause number\n")
2541 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2544 index
->exitpolicy
= RMAP_EXIT
;
2549 /* Cisco/GNU Zebra compatibility aliases */
2551 DEFUN (rmap_continue
,
2553 "continue (1-65535)",
2554 "Continue on a different entry within the route-map\n"
2555 "Route-map entry sequence number\n")
2557 return rmap_onmatch_goto(self
, vty
, argc
, argv
);
2561 DEFUN (no_rmap_continue
,
2562 no_rmap_continue_cmd
,
2563 "no continue [(1-65535)]",
2565 "Continue on a different entry within the route-map\n"
2566 "Route-map entry sequence number\n")
2568 return no_rmap_onmatch_goto(self
, vty
, argc
, argv
);
2572 DEFUN (rmap_show_name
,
2574 "show route-map [WORD]",
2576 "route-map information\n"
2580 const char *name
= (argc
== 3) ? argv
[idx_word
]->arg
: NULL
;
2581 return vty_show_route_map(vty
, name
);
2587 "Jump to another Route-Map after match+set\n"
2588 "Target route-map name\n")
2591 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2592 const char *rmap
= argv
[idx_word
]->arg
;
2596 if (index
->nextrm
) {
2597 route_map_upd8_dependency(RMAP_EVENT_CALL_DELETED
,
2598 index
->nextrm
, index
->map
->name
);
2599 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
2601 index
->nextrm
= XSTRDUP(MTYPE_ROUTE_MAP_NAME
, rmap
);
2603 /* Execute event hook. */
2604 route_map_upd8_dependency(RMAP_EVENT_CALL_ADDED
, index
->nextrm
,
2609 DEFUN (no_rmap_call
,
2613 "Jump to another Route-Map after match+set\n")
2615 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2617 if (index
->nextrm
) {
2618 route_map_upd8_dependency(RMAP_EVENT_CALL_DELETED
,
2619 index
->nextrm
, index
->map
->name
);
2620 XFREE(MTYPE_ROUTE_MAP_NAME
, index
->nextrm
);
2621 index
->nextrm
= NULL
;
2627 DEFUN (rmap_description
,
2628 rmap_description_cmd
,
2629 "description LINE...",
2630 "Route-map comment\n"
2631 "Comment describing this route-map rule\n")
2634 struct route_map_index
*index
= VTY_GET_CONTEXT(route_map_index
);
2637 if (index
->description
)
2638 XFREE(MTYPE_TMP
, index
->description
);
2639 index
->description
= argv_concat(argv
, argc
, idx_line
);
2644 DEFUN (no_rmap_description
,
2645 no_rmap_description_cmd
,
2648 "Route-map comment\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
= NULL
;
2660 /* Configuration write function. */
2661 static int route_map_config_write(struct vty
*vty
)
2663 struct route_map
*map
;
2664 struct route_map_index
*index
;
2665 struct route_map_rule
*rule
;
2669 for (map
= route_map_master
.head
; map
; map
= map
->next
)
2670 for (index
= map
->head
; index
; index
= index
->next
) {
2672 vty_out(vty
, "!\n");
2676 vty_out(vty
, "route-map %s %s %d\n", map
->name
,
2677 route_map_type_str(index
->type
), index
->pref
);
2679 if (index
->description
)
2680 vty_out(vty
, " description %s\n",
2681 index
->description
);
2683 for (rule
= index
->match_list
.head
; rule
;
2685 vty_out(vty
, " match %s %s\n", rule
->cmd
->str
,
2686 rule
->rule_str
? rule
->rule_str
: "");
2688 for (rule
= index
->set_list
.head
; rule
;
2690 vty_out(vty
, " set %s %s\n", rule
->cmd
->str
,
2691 rule
->rule_str
? rule
->rule_str
: "");
2693 vty_out(vty
, " call %s\n", index
->nextrm
);
2694 if (index
->exitpolicy
== RMAP_GOTO
)
2695 vty_out(vty
, " on-match goto %d\n",
2697 if (index
->exitpolicy
== RMAP_NEXT
)
2698 vty_out(vty
, " on-match next\n");
2705 /* Route map node structure. */
2706 static struct cmd_node rmap_node
= {RMAP_NODE
, "%s(config-route-map)# ", 1};
2708 /* Common route map rules */
2710 void *route_map_rule_tag_compile(const char *arg
)
2712 unsigned long int tmp
;
2717 tmp
= strtoul(arg
, &endptr
, 0);
2718 if (arg
[0] == '\0' || *endptr
!= '\0' || errno
|| tmp
> ROUTE_TAG_MAX
)
2721 tag
= XMALLOC(MTYPE_ROUTE_MAP_COMPILED
, sizeof(*tag
));
2727 void route_map_rule_tag_free(void *rule
)
2729 XFREE(MTYPE_ROUTE_MAP_COMPILED
, rule
);
2732 void route_map_finish(void)
2736 vector_free(route_match_vec
);
2737 route_match_vec
= NULL
;
2738 vector_free(route_set_vec
);
2739 route_set_vec
= NULL
;
2741 /* cleanup route_map */
2742 while (route_map_master
.head
) {
2743 struct route_map
*map
= route_map_master
.head
;
2744 map
->to_be_processed
= 0;
2745 route_map_delete(map
);
2748 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++) {
2749 hash_free(route_map_dep_hash
[i
]);
2750 route_map_dep_hash
[i
] = NULL
;
2753 hash_free(route_map_master_hash
);
2754 route_map_master_hash
= NULL
;
2757 static void rmap_autocomplete(vector comps
, struct cmd_token
*token
)
2759 struct route_map
*map
;
2761 for (map
= route_map_master
.head
; map
; map
= map
->next
)
2762 vector_set(comps
, XSTRDUP(MTYPE_COMPLETION
, map
->name
));
2765 static const struct cmd_variable_handler rmap_var_handlers
[] = {
2766 {/* "route-map WORD" */
2767 .varname
= "route_map",
2768 .completions
= rmap_autocomplete
},
2769 {.tokenname
= "ROUTEMAP_NAME", .completions
= rmap_autocomplete
},
2770 {.tokenname
= "RMAP_NAME", .completions
= rmap_autocomplete
},
2771 {.completions
= NULL
}};
2773 /* Initialization of route map vector. */
2774 void route_map_init(void)
2778 /* Make vector for match and set. */
2779 route_match_vec
= vector_init(1);
2780 route_set_vec
= vector_init(1);
2781 route_map_master_hash
=
2782 hash_create(route_map_hash_key_make
, route_map_hash_cmp
, NULL
);
2784 for (i
= 1; i
< ROUTE_MAP_DEP_MAX
; i
++)
2785 route_map_dep_hash
[i
] =
2786 hash_create(route_map_dep_hash_make_key
,
2787 route_map_dep_hash_cmp
, NULL
);
2789 cmd_variable_handler_register(rmap_var_handlers
);
2791 /* Install route map top node. */
2792 install_node(&rmap_node
, route_map_config_write
);
2794 /* Install route map commands. */
2795 install_default(RMAP_NODE
);
2796 install_element(CONFIG_NODE
, &route_map_cmd
);
2797 install_element(CONFIG_NODE
, &no_route_map_cmd
);
2798 install_element(CONFIG_NODE
, &no_route_map_all_cmd
);
2800 /* Install the on-match stuff */
2801 install_element(RMAP_NODE
, &route_map_cmd
);
2802 install_element(RMAP_NODE
, &rmap_onmatch_next_cmd
);
2803 install_element(RMAP_NODE
, &no_rmap_onmatch_next_cmd
);
2804 install_element(RMAP_NODE
, &rmap_onmatch_goto_cmd
);
2805 install_element(RMAP_NODE
, &no_rmap_onmatch_goto_cmd
);
2806 install_element(RMAP_NODE
, &rmap_continue_cmd
);
2807 install_element(RMAP_NODE
, &no_rmap_continue_cmd
);
2809 /* Install the continue stuff (ALIAS of on-match). */
2811 /* Install the call stuff. */
2812 install_element(RMAP_NODE
, &rmap_call_cmd
);
2813 install_element(RMAP_NODE
, &no_rmap_call_cmd
);
2815 /* Install description commands. */
2816 install_element(RMAP_NODE
, &rmap_description_cmd
);
2817 install_element(RMAP_NODE
, &no_rmap_description_cmd
);
2819 /* Install show command */
2820 install_element(ENABLE_NODE
, &rmap_show_name_cmd
);
2822 install_element(RMAP_NODE
, &match_interface_cmd
);
2823 install_element(RMAP_NODE
, &no_match_interface_cmd
);
2825 install_element(RMAP_NODE
, &match_ip_address_cmd
);
2826 install_element(RMAP_NODE
, &no_match_ip_address_cmd
);
2828 install_element(RMAP_NODE
, &match_ip_address_prefix_list_cmd
);
2829 install_element(RMAP_NODE
, &no_match_ip_address_prefix_list_cmd
);
2831 install_element(RMAP_NODE
, &match_ip_next_hop_cmd
);
2832 install_element(RMAP_NODE
, &no_match_ip_next_hop_cmd
);
2834 install_element(RMAP_NODE
, &match_ip_next_hop_prefix_list_cmd
);
2835 install_element(RMAP_NODE
, &no_match_ip_next_hop_prefix_list_cmd
);
2837 install_element(RMAP_NODE
, &match_ipv6_address_cmd
);
2838 install_element(RMAP_NODE
, &no_match_ipv6_address_cmd
);
2840 install_element(RMAP_NODE
, &match_ipv6_address_prefix_list_cmd
);
2841 install_element(RMAP_NODE
, &no_match_ipv6_address_prefix_list_cmd
);
2843 install_element(RMAP_NODE
, &match_metric_cmd
);
2844 install_element(RMAP_NODE
, &no_match_metric_cmd
);
2846 install_element(RMAP_NODE
, &match_tag_cmd
);
2847 install_element(RMAP_NODE
, &no_match_tag_cmd
);
2849 install_element(RMAP_NODE
, &set_ip_nexthop_cmd
);
2850 install_element(RMAP_NODE
, &no_set_ip_nexthop_cmd
);
2852 install_element(RMAP_NODE
, &set_ipv6_nexthop_local_cmd
);
2853 install_element(RMAP_NODE
, &no_set_ipv6_nexthop_local_cmd
);
2855 install_element(RMAP_NODE
, &set_metric_cmd
);
2856 install_element(RMAP_NODE
, &no_set_metric_cmd
);
2858 install_element(RMAP_NODE
, &set_tag_cmd
);
2859 install_element(RMAP_NODE
, &no_set_tag_cmd
);