]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_routemap.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' into Netlink-Prefix-Len-Check
[mirror_frr.git] / zebra / zebra_routemap.c
1 /* zebra routemap.
2 * Copyright (C) 2006 IBM Corporation
3 *
4 * This file is part of GNU Zebra.
5 *
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
9 * later version.
10 *
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.
15 *
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
19 */
20
21 #include <zebra.h>
22
23 #include "memory.h"
24 #include "zebra_memory.h"
25 #include "prefix.h"
26 #include "rib.h"
27 #include "vty.h"
28 #include "routemap.h"
29 #include "command.h"
30 #include "filter.h"
31 #include "plist.h"
32 #include "nexthop.h"
33 #include "vrf.h"
34 #include "frrstr.h"
35
36 #include "zebra/zserv.h"
37 #include "zebra/redistribute.h"
38 #include "zebra/debug.h"
39 #include "zebra/zebra_rnh.h"
40 #include "zebra/zebra_routemap.h"
41
42 static uint32_t zebra_rmap_update_timer = ZEBRA_RMAP_DEFAULT_UPDATE_TIMER;
43 static struct thread *zebra_t_rmap_update = NULL;
44 char *proto_rm[AFI_MAX][ZEBRA_ROUTE_MAX + 1]; /* "any" == ZEBRA_ROUTE_MAX */
45 /* NH Tracking route map */
46 char *nht_rm[AFI_MAX][ZEBRA_ROUTE_MAX + 1]; /* "any" == ZEBRA_ROUTE_MAX */
47 char *zebra_import_table_routemap[AFI_MAX][ZEBRA_KERNEL_TABLE_MAX];
48
49 struct nh_rmap_obj {
50 struct nexthop *nexthop;
51 vrf_id_t vrf_id;
52 uint32_t source_protocol;
53 uint8_t instance;
54 int metric;
55 route_tag_t tag;
56 };
57
58 static void zebra_route_map_set_delay_timer(uint32_t value);
59
60
61 /* Add zebra route map rule */
62 static int zebra_route_match_add(struct vty *vty, const char *command,
63 const char *arg, route_map_event_t type)
64 {
65 VTY_DECLVAR_CONTEXT(route_map_index, index);
66 int ret;
67 int retval = CMD_SUCCESS;
68
69 ret = route_map_add_match(index, command, arg);
70 switch (ret) {
71 case RMAP_RULE_MISSING:
72 vty_out(vty, "%% Zebra Can't find rule.\n");
73 retval = CMD_WARNING_CONFIG_FAILED;
74 break;
75 case RMAP_COMPILE_ERROR:
76 vty_out(vty, "%% Zebra Argument is malformed.\n");
77 retval = CMD_WARNING_CONFIG_FAILED;
78 break;
79 case RMAP_COMPILE_SUCCESS:
80 if (type != RMAP_EVENT_MATCH_ADDED) {
81 route_map_upd8_dependency(type, arg, index->map->name);
82 }
83 break;
84 }
85
86 return retval;
87 }
88
89 /* Delete zebra route map rule. */
90 static int zebra_route_match_delete(struct vty *vty, const char *command,
91 const char *arg, route_map_event_t type)
92 {
93 VTY_DECLVAR_CONTEXT(route_map_index, index);
94 int ret;
95 int retval = CMD_SUCCESS;
96 char *dep_name = NULL;
97 const char *tmpstr;
98 char *rmap_name = NULL;
99
100 if (type != RMAP_EVENT_MATCH_DELETED) {
101 /* ignore the mundane, the types without any dependency */
102 if (arg == NULL) {
103 if ((tmpstr = route_map_get_match_arg(index, command))
104 != NULL)
105 dep_name =
106 XSTRDUP(MTYPE_ROUTE_MAP_RULE, tmpstr);
107 } else {
108 dep_name = XSTRDUP(MTYPE_ROUTE_MAP_RULE, arg);
109 }
110 rmap_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, index->map->name);
111 }
112
113 ret = route_map_delete_match(index, command, arg);
114 switch (ret) {
115 case RMAP_RULE_MISSING:
116 vty_out(vty, "%% Zebra Can't find rule.\n");
117 retval = CMD_WARNING_CONFIG_FAILED;
118 break;
119 case RMAP_COMPILE_ERROR:
120 vty_out(vty, "%% Zebra Argument is malformed.\n");
121 retval = CMD_WARNING_CONFIG_FAILED;
122 break;
123 case RMAP_COMPILE_SUCCESS:
124 if (type != RMAP_EVENT_MATCH_DELETED && dep_name)
125 route_map_upd8_dependency(type, dep_name, rmap_name);
126 break;
127 }
128
129 if (dep_name)
130 XFREE(MTYPE_ROUTE_MAP_RULE, dep_name);
131 if (rmap_name)
132 XFREE(MTYPE_ROUTE_MAP_NAME, rmap_name);
133
134 return retval;
135 }
136
137 /* 'match tag TAG'
138 * Match function return 1 if match is success else return 0
139 */
140 static route_map_result_t route_match_tag(void *rule,
141 const struct prefix *prefix,
142 route_map_object_t type, void *object)
143 {
144 route_tag_t *tag;
145 struct nh_rmap_obj *nh_data;
146
147 if (type == RMAP_ZEBRA) {
148 tag = rule;
149 nh_data = object;
150
151 if (nh_data->tag == *tag)
152 return RMAP_MATCH;
153 }
154 return RMAP_NOMATCH;
155 }
156
157 /* Route map commands for tag matching */
158 static struct route_map_rule_cmd route_match_tag_cmd = {
159 "tag", route_match_tag, route_map_rule_tag_compile,
160 route_map_rule_tag_free,
161 };
162
163
164 /* `match interface IFNAME' */
165 /* Match function return 1 if match is success else return zero. */
166 static route_map_result_t route_match_interface(void *rule,
167 const struct prefix *prefix,
168 route_map_object_t type,
169 void *object)
170 {
171 struct nh_rmap_obj *nh_data;
172 char *ifname = rule;
173 ifindex_t ifindex;
174
175 if (type == RMAP_ZEBRA) {
176 if (strcasecmp(ifname, "any") == 0)
177 return RMAP_MATCH;
178 nh_data = object;
179 if (!nh_data || !nh_data->nexthop)
180 return RMAP_NOMATCH;
181 ifindex = ifname2ifindex(ifname, nh_data->vrf_id);
182 if (ifindex == 0)
183 return RMAP_NOMATCH;
184 if (nh_data->nexthop->ifindex == ifindex)
185 return RMAP_MATCH;
186 }
187 return RMAP_NOMATCH;
188 }
189
190 /* Route map `match interface' match statement. `arg' is IFNAME value */
191 static void *route_match_interface_compile(const char *arg)
192 {
193 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
194 }
195
196 /* Free route map's compiled `match interface' value. */
197 static void route_match_interface_free(void *rule)
198 {
199 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
200 }
201
202 /* Route map commands for interface matching */
203 struct route_map_rule_cmd route_match_interface_cmd = {
204 "interface", route_match_interface, route_match_interface_compile,
205 route_match_interface_free};
206
207 DEFUN (match_ip_address_prefix_len,
208 match_ip_address_prefix_len_cmd,
209 "match ip address prefix-len (0-32)",
210 MATCH_STR
211 IP_STR
212 "Match prefix length of ip address\n"
213 "Match prefix length of ip address\n"
214 "Prefix length\n")
215 {
216 return zebra_route_match_add(vty, "ip address prefix-len", argv[4]->arg,
217 RMAP_EVENT_MATCH_ADDED);
218 }
219
220 DEFUN (no_match_ip_address_prefix_len,
221 no_match_ip_address_prefix_len_cmd,
222 "no match ip address prefix-len [(0-32)]",
223 NO_STR
224 MATCH_STR
225 IP_STR
226 "Match prefix length of ip address\n"
227 "Match prefix length of ip address\n"
228 "Prefix length\n")
229 {
230 char *plen = (argc == 6) ? argv[5]->arg : NULL;
231 return zebra_route_match_delete(vty, "ip address prefix-len", plen,
232 RMAP_EVENT_MATCH_DELETED);
233 }
234
235 DEFUN (match_ipv6_address_prefix_len,
236 match_ipv6_address_prefix_len_cmd,
237 "match ipv6 address prefix-len (0-128)",
238 MATCH_STR
239 IPV6_STR
240 "Match prefix length of ipv6 address\n"
241 "Match prefix length of ipv6 address\n"
242 "Prefix length\n")
243 {
244 return zebra_route_match_add(vty, "ipv6 address prefix-len",
245 argv[4]->arg, RMAP_EVENT_MATCH_ADDED);
246 }
247
248 DEFUN (no_match_ipv6_address_prefix_len,
249 no_match_ipv6_address_prefix_len_cmd,
250 "no match ipv6 address prefix-len [(0-128)]",
251 NO_STR
252 MATCH_STR
253 IPV6_STR
254 "Match prefix length of ip address\n"
255 "Match prefix length of ip address\n"
256 "Prefix length\n")
257 {
258 char *plen = (argc == 6) ? argv[5]->arg : NULL;
259 return zebra_route_match_delete(vty, "ipv6 address prefix-len", plen,
260 RMAP_EVENT_MATCH_DELETED);
261 }
262
263 DEFUN (match_ip_nexthop_prefix_len,
264 match_ip_nexthop_prefix_len_cmd,
265 "match ip next-hop prefix-len (0-32)",
266 MATCH_STR
267 IP_STR
268 "Match prefixlen of nexthop ip address\n"
269 "Match prefixlen of given nexthop\n"
270 "Prefix length\n")
271 {
272 return zebra_route_match_add(vty, "ip next-hop prefix-len",
273 argv[4]->arg, RMAP_EVENT_MATCH_ADDED);
274 }
275
276 DEFUN (no_match_ip_nexthop_prefix_len,
277 no_match_ip_nexthop_prefix_len_cmd,
278 "no match ip next-hop prefix-len [(0-32)]",
279 NO_STR
280 MATCH_STR
281 IP_STR
282 "Match prefixlen of nexthop ip address\n"
283 "Match prefix length of nexthop\n"
284 "Prefix length\n")
285 {
286 char *plen = (argc == 6) ? argv[5]->arg : NULL;
287 return zebra_route_match_delete(vty, "ip next-hop prefix-len", plen,
288 RMAP_EVENT_MATCH_DELETED);
289 }
290
291 DEFUN (match_source_protocol,
292 match_source_protocol_cmd,
293 "match source-protocol <bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>",
294 MATCH_STR
295 "Match protocol via which the route was learnt\n"
296 "BGP protocol\n"
297 "OSPF protocol\n"
298 "RIP protocol\n"
299 "RIPNG protocol\n"
300 "ISIS protocol\n"
301 "OSPF6 protocol\n"
302 "PIM protocol\n"
303 "NHRP protocol\n"
304 "EIGRP protocol\n"
305 "BABEL protocol\n"
306 "Routes from directly connected peer\n"
307 "Routes from system configuration\n"
308 "Routes from kernel\n"
309 "Statically configured routes\n"
310 "SHARP process\n")
311 {
312 char *proto = argv[2]->text;
313 int i;
314
315 i = proto_name2num(proto);
316 if (i < 0) {
317 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
318 return CMD_WARNING_CONFIG_FAILED;
319 }
320 return zebra_route_match_add(vty, "source-protocol", proto,
321 RMAP_EVENT_MATCH_ADDED);
322 }
323
324 DEFUN (no_match_source_protocol,
325 no_match_source_protocol_cmd,
326 "no match source-protocol [<bgp|ospf|rip|ripng|isis|ospf6|pim|nhrp|eigrp|babel|connected|system|kernel|static|sharp>]",
327 NO_STR
328 MATCH_STR
329 "No match protocol via which the route was learnt\n"
330 "BGP protocol\n"
331 "OSPF protocol\n"
332 "RIP protocol\n"
333 "RIPNG protocol\n"
334 "ISIS protocol\n"
335 "OSPF6 protocol\n"
336 "PIM protocol\n"
337 "NHRP protocol\n"
338 "EIGRP protocol\n"
339 "BABEL protocol\n"
340 "Routes from directly connected peer\n"
341 "Routes from system configuration\n"
342 "Routes from kernel\n"
343 "Statically configured routes\n"
344 "SHARP process\n")
345 {
346 char *proto = (argc == 4) ? argv[3]->text : NULL;
347 return zebra_route_match_delete(vty, "source-protocol", proto,
348 RMAP_EVENT_MATCH_DELETED);
349 }
350
351 DEFUN (match_source_instance,
352 match_source_instance_cmd,
353 "match source-instance (0-255)",
354 MATCH_STR
355 "Match the protocol's instance number\n"
356 "The instance number\n")
357 {
358 char *instance = argv[2]->arg;
359
360 return zebra_route_match_add(vty, "source-instance", instance,
361 RMAP_EVENT_MATCH_ADDED);
362 }
363
364 DEFUN (no_match_source_instance,
365 no_match_source_instance_cmd,
366 "no match source-instance [(0-255)]",
367 NO_STR MATCH_STR
368 "Match the protocol's instance number\n"
369 "The instance number\n")
370 {
371 char *instance = (argc == 4) ? argv[3]->arg : NULL;
372
373 return zebra_route_match_delete(vty, "source-instance", instance,
374 RMAP_EVENT_MATCH_ADDED);
375 }
376
377 /* set functions */
378
379 DEFUN (set_src,
380 set_src_cmd,
381 "set src <A.B.C.D|X:X::X:X>",
382 SET_STR
383 "src address for route\n"
384 "IPv4 src address\n"
385 "IPv6 src address\n")
386 {
387 int idx_ip = 2;
388 union g_addr src;
389 struct interface *pif = NULL;
390 int family;
391 struct prefix p;
392 struct vrf *vrf;
393
394 if (inet_pton(AF_INET, argv[idx_ip]->arg, &src.ipv4) != 1) {
395 if (inet_pton(AF_INET6, argv[idx_ip]->arg, &src.ipv6) != 1) {
396 vty_out(vty, "%% not a valid IPv4/v6 address\n");
397 return CMD_WARNING_CONFIG_FAILED;
398 }
399
400 p.family = family = AF_INET6;
401 p.u.prefix6 = src.ipv6;
402 p.prefixlen = IPV6_MAX_BITLEN;
403 } else {
404 p.family = family = AF_INET;
405 p.u.prefix4 = src.ipv4;
406 p.prefixlen = IPV4_MAX_BITLEN;
407 }
408
409 if (!zebra_check_addr(&p)) {
410 vty_out(vty, "%% not a valid source IPv4/v6 address\n");
411 return CMD_WARNING_CONFIG_FAILED;
412 }
413
414 RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
415 if (family == AF_INET)
416 pif = if_lookup_exact_address((void *)&src.ipv4,
417 AF_INET, vrf->vrf_id);
418 else if (family == AF_INET6)
419 pif = if_lookup_exact_address((void *)&src.ipv6,
420 AF_INET6, vrf->vrf_id);
421
422 if (pif != NULL)
423 break;
424 }
425
426 if (!pif) {
427 vty_out(vty, "%% not a local address\n");
428 return CMD_WARNING_CONFIG_FAILED;
429 }
430
431 VTY_DECLVAR_CONTEXT(route_map_index, index);
432 return generic_set_add(vty, index, "src", argv[idx_ip]->arg);
433 }
434
435 DEFUN (no_set_src,
436 no_set_src_cmd,
437 "no set src [<A.B.C.D|X:X::X:X>]",
438 NO_STR
439 SET_STR
440 "Source address for route\n"
441 "IPv4 address\n"
442 "IPv6 address\n")
443 {
444 char *ip = (argc == 4) ? argv[3]->arg : NULL;
445 VTY_DECLVAR_CONTEXT(route_map_index, index);
446 return generic_set_delete(vty, index, "src", ip);
447 }
448
449 DEFUN (zebra_route_map_timer,
450 zebra_route_map_timer_cmd,
451 "zebra route-map delay-timer (0-600)",
452 ZEBRA_STR
453 "Set route-map parameters\n"
454 "Time to wait before route-map updates are processed\n"
455 "0 means event-driven updates are disabled\n")
456 {
457 int idx_number = 3;
458 uint32_t rmap_delay_timer;
459
460 rmap_delay_timer = strtoul(argv[idx_number]->arg, NULL, 10);
461 zebra_route_map_set_delay_timer(rmap_delay_timer);
462
463 return (CMD_SUCCESS);
464 }
465
466 DEFUN (no_zebra_route_map_timer,
467 no_zebra_route_map_timer_cmd,
468 "no zebra route-map delay-timer [(0-600)]",
469 NO_STR
470 ZEBRA_STR
471 "Set route-map parameters\n"
472 "Reset delay-timer to default value, 30 secs\n"
473 "0 means event-driven updates are disabled\n")
474 {
475 zebra_route_map_set_delay_timer(ZEBRA_RMAP_DEFAULT_UPDATE_TIMER);
476
477 return (CMD_SUCCESS);
478 }
479
480
481 DEFUN (ip_protocol,
482 ip_protocol_cmd,
483 "ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA " route-map ROUTE-MAP",
484 IP_STR
485 "Filter routing info exchanged between zebra and protocol\n"
486 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
487 "Specify route-map\n"
488 "Route map name\n")
489 {
490 char *proto = argv[2]->text;
491 char *rmap = argv[4]->arg;
492 int i;
493
494 if (strcasecmp(proto, "any") == 0)
495 i = ZEBRA_ROUTE_MAX;
496 else
497 i = proto_name2num(proto);
498 if (i < 0) {
499 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
500 return CMD_WARNING_CONFIG_FAILED;
501 }
502 if (proto_rm[AFI_IP][i]) {
503 if (strcmp(proto_rm[AFI_IP][i], rmap) == 0)
504 return CMD_SUCCESS;
505
506 XFREE(MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
507 }
508 proto_rm[AFI_IP][i] = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
509
510 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
511 zlog_debug(
512 "%u: IPv4 Routemap config for protocol %s, scheduling RIB processing",
513 VRF_DEFAULT, proto);
514
515 rib_update(VRF_DEFAULT, RIB_UPDATE_RMAP_CHANGE);
516 return CMD_SUCCESS;
517 }
518
519 DEFUN (no_ip_protocol,
520 no_ip_protocol_cmd,
521 "no ip protocol " FRR_IP_PROTOCOL_MAP_STR_ZEBRA " [route-map ROUTE-MAP]",
522 NO_STR
523 IP_STR
524 "Stop filtering routing info between zebra and protocol\n"
525 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
526 "Specify route map\n"
527 "Route map name\n")
528 {
529 char *proto = argv[3]->text;
530 char *rmap = (argc == 6) ? argv[5]->arg : NULL;
531 int i;
532
533 if (strcasecmp(proto, "any") == 0)
534 i = ZEBRA_ROUTE_MAX;
535 else
536 i = proto_name2num(proto);
537
538 if (i < 0) {
539 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
540 return CMD_WARNING_CONFIG_FAILED;
541 }
542
543 if (!proto_rm[AFI_IP][i])
544 return CMD_SUCCESS;
545
546 if (!rmap || strcmp(rmap, proto_rm[AFI_IP][i]) == 0) {
547 XFREE(MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP][i]);
548 proto_rm[AFI_IP][i] = NULL;
549
550 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
551 zlog_debug(
552 "%u: IPv4 Routemap unconfig for protocol %s, scheduling RIB processing",
553 VRF_DEFAULT, proto);
554 rib_update(VRF_DEFAULT, RIB_UPDATE_RMAP_CHANGE);
555 }
556 return CMD_SUCCESS;
557 }
558
559 DEFUN (show_ip_protocol,
560 show_ip_protocol_cmd,
561 "show ip protocol",
562 SHOW_STR
563 IP_STR
564 "IP protocol filtering status\n")
565 {
566 int i;
567
568 vty_out(vty, "Protocol : route-map \n");
569 vty_out(vty, "------------------------\n");
570 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
571 if (proto_rm[AFI_IP][i])
572 vty_out(vty, "%-10s : %-10s\n", zebra_route_string(i),
573 proto_rm[AFI_IP][i]);
574 else
575 vty_out(vty, "%-10s : none\n", zebra_route_string(i));
576 }
577 if (proto_rm[AFI_IP][i])
578 vty_out(vty, "%-10s : %-10s\n", "any", proto_rm[AFI_IP][i]);
579 else
580 vty_out(vty, "%-10s : none\n", "any");
581
582 return CMD_SUCCESS;
583 }
584
585 DEFUN (ipv6_protocol,
586 ipv6_protocol_cmd,
587 "ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA " route-map ROUTE-MAP",
588 IP6_STR
589 "Filter IPv6 routing info exchanged between zebra and protocol\n"
590 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
591 "Specify route map\n"
592 "Route map name\n")
593 {
594 char *proto = argv[2]->text;
595 char *rmap = argv[4]->arg;
596 int i;
597
598 if (strcasecmp(proto, "any") == 0)
599 i = ZEBRA_ROUTE_MAX;
600 else
601 i = proto_name2num(proto);
602 if (i < 0) {
603 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
604 return CMD_WARNING_CONFIG_FAILED;
605 }
606 if (proto_rm[AFI_IP6][i]) {
607 if (strcmp(proto_rm[AFI_IP6][i], rmap) == 0)
608 return CMD_SUCCESS;
609
610 XFREE(MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP6][i]);
611 }
612 proto_rm[AFI_IP6][i] = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
613
614 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
615 zlog_debug(
616 "%u: IPv6 Routemap config for protocol %s, scheduling RIB processing",
617 VRF_DEFAULT, proto);
618
619 rib_update(VRF_DEFAULT, RIB_UPDATE_RMAP_CHANGE);
620 return CMD_SUCCESS;
621 }
622
623 DEFUN (no_ipv6_protocol,
624 no_ipv6_protocol_cmd,
625 "no ipv6 protocol " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA " [route-map ROUTE-MAP]",
626 NO_STR
627 IP6_STR
628 "Stop filtering IPv6 routing info between zebra and protocol\n"
629 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
630 "Specify route map\n"
631 "Route map name\n")
632 {
633 const char *proto = argv[3]->text;
634 const char *rmap = (argc == 6) ? argv[5]->arg : NULL;
635 int i;
636
637 if (strcasecmp(proto, "any") == 0)
638 i = ZEBRA_ROUTE_MAX;
639 else
640 i = proto_name2num(proto);
641 if (i < 0) {
642 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
643 return CMD_WARNING_CONFIG_FAILED;
644 }
645 if (!proto_rm[AFI_IP6][i])
646 return CMD_SUCCESS;
647
648 if (!rmap || strcmp(rmap, proto_rm[AFI_IP6][i]) == 0) {
649 XFREE(MTYPE_ROUTE_MAP_NAME, proto_rm[AFI_IP6][i]);
650 proto_rm[AFI_IP6][i] = NULL;
651
652 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
653 zlog_debug(
654 "%u: IPv6 Routemap unconfig for protocol %s, scheduling RIB processing",
655 VRF_DEFAULT, proto);
656
657 rib_update(VRF_DEFAULT, RIB_UPDATE_RMAP_CHANGE);
658 }
659 return CMD_SUCCESS;
660 }
661
662 DEFUN (show_ipv6_protocol,
663 show_ipv6_protocol_cmd,
664 "show ipv6 protocol",
665 SHOW_STR
666 IP6_STR
667 "IPv6 protocol filtering status\n")
668 {
669 int i;
670
671 vty_out(vty, "Protocol : route-map \n");
672 vty_out(vty, "------------------------\n");
673 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
674 if (proto_rm[AFI_IP6][i])
675 vty_out(vty, "%-10s : %-10s\n", zebra_route_string(i),
676 proto_rm[AFI_IP6][i]);
677 else
678 vty_out(vty, "%-10s : none\n", zebra_route_string(i));
679 }
680 if (proto_rm[AFI_IP6][i])
681 vty_out(vty, "%-10s : %-10s\n", "any", proto_rm[AFI_IP6][i]);
682 else
683 vty_out(vty, "%-10s : none\n", "any");
684
685 return CMD_SUCCESS;
686 }
687
688 DEFUN (ip_protocol_nht_rmap,
689 ip_protocol_nht_rmap_cmd,
690 "ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA " route-map ROUTE-MAP",
691 IP_STR
692 "Filter Next Hop tracking route resolution\n"
693 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
694 "Specify route map\n"
695 "Route map name\n")
696 {
697 char *proto = argv[2]->text;
698 char *rmap = argv[4]->arg;
699 int i;
700
701 if (strcasecmp(proto, "any") == 0)
702 i = ZEBRA_ROUTE_MAX;
703 else
704 i = proto_name2num(proto);
705 if (i < 0) {
706 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
707 return CMD_WARNING_CONFIG_FAILED;
708 }
709 if (nht_rm[AFI_IP][i]) {
710 if (strcmp(nht_rm[AFI_IP][i], rmap) == 0)
711 return CMD_SUCCESS;
712
713 XFREE(MTYPE_ROUTE_MAP_NAME, nht_rm[AFI_IP][i]);
714 }
715
716 nht_rm[AFI_IP][i] = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
717 zebra_evaluate_rnh(0, AF_INET, 1, RNH_NEXTHOP_TYPE, NULL);
718
719 return CMD_SUCCESS;
720 }
721
722 DEFUN (no_ip_protocol_nht_rmap,
723 no_ip_protocol_nht_rmap_cmd,
724 "no ip nht " FRR_IP_PROTOCOL_MAP_STR_ZEBRA " [route-map ROUTE-MAP]",
725 NO_STR
726 IP_STR
727 "Filter Next Hop tracking route resolution\n"
728 FRR_IP_PROTOCOL_MAP_HELP_STR_ZEBRA
729 "Specify route map\n"
730 "Route map name\n")
731 {
732 int idx = 0;
733 char *proto = argv[3]->text;
734 char *rmap = argv_find(argv, argc, "ROUTE-MAP", &idx) ? argv[idx]->arg
735 : NULL;
736
737 int i = strmatch(proto, "any") ? ZEBRA_ROUTE_MAX
738 : proto_name2num(proto);
739
740 if (i < 0) {
741 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
742 return CMD_WARNING_CONFIG_FAILED;
743 }
744
745 if (!nht_rm[AFI_IP][i])
746 return CMD_SUCCESS;
747
748 if (!rmap || strcmp(rmap, nht_rm[AFI_IP][i]) == 0) {
749 XFREE(MTYPE_ROUTE_MAP_NAME, nht_rm[AFI_IP][i]);
750 nht_rm[AFI_IP][i] = NULL;
751 zebra_evaluate_rnh(0, AF_INET, 1, RNH_NEXTHOP_TYPE, NULL);
752 }
753 return CMD_SUCCESS;
754 }
755
756 DEFUN (show_ip_protocol_nht,
757 show_ip_protocol_nht_cmd,
758 "show ip nht route-map",
759 SHOW_STR
760 IP_STR
761 "IP nexthop tracking table\n"
762 "IP Next Hop tracking filtering status\n")
763 {
764 int i;
765
766 vty_out(vty, "Protocol : route-map \n");
767 vty_out(vty, "------------------------\n");
768 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
769 if (nht_rm[AFI_IP][i])
770 vty_out(vty, "%-10s : %-10s\n", zebra_route_string(i),
771 nht_rm[AFI_IP][i]);
772 else
773 vty_out(vty, "%-10s : none\n", zebra_route_string(i));
774 }
775 if (nht_rm[AFI_IP][i])
776 vty_out(vty, "%-10s : %-10s\n", "any", nht_rm[AFI_IP][i]);
777 else
778 vty_out(vty, "%-10s : none\n", "any");
779
780 return CMD_SUCCESS;
781 }
782
783 DEFUN (ipv6_protocol_nht_rmap,
784 ipv6_protocol_nht_rmap_cmd,
785 "ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA " route-map ROUTE-MAP",
786 IP6_STR
787 "Filter Next Hop tracking route resolution\n"
788 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
789 "Specify route map\n"
790 "Route map name\n")
791 {
792 char *proto = argv[2]->text;
793 char *rmap = argv[4]->arg;
794 int i;
795
796 if (strcasecmp(proto, "any") == 0)
797 i = ZEBRA_ROUTE_MAX;
798 else
799 i = proto_name2num(proto);
800 if (i < 0) {
801 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
802 return CMD_WARNING_CONFIG_FAILED;
803 }
804 if (nht_rm[AFI_IP6][i])
805 XFREE(MTYPE_ROUTE_MAP_NAME, nht_rm[AFI_IP6][i]);
806 nht_rm[AFI_IP6][i] = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
807 zebra_evaluate_rnh(0, AF_INET6, 1, RNH_NEXTHOP_TYPE, NULL);
808
809 return CMD_SUCCESS;
810 }
811
812 DEFUN (no_ipv6_protocol_nht_rmap,
813 no_ipv6_protocol_nht_rmap_cmd,
814 "no ipv6 nht " FRR_IP6_PROTOCOL_MAP_STR_ZEBRA " [route-map ROUTE-MAP]",
815 NO_STR
816 IP6_STR
817 "Filter Next Hop tracking route resolution\n"
818 FRR_IP6_PROTOCOL_MAP_HELP_STR_ZEBRA
819 "Specify route map\n"
820 "Route map name\n")
821 {
822 char *proto = argv[3]->text;
823 char *rmap = (argc == 6) ? argv[5]->arg : NULL;
824 int i;
825
826 if (strcasecmp(proto, "any") == 0)
827 i = ZEBRA_ROUTE_MAX;
828 else
829 i = proto_name2num(proto);
830 if (i < 0) {
831 vty_out(vty, "invalid protocol name \"%s\"\n", proto);
832 return CMD_WARNING_CONFIG_FAILED;
833 }
834
835 if (nht_rm[AFI_IP6][i] && rmap && strcmp(rmap, nht_rm[AFI_IP6][i])) {
836 vty_out(vty, "invalid route-map \"%s\"\n", rmap);
837 return CMD_WARNING_CONFIG_FAILED;
838 }
839
840 if (nht_rm[AFI_IP6][i]) {
841 XFREE(MTYPE_ROUTE_MAP_NAME, nht_rm[AFI_IP6][i]);
842 nht_rm[AFI_IP6][i] = NULL;
843 }
844
845 zebra_evaluate_rnh(0, AF_INET6, 1, RNH_NEXTHOP_TYPE, NULL);
846
847 return CMD_SUCCESS;
848 }
849
850 DEFUN (show_ipv6_protocol_nht,
851 show_ipv6_protocol_nht_cmd,
852 "show ipv6 nht route-map",
853 SHOW_STR
854 IP6_STR
855 "Next Hop filtering status\n"
856 "Route-map\n")
857 {
858 int i;
859
860 vty_out(vty, "Protocol : route-map \n");
861 vty_out(vty, "------------------------\n");
862 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
863 if (nht_rm[AFI_IP6][i])
864 vty_out(vty, "%-10s : %-10s\n", zebra_route_string(i),
865 nht_rm[AFI_IP6][i]);
866 else
867 vty_out(vty, "%-10s : none\n", zebra_route_string(i));
868 }
869 if (nht_rm[AFI_IP][i])
870 vty_out(vty, "%-10s : %-10s\n", "any", nht_rm[AFI_IP6][i]);
871 else
872 vty_out(vty, "%-10s : none\n", "any");
873
874 return CMD_SUCCESS;
875 }
876
877 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
878
879 /* `match ip next-hop IP_ACCESS_LIST' */
880
881 /* Match function return 1 if match is success else return zero. */
882 static route_map_result_t route_match_ip_next_hop(void *rule,
883 const struct prefix *prefix,
884 route_map_object_t type,
885 void *object)
886 {
887 struct access_list *alist;
888 struct nh_rmap_obj *nh_data;
889 struct prefix_ipv4 p;
890
891 if (type == RMAP_ZEBRA) {
892 nh_data = object;
893 if (!nh_data)
894 return RMAP_DENYMATCH;
895
896 switch (nh_data->nexthop->type) {
897 case NEXTHOP_TYPE_IFINDEX:
898 /* Interface routes can't match ip next-hop */
899 return RMAP_NOMATCH;
900 case NEXTHOP_TYPE_IPV4_IFINDEX:
901 case NEXTHOP_TYPE_IPV4:
902 p.family = AF_INET;
903 p.prefix = nh_data->nexthop->gate.ipv4;
904 p.prefixlen = IPV4_MAX_BITLEN;
905 break;
906 default:
907 return RMAP_NOMATCH;
908 }
909 alist = access_list_lookup(AFI_IP, (char *)rule);
910 if (alist == NULL)
911 return RMAP_NOMATCH;
912
913 return (access_list_apply(alist, &p) == FILTER_DENY
914 ? RMAP_NOMATCH
915 : RMAP_MATCH);
916 }
917 return RMAP_NOMATCH;
918 }
919
920 /* Route map `ip next-hop' match statement. `arg' should be
921 access-list name. */
922 static void *route_match_ip_next_hop_compile(const char *arg)
923 {
924 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
925 }
926
927 /* Free route map's compiled `. */
928 static void route_match_ip_next_hop_free(void *rule)
929 {
930 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
931 }
932
933 /* Route map commands for ip next-hop matching. */
934 static struct route_map_rule_cmd route_match_ip_next_hop_cmd = {
935 "ip next-hop", route_match_ip_next_hop, route_match_ip_next_hop_compile,
936 route_match_ip_next_hop_free};
937
938 /* `match ip next-hop prefix-list PREFIX_LIST' */
939
940 static route_map_result_t
941 route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
942 route_map_object_t type, void *object)
943 {
944 struct prefix_list *plist;
945 struct nh_rmap_obj *nh_data;
946 struct prefix_ipv4 p;
947
948 if (type == RMAP_ZEBRA) {
949 nh_data = (struct nh_rmap_obj *)object;
950 if (!nh_data)
951 return RMAP_DENYMATCH;
952
953 switch (nh_data->nexthop->type) {
954 case NEXTHOP_TYPE_IFINDEX:
955 /* Interface routes can't match ip next-hop */
956 return RMAP_NOMATCH;
957 case NEXTHOP_TYPE_IPV4_IFINDEX:
958 case NEXTHOP_TYPE_IPV4:
959 p.family = AF_INET;
960 p.prefix = nh_data->nexthop->gate.ipv4;
961 p.prefixlen = IPV4_MAX_BITLEN;
962 break;
963 default:
964 return RMAP_NOMATCH;
965 }
966 plist = prefix_list_lookup(AFI_IP, (char *)rule);
967 if (plist == NULL)
968 return RMAP_NOMATCH;
969
970 return (prefix_list_apply(plist, &p) == PREFIX_DENY
971 ? RMAP_NOMATCH
972 : RMAP_MATCH);
973 }
974 return RMAP_NOMATCH;
975 }
976
977 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
978 {
979 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
980 }
981
982 static void route_match_ip_next_hop_prefix_list_free(void *rule)
983 {
984 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
985 }
986
987 static struct route_map_rule_cmd route_match_ip_next_hop_prefix_list_cmd = {
988 "ip next-hop prefix-list", route_match_ip_next_hop_prefix_list,
989 route_match_ip_next_hop_prefix_list_compile,
990 route_match_ip_next_hop_prefix_list_free};
991
992 /* `match ip address IP_ACCESS_LIST' */
993
994 /* Match function should return 1 if match is success else return
995 zero. */
996 static route_map_result_t route_match_ip_address(void *rule,
997 const struct prefix *prefix,
998 route_map_object_t type,
999 void *object)
1000 {
1001 struct access_list *alist;
1002
1003 if (type == RMAP_ZEBRA) {
1004 alist = access_list_lookup(AFI_IP, (char *)rule);
1005 if (alist == NULL)
1006 return RMAP_NOMATCH;
1007
1008 return (access_list_apply(alist, prefix) == FILTER_DENY
1009 ? RMAP_NOMATCH
1010 : RMAP_MATCH);
1011 }
1012 return RMAP_NOMATCH;
1013 }
1014
1015 /* Route map `ip address' match statement. `arg' should be
1016 access-list name. */
1017 static void *route_match_ip_address_compile(const char *arg)
1018 {
1019 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1020 }
1021
1022 /* Free route map's compiled `ip address' value. */
1023 static void route_match_ip_address_free(void *rule)
1024 {
1025 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1026 }
1027
1028 /* Route map commands for ip address matching. */
1029 static struct route_map_rule_cmd route_match_ip_address_cmd = {
1030 "ip address", route_match_ip_address, route_match_ip_address_compile,
1031 route_match_ip_address_free};
1032
1033 /* `match ip address prefix-list PREFIX_LIST' */
1034
1035 static route_map_result_t
1036 route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
1037 route_map_object_t type, void *object)
1038 {
1039 struct prefix_list *plist;
1040
1041 if (type == RMAP_ZEBRA) {
1042 plist = prefix_list_lookup(AFI_IP, (char *)rule);
1043 if (plist == NULL)
1044 return RMAP_NOMATCH;
1045
1046 return (prefix_list_apply(plist, prefix) == PREFIX_DENY
1047 ? RMAP_NOMATCH
1048 : RMAP_MATCH);
1049 }
1050 return RMAP_NOMATCH;
1051 }
1052
1053 static void *route_match_ip_address_prefix_list_compile(const char *arg)
1054 {
1055 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1056 }
1057
1058 static void route_match_ip_address_prefix_list_free(void *rule)
1059 {
1060 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1061 }
1062
1063 static struct route_map_rule_cmd route_match_ip_address_prefix_list_cmd = {
1064 "ip address prefix-list", route_match_ip_address_prefix_list,
1065 route_match_ip_address_prefix_list_compile,
1066 route_match_ip_address_prefix_list_free};
1067
1068
1069 /* `match ip address prefix-len PREFIXLEN' */
1070
1071 static route_map_result_t
1072 route_match_address_prefix_len(void *rule, const struct prefix *prefix,
1073 route_map_object_t type, void *object)
1074 {
1075 uint32_t *prefixlen = (uint32_t *)rule;
1076
1077 if (type == RMAP_ZEBRA) {
1078 return ((prefix->prefixlen == *prefixlen) ? RMAP_MATCH
1079 : RMAP_NOMATCH);
1080 }
1081 return RMAP_NOMATCH;
1082 }
1083
1084 static void *route_match_address_prefix_len_compile(const char *arg)
1085 {
1086 uint32_t *prefix_len;
1087 char *endptr = NULL;
1088 unsigned long tmpval;
1089
1090 /* prefix len value shoud be integer. */
1091 if (!all_digit(arg))
1092 return NULL;
1093
1094 errno = 0;
1095 tmpval = strtoul(arg, &endptr, 10);
1096 if (*endptr != '\0' || errno || tmpval > UINT32_MAX)
1097 return NULL;
1098
1099 prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1100
1101 if (!prefix_len)
1102 return prefix_len;
1103
1104 *prefix_len = tmpval;
1105 return prefix_len;
1106 }
1107
1108 static void route_match_address_prefix_len_free(void *rule)
1109 {
1110 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1111 }
1112
1113 static struct route_map_rule_cmd route_match_ip_address_prefix_len_cmd = {
1114 "ip address prefix-len", route_match_address_prefix_len,
1115 route_match_address_prefix_len_compile,
1116 route_match_address_prefix_len_free};
1117
1118 static struct route_map_rule_cmd route_match_ipv6_address_prefix_len_cmd = {
1119 "ipv6 address prefix-len", route_match_address_prefix_len,
1120 route_match_address_prefix_len_compile,
1121 route_match_address_prefix_len_free};
1122
1123 /* `match ip nexthop prefix-len PREFIXLEN' */
1124
1125 static route_map_result_t
1126 route_match_ip_nexthop_prefix_len(void *rule, const struct prefix *prefix,
1127 route_map_object_t type, void *object)
1128 {
1129 uint32_t *prefixlen = (uint32_t *)rule;
1130 struct nh_rmap_obj *nh_data;
1131 struct prefix_ipv4 p;
1132
1133 if (type == RMAP_ZEBRA) {
1134 nh_data = (struct nh_rmap_obj *)object;
1135 if (!nh_data || !nh_data->nexthop)
1136 return RMAP_DENYMATCH;
1137
1138 switch (nh_data->nexthop->type) {
1139 case NEXTHOP_TYPE_IFINDEX:
1140 /* Interface routes can't match ip next-hop */
1141 return RMAP_NOMATCH;
1142 case NEXTHOP_TYPE_IPV4_IFINDEX:
1143 case NEXTHOP_TYPE_IPV4:
1144 p.family = AF_INET;
1145 p.prefix = nh_data->nexthop->gate.ipv4;
1146 p.prefixlen = IPV4_MAX_BITLEN;
1147 break;
1148 default:
1149 return RMAP_NOMATCH;
1150 }
1151 return ((p.prefixlen == *prefixlen) ? RMAP_MATCH
1152 : RMAP_NOMATCH);
1153 }
1154 return RMAP_NOMATCH;
1155 }
1156
1157 static struct route_map_rule_cmd route_match_ip_nexthop_prefix_len_cmd = {
1158 "ip next-hop prefix-len", route_match_ip_nexthop_prefix_len,
1159 route_match_address_prefix_len_compile, /* reuse */
1160 route_match_address_prefix_len_free /* reuse */
1161 };
1162
1163 /* `match source-protocol PROTOCOL' */
1164
1165 static route_map_result_t route_match_source_protocol(void *rule,
1166 const struct prefix *p,
1167 route_map_object_t type,
1168 void *object)
1169 {
1170 uint32_t *rib_type = (uint32_t *)rule;
1171 struct nh_rmap_obj *nh_data;
1172
1173 if (type == RMAP_ZEBRA) {
1174 nh_data = (struct nh_rmap_obj *)object;
1175 if (!nh_data)
1176 return RMAP_DENYMATCH;
1177
1178 return ((nh_data->source_protocol == *rib_type) ? RMAP_MATCH
1179 : RMAP_NOMATCH);
1180 }
1181 return RMAP_NOMATCH;
1182 }
1183
1184 static void *route_match_source_protocol_compile(const char *arg)
1185 {
1186 uint32_t *rib_type;
1187 int i;
1188
1189 i = proto_name2num(arg);
1190 rib_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1191
1192 *rib_type = i;
1193
1194 return rib_type;
1195 }
1196
1197 static void route_match_source_protocol_free(void *rule)
1198 {
1199 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1200 }
1201
1202 static struct route_map_rule_cmd route_match_source_protocol_cmd = {
1203 "source-protocol", route_match_source_protocol,
1204 route_match_source_protocol_compile, route_match_source_protocol_free};
1205
1206 /* `source-instance` */
1207 static route_map_result_t route_match_source_instance(void *rule,
1208 const struct prefix *p,
1209 route_map_object_t type,
1210 void *object)
1211 {
1212 uint8_t *instance = (uint8_t *)rule;
1213 struct nh_rmap_obj *nh_data;
1214
1215 if (type != RMAP_ZEBRA)
1216 return RMAP_NOMATCH;
1217
1218 nh_data = (struct nh_rmap_obj *)object;
1219 if (!nh_data)
1220 return RMAP_DENYMATCH;
1221
1222 return (nh_data->instance == *instance) ? RMAP_MATCH : RMAP_NOMATCH;
1223 }
1224
1225 static void *route_match_source_instance_compile(const char *arg)
1226 {
1227 uint8_t *instance;
1228 int i;
1229
1230 i = atoi(arg);
1231 instance = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
1232
1233 *instance = i;
1234
1235 return instance;
1236 }
1237
1238 static void route_match_source_instance_free(void *rule)
1239 {
1240 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1241 }
1242
1243 static struct route_map_rule_cmd route_match_source_instance_cmd = {
1244 "source-instance", route_match_source_instance,
1245 route_match_source_instance_compile, route_match_source_instance_free};
1246
1247 /* `set src A.B.C.D' */
1248
1249 /* Set src. */
1250 static route_map_result_t route_set_src(void *rule, const struct prefix *prefix,
1251 route_map_object_t type, void *object)
1252 {
1253 struct nh_rmap_obj *nh_data;
1254
1255 if (type == RMAP_ZEBRA) {
1256 nh_data = (struct nh_rmap_obj *)object;
1257 nh_data->nexthop->rmap_src = *(union g_addr *)rule;
1258 }
1259 return RMAP_OKAY;
1260 }
1261
1262 /* set src compilation. */
1263 static void *route_set_src_compile(const char *arg)
1264 {
1265 union g_addr src, *psrc;
1266
1267 if ((inet_pton(AF_INET6, arg, &src.ipv6) == 1)
1268 || (inet_pton(AF_INET, arg, &src.ipv4) == 1)) {
1269 psrc = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(union g_addr));
1270 *psrc = src;
1271 return psrc;
1272 }
1273 return NULL;
1274 }
1275
1276 /* Free route map's compiled `set src' value. */
1277 static void route_set_src_free(void *rule)
1278 {
1279 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1280 }
1281
1282 /* Set src rule structure. */
1283 static struct route_map_rule_cmd route_set_src_cmd = {
1284 "src", route_set_src, route_set_src_compile, route_set_src_free,
1285 };
1286
1287 static void zebra_route_map_process_update_cb(char *rmap_name)
1288 {
1289 if (IS_ZEBRA_DEBUG_EVENT)
1290 zlog_debug("Event handler for route-map: %s",
1291 rmap_name);
1292 }
1293
1294 static int zebra_route_map_update_timer(struct thread *thread)
1295 {
1296 zebra_t_rmap_update = NULL;
1297
1298 if (IS_ZEBRA_DEBUG_EVENT)
1299 zlog_debug("Event driven route-map update triggered");
1300
1301 if (IS_ZEBRA_DEBUG_RIB_DETAILED)
1302 zlog_debug(
1303 "%u: Routemap update-timer fired, scheduling RIB processing",
1304 VRF_DEFAULT);
1305
1306 route_map_walk_update_list(zebra_route_map_process_update_cb);
1307
1308 /*
1309 * This code needs to be updated to be:
1310 * 1) VRF Aware <sigh>
1311 * 2) Route-map aware
1312 */
1313 zebra_import_table_rm_update();
1314 rib_update(VRF_DEFAULT, RIB_UPDATE_RMAP_CHANGE);
1315 zebra_evaluate_rnh(0, AF_INET, 1, RNH_NEXTHOP_TYPE, NULL);
1316 zebra_evaluate_rnh(0, AF_INET6, 1, RNH_NEXTHOP_TYPE, NULL);
1317
1318 return (0);
1319 }
1320
1321 static void zebra_route_map_set_delay_timer(uint32_t value)
1322 {
1323 zebra_rmap_update_timer = value;
1324 if (!value && zebra_t_rmap_update) {
1325 /* Event driven route map updates is being disabled */
1326 /* But there's a pending timer. Fire it off now */
1327 thread_cancel(zebra_t_rmap_update);
1328 zebra_route_map_update_timer(zebra_t_rmap_update);
1329 }
1330 }
1331
1332 void zebra_route_map_write_delay_timer(struct vty *vty)
1333 {
1334 if (vty && (zebra_rmap_update_timer != ZEBRA_RMAP_DEFAULT_UPDATE_TIMER))
1335 vty_out(vty, "zebra route-map delay-timer %d\n",
1336 zebra_rmap_update_timer);
1337 return;
1338 }
1339
1340 route_map_result_t zebra_route_map_check(int family, int rib_type,
1341 uint8_t instance,
1342 const struct prefix *p,
1343 struct nexthop *nexthop,
1344 vrf_id_t vrf_id, route_tag_t tag)
1345 {
1346 struct route_map *rmap = NULL;
1347 route_map_result_t ret = RMAP_MATCH;
1348 struct nh_rmap_obj nh_obj;
1349
1350 nh_obj.nexthop = nexthop;
1351 nh_obj.vrf_id = vrf_id;
1352 nh_obj.source_protocol = rib_type;
1353 nh_obj.instance = instance;
1354 nh_obj.metric = 0;
1355 nh_obj.tag = tag;
1356
1357 if (rib_type >= 0 && rib_type < ZEBRA_ROUTE_MAX)
1358 rmap = route_map_lookup_by_name(proto_rm[family][rib_type]);
1359 if (!rmap && proto_rm[family][ZEBRA_ROUTE_MAX])
1360 rmap = route_map_lookup_by_name(
1361 proto_rm[family][ZEBRA_ROUTE_MAX]);
1362 if (rmap) {
1363 ret = route_map_apply(rmap, p, RMAP_ZEBRA, &nh_obj);
1364 }
1365
1366 return (ret);
1367 }
1368
1369 char *zebra_get_import_table_route_map(afi_t afi, uint32_t table)
1370 {
1371 return zebra_import_table_routemap[afi][table];
1372 }
1373
1374 void zebra_add_import_table_route_map(afi_t afi, const char *rmap_name,
1375 uint32_t table)
1376 {
1377 zebra_import_table_routemap[afi][table] =
1378 XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_name);
1379 }
1380
1381 void zebra_del_import_table_route_map(afi_t afi, uint32_t table)
1382 {
1383 XFREE(MTYPE_ROUTE_MAP_NAME, zebra_import_table_routemap[afi][table]);
1384 }
1385
1386 route_map_result_t
1387 zebra_import_table_route_map_check(int family, int re_type, uint8_t instance,
1388 const struct prefix *p,
1389 struct nexthop *nexthop,
1390 vrf_id_t vrf_id, route_tag_t tag,
1391 const char *rmap_name)
1392 {
1393 struct route_map *rmap = NULL;
1394 route_map_result_t ret = RMAP_DENYMATCH;
1395 struct nh_rmap_obj nh_obj;
1396
1397 nh_obj.nexthop = nexthop;
1398 nh_obj.vrf_id = vrf_id;
1399 nh_obj.source_protocol = re_type;
1400 nh_obj.instance = instance;
1401 nh_obj.metric = 0;
1402 nh_obj.tag = tag;
1403
1404 if (re_type >= 0 && re_type < ZEBRA_ROUTE_MAX)
1405 rmap = route_map_lookup_by_name(rmap_name);
1406 if (rmap) {
1407 ret = route_map_apply(rmap, p, RMAP_ZEBRA, &nh_obj);
1408 }
1409
1410 return (ret);
1411 }
1412
1413 route_map_result_t zebra_nht_route_map_check(int family, int client_proto,
1414 const struct prefix *p,
1415 struct route_entry *re,
1416 struct nexthop *nexthop)
1417 {
1418 struct route_map *rmap = NULL;
1419 route_map_result_t ret = RMAP_MATCH;
1420 struct nh_rmap_obj nh_obj;
1421
1422 nh_obj.nexthop = nexthop;
1423 nh_obj.vrf_id = nexthop->vrf_id;
1424 nh_obj.source_protocol = re->type;
1425 nh_obj.instance = re->instance;
1426 nh_obj.metric = re->metric;
1427 nh_obj.tag = re->tag;
1428
1429 if (client_proto >= 0 && client_proto < ZEBRA_ROUTE_MAX)
1430 rmap = route_map_lookup_by_name(nht_rm[family][client_proto]);
1431 if (!rmap && nht_rm[family][ZEBRA_ROUTE_MAX])
1432 rmap = route_map_lookup_by_name(
1433 nht_rm[family][ZEBRA_ROUTE_MAX]);
1434 if (rmap)
1435 ret = route_map_apply(rmap, p, RMAP_ZEBRA, &nh_obj);
1436
1437 return ret;
1438 }
1439
1440 static void zebra_route_map_mark_update(const char *rmap_name)
1441 {
1442 /* rmap_update_timer of 0 means don't do route updates */
1443 if (zebra_rmap_update_timer && !zebra_t_rmap_update) {
1444 zebra_t_rmap_update = NULL;
1445 thread_add_timer(zebrad.master, zebra_route_map_update_timer,
1446 NULL, zebra_rmap_update_timer,
1447 &zebra_t_rmap_update);
1448 }
1449 }
1450
1451 static void zebra_route_map_add(const char *rmap_name)
1452 {
1453 if (route_map_mark_updated(rmap_name) == 0)
1454 zebra_route_map_mark_update(rmap_name);
1455
1456 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
1457 }
1458
1459 static void zebra_route_map_delete(const char *rmap_name)
1460 {
1461 if (route_map_mark_updated(rmap_name) == 0)
1462 zebra_route_map_mark_update(rmap_name);
1463
1464 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_DELETED);
1465 }
1466
1467 static void zebra_route_map_event(route_map_event_t event,
1468 const char *rmap_name)
1469 {
1470 if (route_map_mark_updated(rmap_name) == 0)
1471 zebra_route_map_mark_update(rmap_name);
1472
1473 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
1474 }
1475
1476 /* ip protocol configuration write function */
1477 void zebra_routemap_config_write_protocol(struct vty *vty)
1478 {
1479 int i;
1480
1481 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
1482 if (proto_rm[AFI_IP][i])
1483 vty_out(vty, "ip protocol %s route-map %s\n",
1484 zebra_route_string(i), proto_rm[AFI_IP][i]);
1485
1486 if (proto_rm[AFI_IP6][i])
1487 vty_out(vty, "ipv6 protocol %s route-map %s\n",
1488 zebra_route_string(i), proto_rm[AFI_IP6][i]);
1489
1490 if (nht_rm[AFI_IP][i])
1491 vty_out(vty, "ip nht %s route-map %s\n",
1492 zebra_route_string(i), nht_rm[AFI_IP][i]);
1493
1494 if (nht_rm[AFI_IP6][i])
1495 vty_out(vty, "ipv6 nht %s route-map %s\n",
1496 zebra_route_string(i), nht_rm[AFI_IP6][i]);
1497 }
1498
1499 if (proto_rm[AFI_IP][ZEBRA_ROUTE_MAX])
1500 vty_out(vty, "ip protocol %s route-map %s\n", "any",
1501 proto_rm[AFI_IP][ZEBRA_ROUTE_MAX]);
1502
1503 if (proto_rm[AFI_IP6][ZEBRA_ROUTE_MAX])
1504 vty_out(vty, "ipv6 protocol %s route-map %s\n", "any",
1505 proto_rm[AFI_IP6][ZEBRA_ROUTE_MAX]);
1506
1507 if (nht_rm[AFI_IP][ZEBRA_ROUTE_MAX])
1508 vty_out(vty, "ip nht %s route-map %s\n", "any",
1509 nht_rm[AFI_IP][ZEBRA_ROUTE_MAX]);
1510
1511 if (nht_rm[AFI_IP6][ZEBRA_ROUTE_MAX])
1512 vty_out(vty, "ipv6 nht %s route-map %s\n", "any",
1513 nht_rm[AFI_IP6][ZEBRA_ROUTE_MAX]);
1514
1515 if (zebra_rmap_update_timer != ZEBRA_RMAP_DEFAULT_UPDATE_TIMER)
1516 vty_out(vty, "zebra route-map delay-timer %d\n",
1517 zebra_rmap_update_timer);
1518 }
1519
1520 void zebra_route_map_init()
1521 {
1522 install_element(CONFIG_NODE, &ip_protocol_cmd);
1523 install_element(CONFIG_NODE, &no_ip_protocol_cmd);
1524 install_element(VIEW_NODE, &show_ip_protocol_cmd);
1525 install_element(CONFIG_NODE, &ipv6_protocol_cmd);
1526 install_element(CONFIG_NODE, &no_ipv6_protocol_cmd);
1527 install_element(VIEW_NODE, &show_ipv6_protocol_cmd);
1528 install_element(CONFIG_NODE, &ip_protocol_nht_rmap_cmd);
1529 install_element(CONFIG_NODE, &no_ip_protocol_nht_rmap_cmd);
1530 install_element(VIEW_NODE, &show_ip_protocol_nht_cmd);
1531 install_element(CONFIG_NODE, &ipv6_protocol_nht_rmap_cmd);
1532 install_element(CONFIG_NODE, &no_ipv6_protocol_nht_rmap_cmd);
1533 install_element(VIEW_NODE, &show_ipv6_protocol_nht_cmd);
1534 install_element(CONFIG_NODE, &zebra_route_map_timer_cmd);
1535 install_element(CONFIG_NODE, &no_zebra_route_map_timer_cmd);
1536
1537 route_map_init();
1538
1539 route_map_add_hook(zebra_route_map_add);
1540 route_map_delete_hook(zebra_route_map_delete);
1541 route_map_event_hook(zebra_route_map_event);
1542
1543 route_map_match_interface_hook(generic_match_add);
1544 route_map_no_match_interface_hook(generic_match_delete);
1545
1546 route_map_match_ip_address_hook(generic_match_add);
1547 route_map_no_match_ip_address_hook(generic_match_delete);
1548
1549 route_map_match_ip_address_prefix_list_hook(generic_match_add);
1550 route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
1551
1552 route_map_match_ip_next_hop_hook(generic_match_add);
1553 route_map_no_match_ip_next_hop_hook(generic_match_delete);
1554
1555 route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
1556 route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
1557
1558 route_map_match_tag_hook(generic_match_add);
1559 route_map_no_match_tag_hook(generic_match_delete);
1560
1561 route_map_install_match(&route_match_tag_cmd);
1562 route_map_install_match(&route_match_interface_cmd);
1563 route_map_install_match(&route_match_ip_next_hop_cmd);
1564 route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
1565 route_map_install_match(&route_match_ip_address_cmd);
1566 route_map_install_match(&route_match_ip_address_prefix_list_cmd);
1567 route_map_install_match(&route_match_ip_address_prefix_len_cmd);
1568 route_map_install_match(&route_match_ipv6_address_prefix_len_cmd);
1569 route_map_install_match(&route_match_ip_nexthop_prefix_len_cmd);
1570 route_map_install_match(&route_match_source_protocol_cmd);
1571 route_map_install_match(&route_match_source_instance_cmd);
1572
1573 /* */
1574 route_map_install_set(&route_set_src_cmd);
1575 /* */
1576 install_element(RMAP_NODE, &match_ip_nexthop_prefix_len_cmd);
1577 install_element(RMAP_NODE, &no_match_ip_nexthop_prefix_len_cmd);
1578 install_element(RMAP_NODE, &match_ip_address_prefix_len_cmd);
1579 install_element(RMAP_NODE, &match_ipv6_address_prefix_len_cmd);
1580 install_element(RMAP_NODE, &no_match_ipv6_address_prefix_len_cmd);
1581 install_element(RMAP_NODE, &no_match_ip_address_prefix_len_cmd);
1582 install_element(RMAP_NODE, &match_source_protocol_cmd);
1583 install_element(RMAP_NODE, &no_match_source_protocol_cmd);
1584 install_element(RMAP_NODE, &match_source_instance_cmd);
1585 install_element(RMAP_NODE, &no_match_source_instance_cmd);
1586
1587 /* */
1588 install_element(RMAP_NODE, &set_src_cmd);
1589 install_element(RMAP_NODE, &no_set_src_cmd);
1590 }
FRRouting mirror