]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_routemap.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12816 from gpnaveen/stc_rte_err_msg
[mirror_frr.git] / bgpd / bgp_routemap.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Route map function of bgpd.
3 * Copyright (C) 1998, 1999 Kunihiro Ishiguro
4 */
5
6 #include <zebra.h>
7
8 #include "prefix.h"
9 #include "filter.h"
10 #include "routemap.h"
11 #include "command.h"
12 #include "linklist.h"
13 #include "plist.h"
14 #include "memory.h"
15 #include "log.h"
16 #include "frrlua.h"
17 #include "frrscript.h"
18 #ifdef HAVE_LIBPCRE2_POSIX
19 #ifndef _FRR_PCRE2_POSIX
20 #define _FRR_PCRE2_POSIX
21 #include <pcre2posix.h>
22 #endif /* _FRR_PCRE2_POSIX */
23 #elif defined(HAVE_LIBPCREPOSIX)
24 #include <pcreposix.h>
25 #else
26 #include <regex.h>
27 #endif /* HAVE_LIBPCRE2_POSIX */
28 #include "buffer.h"
29 #include "sockunion.h"
30 #include "hash.h"
31 #include "queue.h"
32 #include "frrstr.h"
33 #include "network.h"
34 #include "lib/northbound_cli.h"
35
36 #include "bgpd/bgpd.h"
37 #include "bgpd/bgp_table.h"
38 #include "bgpd/bgp_attr.h"
39 #include "bgpd/bgp_aspath.h"
40 #include "bgpd/bgp_packet.h"
41 #include "bgpd/bgp_route.h"
42 #include "bgpd/bgp_zebra.h"
43 #include "bgpd/bgp_regex.h"
44 #include "bgpd/bgp_community.h"
45 #include "bgpd/bgp_community_alias.h"
46 #include "bgpd/bgp_clist.h"
47 #include "bgpd/bgp_filter.h"
48 #include "bgpd/bgp_mplsvpn.h"
49 #include "bgpd/bgp_ecommunity.h"
50 #include "bgpd/bgp_lcommunity.h"
51 #include "bgpd/bgp_vty.h"
52 #include "bgpd/bgp_debug.h"
53 #include "bgpd/bgp_evpn.h"
54 #include "bgpd/bgp_evpn_private.h"
55 #include "bgpd/bgp_evpn_vty.h"
56 #include "bgpd/bgp_mplsvpn.h"
57 #include "bgpd/bgp_pbr.h"
58 #include "bgpd/bgp_flowspec_util.h"
59 #include "bgpd/bgp_encap_types.h"
60 #include "bgpd/bgp_mpath.h"
61 #include "bgpd/bgp_script.h"
62
63 #ifdef ENABLE_BGP_VNC
64 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
65 #endif
66
67 #include "bgpd/bgp_routemap_clippy.c"
68
69 /* Memo of route-map commands.
70
71 o Cisco route-map
72
73 match as-path : Done
74 community : Done
75 interface : Done
76 ip address : Done
77 ip next-hop : Done
78 ip route-source : Done
79 ip prefix-list : Done
80 ipv6 address : Done
81 ipv6 next-hop : Done
82 ipv6 route-source: (This will not be implemented by bgpd)
83 ipv6 prefix-list : Done
84 length : (This will not be implemented by bgpd)
85 metric : Done
86 route-type : (This will not be implemented by bgpd)
87 tag : Done
88 local-preference : Done
89
90 set as-path prepend : Done
91 as-path tag : Not yet
92 automatic-tag : (This will not be implemented by bgpd)
93 community : Done
94 large-community : Done
95 large-comm-list : Done
96 comm-list : Not yet
97 dampning : Not yet
98 default : (This will not be implemented by bgpd)
99 interface : (This will not be implemented by bgpd)
100 ip default : (This will not be implemented by bgpd)
101 ip next-hop : Done
102 ip precedence : (This will not be implemented by bgpd)
103 ip tos : (This will not be implemented by bgpd)
104 level : (This will not be implemented by bgpd)
105 local-preference : Done
106 metric : Done
107 metric-type : Not yet
108 origin : Done
109 tag : Done
110 weight : Done
111 table : Done
112
113 o Local extensions
114
115 set ipv6 next-hop global: Done
116 set ipv6 next-hop prefer-global: Done
117 set ipv6 next-hop local : Done
118 set as-path exclude : Done
119
120 */
121
122 /* generic value manipulation to be shared in multiple rules */
123
124 #define RMAP_VALUE_SET 0
125 #define RMAP_VALUE_ADD 1
126 #define RMAP_VALUE_SUB 2
127
128 struct rmap_value {
129 uint8_t action;
130 uint8_t variable;
131 uint32_t value;
132 };
133
134 static int route_value_match(struct rmap_value *rv, uint32_t value)
135 {
136 if (rv->variable == 0 && value == rv->value)
137 return RMAP_MATCH;
138
139 return RMAP_NOMATCH;
140 }
141
142 static uint32_t route_value_adjust(struct rmap_value *rv, uint32_t current,
143 struct peer *peer)
144 {
145 uint32_t value;
146
147 switch (rv->variable) {
148 case 1:
149 value = peer->rtt;
150 break;
151 default:
152 value = rv->value;
153 break;
154 }
155
156 switch (rv->action) {
157 case RMAP_VALUE_ADD:
158 if (current > UINT32_MAX - value)
159 return UINT32_MAX;
160 return current + value;
161 case RMAP_VALUE_SUB:
162 if (current <= value)
163 return 0;
164 return current - value;
165 default:
166 return value;
167 }
168 }
169
170 static void *route_value_compile(const char *arg)
171 {
172 uint8_t action = RMAP_VALUE_SET, var = 0;
173 unsigned long larg = 0;
174 char *endptr = NULL;
175 struct rmap_value *rv;
176
177 if (arg[0] == '+') {
178 action = RMAP_VALUE_ADD;
179 arg++;
180 } else if (arg[0] == '-') {
181 action = RMAP_VALUE_SUB;
182 arg++;
183 }
184
185 if (all_digit(arg)) {
186 errno = 0;
187 larg = strtoul(arg, &endptr, 10);
188 if (*arg == 0 || *endptr != 0 || errno || larg > UINT32_MAX)
189 return NULL;
190 } else {
191 if (strcmp(arg, "rtt") == 0)
192 var = 1;
193 else
194 return NULL;
195 }
196
197 rv = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_value));
198
199 rv->action = action;
200 rv->variable = var;
201 rv->value = larg;
202 return rv;
203 }
204
205 static void route_value_free(void *rule)
206 {
207 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
208 }
209
210 /* generic as path object to be shared in multiple rules */
211
212 static void *route_aspath_compile(const char *arg)
213 {
214 struct aspath *aspath;
215
216 aspath = aspath_str2aspath(arg, bgp_get_asnotation(NULL));
217 if (!aspath)
218 return NULL;
219 return aspath;
220 }
221
222 static void route_aspath_free(void *rule)
223 {
224 struct aspath *aspath = rule;
225 aspath_free(aspath);
226 }
227
228 struct bgp_match_peer_compiled {
229 char *interface;
230 union sockunion su;
231 };
232
233 /* 'match peer (A.B.C.D|X:X::X:X|WORD)' */
234
235 /* Compares the peer specified in the 'match peer' clause with the peer
236 received in bgp_path_info->peer. If it is the same, or if the peer structure
237 received is a peer_group containing it, returns RMAP_MATCH. */
238 static enum route_map_cmd_result_t
239 route_match_peer(void *rule, const struct prefix *prefix, void *object)
240 {
241 struct bgp_match_peer_compiled *pc;
242 union sockunion *su;
243 union sockunion su_def = {
244 .sin = {.sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY}};
245 struct peer_group *group;
246 struct peer *peer;
247 struct listnode *node, *nnode;
248
249 pc = rule;
250 su = &pc->su;
251 peer = ((struct bgp_path_info *)object)->peer;
252
253 if (pc->interface) {
254 if (!peer->conf_if || !peer->group)
255 return RMAP_NOMATCH;
256
257 if (peer->conf_if && strcmp(peer->conf_if, pc->interface) == 0)
258 return RMAP_MATCH;
259
260 if (peer->group &&
261 strcmp(peer->group->name, pc->interface) == 0)
262 return RMAP_MATCH;
263
264 return RMAP_NOMATCH;
265 }
266
267 /* If su='0.0.0.0' (command 'match peer local'), and it's a
268 NETWORK,
269 REDISTRIBUTE, AGGREGATE-ADDRESS or DEFAULT_GENERATED route
270 => return RMAP_MATCH
271 */
272 if (sockunion_same(su, &su_def)) {
273 int ret;
274 if (CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_NETWORK)
275 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_REDISTRIBUTE)
276 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_AGGREGATE)
277 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_DEFAULT))
278 ret = RMAP_MATCH;
279 else
280 ret = RMAP_NOMATCH;
281 return ret;
282 }
283
284 if (!CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
285 if (sockunion_same(su, &peer->su))
286 return RMAP_MATCH;
287
288 return RMAP_NOMATCH;
289 } else {
290 group = peer->group;
291 for (ALL_LIST_ELEMENTS(group->peer, node, nnode, peer)) {
292 if (sockunion_same(su, &peer->su))
293 return RMAP_MATCH;
294 }
295 return RMAP_NOMATCH;
296 }
297
298 return RMAP_NOMATCH;
299 }
300
301 static void *route_match_peer_compile(const char *arg)
302 {
303 struct bgp_match_peer_compiled *pc;
304 int ret;
305
306 pc = XCALLOC(MTYPE_ROUTE_MAP_COMPILED,
307 sizeof(struct bgp_match_peer_compiled));
308
309 ret = str2sockunion(strcmp(arg, "local") ? arg : "0.0.0.0", &pc->su);
310 if (ret < 0) {
311 pc->interface = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
312 return pc;
313 }
314
315 return pc;
316 }
317
318 /* Free route map's compiled `ip address' value. */
319 static void route_match_peer_free(void *rule)
320 {
321 struct bgp_match_peer_compiled *pc = rule;
322
323 XFREE(MTYPE_ROUTE_MAP_COMPILED, pc->interface);
324
325 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
326 }
327
328 /* Route map commands for ip address matching. */
329 static const struct route_map_rule_cmd route_match_peer_cmd = {
330 "peer",
331 route_match_peer,
332 route_match_peer_compile,
333 route_match_peer_free
334 };
335
336 #ifdef HAVE_SCRIPTING
337
338 enum frrlua_rm_status {
339 /*
340 * Script function run failure. This will translate into a deny
341 */
342 LUA_RM_FAILURE = 0,
343 /*
344 * No Match was found for the route map function
345 */
346 LUA_RM_NOMATCH,
347 /*
348 * Match was found but no changes were made to the incoming data.
349 */
350 LUA_RM_MATCH,
351 /*
352 * Match was found and data was modified, so figure out what changed
353 */
354 LUA_RM_MATCH_AND_CHANGE,
355 };
356
357 static enum route_map_cmd_result_t
358 route_match_script(void *rule, const struct prefix *prefix, void *object)
359 {
360 const char *scriptname = rule;
361 const char *routematch_function = "route_match";
362 struct bgp_path_info *path = (struct bgp_path_info *)object;
363
364 struct frrscript *fs = frrscript_new(scriptname);
365
366 if (frrscript_load(fs, routematch_function, NULL)) {
367 zlog_err(
368 "Issue loading script or function; defaulting to no match");
369 return RMAP_NOMATCH;
370 }
371
372 struct attr newattr = *path->attr;
373
374 int result = frrscript_call(
375 fs, routematch_function, ("prefix", prefix),
376 ("attributes", &newattr), ("peer", path->peer),
377 ("RM_FAILURE", LUA_RM_FAILURE), ("RM_NOMATCH", LUA_RM_NOMATCH),
378 ("RM_MATCH", LUA_RM_MATCH),
379 ("RM_MATCH_AND_CHANGE", LUA_RM_MATCH_AND_CHANGE));
380
381 if (result) {
382 zlog_err("Issue running script rule; defaulting to no match");
383 return RMAP_NOMATCH;
384 }
385
386 long long *action = frrscript_get_result(fs, routematch_function,
387 "action", lua_tointegerp);
388
389 int status = RMAP_NOMATCH;
390
391 switch (*action) {
392 case LUA_RM_FAILURE:
393 zlog_err(
394 "Executing route-map match script '%s' failed; defaulting to no match",
395 scriptname);
396 status = RMAP_NOMATCH;
397 break;
398 case LUA_RM_NOMATCH:
399 status = RMAP_NOMATCH;
400 break;
401 case LUA_RM_MATCH_AND_CHANGE:
402 status = RMAP_MATCH;
403 zlog_debug("Updating attribute based on script's values");
404
405 uint32_t locpref = 0;
406
407 path->attr->med = newattr.med;
408
409 if (path->attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
410 locpref = path->attr->local_pref;
411 if (locpref != newattr.local_pref) {
412 SET_FLAG(path->attr->flag,
413 ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
414 path->attr->local_pref = newattr.local_pref;
415 }
416 break;
417 case LUA_RM_MATCH:
418 status = RMAP_MATCH;
419 break;
420 }
421
422 XFREE(MTYPE_SCRIPT_RES, action);
423
424 frrscript_delete(fs);
425
426 return status;
427 }
428
429 static void *route_match_script_compile(const char *arg)
430 {
431 char *scriptname;
432
433 scriptname = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
434
435 return scriptname;
436 }
437
438 static void route_match_script_free(void *rule)
439 {
440 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
441 }
442
443 static const struct route_map_rule_cmd route_match_script_cmd = {
444 "script",
445 route_match_script,
446 route_match_script_compile,
447 route_match_script_free
448 };
449
450 #endif /* HAVE_SCRIPTING */
451
452 /* `match ip address IP_ACCESS_LIST' */
453
454 /* Match function should return 1 if match is success else return
455 zero. */
456 static enum route_map_cmd_result_t
457 route_match_ip_address(void *rule, const struct prefix *prefix, void *object)
458 {
459 struct access_list *alist;
460
461 if (prefix->family == AF_INET) {
462 alist = access_list_lookup(AFI_IP, (char *)rule);
463 if (alist == NULL) {
464 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
465 zlog_debug(
466 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
467 __func__, (char *)rule);
468 return RMAP_NOMATCH;
469 }
470
471 return (access_list_apply(alist, prefix) == FILTER_DENY
472 ? RMAP_NOMATCH
473 : RMAP_MATCH);
474 }
475 return RMAP_NOMATCH;
476 }
477
478 /* Route map `ip address' match statement. `arg' should be
479 access-list name. */
480 static void *route_match_ip_address_compile(const char *arg)
481 {
482 struct access_list *alist;
483
484 alist = access_list_lookup(AFI_IP, arg);
485 if (!alist)
486 zlog_warn(
487 "Access List specified %s does not exist yet, default will be NO_MATCH until it is created",
488 arg);
489 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
490 }
491
492 /* Free route map's compiled `ip address' value. */
493 static void route_match_ip_address_free(void *rule)
494 {
495 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
496 }
497
498 /* Route map commands for ip address matching. */
499 static const struct route_map_rule_cmd route_match_ip_address_cmd = {
500 "ip address",
501 route_match_ip_address,
502 route_match_ip_address_compile,
503 route_match_ip_address_free
504 };
505
506 /* `match ip next-hop <IP_ADDRESS_ACCESS_LIST_NAME>' */
507
508 /* Match function return 1 if match is success else return zero. */
509 static enum route_map_cmd_result_t
510 route_match_ip_next_hop(void *rule, const struct prefix *prefix, void *object)
511 {
512 struct access_list *alist;
513 struct bgp_path_info *path;
514 struct prefix_ipv4 p;
515
516 if (prefix->family == AF_INET) {
517 path = object;
518 p.family = AF_INET;
519 p.prefix = path->attr->nexthop;
520 p.prefixlen = IPV4_MAX_BITLEN;
521
522 alist = access_list_lookup(AFI_IP, (char *)rule);
523 if (alist == NULL) {
524 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
525 zlog_debug(
526 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
527 __func__, (char *)rule);
528
529 return RMAP_NOMATCH;
530 }
531
532 return (access_list_apply(alist, &p) == FILTER_DENY
533 ? RMAP_NOMATCH
534 : RMAP_MATCH);
535 }
536 return RMAP_NOMATCH;
537 }
538
539 /* Route map `ip next-hop' match statement. `arg' is
540 access-list name. */
541 static void *route_match_ip_next_hop_compile(const char *arg)
542 {
543 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
544 }
545
546 /* Free route map's compiled `ip address' value. */
547 static void route_match_ip_next_hop_free(void *rule)
548 {
549 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
550 }
551
552 /* Route map commands for ip next-hop matching. */
553 static const struct route_map_rule_cmd route_match_ip_next_hop_cmd = {
554 "ip next-hop",
555 route_match_ip_next_hop,
556 route_match_ip_next_hop_compile,
557 route_match_ip_next_hop_free
558 };
559
560 /* `match ip route-source ACCESS-LIST' */
561
562 /* Match function return 1 if match is success else return zero. */
563 static enum route_map_cmd_result_t
564 route_match_ip_route_source(void *rule, const struct prefix *pfx, void *object)
565 {
566 struct access_list *alist;
567 struct bgp_path_info *path;
568 struct peer *peer;
569 struct prefix_ipv4 p;
570
571 if (pfx->family == AF_INET) {
572 path = object;
573 peer = path->peer;
574
575 if (!peer || sockunion_family(&peer->su) != AF_INET)
576 return RMAP_NOMATCH;
577
578 p.family = AF_INET;
579 p.prefix = peer->su.sin.sin_addr;
580 p.prefixlen = IPV4_MAX_BITLEN;
581
582 alist = access_list_lookup(AFI_IP, (char *)rule);
583 if (alist == NULL) {
584 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
585 zlog_debug(
586 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
587 __func__, (char *)rule);
588
589 return RMAP_NOMATCH;
590 }
591
592 return (access_list_apply(alist, &p) == FILTER_DENY
593 ? RMAP_NOMATCH
594 : RMAP_MATCH);
595 }
596 return RMAP_NOMATCH;
597 }
598
599 /* Route map `ip route-source' match statement. `arg' is
600 access-list name. */
601 static void *route_match_ip_route_source_compile(const char *arg)
602 {
603 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
604 }
605
606 /* Free route map's compiled `ip address' value. */
607 static void route_match_ip_route_source_free(void *rule)
608 {
609 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
610 }
611
612 /* Route map commands for ip route-source matching. */
613 static const struct route_map_rule_cmd route_match_ip_route_source_cmd = {
614 "ip route-source",
615 route_match_ip_route_source,
616 route_match_ip_route_source_compile,
617 route_match_ip_route_source_free
618 };
619
620 static enum route_map_cmd_result_t
621 route_match_prefix_list_flowspec(afi_t afi, struct prefix_list *plist,
622 const struct prefix *p)
623 {
624 int ret;
625 struct bgp_pbr_entry_main api;
626
627 memset(&api, 0, sizeof(api));
628
629 if (family2afi(p->u.prefix_flowspec.family) != afi)
630 return RMAP_NOMATCH;
631
632 /* extract match from flowspec entries */
633 ret = bgp_flowspec_match_rules_fill(
634 (uint8_t *)p->u.prefix_flowspec.ptr,
635 p->u.prefix_flowspec.prefixlen, &api,
636 afi);
637 if (ret < 0)
638 return RMAP_NOMATCH;
639 if (api.match_bitmask & PREFIX_DST_PRESENT ||
640 api.match_bitmask_iprule & PREFIX_DST_PRESENT) {
641 if (family2afi((&api.dst_prefix)->family) != afi)
642 return RMAP_NOMATCH;
643 return prefix_list_apply(plist, &api.dst_prefix) == PREFIX_DENY
644 ? RMAP_NOMATCH
645 : RMAP_MATCH;
646 } else if (api.match_bitmask & PREFIX_SRC_PRESENT ||
647 api.match_bitmask_iprule & PREFIX_SRC_PRESENT) {
648 if (family2afi((&api.src_prefix)->family) != afi)
649 return RMAP_NOMATCH;
650 return (prefix_list_apply(plist, &api.src_prefix) == PREFIX_DENY
651 ? RMAP_NOMATCH
652 : RMAP_MATCH);
653 }
654 return RMAP_NOMATCH;
655 }
656
657 static enum route_map_cmd_result_t
658 route_match_prefix_list_evpn(afi_t afi, struct prefix_list *plist,
659 const struct prefix *p)
660 {
661 /* Convert to match a general plist */
662 struct prefix new;
663
664 if (evpn_prefix2prefix(p, &new))
665 return RMAP_NOMATCH;
666
667 return (prefix_list_apply(plist, &new) == PREFIX_DENY ? RMAP_NOMATCH
668 : RMAP_MATCH);
669 }
670
671 static enum route_map_cmd_result_t
672 route_match_address_prefix_list(void *rule, afi_t afi,
673 const struct prefix *prefix, void *object)
674 {
675 struct prefix_list *plist;
676
677 plist = prefix_list_lookup(afi, (char *)rule);
678 if (plist == NULL) {
679 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
680 zlog_debug(
681 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
682 __func__, (char *)rule);
683 return RMAP_NOMATCH;
684 }
685
686 if (prefix->family == AF_FLOWSPEC)
687 return route_match_prefix_list_flowspec(afi, plist,
688 prefix);
689
690 else if (prefix->family == AF_EVPN)
691 return route_match_prefix_list_evpn(afi, plist, prefix);
692
693 return (prefix_list_apply(plist, prefix) == PREFIX_DENY ? RMAP_NOMATCH
694 : RMAP_MATCH);
695 }
696
697 static enum route_map_cmd_result_t
698 route_match_ip_address_prefix_list(void *rule, const struct prefix *prefix,
699 void *object)
700 {
701 return route_match_address_prefix_list(rule, AFI_IP, prefix, object);
702 }
703
704 static void *route_match_ip_address_prefix_list_compile(const char *arg)
705 {
706 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
707 }
708
709 static void route_match_ip_address_prefix_list_free(void *rule)
710 {
711 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
712 }
713
714 static const struct route_map_rule_cmd
715 route_match_ip_address_prefix_list_cmd = {
716 "ip address prefix-list",
717 route_match_ip_address_prefix_list,
718 route_match_ip_address_prefix_list_compile,
719 route_match_ip_address_prefix_list_free
720 };
721
722 /* `match ip next-hop prefix-list PREFIX_LIST' */
723
724 static enum route_map_cmd_result_t
725 route_match_ip_next_hop_prefix_list(void *rule, const struct prefix *prefix,
726 void *object)
727 {
728 struct prefix_list *plist;
729 struct bgp_path_info *path;
730 struct prefix_ipv4 p;
731
732 if (prefix->family == AF_INET) {
733 path = object;
734 p.family = AF_INET;
735 p.prefix = path->attr->nexthop;
736 p.prefixlen = IPV4_MAX_BITLEN;
737
738 plist = prefix_list_lookup(AFI_IP, (char *)rule);
739 if (plist == NULL) {
740 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
741 zlog_debug(
742 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
743 __func__, (char *)rule);
744 return RMAP_NOMATCH;
745 }
746
747 return (prefix_list_apply(plist, &p) == PREFIX_DENY
748 ? RMAP_NOMATCH
749 : RMAP_MATCH);
750 }
751 return RMAP_NOMATCH;
752 }
753
754 static void *route_match_ip_next_hop_prefix_list_compile(const char *arg)
755 {
756 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
757 }
758
759 static void route_match_ip_next_hop_prefix_list_free(void *rule)
760 {
761 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
762 }
763
764 static const struct route_map_rule_cmd
765 route_match_ip_next_hop_prefix_list_cmd = {
766 "ip next-hop prefix-list",
767 route_match_ip_next_hop_prefix_list,
768 route_match_ip_next_hop_prefix_list_compile,
769 route_match_ip_next_hop_prefix_list_free
770 };
771
772 /* `match ipv6 next-hop prefix-list PREFIXLIST_NAME' */
773 static enum route_map_cmd_result_t
774 route_match_ipv6_next_hop_prefix_list(void *rule, const struct prefix *prefix,
775 void *object)
776 {
777 struct prefix_list *plist;
778 struct bgp_path_info *path;
779 struct prefix_ipv6 p;
780
781 if (prefix->family == AF_INET6) {
782 path = object;
783 p.family = AF_INET6;
784 p.prefix = path->attr->mp_nexthop_global;
785 p.prefixlen = IPV6_MAX_BITLEN;
786
787 plist = prefix_list_lookup(AFI_IP6, (char *)rule);
788 if (!plist) {
789 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
790 zlog_debug(
791 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
792 __func__, (char *)rule);
793 return RMAP_NOMATCH;
794 }
795
796 if (prefix_list_apply(plist, &p) == PREFIX_PERMIT)
797 return RMAP_MATCH;
798
799 if (path->attr->mp_nexthop_len
800 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
801 p.prefix = path->attr->mp_nexthop_local;
802 if (prefix_list_apply(plist, &p) == PREFIX_PERMIT)
803 return RMAP_MATCH;
804 }
805 }
806
807 return RMAP_NOMATCH;
808 }
809
810 static void *route_match_ipv6_next_hop_prefix_list_compile(const char *arg)
811 {
812 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
813 }
814
815 static void route_match_ipv6_next_hop_prefix_list_free(void *rule)
816 {
817 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
818 }
819
820 static const struct route_map_rule_cmd
821 route_match_ipv6_next_hop_prefix_list_cmd = {
822 "ipv6 next-hop prefix-list",
823 route_match_ipv6_next_hop_prefix_list,
824 route_match_ipv6_next_hop_prefix_list_compile,
825 route_match_ipv6_next_hop_prefix_list_free
826 };
827
828 /* `match ip next-hop type <blackhole>' */
829
830 static enum route_map_cmd_result_t
831 route_match_ip_next_hop_type(void *rule, const struct prefix *prefix,
832 void *object)
833 {
834 struct bgp_path_info *path;
835
836 if (prefix->family == AF_INET) {
837 path = (struct bgp_path_info *)object;
838 if (!path)
839 return RMAP_NOMATCH;
840
841 /* If nexthop interface's index can't be resolved and nexthop is
842 set to any address then mark it as type `blackhole`.
843 This logic works for matching kernel/static routes like:
844 `ip route add blackhole 10.0.0.1`. */
845 if (path->attr->nexthop.s_addr == INADDR_ANY
846 && !path->attr->nh_ifindex)
847 return RMAP_MATCH;
848 }
849 return RMAP_NOMATCH;
850 }
851
852 static void *route_match_ip_next_hop_type_compile(const char *arg)
853 {
854 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
855 }
856
857 static void route_match_ip_next_hop_type_free(void *rule)
858 {
859 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
860 }
861
862 static const struct route_map_rule_cmd
863 route_match_ip_next_hop_type_cmd = {
864 "ip next-hop type",
865 route_match_ip_next_hop_type,
866 route_match_ip_next_hop_type_compile,
867 route_match_ip_next_hop_type_free
868 };
869
870 /* `match ip route-source prefix-list PREFIX_LIST' */
871
872 static enum route_map_cmd_result_t
873 route_match_ip_route_source_prefix_list(void *rule, const struct prefix *prefix,
874 void *object)
875 {
876 struct prefix_list *plist;
877 struct bgp_path_info *path;
878 struct peer *peer;
879 struct prefix_ipv4 p;
880
881 if (prefix->family == AF_INET) {
882 path = object;
883 peer = path->peer;
884
885 if (!peer || sockunion_family(&peer->su) != AF_INET)
886 return RMAP_NOMATCH;
887
888 p.family = AF_INET;
889 p.prefix = peer->su.sin.sin_addr;
890 p.prefixlen = IPV4_MAX_BITLEN;
891
892 plist = prefix_list_lookup(AFI_IP, (char *)rule);
893 if (plist == NULL) {
894 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
895 zlog_debug(
896 "%s: Prefix List %s specified does not exist defaulting to NO_MATCH",
897 __func__, (char *)rule);
898 return RMAP_NOMATCH;
899 }
900
901 return (prefix_list_apply(plist, &p) == PREFIX_DENY
902 ? RMAP_NOMATCH
903 : RMAP_MATCH);
904 }
905 return RMAP_NOMATCH;
906 }
907
908 static void *route_match_ip_route_source_prefix_list_compile(const char *arg)
909 {
910 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
911 }
912
913 static void route_match_ip_route_source_prefix_list_free(void *rule)
914 {
915 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
916 }
917
918 static const struct route_map_rule_cmd
919 route_match_ip_route_source_prefix_list_cmd = {
920 "ip route-source prefix-list",
921 route_match_ip_route_source_prefix_list,
922 route_match_ip_route_source_prefix_list_compile,
923 route_match_ip_route_source_prefix_list_free
924 };
925
926 /* `match evpn default-route' */
927
928 /* Match function should return 1 if match is success else 0 */
929 static enum route_map_cmd_result_t
930 route_match_evpn_default_route(void *rule, const struct prefix *p, void *object)
931 {
932 if (is_evpn_prefix_default(p))
933 return RMAP_MATCH;
934
935 return RMAP_NOMATCH;
936 }
937
938 /* Route map commands for default-route matching. */
939 static const struct route_map_rule_cmd
940 route_match_evpn_default_route_cmd = {
941 "evpn default-route",
942 route_match_evpn_default_route,
943 NULL,
944 NULL
945 };
946
947 /* `match mac address MAC_ACCESS_LIST' */
948
949 /* Match function should return 1 if match is success else return
950 zero. */
951 static enum route_map_cmd_result_t
952 route_match_mac_address(void *rule, const struct prefix *prefix, void *object)
953 {
954 struct access_list *alist;
955 struct prefix p;
956
957 alist = access_list_lookup(AFI_L2VPN, (char *)rule);
958 if (alist == NULL) {
959 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
960 zlog_debug(
961 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
962 __func__, (char *)rule);
963
964 return RMAP_NOMATCH;
965 }
966 if (prefix->u.prefix_evpn.route_type != BGP_EVPN_MAC_IP_ROUTE) {
967 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
968 zlog_debug(
969 "%s: Prefix %pFX is not a EVPN MAC IP ROUTE defaulting to NO_MATCH",
970 __func__, prefix);
971 return RMAP_NOMATCH;
972 }
973
974 p.family = AF_ETHERNET;
975 p.prefixlen = ETH_ALEN * 8;
976 p.u.prefix_eth = prefix->u.prefix_evpn.macip_addr.mac;
977
978 return (access_list_apply(alist, &p) == FILTER_DENY ? RMAP_NOMATCH
979 : RMAP_MATCH);
980 }
981
982 /* Route map `mac address' match statement. `arg' should be
983 access-list name. */
984 static void *route_match_mac_address_compile(const char *arg)
985 {
986 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
987 }
988
989 /* Free route map's compiled `ip address' value. */
990 static void route_match_mac_address_free(void *rule)
991 {
992 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
993 }
994
995 /* Route map commands for mac address matching. */
996 static const struct route_map_rule_cmd route_match_mac_address_cmd = {
997 "mac address",
998 route_match_mac_address,
999 route_match_mac_address_compile,
1000 route_match_mac_address_free
1001 };
1002
1003 /*
1004 * Match function returns:
1005 * ...RMAP_MATCH if match is found.
1006 * ...RMAP_NOMATCH if match is not found.
1007 * ...RMAP_NOOP to ignore this match check.
1008 */
1009 static enum route_map_cmd_result_t
1010 route_match_vni(void *rule, const struct prefix *prefix, void *object)
1011 {
1012 vni_t vni = 0;
1013 unsigned int label_cnt = 0;
1014 struct bgp_path_info *path = NULL;
1015 struct prefix_evpn *evp = (struct prefix_evpn *) prefix;
1016
1017 vni = *((vni_t *)rule);
1018 path = (struct bgp_path_info *)object;
1019
1020 /*
1021 * This rmap filter is valid for vxlan tunnel type only.
1022 * For any other tunnel type, return noop to ignore
1023 * this check.
1024 */
1025 if (path->attr->encap_tunneltype != BGP_ENCAP_TYPE_VXLAN)
1026 return RMAP_NOOP;
1027
1028 /*
1029 * Apply filter to type 1, 2, 5 routes only.
1030 * Other route types do not have vni label.
1031 */
1032 if (evp
1033 && (evp->prefix.route_type != BGP_EVPN_AD_ROUTE
1034 && evp->prefix.route_type != BGP_EVPN_MAC_IP_ROUTE
1035 && evp->prefix.route_type != BGP_EVPN_IP_PREFIX_ROUTE))
1036 return RMAP_NOOP;
1037
1038 if (path->extra == NULL)
1039 return RMAP_NOMATCH;
1040
1041 for (;
1042 label_cnt < BGP_MAX_LABELS && label_cnt < path->extra->num_labels;
1043 label_cnt++) {
1044 if (vni == label2vni(&path->extra->label[label_cnt]))
1045 return RMAP_MATCH;
1046 }
1047
1048 return RMAP_NOMATCH;
1049 }
1050
1051 /* Route map `vni' match statement. */
1052 static void *route_match_vni_compile(const char *arg)
1053 {
1054 vni_t *vni = NULL;
1055 char *end = NULL;
1056
1057 vni = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(vni_t));
1058
1059 *vni = strtoul(arg, &end, 10);
1060 if (*end != '\0') {
1061 XFREE(MTYPE_ROUTE_MAP_COMPILED, vni);
1062 return NULL;
1063 }
1064
1065 return vni;
1066 }
1067
1068 /* Free route map's compiled `vni' value. */
1069 static void route_match_vni_free(void *rule)
1070 {
1071 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1072 }
1073
1074 /* Route map commands for vni matching. */
1075 static const struct route_map_rule_cmd route_match_evpn_vni_cmd = {
1076 "evpn vni",
1077 route_match_vni,
1078 route_match_vni_compile,
1079 route_match_vni_free
1080 };
1081
1082 /* `match evpn route-type' */
1083
1084 /* Match function should return 1 if match is success else return
1085 zero. */
1086 static enum route_map_cmd_result_t
1087 route_match_evpn_route_type(void *rule, const struct prefix *pfx, void *object)
1088 {
1089 uint8_t route_type = 0;
1090
1091 route_type = *((uint8_t *)rule);
1092
1093 if (route_type == pfx->u.prefix_evpn.route_type)
1094 return RMAP_MATCH;
1095
1096 return RMAP_NOMATCH;
1097 }
1098
1099 /* Route map `route-type' match statement. */
1100 static void *route_match_evpn_route_type_compile(const char *arg)
1101 {
1102 uint8_t *route_type = NULL;
1103
1104 route_type = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
1105
1106 if (strncmp(arg, "ea", 2) == 0)
1107 *route_type = BGP_EVPN_AD_ROUTE;
1108 else if (strncmp(arg, "ma", 2) == 0)
1109 *route_type = BGP_EVPN_MAC_IP_ROUTE;
1110 else if (strncmp(arg, "mu", 2) == 0)
1111 *route_type = BGP_EVPN_IMET_ROUTE;
1112 else if (strncmp(arg, "es", 2) == 0)
1113 *route_type = BGP_EVPN_ES_ROUTE;
1114 else
1115 *route_type = BGP_EVPN_IP_PREFIX_ROUTE;
1116
1117 return route_type;
1118 }
1119
1120 /* Free route map's compiled `route-type' value. */
1121 static void route_match_evpn_route_type_free(void *rule)
1122 {
1123 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1124 }
1125
1126 /* Route map commands for evpn route-type matching. */
1127 static const struct route_map_rule_cmd route_match_evpn_route_type_cmd = {
1128 "evpn route-type",
1129 route_match_evpn_route_type,
1130 route_match_evpn_route_type_compile,
1131 route_match_evpn_route_type_free
1132 };
1133
1134 /* `match rd' */
1135
1136 /* Match function should return 1 if match is success else return zero. */
1137 static enum route_map_cmd_result_t
1138 route_match_rd(void *rule, const struct prefix *prefix, void *object)
1139 {
1140 struct prefix_rd *prd_rule = NULL;
1141 const struct prefix_rd *prd_route = NULL;
1142 struct bgp_path_info *path = NULL;
1143
1144 if (prefix->family != AF_EVPN)
1145 return RMAP_NOMATCH;
1146
1147 prd_rule = (struct prefix_rd *)rule;
1148 path = (struct bgp_path_info *)object;
1149
1150 if (path->net == NULL || path->net->pdest == NULL)
1151 return RMAP_NOMATCH;
1152
1153 prd_route = (struct prefix_rd *)bgp_dest_get_prefix(path->net->pdest);
1154 if (memcmp(prd_route->val, prd_rule->val, ECOMMUNITY_SIZE) == 0)
1155 return RMAP_MATCH;
1156
1157 return RMAP_NOMATCH;
1158 }
1159
1160 /* Route map `rd' match statement. */
1161 static void *route_match_rd_compile(const char *arg)
1162 {
1163 struct prefix_rd *prd;
1164 int ret;
1165
1166 prd = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct prefix_rd));
1167
1168 ret = str2prefix_rd(arg, prd);
1169 if (!ret) {
1170 XFREE(MTYPE_ROUTE_MAP_COMPILED, prd);
1171 return NULL;
1172 }
1173
1174 return prd;
1175 }
1176
1177 /* Free route map's compiled `rd' value. */
1178 static void route_match_rd_free(void *rule)
1179 {
1180 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1181 }
1182
1183 /* Route map commands for rd matching. */
1184 static const struct route_map_rule_cmd route_match_evpn_rd_cmd = {
1185 "evpn rd",
1186 route_match_rd,
1187 route_match_rd_compile,
1188 route_match_rd_free
1189 };
1190
1191 static enum route_map_cmd_result_t
1192 route_set_evpn_gateway_ip(void *rule, const struct prefix *prefix, void *object)
1193 {
1194 struct ipaddr *gw_ip = rule;
1195 struct bgp_path_info *path;
1196 struct prefix_evpn *evp;
1197
1198 if (prefix->family != AF_EVPN)
1199 return RMAP_OKAY;
1200
1201 evp = (struct prefix_evpn *)prefix;
1202 if (evp->prefix.route_type != BGP_EVPN_IP_PREFIX_ROUTE)
1203 return RMAP_OKAY;
1204
1205 if ((is_evpn_prefix_ipaddr_v4(evp) && IPADDRSZ(gw_ip) != 4)
1206 || (is_evpn_prefix_ipaddr_v6(evp) && IPADDRSZ(gw_ip) != 16))
1207 return RMAP_OKAY;
1208
1209 path = object;
1210
1211 /* Set gateway-ip value. */
1212 path->attr->evpn_overlay.type = OVERLAY_INDEX_GATEWAY_IP;
1213 memcpy(&path->attr->evpn_overlay.gw_ip, &gw_ip->ip.addr,
1214 IPADDRSZ(gw_ip));
1215
1216 return RMAP_OKAY;
1217 }
1218
1219 /*
1220 * Route map `evpn gateway-ip' compile function.
1221 * Given string is converted to struct ipaddr structure
1222 */
1223 static void *route_set_evpn_gateway_ip_compile(const char *arg)
1224 {
1225 struct ipaddr *gw_ip = NULL;
1226 int ret;
1227
1228 gw_ip = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct ipaddr));
1229
1230 ret = str2ipaddr(arg, gw_ip);
1231 if (ret < 0) {
1232 XFREE(MTYPE_ROUTE_MAP_COMPILED, gw_ip);
1233 return NULL;
1234 }
1235 return gw_ip;
1236 }
1237
1238 /* Free route map's compiled `evpn gateway_ip' value. */
1239 static void route_set_evpn_gateway_ip_free(void *rule)
1240 {
1241 struct ipaddr *gw_ip = rule;
1242
1243 XFREE(MTYPE_ROUTE_MAP_COMPILED, gw_ip);
1244 }
1245
1246 /* Route map commands for set evpn gateway-ip ipv4. */
1247 struct route_map_rule_cmd route_set_evpn_gateway_ip_ipv4_cmd = {
1248 "evpn gateway-ip ipv4", route_set_evpn_gateway_ip,
1249 route_set_evpn_gateway_ip_compile, route_set_evpn_gateway_ip_free};
1250
1251 /* Route map commands for set evpn gateway-ip ipv6. */
1252 struct route_map_rule_cmd route_set_evpn_gateway_ip_ipv6_cmd = {
1253 "evpn gateway-ip ipv6", route_set_evpn_gateway_ip,
1254 route_set_evpn_gateway_ip_compile, route_set_evpn_gateway_ip_free};
1255
1256 /* Route map commands for VRF route leak with source vrf matching */
1257 static enum route_map_cmd_result_t
1258 route_match_vrl_source_vrf(void *rule, const struct prefix *prefix,
1259 void *object)
1260 {
1261 struct bgp_path_info *path;
1262 char *vrf_name;
1263
1264 vrf_name = rule;
1265 path = (struct bgp_path_info *)object;
1266
1267 if (strncmp(vrf_name, "n/a", VRF_NAMSIZ) == 0)
1268 return RMAP_NOMATCH;
1269
1270 if (path->extra == NULL || path->extra->bgp_orig == NULL)
1271 return RMAP_NOMATCH;
1272
1273 if (strncmp(vrf_name, vrf_id_to_name(path->extra->bgp_orig->vrf_id),
1274 VRF_NAMSIZ)
1275 == 0)
1276 return RMAP_MATCH;
1277
1278 return RMAP_NOMATCH;
1279 }
1280
1281 static void *route_match_vrl_source_vrf_compile(const char *arg)
1282 {
1283 uint8_t *vrf_name = NULL;
1284
1285 vrf_name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1286
1287 return vrf_name;
1288 }
1289
1290 /* Free route map's compiled `route-type' value. */
1291 static void route_match_vrl_source_vrf_free(void *rule)
1292 {
1293 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1294 }
1295
1296 static const struct route_map_rule_cmd route_match_vrl_source_vrf_cmd = {
1297 "source-vrf",
1298 route_match_vrl_source_vrf,
1299 route_match_vrl_source_vrf_compile,
1300 route_match_vrl_source_vrf_free
1301 };
1302
1303 /* `match alias` */
1304 static enum route_map_cmd_result_t
1305 route_match_alias(void *rule, const struct prefix *prefix, void *object)
1306 {
1307 char *alias = rule;
1308 struct bgp_path_info *path = object;
1309 char **communities;
1310 int num;
1311 bool found;
1312
1313 if (bgp_attr_get_community(path->attr)) {
1314 found = false;
1315 frrstr_split(bgp_attr_get_community(path->attr)->str, " ",
1316 &communities, &num);
1317 for (int i = 0; i < num; i++) {
1318 const char *com2alias =
1319 bgp_community2alias(communities[i]);
1320 if (!found && strcmp(alias, com2alias) == 0)
1321 found = true;
1322 XFREE(MTYPE_TMP, communities[i]);
1323 }
1324 XFREE(MTYPE_TMP, communities);
1325 if (found)
1326 return RMAP_MATCH;
1327 }
1328
1329 if (bgp_attr_get_lcommunity(path->attr)) {
1330 found = false;
1331 frrstr_split(bgp_attr_get_lcommunity(path->attr)->str, " ",
1332 &communities, &num);
1333 for (int i = 0; i < num; i++) {
1334 const char *com2alias =
1335 bgp_community2alias(communities[i]);
1336 if (!found && strcmp(alias, com2alias) == 0)
1337 found = true;
1338 XFREE(MTYPE_TMP, communities[i]);
1339 }
1340 XFREE(MTYPE_TMP, communities);
1341 if (found)
1342 return RMAP_MATCH;
1343 }
1344
1345 return RMAP_NOMATCH;
1346 }
1347
1348 static void *route_match_alias_compile(const char *arg)
1349 {
1350
1351 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1352 }
1353
1354 static void route_match_alias_free(void *rule)
1355 {
1356 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1357 }
1358
1359 static const struct route_map_rule_cmd route_match_alias_cmd = {
1360 "alias", route_match_alias, route_match_alias_compile,
1361 route_match_alias_free};
1362
1363 /* `match local-preference LOCAL-PREF' */
1364
1365 /* Match function return 1 if match is success else return zero. */
1366 static enum route_map_cmd_result_t
1367 route_match_local_pref(void *rule, const struct prefix *prefix, void *object)
1368 {
1369 uint32_t *local_pref;
1370 struct bgp_path_info *path;
1371
1372 local_pref = rule;
1373 path = object;
1374
1375 if (path->attr->local_pref == *local_pref)
1376 return RMAP_MATCH;
1377 else
1378 return RMAP_NOMATCH;
1379 }
1380
1381 /*
1382 * Route map `match local-preference' match statement.
1383 * `arg' is local-pref value
1384 */
1385 static void *route_match_local_pref_compile(const char *arg)
1386 {
1387 uint32_t *local_pref;
1388 char *endptr = NULL;
1389 unsigned long tmpval;
1390
1391 errno = 0;
1392 tmpval = strtoul(arg, &endptr, 10);
1393 if (*endptr != '\0' || errno || tmpval > UINT32_MAX)
1394 return NULL;
1395
1396 local_pref = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1397
1398 *local_pref = tmpval;
1399 return local_pref;
1400 }
1401
1402 /* Free route map's compiled `match local-preference' value. */
1403 static void route_match_local_pref_free(void *rule)
1404 {
1405 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1406 }
1407
1408 /* Route map commands for metric matching. */
1409 static const struct route_map_rule_cmd route_match_local_pref_cmd = {
1410 "local-preference",
1411 route_match_local_pref,
1412 route_match_local_pref_compile,
1413 route_match_local_pref_free
1414 };
1415
1416 /* `match metric METRIC' */
1417
1418 /* Match function return 1 if match is success else return zero. */
1419 static enum route_map_cmd_result_t
1420 route_match_metric(void *rule, const struct prefix *prefix, void *object)
1421 {
1422 struct rmap_value *rv;
1423 struct bgp_path_info *path;
1424
1425 rv = rule;
1426 path = object;
1427 return route_value_match(rv, path->attr->med);
1428 }
1429
1430 /* Route map commands for metric matching. */
1431 static const struct route_map_rule_cmd route_match_metric_cmd = {
1432 "metric",
1433 route_match_metric,
1434 route_value_compile,
1435 route_value_free,
1436 };
1437
1438 /* `match as-path ASPATH' */
1439
1440 /* Match function for as-path match. I assume given object is */
1441 static enum route_map_cmd_result_t
1442 route_match_aspath(void *rule, const struct prefix *prefix, void *object)
1443 {
1444
1445 struct as_list *as_list;
1446 struct bgp_path_info *path;
1447
1448 as_list = as_list_lookup((char *)rule);
1449 if (as_list == NULL)
1450 return RMAP_NOMATCH;
1451
1452 path = object;
1453
1454 /* Perform match. */
1455 return ((as_list_apply(as_list, path->attr->aspath) == AS_FILTER_DENY)
1456 ? RMAP_NOMATCH
1457 : RMAP_MATCH);
1458 }
1459
1460 /* Compile function for as-path match. */
1461 static void *route_match_aspath_compile(const char *arg)
1462 {
1463 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1464 }
1465
1466 /* Compile function for as-path match. */
1467 static void route_match_aspath_free(void *rule)
1468 {
1469 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1470 }
1471
1472 /* Route map commands for aspath matching. */
1473 static const struct route_map_rule_cmd route_match_aspath_cmd = {
1474 "as-path",
1475 route_match_aspath,
1476 route_match_aspath_compile,
1477 route_match_aspath_free
1478 };
1479
1480 /* `match community COMMUNIY' */
1481 struct rmap_community {
1482 char *name;
1483 uint32_t name_hash;
1484 int exact;
1485 };
1486
1487 /* Match function for community match. */
1488 static enum route_map_cmd_result_t
1489 route_match_community(void *rule, const struct prefix *prefix, void *object)
1490 {
1491 struct community_list *list;
1492 struct bgp_path_info *path;
1493 struct rmap_community *rcom = rule;
1494
1495 path = object;
1496 rcom = rule;
1497
1498 list = community_list_lookup(bgp_clist, rcom->name, rcom->name_hash,
1499 COMMUNITY_LIST_MASTER);
1500 if (!list)
1501 return RMAP_NOMATCH;
1502
1503 if (rcom->exact) {
1504 if (community_list_exact_match(
1505 bgp_attr_get_community(path->attr), list))
1506 return RMAP_MATCH;
1507 } else {
1508 if (community_list_match(bgp_attr_get_community(path->attr),
1509 list))
1510 return RMAP_MATCH;
1511 }
1512
1513 return RMAP_NOMATCH;
1514 }
1515
1516 /* Compile function for community match. */
1517 static void *route_match_community_compile(const char *arg)
1518 {
1519 struct rmap_community *rcom;
1520 int len;
1521 char *p;
1522
1523 rcom = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_community));
1524
1525 p = strchr(arg, ' ');
1526 if (p) {
1527 len = p - arg;
1528 rcom->name = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, len + 1);
1529 memcpy(rcom->name, arg, len);
1530 rcom->exact = 1;
1531 } else {
1532 rcom->name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1533 rcom->exact = 0;
1534 }
1535
1536 rcom->name_hash = bgp_clist_hash_key(rcom->name);
1537 return rcom;
1538 }
1539
1540 /* Compile function for community match. */
1541 static void route_match_community_free(void *rule)
1542 {
1543 struct rmap_community *rcom = rule;
1544
1545 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom->name);
1546 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom);
1547 }
1548
1549 /*
1550 * In routemap processing there is a need to add the
1551 * name as a rule_key in the dependency table. Routemap
1552 * lib is unaware of rule_key when exact-match clause
1553 * is in use. routemap lib uses the compiled output to
1554 * get the rule_key value.
1555 */
1556 static void *route_match_get_community_key(void *rule)
1557 {
1558 struct rmap_community *rcom;
1559
1560 rcom = rule;
1561 return rcom->name;
1562 }
1563
1564
1565 /* Route map commands for community matching. */
1566 static const struct route_map_rule_cmd route_match_community_cmd = {
1567 "community",
1568 route_match_community,
1569 route_match_community_compile,
1570 route_match_community_free,
1571 route_match_get_community_key
1572 };
1573
1574 /* Match function for lcommunity match. */
1575 static enum route_map_cmd_result_t
1576 route_match_lcommunity(void *rule, const struct prefix *prefix, void *object)
1577 {
1578 struct community_list *list;
1579 struct bgp_path_info *path;
1580 struct rmap_community *rcom = rule;
1581
1582 path = object;
1583
1584 list = community_list_lookup(bgp_clist, rcom->name, rcom->name_hash,
1585 LARGE_COMMUNITY_LIST_MASTER);
1586 if (!list)
1587 return RMAP_NOMATCH;
1588
1589 if (rcom->exact) {
1590 if (lcommunity_list_exact_match(
1591 bgp_attr_get_lcommunity(path->attr), list))
1592 return RMAP_MATCH;
1593 } else {
1594 if (lcommunity_list_match(bgp_attr_get_lcommunity(path->attr),
1595 list))
1596 return RMAP_MATCH;
1597 }
1598
1599 return RMAP_NOMATCH;
1600 }
1601
1602 /* Compile function for community match. */
1603 static void *route_match_lcommunity_compile(const char *arg)
1604 {
1605 struct rmap_community *rcom;
1606 int len;
1607 char *p;
1608
1609 rcom = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_community));
1610
1611 p = strchr(arg, ' ');
1612 if (p) {
1613 len = p - arg;
1614 rcom->name = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, len + 1);
1615 memcpy(rcom->name, arg, len);
1616 rcom->exact = 1;
1617 } else {
1618 rcom->name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1619 rcom->exact = 0;
1620 }
1621
1622 rcom->name_hash = bgp_clist_hash_key(rcom->name);
1623 return rcom;
1624 }
1625
1626 /* Compile function for community match. */
1627 static void route_match_lcommunity_free(void *rule)
1628 {
1629 struct rmap_community *rcom = rule;
1630
1631 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom->name);
1632 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom);
1633 }
1634
1635 /* Route map commands for community matching. */
1636 static const struct route_map_rule_cmd route_match_lcommunity_cmd = {
1637 "large-community",
1638 route_match_lcommunity,
1639 route_match_lcommunity_compile,
1640 route_match_lcommunity_free,
1641 route_match_get_community_key
1642 };
1643
1644
1645 /* Match function for extcommunity match. */
1646 static enum route_map_cmd_result_t
1647 route_match_ecommunity(void *rule, const struct prefix *prefix, void *object)
1648 {
1649 struct community_list *list;
1650 struct bgp_path_info *path;
1651 struct rmap_community *rcom = rule;
1652
1653 path = object;
1654
1655 list = community_list_lookup(bgp_clist, rcom->name, rcom->name_hash,
1656 EXTCOMMUNITY_LIST_MASTER);
1657 if (!list)
1658 return RMAP_NOMATCH;
1659
1660 if (ecommunity_list_match(bgp_attr_get_ecommunity(path->attr), list))
1661 return RMAP_MATCH;
1662
1663 return RMAP_NOMATCH;
1664 }
1665
1666 /* Compile function for extcommunity match. */
1667 static void *route_match_ecommunity_compile(const char *arg)
1668 {
1669 struct rmap_community *rcom;
1670
1671 rcom = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_community));
1672 rcom->name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1673 rcom->name_hash = bgp_clist_hash_key(rcom->name);
1674
1675 return rcom;
1676 }
1677
1678 /* Compile function for extcommunity match. */
1679 static void route_match_ecommunity_free(void *rule)
1680 {
1681 struct rmap_community *rcom = rule;
1682
1683 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom->name);
1684 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom);
1685 }
1686
1687 /* Route map commands for community matching. */
1688 static const struct route_map_rule_cmd route_match_ecommunity_cmd = {
1689 "extcommunity",
1690 route_match_ecommunity,
1691 route_match_ecommunity_compile,
1692 route_match_ecommunity_free
1693 };
1694
1695 /* `match nlri` and `set nlri` are replaced by `address-family ipv4`
1696 and `address-family vpnv4'. */
1697
1698 /* `match origin' */
1699 static enum route_map_cmd_result_t
1700 route_match_origin(void *rule, const struct prefix *prefix, void *object)
1701 {
1702 uint8_t *origin;
1703 struct bgp_path_info *path;
1704
1705 origin = rule;
1706 path = object;
1707
1708 if (path->attr->origin == *origin)
1709 return RMAP_MATCH;
1710
1711 return RMAP_NOMATCH;
1712 }
1713
1714 static void *route_match_origin_compile(const char *arg)
1715 {
1716 uint8_t *origin;
1717
1718 origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
1719
1720 if (strcmp(arg, "igp") == 0)
1721 *origin = 0;
1722 else if (strcmp(arg, "egp") == 0)
1723 *origin = 1;
1724 else
1725 *origin = 2;
1726
1727 return origin;
1728 }
1729
1730 /* Free route map's compiled `ip address' value. */
1731 static void route_match_origin_free(void *rule)
1732 {
1733 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1734 }
1735
1736 /* Route map commands for origin matching. */
1737 static const struct route_map_rule_cmd route_match_origin_cmd = {
1738 "origin",
1739 route_match_origin,
1740 route_match_origin_compile,
1741 route_match_origin_free
1742 };
1743
1744 /* match probability { */
1745
1746 static enum route_map_cmd_result_t
1747 route_match_probability(void *rule, const struct prefix *prefix, void *object)
1748 {
1749 long r = frr_weak_random();
1750
1751 switch (*(long *)rule) {
1752 case 0:
1753 break;
1754 case RAND_MAX:
1755 return RMAP_MATCH;
1756 default:
1757 if (r < *(long *)rule) {
1758 return RMAP_MATCH;
1759 }
1760 }
1761
1762 return RMAP_NOMATCH;
1763 }
1764
1765 static void *route_match_probability_compile(const char *arg)
1766 {
1767 long *lobule;
1768 unsigned perc;
1769
1770 perc = atoi(arg);
1771 lobule = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(long));
1772
1773 switch (perc) {
1774 case 0:
1775 *lobule = 0;
1776 break;
1777 case 100:
1778 *lobule = RAND_MAX;
1779 break;
1780 default:
1781 *lobule = RAND_MAX / 100 * perc;
1782 }
1783
1784 return lobule;
1785 }
1786
1787 static void route_match_probability_free(void *rule)
1788 {
1789 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1790 }
1791
1792 static const struct route_map_rule_cmd route_match_probability_cmd = {
1793 "probability",
1794 route_match_probability,
1795 route_match_probability_compile,
1796 route_match_probability_free
1797 };
1798
1799 /* `match interface IFNAME' */
1800 /* Match function should return 1 if match is success else return
1801 zero. */
1802 static enum route_map_cmd_result_t
1803 route_match_interface(void *rule, const struct prefix *prefix, void *object)
1804 {
1805 struct interface *ifp;
1806 struct bgp_path_info *path;
1807
1808 path = object;
1809
1810 if (!path || !path->peer || !path->peer->bgp)
1811 return RMAP_NOMATCH;
1812
1813 ifp = if_lookup_by_name((char *)rule, path->peer->bgp->vrf_id);
1814
1815 if (ifp == NULL || ifp->ifindex != path->attr->nh_ifindex)
1816 return RMAP_NOMATCH;
1817
1818 return RMAP_MATCH;
1819 }
1820
1821 /* Route map `interface' match statement. `arg' should be
1822 interface name. */
1823 static void *route_match_interface_compile(const char *arg)
1824 {
1825 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
1826 }
1827
1828 /* Free route map's compiled `interface' value. */
1829 static void route_match_interface_free(void *rule)
1830 {
1831 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1832 }
1833
1834 /* Route map commands for ip address matching. */
1835 static const struct route_map_rule_cmd route_match_interface_cmd = {
1836 "interface",
1837 route_match_interface,
1838 route_match_interface_compile,
1839 route_match_interface_free
1840 };
1841
1842 /* } */
1843
1844 /* `set ip next-hop IP_ADDRESS' */
1845
1846 /* Match function return 1 if match is success else return zero. */
1847 static enum route_map_cmd_result_t
1848 route_match_tag(void *rule, const struct prefix *prefix, void *object)
1849 {
1850 route_tag_t *tag;
1851 struct bgp_path_info *path;
1852
1853 tag = rule;
1854 path = object;
1855
1856 return ((path->attr->tag == *tag) ? RMAP_MATCH : RMAP_NOMATCH);
1857 }
1858
1859
1860 /* Route map commands for tag matching. */
1861 static const struct route_map_rule_cmd route_match_tag_cmd = {
1862 "tag",
1863 route_match_tag,
1864 route_map_rule_tag_compile,
1865 route_map_rule_tag_free,
1866 };
1867
1868 static enum route_map_cmd_result_t
1869 route_set_srte_color(void *rule, const struct prefix *prefix, void *object)
1870 {
1871 uint32_t *srte_color = rule;
1872 struct bgp_path_info *path;
1873
1874 path = object;
1875
1876 path->attr->srte_color = *srte_color;
1877 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_SRTE_COLOR);
1878
1879 return RMAP_OKAY;
1880 }
1881
1882 /* Route map `sr-te color' compile function */
1883 static void *route_set_srte_color_compile(const char *arg)
1884 {
1885 uint32_t *color;
1886
1887 color = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
1888 *color = atoi(arg);
1889
1890 return color;
1891 }
1892
1893 /* Free route map's compiled `sr-te color' value. */
1894 static void route_set_srte_color_free(void *rule)
1895 {
1896 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
1897 }
1898
1899 /* Route map commands for sr-te color set. */
1900 struct route_map_rule_cmd route_set_srte_color_cmd = {
1901 "sr-te color", route_set_srte_color, route_set_srte_color_compile,
1902 route_set_srte_color_free};
1903
1904 /* Set nexthop to object. object must be pointer to struct attr. */
1905 struct rmap_ip_nexthop_set {
1906 struct in_addr *address;
1907 int peer_address;
1908 int unchanged;
1909 };
1910
1911 static enum route_map_cmd_result_t
1912 route_set_ip_nexthop(void *rule, const struct prefix *prefix, void *object)
1913 {
1914 struct rmap_ip_nexthop_set *rins = rule;
1915 struct bgp_path_info *path;
1916 struct peer *peer;
1917
1918 if (prefix->family == AF_INET6)
1919 return RMAP_OKAY;
1920
1921 path = object;
1922 peer = path->peer;
1923
1924 if (rins->unchanged) {
1925 SET_FLAG(path->attr->rmap_change_flags,
1926 BATTR_RMAP_NEXTHOP_UNCHANGED);
1927 } else if (rins->peer_address) {
1928 if ((CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IN)
1929 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IMPORT))
1930 && peer->su_remote
1931 && sockunion_family(peer->su_remote) == AF_INET) {
1932 path->attr->nexthop.s_addr =
1933 sockunion2ip(peer->su_remote);
1934 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP);
1935 } else if (CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_OUT)) {
1936 /* The next hop value will be set as part of
1937 * packet rewrite. Set the flags here to indicate
1938 * that rewrite needs to be done.
1939 * Also, clear the value.
1940 */
1941 SET_FLAG(path->attr->rmap_change_flags,
1942 BATTR_RMAP_NEXTHOP_PEER_ADDRESS);
1943 path->attr->nexthop.s_addr = INADDR_ANY;
1944 }
1945 } else {
1946 /* Set next hop value. */
1947 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP);
1948 path->attr->nexthop = *rins->address;
1949 SET_FLAG(path->attr->rmap_change_flags,
1950 BATTR_RMAP_IPV4_NHOP_CHANGED);
1951 /* case for MP-BGP : MPLS VPN */
1952 path->attr->mp_nexthop_global_in = *rins->address;
1953 path->attr->mp_nexthop_len = sizeof(*rins->address);
1954 }
1955
1956 return RMAP_OKAY;
1957 }
1958
1959 /* Route map `ip nexthop' compile function. Given string is converted
1960 to struct in_addr structure. */
1961 static void *route_set_ip_nexthop_compile(const char *arg)
1962 {
1963 struct rmap_ip_nexthop_set *rins;
1964 struct in_addr *address = NULL;
1965 int peer_address = 0;
1966 int unchanged = 0;
1967 int ret;
1968
1969 if (strcmp(arg, "peer-address") == 0)
1970 peer_address = 1;
1971 else if (strcmp(arg, "unchanged") == 0)
1972 unchanged = 1;
1973 else {
1974 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED,
1975 sizeof(struct in_addr));
1976 ret = inet_aton(arg, address);
1977
1978 if (ret == 0) {
1979 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
1980 return NULL;
1981 }
1982 }
1983
1984 rins = XCALLOC(MTYPE_ROUTE_MAP_COMPILED,
1985 sizeof(struct rmap_ip_nexthop_set));
1986
1987 rins->address = address;
1988 rins->peer_address = peer_address;
1989 rins->unchanged = unchanged;
1990
1991 return rins;
1992 }
1993
1994 /* Free route map's compiled `ip nexthop' value. */
1995 static void route_set_ip_nexthop_free(void *rule)
1996 {
1997 struct rmap_ip_nexthop_set *rins = rule;
1998
1999 XFREE(MTYPE_ROUTE_MAP_COMPILED, rins->address);
2000
2001 XFREE(MTYPE_ROUTE_MAP_COMPILED, rins);
2002 }
2003
2004 /* Route map commands for ip nexthop set. */
2005 static const struct route_map_rule_cmd route_set_ip_nexthop_cmd = {
2006 "ip next-hop",
2007 route_set_ip_nexthop,
2008 route_set_ip_nexthop_compile,
2009 route_set_ip_nexthop_free
2010 };
2011
2012 /* `set l3vpn next-hop encapsulation l3vpn gre' */
2013
2014 /* Set nexthop to object */
2015 struct rmap_l3vpn_nexthop_encapsulation_set {
2016 uint8_t protocol;
2017 };
2018
2019 static enum route_map_cmd_result_t
2020 route_set_l3vpn_nexthop_encapsulation(void *rule, const struct prefix *prefix,
2021 void *object)
2022 {
2023 struct rmap_l3vpn_nexthop_encapsulation_set *rins = rule;
2024 struct bgp_path_info *path;
2025
2026 path = object;
2027
2028 if (rins->protocol != IPPROTO_GRE)
2029 return RMAP_OKAY;
2030
2031 SET_FLAG(path->attr->rmap_change_flags, BATTR_RMAP_L3VPN_ACCEPT_GRE);
2032 return RMAP_OKAY;
2033 }
2034
2035 /* Route map `l3vpn nexthop encapsulation' compile function. */
2036 static void *route_set_l3vpn_nexthop_encapsulation_compile(const char *arg)
2037 {
2038 struct rmap_l3vpn_nexthop_encapsulation_set *rins;
2039
2040 rins = XCALLOC(MTYPE_ROUTE_MAP_COMPILED,
2041 sizeof(struct rmap_l3vpn_nexthop_encapsulation_set));
2042
2043 /* XXX ALL GRE modes are accepted for now: gre or ip6gre */
2044 rins->protocol = IPPROTO_GRE;
2045
2046 return rins;
2047 }
2048
2049 /* Free route map's compiled `ip nexthop' value. */
2050 static void route_set_l3vpn_nexthop_encapsulation_free(void *rule)
2051 {
2052 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2053 }
2054
2055 /* Route map commands for l3vpn next-hop encapsulation set. */
2056 static const struct route_map_rule_cmd
2057 route_set_l3vpn_nexthop_encapsulation_cmd = {
2058 "l3vpn next-hop encapsulation",
2059 route_set_l3vpn_nexthop_encapsulation,
2060 route_set_l3vpn_nexthop_encapsulation_compile,
2061 route_set_l3vpn_nexthop_encapsulation_free};
2062
2063 /* `set local-preference LOCAL_PREF' */
2064
2065 /* Set local preference. */
2066 static enum route_map_cmd_result_t
2067 route_set_local_pref(void *rule, const struct prefix *prefix, void *object)
2068 {
2069 struct rmap_value *rv;
2070 struct bgp_path_info *path;
2071 uint32_t locpref = 0;
2072
2073 /* Fetch routemap's rule information. */
2074 rv = rule;
2075 path = object;
2076
2077 /* Set local preference value. */
2078 if (path->attr->local_pref)
2079 locpref = path->attr->local_pref;
2080
2081 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF);
2082 path->attr->local_pref = route_value_adjust(rv, locpref, path->peer);
2083
2084 return RMAP_OKAY;
2085 }
2086
2087 /* Set local preference rule structure. */
2088 static const struct route_map_rule_cmd route_set_local_pref_cmd = {
2089 "local-preference",
2090 route_set_local_pref,
2091 route_value_compile,
2092 route_value_free,
2093 };
2094
2095 /* `set weight WEIGHT' */
2096
2097 /* Set weight. */
2098 static enum route_map_cmd_result_t
2099 route_set_weight(void *rule, const struct prefix *prefix, void *object)
2100 {
2101 struct rmap_value *rv;
2102 struct bgp_path_info *path;
2103
2104 /* Fetch routemap's rule information. */
2105 rv = rule;
2106 path = object;
2107
2108 /* Set weight value. */
2109 path->attr->weight = route_value_adjust(rv, 0, path->peer);
2110
2111 return RMAP_OKAY;
2112 }
2113
2114 /* Set local preference rule structure. */
2115 static const struct route_map_rule_cmd route_set_weight_cmd = {
2116 "weight",
2117 route_set_weight,
2118 route_value_compile,
2119 route_value_free,
2120 };
2121
2122 /* `set distance DISTANCE */
2123 static enum route_map_cmd_result_t
2124 route_set_distance(void *rule, const struct prefix *prefix, void *object)
2125 {
2126 struct bgp_path_info *path = object;
2127 struct rmap_value *rv = rule;
2128
2129 path->attr->distance = rv->value;
2130
2131 return RMAP_OKAY;
2132 }
2133
2134 /* set distance rule structure */
2135 static const struct route_map_rule_cmd route_set_distance_cmd = {
2136 "distance",
2137 route_set_distance,
2138 route_value_compile,
2139 route_value_free,
2140 };
2141
2142 /* `set metric METRIC' */
2143
2144 /* Set metric to attribute. */
2145 static enum route_map_cmd_result_t
2146 route_set_metric(void *rule, const struct prefix *prefix, void *object)
2147 {
2148 struct rmap_value *rv;
2149 struct bgp_path_info *path;
2150 uint32_t med = 0;
2151
2152 /* Fetch routemap's rule information. */
2153 rv = rule;
2154 path = object;
2155
2156 if (path->attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
2157 med = path->attr->med;
2158
2159 path->attr->med = route_value_adjust(rv, med, path->peer);
2160 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC);
2161
2162 return RMAP_OKAY;
2163 }
2164
2165 /* Set metric rule structure. */
2166 static const struct route_map_rule_cmd route_set_metric_cmd = {
2167 "metric",
2168 route_set_metric,
2169 route_value_compile,
2170 route_value_free,
2171 };
2172
2173 /* `set table (1-4294967295)' */
2174
2175 static enum route_map_cmd_result_t
2176 route_set_table_id(void *rule, const struct prefix *prefix,
2177
2178 void *object)
2179 {
2180 struct rmap_value *rv;
2181 struct bgp_path_info *path;
2182
2183 /* Fetch routemap's rule information. */
2184 rv = rule;
2185 path = object;
2186
2187 path->attr->rmap_table_id = rv->value;
2188
2189 return RMAP_OKAY;
2190 }
2191
2192 /* Set table_id rule structure. */
2193 static const struct route_map_rule_cmd route_set_table_id_cmd = {
2194 "table",
2195 route_set_table_id,
2196 route_value_compile,
2197 route_value_free
2198 };
2199
2200 /* `set as-path prepend ASPATH' */
2201
2202 /* For AS path prepend mechanism. */
2203 static enum route_map_cmd_result_t
2204 route_set_aspath_prepend(void *rule, const struct prefix *prefix, void *object)
2205 {
2206 struct aspath *aspath;
2207 struct aspath *new;
2208 struct bgp_path_info *path;
2209
2210 path = object;
2211
2212 if (path->attr->aspath->refcnt)
2213 new = aspath_dup(path->attr->aspath);
2214 else
2215 new = path->attr->aspath;
2216
2217 if ((uintptr_t)rule > 10) {
2218 aspath = rule;
2219 aspath_prepend(aspath, new);
2220 } else {
2221 as_t as = aspath_leftmost(new);
2222 if (as)
2223 new = aspath_add_seq_n(new, as, (uintptr_t)rule);
2224 }
2225
2226 path->attr->aspath = new;
2227
2228 return RMAP_OKAY;
2229 }
2230
2231 static void *route_set_aspath_prepend_compile(const char *arg)
2232 {
2233 unsigned int num;
2234
2235 if (sscanf(arg, "last-as %u", &num) == 1 && num > 0 && num <= 10)
2236 return (void *)(uintptr_t)num;
2237
2238 return route_aspath_compile(arg);
2239 }
2240
2241 static void route_set_aspath_prepend_free(void *rule)
2242 {
2243 if ((uintptr_t)rule > 10)
2244 route_aspath_free(rule);
2245 }
2246
2247
2248 /* Set as-path prepend rule structure. */
2249 static const struct route_map_rule_cmd route_set_aspath_prepend_cmd = {
2250 "as-path prepend",
2251 route_set_aspath_prepend,
2252 route_set_aspath_prepend_compile,
2253 route_set_aspath_prepend_free,
2254 };
2255
2256 /* `set as-path exclude ASn' */
2257
2258 /* For ASN exclude mechanism.
2259 * Iterate over ASns requested and filter them from the given AS_PATH one by
2260 * one.
2261 * Make a deep copy of existing AS_PATH, but for the first ASn only.
2262 */
2263 static enum route_map_cmd_result_t
2264 route_set_aspath_exclude(void *rule, const struct prefix *dummy, void *object)
2265 {
2266 struct aspath *new_path, *exclude_path;
2267 struct bgp_path_info *path;
2268
2269 exclude_path = rule;
2270 path = object;
2271 if (path->attr->aspath->refcnt)
2272 new_path = aspath_dup(path->attr->aspath);
2273 else
2274 new_path = path->attr->aspath;
2275 path->attr->aspath = aspath_filter_exclude(new_path, exclude_path);
2276
2277 return RMAP_OKAY;
2278 }
2279
2280 /* Set ASn exlude rule structure. */
2281 static const struct route_map_rule_cmd route_set_aspath_exclude_cmd = {
2282 "as-path exclude",
2283 route_set_aspath_exclude,
2284 route_aspath_compile,
2285 route_aspath_free,
2286 };
2287
2288 /* `set as-path replace AS-PATH` */
2289 static void *route_aspath_replace_compile(const char *arg)
2290 {
2291 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
2292 }
2293
2294 static void route_aspath_replace_free(void *rule)
2295 {
2296 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2297 }
2298
2299 static enum route_map_cmd_result_t
2300 route_set_aspath_replace(void *rule, const struct prefix *dummy, void *object)
2301 {
2302 struct aspath *aspath_new;
2303 const char *replace = rule;
2304 struct bgp_path_info *path = object;
2305 as_t own_asn = path->peer->change_local_as ? path->peer->change_local_as
2306 : path->peer->local_as;
2307
2308 if (path->peer->sort != BGP_PEER_EBGP) {
2309 zlog_warn(
2310 "`set as-path replace` is supported only for EBGP peers");
2311 return RMAP_NOOP;
2312 }
2313
2314 if (path->attr->aspath->refcnt)
2315 aspath_new = aspath_dup(path->attr->aspath);
2316 else
2317 aspath_new = path->attr->aspath;
2318
2319 if (strmatch(replace, "any")) {
2320 path->attr->aspath =
2321 aspath_replace_all_asn(aspath_new, own_asn);
2322 } else {
2323 as_t replace_asn = strtoul(replace, NULL, 10);
2324
2325 path->attr->aspath = aspath_replace_specific_asn(
2326 aspath_new, replace_asn, own_asn);
2327 }
2328
2329 aspath_free(aspath_new);
2330
2331 return RMAP_OKAY;
2332 }
2333
2334 static const struct route_map_rule_cmd route_set_aspath_replace_cmd = {
2335 "as-path replace",
2336 route_set_aspath_replace,
2337 route_aspath_replace_compile,
2338 route_aspath_replace_free,
2339 };
2340
2341 /* `set community COMMUNITY' */
2342 struct rmap_com_set {
2343 struct community *com;
2344 int additive;
2345 int none;
2346 };
2347
2348 /* For community set mechanism. */
2349 static enum route_map_cmd_result_t
2350 route_set_community(void *rule, const struct prefix *prefix, void *object)
2351 {
2352 struct rmap_com_set *rcs;
2353 struct bgp_path_info *path;
2354 struct attr *attr;
2355 struct community *new = NULL;
2356 struct community *old;
2357 struct community *merge;
2358
2359 rcs = rule;
2360 path = object;
2361 attr = path->attr;
2362 old = bgp_attr_get_community(attr);
2363
2364 /* "none" case. */
2365 if (rcs->none) {
2366 bgp_attr_set_community(attr, NULL);
2367 /* See the longer comment down below. */
2368 if (old && old->refcnt == 0)
2369 community_free(&old);
2370 return RMAP_OKAY;
2371 }
2372
2373 /* "additive" case. */
2374 if (rcs->additive && old) {
2375 merge = community_merge(community_dup(old), rcs->com);
2376
2377 new = community_uniq_sort(merge);
2378 community_free(&merge);
2379 } else
2380 new = community_dup(rcs->com);
2381
2382 /* HACK: if the old community is not intern'd,
2383 * we should free it here, or all reference to it may be
2384 * lost.
2385 * Really need to cleanup attribute caching sometime.
2386 */
2387 if (old && old->refcnt == 0)
2388 community_free(&old);
2389
2390 /* will be interned by caller if required */
2391 bgp_attr_set_community(attr, new);
2392
2393 return RMAP_OKAY;
2394 }
2395
2396 /* Compile function for set community. */
2397 static void *route_set_community_compile(const char *arg)
2398 {
2399 struct rmap_com_set *rcs;
2400 struct community *com = NULL;
2401 char *sp;
2402 int additive = 0;
2403 int none = 0;
2404
2405 if (strcmp(arg, "none") == 0)
2406 none = 1;
2407 else {
2408 sp = strstr(arg, "additive");
2409
2410 if (sp && sp > arg) {
2411 /* "additive" keyword is included. */
2412 additive = 1;
2413 *(sp - 1) = '\0';
2414 }
2415
2416 com = community_str2com(arg);
2417
2418 if (additive)
2419 *(sp - 1) = ' ';
2420
2421 if (!com)
2422 return NULL;
2423 }
2424
2425 rcs = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_com_set));
2426 rcs->com = com;
2427 rcs->additive = additive;
2428 rcs->none = none;
2429
2430 return rcs;
2431 }
2432
2433 /* Free function for set community. */
2434 static void route_set_community_free(void *rule)
2435 {
2436 struct rmap_com_set *rcs = rule;
2437
2438 if (rcs->com)
2439 community_free(&rcs->com);
2440 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcs);
2441 }
2442
2443 /* Set community rule structure. */
2444 static const struct route_map_rule_cmd route_set_community_cmd = {
2445 "community",
2446 route_set_community,
2447 route_set_community_compile,
2448 route_set_community_free,
2449 };
2450
2451 /* `set community COMMUNITY' */
2452 struct rmap_lcom_set {
2453 struct lcommunity *lcom;
2454 int additive;
2455 int none;
2456 };
2457
2458
2459 /* For lcommunity set mechanism. */
2460 static enum route_map_cmd_result_t
2461 route_set_lcommunity(void *rule, const struct prefix *prefix, void *object)
2462 {
2463 struct rmap_lcom_set *rcs;
2464 struct bgp_path_info *path;
2465 struct attr *attr;
2466 struct lcommunity *new = NULL;
2467 struct lcommunity *old;
2468 struct lcommunity *merge;
2469
2470 rcs = rule;
2471 path = object;
2472 attr = path->attr;
2473 old = bgp_attr_get_lcommunity(attr);
2474
2475 /* "none" case. */
2476 if (rcs->none) {
2477 bgp_attr_set_lcommunity(attr, NULL);
2478
2479 /* See the longer comment down below. */
2480 if (old && old->refcnt == 0)
2481 lcommunity_free(&old);
2482 return RMAP_OKAY;
2483 }
2484
2485 if (rcs->additive && old) {
2486 merge = lcommunity_merge(lcommunity_dup(old), rcs->lcom);
2487
2488 new = lcommunity_uniq_sort(merge);
2489 lcommunity_free(&merge);
2490 } else
2491 new = lcommunity_dup(rcs->lcom);
2492
2493 /* HACK: if the old large-community is not intern'd,
2494 * we should free it here, or all reference to it may be
2495 * lost.
2496 * Really need to cleanup attribute caching sometime.
2497 */
2498 if (old && old->refcnt == 0)
2499 lcommunity_free(&old);
2500
2501 /* will be intern()'d or attr_flush()'d by bgp_update_main() */
2502 bgp_attr_set_lcommunity(attr, new);
2503
2504 return RMAP_OKAY;
2505 }
2506
2507 /* Compile function for set community. */
2508 static void *route_set_lcommunity_compile(const char *arg)
2509 {
2510 struct rmap_lcom_set *rcs;
2511 struct lcommunity *lcom = NULL;
2512 char *sp;
2513 int additive = 0;
2514 int none = 0;
2515
2516 if (strcmp(arg, "none") == 0)
2517 none = 1;
2518 else {
2519 sp = strstr(arg, "additive");
2520
2521 if (sp && sp > arg) {
2522 /* "additive" keyworkd is included. */
2523 additive = 1;
2524 *(sp - 1) = '\0';
2525 }
2526
2527 lcom = lcommunity_str2com(arg);
2528
2529 if (additive)
2530 *(sp - 1) = ' ';
2531
2532 if (!lcom)
2533 return NULL;
2534 }
2535
2536 rcs = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_com_set));
2537 rcs->lcom = lcom;
2538 rcs->additive = additive;
2539 rcs->none = none;
2540
2541 return rcs;
2542 }
2543
2544 /* Free function for set lcommunity. */
2545 static void route_set_lcommunity_free(void *rule)
2546 {
2547 struct rmap_lcom_set *rcs = rule;
2548
2549 if (rcs->lcom) {
2550 lcommunity_free(&rcs->lcom);
2551 }
2552 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcs);
2553 }
2554
2555 /* Set community rule structure. */
2556 static const struct route_map_rule_cmd route_set_lcommunity_cmd = {
2557 "large-community",
2558 route_set_lcommunity,
2559 route_set_lcommunity_compile,
2560 route_set_lcommunity_free,
2561 };
2562
2563 /* `set large-comm-list (<1-99>|<100-500>|WORD) delete' */
2564
2565 /* For large community set mechanism. */
2566 static enum route_map_cmd_result_t
2567 route_set_lcommunity_delete(void *rule, const struct prefix *pfx, void *object)
2568 {
2569 struct community_list *list;
2570 struct lcommunity *merge;
2571 struct lcommunity *new;
2572 struct lcommunity *old;
2573 struct bgp_path_info *path;
2574 struct rmap_community *rcom = rule;
2575
2576 if (!rcom)
2577 return RMAP_OKAY;
2578
2579 path = object;
2580 list = community_list_lookup(bgp_clist, rcom->name, rcom->name_hash,
2581 LARGE_COMMUNITY_LIST_MASTER);
2582 old = bgp_attr_get_lcommunity(path->attr);
2583
2584 if (list && old) {
2585 merge = lcommunity_list_match_delete(lcommunity_dup(old), list);
2586 new = lcommunity_uniq_sort(merge);
2587 lcommunity_free(&merge);
2588
2589 /* HACK: if the old community is not intern'd,
2590 * we should free it here, or all reference to it may be
2591 * lost.
2592 * Really need to cleanup attribute caching sometime.
2593 */
2594 if (old->refcnt == 0)
2595 lcommunity_free(&old);
2596
2597 if (new->size == 0) {
2598 bgp_attr_set_lcommunity(path->attr, NULL);
2599 lcommunity_free(&new);
2600 } else {
2601 bgp_attr_set_lcommunity(path->attr, new);
2602 }
2603 }
2604
2605 return RMAP_OKAY;
2606 }
2607
2608 /* Compile function for set lcommunity. */
2609 static void *route_set_lcommunity_delete_compile(const char *arg)
2610 {
2611 struct rmap_community *rcom;
2612 char **splits;
2613 int num;
2614
2615 frrstr_split(arg, " ", &splits, &num);
2616
2617 rcom = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_community));
2618 rcom->name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, splits[0]);
2619 rcom->name_hash = bgp_clist_hash_key(rcom->name);
2620
2621 for (int i = 0; i < num; i++)
2622 XFREE(MTYPE_TMP, splits[i]);
2623 XFREE(MTYPE_TMP, splits);
2624
2625 return rcom;
2626 }
2627
2628 /* Free function for set lcommunity. */
2629 static void route_set_lcommunity_delete_free(void *rule)
2630 {
2631 struct rmap_community *rcom = rule;
2632
2633 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom->name);
2634 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom);
2635 }
2636
2637 /* Set lcommunity rule structure. */
2638 static const struct route_map_rule_cmd route_set_lcommunity_delete_cmd = {
2639 "large-comm-list",
2640 route_set_lcommunity_delete,
2641 route_set_lcommunity_delete_compile,
2642 route_set_lcommunity_delete_free,
2643 };
2644
2645
2646 /* `set comm-list (<1-99>|<100-500>|WORD) delete' */
2647
2648 /* For community set mechanism. */
2649 static enum route_map_cmd_result_t
2650 route_set_community_delete(void *rule, const struct prefix *prefix,
2651 void *object)
2652 {
2653 struct community_list *list;
2654 struct community *merge;
2655 struct community *new;
2656 struct community *old;
2657 struct bgp_path_info *path;
2658 struct rmap_community *rcom = rule;
2659
2660 if (!rcom)
2661 return RMAP_OKAY;
2662
2663 path = object;
2664 list = community_list_lookup(bgp_clist, rcom->name, rcom->name_hash,
2665 COMMUNITY_LIST_MASTER);
2666 old = bgp_attr_get_community(path->attr);
2667
2668 if (list && old) {
2669 merge = community_list_match_delete(community_dup(old), list);
2670 new = community_uniq_sort(merge);
2671 community_free(&merge);
2672
2673 /* HACK: if the old community is not intern'd,
2674 * we should free it here, or all reference to it may be
2675 * lost.
2676 * Really need to cleanup attribute caching sometime.
2677 */
2678 if (old->refcnt == 0)
2679 community_free(&old);
2680
2681 if (new->size == 0) {
2682 bgp_attr_set_community(path->attr, NULL);
2683 community_free(&new);
2684 } else {
2685 bgp_attr_set_community(path->attr, new);
2686 }
2687 }
2688
2689 return RMAP_OKAY;
2690 }
2691
2692 /* Compile function for set community. */
2693 static void *route_set_community_delete_compile(const char *arg)
2694 {
2695 struct rmap_community *rcom;
2696 char **splits;
2697 int num;
2698
2699 frrstr_split(arg, " ", &splits, &num);
2700
2701 rcom = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_community));
2702 rcom->name = XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, splits[0]);
2703 rcom->name_hash = bgp_clist_hash_key(rcom->name);
2704
2705 for (int i = 0; i < num; i++)
2706 XFREE(MTYPE_TMP, splits[i]);
2707 XFREE(MTYPE_TMP, splits);
2708
2709 return rcom;
2710 }
2711
2712 /* Free function for set community. */
2713 static void route_set_community_delete_free(void *rule)
2714 {
2715 struct rmap_community *rcom = rule;
2716
2717 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom->name);
2718 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcom);
2719 }
2720
2721 /* Set community rule structure. */
2722 static const struct route_map_rule_cmd route_set_community_delete_cmd = {
2723 "comm-list",
2724 route_set_community_delete,
2725 route_set_community_delete_compile,
2726 route_set_community_delete_free,
2727 };
2728
2729 /* `set extcommunity rt COMMUNITY' */
2730
2731 struct rmap_ecom_set {
2732 struct ecommunity *ecom;
2733 bool none;
2734 };
2735
2736 /* For community set mechanism. Used by _rt and _soo. */
2737 static enum route_map_cmd_result_t
2738 route_set_ecommunity(void *rule, const struct prefix *prefix, void *object)
2739 {
2740 struct rmap_ecom_set *rcs;
2741 struct ecommunity *new_ecom;
2742 struct ecommunity *old_ecom;
2743 struct bgp_path_info *path;
2744 struct attr *attr;
2745
2746 rcs = rule;
2747 path = object;
2748 attr = path->attr;
2749
2750 if (rcs->none) {
2751 bgp_attr_set_ecommunity(attr, NULL);
2752 return RMAP_OKAY;
2753 }
2754
2755 if (!rcs->ecom)
2756 return RMAP_OKAY;
2757
2758 /* We assume additive for Extended Community. */
2759 old_ecom = bgp_attr_get_ecommunity(path->attr);
2760
2761 if (old_ecom) {
2762 new_ecom =
2763 ecommunity_merge(ecommunity_dup(old_ecom), rcs->ecom);
2764
2765 /* old_ecom->refcnt = 1 => owned elsewhere, e.g.
2766 * bgp_update_receive()
2767 * ->refcnt = 0 => set by a previous route-map
2768 * statement */
2769 if (!old_ecom->refcnt)
2770 ecommunity_free(&old_ecom);
2771 } else
2772 new_ecom = ecommunity_dup(rcs->ecom);
2773
2774 /* will be intern()'d or attr_flush()'d by bgp_update_main() */
2775 bgp_attr_set_ecommunity(path->attr, new_ecom);
2776
2777 return RMAP_OKAY;
2778 }
2779
2780 static void *route_set_ecommunity_none_compile(const char *arg)
2781 {
2782 struct rmap_ecom_set *rcs;
2783 bool none = false;
2784
2785 if (strncmp(arg, "none", 4) == 0)
2786 none = true;
2787
2788 rcs = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_ecom_set));
2789 rcs->ecom = NULL;
2790 rcs->none = none;
2791
2792 return rcs;
2793 }
2794
2795 static void *route_set_ecommunity_rt_compile(const char *arg)
2796 {
2797 struct rmap_ecom_set *rcs;
2798 struct ecommunity *ecom;
2799
2800 ecom = ecommunity_str2com(arg, ECOMMUNITY_ROUTE_TARGET, 0);
2801 if (!ecom)
2802 return NULL;
2803
2804 rcs = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_ecom_set));
2805 rcs->ecom = ecommunity_intern(ecom);
2806 rcs->none = false;
2807
2808 return rcs;
2809 }
2810
2811 /* Free function for set community. Used by _rt and _soo */
2812 static void route_set_ecommunity_free(void *rule)
2813 {
2814 struct rmap_ecom_set *rcs = rule;
2815
2816 if (rcs->ecom)
2817 ecommunity_unintern(&rcs->ecom);
2818
2819 XFREE(MTYPE_ROUTE_MAP_COMPILED, rcs);
2820 }
2821
2822 static const struct route_map_rule_cmd route_set_ecommunity_none_cmd = {
2823 "extcommunity",
2824 route_set_ecommunity,
2825 route_set_ecommunity_none_compile,
2826 route_set_ecommunity_free,
2827 };
2828
2829 /* Set community rule structure. */
2830 static const struct route_map_rule_cmd route_set_ecommunity_rt_cmd = {
2831 "extcommunity rt",
2832 route_set_ecommunity,
2833 route_set_ecommunity_rt_compile,
2834 route_set_ecommunity_free,
2835 };
2836
2837 /* `set extcommunity soo COMMUNITY' */
2838
2839 /* Compile function for set community. */
2840 static void *route_set_ecommunity_soo_compile(const char *arg)
2841 {
2842 struct rmap_ecom_set *rcs;
2843 struct ecommunity *ecom;
2844
2845 ecom = ecommunity_str2com(arg, ECOMMUNITY_SITE_ORIGIN, 0);
2846 if (!ecom)
2847 return NULL;
2848
2849 rcs = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct rmap_ecom_set));
2850 rcs->ecom = ecommunity_intern(ecom);
2851 rcs->none = false;
2852
2853 return rcs;
2854 }
2855
2856 /* Set community rule structure. */
2857 static const struct route_map_rule_cmd route_set_ecommunity_soo_cmd = {
2858 "extcommunity soo",
2859 route_set_ecommunity,
2860 route_set_ecommunity_soo_compile,
2861 route_set_ecommunity_free,
2862 };
2863
2864 /* `set extcommunity bandwidth' */
2865
2866 struct rmap_ecomm_lb_set {
2867 uint8_t lb_type;
2868 #define RMAP_ECOMM_LB_SET_VALUE 1
2869 #define RMAP_ECOMM_LB_SET_CUMUL 2
2870 #define RMAP_ECOMM_LB_SET_NUM_MPATH 3
2871 bool non_trans;
2872 uint32_t bw;
2873 };
2874
2875 static enum route_map_cmd_result_t
2876 route_set_ecommunity_lb(void *rule, const struct prefix *prefix, void *object)
2877 {
2878 struct rmap_ecomm_lb_set *rels = rule;
2879 struct bgp_path_info *path;
2880 struct peer *peer;
2881 struct ecommunity ecom_lb = {0};
2882 struct ecommunity_val lb_eval;
2883 uint32_t bw_bytes = 0;
2884 uint16_t mpath_count = 0;
2885 struct ecommunity *new_ecom;
2886 struct ecommunity *old_ecom;
2887 as_t as;
2888
2889 path = object;
2890 peer = path->peer;
2891 if (!peer || !peer->bgp)
2892 return RMAP_ERROR;
2893
2894 /* Build link bandwidth extended community */
2895 as = (peer->bgp->as > BGP_AS_MAX) ? BGP_AS_TRANS : peer->bgp->as;
2896 if (rels->lb_type == RMAP_ECOMM_LB_SET_VALUE) {
2897 bw_bytes = ((uint64_t)rels->bw * 1000 * 1000) / 8;
2898 } else if (rels->lb_type == RMAP_ECOMM_LB_SET_CUMUL) {
2899 /* process this only for the best path. */
2900 if (!CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
2901 return RMAP_OKAY;
2902
2903 bw_bytes = (uint32_t)bgp_path_info_mpath_cumbw(path);
2904 if (!bw_bytes)
2905 return RMAP_OKAY;
2906
2907 } else if (rels->lb_type == RMAP_ECOMM_LB_SET_NUM_MPATH) {
2908
2909 /* process this only for the best path. */
2910 if (!CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
2911 return RMAP_OKAY;
2912
2913 bw_bytes = ((uint64_t)peer->bgp->lb_ref_bw * 1000 * 1000) / 8;
2914 mpath_count = bgp_path_info_mpath_count(path) + 1;
2915 bw_bytes *= mpath_count;
2916 }
2917
2918 encode_lb_extcomm(as, bw_bytes, rels->non_trans, &lb_eval,
2919 CHECK_FLAG(peer->flags,
2920 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE));
2921
2922 /* add to route or merge with existing */
2923 old_ecom = bgp_attr_get_ecommunity(path->attr);
2924 if (old_ecom) {
2925 new_ecom = ecommunity_dup(old_ecom);
2926 ecommunity_add_val(new_ecom, &lb_eval, true, true);
2927 if (!old_ecom->refcnt)
2928 ecommunity_free(&old_ecom);
2929 } else {
2930 ecom_lb.size = 1;
2931 ecom_lb.unit_size = ECOMMUNITY_SIZE;
2932 ecom_lb.val = (uint8_t *)lb_eval.val;
2933 new_ecom = ecommunity_dup(&ecom_lb);
2934 }
2935
2936 /* new_ecom will be intern()'d or attr_flush()'d in call stack */
2937 bgp_attr_set_ecommunity(path->attr, new_ecom);
2938
2939 /* Mark that route-map has set link bandwidth; used in attribute
2940 * setting decisions.
2941 */
2942 SET_FLAG(path->attr->rmap_change_flags, BATTR_RMAP_LINK_BW_SET);
2943
2944 return RMAP_OKAY;
2945 }
2946
2947 static void *route_set_ecommunity_lb_compile(const char *arg)
2948 {
2949 struct rmap_ecomm_lb_set *rels;
2950 uint8_t lb_type;
2951 uint32_t bw = 0;
2952 char bw_str[40] = {0};
2953 char *p, *str;
2954 bool non_trans = false;
2955
2956 str = (char *)arg;
2957 p = strchr(arg, ' ');
2958 if (p) {
2959 int len;
2960
2961 len = p - arg;
2962 memcpy(bw_str, arg, len);
2963 non_trans = true;
2964 str = bw_str;
2965 }
2966
2967 if (strcmp(str, "cumulative") == 0)
2968 lb_type = RMAP_ECOMM_LB_SET_CUMUL;
2969 else if (strcmp(str, "num-multipaths") == 0)
2970 lb_type = RMAP_ECOMM_LB_SET_NUM_MPATH;
2971 else {
2972 char *end = NULL;
2973
2974 bw = strtoul(str, &end, 10);
2975 if (*end != '\0')
2976 return NULL;
2977 lb_type = RMAP_ECOMM_LB_SET_VALUE;
2978 }
2979
2980 rels = XCALLOC(MTYPE_ROUTE_MAP_COMPILED,
2981 sizeof(struct rmap_ecomm_lb_set));
2982 rels->lb_type = lb_type;
2983 rels->bw = bw;
2984 rels->non_trans = non_trans;
2985
2986 return rels;
2987 }
2988
2989 static void route_set_ecommunity_lb_free(void *rule)
2990 {
2991 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
2992 }
2993
2994 /* Set community rule structure. */
2995 struct route_map_rule_cmd route_set_ecommunity_lb_cmd = {
2996 "extcommunity bandwidth",
2997 route_set_ecommunity_lb,
2998 route_set_ecommunity_lb_compile,
2999 route_set_ecommunity_lb_free,
3000 };
3001
3002 /* `set origin ORIGIN' */
3003
3004 /* For origin set. */
3005 static enum route_map_cmd_result_t
3006 route_set_origin(void *rule, const struct prefix *prefix, void *object)
3007 {
3008 uint8_t *origin;
3009 struct bgp_path_info *path;
3010
3011 origin = rule;
3012 path = object;
3013
3014 path->attr->origin = *origin;
3015
3016 return RMAP_OKAY;
3017 }
3018
3019 /* Compile function for origin set. */
3020 static void *route_set_origin_compile(const char *arg)
3021 {
3022 uint8_t *origin;
3023
3024 origin = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint8_t));
3025
3026 if (strcmp(arg, "igp") == 0)
3027 *origin = BGP_ORIGIN_IGP;
3028 else if (strcmp(arg, "egp") == 0)
3029 *origin = BGP_ORIGIN_EGP;
3030 else
3031 *origin = BGP_ORIGIN_INCOMPLETE;
3032
3033 return origin;
3034 }
3035
3036 /* Compile function for origin set. */
3037 static void route_set_origin_free(void *rule)
3038 {
3039 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3040 }
3041
3042 /* Set origin rule structure. */
3043 static const struct route_map_rule_cmd route_set_origin_cmd = {
3044 "origin",
3045 route_set_origin,
3046 route_set_origin_compile,
3047 route_set_origin_free,
3048 };
3049
3050 /* `set atomic-aggregate' */
3051
3052 /* For atomic aggregate set. */
3053 static enum route_map_cmd_result_t
3054 route_set_atomic_aggregate(void *rule, const struct prefix *pfx, void *object)
3055 {
3056 struct bgp_path_info *path;
3057
3058 path = object;
3059 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE);
3060
3061 return RMAP_OKAY;
3062 }
3063
3064 /* Compile function for atomic aggregate. */
3065 static void *route_set_atomic_aggregate_compile(const char *arg)
3066 {
3067 return (void *)1;
3068 }
3069
3070 /* Compile function for atomic aggregate. */
3071 static void route_set_atomic_aggregate_free(void *rule)
3072 {
3073 return;
3074 }
3075
3076 /* Set atomic aggregate rule structure. */
3077 static const struct route_map_rule_cmd route_set_atomic_aggregate_cmd = {
3078 "atomic-aggregate",
3079 route_set_atomic_aggregate,
3080 route_set_atomic_aggregate_compile,
3081 route_set_atomic_aggregate_free,
3082 };
3083
3084 /* AIGP TLV Metric */
3085 static enum route_map_cmd_result_t
3086 route_set_aigp_metric(void *rule, const struct prefix *pfx, void *object)
3087 {
3088 const char *aigp_metric = rule;
3089 struct bgp_path_info *path = object;
3090 uint32_t aigp = 0;
3091
3092 if (strmatch(aigp_metric, "igp-metric")) {
3093 if (!path->nexthop)
3094 return RMAP_NOMATCH;
3095
3096 bgp_attr_set_aigp_metric(path->attr, path->nexthop->metric);
3097 } else {
3098 aigp = atoi(aigp_metric);
3099 bgp_attr_set_aigp_metric(path->attr, aigp);
3100 }
3101
3102 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_AIGP);
3103
3104 return RMAP_OKAY;
3105 }
3106
3107 static void *route_set_aigp_metric_compile(const char *arg)
3108 {
3109 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
3110 }
3111
3112 static void route_set_aigp_metric_free(void *rule)
3113 {
3114 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3115 }
3116
3117 static const struct route_map_rule_cmd route_set_aigp_metric_cmd = {
3118 "aigp-metric",
3119 route_set_aigp_metric,
3120 route_set_aigp_metric_compile,
3121 route_set_aigp_metric_free,
3122 };
3123
3124 /* `set aggregator as AS A.B.C.D' */
3125 struct aggregator {
3126 as_t as;
3127 struct in_addr address;
3128 };
3129
3130 static enum route_map_cmd_result_t
3131 route_set_aggregator_as(void *rule, const struct prefix *prefix, void *object)
3132 {
3133 struct bgp_path_info *path;
3134 struct aggregator *aggregator;
3135
3136 path = object;
3137 aggregator = rule;
3138
3139 path->attr->aggregator_as = aggregator->as;
3140 path->attr->aggregator_addr = aggregator->address;
3141 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR);
3142
3143 return RMAP_OKAY;
3144 }
3145
3146 static void *route_set_aggregator_as_compile(const char *arg)
3147 {
3148 struct aggregator *aggregator;
3149 char as[10];
3150 char address[20];
3151 int ret;
3152
3153 aggregator =
3154 XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct aggregator));
3155 if (sscanf(arg, "%s %s", as, address) != 2) {
3156 XFREE(MTYPE_ROUTE_MAP_COMPILED, aggregator);
3157 return NULL;
3158 }
3159
3160 aggregator->as = strtoul(as, NULL, 10);
3161 ret = inet_aton(address, &aggregator->address);
3162 if (ret == 0) {
3163 XFREE(MTYPE_ROUTE_MAP_COMPILED, aggregator);
3164 return NULL;
3165 }
3166 return aggregator;
3167 }
3168
3169 static void route_set_aggregator_as_free(void *rule)
3170 {
3171 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3172 }
3173
3174 static const struct route_map_rule_cmd route_set_aggregator_as_cmd = {
3175 "aggregator as",
3176 route_set_aggregator_as,
3177 route_set_aggregator_as_compile,
3178 route_set_aggregator_as_free,
3179 };
3180
3181 /* Set tag to object. object must be pointer to struct bgp_path_info */
3182 static enum route_map_cmd_result_t
3183 route_set_tag(void *rule, const struct prefix *prefix, void *object)
3184 {
3185 route_tag_t *tag;
3186 struct bgp_path_info *path;
3187
3188 tag = rule;
3189 path = object;
3190
3191 /* Set tag value */
3192 path->attr->tag = *tag;
3193
3194 return RMAP_OKAY;
3195 }
3196
3197 /* Route map commands for tag set. */
3198 static const struct route_map_rule_cmd route_set_tag_cmd = {
3199 "tag",
3200 route_set_tag,
3201 route_map_rule_tag_compile,
3202 route_map_rule_tag_free,
3203 };
3204
3205 /* Set label-index to object. object must be pointer to struct bgp_path_info */
3206 static enum route_map_cmd_result_t
3207 route_set_label_index(void *rule, const struct prefix *prefix, void *object)
3208 {
3209 struct rmap_value *rv;
3210 struct bgp_path_info *path;
3211 uint32_t label_index;
3212
3213 /* Fetch routemap's rule information. */
3214 rv = rule;
3215 path = object;
3216
3217 /* Set label-index value. */
3218 label_index = rv->value;
3219 if (label_index) {
3220 path->attr->label_index = label_index;
3221 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID);
3222 }
3223
3224 return RMAP_OKAY;
3225 }
3226
3227 /* Route map commands for label-index set. */
3228 static const struct route_map_rule_cmd route_set_label_index_cmd = {
3229 "label-index",
3230 route_set_label_index,
3231 route_value_compile,
3232 route_value_free,
3233 };
3234
3235 /* `match ipv6 address IP_ACCESS_LIST' */
3236
3237 static enum route_map_cmd_result_t
3238 route_match_ipv6_address(void *rule, const struct prefix *prefix, void *object)
3239 {
3240 struct access_list *alist;
3241
3242 if (prefix->family == AF_INET6) {
3243 alist = access_list_lookup(AFI_IP6, (char *)rule);
3244 if (alist == NULL) {
3245 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
3246 zlog_debug(
3247 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
3248 __func__, (char *)rule);
3249
3250 return RMAP_NOMATCH;
3251 }
3252
3253 return (access_list_apply(alist, prefix) == FILTER_DENY
3254 ? RMAP_NOMATCH
3255 : RMAP_MATCH);
3256 }
3257 return RMAP_NOMATCH;
3258 }
3259
3260 static void *route_match_ipv6_address_compile(const char *arg)
3261 {
3262 struct access_list *alist;
3263
3264 alist = access_list_lookup(AFI_IP6, arg);
3265 if (!alist)
3266 zlog_warn(
3267 "Access List specified %s does not exist yet, default will be NO_MATCH until it is created",
3268 arg);
3269
3270 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
3271 }
3272
3273 static void route_match_ipv6_address_free(void *rule)
3274 {
3275 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3276 }
3277
3278 /* Route map commands for ip address matching. */
3279 static const struct route_map_rule_cmd route_match_ipv6_address_cmd = {
3280 "ipv6 address",
3281 route_match_ipv6_address,
3282 route_match_ipv6_address_compile,
3283 route_match_ipv6_address_free
3284 };
3285
3286 /* `match ipv6 next-hop ACCESSLIST6_NAME' */
3287 static enum route_map_cmd_result_t
3288 route_match_ipv6_next_hop(void *rule, const struct prefix *prefix, void *object)
3289 {
3290 struct bgp_path_info *path;
3291 struct access_list *alist;
3292 struct prefix_ipv6 p;
3293
3294 if (prefix->family == AF_INET6) {
3295 path = object;
3296 p.family = AF_INET6;
3297 p.prefix = path->attr->mp_nexthop_global;
3298 p.prefixlen = IPV6_MAX_BITLEN;
3299
3300 alist = access_list_lookup(AFI_IP6, (char *)rule);
3301 if (!alist) {
3302 if (CHECK_FLAG(rmap_debug, DEBUG_ROUTEMAP_DETAIL))
3303 zlog_debug(
3304 "%s: Access-List Specified: %s does not exist defaulting to NO_MATCH",
3305 __func__, (char *)rule);
3306
3307 return RMAP_NOMATCH;
3308 }
3309
3310 if (access_list_apply(alist, &p) == FILTER_PERMIT)
3311 return RMAP_MATCH;
3312
3313 if (path->attr->mp_nexthop_len
3314 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
3315 p.prefix = path->attr->mp_nexthop_local;
3316 if (access_list_apply(alist, &p) == FILTER_PERMIT)
3317 return RMAP_MATCH;
3318 }
3319 }
3320
3321 return RMAP_NOMATCH;
3322 }
3323
3324 static void *route_match_ipv6_next_hop_compile(const char *arg)
3325 {
3326 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
3327 }
3328
3329 static void route_match_ipv6_next_hop_free(void *rule)
3330 {
3331 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3332 }
3333
3334 static const struct route_map_rule_cmd route_match_ipv6_next_hop_cmd = {
3335 "ipv6 next-hop",
3336 route_match_ipv6_next_hop,
3337 route_match_ipv6_next_hop_compile,
3338 route_match_ipv6_next_hop_free
3339 };
3340
3341 /* `match ipv6 next-hop IP_ADDRESS' */
3342
3343 static enum route_map_cmd_result_t
3344 route_match_ipv6_next_hop_address(void *rule, const struct prefix *prefix,
3345 void *object)
3346 {
3347 struct in6_addr *addr = rule;
3348 struct bgp_path_info *path;
3349
3350 path = object;
3351
3352 if (IPV6_ADDR_SAME(&path->attr->mp_nexthop_global, addr))
3353 return RMAP_MATCH;
3354
3355 if (path->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
3356 && IPV6_ADDR_SAME(&path->attr->mp_nexthop_local, rule))
3357 return RMAP_MATCH;
3358
3359 return RMAP_NOMATCH;
3360 }
3361
3362 static void *route_match_ipv6_next_hop_address_compile(const char *arg)
3363 {
3364 struct in6_addr *address;
3365 int ret;
3366
3367 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in6_addr));
3368
3369 ret = inet_pton(AF_INET6, arg, address);
3370 if (!ret) {
3371 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3372 return NULL;
3373 }
3374
3375 return address;
3376 }
3377
3378 static void route_match_ipv6_next_hop_address_free(void *rule)
3379 {
3380 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3381 }
3382
3383 static const struct route_map_rule_cmd route_match_ipv6_next_hop_address_cmd = {
3384 "ipv6 next-hop address",
3385 route_match_ipv6_next_hop_address,
3386 route_match_ipv6_next_hop_address_compile,
3387 route_match_ipv6_next_hop_address_free
3388 };
3389
3390 /* `match ip next-hop address IP_ADDRESS' */
3391
3392 static enum route_map_cmd_result_t
3393 route_match_ipv4_next_hop(void *rule, const struct prefix *prefix, void *object)
3394 {
3395 struct in_addr *addr = rule;
3396 struct bgp_path_info *path;
3397
3398 path = object;
3399
3400 if (path->attr->nexthop.s_addr == addr->s_addr
3401 || (path->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4
3402 && IPV4_ADDR_SAME(&path->attr->mp_nexthop_global_in, addr)))
3403 return RMAP_MATCH;
3404
3405 return RMAP_NOMATCH;
3406 }
3407
3408 static void *route_match_ipv4_next_hop_compile(const char *arg)
3409 {
3410 struct in_addr *address;
3411 int ret;
3412
3413 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));
3414
3415 ret = inet_pton(AF_INET, arg, address);
3416 if (!ret) {
3417 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3418 return NULL;
3419 }
3420
3421 return address;
3422 }
3423
3424 static void route_match_ipv4_next_hop_free(void *rule)
3425 {
3426 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3427 }
3428
3429 static const struct route_map_rule_cmd route_match_ipv4_next_hop_cmd = {
3430 "ip next-hop address",
3431 route_match_ipv4_next_hop,
3432 route_match_ipv4_next_hop_compile,
3433 route_match_ipv4_next_hop_free
3434 };
3435
3436 /* `match ipv6 address prefix-list PREFIX_LIST' */
3437
3438 static enum route_map_cmd_result_t
3439 route_match_ipv6_address_prefix_list(void *rule, const struct prefix *prefix,
3440 void *object)
3441 {
3442 return route_match_address_prefix_list(rule, AFI_IP6, prefix, object);
3443 }
3444
3445 static void *route_match_ipv6_address_prefix_list_compile(const char *arg)
3446 {
3447 return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
3448 }
3449
3450 static void route_match_ipv6_address_prefix_list_free(void *rule)
3451 {
3452 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3453 }
3454
3455 static const struct route_map_rule_cmd
3456 route_match_ipv6_address_prefix_list_cmd = {
3457 "ipv6 address prefix-list",
3458 route_match_ipv6_address_prefix_list,
3459 route_match_ipv6_address_prefix_list_compile,
3460 route_match_ipv6_address_prefix_list_free
3461 };
3462
3463 /* `match ipv6 next-hop type <TYPE>' */
3464
3465 static enum route_map_cmd_result_t
3466 route_match_ipv6_next_hop_type(void *rule, const struct prefix *prefix,
3467 void *object)
3468 {
3469 struct bgp_path_info *path;
3470 struct in6_addr *addr = rule;
3471
3472 if (prefix->family == AF_INET6) {
3473 path = (struct bgp_path_info *)object;
3474 if (!path)
3475 return RMAP_NOMATCH;
3476
3477 if (IPV6_ADDR_SAME(&path->attr->mp_nexthop_global, addr)
3478 && !path->attr->nh_ifindex)
3479 return RMAP_MATCH;
3480 }
3481
3482 return RMAP_NOMATCH;
3483 }
3484
3485 static void *route_match_ipv6_next_hop_type_compile(const char *arg)
3486 {
3487 struct in6_addr *address;
3488 int ret;
3489
3490 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in6_addr));
3491
3492 ret = inet_pton(AF_INET6, "::0", address);
3493 if (!ret) {
3494 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3495 return NULL;
3496 }
3497
3498 return address;
3499 }
3500
3501 static void route_match_ipv6_next_hop_type_free(void *rule)
3502 {
3503 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3504 }
3505
3506 static const struct route_map_rule_cmd
3507 route_match_ipv6_next_hop_type_cmd = {
3508 "ipv6 next-hop type",
3509 route_match_ipv6_next_hop_type,
3510 route_match_ipv6_next_hop_type_compile,
3511 route_match_ipv6_next_hop_type_free
3512 };
3513
3514 /* `set ipv6 nexthop global IP_ADDRESS' */
3515
3516 /* Set nexthop to object. object must be pointer to struct attr. */
3517 static enum route_map_cmd_result_t
3518 route_set_ipv6_nexthop_global(void *rule, const struct prefix *p, void *object)
3519 {
3520 struct in6_addr *address;
3521 struct bgp_path_info *path;
3522
3523 /* Fetch routemap's rule information. */
3524 address = rule;
3525 path = object;
3526
3527 /* Set next hop value. */
3528 path->attr->mp_nexthop_global = *address;
3529
3530 /* Set nexthop length. */
3531 if (path->attr->mp_nexthop_len == 0)
3532 path->attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
3533
3534 SET_FLAG(path->attr->rmap_change_flags,
3535 BATTR_RMAP_IPV6_GLOBAL_NHOP_CHANGED);
3536
3537 return RMAP_OKAY;
3538 }
3539
3540 /* Route map `ip next-hop' compile function. Given string is converted
3541 to struct in_addr structure. */
3542 static void *route_set_ipv6_nexthop_global_compile(const char *arg)
3543 {
3544 int ret;
3545 struct in6_addr *address;
3546
3547 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in6_addr));
3548
3549 ret = inet_pton(AF_INET6, arg, address);
3550
3551 if (ret == 0) {
3552 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3553 return NULL;
3554 }
3555
3556 return address;
3557 }
3558
3559 /* Free route map's compiled `ip next-hop' value. */
3560 static void route_set_ipv6_nexthop_global_free(void *rule)
3561 {
3562 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3563 }
3564
3565 /* Route map commands for ip nexthop set. */
3566 static const struct route_map_rule_cmd
3567 route_set_ipv6_nexthop_global_cmd = {
3568 "ipv6 next-hop global",
3569 route_set_ipv6_nexthop_global,
3570 route_set_ipv6_nexthop_global_compile,
3571 route_set_ipv6_nexthop_global_free
3572 };
3573
3574 /* Set next-hop preference value. */
3575 static enum route_map_cmd_result_t
3576 route_set_ipv6_nexthop_prefer_global(void *rule, const struct prefix *prefix,
3577 void *object)
3578 {
3579 struct bgp_path_info *path;
3580 struct peer *peer;
3581
3582 /* Fetch routemap's rule information. */
3583 path = object;
3584 peer = path->peer;
3585
3586 if (CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IN)
3587 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IMPORT)) {
3588 /* Set next hop preference to global */
3589 path->attr->mp_nexthop_prefer_global = true;
3590 SET_FLAG(path->attr->rmap_change_flags,
3591 BATTR_RMAP_IPV6_PREFER_GLOBAL_CHANGED);
3592 } else {
3593 path->attr->mp_nexthop_prefer_global = false;
3594 SET_FLAG(path->attr->rmap_change_flags,
3595 BATTR_RMAP_IPV6_PREFER_GLOBAL_CHANGED);
3596 }
3597
3598 return RMAP_OKAY;
3599 }
3600
3601 static void *route_set_ipv6_nexthop_prefer_global_compile(const char *arg)
3602 {
3603 int *rins = NULL;
3604
3605 rins = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(int));
3606 *rins = 1;
3607
3608 return rins;
3609 }
3610
3611 /* Free route map's compiled `ip next-hop' value. */
3612 static void route_set_ipv6_nexthop_prefer_global_free(void *rule)
3613 {
3614 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3615 }
3616
3617 /* Route map commands for ip nexthop set preferred. */
3618 static const struct route_map_rule_cmd
3619 route_set_ipv6_nexthop_prefer_global_cmd = {
3620 "ipv6 next-hop prefer-global",
3621 route_set_ipv6_nexthop_prefer_global,
3622 route_set_ipv6_nexthop_prefer_global_compile,
3623 route_set_ipv6_nexthop_prefer_global_free
3624 };
3625
3626 /* `set ipv6 nexthop local IP_ADDRESS' */
3627
3628 /* Set nexthop to object. object must be pointer to struct attr. */
3629 static enum route_map_cmd_result_t
3630 route_set_ipv6_nexthop_local(void *rule, const struct prefix *p, void *object)
3631 {
3632 struct in6_addr *address;
3633 struct bgp_path_info *path;
3634 struct bgp_dest *dest;
3635 struct bgp_table *table = NULL;
3636
3637 /* Fetch routemap's rule information. */
3638 address = rule;
3639 path = object;
3640 dest = path->net;
3641
3642 if (!dest)
3643 return RMAP_OKAY;
3644
3645 table = bgp_dest_table(dest);
3646 if (!table)
3647 return RMAP_OKAY;
3648
3649 /* Set next hop value. */
3650 path->attr->mp_nexthop_local = *address;
3651
3652 /* Set nexthop length. */
3653 if (table->safi == SAFI_MPLS_VPN || table->safi == SAFI_ENCAP ||
3654 table->safi == SAFI_EVPN)
3655 path->attr->mp_nexthop_len = BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL;
3656 else
3657 path->attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL;
3658
3659 SET_FLAG(path->attr->rmap_change_flags,
3660 BATTR_RMAP_IPV6_LL_NHOP_CHANGED);
3661
3662 return RMAP_OKAY;
3663 }
3664
3665 /* Route map `ip nexthop' compile function. Given string is converted
3666 to struct in_addr structure. */
3667 static void *route_set_ipv6_nexthop_local_compile(const char *arg)
3668 {
3669 int ret;
3670 struct in6_addr *address;
3671
3672 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in6_addr));
3673
3674 ret = inet_pton(AF_INET6, arg, address);
3675
3676 if (ret == 0) {
3677 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3678 return NULL;
3679 }
3680
3681 return address;
3682 }
3683
3684 /* Free route map's compiled `ip nexthop' value. */
3685 static void route_set_ipv6_nexthop_local_free(void *rule)
3686 {
3687 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3688 }
3689
3690 /* Route map commands for ip nexthop set. */
3691 static const struct route_map_rule_cmd
3692 route_set_ipv6_nexthop_local_cmd = {
3693 "ipv6 next-hop local",
3694 route_set_ipv6_nexthop_local,
3695 route_set_ipv6_nexthop_local_compile,
3696 route_set_ipv6_nexthop_local_free
3697 };
3698
3699 /* `set ipv6 nexthop peer-address' */
3700
3701 /* Set nexthop to object. object must be pointer to struct attr. */
3702 static enum route_map_cmd_result_t
3703 route_set_ipv6_nexthop_peer(void *rule, const struct prefix *pfx, void *object)
3704 {
3705 struct in6_addr peer_address;
3706 struct bgp_path_info *path;
3707 struct peer *peer;
3708
3709 /* Fetch routemap's rule information. */
3710 path = object;
3711 peer = path->peer;
3712
3713 if ((CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IN)
3714 || CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IMPORT))
3715 && peer->su_remote
3716 && sockunion_family(peer->su_remote) == AF_INET6) {
3717 peer_address = peer->su_remote->sin6.sin6_addr;
3718 /* Set next hop value and length in attribute. */
3719 if (IN6_IS_ADDR_LINKLOCAL(&peer_address)) {
3720 path->attr->mp_nexthop_local = peer_address;
3721 if (path->attr->mp_nexthop_len
3722 != BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
3723 path->attr->mp_nexthop_len =
3724 BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL;
3725 } else {
3726 path->attr->mp_nexthop_global = peer_address;
3727 if (path->attr->mp_nexthop_len == 0)
3728 path->attr->mp_nexthop_len =
3729 BGP_ATTR_NHLEN_IPV6_GLOBAL;
3730 }
3731
3732 } else if (CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_OUT)) {
3733 /* The next hop value will be set as part of packet
3734 * rewrite.
3735 * Set the flags here to indicate that rewrite needs to
3736 * be done.
3737 * Also, clear the value - we clear both global and
3738 * link-local
3739 * nexthops, whether we send one or both is determined
3740 * elsewhere.
3741 */
3742 SET_FLAG(path->attr->rmap_change_flags,
3743 BATTR_RMAP_NEXTHOP_PEER_ADDRESS);
3744 /* clear next hop value. */
3745 memset(&(path->attr->mp_nexthop_global), 0,
3746 sizeof(struct in6_addr));
3747 memset(&(path->attr->mp_nexthop_local), 0,
3748 sizeof(struct in6_addr));
3749 }
3750
3751 return RMAP_OKAY;
3752 }
3753
3754 /* Route map `ip next-hop' compile function. Given string is converted
3755 to struct in_addr structure. */
3756 static void *route_set_ipv6_nexthop_peer_compile(const char *arg)
3757 {
3758 int *rins = NULL;
3759
3760 rins = XCALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(int));
3761 *rins = 1;
3762
3763 return rins;
3764 }
3765
3766 /* Free route map's compiled `ip next-hop' value. */
3767 static void route_set_ipv6_nexthop_peer_free(void *rule)
3768 {
3769 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3770 }
3771
3772 /* Route map commands for ip nexthop set. */
3773 static const struct route_map_rule_cmd route_set_ipv6_nexthop_peer_cmd = {
3774 "ipv6 next-hop peer-address",
3775 route_set_ipv6_nexthop_peer,
3776 route_set_ipv6_nexthop_peer_compile,
3777 route_set_ipv6_nexthop_peer_free
3778 };
3779
3780 /* `set ipv4 vpn next-hop A.B.C.D' */
3781
3782 static enum route_map_cmd_result_t
3783 route_set_vpnv4_nexthop(void *rule, const struct prefix *prefix, void *object)
3784 {
3785 struct in_addr *address;
3786 struct bgp_path_info *path;
3787
3788 /* Fetch routemap's rule information. */
3789 address = rule;
3790 path = object;
3791
3792 /* Set next hop value. */
3793 path->attr->mp_nexthop_global_in = *address;
3794 path->attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
3795
3796 SET_FLAG(path->attr->rmap_change_flags, BATTR_RMAP_VPNV4_NHOP_CHANGED);
3797
3798 return RMAP_OKAY;
3799 }
3800
3801 static void *route_set_vpnv4_nexthop_compile(const char *arg)
3802 {
3803 int ret;
3804 struct in_addr *address;
3805
3806 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));
3807
3808 ret = inet_aton(arg, address);
3809
3810 if (ret == 0) {
3811 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3812 return NULL;
3813 }
3814
3815 return address;
3816 }
3817
3818 /* `set ipv6 vpn next-hop A.B.C.D' */
3819
3820 static enum route_map_cmd_result_t
3821 route_set_vpnv6_nexthop(void *rule, const struct prefix *prefix, void *object)
3822 {
3823 struct in6_addr *address;
3824 struct bgp_path_info *path;
3825
3826 /* Fetch routemap's rule information. */
3827 address = rule;
3828 path = object;
3829
3830 /* Set next hop value. */
3831 memcpy(&path->attr->mp_nexthop_global, address,
3832 sizeof(struct in6_addr));
3833 path->attr->mp_nexthop_len = BGP_ATTR_NHLEN_VPNV6_GLOBAL;
3834
3835 SET_FLAG(path->attr->rmap_change_flags,
3836 BATTR_RMAP_VPNV6_GLOBAL_NHOP_CHANGED);
3837
3838 return RMAP_OKAY;
3839 }
3840
3841 static void *route_set_vpnv6_nexthop_compile(const char *arg)
3842 {
3843 int ret;
3844 struct in6_addr *address;
3845
3846 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in6_addr));
3847 ret = inet_pton(AF_INET6, arg, address);
3848
3849 if (ret == 0) {
3850 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3851 return NULL;
3852 }
3853
3854 return address;
3855 }
3856
3857 static void route_set_vpn_nexthop_free(void *rule)
3858 {
3859 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3860 }
3861
3862 /* Route map commands for ipv4 next-hop set. */
3863 static const struct route_map_rule_cmd route_set_vpnv4_nexthop_cmd = {
3864 "ipv4 vpn next-hop",
3865 route_set_vpnv4_nexthop,
3866 route_set_vpnv4_nexthop_compile,
3867 route_set_vpn_nexthop_free
3868 };
3869
3870 /* Route map commands for ipv6 next-hop set. */
3871 static const struct route_map_rule_cmd route_set_vpnv6_nexthop_cmd = {
3872 "ipv6 vpn next-hop",
3873 route_set_vpnv6_nexthop,
3874 route_set_vpnv6_nexthop_compile,
3875 route_set_vpn_nexthop_free
3876 };
3877
3878 /* `set originator-id' */
3879
3880 /* For origin set. */
3881 static enum route_map_cmd_result_t
3882 route_set_originator_id(void *rule, const struct prefix *prefix, void *object)
3883 {
3884 struct in_addr *address;
3885 struct bgp_path_info *path;
3886
3887 address = rule;
3888 path = object;
3889
3890 path->attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID);
3891 path->attr->originator_id = *address;
3892
3893 return RMAP_OKAY;
3894 }
3895
3896 /* Compile function for originator-id set. */
3897 static void *route_set_originator_id_compile(const char *arg)
3898 {
3899 int ret;
3900 struct in_addr *address;
3901
3902 address = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(struct in_addr));
3903
3904 ret = inet_aton(arg, address);
3905
3906 if (ret == 0) {
3907 XFREE(MTYPE_ROUTE_MAP_COMPILED, address);
3908 return NULL;
3909 }
3910
3911 return address;
3912 }
3913
3914 /* Compile function for originator_id set. */
3915 static void route_set_originator_id_free(void *rule)
3916 {
3917 XFREE(MTYPE_ROUTE_MAP_COMPILED, rule);
3918 }
3919
3920 /* Set originator-id rule structure. */
3921 static const struct route_map_rule_cmd route_set_originator_id_cmd = {
3922 "originator-id",
3923 route_set_originator_id,
3924 route_set_originator_id_compile,
3925 route_set_originator_id_free,
3926 };
3927
3928 static enum route_map_cmd_result_t
3929 route_match_rpki_extcommunity(void *rule, const struct prefix *prefix,
3930 void *object)
3931 {
3932 struct bgp_path_info *path;
3933 struct ecommunity *ecomm;
3934 struct ecommunity_val *ecomm_val;
3935 enum rpki_states *rpki_status = rule;
3936 enum rpki_states ecomm_rpki_status = RPKI_NOT_BEING_USED;
3937
3938 path = object;
3939
3940 ecomm = bgp_attr_get_ecommunity(path->attr);
3941 if (!ecomm)
3942 return RMAP_NOMATCH;
3943
3944 ecomm_val = ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_OPAQUE_NON_TRANS,
3945 ECOMMUNITY_ORIGIN_VALIDATION_STATE);
3946 if (!ecomm_val)
3947 return RMAP_NOMATCH;
3948
3949 /* The Origin Validation State is encoded in the last octet of
3950 * the extended community.
3951 */
3952 switch (ecomm_val->val[7]) {
3953 case ECOMMUNITY_ORIGIN_VALIDATION_STATE_VALID:
3954 ecomm_rpki_status = RPKI_VALID;
3955 break;
3956 case ECOMMUNITY_ORIGIN_VALIDATION_STATE_NOTFOUND:
3957 ecomm_rpki_status = RPKI_NOTFOUND;
3958 break;
3959 case ECOMMUNITY_ORIGIN_VALIDATION_STATE_INVALID:
3960 ecomm_rpki_status = RPKI_INVALID;
3961 break;
3962 case ECOMMUNITY_ORIGIN_VALIDATION_STATE_NOTUSED:
3963 break;
3964 }
3965
3966 if (ecomm_rpki_status == *rpki_status)
3967 return RMAP_MATCH;
3968
3969 return RMAP_NOMATCH;
3970 }
3971
3972 static void *route_match_extcommunity_compile(const char *arg)
3973 {
3974 int *rpki_status;
3975
3976 rpki_status = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(int));
3977
3978 if (strcmp(arg, "valid") == 0)
3979 *rpki_status = RPKI_VALID;
3980 else if (strcmp(arg, "invalid") == 0)
3981 *rpki_status = RPKI_INVALID;
3982 else
3983 *rpki_status = RPKI_NOTFOUND;
3984
3985 return rpki_status;
3986 }
3987
3988 static const struct route_map_rule_cmd route_match_rpki_extcommunity_cmd = {
3989 "rpki-extcommunity",
3990 route_match_rpki_extcommunity,
3991 route_match_extcommunity_compile,
3992 route_value_free
3993 };
3994
3995 /*
3996 * This is the workhorse routine for processing in/out routemap
3997 * modifications.
3998 */
3999 static void bgp_route_map_process_peer(const char *rmap_name,
4000 struct route_map *map, struct peer *peer,
4001 int afi, int safi, int route_update)
4002 {
4003 struct bgp_filter *filter;
4004
4005 if (!peer || !rmap_name)
4006 return;
4007
4008 filter = &peer->filter[afi][safi];
4009 /*
4010 * in is for non-route-server clients,
4011 * out is for all peers
4012 */
4013 if (filter->map[RMAP_IN].name
4014 && (strcmp(rmap_name, filter->map[RMAP_IN].name) == 0)) {
4015 filter->map[RMAP_IN].map = map;
4016
4017 if (route_update && peer_established(peer)) {
4018 if (CHECK_FLAG(peer->af_flags[afi][safi],
4019 PEER_FLAG_SOFT_RECONFIG)) {
4020 if (bgp_debug_update(peer, NULL, NULL, 1))
4021 zlog_debug(
4022 "Processing route_map %s(%s:%s) update on peer %s (inbound, soft-reconfig)",
4023 rmap_name, afi2str(afi),
4024 safi2str(safi), peer->host);
4025
4026 bgp_soft_reconfig_in(peer, afi, safi);
4027 } else if (CHECK_FLAG(peer->cap,
4028 PEER_CAP_REFRESH_OLD_RCV)
4029 || CHECK_FLAG(peer->cap,
4030 PEER_CAP_REFRESH_NEW_RCV)) {
4031 if (bgp_debug_update(peer, NULL, NULL, 1))
4032 zlog_debug(
4033 "Processing route_map %s(%s:%s) update on peer %s (inbound, route-refresh)",
4034 rmap_name, afi2str(afi),
4035 safi2str(safi), peer->host);
4036 bgp_route_refresh_send(
4037 peer, afi, safi, 0, 0, 0,
4038 BGP_ROUTE_REFRESH_NORMAL);
4039 }
4040 }
4041 }
4042
4043 /*
4044 * For outbound, unsuppress and default-originate map change (content or
4045 * map created), merely update the "config" here, the actual route
4046 * announcement happens at the group level.
4047 */
4048 if (filter->map[RMAP_OUT].name
4049 && (strcmp(rmap_name, filter->map[RMAP_OUT].name) == 0))
4050 filter->map[RMAP_OUT].map = map;
4051
4052 if (filter->usmap.name && (strcmp(rmap_name, filter->usmap.name) == 0))
4053 filter->usmap.map = map;
4054
4055 if (filter->advmap.aname
4056 && (strcmp(rmap_name, filter->advmap.aname) == 0)) {
4057 filter->advmap.amap = map;
4058 }
4059
4060 if (filter->advmap.cname
4061 && (strcmp(rmap_name, filter->advmap.cname) == 0)) {
4062 filter->advmap.cmap = map;
4063 }
4064
4065 if (peer->default_rmap[afi][safi].name
4066 && (strcmp(rmap_name, peer->default_rmap[afi][safi].name) == 0))
4067 peer->default_rmap[afi][safi].map = map;
4068
4069 /* Notify BGP conditional advertisement scanner percess */
4070 peer->advmap_config_change[afi][safi] = true;
4071 }
4072
4073 static void bgp_route_map_update_peer_group(const char *rmap_name,
4074 struct route_map *map,
4075 struct bgp *bgp)
4076 {
4077 struct peer_group *group;
4078 struct listnode *node, *nnode;
4079 struct bgp_filter *filter;
4080 int afi, safi;
4081 int direct;
4082
4083 if (!bgp)
4084 return;
4085
4086 /* All the peers have been updated correctly already. This is
4087 * just updating the placeholder data. No real update required.
4088 */
4089 for (ALL_LIST_ELEMENTS(bgp->group, node, nnode, group)) {
4090 FOREACH_AFI_SAFI (afi, safi) {
4091 filter = &group->conf->filter[afi][safi];
4092
4093 for (direct = RMAP_IN; direct < RMAP_MAX; direct++) {
4094 if ((filter->map[direct].name)
4095 && (strcmp(rmap_name,
4096 filter->map[direct].name)
4097 == 0))
4098 filter->map[direct].map = map;
4099 }
4100
4101 if (filter->usmap.name
4102 && (strcmp(rmap_name, filter->usmap.name) == 0))
4103 filter->usmap.map = map;
4104
4105 if (filter->advmap.aname &&
4106 (strcmp(rmap_name, filter->advmap.aname) == 0))
4107 filter->advmap.amap = map;
4108
4109 if (filter->advmap.cname &&
4110 (strcmp(rmap_name, filter->advmap.cname) == 0))
4111 filter->advmap.cmap = map;
4112 }
4113 }
4114 }
4115
4116 /*
4117 * Note that if an extreme number (tens of thousands) of route-maps are in use
4118 * and if bgp has an extreme number of peers, network statements, etc then this
4119 * function can consume a lot of cycles. This is due to this function being
4120 * called for each route-map and within this function we walk the list of peers,
4121 * network statements, etc looking to see if they use this route-map.
4122 */
4123 static void bgp_route_map_process_update(struct bgp *bgp, const char *rmap_name,
4124 bool route_update)
4125 {
4126 int i;
4127 bool matched;
4128 afi_t afi;
4129 safi_t safi;
4130 struct peer *peer;
4131 struct bgp_dest *bn;
4132 struct bgp_static *bgp_static;
4133 struct bgp_aggregate *aggregate;
4134 struct listnode *node, *nnode;
4135 struct route_map *map;
4136 char buf[INET6_ADDRSTRLEN];
4137
4138 map = route_map_lookup_by_name(rmap_name);
4139
4140 for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
4141
4142 /* Ignore dummy peer-group structure */
4143 if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP))
4144 continue;
4145
4146 FOREACH_AFI_SAFI (afi, safi) {
4147 /* process in/out/import/export/default-orig
4148 * route-maps */
4149 bgp_route_map_process_peer(rmap_name, map, peer, afi,
4150 safi, route_update);
4151 }
4152 }
4153
4154 /* for outbound/default-orig route-maps, process for groups */
4155 update_group_policy_update(bgp, BGP_POLICY_ROUTE_MAP, rmap_name,
4156 route_update, 0);
4157
4158 /* update peer-group config (template) */
4159 bgp_route_map_update_peer_group(rmap_name, map, bgp);
4160
4161 FOREACH_AFI_SAFI (afi, safi) {
4162 /* For table route-map updates. */
4163 if (!bgp_fibupd_safi(safi))
4164 continue;
4165
4166 if (bgp->table_map[afi][safi].name
4167 && (strcmp(rmap_name, bgp->table_map[afi][safi].name)
4168 == 0)) {
4169
4170 /* bgp->table_map[afi][safi].map is NULL.
4171 * i.e Route map creation event.
4172 * So update applied_counter.
4173 * If it is not NULL, i.e It may be routemap updation or
4174 * deletion. so no need to update the counter.
4175 */
4176 if (!bgp->table_map[afi][safi].map)
4177 route_map_counter_increment(map);
4178 bgp->table_map[afi][safi].map = map;
4179
4180 if (BGP_DEBUG(zebra, ZEBRA))
4181 zlog_debug(
4182 "Processing route_map %s(%s:%s) update on table map",
4183 rmap_name, afi2str(afi),
4184 safi2str(safi));
4185 if (route_update)
4186 bgp_zebra_announce_table(bgp, afi, safi);
4187 }
4188
4189 /* For network route-map updates. */
4190 for (bn = bgp_table_top(bgp->route[afi][safi]); bn;
4191 bn = bgp_route_next(bn)) {
4192 bgp_static = bgp_dest_get_bgp_static_info(bn);
4193 if (!bgp_static)
4194 continue;
4195
4196 if (!bgp_static->rmap.name
4197 || (strcmp(rmap_name, bgp_static->rmap.name) != 0))
4198 continue;
4199
4200 if (!bgp_static->rmap.map)
4201 route_map_counter_increment(map);
4202
4203 bgp_static->rmap.map = map;
4204
4205 if (route_update && !bgp_static->backdoor) {
4206 const struct prefix *bn_p =
4207 bgp_dest_get_prefix(bn);
4208
4209 if (bgp_debug_zebra(bn_p))
4210 zlog_debug(
4211 "Processing route_map %s(%s:%s) update on static route %s",
4212 rmap_name, afi2str(afi),
4213 safi2str(safi),
4214 inet_ntop(bn_p->family,
4215 &bn_p->u.prefix, buf,
4216 sizeof(buf)));
4217 bgp_static_update(bgp, bn_p, bgp_static, afi,
4218 safi);
4219 }
4220 }
4221
4222 /* For aggregate-address route-map updates. */
4223 for (bn = bgp_table_top(bgp->aggregate[afi][safi]); bn;
4224 bn = bgp_route_next(bn)) {
4225 aggregate = bgp_dest_get_bgp_aggregate_info(bn);
4226 if (!aggregate)
4227 continue;
4228
4229 matched = false;
4230
4231 /* Update suppress map pointer. */
4232 if (aggregate->suppress_map_name
4233 && strmatch(aggregate->suppress_map_name,
4234 rmap_name)) {
4235 if (aggregate->rmap.map == NULL)
4236 route_map_counter_increment(map);
4237
4238 aggregate->suppress_map = map;
4239
4240 bgp_aggregate_toggle_suppressed(
4241 aggregate, bgp, bgp_dest_get_prefix(bn),
4242 afi, safi, false);
4243
4244 matched = true;
4245 }
4246
4247 if (aggregate->rmap.name
4248 && strmatch(rmap_name, aggregate->rmap.name)) {
4249 if (aggregate->rmap.map == NULL)
4250 route_map_counter_increment(map);
4251
4252 aggregate->rmap.map = map;
4253
4254 matched = true;
4255 }
4256
4257 if (matched && route_update) {
4258 const struct prefix *bn_p =
4259 bgp_dest_get_prefix(bn);
4260
4261 if (bgp_debug_zebra(bn_p))
4262 zlog_debug(
4263 "Processing route_map %s(%s:%s) update on aggregate-address route %s",
4264 rmap_name, afi2str(afi),
4265 safi2str(safi),
4266 inet_ntop(bn_p->family,
4267 &bn_p->u.prefix, buf,
4268 sizeof(buf)));
4269 (void)bgp_aggregate_route(bgp, bn_p, afi, safi,
4270 aggregate);
4271 }
4272 }
4273 }
4274
4275 /* For redistribute route-map updates. */
4276 for (afi = AFI_IP; afi < AFI_MAX; afi++)
4277 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
4278 struct list *red_list;
4279 struct bgp_redist *red;
4280
4281 red_list = bgp->redist[afi][i];
4282 if (!red_list)
4283 continue;
4284
4285 for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
4286 if (!red->rmap.name
4287 || (strcmp(rmap_name, red->rmap.name) != 0))
4288 continue;
4289
4290 if (!red->rmap.map)
4291 route_map_counter_increment(map);
4292
4293 red->rmap.map = map;
4294
4295 if (!route_update)
4296 continue;
4297
4298 if (BGP_DEBUG(zebra, ZEBRA))
4299 zlog_debug(
4300 "Processing route_map %s(%s:%s) update on redistributed routes",
4301 rmap_name, afi2str(afi),
4302 safi2str(safi));
4303
4304 bgp_redistribute_resend(bgp, afi, i,
4305 red->instance);
4306 }
4307 }
4308
4309 /* for type5 command route-maps */
4310 FOREACH_AFI_SAFI (afi, safi) {
4311 if (!bgp->adv_cmd_rmap[afi][safi].name
4312 || strcmp(rmap_name, bgp->adv_cmd_rmap[afi][safi].name)
4313 != 0)
4314 continue;
4315
4316 /* Make sure the route-map is populated here if not already done */
4317 bgp->adv_cmd_rmap[afi][safi].map = map;
4318
4319 if (BGP_DEBUG(zebra, ZEBRA))
4320 zlog_debug(
4321 "Processing route_map %s(%s:%s) update on advertise type5 route command",
4322 rmap_name, afi2str(afi), safi2str(safi));
4323
4324 if (route_update && advertise_type5_routes(bgp, afi)) {
4325 bgp_evpn_withdraw_type5_routes(bgp, afi, safi);
4326 bgp_evpn_advertise_type5_routes(bgp, afi, safi);
4327 }
4328 }
4329 }
4330
4331 static void bgp_route_map_process_update_cb(char *rmap_name)
4332 {
4333 struct listnode *node, *nnode;
4334 struct bgp *bgp;
4335
4336 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
4337 bgp_route_map_process_update(bgp, rmap_name, true);
4338
4339 #ifdef ENABLE_BGP_VNC
4340 vnc_routemap_update(bgp, __func__);
4341 #endif
4342 }
4343
4344 vpn_policy_routemap_event(rmap_name);
4345 }
4346
4347 void bgp_route_map_update_timer(struct thread *thread)
4348 {
4349 route_map_walk_update_list(bgp_route_map_process_update_cb);
4350 }
4351
4352 static void bgp_route_map_mark_update(const char *rmap_name)
4353 {
4354 struct listnode *node, *nnode;
4355 struct bgp *bgp;
4356
4357 /* If new update is received before the current timer timed out,
4358 * turn it off and start a new timer.
4359 */
4360 THREAD_OFF(bm->t_rmap_update);
4361
4362 /* rmap_update_timer of 0 means don't do route updates */
4363 if (bm->rmap_update_timer) {
4364 thread_add_timer(bm->master, bgp_route_map_update_timer,
4365 NULL, bm->rmap_update_timer,
4366 &bm->t_rmap_update);
4367
4368 /* Signal the groups that a route-map update event has
4369 * started */
4370 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
4371 update_group_policy_update(bgp, BGP_POLICY_ROUTE_MAP,
4372 rmap_name, true, 1);
4373 } else {
4374 for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
4375 bgp_route_map_process_update(bgp, rmap_name, false);
4376 #ifdef ENABLE_BGP_VNC
4377 vnc_routemap_update(bgp, __func__);
4378 #endif
4379 }
4380
4381 vpn_policy_routemap_event(rmap_name);
4382 }
4383 }
4384
4385 static void bgp_route_map_add(const char *rmap_name)
4386 {
4387 if (route_map_mark_updated(rmap_name) == 0)
4388 bgp_route_map_mark_update(rmap_name);
4389
4390 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
4391 }
4392
4393 static void bgp_route_map_delete(const char *rmap_name)
4394 {
4395 if (route_map_mark_updated(rmap_name) == 0)
4396 bgp_route_map_mark_update(rmap_name);
4397
4398 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_DELETED);
4399 }
4400
4401 static void bgp_route_map_event(const char *rmap_name)
4402 {
4403 if (route_map_mark_updated(rmap_name) == 0)
4404 bgp_route_map_mark_update(rmap_name);
4405
4406 route_map_notify_dependencies(rmap_name, RMAP_EVENT_MATCH_ADDED);
4407 }
4408
4409 DEFUN_YANG (match_mac_address,
4410 match_mac_address_cmd,
4411 "match mac address ACCESSLIST_MAC_NAME",
4412 MATCH_STR
4413 "mac address\n"
4414 "Match address of route\n"
4415 "MAC Access-list name\n")
4416 {
4417 const char *xpath =
4418 "./match-condition[condition='frr-bgp-route-map:mac-address-list']";
4419 char xpath_value[XPATH_MAXLEN];
4420
4421 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4422 snprintf(xpath_value, sizeof(xpath_value),
4423 "%s/rmap-match-condition/frr-bgp-route-map:list-name", xpath);
4424 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[3]->arg);
4425
4426 return nb_cli_apply_changes(vty, NULL);
4427 }
4428
4429 DEFUN_YANG (no_match_mac_address,
4430 no_match_mac_address_cmd,
4431 "no match mac address ACCESSLIST_MAC_NAME",
4432 NO_STR
4433 MATCH_STR
4434 "mac\n"
4435 "Match address of route\n"
4436 "MAC acess-list name\n")
4437 {
4438 const char *xpath =
4439 "./match-condition[condition='frr-bgp-route-map:mac-address-list']";
4440
4441 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4442 return nb_cli_apply_changes(vty, NULL);
4443 }
4444
4445 /*
4446 * Helper to handle the case of the user passing in a number or type string
4447 */
4448 static const char *parse_evpn_rt_type(const char *num_rt_type)
4449 {
4450 switch (num_rt_type[0]) {
4451 case '1':
4452 return "ead";
4453 case '2':
4454 return "macip";
4455 case '3':
4456 return "multicast";
4457 case '4':
4458 return "es";
4459 case '5':
4460 return "prefix";
4461 default:
4462 break;
4463 }
4464
4465 /* Was already full type string */
4466 return num_rt_type;
4467 }
4468
4469 DEFUN_YANG (match_evpn_route_type,
4470 match_evpn_route_type_cmd,
4471 "match evpn route-type <ead|1|macip|2|multicast|3|es|4|prefix|5>",
4472 MATCH_STR
4473 EVPN_HELP_STR
4474 EVPN_TYPE_HELP_STR
4475 EVPN_TYPE_1_HELP_STR
4476 EVPN_TYPE_1_HELP_STR
4477 EVPN_TYPE_2_HELP_STR
4478 EVPN_TYPE_2_HELP_STR
4479 EVPN_TYPE_3_HELP_STR
4480 EVPN_TYPE_3_HELP_STR
4481 EVPN_TYPE_4_HELP_STR
4482 EVPN_TYPE_4_HELP_STR
4483 EVPN_TYPE_5_HELP_STR
4484 EVPN_TYPE_5_HELP_STR)
4485 {
4486 const char *xpath =
4487 "./match-condition[condition='frr-bgp-route-map:evpn-route-type']";
4488 char xpath_value[XPATH_MAXLEN];
4489
4490 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4491 snprintf(xpath_value, sizeof(xpath_value),
4492 "%s/rmap-match-condition/frr-bgp-route-map:evpn-route-type",
4493 xpath);
4494 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
4495 parse_evpn_rt_type(argv[3]->arg));
4496
4497 return nb_cli_apply_changes(vty, NULL);
4498 }
4499
4500 DEFUN_YANG (no_match_evpn_route_type,
4501 no_match_evpn_route_type_cmd,
4502 "no match evpn route-type <ead|1|macip|2|multicast|3|es|4|prefix|5>",
4503 NO_STR
4504 MATCH_STR
4505 EVPN_HELP_STR
4506 EVPN_TYPE_HELP_STR
4507 EVPN_TYPE_1_HELP_STR
4508 EVPN_TYPE_1_HELP_STR
4509 EVPN_TYPE_2_HELP_STR
4510 EVPN_TYPE_2_HELP_STR
4511 EVPN_TYPE_3_HELP_STR
4512 EVPN_TYPE_3_HELP_STR
4513 EVPN_TYPE_4_HELP_STR
4514 EVPN_TYPE_4_HELP_STR
4515 EVPN_TYPE_5_HELP_STR
4516 EVPN_TYPE_5_HELP_STR)
4517 {
4518 const char *xpath =
4519 "./match-condition[condition='frr-bgp-route-map:evpn-route-type']";
4520
4521 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4522
4523 return nb_cli_apply_changes(vty, NULL);
4524 }
4525
4526
4527 DEFUN_YANG (match_evpn_vni,
4528 match_evpn_vni_cmd,
4529 "match evpn vni " CMD_VNI_RANGE,
4530 MATCH_STR
4531 EVPN_HELP_STR
4532 "Match VNI\n"
4533 "VNI ID\n")
4534 {
4535 const char *xpath =
4536 "./match-condition[condition='frr-bgp-route-map:evpn-vni']";
4537 char xpath_value[XPATH_MAXLEN];
4538
4539 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4540 snprintf(xpath_value, sizeof(xpath_value),
4541 "%s/rmap-match-condition/frr-bgp-route-map:evpn-vni", xpath);
4542 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[3]->arg);
4543
4544 return nb_cli_apply_changes(vty, NULL);
4545 }
4546
4547 DEFUN_YANG (no_match_evpn_vni,
4548 no_match_evpn_vni_cmd,
4549 "no match evpn vni " CMD_VNI_RANGE,
4550 NO_STR
4551 MATCH_STR
4552 EVPN_HELP_STR
4553 "Match VNI\n"
4554 "VNI ID\n")
4555 {
4556 const char *xpath =
4557 "./match-condition[condition='frr-bgp-route-map:evpn-vni']";
4558 char xpath_value[XPATH_MAXLEN];
4559
4560 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4561 snprintf(xpath_value, sizeof(xpath_value),
4562 "%s/rmap-match-condition/frr-bgp-route-map:evpn-vni", xpath);
4563 nb_cli_enqueue_change(vty, xpath_value, NB_OP_DESTROY, argv[3]->arg);
4564
4565 return nb_cli_apply_changes(vty, NULL);
4566 }
4567
4568 DEFUN_YANG (match_evpn_default_route,
4569 match_evpn_default_route_cmd,
4570 "match evpn default-route",
4571 MATCH_STR
4572 EVPN_HELP_STR
4573 "default EVPN type-5 route\n")
4574 {
4575 const char *xpath =
4576 "./match-condition[condition='frr-bgp-route-map:evpn-default-route']";
4577 char xpath_value[XPATH_MAXLEN];
4578
4579 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4580
4581 snprintf(xpath_value, sizeof(xpath_value),
4582 "%s/rmap-match-condition/frr-bgp-route-map:evpn-default-route",
4583 xpath);
4584 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, NULL);
4585
4586 return nb_cli_apply_changes(vty, NULL);
4587 }
4588
4589 DEFUN_YANG (no_match_evpn_default_route,
4590 no_match_evpn_default_route_cmd,
4591 "no match evpn default-route",
4592 NO_STR
4593 MATCH_STR
4594 EVPN_HELP_STR
4595 "default EVPN type-5 route\n")
4596 {
4597 const char *xpath =
4598 "./match-condition[condition='frr-bgp-route-map:evpn-default-route']";
4599
4600 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4601
4602 return nb_cli_apply_changes(vty, NULL);
4603 }
4604
4605 DEFUN_YANG (match_evpn_rd,
4606 match_evpn_rd_cmd,
4607 "match evpn rd ASN:NN_OR_IP-ADDRESS:NN",
4608 MATCH_STR
4609 EVPN_HELP_STR
4610 "Route Distinguisher\n"
4611 "ASN:XX or A.B.C.D:XX\n")
4612 {
4613 const char *xpath =
4614 "./match-condition[condition='frr-bgp-route-map:evpn-rd']";
4615 char xpath_value[XPATH_MAXLEN];
4616
4617 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4618 snprintf(
4619 xpath_value, sizeof(xpath_value),
4620 "%s/rmap-match-condition/frr-bgp-route-map:route-distinguisher",
4621 xpath);
4622 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[3]->arg);
4623
4624 return nb_cli_apply_changes(vty, NULL);
4625 }
4626
4627 DEFUN_YANG (no_match_evpn_rd,
4628 no_match_evpn_rd_cmd,
4629 "no match evpn rd ASN:NN_OR_IP-ADDRESS:NN",
4630 NO_STR
4631 MATCH_STR
4632 EVPN_HELP_STR
4633 "Route Distinguisher\n"
4634 "ASN:XX or A.B.C.D:XX\n")
4635 {
4636 const char *xpath =
4637 "./match-condition[condition='frr-bgp-route-map:evpn-rd']";
4638
4639 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4640 return nb_cli_apply_changes(vty, NULL);
4641 }
4642
4643 DEFUN_YANG (set_evpn_gw_ip_ipv4,
4644 set_evpn_gw_ip_ipv4_cmd,
4645 "set evpn gateway-ip ipv4 A.B.C.D",
4646 SET_STR
4647 EVPN_HELP_STR
4648 "Set gateway IP for prefix advertisement route\n"
4649 "IPv4 address\n"
4650 "Gateway IP address in IPv4 format\n")
4651 {
4652 int ret;
4653 union sockunion su;
4654 const char *xpath =
4655 "./set-action[action='frr-bgp-route-map:set-evpn-gateway-ip-ipv4']";
4656 char xpath_value[XPATH_MAXLEN];
4657
4658 ret = str2sockunion(argv[4]->arg, &su);
4659 if (ret < 0) {
4660 vty_out(vty, "%% Malformed gateway IP\n");
4661 return CMD_WARNING_CONFIG_FAILED;
4662 }
4663
4664 if (su.sin.sin_addr.s_addr == 0 ||
4665 !ipv4_unicast_valid(&su.sin.sin_addr)) {
4666 vty_out(vty,
4667 "%% Gateway IP cannot be 0.0.0.0, multicast or reserved\n");
4668 return CMD_WARNING_CONFIG_FAILED;
4669 }
4670
4671 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4672
4673 snprintf(xpath_value, sizeof(xpath_value),
4674 "%s/rmap-set-action/frr-bgp-route-map:evpn-gateway-ip-ipv4",
4675 xpath);
4676
4677 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[4]->arg);
4678 return nb_cli_apply_changes(vty, NULL);
4679 }
4680
4681 DEFUN_YANG (no_set_evpn_gw_ip_ipv4,
4682 no_set_evpn_gw_ip_ipv4_cmd,
4683 "no set evpn gateway-ip ipv4 A.B.C.D",
4684 NO_STR
4685 SET_STR
4686 EVPN_HELP_STR
4687 "Set gateway IP for prefix advertisement route\n"
4688 "IPv4 address\n"
4689 "Gateway IP address in IPv4 format\n")
4690 {
4691 int ret;
4692 union sockunion su;
4693 const char *xpath =
4694 "./set-action[action='frr-bgp-route-map:set-evpn-gateway-ip-ipv4']";
4695
4696 ret = str2sockunion(argv[5]->arg, &su);
4697 if (ret < 0) {
4698 vty_out(vty, "%% Malformed gateway IP\n");
4699 return CMD_WARNING_CONFIG_FAILED;
4700 }
4701
4702 if (su.sin.sin_addr.s_addr == 0 ||
4703 !ipv4_unicast_valid(&su.sin.sin_addr)) {
4704 vty_out(vty,
4705 "%% Gateway IP cannot be 0.0.0.0, multicast or reserved\n");
4706 return CMD_WARNING_CONFIG_FAILED;
4707 }
4708
4709 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4710
4711 return nb_cli_apply_changes(vty, NULL);
4712 }
4713
4714 DEFUN_YANG (set_evpn_gw_ip_ipv6,
4715 set_evpn_gw_ip_ipv6_cmd,
4716 "set evpn gateway-ip ipv6 X:X::X:X",
4717 SET_STR
4718 EVPN_HELP_STR
4719 "Set gateway IP for prefix advertisement route\n"
4720 "IPv6 address\n"
4721 "Gateway IP address in IPv6 format\n")
4722 {
4723 int ret;
4724 union sockunion su;
4725 const char *xpath =
4726 "./set-action[action='frr-bgp-route-map:set-evpn-gateway-ip-ipv6']";
4727 char xpath_value[XPATH_MAXLEN];
4728
4729 ret = str2sockunion(argv[4]->arg, &su);
4730 if (ret < 0) {
4731 vty_out(vty, "%% Malformed gateway IP\n");
4732 return CMD_WARNING_CONFIG_FAILED;
4733 }
4734
4735 if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr)
4736 || IN6_IS_ADDR_MULTICAST(&su.sin6.sin6_addr)) {
4737 vty_out(vty,
4738 "%% Gateway IP cannot be a linklocal or multicast address\n");
4739 return CMD_WARNING_CONFIG_FAILED;
4740 }
4741
4742 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4743
4744 snprintf(xpath_value, sizeof(xpath_value),
4745 "%s/rmap-set-action/frr-bgp-route-map:evpn-gateway-ip-ipv6",
4746 xpath);
4747
4748 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[4]->arg);
4749 return nb_cli_apply_changes(vty, NULL);
4750 }
4751
4752 DEFUN_YANG (no_set_evpn_gw_ip_ipv6,
4753 no_set_evpn_gw_ip_ipv6_cmd,
4754 "no set evpn gateway-ip ipv6 X:X::X:X",
4755 NO_STR
4756 SET_STR
4757 EVPN_HELP_STR
4758 "Set gateway IP for prefix advertisement route\n"
4759 "IPv4 address\n"
4760 "Gateway IP address in IPv4 format\n")
4761 {
4762 int ret;
4763 union sockunion su;
4764 const char *xpath =
4765 "./set-action[action='frr-bgp-route-map:set-evpn-gateway-ip-ipv6']";
4766
4767 ret = str2sockunion(argv[5]->arg, &su);
4768 if (ret < 0) {
4769 vty_out(vty, "%% Malformed gateway IP\n");
4770 return CMD_WARNING_CONFIG_FAILED;
4771 }
4772
4773 if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr)
4774 || IN6_IS_ADDR_MULTICAST(&su.sin6.sin6_addr)) {
4775 vty_out(vty,
4776 "%% Gateway IP cannot be a linklocal or multicast address\n");
4777 return CMD_WARNING_CONFIG_FAILED;
4778 }
4779
4780 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4781
4782 return nb_cli_apply_changes(vty, NULL);
4783 }
4784
4785 DEFPY_YANG(match_vrl_source_vrf,
4786 match_vrl_source_vrf_cmd,
4787 "match source-vrf NAME$vrf_name",
4788 MATCH_STR
4789 "source vrf\n"
4790 "The VRF name\n")
4791 {
4792 const char *xpath =
4793 "./match-condition[condition='frr-bgp-route-map:source-vrf']";
4794 char xpath_value[XPATH_MAXLEN];
4795
4796 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4797 snprintf(xpath_value, sizeof(xpath_value),
4798 "%s/rmap-match-condition/frr-bgp-route-map:source-vrf", xpath);
4799 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, vrf_name);
4800
4801 return nb_cli_apply_changes(vty, NULL);
4802 }
4803
4804 DEFPY_YANG(no_match_vrl_source_vrf,
4805 no_match_vrl_source_vrf_cmd,
4806 "no match source-vrf NAME$vrf_name",
4807 NO_STR MATCH_STR
4808 "source vrf\n"
4809 "The VRF name\n")
4810 {
4811 const char *xpath =
4812 "./match-condition[condition='frr-bgp-route-map:source-vrf']";
4813
4814 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4815 return nb_cli_apply_changes(vty, NULL);
4816 }
4817
4818 DEFPY_YANG (match_peer,
4819 match_peer_cmd,
4820 "match peer <A.B.C.D$addrv4|X:X::X:X$addrv6|WORD$intf>",
4821 MATCH_STR
4822 "Match peer address\n"
4823 "IP address of peer\n"
4824 "IPv6 address of peer\n"
4825 "Interface name of peer or peer group name\n")
4826 {
4827 const char *xpath =
4828 "./match-condition[condition='frr-bgp-route-map:peer']";
4829 char xpath_value[XPATH_MAXLEN];
4830
4831 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4832
4833 if (addrv4_str) {
4834 snprintf(
4835 xpath_value, sizeof(xpath_value),
4836 "%s/rmap-match-condition/frr-bgp-route-map:peer-ipv4-address",
4837 xpath);
4838 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
4839 addrv4_str);
4840 } else if (addrv6_str) {
4841 snprintf(
4842 xpath_value, sizeof(xpath_value),
4843 "%s/rmap-match-condition/frr-bgp-route-map:peer-ipv6-address",
4844 xpath);
4845 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
4846 addrv6_str);
4847 } else {
4848 snprintf(
4849 xpath_value, sizeof(xpath_value),
4850 "%s/rmap-match-condition/frr-bgp-route-map:peer-interface",
4851 xpath);
4852 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, intf);
4853 }
4854
4855 return nb_cli_apply_changes(vty, NULL);
4856 }
4857
4858 DEFUN_YANG (match_peer_local,
4859 match_peer_local_cmd,
4860 "match peer local",
4861 MATCH_STR
4862 "Match peer address\n"
4863 "Static or Redistributed routes\n")
4864 {
4865 const char *xpath =
4866 "./match-condition[condition='frr-bgp-route-map:peer']";
4867 char xpath_value[XPATH_MAXLEN];
4868
4869 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4870
4871 snprintf(xpath_value, sizeof(xpath_value),
4872 "%s/rmap-match-condition/frr-bgp-route-map:peer-local", xpath);
4873 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
4874
4875 return nb_cli_apply_changes(vty, NULL);
4876 }
4877
4878 DEFUN_YANG (no_match_peer,
4879 no_match_peer_cmd,
4880 "no match peer [<local|A.B.C.D|X:X::X:X|WORD>]",
4881 NO_STR
4882 MATCH_STR
4883 "Match peer address\n"
4884 "Static or Redistributed routes\n"
4885 "IP address of peer\n"
4886 "IPv6 address of peer\n"
4887 "Interface name of peer\n")
4888 {
4889 const char *xpath =
4890 "./match-condition[condition='frr-bgp-route-map:peer']";
4891
4892 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4893
4894 return nb_cli_apply_changes(vty, NULL);
4895 }
4896
4897 #ifdef HAVE_SCRIPTING
4898 DEFUN_YANG (match_script,
4899 match_script_cmd,
4900 "[no] match script WORD",
4901 NO_STR
4902 MATCH_STR
4903 "Execute script to determine match\n"
4904 "The script name to run, without .lua; e.g. 'myroutemap' to run myroutemap.lua\n")
4905 {
4906 bool no = strmatch(argv[0]->text, "no");
4907 int i = 0;
4908 argv_find(argv, argc, "WORD", &i);
4909 const char *script = argv[i]->arg;
4910 const char *xpath =
4911 "./match-condition[condition='frr-bgp-route-map:match-script']";
4912 char xpath_value[XPATH_MAXLEN];
4913
4914 if (no) {
4915 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4916 snprintf(xpath_value, sizeof(xpath_value),
4917 "%s/rmap-match-condition/frr-bgp-route-map:script",
4918 xpath);
4919 nb_cli_enqueue_change(vty, xpath_value, NB_OP_DESTROY,
4920 script);
4921
4922 return nb_cli_apply_changes(vty, NULL);
4923 }
4924
4925 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4926 snprintf(xpath_value, sizeof(xpath_value),
4927 "%s/rmap-match-condition/frr-bgp-route-map:script",
4928 xpath);
4929 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
4930 script);
4931
4932 return nb_cli_apply_changes(vty, NULL);
4933 }
4934 #endif /* HAVE_SCRIPTING */
4935
4936 /* match probability */
4937 DEFUN_YANG (match_probability,
4938 match_probability_cmd,
4939 "match probability (0-100)",
4940 MATCH_STR
4941 "Match portion of routes defined by percentage value\n"
4942 "Percentage of routes\n")
4943 {
4944 int idx_number = 2;
4945
4946 const char *xpath =
4947 "./match-condition[condition='frr-bgp-route-map:probability']";
4948 char xpath_value[XPATH_MAXLEN];
4949
4950 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
4951 snprintf(xpath_value, sizeof(xpath_value),
4952 "%s/rmap-match-condition/frr-bgp-route-map:probability",
4953 xpath);
4954 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
4955 argv[idx_number]->arg);
4956
4957 return nb_cli_apply_changes(vty, NULL);
4958 }
4959
4960
4961 DEFUN_YANG (no_match_probability,
4962 no_match_probability_cmd,
4963 "no match probability [(1-99)]",
4964 NO_STR
4965 MATCH_STR
4966 "Match portion of routes defined by percentage value\n"
4967 "Percentage of routes\n")
4968 {
4969 int idx_number = 3;
4970 const char *xpath =
4971 "./match-condition[condition='frr-bgp-route-map:probability']";
4972 char xpath_value[XPATH_MAXLEN];
4973
4974 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
4975
4976 if (argc <= idx_number)
4977 return nb_cli_apply_changes(vty, NULL);
4978
4979 snprintf(xpath_value, sizeof(xpath_value),
4980 "%s/rmap-match-condition/frr-bgp-route-map:probability",
4981 xpath);
4982 nb_cli_enqueue_change(vty, xpath_value, NB_OP_DESTROY,
4983 argv[idx_number]->arg);
4984
4985 return nb_cli_apply_changes(vty, NULL);
4986 }
4987
4988
4989 DEFPY_YANG (match_ip_route_source,
4990 match_ip_route_source_cmd,
4991 "match ip route-source ACCESSLIST4_NAME",
4992 MATCH_STR
4993 IP_STR
4994 "Match advertising source address of route\n"
4995 "IP Access-list name\n")
4996 {
4997 const char *xpath =
4998 "./match-condition[condition='frr-bgp-route-map:ip-route-source']";
4999 char xpath_value[XPATH_MAXLEN + 32];
5000 int idx_acl = 3;
5001
5002 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5003 snprintf(xpath_value, sizeof(xpath_value),
5004 "%s/rmap-match-condition/frr-bgp-route-map:list-name",
5005 xpath);
5006 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5007 argv[idx_acl]->arg);
5008
5009 return nb_cli_apply_changes(vty, NULL);
5010 }
5011
5012
5013 DEFUN_YANG (no_match_ip_route_source,
5014 no_match_ip_route_source_cmd,
5015 "no match ip route-source [ACCESSLIST4_NAME]",
5016 NO_STR
5017 MATCH_STR
5018 IP_STR
5019 "Match advertising source address of route\n"
5020 "IP Access-list name\n")
5021 {
5022 const char *xpath =
5023 "./match-condition[condition='frr-bgp-route-map:ip-route-source']";
5024
5025 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5026 return nb_cli_apply_changes(vty, NULL);
5027 }
5028
5029 DEFUN_YANG (match_ip_route_source_prefix_list,
5030 match_ip_route_source_prefix_list_cmd,
5031 "match ip route-source prefix-list PREFIXLIST_NAME",
5032 MATCH_STR
5033 IP_STR
5034 "Match advertising source address of route\n"
5035 "Match entries of prefix-lists\n"
5036 "IP prefix-list name\n")
5037 {
5038 int idx_word = 4;
5039 const char *xpath =
5040 "./match-condition[condition='frr-bgp-route-map:ip-route-source-prefix-list']";
5041 char xpath_value[XPATH_MAXLEN + 32];
5042
5043 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5044 snprintf(xpath_value, sizeof(xpath_value),
5045 "%s/rmap-match-condition/frr-bgp-route-map:list-name", xpath);
5046 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5047 argv[idx_word]->arg);
5048
5049 return nb_cli_apply_changes(vty, NULL);
5050 }
5051
5052
5053 DEFUN_YANG (no_match_ip_route_source_prefix_list,
5054 no_match_ip_route_source_prefix_list_cmd,
5055 "no match ip route-source prefix-list [PREFIXLIST_NAME]",
5056 NO_STR
5057 MATCH_STR
5058 IP_STR
5059 "Match advertising source address of route\n"
5060 "Match entries of prefix-lists\n"
5061 "IP prefix-list name\n")
5062 {
5063 const char *xpath =
5064 "./match-condition[condition='frr-bgp-route-map:ip-route-source-prefix-list']";
5065
5066 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5067 return nb_cli_apply_changes(vty, NULL);
5068 }
5069
5070 DEFUN_YANG (match_local_pref,
5071 match_local_pref_cmd,
5072 "match local-preference (0-4294967295)",
5073 MATCH_STR
5074 "Match local-preference of route\n"
5075 "Metric value\n")
5076 {
5077 int idx_number = 2;
5078
5079 const char *xpath =
5080 "./match-condition[condition='frr-bgp-route-map:match-local-preference']";
5081 char xpath_value[XPATH_MAXLEN];
5082
5083 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5084 snprintf(xpath_value, sizeof(xpath_value),
5085 "%s/rmap-match-condition/frr-bgp-route-map:local-preference",
5086 xpath);
5087 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5088 argv[idx_number]->arg);
5089
5090 return nb_cli_apply_changes(vty, NULL);
5091 }
5092
5093
5094 DEFUN_YANG (no_match_local_pref,
5095 no_match_local_pref_cmd,
5096 "no match local-preference [(0-4294967295)]",
5097 NO_STR
5098 MATCH_STR
5099 "Match local preference of route\n"
5100 "Local preference value\n")
5101 {
5102 int idx_localpref = 3;
5103 const char *xpath =
5104 "./match-condition[condition='frr-bgp-route-map:match-local-preference']";
5105 char xpath_value[XPATH_MAXLEN];
5106
5107 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5108
5109 if (argc <= idx_localpref)
5110 return nb_cli_apply_changes(vty, NULL);
5111
5112 snprintf(xpath_value, sizeof(xpath_value),
5113 "%s/rmap-match-condition/frr-bgp-route-map:local-preference",
5114 xpath);
5115 nb_cli_enqueue_change(vty, xpath_value, NB_OP_DESTROY,
5116 argv[idx_localpref]->arg);
5117
5118 return nb_cli_apply_changes(vty, NULL);
5119 }
5120
5121 DEFUN_YANG(match_alias, match_alias_cmd, "match alias ALIAS_NAME",
5122 MATCH_STR
5123 "Match BGP community alias name\n"
5124 "BGP community alias name\n")
5125 {
5126 const char *alias = argv[2]->arg;
5127 struct community_alias ca1;
5128 struct community_alias *lookup_alias;
5129
5130 const char *xpath =
5131 "./match-condition[condition='frr-bgp-route-map:match-alias']";
5132 char xpath_value[XPATH_MAXLEN];
5133
5134 memset(&ca1, 0, sizeof(ca1));
5135 strlcpy(ca1.alias, alias, sizeof(ca1.alias));
5136 lookup_alias = bgp_ca_alias_lookup(&ca1);
5137 if (!lookup_alias) {
5138 vty_out(vty, "%% BGP alias name '%s' does not exist\n", alias);
5139 return CMD_WARNING_CONFIG_FAILED;
5140 }
5141
5142 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5143 snprintf(xpath_value, sizeof(xpath_value),
5144 "%s/rmap-match-condition/frr-bgp-route-map:alias", xpath);
5145 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, alias);
5146
5147 return nb_cli_apply_changes(vty, NULL);
5148 }
5149
5150
5151 DEFUN_YANG(no_match_alias, no_match_alias_cmd, "no match alias [ALIAS_NAME]",
5152 NO_STR MATCH_STR
5153 "Match BGP community alias name\n"
5154 "BGP community alias name\n")
5155 {
5156 int idx_alias = 3;
5157 const char *xpath =
5158 "./match-condition[condition='frr-bgp-route-map:match-alias']";
5159 char xpath_value[XPATH_MAXLEN];
5160
5161 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5162
5163 if (argc <= idx_alias)
5164 return nb_cli_apply_changes(vty, NULL);
5165
5166 snprintf(xpath_value, sizeof(xpath_value),
5167 "%s/rmap-match-condition/frr-bgp-route-map:alias", xpath);
5168 nb_cli_enqueue_change(vty, xpath_value, NB_OP_DESTROY,
5169 argv[idx_alias]->arg);
5170
5171 return nb_cli_apply_changes(vty, NULL);
5172 }
5173
5174 DEFPY_YANG (match_community,
5175 match_community_cmd,
5176 "match community <(1-99)|(100-500)|COMMUNITY_LIST_NAME> [exact-match]",
5177 MATCH_STR
5178 "Match BGP community list\n"
5179 "Community-list number (standard)\n"
5180 "Community-list number (expanded)\n"
5181 "Community-list name\n"
5182 "Do exact matching of communities\n")
5183 {
5184 const char *xpath =
5185 "./match-condition[condition='frr-bgp-route-map:match-community']";
5186 char xpath_value[XPATH_MAXLEN];
5187 char xpath_match[XPATH_MAXLEN];
5188 int idx_comm_list = 2;
5189
5190 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5191
5192 snprintf(
5193 xpath_value, sizeof(xpath_value),
5194 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name",
5195 xpath);
5196 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[idx_comm_list]->arg);
5197
5198 if (argc == 4) {
5199 snprintf(
5200 xpath_match, sizeof(xpath_match),
5201 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name-exact-match",
5202 xpath);
5203 nb_cli_enqueue_change(vty, xpath_match, NB_OP_MODIFY,
5204 "true");
5205 } else {
5206 snprintf(
5207 xpath_match, sizeof(xpath_match),
5208 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name-exact-match",
5209 xpath);
5210 nb_cli_enqueue_change(vty, xpath_match, NB_OP_MODIFY,
5211 "false");
5212 }
5213
5214 return nb_cli_apply_changes(vty, NULL);
5215 }
5216
5217 DEFUN_YANG (no_match_community,
5218 no_match_community_cmd,
5219 "no match community [<(1-99)|(100-500)|COMMUNITY_LIST_NAME> [exact-match]]",
5220 NO_STR
5221 MATCH_STR
5222 "Match BGP community list\n"
5223 "Community-list number (standard)\n"
5224 "Community-list number (expanded)\n"
5225 "Community-list name\n"
5226 "Do exact matching of communities\n")
5227 {
5228 const char *xpath =
5229 "./match-condition[condition='frr-bgp-route-map:match-community']";
5230
5231 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5232 return nb_cli_apply_changes(vty, NULL);
5233 }
5234
5235 DEFPY_YANG (match_lcommunity,
5236 match_lcommunity_cmd,
5237 "match large-community <(1-99)|(100-500)|LCOMMUNITY_LIST_NAME> [exact-match]",
5238 MATCH_STR
5239 "Match BGP large community list\n"
5240 "Large Community-list number (standard)\n"
5241 "Large Community-list number (expanded)\n"
5242 "Large Community-list name\n"
5243 "Do exact matching of communities\n")
5244 {
5245 const char *xpath =
5246 "./match-condition[condition='frr-bgp-route-map:match-large-community']";
5247 char xpath_value[XPATH_MAXLEN];
5248 char xpath_match[XPATH_MAXLEN];
5249 int idx_lcomm_list = 2;
5250
5251 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5252
5253 snprintf(
5254 xpath_value, sizeof(xpath_value),
5255 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name",
5256 xpath);
5257 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[idx_lcomm_list]->arg);
5258
5259 if (argc == 4) {
5260 snprintf(
5261 xpath_match, sizeof(xpath_match),
5262 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name-exact-match",
5263 xpath);
5264 nb_cli_enqueue_change(vty, xpath_match, NB_OP_MODIFY,
5265 "true");
5266 } else {
5267 snprintf(
5268 xpath_match, sizeof(xpath_match),
5269 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name-exact-match",
5270 xpath);
5271 nb_cli_enqueue_change(vty, xpath_match, NB_OP_MODIFY,
5272 "false");
5273 }
5274
5275 return nb_cli_apply_changes(vty, NULL);
5276 }
5277
5278 DEFUN_YANG (no_match_lcommunity,
5279 no_match_lcommunity_cmd,
5280 "no match large-community [<(1-99)|(100-500)|LCOMMUNITY_LIST_NAME> [exact-match]]",
5281 NO_STR
5282 MATCH_STR
5283 "Match BGP large community list\n"
5284 "Large Community-list number (standard)\n"
5285 "Large Community-list number (expanded)\n"
5286 "Large Community-list name\n"
5287 "Do exact matching of communities\n")
5288 {
5289 const char *xpath =
5290 "./match-condition[condition='frr-bgp-route-map:match-large-community']";
5291
5292 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5293 return nb_cli_apply_changes(vty, NULL);
5294 }
5295
5296 DEFPY_YANG (match_ecommunity,
5297 match_ecommunity_cmd,
5298 "match extcommunity <(1-99)|(100-500)|EXTCOMMUNITY_LIST_NAME>",
5299 MATCH_STR
5300 "Match BGP/VPN extended community list\n"
5301 "Extended community-list number (standard)\n"
5302 "Extended community-list number (expanded)\n"
5303 "Extended community-list name\n")
5304 {
5305 const char *xpath =
5306 "./match-condition[condition='frr-bgp-route-map:match-extcommunity']";
5307 char xpath_value[XPATH_MAXLEN];
5308 int idx_comm_list = 2;
5309
5310 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5311
5312 snprintf(
5313 xpath_value, sizeof(xpath_value),
5314 "%s/rmap-match-condition/frr-bgp-route-map:comm-list/comm-list-name",
5315 xpath);
5316 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[idx_comm_list]->arg);
5317
5318 return nb_cli_apply_changes(vty, NULL);
5319 }
5320
5321
5322 DEFUN_YANG (no_match_ecommunity,
5323 no_match_ecommunity_cmd,
5324 "no match extcommunity [<(1-99)|(100-500)|EXTCOMMUNITY_LIST_NAME>]",
5325 NO_STR
5326 MATCH_STR
5327 "Match BGP/VPN extended community list\n"
5328 "Extended community-list number (standard)\n"
5329 "Extended community-list number (expanded)\n"
5330 "Extended community-list name\n")
5331 {
5332 const char *xpath =
5333 "./match-condition[condition='frr-bgp-route-map:match-extcommunity']";
5334
5335 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5336 return nb_cli_apply_changes(vty, NULL);
5337 }
5338
5339
5340 DEFUN_YANG (match_aspath,
5341 match_aspath_cmd,
5342 "match as-path AS_PATH_FILTER_NAME",
5343 MATCH_STR
5344 "Match BGP AS path list\n"
5345 "AS path access-list name\n")
5346 {
5347 int idx_word = 2;
5348
5349 const char *xpath =
5350 "./match-condition[condition='frr-bgp-route-map:as-path-list']";
5351 char xpath_value[XPATH_MAXLEN];
5352
5353 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5354 snprintf(xpath_value, sizeof(xpath_value),
5355 "%s/rmap-match-condition/frr-bgp-route-map:list-name", xpath);
5356 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5357 argv[idx_word]->arg);
5358
5359 return nb_cli_apply_changes(vty, NULL);
5360 }
5361
5362
5363 DEFUN_YANG (no_match_aspath,
5364 no_match_aspath_cmd,
5365 "no match as-path [AS_PATH_FILTER_NAME]",
5366 NO_STR
5367 MATCH_STR
5368 "Match BGP AS path list\n"
5369 "AS path access-list name\n")
5370 {
5371 const char *xpath =
5372 "./match-condition[condition='frr-bgp-route-map:as-path-list']";
5373
5374 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5375
5376 return nb_cli_apply_changes(vty, NULL);
5377 }
5378
5379 DEFUN_YANG (match_origin,
5380 match_origin_cmd,
5381 "match origin <egp|igp|incomplete>",
5382 MATCH_STR
5383 "BGP origin code\n"
5384 "remote EGP\n"
5385 "local IGP\n"
5386 "unknown heritage\n")
5387 {
5388 int idx_origin = 2;
5389 const char *origin_type;
5390 const char *xpath =
5391 "./match-condition[condition='frr-bgp-route-map:match-origin']";
5392 char xpath_value[XPATH_MAXLEN];
5393
5394 if (strncmp(argv[idx_origin]->arg, "igp", 2) == 0)
5395 origin_type = "igp";
5396 else if (strncmp(argv[idx_origin]->arg, "egp", 1) == 0)
5397 origin_type = "egp";
5398 else if (strncmp(argv[idx_origin]->arg, "incomplete", 2) == 0)
5399 origin_type = "incomplete";
5400 else {
5401 vty_out(vty, "%% Invalid match origin type\n");
5402 return CMD_WARNING_CONFIG_FAILED;
5403 }
5404
5405 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5406 snprintf(xpath_value, sizeof(xpath_value),
5407 "%s/rmap-match-condition/frr-bgp-route-map:origin", xpath);
5408 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, origin_type);
5409
5410 return nb_cli_apply_changes(vty, NULL);
5411 }
5412
5413
5414 DEFUN_YANG (no_match_origin,
5415 no_match_origin_cmd,
5416 "no match origin [<egp|igp|incomplete>]",
5417 NO_STR
5418 MATCH_STR
5419 "BGP origin code\n"
5420 "remote EGP\n"
5421 "local IGP\n"
5422 "unknown heritage\n")
5423 {
5424 const char *xpath =
5425 "./match-condition[condition='frr-bgp-route-map:match-origin']";
5426 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5427 return nb_cli_apply_changes(vty, NULL);
5428 }
5429
5430 DEFUN_YANG (set_table_id,
5431 set_table_id_cmd,
5432 "set table (1-4294967295)",
5433 SET_STR
5434 "export route to non-main kernel table\n"
5435 "Kernel routing table id\n")
5436 {
5437 int idx_number = 2;
5438 const char *xpath = "./set-action[action='frr-bgp-route-map:table']";
5439 char xpath_value[XPATH_MAXLEN];
5440
5441 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5442 snprintf(xpath_value, sizeof(xpath_value),
5443 "%s/rmap-set-action/frr-bgp-route-map:table", xpath);
5444 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5445 argv[idx_number]->arg);
5446 return nb_cli_apply_changes(vty, NULL);
5447 }
5448
5449 DEFUN_YANG (no_set_table_id,
5450 no_set_table_id_cmd,
5451 "no set table",
5452 NO_STR
5453 SET_STR
5454 "export route to non-main kernel table\n")
5455 {
5456 const char *xpath = "./set-action[action='frr-bgp-route-map:table']";
5457 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5458 return nb_cli_apply_changes(vty, NULL);
5459 }
5460
5461 DEFUN_YANG (set_ip_nexthop_peer,
5462 set_ip_nexthop_peer_cmd,
5463 "[no] set ip next-hop peer-address",
5464 NO_STR
5465 SET_STR
5466 IP_STR
5467 "Next hop address\n"
5468 "Use peer address (for BGP only)\n")
5469 {
5470 char xpath_value[XPATH_MAXLEN];
5471 const char *xpath =
5472 "./set-action[action='frr-bgp-route-map:set-ipv4-nexthop']";
5473
5474 if (strmatch(argv[0]->text, "no"))
5475 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5476 else {
5477 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5478 snprintf(xpath_value, sizeof(xpath_value),
5479 "%s/rmap-set-action/frr-bgp-route-map:ipv4-nexthop",
5480 xpath);
5481 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5482 "peer-address");
5483 }
5484 return nb_cli_apply_changes(vty, NULL);
5485 }
5486
5487 DEFUN_YANG (set_ip_nexthop_unchanged,
5488 set_ip_nexthop_unchanged_cmd,
5489 "[no] set ip next-hop unchanged",
5490 NO_STR
5491 SET_STR
5492 IP_STR
5493 "Next hop address\n"
5494 "Don't modify existing Next hop address\n")
5495 {
5496 char xpath_value[XPATH_MAXLEN];
5497 const char *xpath =
5498 "./set-action[action='frr-bgp-route-map:set-ipv4-nexthop']";
5499
5500 if (strmatch(argv[0]->text, "no"))
5501 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5502 else {
5503 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5504 snprintf(xpath_value, sizeof(xpath_value),
5505 "%s/rmap-set-action/frr-bgp-route-map:ipv4-nexthop",
5506 xpath);
5507 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5508 "unchanged");
5509 }
5510 return nb_cli_apply_changes(vty, NULL);
5511 }
5512
5513 DEFUN_YANG (set_distance,
5514 set_distance_cmd,
5515 "set distance (0-255)",
5516 SET_STR
5517 "BGP Administrative Distance to use\n"
5518 "Distance value\n")
5519 {
5520 int idx_number = 2;
5521 const char *xpath = "./set-action[action='frr-bgp-route-map:distance']";
5522 char xpath_value[XPATH_MAXLEN];
5523
5524 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5525 snprintf(xpath_value, sizeof(xpath_value),
5526 "%s/rmap-set-action/frr-bgp-route-map:distance", xpath);
5527 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5528 argv[idx_number]->arg);
5529 return nb_cli_apply_changes(vty, NULL);
5530 }
5531
5532 DEFUN_YANG (no_set_distance,
5533 no_set_distance_cmd,
5534 "no set distance [(0-255)]",
5535 NO_STR SET_STR
5536 "BGP Administrative Distance to use\n"
5537 "Distance value\n")
5538 {
5539 const char *xpath = "./set-action[action='frr-bgp-route-map:distance']";
5540
5541 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5542 return nb_cli_apply_changes(vty, NULL);
5543 }
5544
5545 DEFPY_YANG(set_l3vpn_nexthop_encapsulation, set_l3vpn_nexthop_encapsulation_cmd,
5546 "[no] set l3vpn next-hop encapsulation gre",
5547 NO_STR SET_STR
5548 "L3VPN operations\n"
5549 "Next hop Information\n"
5550 "Encapsulation options (for BGP only)\n"
5551 "Accept L3VPN traffic over GRE encapsulation\n")
5552 {
5553 const char *xpath =
5554 "./set-action[action='frr-bgp-route-map:set-l3vpn-nexthop-encapsulation']";
5555 const char *xpath_value =
5556 "./set-action[action='frr-bgp-route-map:set-l3vpn-nexthop-encapsulation']/rmap-set-action/frr-bgp-route-map:l3vpn-nexthop-encapsulation";
5557 enum nb_operation operation;
5558
5559 if (no)
5560 operation = NB_OP_DESTROY;
5561 else
5562 operation = NB_OP_CREATE;
5563
5564 nb_cli_enqueue_change(vty, xpath, operation, NULL);
5565 if (operation == NB_OP_DESTROY)
5566 return nb_cli_apply_changes(vty, NULL);
5567
5568 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "gre");
5569
5570 return nb_cli_apply_changes(vty, NULL);
5571 }
5572
5573 DEFUN_YANG (set_local_pref,
5574 set_local_pref_cmd,
5575 "set local-preference WORD",
5576 SET_STR
5577 "BGP local preference path attribute\n"
5578 "Preference value (0-4294967295)\n")
5579 {
5580 int idx_number = 2;
5581 const char *xpath =
5582 "./set-action[action='frr-bgp-route-map:set-local-preference']";
5583 char xpath_value[XPATH_MAXLEN];
5584
5585 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5586 snprintf(xpath_value, sizeof(xpath_value),
5587 "%s/rmap-set-action/frr-bgp-route-map:local-pref", xpath);
5588 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5589 argv[idx_number]->arg);
5590 return nb_cli_apply_changes(vty, NULL);
5591 }
5592
5593 DEFUN_YANG (no_set_local_pref,
5594 no_set_local_pref_cmd,
5595 "no set local-preference [WORD]",
5596 NO_STR
5597 SET_STR
5598 "BGP local preference path attribute\n"
5599 "Preference value (0-4294967295)\n")
5600 {
5601 const char *xpath =
5602 "./set-action[action='frr-bgp-route-map:set-local-preference']";
5603
5604 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5605 return nb_cli_apply_changes(vty, NULL);
5606 }
5607
5608 DEFUN_YANG (set_weight,
5609 set_weight_cmd,
5610 "set weight (0-4294967295)",
5611 SET_STR
5612 "BGP weight for routing table\n"
5613 "Weight value\n")
5614 {
5615 int idx_number = 2;
5616 const char *xpath = "./set-action[action='frr-bgp-route-map:weight']";
5617 char xpath_value[XPATH_MAXLEN];
5618
5619 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5620 snprintf(xpath_value, sizeof(xpath_value),
5621 "%s/rmap-set-action/frr-bgp-route-map:weight", xpath);
5622 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5623 argv[idx_number]->arg);
5624 return nb_cli_apply_changes(vty, NULL);
5625 }
5626
5627 DEFUN_YANG (no_set_weight,
5628 no_set_weight_cmd,
5629 "no set weight [(0-4294967295)]",
5630 NO_STR
5631 SET_STR
5632 "BGP weight for routing table\n"
5633 "Weight value\n")
5634 {
5635 const char *xpath = "./set-action[action='frr-bgp-route-map:weight']";
5636
5637 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5638 return nb_cli_apply_changes(vty, NULL);
5639 }
5640
5641 DEFUN_YANG (set_label_index,
5642 set_label_index_cmd,
5643 "set label-index (0-1048560)",
5644 SET_STR
5645 "Label index to associate with the prefix\n"
5646 "Label index value\n")
5647 {
5648 int idx_number = 2;
5649 const char *xpath =
5650 "./set-action[action='frr-bgp-route-map:label-index']";
5651 char xpath_value[XPATH_MAXLEN];
5652
5653 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5654 snprintf(xpath_value, sizeof(xpath_value),
5655 "%s/rmap-set-action/frr-bgp-route-map:label-index", xpath);
5656 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5657 argv[idx_number]->arg);
5658 return nb_cli_apply_changes(vty, NULL);
5659 }
5660
5661 DEFUN_YANG (no_set_label_index,
5662 no_set_label_index_cmd,
5663 "no set label-index [(0-1048560)]",
5664 NO_STR
5665 SET_STR
5666 "Label index to associate with the prefix\n"
5667 "Label index value\n")
5668 {
5669 const char *xpath =
5670 "./set-action[action='frr-bgp-route-map:label-index']";
5671
5672 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5673 return nb_cli_apply_changes(vty, NULL);
5674 }
5675
5676 DEFUN_YANG (set_aspath_prepend_asn,
5677 set_aspath_prepend_asn_cmd,
5678 "set as-path prepend ASNUM...",
5679 SET_STR
5680 "Transform BGP AS_PATH attribute\n"
5681 "Prepend to the as-path\n"
5682 AS_STR)
5683 {
5684 int idx_asn = 3;
5685 int ret;
5686 char *str;
5687 struct aspath *aspath;
5688
5689 str = argv_concat(argv, argc, idx_asn);
5690
5691 const char *xpath =
5692 "./set-action[action='frr-bgp-route-map:as-path-prepend']";
5693 char xpath_value[XPATH_MAXLEN];
5694
5695 aspath = route_aspath_compile(str);
5696 if (!aspath) {
5697 vty_out(vty, "%% Invalid AS path value %s\n", str);
5698 return CMD_WARNING_CONFIG_FAILED;
5699 }
5700 route_aspath_free(aspath);
5701 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5702 snprintf(xpath_value, sizeof(xpath_value),
5703 "%s/rmap-set-action/frr-bgp-route-map:prepend-as-path", xpath);
5704 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
5705 ret = nb_cli_apply_changes(vty, NULL);
5706 XFREE(MTYPE_TMP, str);
5707 return ret;
5708 }
5709
5710 DEFUN_YANG (set_aspath_prepend_lastas,
5711 set_aspath_prepend_lastas_cmd,
5712 "set as-path prepend last-as (1-10)",
5713 SET_STR
5714 "Transform BGP AS_PATH attribute\n"
5715 "Prepend to the as-path\n"
5716 "Use the last AS-number in the as-path\n"
5717 "Number of times to insert\n")
5718 {
5719 int idx_num = 4;
5720
5721 const char *xpath =
5722 "./set-action[action='frr-bgp-route-map:as-path-prepend']";
5723 char xpath_value[XPATH_MAXLEN];
5724
5725 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5726 snprintf(xpath_value, sizeof(xpath_value),
5727 "%s/rmap-set-action/frr-bgp-route-map:last-as", xpath);
5728 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
5729 argv[idx_num]->arg);
5730 return nb_cli_apply_changes(vty, NULL);
5731 }
5732
5733 DEFPY_YANG (set_aspath_replace_asn,
5734 set_aspath_replace_asn_cmd,
5735 "set as-path replace <any|ASNUM>$replace",
5736 SET_STR
5737 "Transform BGP AS_PATH attribute\n"
5738 "Replace AS number to local AS number\n"
5739 "Replace any AS number to local AS number\n"
5740 "Replace a specific AS number in plain or dotted format to local AS number\n")
5741 {
5742 const char *xpath =
5743 "./set-action[action='frr-bgp-route-map:as-path-replace']";
5744 char xpath_value[XPATH_MAXLEN];
5745 as_t as_value;
5746
5747 if (!strmatch(replace, "any") && !asn_str2asn(replace, &as_value)) {
5748 vty_out(vty, "%% Invalid AS value %s\n", replace);
5749 return CMD_WARNING_CONFIG_FAILED;
5750 }
5751
5752 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5753 snprintf(xpath_value, sizeof(xpath_value),
5754 "%s/rmap-set-action/frr-bgp-route-map:replace-as-path", xpath);
5755 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, replace);
5756 return nb_cli_apply_changes(vty, NULL);
5757 }
5758
5759 DEFPY_YANG (no_set_aspath_replace_asn,
5760 no_set_aspath_replace_asn_cmd,
5761 "no set as-path replace [<any|ASNUM>]",
5762 NO_STR
5763 SET_STR
5764 "Transform BGP AS_PATH attribute\n"
5765 "Replace AS number to local AS number\n"
5766 "Replace any AS number to local AS number\n"
5767 "Replace a specific AS number in plain or dotted format to local AS number\n")
5768 {
5769 const char *xpath =
5770 "./set-action[action='frr-bgp-route-map:as-path-replace']";
5771
5772 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5773 return nb_cli_apply_changes(vty, NULL);
5774 }
5775
5776 DEFUN_YANG (no_set_aspath_prepend,
5777 no_set_aspath_prepend_cmd,
5778 "no set as-path prepend [ASNUM]",
5779 NO_STR
5780 SET_STR
5781 "Transform BGP AS_PATH attribute\n"
5782 "Prepend to the as-path\n"
5783 AS_STR)
5784 {
5785 const char *xpath =
5786 "./set-action[action='frr-bgp-route-map:as-path-prepend']";
5787
5788 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5789 return nb_cli_apply_changes(vty, NULL);
5790 }
5791
5792 DEFUN_YANG (no_set_aspath_prepend_lastas,
5793 no_set_aspath_prepend_lastas_cmd,
5794 "no set as-path prepend last-as [(1-10)]",
5795 NO_STR
5796 SET_STR
5797 "Transform BGP AS_PATH attribute\n"
5798 "Prepend to the as-path\n"
5799 "Use the peers AS-number\n"
5800 "Number of times to insert\n")
5801 {
5802 const char *xpath =
5803 "./set-action[action='frr-bgp-route-map:as-path-prepend']";
5804
5805 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5806 return nb_cli_apply_changes(vty, NULL);
5807 }
5808
5809 DEFUN_YANG (set_aspath_exclude,
5810 set_aspath_exclude_cmd,
5811 "set as-path exclude ASNUM...",
5812 SET_STR
5813 "Transform BGP AS-path attribute\n"
5814 "Exclude from the as-path\n"
5815 AS_STR)
5816 {
5817 int idx_asn = 3;
5818 int ret;
5819 char *str;
5820 struct aspath *aspath;
5821
5822 str = argv_concat(argv, argc, idx_asn);
5823
5824 const char *xpath =
5825 "./set-action[action='frr-bgp-route-map:as-path-exclude']";
5826 char xpath_value[XPATH_MAXLEN];
5827
5828 aspath = route_aspath_compile(str);
5829 if (!aspath) {
5830 vty_out(vty, "%% Invalid AS path value %s\n", str);
5831 return CMD_WARNING_CONFIG_FAILED;
5832 }
5833 route_aspath_free(aspath);
5834 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5835 snprintf(xpath_value, sizeof(xpath_value),
5836 "%s/rmap-set-action/frr-bgp-route-map:exclude-as-path", xpath);
5837 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
5838 ret = nb_cli_apply_changes(vty, NULL);
5839 XFREE(MTYPE_TMP, str);
5840 return ret;
5841 }
5842
5843 DEFUN_YANG (no_set_aspath_exclude,
5844 no_set_aspath_exclude_cmd,
5845 "no set as-path exclude ASNUM...",
5846 NO_STR
5847 SET_STR
5848 "Transform BGP AS_PATH attribute\n"
5849 "Exclude from the as-path\n"
5850 "AS number\n")
5851 {
5852 const char *xpath =
5853 "./set-action[action='frr-bgp-route-map:as-path-exclude']";
5854
5855 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
5856 return nb_cli_apply_changes(vty, NULL);
5857 }
5858
5859 ALIAS_YANG (no_set_aspath_exclude, no_set_aspath_exclude_all_cmd,
5860 "no set as-path exclude",
5861 NO_STR SET_STR
5862 "Transform BGP AS_PATH attribute\n"
5863 "Exclude from the as-path\n")
5864
5865 DEFUN_YANG (set_community,
5866 set_community_cmd,
5867 "set community AA:NN...",
5868 SET_STR
5869 "BGP community attribute\n"
5870 COMMUNITY_VAL_STR)
5871 {
5872 int idx_aa_nn = 2;
5873 int i;
5874 int first = 0;
5875 int additive = 0;
5876 struct buffer *b;
5877 struct community *com = NULL;
5878 char *str;
5879 char *argstr = NULL;
5880 int ret;
5881
5882 const char *xpath =
5883 "./set-action[action='frr-bgp-route-map:set-community']";
5884 char xpath_value[XPATH_MAXLEN];
5885
5886 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5887 snprintf(xpath_value, sizeof(xpath_value),
5888 "%s/rmap-set-action/frr-bgp-route-map:community-string",
5889 xpath);
5890
5891 b = buffer_new(1024);
5892
5893 for (i = idx_aa_nn; i < argc; i++) {
5894 if (strncmp(argv[i]->arg, "additive", strlen(argv[i]->arg))
5895 == 0) {
5896 additive = 1;
5897 continue;
5898 }
5899
5900 if (first)
5901 buffer_putc(b, ' ');
5902 else
5903 first = 1;
5904
5905 #if CONFDATE > 20230801
5906 CPP_NOTICE("Deprecate COMMUNITY_INTERNET BGP community")
5907 #endif
5908 if (strncmp(argv[i]->arg, "internet", strlen(argv[i]->arg))
5909 == 0) {
5910 buffer_putstr(b, "internet");
5911 vty_out(vty, "%% `internet` community is deprecated\n");
5912 zlog_warn("`internet` community is deprecated");
5913 continue;
5914 }
5915 if (strncmp(argv[i]->arg, "local-AS", strlen(argv[i]->arg))
5916 == 0) {
5917 buffer_putstr(b, "local-AS");
5918 continue;
5919 }
5920 if (strncmp(argv[i]->arg, "no-a", strlen("no-a")) == 0
5921 && strncmp(argv[i]->arg, "no-advertise",
5922 strlen(argv[i]->arg))
5923 == 0) {
5924 buffer_putstr(b, "no-advertise");
5925 continue;
5926 }
5927 if (strncmp(argv[i]->arg, "no-e", strlen("no-e")) == 0
5928 && strncmp(argv[i]->arg, "no-export", strlen(argv[i]->arg))
5929 == 0) {
5930 buffer_putstr(b, "no-export");
5931 continue;
5932 }
5933 if (strncmp(argv[i]->arg, "blackhole", strlen(argv[i]->arg))
5934 == 0) {
5935 buffer_putstr(b, "blackhole");
5936 continue;
5937 }
5938 if (strncmp(argv[i]->arg, "graceful-shutdown",
5939 strlen(argv[i]->arg))
5940 == 0) {
5941 buffer_putstr(b, "graceful-shutdown");
5942 continue;
5943 }
5944 buffer_putstr(b, argv[i]->arg);
5945 }
5946 buffer_putc(b, '\0');
5947
5948 /* Fetch result string then compile it to communities attribute. */
5949 str = buffer_getstr(b);
5950 buffer_free(b);
5951
5952 if (str)
5953 com = community_str2com(str);
5954
5955 /* Can't compile user input into communities attribute. */
5956 if (!com) {
5957 vty_out(vty, "%% Malformed communities attribute '%s'\n", str);
5958 XFREE(MTYPE_TMP, str);
5959 return CMD_WARNING_CONFIG_FAILED;
5960 }
5961 XFREE(MTYPE_TMP, str);
5962
5963 /* Set communites attribute string. */
5964 str = community_str(com, false, false);
5965
5966 if (additive) {
5967 size_t argstr_sz = strlen(str) + strlen(" additive") + 1;
5968 argstr = XCALLOC(MTYPE_TMP, argstr_sz);
5969 strlcpy(argstr, str, argstr_sz);
5970 strlcat(argstr, " additive", argstr_sz);
5971 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argstr);
5972 } else
5973 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
5974
5975 ret = nb_cli_apply_changes(vty, NULL);
5976
5977 if (argstr)
5978 XFREE(MTYPE_TMP, argstr);
5979 community_free(&com);
5980
5981 return ret;
5982 }
5983
5984 DEFUN_YANG (set_community_none,
5985 set_community_none_cmd,
5986 "set community none",
5987 SET_STR
5988 "BGP community attribute\n"
5989 "No community attribute\n")
5990 {
5991 const char *xpath =
5992 "./set-action[action='frr-bgp-route-map:set-community']";
5993 char xpath_value[XPATH_MAXLEN];
5994
5995 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
5996
5997 snprintf(xpath_value, sizeof(xpath_value),
5998 "%s/rmap-set-action/frr-bgp-route-map:community-none", xpath);
5999 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
6000 return nb_cli_apply_changes(vty, NULL);
6001 }
6002
6003 DEFUN_YANG (no_set_community,
6004 no_set_community_cmd,
6005 "no set community AA:NN...",
6006 NO_STR
6007 SET_STR
6008 "BGP community attribute\n"
6009 COMMUNITY_VAL_STR)
6010 {
6011 const char *xpath =
6012 "./set-action[action='frr-bgp-route-map:set-community']";
6013
6014 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6015 return nb_cli_apply_changes(vty, NULL);
6016 }
6017
6018 ALIAS_YANG (no_set_community,
6019 no_set_community_short_cmd,
6020 "no set community",
6021 NO_STR
6022 SET_STR
6023 "BGP community attribute\n")
6024
6025 DEFPY_YANG (set_community_delete,
6026 set_community_delete_cmd,
6027 "set comm-list <(1-99)|(100-500)|COMMUNITY_LIST_NAME> delete",
6028 SET_STR
6029 "set BGP community list (for deletion)\n"
6030 "Community-list number (standard)\n"
6031 "Community-list number (expanded)\n"
6032 "Community-list name\n"
6033 "Delete matching communities\n")
6034 {
6035 const char *xpath =
6036 "./set-action[action='frr-bgp-route-map:comm-list-delete']";
6037 char xpath_value[XPATH_MAXLEN];
6038 int idx_comm_list = 2;
6039
6040 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6041
6042 snprintf(xpath_value, sizeof(xpath_value),
6043 "%s/rmap-set-action/frr-bgp-route-map:comm-list-name",
6044 xpath);
6045 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6046 argv[idx_comm_list]->arg);
6047
6048 return nb_cli_apply_changes(vty, NULL);
6049
6050 }
6051
6052 DEFUN_YANG (no_set_community_delete,
6053 no_set_community_delete_cmd,
6054 "no set comm-list [<(1-99)|(100-500)|COMMUNITY_LIST_NAME> delete]",
6055 NO_STR
6056 SET_STR
6057 "set BGP community list (for deletion)\n"
6058 "Community-list number (standard)\n"
6059 "Community-list number (expanded)\n"
6060 "Community-list name\n"
6061 "Delete matching communities\n")
6062 {
6063 const char *xpath =
6064 "./set-action[action='frr-bgp-route-map:comm-list-delete']";
6065
6066 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6067 return nb_cli_apply_changes(vty, NULL);
6068 }
6069
6070 DEFUN_YANG (set_lcommunity,
6071 set_lcommunity_cmd,
6072 "set large-community AA:BB:CC...",
6073 SET_STR
6074 "BGP large community attribute\n"
6075 "Large Community number in aa:bb:cc format or additive\n")
6076 {
6077 char *str;
6078 int ret;
6079 const char *xpath =
6080 "./set-action[action='frr-bgp-route-map:set-large-community']";
6081 char xpath_value[XPATH_MAXLEN];
6082
6083 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6084
6085 snprintf(xpath_value, sizeof(xpath_value),
6086 "%s/rmap-set-action/frr-bgp-route-map:large-community-string",
6087 xpath);
6088 str = argv_concat(argv, argc, 2);
6089 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
6090 ret = nb_cli_apply_changes(vty, NULL);
6091 XFREE(MTYPE_TMP, str);
6092 return ret;
6093 }
6094
6095 DEFUN_YANG (set_lcommunity_none,
6096 set_lcommunity_none_cmd,
6097 "set large-community none",
6098 SET_STR
6099 "BGP large community attribute\n"
6100 "No large community attribute\n")
6101 {
6102 const char *xpath =
6103 "./set-action[action='frr-bgp-route-map:set-large-community']";
6104 char xpath_value[XPATH_MAXLEN];
6105
6106 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6107
6108 snprintf(xpath_value, sizeof(xpath_value),
6109 "%s/rmap-set-action/frr-bgp-route-map:large-community-none",
6110 xpath);
6111 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
6112 return nb_cli_apply_changes(vty, NULL);
6113 }
6114
6115 DEFUN_YANG (no_set_lcommunity,
6116 no_set_lcommunity_cmd,
6117 "no set large-community none",
6118 NO_STR
6119 SET_STR
6120 "BGP large community attribute\n"
6121 "No community attribute\n")
6122 {
6123 const char *xpath =
6124 "./set-action[action='frr-bgp-route-map:set-large-community']";
6125
6126 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6127 return nb_cli_apply_changes(vty, NULL);
6128 }
6129
6130 DEFUN_YANG (no_set_lcommunity1,
6131 no_set_lcommunity1_cmd,
6132 "no set large-community AA:BB:CC...",
6133 NO_STR
6134 SET_STR
6135 "BGP large community attribute\n"
6136 "Large community in AA:BB:CC... format or additive\n")
6137 {
6138 const char *xpath =
6139 "./set-action[action='frr-bgp-route-map:set-large-community']";
6140
6141 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6142 return nb_cli_apply_changes(vty, NULL);
6143 }
6144
6145 ALIAS_YANG (no_set_lcommunity1,
6146 no_set_lcommunity1_short_cmd,
6147 "no set large-community",
6148 NO_STR
6149 SET_STR
6150 "BGP large community attribute\n")
6151
6152 DEFPY_YANG (set_lcommunity_delete,
6153 set_lcommunity_delete_cmd,
6154 "set large-comm-list <(1-99)|(100-500)|LCOMMUNITY_LIST_NAME> delete",
6155 SET_STR
6156 "set BGP large community list (for deletion)\n"
6157 "Large Community-list number (standard)\n"
6158 "Large Communitly-list number (expanded)\n"
6159 "Large Community-list name\n"
6160 "Delete matching large communities\n")
6161 {
6162 const char *xpath =
6163 "./set-action[action='frr-bgp-route-map:large-comm-list-delete']";
6164 char xpath_value[XPATH_MAXLEN];
6165 int idx_lcomm_list = 2;
6166
6167 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6168
6169 snprintf(xpath_value, sizeof(xpath_value),
6170 "%s/rmap-set-action/frr-bgp-route-map:comm-list-name",
6171 xpath);
6172 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6173 argv[idx_lcomm_list]->arg);
6174
6175 return nb_cli_apply_changes(vty, NULL);
6176 }
6177
6178 DEFUN_YANG (no_set_lcommunity_delete,
6179 no_set_lcommunity_delete_cmd,
6180 "no set large-comm-list <(1-99)|(100-500)|LCOMMUNITY_LIST_NAME> [delete]",
6181 NO_STR
6182 SET_STR
6183 "set BGP large community list (for deletion)\n"
6184 "Large Community-list number (standard)\n"
6185 "Large Communitly-list number (expanded)\n"
6186 "Large Community-list name\n"
6187 "Delete matching large communities\n")
6188 {
6189 const char *xpath =
6190 "./set-action[action='frr-bgp-route-map:large-comm-list-delete']";
6191
6192 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6193 return nb_cli_apply_changes(vty, NULL);
6194 }
6195
6196 ALIAS_YANG (no_set_lcommunity_delete,
6197 no_set_lcommunity_delete_short_cmd,
6198 "no set large-comm-list",
6199 NO_STR
6200 SET_STR
6201 "set BGP large community list (for deletion)\n")
6202
6203 DEFUN_YANG (set_ecommunity_rt,
6204 set_ecommunity_rt_cmd,
6205 "set extcommunity rt ASN:NN_OR_IP-ADDRESS:NN...",
6206 SET_STR
6207 "BGP extended community attribute\n"
6208 "Route Target extended community\n"
6209 "VPN extended community\n")
6210 {
6211 int idx_asn_nn = 3;
6212 char *str;
6213 int ret;
6214 const char *xpath =
6215 "./set-action[action='frr-bgp-route-map:set-extcommunity-rt']";
6216 char xpath_value[XPATH_MAXLEN];
6217
6218 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6219
6220 snprintf(xpath_value, sizeof(xpath_value),
6221 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-rt", xpath);
6222 str = argv_concat(argv, argc, idx_asn_nn);
6223 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
6224 ret = nb_cli_apply_changes(vty, NULL);
6225 XFREE(MTYPE_TMP, str);
6226 return ret;
6227 }
6228
6229 DEFUN_YANG (no_set_ecommunity_rt,
6230 no_set_ecommunity_rt_cmd,
6231 "no set extcommunity rt ASN:NN_OR_IP-ADDRESS:NN...",
6232 NO_STR
6233 SET_STR
6234 "BGP extended community attribute\n"
6235 "Route Target extended community\n"
6236 "VPN extended community\n")
6237 {
6238 const char *xpath =
6239 "./set-action[action='frr-bgp-route-map:set-extcommunity-rt']";
6240 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6241 return nb_cli_apply_changes(vty, NULL);
6242 }
6243
6244 ALIAS_YANG (no_set_ecommunity_rt,
6245 no_set_ecommunity_rt_short_cmd,
6246 "no set extcommunity rt",
6247 NO_STR
6248 SET_STR
6249 "BGP extended community attribute\n"
6250 "Route Target extended community\n")
6251
6252 DEFUN_YANG (set_ecommunity_soo,
6253 set_ecommunity_soo_cmd,
6254 "set extcommunity soo ASN:NN_OR_IP-ADDRESS:NN...",
6255 SET_STR
6256 "BGP extended community attribute\n"
6257 "Site-of-Origin extended community\n"
6258 "VPN extended community\n")
6259 {
6260 int idx_asn_nn = 3;
6261 char *str;
6262 int ret;
6263 const char *xpath =
6264 "./set-action[action='frr-bgp-route-map:set-extcommunity-soo']";
6265 char xpath_value[XPATH_MAXLEN];
6266
6267 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6268
6269 snprintf(xpath_value, sizeof(xpath_value),
6270 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-soo",
6271 xpath);
6272 str = argv_concat(argv, argc, idx_asn_nn);
6273 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, str);
6274 ret = nb_cli_apply_changes(vty, NULL);
6275 XFREE(MTYPE_TMP, str);
6276 return ret;
6277 }
6278
6279 DEFUN_YANG (no_set_ecommunity_soo,
6280 no_set_ecommunity_soo_cmd,
6281 "no set extcommunity soo ASN:NN_OR_IP-ADDRESS:NN...",
6282 NO_STR
6283 SET_STR
6284 "BGP extended community attribute\n"
6285 "Site-of-Origin extended community\n"
6286 "VPN extended community\n")
6287 {
6288 const char *xpath =
6289 "./set-action[action='frr-bgp-route-map:set-extcommunity-soo']";
6290 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6291 return nb_cli_apply_changes(vty, NULL);
6292 }
6293
6294 ALIAS_YANG (no_set_ecommunity_soo,
6295 no_set_ecommunity_soo_short_cmd,
6296 "no set extcommunity soo",
6297 NO_STR
6298 SET_STR
6299 "GP extended community attribute\n"
6300 "Site-of-Origin extended community\n")
6301
6302 DEFUN_YANG(set_ecommunity_none, set_ecommunity_none_cmd,
6303 "set extcommunity none",
6304 SET_STR
6305 "BGP extended community attribute\n"
6306 "No extended community attribute\n")
6307 {
6308 const char *xpath =
6309 "./set-action[action='frr-bgp-route-map:set-extcommunity-none']";
6310 char xpath_value[XPATH_MAXLEN];
6311
6312 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6313
6314 snprintf(xpath_value, sizeof(xpath_value),
6315 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-none",
6316 xpath);
6317 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
6318 return nb_cli_apply_changes(vty, NULL);
6319 }
6320
6321 DEFUN_YANG(no_set_ecommunity_none, no_set_ecommunity_none_cmd,
6322 "no set extcommunity none",
6323 NO_STR SET_STR
6324 "BGP extended community attribute\n"
6325 "No extended community attribute\n")
6326 {
6327 const char *xpath =
6328 "./set-action[action='frr-bgp-route-map:set-extcommunity-none']";
6329 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6330 return nb_cli_apply_changes(vty, NULL);
6331 }
6332
6333 DEFUN_YANG (set_ecommunity_lb,
6334 set_ecommunity_lb_cmd,
6335 "set extcommunity bandwidth <(1-25600)|cumulative|num-multipaths> [non-transitive]",
6336 SET_STR
6337 "BGP extended community attribute\n"
6338 "Link bandwidth extended community\n"
6339 "Bandwidth value in Mbps\n"
6340 "Cumulative bandwidth of all multipaths (outbound-only)\n"
6341 "Internally computed bandwidth based on number of multipaths (outbound-only)\n"
6342 "Attribute is set as non-transitive\n")
6343 {
6344 int idx_lb = 3;
6345 int idx_non_transitive = 0;
6346 const char *xpath =
6347 "./set-action[action='frr-bgp-route-map:set-extcommunity-lb']";
6348 char xpath_lb_type[XPATH_MAXLEN];
6349 char xpath_bandwidth[XPATH_MAXLEN];
6350 char xpath_non_transitive[XPATH_MAXLEN];
6351
6352 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6353
6354 snprintf(xpath_lb_type, sizeof(xpath_lb_type),
6355 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-lb/lb-type",
6356 xpath);
6357 snprintf(xpath_bandwidth, sizeof(xpath_bandwidth),
6358 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-lb/bandwidth",
6359 xpath);
6360 snprintf(xpath_non_transitive, sizeof(xpath_non_transitive),
6361 "%s/rmap-set-action/frr-bgp-route-map:extcommunity-lb/two-octet-as-specific",
6362 xpath);
6363
6364 if ((strcmp(argv[idx_lb]->arg, "cumulative")) == 0)
6365 nb_cli_enqueue_change(vty, xpath_lb_type, NB_OP_MODIFY,
6366 "cumulative-bandwidth");
6367 else if ((strcmp(argv[idx_lb]->arg, "num-multipaths")) == 0)
6368 nb_cli_enqueue_change(vty, xpath_lb_type, NB_OP_MODIFY,
6369 "computed-bandwidth");
6370 else {
6371 nb_cli_enqueue_change(vty, xpath_lb_type, NB_OP_MODIFY,
6372 "explicit-bandwidth");
6373 nb_cli_enqueue_change(vty, xpath_bandwidth, NB_OP_MODIFY,
6374 argv[idx_lb]->arg);
6375 }
6376
6377 if (argv_find(argv, argc, "non-transitive", &idx_non_transitive))
6378 nb_cli_enqueue_change(vty, xpath_non_transitive, NB_OP_MODIFY,
6379 "true");
6380 else
6381 nb_cli_enqueue_change(vty, xpath_non_transitive, NB_OP_MODIFY,
6382 "false");
6383
6384 return nb_cli_apply_changes(vty, NULL);
6385 }
6386
6387 DEFUN_YANG (no_set_ecommunity_lb,
6388 no_set_ecommunity_lb_cmd,
6389 "no set extcommunity bandwidth <(1-25600)|cumulative|num-multipaths> [non-transitive]",
6390 NO_STR
6391 SET_STR
6392 "BGP extended community attribute\n"
6393 "Link bandwidth extended community\n"
6394 "Bandwidth value in Mbps\n"
6395 "Cumulative bandwidth of all multipaths (outbound-only)\n"
6396 "Internally computed bandwidth based on number of multipaths (outbound-only)\n"
6397 "Attribute is set as non-transitive\n")
6398 {
6399 const char *xpath =
6400 "./set-action[action='frr-bgp-route-map:set-extcommunity-lb']";
6401
6402 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6403 return nb_cli_apply_changes(vty, NULL);
6404 }
6405
6406 ALIAS_YANG (no_set_ecommunity_lb,
6407 no_set_ecommunity_lb_short_cmd,
6408 "no set extcommunity bandwidth",
6409 NO_STR
6410 SET_STR
6411 "BGP extended community attribute\n"
6412 "Link bandwidth extended community\n")
6413
6414 DEFUN_YANG (set_origin,
6415 set_origin_cmd,
6416 "set origin <egp|igp|incomplete>",
6417 SET_STR
6418 "BGP origin code\n"
6419 "remote EGP\n"
6420 "local IGP\n"
6421 "unknown heritage\n")
6422 {
6423 int idx_origin = 2;
6424 const char *origin_type;
6425 const char *xpath =
6426 "./set-action[action='frr-bgp-route-map:set-origin']";
6427 char xpath_value[XPATH_MAXLEN];
6428
6429 if (strncmp(argv[idx_origin]->arg, "igp", 2) == 0)
6430 origin_type = "igp";
6431 else if (strncmp(argv[idx_origin]->arg, "egp", 1) == 0)
6432 origin_type = "egp";
6433 else if (strncmp(argv[idx_origin]->arg, "incomplete", 2) == 0)
6434 origin_type = "incomplete";
6435 else {
6436 vty_out(vty, "%% Invalid match origin type\n");
6437 return CMD_WARNING_CONFIG_FAILED;
6438 }
6439
6440 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6441 snprintf(xpath_value, sizeof(xpath_value),
6442 "%s/rmap-set-action/frr-bgp-route-map:origin", xpath);
6443 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, origin_type);
6444
6445 return nb_cli_apply_changes(vty, NULL);
6446 }
6447
6448 DEFUN_YANG (no_set_origin,
6449 no_set_origin_cmd,
6450 "no set origin [<egp|igp|incomplete>]",
6451 NO_STR
6452 SET_STR
6453 "BGP origin code\n"
6454 "remote EGP\n"
6455 "local IGP\n"
6456 "unknown heritage\n")
6457 {
6458 const char *xpath =
6459 "./set-action[action='frr-bgp-route-map:set-origin']";
6460
6461 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6462 return nb_cli_apply_changes(vty, NULL);
6463 }
6464
6465 DEFUN_YANG (set_atomic_aggregate,
6466 set_atomic_aggregate_cmd,
6467 "set atomic-aggregate",
6468 SET_STR
6469 "BGP atomic aggregate attribute\n" )
6470 {
6471 const char *xpath =
6472 "./set-action[action='frr-bgp-route-map:atomic-aggregate']";
6473 char xpath_value[XPATH_MAXLEN];
6474
6475 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6476 snprintf(xpath_value, sizeof(xpath_value),
6477 "%s/rmap-set-action/frr-bgp-route-map:atomic-aggregate",
6478 xpath);
6479 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, NULL);
6480
6481 return nb_cli_apply_changes(vty, NULL);
6482 }
6483
6484 DEFUN_YANG (no_set_atomic_aggregate,
6485 no_set_atomic_aggregate_cmd,
6486 "no set atomic-aggregate",
6487 NO_STR
6488 SET_STR
6489 "BGP atomic aggregate attribute\n" )
6490 {
6491 const char *xpath =
6492 "./set-action[action='frr-bgp-route-map:atomic-aggregate']";
6493
6494 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6495 return nb_cli_apply_changes(vty, NULL);
6496 }
6497
6498 DEFPY_YANG (set_aigp_metric,
6499 set_aigp_metric_cmd,
6500 "set aigp-metric <igp-metric|(1-4294967295)>$aigp_metric",
6501 SET_STR
6502 "BGP AIGP attribute (AIGP Metric TLV)\n"
6503 "AIGP Metric value from IGP protocol\n"
6504 "Manual AIGP Metric value\n")
6505 {
6506 const char *xpath =
6507 "./set-action[action='frr-bgp-route-map:aigp-metric']";
6508 char xpath_value[XPATH_MAXLEN];
6509
6510 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6511 snprintf(xpath_value, sizeof(xpath_value),
6512 "%s/rmap-set-action/frr-bgp-route-map:aigp-metric", xpath);
6513 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, aigp_metric);
6514
6515 return nb_cli_apply_changes(vty, NULL);
6516 }
6517
6518 DEFPY_YANG (no_set_aigp_metric,
6519 no_set_aigp_metric_cmd,
6520 "no set aigp-metric [<igp-metric|(1-4294967295)>]",
6521 NO_STR
6522 SET_STR
6523 "BGP AIGP attribute (AIGP Metric TLV)\n"
6524 "AIGP Metric value from IGP protocol\n"
6525 "Manual AIGP Metric value\n")
6526 {
6527 const char *xpath =
6528 "./set-action[action='frr-bgp-route-map:aigp-metric']";
6529
6530 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6531 return nb_cli_apply_changes(vty, NULL);
6532 }
6533
6534 DEFUN_YANG (set_aggregator_as,
6535 set_aggregator_as_cmd,
6536 "set aggregator as ASNUM A.B.C.D",
6537 SET_STR
6538 "BGP aggregator attribute\n"
6539 "AS number of aggregator\n"
6540 AS_STR
6541 "IP address of aggregator\n")
6542 {
6543 int idx_number = 3;
6544 int idx_ipv4 = 4;
6545 char xpath_asn[XPATH_MAXLEN];
6546 char xpath_addr[XPATH_MAXLEN];
6547 const char *xpath =
6548 "./set-action[action='frr-bgp-route-map:aggregator']";
6549 as_t as_value;
6550
6551 if (!asn_str2asn(argv[idx_number]->arg, &as_value)) {
6552 vty_out(vty, "%% Invalid AS value %s\n", argv[idx_number]->arg);
6553 return CMD_WARNING_CONFIG_FAILED;
6554 }
6555
6556 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6557
6558 snprintf(
6559 xpath_asn, sizeof(xpath_asn),
6560 "%s/rmap-set-action/frr-bgp-route-map:aggregator/aggregator-asn",
6561 xpath);
6562 nb_cli_enqueue_change(vty, xpath_asn, NB_OP_MODIFY,
6563 argv[idx_number]->arg);
6564
6565 snprintf(
6566 xpath_addr, sizeof(xpath_addr),
6567 "%s/rmap-set-action/frr-bgp-route-map:aggregator/aggregator-address",
6568 xpath);
6569 nb_cli_enqueue_change(vty, xpath_addr, NB_OP_MODIFY,
6570 argv[idx_ipv4]->arg);
6571
6572 return nb_cli_apply_changes(vty, NULL);
6573 }
6574
6575 DEFUN_YANG (no_set_aggregator_as,
6576 no_set_aggregator_as_cmd,
6577 "no set aggregator as [ASNUM A.B.C.D]",
6578 NO_STR
6579 SET_STR
6580 "BGP aggregator attribute\n"
6581 "AS number of aggregator\n"
6582 AS_STR
6583 "IP address of aggregator\n")
6584 {
6585 const char *xpath =
6586 "./set-action[action='frr-bgp-route-map:aggregator']";
6587
6588 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6589 return nb_cli_apply_changes(vty, NULL);
6590 }
6591
6592 DEFUN_YANG (match_ipv6_next_hop,
6593 match_ipv6_next_hop_cmd,
6594 "match ipv6 next-hop ACCESSLIST6_NAME",
6595 MATCH_STR
6596 IPV6_STR
6597 "Match IPv6 next-hop address of route\n"
6598 "IPv6 access-list name\n")
6599 {
6600 const char *xpath =
6601 "./match-condition[condition='frr-route-map:ipv6-next-hop-list']";
6602 char xpath_value[XPATH_MAXLEN];
6603
6604 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6605 snprintf(xpath_value, sizeof(xpath_value),
6606 "%s/rmap-match-condition/list-name", xpath);
6607 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6608 argv[argc - 1]->arg);
6609
6610 return nb_cli_apply_changes(vty, NULL);
6611 }
6612
6613 DEFUN_YANG (no_match_ipv6_next_hop,
6614 no_match_ipv6_next_hop_cmd,
6615 "no match ipv6 next-hop [ACCESSLIST6_NAME]",
6616 NO_STR
6617 MATCH_STR
6618 IPV6_STR
6619 "Match IPv6 next-hop address of route\n"
6620 "IPv6 access-list name\n")
6621 {
6622 const char *xpath =
6623 "./match-condition[condition='frr-route-map:ipv6-next-hop-list']";
6624
6625 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6626 return nb_cli_apply_changes(vty, NULL);
6627 }
6628
6629 DEFUN_YANG (match_ipv6_next_hop_address,
6630 match_ipv6_next_hop_address_cmd,
6631 "match ipv6 next-hop address X:X::X:X",
6632 MATCH_STR
6633 IPV6_STR
6634 "Match IPv6 next-hop address of route\n"
6635 "IPv6 address\n"
6636 "IPv6 address of next hop\n")
6637 {
6638 const char *xpath =
6639 "./match-condition[condition='frr-bgp-route-map:ipv6-nexthop']";
6640 char xpath_value[XPATH_MAXLEN];
6641
6642 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6643 snprintf(xpath_value, sizeof(xpath_value),
6644 "%s/rmap-match-condition/frr-bgp-route-map:ipv6-address",
6645 xpath);
6646 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6647 argv[argc - 1]->arg);
6648
6649 return nb_cli_apply_changes(vty, NULL);
6650 }
6651
6652 DEFUN_YANG (no_match_ipv6_next_hop_address,
6653 no_match_ipv6_next_hop_address_cmd,
6654 "no match ipv6 next-hop address X:X::X:X",
6655 NO_STR
6656 MATCH_STR
6657 IPV6_STR
6658 "Match IPv6 next-hop address of route\n"
6659 "IPv6 address\n"
6660 "IPv6 address of next hop\n")
6661 {
6662 const char *xpath =
6663 "./match-condition[condition='frr-bgp-route-map:ipv6-nexthop']";
6664
6665 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6666 return nb_cli_apply_changes(vty, NULL);
6667 }
6668
6669 ALIAS_HIDDEN (match_ipv6_next_hop_address,
6670 match_ipv6_next_hop_old_cmd,
6671 "match ipv6 next-hop X:X::X:X",
6672 MATCH_STR
6673 IPV6_STR
6674 "Match IPv6 next-hop address of route\n"
6675 "IPv6 address of next hop\n")
6676
6677 ALIAS_HIDDEN (no_match_ipv6_next_hop_address,
6678 no_match_ipv6_next_hop_old_cmd,
6679 "no match ipv6 next-hop X:X::X:X",
6680 NO_STR
6681 MATCH_STR
6682 IPV6_STR
6683 "Match IPv6 next-hop address of route\n"
6684 "IPv6 address of next hop\n")
6685
6686 DEFUN_YANG (match_ipv6_next_hop_prefix_list,
6687 match_ipv6_next_hop_prefix_list_cmd,
6688 "match ipv6 next-hop prefix-list PREFIXLIST_NAME",
6689 MATCH_STR
6690 IPV6_STR
6691 "Match IPv6 next-hop address of route\n"
6692 "Match entries by prefix-list\n"
6693 "IPv6 prefix-list name\n")
6694 {
6695 const char *xpath =
6696 "./match-condition[condition='frr-route-map:ipv6-next-hop-prefix-list']";
6697 char xpath_value[XPATH_MAXLEN];
6698
6699 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6700 snprintf(xpath_value, sizeof(xpath_value),
6701 "%s/rmap-match-condition/list-name", xpath);
6702 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6703 argv[argc - 1]->arg);
6704
6705 return nb_cli_apply_changes(vty, NULL);
6706 }
6707
6708 DEFUN_YANG (no_match_ipv6_next_hop_prefix_list,
6709 no_match_ipv6_next_hop_prefix_list_cmd,
6710 "no match ipv6 next-hop prefix-list [PREFIXLIST_NAME]",
6711 NO_STR
6712 MATCH_STR
6713 IPV6_STR
6714 "Match IPv6 next-hop address of route\n"
6715 "Match entries by prefix-list\n"
6716 "IPv6 prefix-list name\n")
6717 {
6718 const char *xpath =
6719 "./match-condition[condition='frr-route-map:ipv6-next-hop-prefix-list']";
6720
6721 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6722 return nb_cli_apply_changes(vty, NULL);
6723 }
6724
6725 DEFPY_YANG (match_ipv4_next_hop,
6726 match_ipv4_next_hop_cmd,
6727 "match ip next-hop address A.B.C.D",
6728 MATCH_STR
6729 IP_STR
6730 "Match IP next-hop address of route\n"
6731 "IP address\n"
6732 "IP address of next-hop\n")
6733 {
6734 const char *xpath =
6735 "./match-condition[condition='frr-bgp-route-map:ipv4-nexthop']";
6736 char xpath_value[XPATH_MAXLEN];
6737
6738 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6739 snprintf(xpath_value, sizeof(xpath_value),
6740 "%s/rmap-match-condition/frr-bgp-route-map:ipv4-address",
6741 xpath);
6742 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, argv[4]->arg);
6743
6744 return nb_cli_apply_changes(vty, NULL);
6745 }
6746
6747 DEFPY_YANG (no_match_ipv4_next_hop,
6748 no_match_ipv4_next_hop_cmd,
6749 "no match ip next-hop address [A.B.C.D]",
6750 NO_STR
6751 MATCH_STR
6752 IP_STR
6753 "Match IP next-hop address of route\n"
6754 "IP address\n"
6755 "IP address of next-hop\n")
6756 {
6757 const char *xpath =
6758 "./match-condition[condition='frr-bgp-route-map:ipv4-nexthop']";
6759
6760 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6761 return nb_cli_apply_changes(vty, NULL);
6762 }
6763
6764 DEFUN_YANG (set_ipv6_nexthop_peer,
6765 set_ipv6_nexthop_peer_cmd,
6766 "set ipv6 next-hop peer-address",
6767 SET_STR
6768 IPV6_STR
6769 "Next hop address\n"
6770 "Use peer address (for BGP only)\n")
6771 {
6772 const char *xpath =
6773 "./set-action[action='frr-bgp-route-map:ipv6-peer-address']";
6774 char xpath_value[XPATH_MAXLEN];
6775
6776 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6777 snprintf(xpath_value, sizeof(xpath_value),
6778 "%s/rmap-set-action/frr-bgp-route-map:preference", xpath);
6779 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
6780
6781 return nb_cli_apply_changes(vty, NULL);
6782 }
6783
6784 DEFUN_YANG (no_set_ipv6_nexthop_peer,
6785 no_set_ipv6_nexthop_peer_cmd,
6786 "no set ipv6 next-hop peer-address",
6787 NO_STR
6788 SET_STR
6789 IPV6_STR
6790 "IPv6 next-hop address\n"
6791 "Use peer address (for BGP only)\n")
6792 {
6793 const char *xpath =
6794 "./set-action[action='frr-bgp-route-map:ipv6-peer-address']";
6795
6796 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6797 return nb_cli_apply_changes(vty, NULL);
6798 }
6799
6800 DEFUN_YANG (set_ipv6_nexthop_prefer_global,
6801 set_ipv6_nexthop_prefer_global_cmd,
6802 "set ipv6 next-hop prefer-global",
6803 SET_STR
6804 IPV6_STR
6805 "IPv6 next-hop address\n"
6806 "Prefer global over link-local if both exist\n")
6807 {
6808 const char *xpath =
6809 "./set-action[action='frr-bgp-route-map:ipv6-prefer-global']";
6810 char xpath_value[XPATH_MAXLEN];
6811
6812 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6813 snprintf(xpath_value, sizeof(xpath_value),
6814 "%s/rmap-set-action/frr-bgp-route-map:preference", xpath);
6815 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY, "true");
6816
6817 return nb_cli_apply_changes(vty, NULL);
6818 }
6819
6820 DEFUN_YANG (no_set_ipv6_nexthop_prefer_global,
6821 no_set_ipv6_nexthop_prefer_global_cmd,
6822 "no set ipv6 next-hop prefer-global",
6823 NO_STR
6824 SET_STR
6825 IPV6_STR
6826 "IPv6 next-hop address\n"
6827 "Prefer global over link-local if both exist\n")
6828 {
6829 const char *xpath =
6830 "./set-action[action='frr-bgp-route-map:ipv6-prefer-global']";
6831
6832 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6833 return nb_cli_apply_changes(vty, NULL);
6834 }
6835
6836 DEFUN_YANG (set_ipv6_nexthop_global,
6837 set_ipv6_nexthop_global_cmd,
6838 "set ipv6 next-hop global X:X::X:X",
6839 SET_STR
6840 IPV6_STR
6841 "IPv6 next-hop address\n"
6842 "IPv6 global address\n"
6843 "IPv6 address of next hop\n")
6844 {
6845 int idx_ipv6 = 4;
6846 const char *xpath =
6847 "./set-action[action='frr-bgp-route-map:ipv6-nexthop-global']";
6848 char xpath_value[XPATH_MAXLEN];
6849
6850 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6851 snprintf(xpath_value, sizeof(xpath_value),
6852 "%s/rmap-set-action/frr-bgp-route-map:ipv6-address", xpath);
6853 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6854 argv[idx_ipv6]->arg);
6855
6856 return nb_cli_apply_changes(vty, NULL);
6857 }
6858
6859 DEFUN_YANG (no_set_ipv6_nexthop_global,
6860 no_set_ipv6_nexthop_global_cmd,
6861 "no set ipv6 next-hop global X:X::X:X",
6862 NO_STR
6863 SET_STR
6864 IPV6_STR
6865 "IPv6 next-hop address\n"
6866 "IPv6 global address\n"
6867 "IPv6 address of next hop\n")
6868 {
6869 const char *xpath =
6870 "./set-action[action='frr-bgp-route-map:ipv6-nexthop-global']";
6871
6872 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6873 return nb_cli_apply_changes(vty, NULL);
6874 }
6875
6876 #ifdef KEEP_OLD_VPN_COMMANDS
6877 DEFUN_YANG (set_vpn_nexthop,
6878 set_vpn_nexthop_cmd,
6879 "set <vpnv4 next-hop A.B.C.D|vpnv6 next-hop X:X::X:X>",
6880 SET_STR
6881 "VPNv4 information\n"
6882 "VPN next-hop address\n"
6883 "IP address of next hop\n"
6884 "VPNv6 information\n"
6885 "VPN next-hop address\n"
6886 "IPv6 address of next hop\n")
6887 {
6888 int idx_ip = 3;
6889 afi_t afi;
6890 int idx = 0;
6891 char xpath_value[XPATH_MAXLEN];
6892
6893 if (argv_find_and_parse_vpnvx(argv, argc, &idx, &afi)) {
6894 if (afi == AFI_IP) {
6895 const char *xpath =
6896 "./set-action[action='frr-bgp-route-map:ipv4-vpn-address']";
6897
6898 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6899 snprintf(
6900 xpath_value, sizeof(xpath_value),
6901 "%s/rmap-set-action/frr-bgp-route-map:ipv4-address",
6902 xpath);
6903 } else {
6904 const char *xpath =
6905 "./set-action[action='frr-bgp-route-map:ipv6-vpn-address']";
6906
6907 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6908 snprintf(
6909 xpath_value, sizeof(xpath_value),
6910 "%s/rmap-set-action/frr-bgp-route-map:ipv6-address",
6911 xpath);
6912 }
6913
6914 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
6915 argv[idx_ip]->arg);
6916
6917 return nb_cli_apply_changes(vty, NULL);
6918 }
6919
6920 return CMD_SUCCESS;
6921 }
6922
6923 DEFUN_YANG (no_set_vpn_nexthop,
6924 no_set_vpn_nexthop_cmd,
6925 "no set <vpnv4 next-hop A.B.C.D|vpnv6 next-hop X:X::X:X>",
6926 NO_STR
6927 SET_STR
6928 "VPNv4 information\n"
6929 "VPN next-hop address\n"
6930 "IP address of next hop\n"
6931 "VPNv6 information\n"
6932 "VPN next-hop address\n"
6933 "IPv6 address of next hop\n")
6934 {
6935 afi_t afi;
6936 int idx = 0;
6937
6938 if (argv_find_and_parse_vpnvx(argv, argc, &idx, &afi)) {
6939 if (afi == AFI_IP) {
6940 const char *xpath =
6941 "./set-action[action='frr-bgp-route-map:ipv4-vpn-address']";
6942 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6943 } else {
6944 const char *xpath =
6945 "./set-action[action='frr-bgp-route-map:ipv6-vpn-address']";
6946 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
6947 }
6948 return nb_cli_apply_changes(vty, NULL);
6949 }
6950 return CMD_SUCCESS;
6951 }
6952 #endif /* KEEP_OLD_VPN_COMMANDS */
6953
6954 DEFPY_YANG (set_ipx_vpn_nexthop,
6955 set_ipx_vpn_nexthop_cmd,
6956 "set <ipv4|ipv6> vpn next-hop <A.B.C.D$addrv4|X:X::X:X$addrv6>",
6957 SET_STR
6958 "IPv4 information\n"
6959 "IPv6 information\n"
6960 "VPN information\n"
6961 "VPN next-hop address\n"
6962 "IP address of next hop\n"
6963 "IPv6 address of next hop\n")
6964 {
6965 int idx_ip = 4;
6966 afi_t afi;
6967 int idx = 0;
6968 char xpath_value[XPATH_MAXLEN];
6969
6970 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
6971 if (afi == AFI_IP) {
6972 if (addrv6_str) {
6973 vty_out(vty, "%% IPv4 next-hop expected\n");
6974 return CMD_WARNING_CONFIG_FAILED;
6975 }
6976
6977 const char *xpath =
6978 "./set-action[action='frr-bgp-route-map:ipv4-vpn-address']";
6979
6980 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6981 snprintf(
6982 xpath_value, sizeof(xpath_value),
6983 "%s/rmap-set-action/frr-bgp-route-map:ipv4-address",
6984 xpath);
6985 } else {
6986 if (addrv4_str) {
6987 vty_out(vty, "%% IPv6 next-hop expected\n");
6988 return CMD_WARNING_CONFIG_FAILED;
6989 }
6990
6991 const char *xpath =
6992 "./set-action[action='frr-bgp-route-map:ipv6-vpn-address']";
6993
6994 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
6995 snprintf(
6996 xpath_value, sizeof(xpath_value),
6997 "%s/rmap-set-action/frr-bgp-route-map:ipv6-address",
6998 xpath);
6999 }
7000 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
7001 argv[idx_ip]->arg);
7002 return nb_cli_apply_changes(vty, NULL);
7003 }
7004 return CMD_SUCCESS;
7005 }
7006
7007 DEFUN_YANG (no_set_ipx_vpn_nexthop,
7008 no_set_ipx_vpn_nexthop_cmd,
7009 "no set <ipv4|ipv6> vpn next-hop [<A.B.C.D|X:X::X:X>]",
7010 NO_STR
7011 SET_STR
7012 "IPv4 information\n"
7013 "IPv6 information\n"
7014 "VPN information\n"
7015 "VPN next-hop address\n"
7016 "IP address of next hop\n"
7017 "IPv6 address of next hop\n")
7018 {
7019 afi_t afi;
7020 int idx = 0;
7021
7022 if (argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
7023 if (afi == AFI_IP) {
7024 const char *xpath =
7025 "./set-action[action='frr-bgp-route-map:ipv4-vpn-address']";
7026 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
7027 } else {
7028 const char *xpath =
7029 "./set-action[action='frr-bgp-route-map:ipv6-vpn-address']";
7030 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
7031 }
7032 return nb_cli_apply_changes(vty, NULL);
7033 }
7034 return CMD_SUCCESS;
7035 }
7036
7037 DEFUN_YANG (set_originator_id,
7038 set_originator_id_cmd,
7039 "set originator-id A.B.C.D",
7040 SET_STR
7041 "BGP originator ID attribute\n"
7042 "IP address of originator\n")
7043 {
7044 int idx_ipv4 = 2;
7045 const char *xpath =
7046 "./set-action[action='frr-bgp-route-map:originator-id']";
7047 char xpath_value[XPATH_MAXLEN];
7048
7049 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
7050 snprintf(xpath_value, sizeof(xpath_value),
7051 "%s/rmap-set-action/frr-bgp-route-map:originator-id", xpath);
7052 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
7053 argv[idx_ipv4]->arg);
7054
7055 return nb_cli_apply_changes(vty, NULL);
7056 }
7057
7058 DEFUN_YANG (no_set_originator_id,
7059 no_set_originator_id_cmd,
7060 "no set originator-id [A.B.C.D]",
7061 NO_STR
7062 SET_STR
7063 "BGP originator ID attribute\n"
7064 "IP address of originator\n")
7065 {
7066 const char *xpath =
7067 "./set-action[action='frr-bgp-route-map:originator-id']";
7068
7069 nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
7070 return nb_cli_apply_changes(vty, NULL);
7071 }
7072
7073 DEFPY_YANG (match_rpki_extcommunity,
7074 match_rpki_extcommunity_cmd,
7075 "[no$no] match rpki-extcommunity <valid|invalid|notfound>",
7076 NO_STR
7077 MATCH_STR
7078 "BGP RPKI (Origin Validation State) extended community attribute\n"
7079 "Valid prefix\n"
7080 "Invalid prefix\n"
7081 "Prefix not found\n")
7082 {
7083 const char *xpath =
7084 "./match-condition[condition='frr-bgp-route-map:rpki-extcommunity']";
7085 char xpath_value[XPATH_MAXLEN];
7086
7087 nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
7088
7089 if (!no) {
7090 snprintf(
7091 xpath_value, sizeof(xpath_value),
7092 "%s/rmap-match-condition/frr-bgp-route-map:rpki-extcommunity",
7093 xpath);
7094 nb_cli_enqueue_change(vty, xpath_value, NB_OP_MODIFY,
7095 argv[2]->arg);
7096 }
7097
7098 return nb_cli_apply_changes(vty, NULL);
7099 }
7100
7101 /* Initialization of route map. */
7102 void bgp_route_map_init(void)
7103 {
7104 route_map_init();
7105
7106 route_map_add_hook(bgp_route_map_add);
7107 route_map_delete_hook(bgp_route_map_delete);
7108 route_map_event_hook(bgp_route_map_event);
7109
7110 route_map_match_interface_hook(generic_match_add);
7111 route_map_no_match_interface_hook(generic_match_delete);
7112
7113 route_map_match_ip_address_hook(generic_match_add);
7114 route_map_no_match_ip_address_hook(generic_match_delete);
7115
7116 route_map_match_ip_address_prefix_list_hook(generic_match_add);
7117 route_map_no_match_ip_address_prefix_list_hook(generic_match_delete);
7118
7119 route_map_match_ip_next_hop_hook(generic_match_add);
7120 route_map_no_match_ip_next_hop_hook(generic_match_delete);
7121
7122 route_map_match_ipv6_next_hop_hook(generic_match_add);
7123 route_map_no_match_ipv6_next_hop_hook(generic_match_delete);
7124
7125 route_map_match_ip_next_hop_prefix_list_hook(generic_match_add);
7126 route_map_no_match_ip_next_hop_prefix_list_hook(generic_match_delete);
7127
7128 route_map_match_ip_next_hop_type_hook(generic_match_add);
7129 route_map_no_match_ip_next_hop_type_hook(generic_match_delete);
7130
7131 route_map_match_ipv6_address_hook(generic_match_add);
7132 route_map_no_match_ipv6_address_hook(generic_match_delete);
7133
7134 route_map_match_ipv6_address_prefix_list_hook(generic_match_add);
7135 route_map_no_match_ipv6_address_prefix_list_hook(generic_match_delete);
7136
7137 route_map_match_ipv6_next_hop_type_hook(generic_match_add);
7138 route_map_no_match_ipv6_next_hop_type_hook(generic_match_delete);
7139
7140 route_map_match_ipv6_next_hop_prefix_list_hook(generic_match_add);
7141 route_map_no_match_ipv6_next_hop_prefix_list_hook(generic_match_delete);
7142
7143 route_map_match_metric_hook(generic_match_add);
7144 route_map_no_match_metric_hook(generic_match_delete);
7145
7146 route_map_match_tag_hook(generic_match_add);
7147 route_map_no_match_tag_hook(generic_match_delete);
7148
7149 route_map_set_srte_color_hook(generic_set_add);
7150 route_map_no_set_srte_color_hook(generic_set_delete);
7151
7152 route_map_set_ip_nexthop_hook(generic_set_add);
7153 route_map_no_set_ip_nexthop_hook(generic_set_delete);
7154
7155 route_map_set_ipv6_nexthop_local_hook(generic_set_add);
7156 route_map_no_set_ipv6_nexthop_local_hook(generic_set_delete);
7157
7158 route_map_set_metric_hook(generic_set_add);
7159 route_map_no_set_metric_hook(generic_set_delete);
7160
7161 route_map_set_tag_hook(generic_set_add);
7162 route_map_no_set_tag_hook(generic_set_delete);
7163
7164 route_map_install_match(&route_match_peer_cmd);
7165 route_map_install_match(&route_match_alias_cmd);
7166 route_map_install_match(&route_match_local_pref_cmd);
7167 #ifdef HAVE_SCRIPTING
7168 route_map_install_match(&route_match_script_cmd);
7169 #endif
7170 route_map_install_match(&route_match_ip_address_cmd);
7171 route_map_install_match(&route_match_ip_next_hop_cmd);
7172 route_map_install_match(&route_match_ip_route_source_cmd);
7173 route_map_install_match(&route_match_ip_address_prefix_list_cmd);
7174 route_map_install_match(&route_match_ip_next_hop_prefix_list_cmd);
7175 route_map_install_match(&route_match_ip_next_hop_type_cmd);
7176 route_map_install_match(&route_match_ip_route_source_prefix_list_cmd);
7177 route_map_install_match(&route_match_aspath_cmd);
7178 route_map_install_match(&route_match_community_cmd);
7179 route_map_install_match(&route_match_lcommunity_cmd);
7180 route_map_install_match(&route_match_ecommunity_cmd);
7181 route_map_install_match(&route_match_local_pref_cmd);
7182 route_map_install_match(&route_match_metric_cmd);
7183 route_map_install_match(&route_match_origin_cmd);
7184 route_map_install_match(&route_match_probability_cmd);
7185 route_map_install_match(&route_match_interface_cmd);
7186 route_map_install_match(&route_match_tag_cmd);
7187 route_map_install_match(&route_match_mac_address_cmd);
7188 route_map_install_match(&route_match_evpn_vni_cmd);
7189 route_map_install_match(&route_match_evpn_route_type_cmd);
7190 route_map_install_match(&route_match_evpn_rd_cmd);
7191 route_map_install_match(&route_match_evpn_default_route_cmd);
7192 route_map_install_match(&route_match_vrl_source_vrf_cmd);
7193
7194 route_map_install_set(&route_set_evpn_gateway_ip_ipv4_cmd);
7195 route_map_install_set(&route_set_evpn_gateway_ip_ipv6_cmd);
7196 route_map_install_set(&route_set_table_id_cmd);
7197 route_map_install_set(&route_set_srte_color_cmd);
7198 route_map_install_set(&route_set_ip_nexthop_cmd);
7199 route_map_install_set(&route_set_local_pref_cmd);
7200 route_map_install_set(&route_set_weight_cmd);
7201 route_map_install_set(&route_set_label_index_cmd);
7202 route_map_install_set(&route_set_metric_cmd);
7203 route_map_install_set(&route_set_distance_cmd);
7204 route_map_install_set(&route_set_aspath_prepend_cmd);
7205 route_map_install_set(&route_set_aspath_exclude_cmd);
7206 route_map_install_set(&route_set_aspath_replace_cmd);
7207 route_map_install_set(&route_set_origin_cmd);
7208 route_map_install_set(&route_set_atomic_aggregate_cmd);
7209 route_map_install_set(&route_set_aigp_metric_cmd);
7210 route_map_install_set(&route_set_aggregator_as_cmd);
7211 route_map_install_set(&route_set_community_cmd);
7212 route_map_install_set(&route_set_community_delete_cmd);
7213 route_map_install_set(&route_set_lcommunity_cmd);
7214 route_map_install_set(&route_set_lcommunity_delete_cmd);
7215 route_map_install_set(&route_set_vpnv4_nexthop_cmd);
7216 route_map_install_set(&route_set_vpnv6_nexthop_cmd);
7217 route_map_install_set(&route_set_originator_id_cmd);
7218 route_map_install_set(&route_set_ecommunity_rt_cmd);
7219 route_map_install_set(&route_set_ecommunity_soo_cmd);
7220 route_map_install_set(&route_set_ecommunity_lb_cmd);
7221 route_map_install_set(&route_set_ecommunity_none_cmd);
7222 route_map_install_set(&route_set_tag_cmd);
7223 route_map_install_set(&route_set_label_index_cmd);
7224 route_map_install_set(&route_set_l3vpn_nexthop_encapsulation_cmd);
7225
7226 install_element(RMAP_NODE, &match_peer_cmd);
7227 install_element(RMAP_NODE, &match_peer_local_cmd);
7228 install_element(RMAP_NODE, &no_match_peer_cmd);
7229 install_element(RMAP_NODE, &match_ip_route_source_cmd);
7230 install_element(RMAP_NODE, &no_match_ip_route_source_cmd);
7231 install_element(RMAP_NODE, &match_ip_route_source_prefix_list_cmd);
7232 install_element(RMAP_NODE, &no_match_ip_route_source_prefix_list_cmd);
7233 install_element(RMAP_NODE, &match_mac_address_cmd);
7234 install_element(RMAP_NODE, &no_match_mac_address_cmd);
7235 install_element(RMAP_NODE, &match_evpn_vni_cmd);
7236 install_element(RMAP_NODE, &no_match_evpn_vni_cmd);
7237 install_element(RMAP_NODE, &match_evpn_route_type_cmd);
7238 install_element(RMAP_NODE, &no_match_evpn_route_type_cmd);
7239 install_element(RMAP_NODE, &match_evpn_rd_cmd);
7240 install_element(RMAP_NODE, &no_match_evpn_rd_cmd);
7241 install_element(RMAP_NODE, &match_evpn_default_route_cmd);
7242 install_element(RMAP_NODE, &no_match_evpn_default_route_cmd);
7243 install_element(RMAP_NODE, &set_evpn_gw_ip_ipv4_cmd);
7244 install_element(RMAP_NODE, &no_set_evpn_gw_ip_ipv4_cmd);
7245 install_element(RMAP_NODE, &set_evpn_gw_ip_ipv6_cmd);
7246 install_element(RMAP_NODE, &no_set_evpn_gw_ip_ipv6_cmd);
7247 install_element(RMAP_NODE, &match_vrl_source_vrf_cmd);
7248 install_element(RMAP_NODE, &no_match_vrl_source_vrf_cmd);
7249
7250 install_element(RMAP_NODE, &match_aspath_cmd);
7251 install_element(RMAP_NODE, &no_match_aspath_cmd);
7252 install_element(RMAP_NODE, &match_local_pref_cmd);
7253 install_element(RMAP_NODE, &no_match_local_pref_cmd);
7254 install_element(RMAP_NODE, &match_alias_cmd);
7255 install_element(RMAP_NODE, &no_match_alias_cmd);
7256 install_element(RMAP_NODE, &match_community_cmd);
7257 install_element(RMAP_NODE, &no_match_community_cmd);
7258 install_element(RMAP_NODE, &match_lcommunity_cmd);
7259 install_element(RMAP_NODE, &no_match_lcommunity_cmd);
7260 install_element(RMAP_NODE, &match_ecommunity_cmd);
7261 install_element(RMAP_NODE, &no_match_ecommunity_cmd);
7262 install_element(RMAP_NODE, &match_origin_cmd);
7263 install_element(RMAP_NODE, &no_match_origin_cmd);
7264 install_element(RMAP_NODE, &match_probability_cmd);
7265 install_element(RMAP_NODE, &no_match_probability_cmd);
7266
7267 install_element(RMAP_NODE, &no_set_table_id_cmd);
7268 install_element(RMAP_NODE, &set_table_id_cmd);
7269 install_element(RMAP_NODE, &set_ip_nexthop_peer_cmd);
7270 install_element(RMAP_NODE, &set_ip_nexthop_unchanged_cmd);
7271 install_element(RMAP_NODE, &set_local_pref_cmd);
7272 install_element(RMAP_NODE, &set_distance_cmd);
7273 install_element(RMAP_NODE, &no_set_distance_cmd);
7274 install_element(RMAP_NODE, &no_set_local_pref_cmd);
7275 install_element(RMAP_NODE, &set_weight_cmd);
7276 install_element(RMAP_NODE, &set_label_index_cmd);
7277 install_element(RMAP_NODE, &no_set_weight_cmd);
7278 install_element(RMAP_NODE, &no_set_label_index_cmd);
7279 install_element(RMAP_NODE, &set_aspath_prepend_asn_cmd);
7280 install_element(RMAP_NODE, &set_aspath_prepend_lastas_cmd);
7281 install_element(RMAP_NODE, &set_aspath_exclude_cmd);
7282 install_element(RMAP_NODE, &set_aspath_replace_asn_cmd);
7283 install_element(RMAP_NODE, &no_set_aspath_prepend_cmd);
7284 install_element(RMAP_NODE, &no_set_aspath_prepend_lastas_cmd);
7285 install_element(RMAP_NODE, &no_set_aspath_exclude_cmd);
7286 install_element(RMAP_NODE, &no_set_aspath_exclude_all_cmd);
7287 install_element(RMAP_NODE, &no_set_aspath_replace_asn_cmd);
7288 install_element(RMAP_NODE, &set_origin_cmd);
7289 install_element(RMAP_NODE, &no_set_origin_cmd);
7290 install_element(RMAP_NODE, &set_atomic_aggregate_cmd);
7291 install_element(RMAP_NODE, &no_set_atomic_aggregate_cmd);
7292 install_element(RMAP_NODE, &set_aigp_metric_cmd);
7293 install_element(RMAP_NODE, &no_set_aigp_metric_cmd);
7294 install_element(RMAP_NODE, &set_aggregator_as_cmd);
7295 install_element(RMAP_NODE, &no_set_aggregator_as_cmd);
7296 install_element(RMAP_NODE, &set_community_cmd);
7297 install_element(RMAP_NODE, &set_community_none_cmd);
7298 install_element(RMAP_NODE, &no_set_community_cmd);
7299 install_element(RMAP_NODE, &no_set_community_short_cmd);
7300 install_element(RMAP_NODE, &set_community_delete_cmd);
7301 install_element(RMAP_NODE, &no_set_community_delete_cmd);
7302 install_element(RMAP_NODE, &set_lcommunity_cmd);
7303 install_element(RMAP_NODE, &set_lcommunity_none_cmd);
7304 install_element(RMAP_NODE, &no_set_lcommunity_cmd);
7305 install_element(RMAP_NODE, &no_set_lcommunity1_cmd);
7306 install_element(RMAP_NODE, &no_set_lcommunity1_short_cmd);
7307 install_element(RMAP_NODE, &set_lcommunity_delete_cmd);
7308 install_element(RMAP_NODE, &no_set_lcommunity_delete_cmd);
7309 install_element(RMAP_NODE, &no_set_lcommunity_delete_short_cmd);
7310 install_element(RMAP_NODE, &set_ecommunity_rt_cmd);
7311 install_element(RMAP_NODE, &no_set_ecommunity_rt_cmd);
7312 install_element(RMAP_NODE, &no_set_ecommunity_rt_short_cmd);
7313 install_element(RMAP_NODE, &set_ecommunity_soo_cmd);
7314 install_element(RMAP_NODE, &no_set_ecommunity_soo_cmd);
7315 install_element(RMAP_NODE, &no_set_ecommunity_soo_short_cmd);
7316 install_element(RMAP_NODE, &set_ecommunity_lb_cmd);
7317 install_element(RMAP_NODE, &no_set_ecommunity_lb_cmd);
7318 install_element(RMAP_NODE, &no_set_ecommunity_lb_short_cmd);
7319 install_element(RMAP_NODE, &set_ecommunity_none_cmd);
7320 install_element(RMAP_NODE, &no_set_ecommunity_none_cmd);
7321 #ifdef KEEP_OLD_VPN_COMMANDS
7322 install_element(RMAP_NODE, &set_vpn_nexthop_cmd);
7323 install_element(RMAP_NODE, &no_set_vpn_nexthop_cmd);
7324 #endif /* KEEP_OLD_VPN_COMMANDS */
7325 install_element(RMAP_NODE, &set_ipx_vpn_nexthop_cmd);
7326 install_element(RMAP_NODE, &no_set_ipx_vpn_nexthop_cmd);
7327 install_element(RMAP_NODE, &set_originator_id_cmd);
7328 install_element(RMAP_NODE, &no_set_originator_id_cmd);
7329 install_element(RMAP_NODE, &set_l3vpn_nexthop_encapsulation_cmd);
7330
7331 route_map_install_match(&route_match_ipv6_address_cmd);
7332 route_map_install_match(&route_match_ipv6_next_hop_cmd);
7333 route_map_install_match(&route_match_ipv6_next_hop_address_cmd);
7334 route_map_install_match(&route_match_ipv6_next_hop_prefix_list_cmd);
7335 route_map_install_match(&route_match_ipv4_next_hop_cmd);
7336 route_map_install_match(&route_match_ipv6_address_prefix_list_cmd);
7337 route_map_install_match(&route_match_ipv6_next_hop_type_cmd);
7338 route_map_install_set(&route_set_ipv6_nexthop_global_cmd);
7339 route_map_install_set(&route_set_ipv6_nexthop_prefer_global_cmd);
7340 route_map_install_set(&route_set_ipv6_nexthop_local_cmd);
7341 route_map_install_set(&route_set_ipv6_nexthop_peer_cmd);
7342 route_map_install_match(&route_match_rpki_extcommunity_cmd);
7343
7344 install_element(RMAP_NODE, &match_ipv6_next_hop_cmd);
7345 install_element(RMAP_NODE, &match_ipv6_next_hop_address_cmd);
7346 install_element(RMAP_NODE, &match_ipv6_next_hop_prefix_list_cmd);
7347 install_element(RMAP_NODE, &no_match_ipv6_next_hop_cmd);
7348 install_element(RMAP_NODE, &no_match_ipv6_next_hop_address_cmd);
7349 install_element(RMAP_NODE, &no_match_ipv6_next_hop_prefix_list_cmd);
7350 install_element(RMAP_NODE, &match_ipv6_next_hop_old_cmd);
7351 install_element(RMAP_NODE, &no_match_ipv6_next_hop_old_cmd);
7352 install_element(RMAP_NODE, &match_ipv4_next_hop_cmd);
7353 install_element(RMAP_NODE, &no_match_ipv4_next_hop_cmd);
7354 install_element(RMAP_NODE, &set_ipv6_nexthop_global_cmd);
7355 install_element(RMAP_NODE, &no_set_ipv6_nexthop_global_cmd);
7356 install_element(RMAP_NODE, &set_ipv6_nexthop_prefer_global_cmd);
7357 install_element(RMAP_NODE, &no_set_ipv6_nexthop_prefer_global_cmd);
7358 install_element(RMAP_NODE, &set_ipv6_nexthop_peer_cmd);
7359 install_element(RMAP_NODE, &no_set_ipv6_nexthop_peer_cmd);
7360 install_element(RMAP_NODE, &match_rpki_extcommunity_cmd);
7361 #ifdef HAVE_SCRIPTING
7362 install_element(RMAP_NODE, &match_script_cmd);
7363 #endif
7364 }
7365
7366 void bgp_route_map_terminate(void)
7367 {
7368 /* ToDo: Cleanup all the used memory */
7369 route_map_finish();
7370 }
FRRouting mirror