1 /* Ethernet-VPN Packet and vty Processing File
2 * Copyright (C) 2017 6WIND
4 * This file is part of FRRouting
6 * FRRouting is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * FRRouting is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "lib/printfrr.h"
26 #include "lib/vxlan.h"
29 #include "bgpd/bgpd.h"
30 #include "bgpd/bgp_table.h"
31 #include "bgpd/bgp_attr.h"
32 #include "bgpd/bgp_route.h"
33 #include "bgpd/bgp_mplsvpn.h"
34 #include "bgpd/bgp_vpn.h"
35 #include "bgpd/bgp_evpn_vty.h"
36 #include "bgpd/bgp_evpn.h"
37 #include "bgpd/bgp_evpn_private.h"
38 #include "bgpd/bgp_evpn_mh.h"
39 #include "bgpd/bgp_zebra.h"
40 #include "bgpd/bgp_vty.h"
41 #include "bgpd/bgp_errors.h"
42 #include "bgpd/bgp_ecommunity.h"
43 #include "bgpd/bgp_lcommunity.h"
44 #include "bgpd/bgp_community.h"
46 #define SHOW_DISPLAY_STANDARD 0
47 #define SHOW_DISPLAY_TAGS 1
48 #define SHOW_DISPLAY_OVERLAY 2
49 #define VNI_STR_LEN 32
52 * Context for VNI hash walk - used by callbacks.
57 struct in_addr vtep_ip
;
64 int argv_find_and_parse_oly_idx(struct cmd_token
**argv
, int argc
, int *oly_idx
,
65 enum overlay_index_type
*oly
)
67 *oly
= OVERLAY_INDEX_TYPE_NONE
;
68 if (argv_find(argv
, argc
, "gateway-ip", oly_idx
))
69 *oly
= OVERLAY_INDEX_GATEWAY_IP
;
73 static void display_vrf_import_rt(struct vty
*vty
, struct vrf_irt_node
*irt
,
77 uint8_t type
, sub_type
;
78 struct ecommunity_as eas
;
79 struct ecommunity_ip eip
;
80 struct listnode
*node
, *nnode
;
81 struct bgp
*tmp_bgp_vrf
= NULL
;
82 json_object
*json_rt
= NULL
;
83 json_object
*json_vrfs
= NULL
;
84 char rt_buf
[RT_ADDRSTRLEN
];
87 json_rt
= json_object_new_object();
88 json_vrfs
= json_object_new_array();
91 pnt
= (uint8_t *)&irt
->rt
.val
;
94 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
97 memset(&eas
, 0, sizeof(eas
));
99 case ECOMMUNITY_ENCODE_AS
:
100 eas
.as
= (*pnt
++ << 8);
102 ptr_get_be32(pnt
, &eas
.val
);
104 snprintf(rt_buf
, sizeof(rt_buf
), "%u:%u", eas
.as
, eas
.val
);
107 json_object_string_add(json_rt
, "rt", rt_buf
);
109 vty_out(vty
, "Route-target: %s", rt_buf
);
113 case ECOMMUNITY_ENCODE_IP
:
114 memcpy(&eip
.ip
, pnt
, 4);
116 eip
.val
= (*pnt
++ << 8);
119 snprintfrr(rt_buf
, sizeof(rt_buf
), "%pI4:%u", &eip
.ip
, eip
.val
);
122 json_object_string_add(json_rt
, "rt", rt_buf
);
124 vty_out(vty
, "Route-target: %s", rt_buf
);
128 case ECOMMUNITY_ENCODE_AS4
:
129 pnt
= ptr_get_be32(pnt
, &eas
.val
);
130 eas
.val
= (*pnt
++ << 8);
133 snprintf(rt_buf
, sizeof(rt_buf
), "%u:%u", eas
.as
, eas
.val
);
136 json_object_string_add(json_rt
, "rt", rt_buf
);
138 vty_out(vty
, "Route-target: %s", rt_buf
);
148 "\nList of VRFs importing routes with this route-target:\n");
151 for (ALL_LIST_ELEMENTS(irt
->vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
153 json_object_array_add(
155 json_object_new_string(
156 vrf_id_to_name(tmp_bgp_vrf
->vrf_id
)));
158 vty_out(vty
, " %s\n",
159 vrf_id_to_name(tmp_bgp_vrf
->vrf_id
));
163 json_object_object_add(json_rt
, "vrfs", json_vrfs
);
164 json_object_object_add(json
, rt_buf
, json_rt
);
168 static void show_vrf_import_rt_entry(struct hash_bucket
*bucket
, void *args
[])
170 json_object
*json
= NULL
;
171 struct vty
*vty
= NULL
;
172 struct vrf_irt_node
*irt
= (struct vrf_irt_node
*)bucket
->data
;
174 vty
= (struct vty
*)args
[0];
175 json
= (struct json_object
*)args
[1];
177 display_vrf_import_rt(vty
, irt
, json
);
180 static void display_import_rt(struct vty
*vty
, struct irt_node
*irt
,
184 uint8_t type
, sub_type
;
185 struct ecommunity_as eas
;
186 struct ecommunity_ip eip
;
187 struct listnode
*node
, *nnode
;
188 struct bgpevpn
*tmp_vpn
;
189 json_object
*json_rt
= NULL
;
190 json_object
*json_vnis
= NULL
;
191 char rt_buf
[RT_ADDRSTRLEN
];
194 json_rt
= json_object_new_object();
195 json_vnis
= json_object_new_array();
198 /* TODO: This needs to go into a function */
200 pnt
= (uint8_t *)&irt
->rt
.val
;
203 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
206 memset(&eas
, 0, sizeof(eas
));
208 case ECOMMUNITY_ENCODE_AS
:
209 eas
.as
= (*pnt
++ << 8);
211 ptr_get_be32(pnt
, &eas
.val
);
213 snprintf(rt_buf
, sizeof(rt_buf
), "%u:%u", eas
.as
, eas
.val
);
216 json_object_string_add(json_rt
, "rt", rt_buf
);
218 vty_out(vty
, "Route-target: %s", rt_buf
);
222 case ECOMMUNITY_ENCODE_IP
:
223 memcpy(&eip
.ip
, pnt
, 4);
225 eip
.val
= (*pnt
++ << 8);
228 snprintfrr(rt_buf
, sizeof(rt_buf
), "%pI4:%u", &eip
.ip
, eip
.val
);
231 json_object_string_add(json_rt
, "rt", rt_buf
);
233 vty_out(vty
, "Route-target: %s", rt_buf
);
237 case ECOMMUNITY_ENCODE_AS4
:
238 pnt
= ptr_get_be32(pnt
, &eas
.val
);
239 eas
.val
= (*pnt
++ << 8);
242 snprintf(rt_buf
, sizeof(rt_buf
), "%u:%u", eas
.as
, eas
.val
);
245 json_object_string_add(json_rt
, "rt", rt_buf
);
247 vty_out(vty
, "Route-target: %s", rt_buf
);
257 "\nList of VNIs importing routes with this route-target:\n");
260 for (ALL_LIST_ELEMENTS(irt
->vnis
, node
, nnode
, tmp_vpn
)) {
262 json_object_array_add(
263 json_vnis
, json_object_new_int(tmp_vpn
->vni
));
265 vty_out(vty
, " %u\n", tmp_vpn
->vni
);
269 json_object_object_add(json_rt
, "vnis", json_vnis
);
270 json_object_object_add(json
, rt_buf
, json_rt
);
274 static void show_import_rt_entry(struct hash_bucket
*bucket
, void *args
[])
276 json_object
*json
= NULL
;
277 struct vty
*vty
= NULL
;
278 struct irt_node
*irt
= (struct irt_node
*)bucket
->data
;
283 display_import_rt(vty
, irt
, json
);
288 static void bgp_evpn_show_route_rd_header(struct vty
*vty
,
289 struct bgp_dest
*rd_dest
,
290 json_object
*json
, char *rd_str
,
297 const struct prefix
*p
= bgp_dest_get_prefix(rd_dest
);
301 /* Decode RD type. */
302 type
= decode_rd_type(pnt
);
305 vty_out(vty
, "Route Distinguisher: ");
309 decode_rd_as(pnt
+ 2, &rd_as
);
310 snprintf(rd_str
, len
, "%u:%d", rd_as
.as
, rd_as
.val
);
312 json_object_string_add(json
, "rd", rd_str
);
314 vty_out(vty
, "%s\n", rd_str
);
318 decode_rd_as4(pnt
+ 2, &rd_as
);
319 snprintf(rd_str
, len
, "%u:%d", rd_as
.as
, rd_as
.val
);
321 json_object_string_add(json
, "rd", rd_str
);
323 vty_out(vty
, "%s\n", rd_str
);
327 decode_rd_ip(pnt
+ 2, &rd_ip
);
328 snprintfrr(rd_str
, len
, "%pI4:%d", &rd_ip
.ip
, rd_ip
.val
);
330 json_object_string_add(json
, "rd", rd_str
);
332 vty_out(vty
, "%s\n", rd_str
);
337 snprintf(rd_str
, len
, "Unknown");
338 json_object_string_add(json
, "rd", rd_str
);
340 snprintf(rd_str
, len
, "Unknown RD type");
341 vty_out(vty
, "%s\n", rd_str
);
347 static void bgp_evpn_show_route_header(struct vty
*vty
, struct bgp
*bgp
,
348 uint64_t tbl_ver
, json_object
*json
)
351 " Network Next Hop Metric LocPrf Weight Path\n";
357 "BGP table version is %" PRIu64
", local router ID is %pI4\n",
358 tbl_ver
, &bgp
->router_id
);
360 "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal\n");
361 vty_out(vty
, "Origin codes: i - IGP, e - EGP, ? - incomplete\n");
363 "EVPN type-1 prefix: [1]:[EthTag]:[ESI]:[IPlen]:[VTEP-IP]:[Frag-id]\n");
365 "EVPN type-2 prefix: [2]:[EthTag]:[MAClen]:[MAC]:[IPlen]:[IP]\n");
366 vty_out(vty
, "EVPN type-3 prefix: [3]:[EthTag]:[IPlen]:[OrigIP]\n");
367 vty_out(vty
, "EVPN type-4 prefix: [4]:[ESI]:[IPlen]:[OrigIP]\n");
368 vty_out(vty
, "EVPN type-5 prefix: [5]:[EthTag]:[IPlen]:[IP]\n\n");
369 vty_out(vty
, "%s", ri_header
);
372 static void display_l3vni(struct vty
*vty
, struct bgp
*bgp_vrf
,
376 struct listnode
*node
, *nnode
;
377 struct vrf_route_target
*l3rt
;
378 json_object
*json_import_rtl
= NULL
;
379 json_object
*json_export_rtl
= NULL
;
380 char buf2
[ETHER_ADDR_STRLEN
];
382 json_import_rtl
= json_export_rtl
= 0;
385 json_import_rtl
= json_object_new_array();
386 json_export_rtl
= json_object_new_array();
387 json_object_int_add(json
, "vni", bgp_vrf
->l3vni
);
388 json_object_string_add(json
, "type", "L3");
389 json_object_string_add(json
, "inKernel", "True");
390 json_object_string_addf(json
, "rd", "%pRD", &bgp_vrf
->vrf_prd
);
391 json_object_string_addf(json
, "originatorIp", "%pI4",
392 &bgp_vrf
->originator_ip
);
393 json_object_string_add(json
, "advertiseGatewayMacip", "n/a");
394 json_object_string_add(json
, "advertiseSviMacIp", "n/a");
395 json_object_string_add(json
, "advertisePip",
396 bgp_vrf
->evpn_info
->advertise_pip
?
397 "Enabled" : "Disabled");
398 json_object_string_addf(json
, "sysIP", "%pI4",
399 &bgp_vrf
->evpn_info
->pip_ip
);
400 json_object_string_add(json
, "sysMac",
401 prefix_mac2str(&bgp_vrf
->evpn_info
->pip_rmac
,
402 buf2
, sizeof(buf2
)));
403 json_object_string_add(json
, "rmac",
404 prefix_mac2str(&bgp_vrf
->rmac
,
405 buf2
, sizeof(buf2
)));
407 vty_out(vty
, "VNI: %d", bgp_vrf
->l3vni
);
408 vty_out(vty
, " (known to the kernel)");
411 vty_out(vty
, " Type: %s\n", "L3");
412 vty_out(vty
, " Tenant VRF: %s\n",
413 vrf_id_to_name(bgp_vrf
->vrf_id
));
414 vty_out(vty
, " RD: %pRD\n", &bgp_vrf
->vrf_prd
);
415 vty_out(vty
, " Originator IP: %pI4\n",
416 &bgp_vrf
->originator_ip
);
417 vty_out(vty
, " Advertise-gw-macip : %s\n", "n/a");
418 vty_out(vty
, " Advertise-svi-macip : %s\n", "n/a");
419 vty_out(vty
, " Advertise-pip: %s\n",
420 bgp_vrf
->evpn_info
->advertise_pip
? "Yes" : "No");
421 vty_out(vty
, " System-IP: %pI4\n",
422 &bgp_vrf
->evpn_info
->pip_ip
);
423 vty_out(vty
, " System-MAC: %s\n",
424 prefix_mac2str(&bgp_vrf
->evpn_info
->pip_rmac
,
425 buf2
, sizeof(buf2
)));
426 vty_out(vty
, " Router-MAC: %s\n",
427 prefix_mac2str(&bgp_vrf
->rmac
,
428 buf2
, sizeof(buf2
)));
432 vty_out(vty
, " Import Route Target:\n");
434 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, l3rt
)) {
435 ecom_str
= ecommunity_ecom2str(l3rt
->ecom
,
436 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
439 json_object_array_add(json_import_rtl
,
440 json_object_new_string(ecom_str
));
442 vty_out(vty
, " %s\n", ecom_str
);
444 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
448 json_object_object_add(json
, "importRts", json_import_rtl
);
450 vty_out(vty
, " Export Route Target:\n");
452 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, l3rt
)) {
453 ecom_str
= ecommunity_ecom2str(l3rt
->ecom
,
454 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
457 json_object_array_add(json_export_rtl
,
458 json_object_new_string(ecom_str
));
460 vty_out(vty
, " %s\n", ecom_str
);
462 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
466 json_object_object_add(json
, "exportRts", json_export_rtl
);
469 static void display_vni(struct vty
*vty
, struct bgpevpn
*vpn
, json_object
*json
)
472 struct listnode
*node
, *nnode
;
473 struct ecommunity
*ecom
;
474 json_object
*json_import_rtl
= NULL
;
475 json_object
*json_export_rtl
= NULL
;
476 struct bgp
*bgp_evpn
;
478 bgp_evpn
= bgp_get_evpn();
481 json_import_rtl
= json_object_new_array();
482 json_export_rtl
= json_object_new_array();
483 json_object_int_add(json
, "vni", vpn
->vni
);
484 json_object_string_add(json
, "type", "L2");
485 json_object_string_add(json
, "inKernel",
486 is_vni_live(vpn
) ? "True" : "False");
487 json_object_string_addf(json
, "rd", "%pRD", &vpn
->prd
);
488 json_object_string_addf(json
, "originatorIp", "%pI4",
489 &vpn
->originator_ip
);
490 json_object_string_addf(json
, "mcastGroup", "%pI4",
492 /* per vni knob is enabled -- Enabled
493 * Global knob is enabled -- Active
494 * default -- Disabled
496 if (!vpn
->advertise_gw_macip
&&
497 bgp_evpn
&& bgp_evpn
->advertise_gw_macip
)
498 json_object_string_add(json
, "advertiseGatewayMacip",
500 else if (vpn
->advertise_gw_macip
)
501 json_object_string_add(json
, "advertiseGatewayMacip",
504 json_object_string_add(json
, "advertiseGatewayMacip",
506 if (!vpn
->advertise_svi_macip
&& bgp_evpn
&&
507 bgp_evpn
->evpn_info
->advertise_svi_macip
)
508 json_object_string_add(json
, "advertiseSviMacIp",
510 else if (vpn
->advertise_svi_macip
)
511 json_object_string_add(json
, "advertiseSviMacIp",
514 json_object_string_add(json
, "advertiseSviMacIp",
516 json_object_string_add(
517 json
, "sviInterface",
518 ifindex2ifname(vpn
->svi_ifindex
, vpn
->tenant_vrf_id
));
520 vty_out(vty
, "VNI: %u", vpn
->vni
);
521 if (is_vni_live(vpn
))
522 vty_out(vty
, " (known to the kernel)");
525 vty_out(vty
, " Type: %s\n", "L2");
526 vty_out(vty
, " Tenant-Vrf: %s\n",
527 vrf_id_to_name(vpn
->tenant_vrf_id
));
528 vty_out(vty
, " RD: %pRD\n", &vpn
->prd
);
529 vty_out(vty
, " Originator IP: %pI4\n", &vpn
->originator_ip
);
530 vty_out(vty
, " Mcast group: %pI4\n", &vpn
->mcast_grp
);
531 if (!vpn
->advertise_gw_macip
&&
532 bgp_evpn
&& bgp_evpn
->advertise_gw_macip
)
533 vty_out(vty
, " Advertise-gw-macip : %s\n",
535 else if (vpn
->advertise_gw_macip
)
536 vty_out(vty
, " Advertise-gw-macip : %s\n",
539 vty_out(vty
, " Advertise-gw-macip : %s\n",
541 if (!vpn
->advertise_svi_macip
&& bgp_evpn
&&
542 bgp_evpn
->evpn_info
->advertise_svi_macip
)
543 vty_out(vty
, " Advertise-svi-macip : %s\n",
545 else if (vpn
->advertise_svi_macip
)
546 vty_out(vty
, " Advertise-svi-macip : %s\n",
549 vty_out(vty
, " Advertise-svi-macip : %s\n",
551 vty_out(vty
, " SVI interface : %s\n",
552 ifindex2ifname(vpn
->svi_ifindex
, vpn
->tenant_vrf_id
));
556 vty_out(vty
, " Import Route Target:\n");
558 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
559 ecom_str
= ecommunity_ecom2str(ecom
,
560 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
563 json_object_array_add(json_import_rtl
,
564 json_object_new_string(ecom_str
));
566 vty_out(vty
, " %s\n", ecom_str
);
568 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
572 json_object_object_add(json
, "importRts", json_import_rtl
);
574 vty_out(vty
, " Export Route Target:\n");
576 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
)) {
577 ecom_str
= ecommunity_ecom2str(ecom
,
578 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
581 json_object_array_add(json_export_rtl
,
582 json_object_new_string(ecom_str
));
584 vty_out(vty
, " %s\n", ecom_str
);
586 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
590 json_object_object_add(json
, "exportRts", json_export_rtl
);
593 static void show_esi_routes(struct bgp
*bgp
,
594 struct bgp_evpn_es
*es
,
599 struct bgp_dest
*dest
;
600 struct bgp_path_info
*pi
;
601 uint32_t prefix_cnt
, path_cnt
;
604 prefix_cnt
= path_cnt
= 0;
606 tbl_ver
= es
->route_table
->version
;
607 for (dest
= bgp_table_top(es
->route_table
); dest
;
608 dest
= bgp_route_next(dest
)) {
609 int add_prefix_to_json
= 0;
610 json_object
*json_paths
= NULL
;
611 json_object
*json_prefix
= NULL
;
612 const struct prefix
*p
= bgp_dest_get_prefix(dest
);
615 json_prefix
= json_object_new_object();
617 pi
= bgp_dest_get_bgp_path_info(dest
);
619 /* Overall header/legend displayed once. */
621 bgp_evpn_show_route_header(vty
, bgp
,
630 json_paths
= json_object_new_array();
632 /* For EVPN, the prefix is displayed for each path (to fit in
633 * with code that already exists).
635 for (; pi
; pi
= pi
->next
) {
636 json_object
*json_path
= NULL
;
639 json_path
= json_object_new_array();
641 route_vty_out(vty
, p
, pi
, 0, SAFI_EVPN
, json_path
,
645 json_object_array_add(json_paths
, json_path
);
648 add_prefix_to_json
= 1;
652 if (add_prefix_to_json
) {
653 json_object_string_addf(json_prefix
, "prefix",
655 json_object_int_add(json_prefix
, "prefixLen",
657 json_object_object_add(json_prefix
, "paths",
659 json_object_object_addf(json
, json_prefix
,
662 json_object_free(json_paths
);
663 json_object_free(json_prefix
);
671 json_object_int_add(json
, "numPrefix", prefix_cnt
);
672 json_object_int_add(json
, "numPaths", path_cnt
);
675 vty_out(vty
, "No EVPN prefixes exist for this ESI\n");
677 vty_out(vty
, "\nDisplayed %u prefixes (%u paths)\n",
678 prefix_cnt
, path_cnt
);
682 /* Display all MAC-IP VNI routes linked to an ES */
683 static void bgp_evpn_show_routes_mac_ip_es(struct vty
*vty
, esi_t
*esi
,
684 json_object
*json
, int detail
,
688 struct bgp_path_info
*pi
;
689 int header
= detail
? 0 : 1;
691 struct listnode
*node
;
692 struct bgp_evpn_es
*es
;
693 struct bgp_path_es_info
*es_info
;
694 struct bgp
*bgp
= bgp_get_evpn();
695 json_object
*json_paths
= NULL
;
703 json_paths
= json_object_new_array();
705 RB_FOREACH (es
, bgp_es_rb_head
, &bgp_mh_info
->es_rb_tree
) {
706 struct list
*es_list
;
708 if (esi
&& memcmp(esi
, &es
->esi
, sizeof(*esi
)))
712 es_list
= es
->macip_global_path_list
;
714 es_list
= es
->macip_evi_path_list
;
716 for (ALL_LIST_ELEMENTS_RO(es_list
, node
, es_info
)) {
717 json_object
*json_path
= NULL
;
722 if (!CHECK_FLAG(pi
->flags
, BGP_PATH_VALID
))
725 /* Overall header/legend displayed once. */
727 bgp_evpn_show_route_header(vty
, bgp
, 0, json
);
734 json_path
= json_object_new_array();
737 route_vty_out_detail(
738 vty
, bgp
, rn
, bgp_dest_get_prefix(rn
),
739 pi
, AFI_L2VPN
, SAFI_EVPN
,
740 RPKI_NOT_BEING_USED
, json_path
);
742 route_vty_out(vty
, &rn
->p
, pi
, 0, SAFI_EVPN
,
746 json_object_array_add(json_paths
, json_path
);
751 json_object_object_add(json
, "paths", json_paths
);
752 json_object_int_add(json
, "numPaths", path_cnt
);
755 vty_out(vty
, "There are no MAC-IP ES paths");
757 vty_out(vty
, "\nDisplayed %u paths\n", path_cnt
);
762 static void bgp_evpn_show_routes_mac_ip_evi_es(struct vty
*vty
, esi_t
*esi
,
763 json_object
*json
, int detail
)
765 bgp_evpn_show_routes_mac_ip_es(vty
, esi
, json
, detail
, false);
768 static void bgp_evpn_show_routes_mac_ip_global_es(struct vty
*vty
, esi_t
*esi
,
769 json_object
*json
, int detail
)
771 bgp_evpn_show_routes_mac_ip_es(vty
, esi
, json
, detail
, true);
774 static void show_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
,
775 struct vty
*vty
, int type
, bool mac_table
,
776 struct in_addr vtep_ip
, json_object
*json
,
779 struct bgp_dest
*dest
;
780 struct bgp_path_info
*pi
;
781 struct bgp_table
*table
;
782 int header
= detail
? 0 : 1;
784 uint32_t prefix_cnt
, path_cnt
;
786 prefix_cnt
= path_cnt
= 0;
789 table
= vpn
->mac_table
;
791 table
= vpn
->ip_table
;
793 tbl_ver
= table
->version
;
794 for (dest
= bgp_table_top(table
); dest
; dest
= bgp_route_next(dest
)) {
795 const struct prefix_evpn
*evp
=
796 (const struct prefix_evpn
*)bgp_dest_get_prefix(dest
);
797 int add_prefix_to_json
= 0;
798 json_object
*json_paths
= NULL
;
799 json_object
*json_prefix
= NULL
;
800 const struct prefix
*p
= bgp_dest_get_prefix(dest
);
802 if (type
&& evp
->prefix
.route_type
!= type
)
806 json_prefix
= json_object_new_object();
808 pi
= bgp_dest_get_bgp_path_info(dest
);
810 /* Overall header/legend displayed once. */
812 bgp_evpn_show_route_header(vty
, bgp
,
821 json_paths
= json_object_new_array();
823 /* For EVPN, the prefix is displayed for each path (to fit in
824 * with code that already exists).
826 for (; pi
; pi
= pi
->next
) {
828 json_object
*json_path
= NULL
;
830 if (vtep_ip
.s_addr
!= INADDR_ANY
831 && !IPV4_ADDR_SAME(&(vtep_ip
),
832 &(pi
->attr
->nexthop
)))
835 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
837 * VNI IP/MAC table prefixes don't have MAC/IP
838 * respectively so make sure it's set from path
841 if (is_evpn_prefix_ipaddr_none(evp
)) {
842 /* VNI MAC -> Global */
843 evpn_type2_prefix_global_copy(
844 (struct prefix_evpn
*)&tmp_p
,
846 evpn_type2_path_info_get_ip(
849 /* VNI IP -> Global */
850 evpn_type2_prefix_global_copy(
851 (struct prefix_evpn
*)&tmp_p
,
853 evpn_type2_path_info_get_mac(
858 memcpy(&tmp_p
, p
, sizeof(tmp_p
));
862 json_path
= json_object_new_array();
865 route_vty_out_detail(vty
, bgp
, dest
, &tmp_p
, pi
,
866 AFI_L2VPN
, SAFI_EVPN
,
871 route_vty_out(vty
, &tmp_p
, pi
, 0, SAFI_EVPN
,
875 json_object_array_add(json_paths
, json_path
);
878 add_prefix_to_json
= 1;
882 if (add_prefix_to_json
) {
883 json_object_string_addf(json_prefix
, "prefix",
885 json_object_int_add(json_prefix
, "prefixLen",
887 json_object_object_add(json_prefix
, "paths",
889 json_object_object_addf(json
, json_prefix
,
892 json_object_free(json_paths
);
893 json_object_free(json_prefix
);
901 json_object_int_add(json
, "numPrefix", prefix_cnt
);
902 json_object_int_add(json
, "numPaths", path_cnt
);
905 vty_out(vty
, "No EVPN prefixes %sexist for this VNI",
906 type
? "(of requested type) " : "");
908 vty_out(vty
, "\nDisplayed %u prefixes (%u paths)%s\n",
909 prefix_cnt
, path_cnt
,
910 type
? " (of requested type)" : "");
915 static void show_vni_routes_hash(struct hash_bucket
*bucket
, void *arg
)
917 struct bgpevpn
*vpn
= (struct bgpevpn
*)bucket
->data
;
918 struct vni_walk_ctx
*wctx
= arg
;
919 struct vty
*vty
= wctx
->vty
;
920 json_object
*json
= wctx
->json
;
921 json_object
*json_vni
= NULL
;
922 char vni_str
[VNI_STR_LEN
];
924 snprintf(vni_str
, sizeof(vni_str
), "%u", vpn
->vni
);
926 json_vni
= json_object_new_object();
927 json_object_int_add(json_vni
, "vni", vpn
->vni
);
929 vty_out(vty
, "\nVNI: %u\n\n", vpn
->vni
);
932 show_vni_routes(wctx
->bgp
, vpn
, wctx
->vty
, wctx
->type
, wctx
->mac_table
,
933 wctx
->vtep_ip
, json_vni
, wctx
->detail
);
936 json_object_object_add(json
, vni_str
, json_vni
);
939 static void show_vni_routes_all_hash(struct hash_bucket
*bucket
, void *arg
)
941 struct bgpevpn
*vpn
= (struct bgpevpn
*)bucket
->data
;
942 struct vni_walk_ctx
*wctx
= arg
;
943 struct vty
*vty
= wctx
->vty
;
944 json_object
*json
= wctx
->json
;
945 json_object
*json_vni
= NULL
;
946 json_object
*json_vni_mac
= NULL
;
947 char vni_str
[VNI_STR_LEN
];
949 snprintf(vni_str
, sizeof(vni_str
), "%u", vpn
->vni
);
951 json_vni
= json_object_new_object();
952 json_object_int_add(json_vni
, "vni", vpn
->vni
);
954 vty_out(vty
, "\nVNI: %u\n\n", vpn
->vni
);
957 show_vni_routes(wctx
->bgp
, vpn
, wctx
->vty
, 0, false, wctx
->vtep_ip
,
958 json_vni
, wctx
->detail
);
961 json_object_object_add(json
, vni_str
, json_vni
);
964 json_vni_mac
= json_object_new_object();
966 vty_out(vty
, "\nVNI: %u MAC Table\n\n", vpn
->vni
);
968 show_vni_routes(wctx
->bgp
, vpn
, wctx
->vty
, 0, true, wctx
->vtep_ip
,
969 json_vni_mac
, wctx
->detail
);
972 json_object_object_add(json_vni
, "macTable", json_vni_mac
);
975 static void show_l3vni_entry(struct vty
*vty
, struct bgp
*bgp
,
978 json_object
*json_vni
= NULL
;
979 json_object
*json_import_rtl
= NULL
;
980 json_object
*json_export_rtl
= NULL
;
982 char buf2
[INET6_ADDRSTRLEN
];
985 struct listnode
*node
, *nnode
;
986 struct vrf_route_target
*l3rt
;
992 json_vni
= json_object_new_object();
993 json_import_rtl
= json_object_new_array();
994 json_export_rtl
= json_object_new_array();
997 /* if an l3vni is present in bgp it is live */
999 snprintf(buf1
, sizeof(buf1
), "*");
1002 json_object_int_add(json_vni
, "vni", bgp
->l3vni
);
1003 json_object_string_add(json_vni
, "type", "L3");
1004 json_object_string_add(json_vni
, "inKernel", "True");
1005 json_object_string_addf(json_vni
, "originatorIp", "%pI4",
1006 &bgp
->originator_ip
);
1007 json_object_string_addf(json_vni
, "rd", "%pRD", &bgp
->vrf_prd
);
1008 json_object_string_add(json_vni
, "advertiseGatewayMacip",
1010 json_object_string_add(json_vni
, "advertiseSviMacIp", "n/a");
1011 json_object_string_add(
1012 json_vni
, "advertisePip",
1013 bgp
->evpn_info
->advertise_pip
? "Enabled" : "Disabled");
1014 json_object_string_addf(json_vni
, "sysIP", "%pI4",
1015 &bgp
->evpn_info
->pip_ip
);
1016 json_object_string_add(json_vni
, "sysMAC",
1017 prefix_mac2str(&bgp
->evpn_info
->pip_rmac
,
1018 buf2
, sizeof(buf2
)));
1019 json_object_string_add(
1021 prefix_mac2str(&bgp
->rmac
, buf2
, sizeof(buf2
)));
1023 vty_out(vty
, "%-1s %-10u %-4s %-21pRD", buf1
, bgp
->l3vni
, "L3",
1027 for (ALL_LIST_ELEMENTS(bgp
->vrf_import_rtl
, node
, nnode
, l3rt
)) {
1028 ecom_str
= ecommunity_ecom2str(l3rt
->ecom
,
1029 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
1032 json_object_array_add(json_import_rtl
,
1033 json_object_new_string(ecom_str
));
1035 if (listcount(bgp
->vrf_import_rtl
) > 1)
1036 snprintf(rt_buf
, sizeof(rt_buf
), "%s, ...",
1039 snprintf(rt_buf
, sizeof(rt_buf
), "%s",
1041 vty_out(vty
, " %-25s", rt_buf
);
1044 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
1046 /* If there are multiple import RTs we break here and show only
1053 json_object_object_add(json_vni
, "importRTs", json_import_rtl
);
1055 for (ALL_LIST_ELEMENTS(bgp
->vrf_export_rtl
, node
, nnode
, l3rt
)) {
1056 ecom_str
= ecommunity_ecom2str(l3rt
->ecom
,
1057 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
1060 json_object_array_add(json_export_rtl
,
1061 json_object_new_string(ecom_str
));
1063 if (listcount(bgp
->vrf_export_rtl
) > 1)
1064 snprintf(rt_buf
, sizeof(rt_buf
), "%s, ...",
1067 snprintf(rt_buf
, sizeof(rt_buf
), "%s",
1069 vty_out(vty
, " %-25s", rt_buf
);
1072 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
1074 /* If there are multiple export RTs we break here and show only
1077 vty_out(vty
, "%-37s", vrf_id_to_name(bgp
->vrf_id
));
1083 char vni_str
[VNI_STR_LEN
];
1085 json_object_object_add(json_vni
, "exportRTs", json_export_rtl
);
1086 snprintf(vni_str
, sizeof(vni_str
), "%u", bgp
->l3vni
);
1087 json_object_object_add(json
, vni_str
, json_vni
);
1093 static void show_vni_entry(struct hash_bucket
*bucket
, void *args
[])
1097 json_object
*json_vni
= NULL
;
1098 json_object
*json_import_rtl
= NULL
;
1099 json_object
*json_export_rtl
= NULL
;
1100 struct bgpevpn
*vpn
= (struct bgpevpn
*)bucket
->data
;
1104 struct listnode
*node
, *nnode
;
1105 struct ecommunity
*ecom
;
1106 struct bgp
*bgp_evpn
;
1111 bgp_evpn
= bgp_get_evpn();
1114 json_vni
= json_object_new_object();
1115 json_import_rtl
= json_object_new_array();
1116 json_export_rtl
= json_object_new_array();
1120 if (is_vni_live(vpn
))
1121 snprintf(buf1
, sizeof(buf1
), "*");
1124 json_object_int_add(json_vni
, "vni", vpn
->vni
);
1125 json_object_string_add(json_vni
, "type", "L2");
1126 json_object_string_add(json_vni
, "inKernel",
1127 is_vni_live(vpn
) ? "True" : "False");
1128 json_object_string_addf(json_vni
, "rd", "%pRD", &vpn
->prd
);
1129 json_object_string_addf(json_vni
, "originatorIp", "%pI4",
1130 &vpn
->originator_ip
);
1131 json_object_string_addf(json_vni
, "mcastGroup", "%pI4",
1133 /* per vni knob is enabled -- Enabled
1134 * Global knob is enabled -- Active
1135 * default -- Disabled
1137 if (!vpn
->advertise_gw_macip
&& bgp_evpn
1138 && bgp_evpn
->advertise_gw_macip
)
1139 json_object_string_add(
1140 json_vni
, "advertiseGatewayMacip", "Active");
1141 else if (vpn
->advertise_gw_macip
)
1142 json_object_string_add(
1143 json_vni
, "advertiseGatewayMacip", "Enabled");
1145 json_object_string_add(
1146 json_vni
, "advertiseGatewayMacip", "Disabled");
1147 if (!vpn
->advertise_svi_macip
&& bgp_evpn
1148 && bgp_evpn
->evpn_info
->advertise_svi_macip
)
1149 json_object_string_add(json_vni
, "advertiseSviMacIp",
1151 else if (vpn
->advertise_svi_macip
)
1152 json_object_string_add(json_vni
, "advertiseSviMacIp",
1155 json_object_string_add(json_vni
, "advertiseSviMacIp",
1158 vty_out(vty
, "%-1s %-10u %-4s %-21pRD", buf1
, vpn
->vni
, "L2",
1162 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
1163 ecom_str
= ecommunity_ecom2str(ecom
,
1164 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
1167 json_object_array_add(json_import_rtl
,
1168 json_object_new_string(ecom_str
));
1170 if (listcount(vpn
->import_rtl
) > 1)
1171 snprintf(rt_buf
, sizeof(rt_buf
), "%s, ...",
1174 snprintf(rt_buf
, sizeof(rt_buf
), "%s",
1176 vty_out(vty
, " %-25s", rt_buf
);
1179 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
1181 /* If there are multiple import RTs we break here and show only
1188 json_object_object_add(json_vni
, "importRTs", json_import_rtl
);
1190 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
)) {
1191 ecom_str
= ecommunity_ecom2str(ecom
,
1192 ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
1195 json_object_array_add(json_export_rtl
,
1196 json_object_new_string(ecom_str
));
1198 if (listcount(vpn
->export_rtl
) > 1)
1199 snprintf(rt_buf
, sizeof(rt_buf
), "%s, ...",
1202 snprintf(rt_buf
, sizeof(rt_buf
), "%s",
1204 vty_out(vty
, " %-25s", rt_buf
);
1207 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
1209 /* If there are multiple export RTs we break here and show only
1212 vty_out(vty
, "%-37s",
1213 vrf_id_to_name(vpn
->tenant_vrf_id
));
1219 char vni_str
[VNI_STR_LEN
];
1221 json_object_object_add(json_vni
, "exportRTs", json_export_rtl
);
1222 snprintf(vni_str
, sizeof(vni_str
), "%u", vpn
->vni
);
1223 json_object_object_add(json
, vni_str
, json_vni
);
1229 static int bgp_show_ethernet_vpn(struct vty
*vty
, struct prefix_rd
*prd
,
1230 enum bgp_show_type type
, void *output_arg
,
1231 int option
, bool use_json
)
1233 afi_t afi
= AFI_L2VPN
;
1235 struct bgp_table
*table
;
1236 struct bgp_dest
*dest
;
1237 struct bgp_dest
*rm
;
1238 struct bgp_path_info
*pi
;
1241 char rd_str
[RD_ADDRSTRLEN
];
1244 unsigned long output_count
= 0;
1245 unsigned long total_count
= 0;
1246 json_object
*json
= NULL
;
1247 json_object
*json_array
= NULL
;
1248 json_object
*json_prefix_info
= NULL
;
1250 memset(rd_str
, 0, RD_ADDRSTRLEN
);
1252 bgp
= bgp_get_evpn();
1255 vty_out(vty
, "No BGP process is configured\n");
1257 vty_out(vty
, "{}\n");
1262 json
= json_object_new_object();
1264 for (dest
= bgp_table_top(bgp
->rib
[afi
][SAFI_EVPN
]); dest
;
1265 dest
= bgp_route_next(dest
)) {
1267 json_object
*json_nroute
= NULL
;
1268 const struct prefix
*p
= bgp_dest_get_prefix(dest
);
1270 if (prd
&& memcmp(p
->u
.val
, prd
->val
, 8) != 0)
1273 table
= bgp_dest_get_bgp_table_info(dest
);
1278 tbl_ver
= table
->version
;
1280 for (rm
= bgp_table_top(table
); rm
; rm
= bgp_route_next(rm
)) {
1281 pi
= bgp_dest_get_bgp_path_info(rm
);
1286 for (; pi
; pi
= pi
->next
) {
1287 struct community
*picomm
= NULL
;
1289 picomm
= bgp_attr_get_community(pi
->attr
);
1292 if (type
== bgp_show_type_neighbor
) {
1293 struct peer
*peer
= output_arg
;
1295 if (peer_cmp(peer
, pi
->peer
) != 0)
1298 if (type
== bgp_show_type_lcommunity_exact
) {
1299 struct lcommunity
*lcom
= output_arg
;
1301 if (!bgp_attr_get_lcommunity(
1304 bgp_attr_get_lcommunity(
1309 if (type
== bgp_show_type_lcommunity
) {
1310 struct lcommunity
*lcom
= output_arg
;
1312 if (!bgp_attr_get_lcommunity(
1315 bgp_attr_get_lcommunity(
1320 if (type
== bgp_show_type_community
) {
1321 struct community
*com
= output_arg
;
1324 !community_match(picomm
, com
))
1327 if (type
== bgp_show_type_community_exact
) {
1328 struct community
*com
= output_arg
;
1331 !community_cmp(picomm
, com
))
1336 json_object_int_add(
1337 json
, "bgpTableVersion",
1339 json_object_string_addf(
1344 json_object_int_add(
1347 bgp
->default_local_pref
);
1348 json_object_int_add(
1352 if (option
== SHOW_DISPLAY_TAGS
)
1357 == SHOW_DISPLAY_OVERLAY
)
1361 bgp_evpn_show_route_header(vty
, bgp
, tbl_ver
, NULL
);
1369 json_object_new_object();
1370 bgp_evpn_show_route_rd_header(
1371 vty
, dest
, json_nroute
, rd_str
,
1375 if (use_json
&& !json_array
)
1376 json_array
= json_object_new_array();
1378 if (option
== SHOW_DISPLAY_TAGS
)
1380 vty
, bgp_dest_get_prefix(rm
),
1381 pi
, no_display
, SAFI_EVPN
,
1383 else if (option
== SHOW_DISPLAY_OVERLAY
)
1384 route_vty_out_overlay(
1385 vty
, bgp_dest_get_prefix(rm
),
1386 pi
, no_display
, json_array
);
1389 bgp_dest_get_prefix(rm
),
1390 pi
, no_display
, SAFI_EVPN
,
1398 if (use_json
&& json_array
) {
1399 const struct prefix
*p
=
1400 bgp_dest_get_prefix(rm
);
1402 json_prefix_info
= json_object_new_object();
1404 json_object_string_addf(json_prefix_info
,
1405 "prefix", "%pFX", p
);
1407 json_object_int_add(json_prefix_info
,
1408 "prefixLen", p
->prefixlen
);
1410 json_object_object_add(json_prefix_info
,
1411 "paths", json_array
);
1412 json_object_object_addf(json_nroute
,
1419 if (use_json
&& json_nroute
)
1420 json_object_object_add(json
, rd_str
, json_nroute
);
1424 json_object_int_add(json
, "numPrefix", output_count
);
1425 json_object_int_add(json
, "totalPrefix", total_count
);
1426 vty_json(vty
, json
);
1428 if (output_count
== 0)
1429 vty_out(vty
, "No prefixes displayed, %ld exist\n",
1433 "\nDisplayed %ld out of %ld total prefixes\n",
1434 output_count
, total_count
);
1439 DEFUN(show_ip_bgp_l2vpn_evpn
,
1440 show_ip_bgp_l2vpn_evpn_cmd
,
1441 "show [ip] bgp l2vpn evpn [json]",
1442 SHOW_STR IP_STR BGP_STR L2VPN_HELP_STR EVPN_HELP_STR JSON_STR
)
1444 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
, NULL
,
1445 SHOW_DISPLAY_STANDARD
,
1446 use_json(argc
, argv
));
1449 DEFUN(show_ip_bgp_l2vpn_evpn_rd
,
1450 show_ip_bgp_l2vpn_evpn_rd_cmd
,
1451 "show [ip] bgp l2vpn evpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> [json]",
1457 "Display information for a route distinguisher\n"
1458 "VPN Route Distinguisher\n"
1459 "All VPN Route Distinguishers\n"
1462 int idx_ext_community
= 0;
1464 struct prefix_rd prd
;
1467 if (argv_find(argv
, argc
, "all", &rd_all
))
1468 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
,
1469 NULL
, SHOW_DISPLAY_STANDARD
,
1470 use_json(argc
, argv
));
1472 argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community
);
1473 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
1475 vty_out(vty
, "%% Malformed Route Distinguisher\n");
1478 return bgp_show_ethernet_vpn(vty
, &prd
, bgp_show_type_normal
, NULL
,
1479 SHOW_DISPLAY_STANDARD
,
1480 use_json(argc
, argv
));
1483 DEFUN(show_ip_bgp_l2vpn_evpn_all_tags
,
1484 show_ip_bgp_l2vpn_evpn_all_tags_cmd
,
1485 "show [ip] bgp l2vpn evpn all tags",
1491 "Display information about all EVPN NLRIs\n"
1492 "Display BGP tags for prefixes\n")
1494 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
, NULL
,
1495 SHOW_DISPLAY_TAGS
, 0);
1498 DEFUN(show_ip_bgp_l2vpn_evpn_rd_tags
,
1499 show_ip_bgp_l2vpn_evpn_rd_tags_cmd
,
1500 "show [ip] bgp l2vpn evpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> tags",
1506 "Display information for a route distinguisher\n"
1507 "VPN Route Distinguisher\n"
1508 "All VPN Route Distinguishers\n"
1509 "Display BGP tags for prefixes\n")
1511 int idx_ext_community
= 0;
1513 struct prefix_rd prd
;
1516 if (argv_find(argv
, argc
, "all", &rd_all
))
1517 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
,
1518 NULL
, SHOW_DISPLAY_TAGS
, 0);
1520 argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community
);
1521 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
1523 vty_out(vty
, "%% Malformed Route Distinguisher\n");
1526 return bgp_show_ethernet_vpn(vty
, &prd
, bgp_show_type_normal
, NULL
,
1527 SHOW_DISPLAY_TAGS
, 0);
1530 DEFUN(show_ip_bgp_l2vpn_evpn_neighbor_routes
,
1531 show_ip_bgp_l2vpn_evpn_neighbor_routes_cmd
,
1532 "show [ip] bgp l2vpn evpn neighbors <A.B.C.D|X:X::X:X|WORD> routes [json]",
1538 "Detailed information on TCP and BGP neighbor connections\n"
1539 "IPv4 Neighbor to display information about\n"
1540 "IPv6 Neighbor to display information about\n"
1541 "Neighbor on BGP configured interface\n"
1542 "Display routes learned from neighbor\n" JSON_STR
)
1546 char *peerstr
= NULL
;
1547 bool uj
= use_json(argc
, argv
);
1548 afi_t afi
= AFI_L2VPN
;
1549 safi_t safi
= SAFI_EVPN
;
1550 struct bgp
*bgp
= NULL
;
1552 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
1555 vty_out(vty
, "No index\n");
1559 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
1560 argv_find(argv
, argc
, "neighbors", &idx
);
1561 peerstr
= argv
[++idx
]->arg
;
1563 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
1566 json_object
*json_no
= NULL
;
1567 json_no
= json_object_new_object();
1568 json_object_string_add(json_no
, "warning",
1569 "Malformed address");
1570 vty_out(vty
, "%s\n",
1571 json_object_to_json_string(json_no
));
1572 json_object_free(json_no
);
1574 vty_out(vty
, "Malformed address: %s\n",
1578 if (!peer
|| !peer
->afc
[AFI_L2VPN
][SAFI_EVPN
]) {
1580 json_object
*json_no
= NULL
;
1581 json_no
= json_object_new_object();
1582 json_object_string_add(
1584 "No such neighbor or address family");
1585 vty_out(vty
, "%s\n",
1586 json_object_to_json_string(json_no
));
1587 json_object_free(json_no
);
1589 vty_out(vty
, "%% No such neighbor or address family\n");
1593 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_neighbor
, peer
,
1594 SHOW_DISPLAY_STANDARD
, uj
);
1597 DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_routes
,
1598 show_ip_bgp_l2vpn_evpn_rd_neighbor_routes_cmd
,
1599 "show [ip] bgp l2vpn evpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> neighbors <A.B.C.D|X:X::X:X|WORD> routes [json]",
1605 "Display information for a route distinguisher\n"
1606 "VPN Route Distinguisher\n"
1607 "All VPN Route Distinguishers\n"
1608 "Detailed information on TCP and BGP neighbor connections\n"
1609 "IPv4 Neighbor to display information about\n"
1610 "IPv6 Neighbor to display information about\n"
1611 "Neighbor on BGP configured interface\n"
1612 "Display routes learned from neighbor\n" JSON_STR
)
1614 int idx_ext_community
= 0;
1618 char *peerstr
= NULL
;
1619 struct prefix_rd prd
= {};
1620 bool uj
= use_json(argc
, argv
);
1621 afi_t afi
= AFI_L2VPN
;
1622 safi_t safi
= SAFI_EVPN
;
1623 struct bgp
*bgp
= NULL
;
1626 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
1629 vty_out(vty
, "No index\n");
1633 if (argv_find(argv
, argc
, "all", &rd_all
)) {
1634 argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN",
1635 &idx_ext_community
);
1636 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
1639 json_object
*json_no
= NULL
;
1640 json_no
= json_object_new_object();
1641 json_object_string_add(
1643 "Malformed Route Distinguisher");
1644 vty_out(vty
, "%s\n",
1645 json_object_to_json_string(json_no
));
1646 json_object_free(json_no
);
1649 "%% Malformed Route Distinguisher\n");
1654 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
1655 argv_find(argv
, argc
, "neighbors", &idx
);
1656 peerstr
= argv
[++idx
]->arg
;
1658 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
1661 json_object
*json_no
= NULL
;
1662 json_no
= json_object_new_object();
1663 json_object_string_add(json_no
, "warning",
1664 "Malformed address");
1665 vty_out(vty
, "%s\n",
1666 json_object_to_json_string(json_no
));
1667 json_object_free(json_no
);
1669 vty_out(vty
, "Malformed address: %s\n",
1673 if (!peer
|| !peer
->afc
[AFI_L2VPN
][SAFI_EVPN
]) {
1675 json_object
*json_no
= NULL
;
1676 json_no
= json_object_new_object();
1677 json_object_string_add(
1679 "No such neighbor or address family");
1680 vty_out(vty
, "%s\n",
1681 json_object_to_json_string(json_no
));
1682 json_object_free(json_no
);
1684 vty_out(vty
, "%% No such neighbor or address family\n");
1690 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_neighbor
,
1691 peer
, SHOW_DISPLAY_STANDARD
, uj
);
1693 return bgp_show_ethernet_vpn(vty
, &prd
, bgp_show_type_neighbor
,
1694 peer
, SHOW_DISPLAY_STANDARD
, uj
);
1697 DEFUN(show_ip_bgp_l2vpn_evpn_neighbor_advertised_routes
,
1698 show_ip_bgp_l2vpn_evpn_neighbor_advertised_routes_cmd
,
1699 "show [ip] bgp l2vpn evpn neighbors <A.B.C.D|X:X::X:X|WORD> advertised-routes [json]",
1705 "Detailed information on TCP and BGP neighbor connections\n"
1706 "IPv4 Neighbor to display information about\n"
1707 "IPv6 Neighbor to display information about\n"
1708 "Neighbor on BGP configured interface\n"
1709 "Display the routes advertised to a BGP neighbor\n" JSON_STR
)
1713 bool uj
= use_json(argc
, argv
);
1714 struct bgp
*bgp
= NULL
;
1715 afi_t afi
= AFI_L2VPN
;
1716 safi_t safi
= SAFI_EVPN
;
1717 char *peerstr
= NULL
;
1722 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
1725 vty_out(vty
, "No index\n");
1729 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
1730 argv_find(argv
, argc
, "neighbors", &idx
);
1731 peerstr
= argv
[++idx
]->arg
;
1733 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
1736 json_object
*json_no
= NULL
;
1737 json_no
= json_object_new_object();
1738 json_object_string_add(json_no
, "warning",
1739 "Malformed address");
1740 vty_out(vty
, "%s\n",
1741 json_object_to_json_string(json_no
));
1742 json_object_free(json_no
);
1744 vty_out(vty
, "Malformed address: %s\n",
1748 if (!peer
|| !peer
->afc
[AFI_L2VPN
][SAFI_EVPN
]) {
1750 json_object
*json_no
= NULL
;
1751 json_no
= json_object_new_object();
1752 json_object_string_add(
1754 "No such neighbor or address family");
1755 vty_out(vty
, "%s\n",
1756 json_object_to_json_string(json_no
));
1757 json_object_free(json_no
);
1759 vty_out(vty
, "%% No such neighbor or address family\n");
1763 return show_adj_route_vpn(vty
, peer
, NULL
, AFI_L2VPN
, SAFI_EVPN
, uj
);
1766 DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes
,
1767 show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes_cmd
,
1768 "show [ip] bgp l2vpn evpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> neighbors <A.B.C.D|X:X::X:X|WORD> advertised-routes [json]",
1774 "Display information for a route distinguisher\n"
1775 "VPN Route Distinguisher\n"
1776 "All VPN Route Distinguishers\n"
1777 "Detailed information on TCP and BGP neighbor connections\n"
1778 "IPv4 Neighbor to display information about\n"
1779 "IPv6 Neighbor to display information about\n"
1780 "Neighbor on BGP configured interface\n"
1781 "Display the routes advertised to a BGP neighbor\n" JSON_STR
)
1783 int idx_ext_community
= 0;
1787 struct prefix_rd prd
;
1788 struct bgp
*bgp
= NULL
;
1789 bool uj
= use_json(argc
, argv
);
1790 char *peerstr
= NULL
;
1791 afi_t afi
= AFI_L2VPN
;
1792 safi_t safi
= SAFI_EVPN
;
1801 bgp_vty_find_and_parse_afi_safi_bgp(vty
, argv
, argc
, &idx
, &afi
, &safi
,
1804 vty_out(vty
, "No index\n");
1808 /* neighbors <A.B.C.D|X:X::X:X|WORD> */
1809 argv_find(argv
, argc
, "neighbors", &idx
);
1810 peerstr
= argv
[++idx
]->arg
;
1812 peer
= peer_lookup_in_view(vty
, bgp
, peerstr
, uj
);
1815 json_object
*json_no
= NULL
;
1816 json_no
= json_object_new_object();
1817 json_object_string_add(json_no
, "warning",
1818 "Malformed address");
1819 vty_out(vty
, "%s\n",
1820 json_object_to_json_string(json_no
));
1821 json_object_free(json_no
);
1823 vty_out(vty
, "Malformed address: %s\n",
1827 if (!peer
|| !peer
->afc
[AFI_L2VPN
][SAFI_EVPN
]) {
1829 json_object
*json_no
= NULL
;
1830 json_no
= json_object_new_object();
1831 json_object_string_add(
1833 "No such neighbor or address family");
1834 vty_out(vty
, "%s\n",
1835 json_object_to_json_string(json_no
));
1836 json_object_free(json_no
);
1838 vty_out(vty
, "%% No such neighbor or address family\n");
1842 if (argv_find(argv
, argc
, "all", &rd_all
))
1843 return show_adj_route_vpn(vty
, peer
, NULL
, AFI_L2VPN
, SAFI_EVPN
,
1846 argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN",
1847 &idx_ext_community
);
1848 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
1851 json_object
*json_no
= NULL
;
1852 json_no
= json_object_new_object();
1853 json_object_string_add(
1855 "Malformed Route Distinguisher");
1856 vty_out(vty
, "%s\n",
1857 json_object_to_json_string(json_no
));
1858 json_object_free(json_no
);
1861 "%% Malformed Route Distinguisher\n");
1866 return show_adj_route_vpn(vty
, peer
, &prd
, AFI_L2VPN
, SAFI_EVPN
, uj
);
1869 DEFUN(show_ip_bgp_l2vpn_evpn_all_overlay
,
1870 show_ip_bgp_l2vpn_evpn_all_overlay_cmd
,
1871 "show [ip] bgp l2vpn evpn all overlay [json]",
1877 "Display information about all EVPN NLRIs\n"
1878 "Display BGP Overlay Information for prefixes\n"
1881 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
, NULL
,
1882 SHOW_DISPLAY_OVERLAY
,
1883 use_json(argc
, argv
));
1886 DEFUN(show_ip_bgp_evpn_rd_overlay
,
1887 show_ip_bgp_evpn_rd_overlay_cmd
,
1888 "show [ip] bgp l2vpn evpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> overlay",
1894 "Display information for a route distinguisher\n"
1895 "VPN Route Distinguisher\n"
1896 "All VPN Route Distinguishers\n"
1897 "Display BGP Overlay Information for prefixes\n")
1899 int idx_ext_community
= 0;
1901 struct prefix_rd prd
;
1904 if (argv_find(argv
, argc
, "all", &rd_all
))
1905 return bgp_show_ethernet_vpn(vty
, NULL
, bgp_show_type_normal
,
1906 NULL
, SHOW_DISPLAY_OVERLAY
,
1907 use_json(argc
, argv
));
1909 argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community
);
1910 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
1912 vty_out(vty
, "%% Malformed Route Distinguisher\n");
1915 return bgp_show_ethernet_vpn(vty
, &prd
, bgp_show_type_normal
, NULL
,
1916 SHOW_DISPLAY_OVERLAY
,
1917 use_json(argc
, argv
));
1920 DEFUN(show_bgp_l2vpn_evpn_com
,
1921 show_bgp_l2vpn_evpn_com_cmd
,
1922 "show bgp l2vpn evpn \
1923 <community AA:NN|large-community AA:BB:CC> \
1924 [exact-match] [json]",
1929 "Display routes matching the community\n"
1930 "Community number where AA and NN are (0-65535)\n"
1931 "Display routes matching the large-community\n"
1932 "List of large-community numbers\n"
1933 "Exact match of the communities\n"
1938 const char *clist_number_or_name
;
1939 int show_type
= bgp_show_type_normal
;
1940 struct community
*com
;
1941 struct lcommunity
*lcom
;
1943 if (argv_find(argv
, argc
, "large-community", &idx
)) {
1944 clist_number_or_name
= argv
[++idx
]->arg
;
1945 show_type
= bgp_show_type_lcommunity
;
1947 if (++idx
< argc
&& strmatch(argv
[idx
]->text
, "exact-match"))
1948 show_type
= bgp_show_type_lcommunity_exact
;
1950 lcom
= lcommunity_str2com(clist_number_or_name
);
1952 vty_out(vty
, "%% Large-community malformed\n");
1956 ret
= bgp_show_ethernet_vpn(vty
, NULL
, show_type
, lcom
,
1957 SHOW_DISPLAY_STANDARD
,
1958 use_json(argc
, argv
));
1960 lcommunity_free(&lcom
);
1961 } else if (argv_find(argv
, argc
, "community", &idx
)) {
1962 clist_number_or_name
= argv
[++idx
]->arg
;
1963 show_type
= bgp_show_type_community
;
1965 if (++idx
< argc
&& strmatch(argv
[idx
]->text
, "exact-match"))
1966 show_type
= bgp_show_type_community_exact
;
1968 com
= community_str2com(clist_number_or_name
);
1971 vty_out(vty
, "%% Community malformed: %s\n",
1972 clist_number_or_name
);
1976 ret
= bgp_show_ethernet_vpn(vty
, NULL
, show_type
, com
,
1977 SHOW_DISPLAY_STANDARD
,
1978 use_json(argc
, argv
));
1979 community_free(&com
);
1985 /* For testing purpose, static route of EVPN RT-5. */
1986 DEFUN(evpnrt5_network
,
1987 evpnrt5_network_cmd
,
1988 "network <A.B.C.D/M|X:X::X:X/M> rd ASN:NN_OR_IP-ADDRESS:NN ethtag WORD label WORD esi WORD gwip <A.B.C.D|X:X::X:X> routermac WORD [route-map RMAP_NAME]",
1989 "Specify a network to announce via BGP\n"
1992 "Specify Route Distinguisher\n"
1993 "VPN Route Distinguisher\n"
1995 "Ethernet Tag Value\n"
1998 "Ethernet Segment Identifier\n"
1999 "ESI value ( 00:11:22:33:44:55:66:77:88:99 format) \n"
2001 "Gateway IP ( A.B.C.D )\n"
2002 "Gateway IPv6 ( X:X::X:X )\n"
2003 "Router Mac Ext Comm\n"
2004 "Router Mac address Value ( aa:bb:cc:dd:ee:ff format)\n"
2005 "Route-map to modify the attributes\n"
2006 "Name of the route map\n")
2008 int idx_ipv4_prefixlen
= 1;
2009 int idx_route_distinguisher
= 3;
2014 int idx_routermac
= 13;
2016 return bgp_static_set_safi(
2017 AFI_L2VPN
, SAFI_EVPN
, vty
, argv
[idx_ipv4_prefixlen
]->arg
,
2018 argv
[idx_route_distinguisher
]->arg
, argv
[idx_label
]->arg
, NULL
,
2019 BGP_EVPN_IP_PREFIX_ROUTE
, argv
[idx_esi
]->arg
,
2020 argv
[idx_gwip
]->arg
, argv
[idx_ethtag
]->arg
,
2021 argv
[idx_routermac
]->arg
);
2024 /* For testing purpose, static route of EVPN RT-5. */
2025 DEFUN(no_evpnrt5_network
,
2026 no_evpnrt5_network_cmd
,
2027 "no network <A.B.C.D/M|X:X::X:X/M> rd ASN:NN_OR_IP-ADDRESS:NN ethtag WORD label WORD esi WORD gwip <A.B.C.D|X:X::X:X>",
2029 "Specify a network to announce via BGP\n"
2032 "Specify Route Distinguisher\n"
2033 "VPN Route Distinguisher\n"
2035 "Ethernet Tag Value\n"
2038 "Ethernet Segment Identifier\n"
2039 "ESI value ( 00:11:22:33:44:55:66:77:88:99 format) \n"
2040 "Gateway IP\n" "Gateway IP ( A.B.C.D )\n" "Gateway IPv6 ( X:X::X:X )\n")
2042 int idx_ipv4_prefixlen
= 2;
2043 int idx_ext_community
= 4;
2048 return bgp_static_unset_safi(
2049 AFI_L2VPN
, SAFI_EVPN
, vty
, argv
[idx_ipv4_prefixlen
]->arg
,
2050 argv
[idx_ext_community
]->arg
, argv
[idx_label
]->arg
,
2051 BGP_EVPN_IP_PREFIX_ROUTE
, argv
[idx_esi
]->arg
,
2052 argv
[idx_gwip
]->arg
, argv
[idx_ethtag
]->arg
);
2055 static void evpn_import_rt_delete_auto(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2057 evpn_rt_delete_auto(bgp
, vpn
->vni
, vpn
->import_rtl
, false);
2060 static void evpn_export_rt_delete_auto(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2062 evpn_rt_delete_auto(bgp
, vpn
->vni
, vpn
->export_rtl
, false);
2066 * Configure the Import RTs for a VNI (vty handler). Caller expected to
2067 * check that this is a change.
2069 static void evpn_configure_import_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2070 struct ecommunity
*ecomadd
)
2072 /* If the VNI is "live", we need to uninstall routes using the current
2073 * import RT(s) first before we update the import RT, and subsequently
2076 if (is_vni_live(vpn
))
2077 bgp_evpn_uninstall_routes(bgp
, vpn
);
2079 /* Cleanup the RT to VNI mapping and get rid of existing import RT. */
2080 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
2082 /* If the auto route-target is in use we must remove it */
2083 evpn_import_rt_delete_auto(bgp
, vpn
);
2085 /* Add new RT and rebuild the RT to VNI mapping */
2086 listnode_add_sort(vpn
->import_rtl
, ecomadd
);
2088 SET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
2089 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
2091 /* Install routes that match new import RT */
2092 if (is_vni_live(vpn
))
2093 bgp_evpn_install_routes(bgp
, vpn
);
2097 * Unconfigure Import RT(s) for a VNI (vty handler).
2099 static void evpn_unconfigure_import_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2100 struct ecommunity
*ecomdel
)
2102 struct listnode
*node
, *nnode
, *node_to_del
;
2103 struct ecommunity
*ecom
;
2105 /* Along the lines of "configure" except we have to reset to the
2108 if (is_vni_live(vpn
))
2109 bgp_evpn_uninstall_routes(bgp
, vpn
);
2111 /* Cleanup the RT to VNI mapping and get rid of existing import RT. */
2112 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
2114 /* Delete all import RTs */
2115 if (ecomdel
== NULL
) {
2116 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
2117 ecommunity_free(&ecom
);
2118 list_delete_node(vpn
->import_rtl
, node
);
2122 /* Delete a specific import RT */
2126 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
2127 if (ecommunity_match(ecom
, ecomdel
)) {
2128 ecommunity_free(&ecom
);
2135 list_delete_node(vpn
->import_rtl
, node_to_del
);
2138 assert(vpn
->import_rtl
);
2139 /* Reset to auto RT - this also rebuilds the RT to VNI mapping */
2140 if (list_isempty(vpn
->import_rtl
)) {
2141 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
2142 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
2144 /* Rebuild the RT to VNI mapping */
2146 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
2148 /* Install routes that match new import RT */
2149 if (is_vni_live(vpn
))
2150 bgp_evpn_install_routes(bgp
, vpn
);
2154 * Configure the Export RT for a VNI (vty handler). Caller expected to
2155 * check that this is a change. Note that only a single export RT is
2156 * allowed for a VNI and any change to configuration is implemented as
2157 * a "replace" (similar to other configuration).
2159 static void evpn_configure_export_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2160 struct ecommunity
*ecomadd
)
2162 /* If the auto route-target is in use we must remove it */
2163 evpn_export_rt_delete_auto(bgp
, vpn
);
2165 listnode_add_sort(vpn
->export_rtl
, ecomadd
);
2166 SET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
2168 if (is_vni_live(vpn
))
2169 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
2173 * Unconfigure the Export RT for a VNI (vty handler)
2175 static void evpn_unconfigure_export_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2176 struct ecommunity
*ecomdel
)
2178 struct listnode
*node
, *nnode
, *node_to_del
;
2179 struct ecommunity
*ecom
;
2181 /* Delete all export RTs */
2182 if (ecomdel
== NULL
) {
2183 /* Reset to default and process all routes. */
2184 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
)) {
2185 ecommunity_free(&ecom
);
2186 list_delete_node(vpn
->export_rtl
, node
);
2190 /* Delete a specific export RT */
2194 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
)) {
2195 if (ecommunity_match(ecom
, ecomdel
)) {
2196 ecommunity_free(&ecom
);
2203 list_delete_node(vpn
->export_rtl
, node_to_del
);
2206 assert(vpn
->export_rtl
);
2207 if (list_isempty(vpn
->export_rtl
)) {
2208 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
2209 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
2212 if (is_vni_live(vpn
))
2213 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
2217 * Configure RD for VRF
2219 static void evpn_configure_vrf_rd(struct bgp
*bgp_vrf
, struct prefix_rd
*rd
)
2221 /* If we have already advertise type-5 routes with a diffrent RD, we
2222 * have to delete and withdraw them firs
2224 bgp_evpn_handle_vrf_rd_change(bgp_vrf
, 1);
2227 memcpy(&bgp_vrf
->vrf_prd
, rd
, sizeof(struct prefix_rd
));
2228 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_RD_CFGD
);
2230 /* We have a new RD for VRF.
2231 * Advertise all type-5 routes again with the new RD
2233 bgp_evpn_handle_vrf_rd_change(bgp_vrf
, 0);
2237 * Unconfigure RD for VRF
2239 static void evpn_unconfigure_vrf_rd(struct bgp
*bgp_vrf
)
2241 /* If we have already advertise type-5 routes with a diffrent RD, we
2242 * have to delete and withdraw them firs
2244 bgp_evpn_handle_vrf_rd_change(bgp_vrf
, 1);
2246 /* fall back to default RD */
2247 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
2248 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_RD_CFGD
);
2250 /* We have a new RD for VRF.
2251 * Advertise all type-5 routes again with the new RD
2253 bgp_evpn_handle_vrf_rd_change(bgp_vrf
, 0);
2257 * Configure RD for a VNI (vty handler)
2259 static void evpn_configure_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2260 struct prefix_rd
*rd
)
2262 /* If the VNI is "live", we need to delete and withdraw this VNI's
2263 * local routes with the prior RD first. Then, after updating RD,
2264 * need to re-advertise.
2266 if (is_vni_live(vpn
))
2267 bgp_evpn_handle_rd_change(bgp
, vpn
, 1);
2270 memcpy(&vpn
->prd
, rd
, sizeof(struct prefix_rd
));
2271 SET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
2273 if (is_vni_live(vpn
))
2274 bgp_evpn_handle_rd_change(bgp
, vpn
, 0);
2278 * Unconfigure RD for a VNI (vty handler)
2280 static void evpn_unconfigure_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2282 /* If the VNI is "live", we need to delete and withdraw this VNI's
2283 * local routes with the prior RD first. Then, after resetting RD
2284 * to automatic value, need to re-advertise.
2286 if (is_vni_live(vpn
))
2287 bgp_evpn_handle_rd_change(bgp
, vpn
, 1);
2289 /* reset RD to default */
2290 bgp_evpn_derive_auto_rd(bgp
, vpn
);
2292 if (is_vni_live(vpn
))
2293 bgp_evpn_handle_rd_change(bgp
, vpn
, 0);
2297 * Create VNI, if not already present (VTY handler). Mark as configured.
2299 static struct bgpevpn
*evpn_create_update_vni(struct bgp
*bgp
, vni_t vni
)
2301 struct bgpevpn
*vpn
;
2302 struct in_addr mcast_grp
= {INADDR_ANY
};
2304 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
2306 /* Check if this L2VNI is already configured as L3VNI */
2307 if (bgp_evpn_lookup_l3vni_l2vni_table(vni
)) {
2310 "%u: Failed to create L2VNI %u, it is configured as L3VNI",
2315 /* tenant vrf will be updated when we get local_vni_add from
2318 vpn
= bgp_evpn_new(bgp
, vni
, bgp
->router_id
, 0, mcast_grp
, 0);
2321 /* Mark as configured. */
2322 SET_FLAG(vpn
->flags
, VNI_FLAG_CFGD
);
2327 * Delete VNI. If VNI does not exist in the system (i.e., just
2328 * configuration), all that is needed is to free it. Otherwise,
2329 * any parameters configured for the VNI need to be reset (with
2330 * appropriate action) and the VNI marked as unconfigured; the
2331 * VNI will continue to exist, purely as a "learnt" entity.
2333 static void evpn_delete_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2335 if (!is_vni_live(vpn
)) {
2336 bgp_evpn_free(bgp
, vpn
);
2340 /* We need to take the unconfigure action for each parameter of this VNI
2341 * that is configured. Some optimization is possible, but not worth the
2342 * additional code for an operation that should be pretty rare.
2344 UNSET_FLAG(vpn
->flags
, VNI_FLAG_CFGD
);
2346 /* First, deal with the export side - RD and export RT changes. */
2347 if (is_rd_configured(vpn
))
2348 evpn_unconfigure_rd(bgp
, vpn
);
2349 if (is_export_rt_configured(vpn
))
2350 evpn_unconfigure_export_rt(bgp
, vpn
, NULL
);
2352 /* Next, deal with the import side. */
2353 if (is_import_rt_configured(vpn
))
2354 evpn_unconfigure_import_rt(bgp
, vpn
, NULL
);
2358 * Display import RT mapping to VRFs (vty handler)
2359 * bgp_evpn: evpn bgp instance
2361 static void evpn_show_vrf_import_rts(struct vty
*vty
, struct bgp
*bgp_evpn
,
2369 hash_iterate(bgp_evpn
->vrf_import_rt_hash
,
2370 (void (*)(struct hash_bucket
*,
2371 void *))show_vrf_import_rt_entry
,
2376 * Display import RT mapping to VNIs (vty handler)
2378 static void evpn_show_import_rts(struct vty
*vty
, struct bgp
*bgp
,
2387 bgp
->import_rt_hash
,
2388 (void (*)(struct hash_bucket
*, void *))show_import_rt_entry
,
2393 * Display EVPN routes for all VNIs - vty handler.
2395 static void evpn_show_routes_vni_all(struct vty
*vty
, struct bgp
*bgp
, int type
,
2396 bool mac_table
, struct in_addr vtep_ip
,
2397 json_object
*json
, int detail
)
2400 struct vni_walk_ctx wctx
;
2402 num_vnis
= hashcount(bgp
->vnihash
);
2405 memset(&wctx
, 0, sizeof(wctx
));
2409 wctx
.mac_table
= mac_table
;
2410 wctx
.vtep_ip
= vtep_ip
;
2412 wctx
.detail
= detail
;
2413 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_bucket
*,
2414 void *))show_vni_routes_hash
,
2419 * Display EVPN routes for all VNIs & all types - vty handler.
2421 static void evpn_show_routes_vni_all_type_all(struct vty
*vty
, struct bgp
*bgp
,
2422 struct in_addr vtep_ip
,
2423 json_object
*json
, int detail
)
2426 struct vni_walk_ctx wctx
;
2428 num_vnis
= hashcount(bgp
->vnihash
);
2432 memset(&wctx
, 0, sizeof(struct vni_walk_ctx
));
2435 wctx
.vtep_ip
= vtep_ip
;
2437 wctx
.detail
= detail
;
2438 hash_iterate(bgp
->vnihash
,
2439 (void (*)(struct hash_bucket
*,
2440 void *))show_vni_routes_all_hash
,
2445 * Display EVPN routes for a VNI -- for specific type-3 route (vty handler).
2447 static void evpn_show_route_vni_multicast(struct vty
*vty
, struct bgp
*bgp
,
2448 vni_t vni
, struct in_addr orig_ip
,
2451 struct bgpevpn
*vpn
;
2452 struct prefix_evpn p
;
2453 struct bgp_dest
*dest
;
2454 struct bgp_path_info
*pi
;
2455 uint32_t path_cnt
= 0;
2458 json_object
*json_paths
= NULL
;
2464 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
2466 vty_out(vty
, "VNI not found\n");
2470 /* See if route exists. */
2471 build_evpn_type3_prefix(&p
, orig_ip
);
2472 dest
= bgp_evpn_vni_node_lookup(vpn
, &p
, NULL
);
2473 if (!dest
|| !bgp_dest_has_bgp_path_info_data(dest
)) {
2475 vty_out(vty
, "%% Network not in table\n");
2478 bgp_dest_unlock_node(dest
);
2484 json_paths
= json_object_new_array();
2486 /* Prefix and num paths displayed once per prefix. */
2487 route_vty_out_detail_header(vty
, bgp
, dest
, bgp_dest_get_prefix(dest
),
2488 NULL
, afi
, safi
, json
);
2490 /* Display each path for this prefix. */
2491 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
; pi
= pi
->next
) {
2492 json_object
*json_path
= NULL
;
2495 json_path
= json_object_new_array();
2497 route_vty_out_detail(vty
, bgp
, dest
, bgp_dest_get_prefix(dest
),
2498 pi
, afi
, safi
, RPKI_NOT_BEING_USED
,
2502 json_object_array_add(json_paths
, json_path
);
2509 json_object_object_add(json
, "paths", json_paths
);
2511 json_object_int_add(json
, "numPaths", path_cnt
);
2513 vty_out(vty
, "\nDisplayed %u paths for requested prefix\n",
2517 bgp_dest_unlock_node(dest
);
2521 * Display EVPN routes for a VNI -- for specific MAC and/or IP (vty handler).
2522 * By definition, only matching type-2 route will be displayed.
2524 static void evpn_show_route_vni_macip(struct vty
*vty
, struct bgp
*bgp
,
2525 vni_t vni
, struct ethaddr
*mac
,
2526 struct ipaddr
*ip
, json_object
*json
)
2528 struct bgpevpn
*vpn
;
2529 struct prefix_evpn p
;
2530 struct prefix_evpn tmp_p
;
2531 struct bgp_dest
*dest
;
2532 struct bgp_path_info
*pi
;
2533 uint32_t path_cnt
= 0;
2536 json_object
*json_paths
= NULL
;
2537 struct ethaddr empty_mac
= {};
2538 struct ipaddr empty_ip
= {};
2539 const struct prefix_evpn
*evp
;
2545 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
2548 vty_out(vty
, "VNI not found\n");
2552 build_evpn_type2_prefix(&p
, mac
? mac
: &empty_mac
,
2553 ip
? ip
: &empty_ip
);
2555 /* See if route exists. Look for both non-sticky and sticky. */
2556 dest
= bgp_evpn_vni_node_lookup(vpn
, &p
, NULL
);
2557 if (!dest
|| !bgp_dest_has_bgp_path_info_data(dest
)) {
2559 vty_out(vty
, "%% Network not in table\n");
2562 bgp_dest_unlock_node(dest
);
2568 * MAC is per-path, we have to walk the path_info's and look for it
2572 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
; pi
= pi
->next
) {
2573 if (memcmp(mac
, evpn_type2_path_info_get_mac(pi
),
2580 vty_out(vty
, "%% Network not in table\n");
2586 json_paths
= json_object_new_array();
2588 /* Prefix and num paths displayed once per prefix. */
2589 route_vty_out_detail_header(vty
, bgp
, dest
, (struct prefix
*)&p
, NULL
,
2592 evp
= (const struct prefix_evpn
*)bgp_dest_get_prefix(dest
);
2594 /* Display each path for this prefix. */
2595 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
; pi
= pi
->next
) {
2596 json_object
*json_path
= NULL
;
2598 /* skip non-matching MACs */
2600 memcmp(mac
, evpn_type2_path_info_get_mac(pi
),
2605 json_path
= json_object_new_array();
2608 * VNI table MAC-IP prefixes don't have MAC so
2609 * make sure it's set from path info
2612 if (is_evpn_prefix_ipaddr_none(evp
)) {
2613 /* VNI MAC -> Global */
2614 evpn_type2_prefix_global_copy(
2615 (struct prefix_evpn
*)&tmp_p
, evp
,
2617 evpn_type2_path_info_get_ip(pi
));
2619 /* VNI IP -> Global */
2620 evpn_type2_prefix_global_copy(
2621 (struct prefix_evpn
*)&tmp_p
, evp
,
2622 evpn_type2_path_info_get_mac(pi
),
2626 route_vty_out_detail(vty
, bgp
, dest
, (struct prefix
*)&tmp_p
,
2627 pi
, afi
, safi
, RPKI_NOT_BEING_USED
,
2631 json_object_array_add(json_paths
, json_path
);
2638 json_object_object_add(json
, "paths", json_paths
);
2640 json_object_int_add(json
, "numPaths", path_cnt
);
2642 vty_out(vty
, "\nDisplayed %u paths for requested prefix\n",
2646 bgp_dest_unlock_node(dest
);
2649 /* Disaplay EVPN routes for a ESI - VTY handler */
2650 static void evpn_show_routes_esi(struct vty
*vty
, struct bgp
*bgp
,
2651 esi_t
*esi
, json_object
*json
)
2653 struct bgp_evpn_es
*es
= NULL
;
2656 es
= bgp_evpn_es_find(esi
);
2659 vty_out(vty
, "ESI not found\n");
2663 show_esi_routes(bgp
, es
, vty
, json
);
2667 * Display EVPN routes for a VNI - vty handler.
2668 * If 'type' is non-zero, only routes matching that type are shown.
2669 * If the vtep_ip is non zero, only routes behind that vtep are shown
2671 static void evpn_show_routes_vni(struct vty
*vty
, struct bgp
*bgp
, vni_t vni
,
2672 int type
, bool mac_table
,
2673 struct in_addr vtep_ip
, json_object
*json
)
2675 struct bgpevpn
*vpn
;
2678 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
2681 vty_out(vty
, "VNI not found\n");
2685 /* Walk this VNI's route table and display appropriate routes. */
2686 show_vni_routes(bgp
, vpn
, vty
, type
, mac_table
, vtep_ip
, json
, 0);
2690 * Display BGP EVPN routing table -- for specific RD and MAC and/or
2691 * IP (vty handler). By definition, only matching type-2 route will be
2694 static void evpn_show_route_rd_macip(struct vty
*vty
, struct bgp
*bgp
,
2695 struct prefix_rd
*prd
, struct ethaddr
*mac
,
2696 struct ipaddr
*ip
, json_object
*json
)
2698 struct prefix_evpn p
;
2699 struct bgp_dest
*dest
;
2700 struct bgp_path_info
*pi
;
2703 uint32_t path_cnt
= 0;
2704 json_object
*json_paths
= NULL
;
2709 /* See if route exists. Look for both non-sticky and sticky. */
2710 build_evpn_type2_prefix(&p
, mac
, ip
);
2711 dest
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
2712 (struct prefix
*)&p
, prd
);
2713 if (!dest
|| !bgp_dest_has_bgp_path_info_data(dest
)) {
2715 vty_out(vty
, "%% Network not in table\n");
2718 bgp_dest_unlock_node(dest
);
2723 /* Prefix and num paths displayed once per prefix. */
2724 route_vty_out_detail_header(vty
, bgp
, dest
, bgp_dest_get_prefix(dest
),
2725 prd
, afi
, safi
, json
);
2728 json_paths
= json_object_new_array();
2730 /* Display each path for this prefix. */
2731 for (pi
= bgp_dest_get_bgp_path_info(dest
); pi
; pi
= pi
->next
) {
2732 json_object
*json_path
= NULL
;
2735 json_path
= json_object_new_array();
2737 route_vty_out_detail(vty
, bgp
, dest
, bgp_dest_get_prefix(dest
),
2738 pi
, afi
, safi
, RPKI_NOT_BEING_USED
,
2742 json_object_array_add(json_paths
, json_path
);
2747 if (json
&& path_cnt
) {
2749 json_object_object_addf(json
, json_paths
, "%pFX", &p
);
2750 json_object_int_add(json
, "numPaths", path_cnt
);
2752 vty_out(vty
, "\nDisplayed %u paths for requested prefix\n",
2756 bgp_dest_unlock_node(dest
);
2760 * Display BGP EVPN routing table -- for specific RD (vty handler)
2761 * If 'type' is non-zero, only routes matching that type are shown.
2763 static void evpn_show_route_rd(struct vty
*vty
, struct bgp
*bgp
,
2764 struct prefix_rd
*prd
, int type
,
2767 struct bgp_dest
*rd_dest
;
2768 struct bgp_table
*table
;
2769 struct bgp_dest
*dest
;
2770 struct bgp_path_info
*pi
;
2774 uint32_t prefix_cnt
, path_cnt
;
2775 json_object
*json_rd
= NULL
;
2776 int add_rd_to_json
= 0;
2780 prefix_cnt
= path_cnt
= 0;
2782 rd_dest
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)prd
);
2786 table
= bgp_dest_get_bgp_table_info(rd_dest
);
2787 if (table
== NULL
) {
2788 bgp_dest_unlock_node(rd_dest
);
2793 json_rd
= json_object_new_object();
2794 json_object_string_addf(json_rd
, "rd", "%pRD", prd
);
2797 bgp_dest_unlock_node(rd_dest
);
2799 /* Display all prefixes with this RD. */
2800 for (dest
= bgp_table_top(table
); dest
; dest
= bgp_route_next(dest
)) {
2801 const struct prefix_evpn
*evp
=
2802 (const struct prefix_evpn
*)bgp_dest_get_prefix(dest
);
2803 json_object
*json_prefix
= NULL
;
2804 json_object
*json_paths
= NULL
;
2805 int add_prefix_to_json
= 0;
2807 if (type
&& evp
->prefix
.route_type
!= type
)
2811 json_prefix
= json_object_new_object();
2813 pi
= bgp_dest_get_bgp_path_info(dest
);
2815 /* RD header and legend - once overall. */
2816 if (rd_header
&& !json
) {
2818 "EVPN type-1 prefix: [1]:[EthTag]:[ESI]:[IPlen]:[VTEP-IP]:[Frag-id]\n");
2820 "EVPN type-2 prefix: [2]:[EthTag]:[MAClen]:[MAC]\n");
2822 "EVPN type-3 prefix: [3]:[EthTag]:[IPlen]:[OrigIP]\n");
2824 "EVPN type-4 prefix: [4]:[ESI]:[IPlen]:[OrigIP]\n");
2826 "EVPN type-5 prefix: [5]:[EthTag]:[IPlen]:[IP]\n\n");
2830 /* Prefix and num paths displayed once per prefix. */
2831 route_vty_out_detail_header(
2832 vty
, bgp
, dest
, bgp_dest_get_prefix(dest
), prd
,
2833 afi
, safi
, json_prefix
);
2839 json_paths
= json_object_new_array();
2841 /* Display each path for this prefix. */
2842 for (; pi
; pi
= pi
->next
) {
2843 json_object
*json_path
= NULL
;
2846 json_path
= json_object_new_array();
2848 route_vty_out_detail(
2849 vty
, bgp
, dest
, bgp_dest_get_prefix(dest
), pi
,
2850 afi
, safi
, RPKI_NOT_BEING_USED
, json_path
);
2853 json_object_array_add(json_paths
, json_path
);
2856 add_prefix_to_json
= 1;
2861 if (add_prefix_to_json
) {
2862 json_object_object_add(json_prefix
, "paths",
2864 json_object_object_addf(json_rd
, json_prefix
,
2867 json_object_free(json_paths
);
2868 json_object_free(json_prefix
);
2877 json_object_object_addf(json
, json_rd
, "%pRD", prd
);
2879 json_object_free(json_rd
);
2883 json_object_int_add(json
, "numPrefix", prefix_cnt
);
2884 json_object_int_add(json
, "numPaths", path_cnt
);
2886 if (prefix_cnt
== 0)
2887 vty_out(vty
, "No prefixes exist with this RD%s\n",
2888 type
? " (of requested type)" : "");
2891 "\nDisplayed %u prefixes (%u paths) with this RD%s\n",
2892 prefix_cnt
, path_cnt
,
2893 type
? " (of requested type)" : "");
2898 * Display BGP EVPN routing table -- all RDs and MAC and/or IP
2899 * (vty handler). Only matching type-2 routes will be displayed.
2901 static void evpn_show_route_rd_all_macip(struct vty
*vty
, struct bgp
*bgp
,
2902 struct ethaddr
*mac
, struct ipaddr
*ip
,
2905 struct bgp_dest
*rd_dest
;
2906 struct bgp_table
*table
;
2907 struct bgp_dest
*dest
;
2908 struct bgp_path_info
*pi
;
2909 afi_t afi
= AFI_L2VPN
;
2910 safi_t safi
= SAFI_EVPN
;
2911 uint32_t prefix_cnt
, path_cnt
;
2912 prefix_cnt
= path_cnt
= 0;
2914 /* EVPN routing table is a 2-level table with the first level being
2915 * the RD. We need to look in every RD we know about.
2917 for (rd_dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_dest
;
2918 rd_dest
= bgp_route_next(rd_dest
)) {
2919 json_object
*json_paths
= NULL
; /* paths array for prefix */
2920 json_object
*json_prefix
= NULL
; /* prefix within an RD */
2921 json_object
*json_rd
= NULL
; /* holds all prefixes for RD */
2922 char rd_str
[RD_ADDRSTRLEN
];
2923 int add_rd_to_json
= 0;
2924 struct prefix_evpn ep
;
2925 const struct prefix
*rd_destp
= bgp_dest_get_prefix(rd_dest
);
2927 table
= bgp_dest_get_bgp_table_info(rd_dest
);
2931 prefix_rd2str((struct prefix_rd
*)rd_destp
, rd_str
,
2934 /* Construct an RT-2 from the user-supplied mac(ip),
2935 * then search the l2vpn evpn table for it.
2937 build_evpn_type2_prefix(&ep
, mac
, ip
);
2938 dest
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
2939 (struct prefix
*)&ep
,
2940 (struct prefix_rd
*)rd_destp
);
2945 json_rd
= json_object_new_object();
2947 const struct prefix
*p
= bgp_dest_get_prefix(dest
);
2949 pi
= bgp_dest_get_bgp_path_info(dest
);
2951 /* RD header - per RD. */
2952 bgp_evpn_show_route_rd_header(vty
, rd_dest
, json_rd
,
2953 rd_str
, RD_ADDRSTRLEN
);
2958 json_prefix
= json_object_new_object();
2959 json_paths
= json_object_new_array();
2960 json_object_string_addf(json_prefix
, "prefix", "%pFX",
2962 json_object_int_add(json_prefix
, "prefixLen",
2965 /* Prefix and num paths displayed once per prefix. */
2966 route_vty_out_detail_header(
2967 vty
, bgp
, dest
, p
, (struct prefix_rd
*)rd_destp
,
2968 AFI_L2VPN
, SAFI_EVPN
, json_prefix
);
2970 /* For EVPN, the prefix is displayed for each path (to
2971 * fit in with code that already exists).
2973 for (; pi
; pi
= pi
->next
) {
2974 json_object
*json_path
= NULL
;
2980 json_path
= json_object_new_array();
2982 route_vty_out_detail(vty
, bgp
, dest
, p
, pi
, AFI_L2VPN
,
2983 SAFI_EVPN
, RPKI_NOT_BEING_USED
,
2987 json_object_array_add(json_paths
, json_path
);
2993 json_object_object_add(json_prefix
, "paths",
2995 json_object_object_addf(json_rd
, json_prefix
, "%pFX",
2998 json_object_object_add(json
, rd_str
, json_rd
);
3000 json_object_free(json_rd
);
3005 bgp_dest_unlock_node(dest
);
3009 json_object_int_add(json
, "numPrefix", prefix_cnt
);
3010 json_object_int_add(json
, "numPaths", path_cnt
);
3012 if (prefix_cnt
== 0) {
3013 vty_out(vty
, "No Matching EVPN prefixes exist\n");
3015 vty_out(vty
, "Displayed %u prefixes (%u paths)\n",
3016 prefix_cnt
, path_cnt
);
3022 * Display BGP EVPN routing table - all routes (vty handler).
3023 * If 'type' is non-zero, only routes matching that type are shown.
3025 static void evpn_show_all_routes(struct vty
*vty
, struct bgp
*bgp
, int type
,
3026 json_object
*json
, int detail
)
3028 struct bgp_dest
*rd_dest
;
3029 struct bgp_table
*table
;
3030 struct bgp_dest
*dest
;
3031 struct bgp_path_info
*pi
;
3032 int header
= detail
? 0 : 1;
3036 uint32_t prefix_cnt
, path_cnt
;
3040 prefix_cnt
= path_cnt
= 0;
3042 /* EVPN routing table is a 2-level table with the first level being
3045 for (rd_dest
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_dest
;
3046 rd_dest
= bgp_route_next(rd_dest
)) {
3047 char rd_str
[RD_ADDRSTRLEN
];
3048 json_object
*json_rd
= NULL
; /* contains routes for an RD */
3049 int add_rd_to_json
= 0;
3051 const struct prefix
*rd_destp
= bgp_dest_get_prefix(rd_dest
);
3053 table
= bgp_dest_get_bgp_table_info(rd_dest
);
3057 tbl_ver
= table
->version
;
3058 prefix_rd2str((struct prefix_rd
*)rd_destp
, rd_str
,
3062 json_rd
= json_object_new_object();
3066 /* Display all prefixes for an RD */
3067 for (dest
= bgp_table_top(table
); dest
;
3068 dest
= bgp_route_next(dest
)) {
3069 json_object
*json_prefix
=
3070 NULL
; /* contains prefix under a RD */
3071 json_object
*json_paths
=
3072 NULL
; /* array of paths under a prefix*/
3073 const struct prefix_evpn
*evp
=
3074 (const struct prefix_evpn
*)bgp_dest_get_prefix(
3076 int add_prefix_to_json
= 0;
3077 const struct prefix
*p
= bgp_dest_get_prefix(dest
);
3079 if (type
&& evp
->prefix
.route_type
!= type
)
3082 pi
= bgp_dest_get_bgp_path_info(dest
);
3084 /* Overall header/legend displayed once. */
3086 bgp_evpn_show_route_header(vty
, bgp
,
3091 "%19s Extended Community\n"
3096 /* RD header - per RD. */
3098 bgp_evpn_show_route_rd_header(
3099 vty
, rd_dest
, json_rd
, rd_str
,
3108 json_prefix
= json_object_new_object();
3109 json_paths
= json_object_new_array();
3110 json_object_string_addf(json_prefix
, "prefix",
3112 json_object_int_add(json_prefix
, "prefixLen",
3116 /* Prefix and num paths displayed once per prefix. */
3118 route_vty_out_detail_header(
3120 bgp_dest_get_prefix(dest
),
3121 (struct prefix_rd
*)rd_destp
, AFI_L2VPN
,
3122 SAFI_EVPN
, json_prefix
);
3124 /* For EVPN, the prefix is displayed for each path (to
3126 * with code that already exists).
3128 for (; pi
; pi
= pi
->next
) {
3129 json_object
*json_path
= NULL
;
3132 add_prefix_to_json
= 1;
3136 json_path
= json_object_new_array();
3139 route_vty_out_detail(
3141 bgp_dest_get_prefix(dest
), pi
,
3142 AFI_L2VPN
, SAFI_EVPN
,
3143 RPKI_NOT_BEING_USED
, json_path
);
3145 route_vty_out(vty
, p
, pi
, 0, SAFI_EVPN
,
3149 json_object_array_add(json_paths
,
3154 if (add_prefix_to_json
) {
3155 json_object_object_add(json_prefix
,
3158 json_object_object_addf(json_rd
,
3162 json_object_free(json_prefix
);
3163 json_object_free(json_paths
);
3172 json_object_object_add(json
, rd_str
, json_rd
);
3174 json_object_free(json_rd
);
3181 json_object_int_add(json
, "numPrefix", prefix_cnt
);
3182 json_object_int_add(json
, "numPaths", path_cnt
);
3184 if (prefix_cnt
== 0) {
3185 vty_out(vty
, "No EVPN prefixes %sexist\n",
3186 type
? "(of requested type) " : "");
3188 vty_out(vty
, "\nDisplayed %u prefixes (%u paths)%s\n",
3189 prefix_cnt
, path_cnt
,
3190 type
? " (of requested type)" : "");
3195 int bgp_evpn_show_all_routes(struct vty
*vty
, struct bgp
*bgp
, int type
,
3196 bool use_json
, int detail
)
3198 json_object
*json
= NULL
;
3201 json
= json_object_new_object();
3203 evpn_show_all_routes(vty
, bgp
, type
, json
, detail
);
3206 vty_json(vty
, json
);
3211 * Display specified VNI (vty handler)
3213 static void evpn_show_vni(struct vty
*vty
, struct bgp
*bgp
, vni_t vni
,
3217 struct bgpevpn
*vpn
;
3219 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
3222 display_vni(vty
, vpn
, json
);
3224 struct bgp
*bgp_temp
;
3225 struct listnode
*node
= NULL
;
3227 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp_temp
)) {
3228 if (bgp_temp
->l3vni
== vni
) {
3230 display_l3vni(vty
, bgp_temp
, json
);
3237 vty_out(vty
, "{}\n");
3239 vty_out(vty
, "VNI not found\n");
3246 * Display a VNI (upon user query).
3248 static void evpn_show_all_vnis(struct vty
*vty
, struct bgp
*bgp
,
3252 struct bgp
*bgp_temp
= NULL
;
3253 struct listnode
*node
;
3257 vty_out(vty
, "Flags: * - Kernel\n");
3258 vty_out(vty
, " %-10s %-4s %-21s %-25s %-25s %-37s\n", "VNI",
3259 "Type", "RD", "Import RT", "Export RT", "Tenant VRF");
3262 /* print all L2 VNIS */
3265 hash_iterate(bgp
->vnihash
,
3266 (void (*)(struct hash_bucket
*, void *))show_vni_entry
,
3269 /* print all L3 VNIs */
3270 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp_temp
))
3271 show_l3vni_entry(vty
, bgp_temp
, json
);
3275 * evpn - enable advertisement of svi MAC-IP
3277 static void evpn_set_advertise_svi_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
3281 if (set
&& bgp
->evpn_info
->advertise_svi_macip
)
3283 else if (!set
&& !bgp
->evpn_info
->advertise_svi_macip
)
3286 bgp
->evpn_info
->advertise_svi_macip
= set
;
3287 bgp_zebra_advertise_svi_macip(bgp
,
3288 bgp
->evpn_info
->advertise_svi_macip
, 0);
3290 if (set
&& vpn
->advertise_svi_macip
)
3292 else if (!set
&& !vpn
->advertise_svi_macip
)
3295 vpn
->advertise_svi_macip
= set
;
3296 bgp_zebra_advertise_svi_macip(bgp
, vpn
->advertise_svi_macip
,
3302 * evpn - enable advertisement of default g/w
3304 static void evpn_set_advertise_default_gw(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3307 if (bgp
->advertise_gw_macip
)
3310 bgp
->advertise_gw_macip
= 1;
3311 bgp_zebra_advertise_gw_macip(bgp
, bgp
->advertise_gw_macip
, 0);
3313 if (vpn
->advertise_gw_macip
)
3316 vpn
->advertise_gw_macip
= 1;
3317 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
,
3324 * evpn - disable advertisement of default g/w
3326 static void evpn_unset_advertise_default_gw(struct bgp
*bgp
,
3327 struct bgpevpn
*vpn
)
3330 if (!bgp
->advertise_gw_macip
)
3333 bgp
->advertise_gw_macip
= 0;
3334 bgp_zebra_advertise_gw_macip(bgp
, bgp
->advertise_gw_macip
, 0);
3336 if (!vpn
->advertise_gw_macip
)
3339 vpn
->advertise_gw_macip
= 0;
3340 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
,
3347 * evpn - enable advertisement of default g/w
3349 static void evpn_process_default_originate_cmd(struct bgp
*bgp_vrf
,
3350 afi_t afi
, bool add
)
3352 safi_t safi
= SAFI_UNICAST
; /* ipv4/ipv6 unicast */
3355 /* bail if we are already advertising default route */
3356 if (evpn_default_originate_set(bgp_vrf
, afi
, safi
))
3360 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
3361 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4
);
3362 else if (afi
== AFI_IP6
)
3363 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
3364 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6
);
3366 /* bail out if we havent advertised the default route */
3367 if (!evpn_default_originate_set(bgp_vrf
, afi
, safi
))
3370 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
3371 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4
);
3372 else if (afi
== AFI_IP6
)
3373 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
3374 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6
);
3377 bgp_evpn_install_uninstall_default_route(bgp_vrf
, afi
, safi
, add
);
3381 * evpn - enable advertisement of default g/w
3383 static void evpn_set_advertise_subnet(struct bgp
*bgp
,
3384 struct bgpevpn
*vpn
)
3386 if (vpn
->advertise_subnet
)
3389 vpn
->advertise_subnet
= 1;
3390 bgp_zebra_advertise_subnet(bgp
, vpn
->advertise_subnet
, vpn
->vni
);
3394 * evpn - disable advertisement of default g/w
3396 static void evpn_unset_advertise_subnet(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3398 if (!vpn
->advertise_subnet
)
3401 vpn
->advertise_subnet
= 0;
3402 bgp_zebra_advertise_subnet(bgp
, vpn
->advertise_subnet
, vpn
->vni
);
3406 * EVPN (VNI advertisement) enabled. Register with zebra.
3408 static void evpn_set_advertise_all_vni(struct bgp
*bgp
)
3410 bgp
->advertise_all_vni
= 1;
3412 bgp_zebra_advertise_all_vni(bgp
, bgp
->advertise_all_vni
);
3416 * EVPN (VNI advertisement) disabled. De-register with zebra. Cleanup VNI
3417 * cache, EVPN routes (delete and withdraw from peers).
3419 static void evpn_unset_advertise_all_vni(struct bgp
*bgp
)
3421 bgp
->advertise_all_vni
= 0;
3422 bgp_set_evpn(bgp_get_default());
3423 bgp_zebra_advertise_all_vni(bgp
, bgp
->advertise_all_vni
);
3424 bgp_evpn_cleanup_on_disable(bgp
);
3427 /* Set resolve overlay index flag */
3428 static void bgp_evpn_set_unset_resolve_overlay_index(struct bgp
*bgp
, bool set
)
3430 if (set
== bgp
->resolve_overlay_index
)
3434 bgp
->resolve_overlay_index
= true;
3435 hash_iterate(bgp
->vnihash
,
3436 (void (*)(struct hash_bucket
*, void *))
3437 bgp_evpn_handle_resolve_overlay_index_set
,
3442 (void (*)(struct hash_bucket
*, void *))
3443 bgp_evpn_handle_resolve_overlay_index_unset
,
3445 bgp
->resolve_overlay_index
= false;
3450 * EVPN - use RFC8365 to auto-derive RT
3452 static void evpn_set_advertise_autort_rfc8365(struct bgp
*bgp
)
3454 bgp
->advertise_autort_rfc8365
= 1;
3455 bgp_evpn_handle_autort_change(bgp
);
3459 * EVPN - don't use RFC8365 to auto-derive RT
3461 static void evpn_unset_advertise_autort_rfc8365(struct bgp
*bgp
)
3463 bgp
->advertise_autort_rfc8365
= 0;
3464 bgp_evpn_handle_autort_change(bgp
);
3467 static void write_vni_config(struct vty
*vty
, struct bgpevpn
*vpn
)
3470 struct listnode
*node
, *nnode
;
3471 struct ecommunity
*ecom
;
3473 if (is_vni_configured(vpn
)) {
3474 vty_out(vty
, " vni %u\n", vpn
->vni
);
3475 if (is_rd_configured(vpn
))
3476 vty_out(vty
, " rd %pRD\n", &vpn
->prd
);
3478 if (is_import_rt_configured(vpn
)) {
3479 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
,
3481 ecom_str
= ecommunity_ecom2str(
3482 ecom
, ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
3483 vty_out(vty
, " route-target import %s\n",
3485 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
3489 if (is_export_rt_configured(vpn
)) {
3490 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
,
3492 ecom_str
= ecommunity_ecom2str(
3493 ecom
, ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
3494 vty_out(vty
, " route-target export %s\n",
3496 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
3500 if (vpn
->advertise_gw_macip
)
3501 vty_out(vty
, " advertise-default-gw\n");
3503 if (vpn
->advertise_svi_macip
)
3504 vty_out(vty
, " advertise-svi-ip\n");
3506 if (vpn
->advertise_subnet
)
3507 vty_out(vty
, " advertise-subnet\n");
3509 vty_out(vty
, " exit-vni\n");
3513 #include "bgpd/bgp_evpn_vty_clippy.c"
3515 DEFPY(bgp_evpn_flood_control
,
3516 bgp_evpn_flood_control_cmd
,
3517 "[no$no] flooding <disable$disable|head-end-replication$her>",
3519 "Specify handling for BUM packets\n"
3520 "Do not flood any BUM packets\n"
3521 "Flood BUM packets using head-end replication\n")
3523 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3524 enum vxlan_flood_control flood_ctrl
;
3530 flood_ctrl
= VXLAN_FLOOD_DISABLED
;
3532 flood_ctrl
= VXLAN_FLOOD_HEAD_END_REPL
;
3536 if (bgp
->vxlan_flood_ctrl
== flood_ctrl
)
3539 bgp
->vxlan_flood_ctrl
= flood_ctrl
;
3540 bgp_evpn_flood_control_change(bgp
);
3545 DEFUN (bgp_evpn_advertise_default_gw_vni
,
3546 bgp_evpn_advertise_default_gw_vni_cmd
,
3547 "advertise-default-gw",
3548 "Advertise default g/w mac-ip routes in EVPN for a VNI\n")
3550 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3551 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
3556 evpn_set_advertise_default_gw(bgp
, vpn
);
3561 DEFUN (no_bgp_evpn_advertise_default_vni_gw
,
3562 no_bgp_evpn_advertise_default_gw_vni_cmd
,
3563 "no advertise-default-gw",
3565 "Withdraw default g/w mac-ip routes from EVPN for a VNI\n")
3567 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3568 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
3573 evpn_unset_advertise_default_gw(bgp
, vpn
);
3579 DEFUN (bgp_evpn_advertise_default_gw
,
3580 bgp_evpn_advertise_default_gw_cmd
,
3581 "advertise-default-gw",
3582 "Advertise All default g/w mac-ip routes in EVPN\n")
3584 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3589 if (!EVPN_ENABLED(bgp
)) {
3591 "This command is only supported under the EVPN VRF\n");
3595 evpn_set_advertise_default_gw(bgp
, NULL
);
3600 DEFUN (no_bgp_evpn_advertise_default_gw
,
3601 no_bgp_evpn_advertise_default_gw_cmd
,
3602 "no advertise-default-gw",
3604 "Withdraw All default g/w mac-ip routes from EVPN\n")
3606 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3611 evpn_unset_advertise_default_gw(bgp
, NULL
);
3616 DEFUN (bgp_evpn_advertise_all_vni
,
3617 bgp_evpn_advertise_all_vni_cmd
,
3618 "advertise-all-vni",
3619 "Advertise All local VNIs\n")
3621 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3622 struct bgp
*bgp_evpn
= NULL
;
3627 bgp_evpn
= bgp_get_evpn();
3628 if (bgp_evpn
&& bgp_evpn
!= bgp
) {
3629 vty_out(vty
, "%% Please unconfigure EVPN in %s\n",
3630 bgp_evpn
->name_pretty
);
3631 return CMD_WARNING_CONFIG_FAILED
;
3634 evpn_set_advertise_all_vni(bgp
);
3638 DEFUN (no_bgp_evpn_advertise_all_vni
,
3639 no_bgp_evpn_advertise_all_vni_cmd
,
3640 "no advertise-all-vni",
3642 "Advertise All local VNIs\n")
3644 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3648 evpn_unset_advertise_all_vni(bgp
);
3652 DEFUN (bgp_evpn_advertise_autort_rfc8365
,
3653 bgp_evpn_advertise_autort_rfc8365_cmd
,
3654 "autort rfc8365-compatible",
3655 "Auto-derivation of RT\n"
3656 "Auto-derivation of RT using RFC8365\n")
3658 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3662 evpn_set_advertise_autort_rfc8365(bgp
);
3666 DEFUN (no_bgp_evpn_advertise_autort_rfc8365
,
3667 no_bgp_evpn_advertise_autort_rfc8365_cmd
,
3668 "no autort rfc8365-compatible",
3670 "Auto-derivation of RT\n"
3671 "Auto-derivation of RT using RFC8365\n")
3673 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3677 evpn_unset_advertise_autort_rfc8365(bgp
);
3681 DEFUN (bgp_evpn_default_originate
,
3682 bgp_evpn_default_originate_cmd
,
3683 "default-originate <ipv4 | ipv6>",
3684 "originate a default route\n"
3685 "ipv4 address family\n"
3686 "ipv6 address family\n")
3690 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
3694 argv_find_and_parse_afi(argv
, argc
, &idx_afi
, &afi
);
3695 evpn_process_default_originate_cmd(bgp_vrf
, afi
, true);
3699 DEFUN (no_bgp_evpn_default_originate
,
3700 no_bgp_evpn_default_originate_cmd
,
3701 "no default-originate <ipv4 | ipv6>",
3703 "withdraw a default route\n"
3704 "ipv4 address family\n"
3705 "ipv6 address family\n")
3709 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
3713 argv_find_and_parse_afi(argv
, argc
, &idx_afi
, &afi
);
3714 evpn_process_default_originate_cmd(bgp_vrf
, afi
, false);
3718 DEFPY (dup_addr_detection
,
3719 dup_addr_detection_cmd
,
3720 "dup-addr-detection [max-moves (2-1000)$max_moves_val time (2-1800)$time_val]",
3721 "Duplicate address detection\n"
3722 "Max allowed moves before address detected as duplicate\n"
3723 "Num of max allowed moves (2-1000) default 5\n"
3724 "Duplicate address detection time\n"
3725 "Time in seconds (2-1800) default 180\n")
3727 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
3732 if (!EVPN_ENABLED(bgp_vrf
)) {
3734 "This command is only supported under the EVPN VRF\n");
3738 bgp_vrf
->evpn_info
->dup_addr_detect
= true;
3741 bgp_vrf
->evpn_info
->dad_time
= time_val
;
3743 bgp_vrf
->evpn_info
->dad_max_moves
= max_moves_val
;
3745 bgp_zebra_dup_addr_detection(bgp_vrf
);
3750 DEFPY (dup_addr_detection_auto_recovery
,
3751 dup_addr_detection_auto_recovery_cmd
,
3752 "dup-addr-detection freeze <permanent |(30-3600)$freeze_time_val>",
3753 "Duplicate address detection\n"
3754 "Duplicate address detection freeze\n"
3755 "Duplicate address detection permanent freeze\n"
3756 "Duplicate address detection freeze time (30-3600)\n")
3758 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
3759 uint32_t freeze_time
= freeze_time_val
;
3764 if (!EVPN_ENABLED(bgp_vrf
)) {
3766 "This command is only supported under the EVPN VRF\n");
3770 bgp_vrf
->evpn_info
->dup_addr_detect
= true;
3771 bgp_vrf
->evpn_info
->dad_freeze
= true;
3772 bgp_vrf
->evpn_info
->dad_freeze_time
= freeze_time
;
3774 bgp_zebra_dup_addr_detection(bgp_vrf
);
3779 DEFPY (no_dup_addr_detection
,
3780 no_dup_addr_detection_cmd
,
3781 "no dup-addr-detection [max-moves (2-1000)$max_moves_val time (2-1800)$time_val | freeze <permanent$permanent_val | (30-3600)$freeze_time_val>]",
3783 "Duplicate address detection\n"
3784 "Max allowed moves before address detected as duplicate\n"
3785 "Num of max allowed moves (2-1000) default 5\n"
3786 "Duplicate address detection time\n"
3787 "Time in seconds (2-1800) default 180\n"
3788 "Duplicate address detection freeze\n"
3789 "Duplicate address detection permanent freeze\n"
3790 "Duplicate address detection freeze time (30-3600)\n")
3792 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
3793 uint32_t max_moves
= (uint32_t)max_moves_val
;
3794 uint32_t freeze_time
= (uint32_t)freeze_time_val
;
3799 if (!EVPN_ENABLED(bgp_vrf
)) {
3801 "This command is only supported under the EVPN VRF\n");
3806 if (!bgp_vrf
->evpn_info
->dup_addr_detect
)
3808 /* Reset all parameters to default. */
3809 bgp_vrf
->evpn_info
->dup_addr_detect
= false;
3810 bgp_vrf
->evpn_info
->dad_time
= EVPN_DAD_DEFAULT_TIME
;
3811 bgp_vrf
->evpn_info
->dad_max_moves
= EVPN_DAD_DEFAULT_MAX_MOVES
;
3812 bgp_vrf
->evpn_info
->dad_freeze
= false;
3813 bgp_vrf
->evpn_info
->dad_freeze_time
= 0;
3816 if (bgp_vrf
->evpn_info
->dad_max_moves
!= max_moves
) {
3818 "%% Value does not match with config\n");
3821 bgp_vrf
->evpn_info
->dad_max_moves
=
3822 EVPN_DAD_DEFAULT_MAX_MOVES
;
3826 if (bgp_vrf
->evpn_info
->dad_time
!= time_val
) {
3828 "%% Value does not match with config\n");
3831 bgp_vrf
->evpn_info
->dad_time
= EVPN_DAD_DEFAULT_TIME
;
3835 if (bgp_vrf
->evpn_info
->dad_freeze_time
3838 "%% Value does not match with config\n");
3841 bgp_vrf
->evpn_info
->dad_freeze_time
= 0;
3842 bgp_vrf
->evpn_info
->dad_freeze
= false;
3845 if (permanent_val
) {
3846 if (bgp_vrf
->evpn_info
->dad_freeze_time
) {
3848 "%% Value does not match with config\n");
3851 bgp_vrf
->evpn_info
->dad_freeze
= false;
3855 bgp_zebra_dup_addr_detection(bgp_vrf
);
3860 DEFPY(bgp_evpn_advertise_svi_ip
,
3861 bgp_evpn_advertise_svi_ip_cmd
,
3862 "[no$no] advertise-svi-ip",
3864 "Advertise svi mac-ip routes in EVPN\n")
3866 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3872 evpn_set_advertise_svi_macip(bgp
, NULL
, 0);
3874 if (!EVPN_ENABLED(bgp
)) {
3876 "This command is only supported under EVPN VRF\n");
3879 evpn_set_advertise_svi_macip(bgp
, NULL
, 1);
3885 DEFPY(bgp_evpn_advertise_svi_ip_vni
,
3886 bgp_evpn_advertise_svi_ip_vni_cmd
,
3887 "[no$no] advertise-svi-ip",
3889 "Advertise svi mac-ip routes in EVPN for a VNI\n")
3891 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3892 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
3898 evpn_set_advertise_svi_macip(bgp
, vpn
, 0);
3900 evpn_set_advertise_svi_macip(bgp
, vpn
, 1);
3905 DEFUN_HIDDEN (bgp_evpn_advertise_vni_subnet
,
3906 bgp_evpn_advertise_vni_subnet_cmd
,
3908 "Advertise the subnet corresponding to VNI\n")
3910 struct bgp
*bgp_vrf
= NULL
;
3911 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3912 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
3917 bgp_vrf
= bgp_lookup_by_vrf_id(vpn
->tenant_vrf_id
);
3921 evpn_set_advertise_subnet(bgp
, vpn
);
3925 DEFUN_HIDDEN (no_bgp_evpn_advertise_vni_subnet
,
3926 no_bgp_evpn_advertise_vni_subnet_cmd
,
3927 "no advertise-subnet",
3929 "Advertise All local VNIs\n")
3931 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
3932 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
3937 evpn_unset_advertise_subnet(bgp
, vpn
);
3941 DEFUN (bgp_evpn_advertise_type5
,
3942 bgp_evpn_advertise_type5_cmd
,
3943 "advertise " BGP_AFI_CMD_STR
"" BGP_SAFI_CMD_STR
" [gateway-ip] [route-map RMAP_NAME]",
3944 "Advertise prefix routes\n"
3947 "advertise gateway IP overlay index\n"
3948 "route-map for filtering specific routes\n"
3949 "Name of the route map\n")
3951 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
); /* bgp vrf instance */
3958 int rmap_changed
= 0;
3959 enum overlay_index_type oly
= OVERLAY_INDEX_TYPE_NONE
;
3961 bool adv_flag_changed
= false;
3963 argv_find_and_parse_afi(argv
, argc
, &idx_afi
, &afi
);
3964 argv_find_and_parse_safi(argv
, argc
, &idx_safi
, &safi
);
3965 argv_find_and_parse_oly_idx(argv
, argc
, &idx_oly
, &oly
);
3967 ret
= argv_find(argv
, argc
, "route-map", &idx_rmap
);
3969 if (!bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
)
3971 else if (strcmp(argv
[idx_rmap
+ 1]->arg
,
3972 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
)
3975 } else if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
) {
3979 if (!(afi
== AFI_IP
|| afi
== AFI_IP6
)) {
3981 "%% Only ipv4 or ipv6 address families are supported\n");
3985 if (safi
!= SAFI_UNICAST
) {
3987 "%% Only ipv4 unicast or ipv6 unicast are supported\n");
3991 if ((oly
!= OVERLAY_INDEX_TYPE_NONE
)
3992 && (oly
!= OVERLAY_INDEX_GATEWAY_IP
)) {
3993 vty_out(vty
, "%% Unknown overlay-index type specified\n");
3997 if (afi
== AFI_IP
) {
3998 if ((!CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
3999 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
))
4000 && (!CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4001 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
))) {
4004 * this is the case for first time ever configuration
4005 * adv ipv4 unicast is enabled for the first time.
4006 * So no need to reset any flag
4008 if (oly
== OVERLAY_INDEX_TYPE_NONE
)
4010 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4011 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
);
4012 else if (oly
== OVERLAY_INDEX_GATEWAY_IP
)
4014 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4015 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
);
4016 } else if ((oly
== OVERLAY_INDEX_TYPE_NONE
)
4018 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4019 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
))) {
4022 * This is modify case from gateway-ip
4023 * to no overlay index
4025 adv_flag_changed
= true;
4026 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4027 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
);
4028 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4029 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
);
4030 } else if ((oly
== OVERLAY_INDEX_GATEWAY_IP
)
4032 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4033 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
))) {
4036 * This is modify case from no overlay index
4039 adv_flag_changed
= true;
4040 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4041 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
);
4042 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4043 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
);
4047 * Command is issued with the same option
4048 * (no overlay index or gateway-ip) which was
4049 * already configured. So nothing to do.
4050 * However, route-map may have been modified.
4051 * check if route-map has been modified.
4052 * If not, return an error
4058 if ((!CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4059 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
))
4060 && (!CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4061 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
))) {
4064 * this is the case for first time ever configuration
4065 * adv ipv6 unicast is enabled for the first time.
4066 * So no need to reset any flag
4068 if (oly
== OVERLAY_INDEX_TYPE_NONE
)
4070 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4071 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
);
4072 else if (oly
== OVERLAY_INDEX_GATEWAY_IP
)
4074 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4075 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
);
4076 } else if ((oly
== OVERLAY_INDEX_TYPE_NONE
)
4078 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4079 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
))) {
4082 * This is modify case from gateway-ip
4083 * to no overlay index
4085 adv_flag_changed
= true;
4086 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4087 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
);
4088 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4089 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
);
4090 } else if ((oly
== OVERLAY_INDEX_GATEWAY_IP
)
4092 bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4093 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
))) {
4096 * This is modify case from no overlay index
4099 adv_flag_changed
= true;
4100 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4101 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
);
4102 SET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4103 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
);
4107 * Command is issued with the same option
4108 * (no overlay index or gateway-ip) which was
4109 * already configured. So nothing to do.
4110 * However, route-map may have been modified.
4111 * check if route-map has been modified.
4112 * If not, return an error
4119 if ((rmap_changed
) || (adv_flag_changed
)) {
4121 /* If either of these are changed, then FRR needs to
4122 * withdraw already advertised type5 routes.
4124 bgp_evpn_withdraw_type5_routes(bgp_vrf
, afi
, safi
);
4126 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
) {
4127 XFREE(MTYPE_ROUTE_MAP_NAME
,
4128 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
);
4129 route_map_counter_decrement(
4130 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
);
4131 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
= NULL
;
4132 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
= NULL
;
4137 /* set the route-map for advertise command */
4138 if (ret
&& argv
[idx_rmap
+ 1]->arg
) {
4139 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
=
4140 XSTRDUP(MTYPE_ROUTE_MAP_NAME
, argv
[idx_rmap
+ 1]->arg
);
4141 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
=
4142 route_map_lookup_by_name(argv
[idx_rmap
+ 1]->arg
);
4143 route_map_counter_increment(
4144 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
);
4147 /* advertise type-5 routes */
4148 if (advertise_type5_routes(bgp_vrf
, afi
))
4149 bgp_evpn_advertise_type5_routes(bgp_vrf
, afi
, safi
);
4153 DEFUN (no_bgp_evpn_advertise_type5
,
4154 no_bgp_evpn_advertise_type5_cmd
,
4155 "no advertise " BGP_AFI_CMD_STR
"" BGP_SAFI_CMD_STR
" [route-map WORD]",
4157 "Advertise prefix routes\n"
4160 "route-map for filtering specific routes\n"
4161 "Name of the route map\n")
4163 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
); /* bgp vrf instance */
4172 argv_find_and_parse_afi(argv
, argc
, &idx_afi
, &afi
);
4173 argv_find_and_parse_safi(argv
, argc
, &idx_safi
, &safi
);
4175 if (!(afi
== AFI_IP
|| afi
== AFI_IP6
)) {
4177 "%% Only ipv4 or ipv6 address families are supported\n");
4181 if (safi
!= SAFI_UNICAST
) {
4183 "%% Only ipv4 unicast or ipv6 unicast are supported\n");
4187 if (afi
== AFI_IP
) {
4189 /* if we are not advertising ipv4 prefix as type-5
4192 if ((CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4193 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
)) ||
4194 (CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4195 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
))) {
4196 bgp_evpn_withdraw_type5_routes(bgp_vrf
, afi
, safi
);
4197 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4198 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
);
4199 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4200 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
);
4204 /* if we are not advertising ipv6 prefix as type-5
4207 if ((CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4208 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
)) ||
4209 (CHECK_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4210 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
))){
4211 bgp_evpn_withdraw_type5_routes(bgp_vrf
, afi
, safi
);
4212 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4213 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
);
4214 UNSET_FLAG(bgp_vrf
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
4215 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
);
4219 /* clear the route-map information for advertise ipv4/ipv6 unicast */
4220 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
) {
4221 XFREE(MTYPE_ROUTE_MAP_NAME
,
4222 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
);
4223 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].name
= NULL
;
4224 bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
= NULL
;
4230 DEFPY (bgp_evpn_use_es_l3nhg
,
4231 bgp_evpn_use_es_l3nhg_cmd
,
4232 "[no$no] use-es-l3nhg",
4234 "use L3 nexthop group for host routes with ES destination\n")
4236 bgp_mh_info
->host_routes_use_l3nhg
= no
? false :true;
4240 DEFPY (bgp_evpn_ead_evi_rx_disable
,
4241 bgp_evpn_ead_evi_rx_disable_cmd
,
4242 "[no$no] disable-ead-evi-rx",
4244 "Activate PE on EAD-ES even if EAD-EVI is not received\n")
4246 bool ead_evi_rx
= no
? true :false;
4248 if (ead_evi_rx
!= bgp_mh_info
->ead_evi_rx
) {
4249 bgp_mh_info
->ead_evi_rx
= ead_evi_rx
;
4250 bgp_evpn_switch_ead_evi_rx();
4255 DEFPY (bgp_evpn_ead_evi_tx_disable
,
4256 bgp_evpn_ead_evi_tx_disable_cmd
,
4257 "[no$no] disable-ead-evi-tx",
4259 "Don't advertise EAD-EVI for local ESs\n")
4261 bgp_mh_info
->ead_evi_tx
= no
? true :false;
4265 DEFPY (bgp_evpn_enable_resolve_overlay_index
,
4266 bgp_evpn_enable_resolve_overlay_index_cmd
,
4267 "[no$no] enable-resolve-overlay-index",
4269 "Enable Recursive Resolution of type-5 route overlay index\n")
4271 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
4273 if (bgp
!= bgp_get_evpn()) {
4274 vty_out(vty
, "This command is only supported under EVPN VRF\n");
4278 bgp_evpn_set_unset_resolve_overlay_index(bgp
, no
? false : true);
4282 DEFPY (bgp_evpn_advertise_pip_ip_mac
,
4283 bgp_evpn_advertise_pip_ip_mac_cmd
,
4284 "[no$no] advertise-pip [ip <A.B.C.D> [mac <X:X:X:X:X:X|X:X:X:X:X:X/M>]]",
4286 "evpn system primary IP\n"
4289 MAC_STR MAC_STR MAC_STR
)
4291 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
); /* bgp vrf instance */
4292 struct bgp
*bgp_evpn
= NULL
;
4294 if (EVPN_ENABLED(bgp_vrf
)) {
4296 "This command is supported under L3VNI BGP EVPN VRF\n");
4297 return CMD_WARNING_CONFIG_FAILED
;
4299 bgp_evpn
= bgp_get_evpn();
4302 /* pip is already enabled */
4303 if (argc
== 1 && bgp_vrf
->evpn_info
->advertise_pip
)
4306 bgp_vrf
->evpn_info
->advertise_pip
= true;
4307 if (ip
.s_addr
!= INADDR_ANY
) {
4308 /* Already configured with same IP */
4309 if (IPV4_ADDR_SAME(&ip
,
4310 &bgp_vrf
->evpn_info
->pip_ip_static
))
4313 bgp_vrf
->evpn_info
->pip_ip_static
= ip
;
4314 bgp_vrf
->evpn_info
->pip_ip
= ip
;
4316 bgp_vrf
->evpn_info
->pip_ip_static
.s_addr
4318 /* default instance router-id assignemt */
4320 bgp_vrf
->evpn_info
->pip_ip
=
4321 bgp_evpn
->router_id
;
4324 if (!is_zero_mac(&mac
->eth_addr
)) {
4325 /* Already configured with same MAC */
4326 if (memcmp(&bgp_vrf
->evpn_info
->pip_rmac_static
,
4327 &mac
->eth_addr
, ETH_ALEN
) == 0)
4330 memcpy(&bgp_vrf
->evpn_info
->pip_rmac_static
,
4331 &mac
->eth_addr
, ETH_ALEN
);
4332 memcpy(&bgp_vrf
->evpn_info
->pip_rmac
,
4333 &bgp_vrf
->evpn_info
->pip_rmac_static
,
4336 /* Copy zebra sys mac */
4337 if (!is_zero_mac(&bgp_vrf
->evpn_info
->pip_rmac_zebra
))
4338 memcpy(&bgp_vrf
->evpn_info
->pip_rmac
,
4339 &bgp_vrf
->evpn_info
->pip_rmac_zebra
,
4344 if (!bgp_vrf
->evpn_info
->advertise_pip
)
4346 /* Disable PIP feature */
4347 bgp_vrf
->evpn_info
->advertise_pip
= false;
4348 /* copy anycast mac */
4349 memcpy(&bgp_vrf
->evpn_info
->pip_rmac
,
4350 &bgp_vrf
->rmac
, ETH_ALEN
);
4352 /* remove MAC-IP option retain PIP knob. */
4353 if ((ip
.s_addr
!= INADDR_ANY
) &&
4354 !IPV4_ADDR_SAME(&ip
,
4355 &bgp_vrf
->evpn_info
->pip_ip_static
)) {
4357 "%% BGP EVPN PIP IP does not match\n");
4358 return CMD_WARNING_CONFIG_FAILED
;
4361 if (!is_zero_mac(&mac
->eth_addr
) &&
4362 memcmp(&bgp_vrf
->evpn_info
->pip_rmac_static
,
4363 &mac
->eth_addr
, ETH_ALEN
) != 0) {
4365 "%% BGP EVPN PIP MAC does not match\n");
4366 return CMD_WARNING_CONFIG_FAILED
;
4368 /* pip_rmac can carry vrr_rmac reset only if it matches
4369 * with static value.
4371 if (memcmp(&bgp_vrf
->evpn_info
->pip_rmac
,
4372 &bgp_vrf
->evpn_info
->pip_rmac_static
,
4374 /* Copy zebra sys mac */
4376 &bgp_vrf
->evpn_info
->pip_rmac_zebra
))
4377 memcpy(&bgp_vrf
->evpn_info
->pip_rmac
,
4378 &bgp_vrf
->evpn_info
->pip_rmac_zebra
,
4381 /* copy anycast mac */
4382 memcpy(&bgp_vrf
->evpn_info
->pip_rmac
,
4383 &bgp_vrf
->rmac
, ETH_ALEN
);
4387 /* reset user configured sys MAC */
4388 memset(&bgp_vrf
->evpn_info
->pip_rmac_static
, 0, ETH_ALEN
);
4389 /* reset user configured sys IP */
4390 bgp_vrf
->evpn_info
->pip_ip_static
.s_addr
= INADDR_ANY
;
4391 /* Assign default PIP IP (bgp instance router-id) */
4393 bgp_vrf
->evpn_info
->pip_ip
= bgp_evpn
->router_id
;
4395 bgp_vrf
->evpn_info
->pip_ip
.s_addr
= INADDR_ANY
;
4398 if (is_evpn_enabled()) {
4399 struct listnode
*node
= NULL
;
4400 struct bgpevpn
*vpn
= NULL
;
4403 * At this point if bgp_evpn is NULL and evpn is enabled
4404 * something stupid has gone wrong
4408 update_advertise_vrf_routes(bgp_vrf
);
4410 /* Update (svi) type-2 routes */
4411 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
4412 if (!bgp_evpn_is_svi_macip_enabled(vpn
))
4414 update_routes_for_vni(bgp_evpn
, vpn
);
4422 * Display VNI information - for all or a specific VNI
4424 DEFUN(show_bgp_l2vpn_evpn_vni
,
4425 show_bgp_l2vpn_evpn_vni_cmd
,
4426 "show bgp l2vpn evpn vni [" CMD_VNI_RANGE
"] [json]",
4435 struct bgp
*bgp_evpn
;
4439 json_object
*json
= NULL
;
4440 uint32_t num_l2vnis
= 0;
4441 uint32_t num_l3vnis
= 0;
4442 uint32_t num_vnis
= 0;
4443 struct listnode
*node
= NULL
;
4444 struct bgp
*bgp_temp
= NULL
;
4446 uj
= use_json(argc
, argv
);
4448 bgp_evpn
= bgp_get_evpn();
4452 if (!argv_find(argv
, argc
, "evpn", &idx
))
4456 json
= json_object_new_object();
4458 if ((uj
&& argc
== ((idx
+ 1) + 2)) || (!uj
&& argc
== (idx
+ 1) + 1)) {
4460 num_l2vnis
= hashcount(bgp_evpn
->vnihash
);
4462 for (ALL_LIST_ELEMENTS_RO(bm
->bgp
, node
, bgp_temp
)) {
4463 if (bgp_temp
->l3vni
)
4466 num_vnis
= num_l2vnis
+ num_l3vnis
;
4468 json_object_string_add(json
, "advertiseGatewayMacip",
4469 bgp_evpn
->advertise_gw_macip
4472 json_object_string_add(json
, "advertiseSviMacIp",
4473 bgp_evpn
->evpn_info
->advertise_svi_macip
4474 ? "Enabled" : "Disabled");
4475 json_object_string_add(json
, "advertiseAllVnis",
4476 is_evpn_enabled() ? "Enabled"
4478 json_object_string_add(
4480 bgp_evpn
->vxlan_flood_ctrl
==
4481 VXLAN_FLOOD_HEAD_END_REPL
4482 ? "Head-end replication"
4484 json_object_string_add(
4485 json
, "vxlanFlooding",
4486 bgp_evpn
->vxlan_flood_ctrl
==
4487 VXLAN_FLOOD_HEAD_END_REPL
4490 json_object_int_add(json
, "numVnis", num_vnis
);
4491 json_object_int_add(json
, "numL2Vnis", num_l2vnis
);
4492 json_object_int_add(json
, "numL3Vnis", num_l3vnis
);
4494 vty_out(vty
, "Advertise Gateway Macip: %s\n",
4495 bgp_evpn
->advertise_gw_macip
? "Enabled"
4497 vty_out(vty
, "Advertise SVI Macip: %s\n",
4498 bgp_evpn
->evpn_info
->advertise_svi_macip
? "Enabled"
4500 vty_out(vty
, "Advertise All VNI flag: %s\n",
4501 is_evpn_enabled() ? "Enabled" : "Disabled");
4502 vty_out(vty
, "BUM flooding: %s\n",
4503 bgp_evpn
->vxlan_flood_ctrl
==
4504 VXLAN_FLOOD_HEAD_END_REPL
4505 ? "Head-end replication"
4507 vty_out(vty
, "VXLAN flooding: %s\n",
4508 bgp_evpn
->vxlan_flood_ctrl
==
4509 VXLAN_FLOOD_HEAD_END_REPL
4512 vty_out(vty
, "Number of L2 VNIs: %u\n", num_l2vnis
);
4513 vty_out(vty
, "Number of L3 VNIs: %u\n", num_l3vnis
);
4515 evpn_show_all_vnis(vty
, bgp_evpn
, json
);
4519 if (!argv_find(argv
, argc
, "vni", &vni_idx
))
4522 /* Display specific VNI */
4523 vni
= strtoul(argv
[vni_idx
+ 1]->arg
, NULL
, 10);
4524 evpn_show_vni(vty
, bgp_evpn
, vni
, json
);
4528 vty_json(vty
, json
);
4533 DEFUN_HIDDEN(show_bgp_l2vpn_evpn_vni_remote_ip_hash
,
4534 show_bgp_l2vpn_evpn_vni_remote_ip_hash_cmd
,
4535 "show bgp l2vpn evpn vni remote-ip-hash",
4543 struct bgp
*bgp_evpn
;
4546 bgp_evpn
= bgp_get_evpn();
4550 if (!argv_find(argv
, argc
, "evpn", &idx
))
4553 hash_iterate(bgp_evpn
->vnihash
,
4554 (void (*)(struct hash_bucket
*,
4555 void *))bgp_evpn_show_remote_ip_hash
,
4561 DEFUN_HIDDEN(show_bgp_l2vpn_evpn_vni_svi_hash
,
4562 show_bgp_l2vpn_evpn_vni_svi_hash_cmd
,
4563 "show bgp l2vpn evpn vni-svi-hash",
4568 "Show vni-svi-hash\n")
4570 struct bgp
*bgp_evpn
;
4573 bgp_evpn
= bgp_get_evpn();
4577 if (!argv_find(argv
, argc
, "evpn", &idx
))
4580 hash_iterate(bgp_evpn
->vni_svi_hash
,
4581 (void (*)(struct hash_bucket
*,
4582 void *))bgp_evpn_show_vni_svi_hash
,
4588 DEFPY(show_bgp_l2vpn_evpn_es_evi
,
4589 show_bgp_l2vpn_evpn_es_evi_cmd
,
4590 "show bgp l2vpn evpn es-evi [vni (1-16777215)$vni] [json$uj] [detail$detail]",
4596 "VxLAN Network Identifier\n"
4599 "Detailed information\n")
4602 bgp_evpn_es_evi_show_vni(vty
, vni
, !!uj
, !!detail
);
4604 bgp_evpn_es_evi_show(vty
, !!uj
, !!detail
);
4609 DEFPY(show_bgp_l2vpn_evpn_es
,
4610 show_bgp_l2vpn_evpn_es_cmd
,
4611 "show bgp l2vpn evpn es [NAME$esi_str|detail$detail] [json$uj]",
4616 "Ethernet Segment\n"
4618 "Detailed information\n"
4624 if (!str_to_esi(esi_str
, &esi
)) {
4625 vty_out(vty
, "%% Malformed ESI\n");
4628 bgp_evpn_es_show_esi(vty
, &esi
, uj
);
4631 bgp_evpn_es_show(vty
, uj
, !!detail
);
4637 DEFPY(show_bgp_l2vpn_evpn_es_vrf
, show_bgp_l2vpn_evpn_es_vrf_cmd
,
4638 "show bgp l2vpn evpn es-vrf [NAME$esi_str] [json$uj]",
4639 SHOW_STR BGP_STR L2VPN_HELP_STR EVPN_HELP_STR
4640 "Ethernet Segment\n"
4646 if (!str_to_esi(esi_str
, &esi
)) {
4647 vty_out(vty
, "%% Malformed ESI\n");
4650 bgp_evpn_es_vrf_show_esi(vty
, &esi
, uj
);
4653 bgp_evpn_es_vrf_show(vty
, uj
, NULL
);
4659 DEFPY(show_bgp_l2vpn_evpn_nh
,
4660 show_bgp_l2vpn_evpn_nh_cmd
,
4661 "show bgp l2vpn evpn next-hops [json$uj]",
4669 bgp_evpn_nh_show(vty
, uj
);
4675 * Display EVPN neighbor summary.
4677 DEFUN(show_bgp_l2vpn_evpn_summary
, show_bgp_l2vpn_evpn_summary_cmd
,
4678 "show bgp [vrf VRFNAME] l2vpn evpn summary [established|failed] [<neighbor <A.B.C.D|X:X::X:X|WORD>|remote-as <(1-4294967295)|internal|external>>] [terse] [wide] [json]",
4681 "vrf name\n" L2VPN_HELP_STR EVPN_HELP_STR
4682 "Summary of BGP neighbor status\n"
4683 "Show only sessions in Established state\n"
4684 "Show only sessions not in Established state\n"
4685 "Show only the specified neighbor session\n"
4686 "Neighbor to display information about\n"
4687 "Neighbor to display information about\n"
4688 "Neighbor on BGP configured interface\n"
4689 "Show only the specified remote AS sessions\n"
4691 "Internal (iBGP) AS sessions\n"
4692 "External (eBGP) AS sessions\n"
4693 "Shorten the information on BGP instances\n"
4694 "Increase table width for longer output\n" JSON_STR
)
4699 char *neighbor
= NULL
;
4700 as_t as
= 0; /* 0 means AS filter not set */
4701 int as_type
= AS_UNSPECIFIED
;
4702 uint16_t show_flags
= 0;
4704 if (argv_find(argv
, argc
, "vrf", &idx_vrf
))
4705 vrf
= argv
[++idx_vrf
]->arg
;
4707 if (argv_find(argv
, argc
, "failed", &idx
))
4708 SET_FLAG(show_flags
, BGP_SHOW_OPT_FAILED
);
4710 if (argv_find(argv
, argc
, "established", &idx
))
4711 SET_FLAG(show_flags
, BGP_SHOW_OPT_ESTABLISHED
);
4714 if (argv_find(argv
, argc
, "neighbor", &idx
))
4715 neighbor
= argv
[idx
+ 1]->arg
;
4717 if (argv_find(argv
, argc
, "remote-as", &idx
)) {
4718 if (argv
[idx
+ 1]->arg
[0] == 'i')
4719 as_type
= AS_INTERNAL
;
4720 else if (argv
[idx
+ 1]->arg
[0] == 'e')
4721 as_type
= AS_EXTERNAL
;
4723 as
= (as_t
)atoi(argv
[idx
+ 1]->arg
);
4726 if (argv_find(argv
, argc
, "terse", &idx
))
4727 SET_FLAG(show_flags
, BGP_SHOW_OPT_TERSE
);
4729 if (argv_find(argv
, argc
, "wide", &idx
))
4730 SET_FLAG(show_flags
, BGP_SHOW_OPT_WIDE
);
4732 if (use_json(argc
, argv
))
4733 SET_FLAG(show_flags
, BGP_SHOW_OPT_JSON
);
4735 return bgp_show_summary_vty(vty
, vrf
, AFI_L2VPN
, SAFI_EVPN
, neighbor
,
4736 as_type
, as
, show_flags
);
4739 static int bgp_evpn_cli_parse_type_cmp(int *type
, const char *type_str
)
4741 if ((strncmp(type_str
, "ma", 2) == 0) || (strmatch(type_str
, "2")))
4742 *type
= BGP_EVPN_MAC_IP_ROUTE
;
4743 else if ((strncmp(type_str
, "mu", 2) == 0) || (strmatch(type_str
, "3")))
4744 *type
= BGP_EVPN_IMET_ROUTE
;
4745 else if ((strncmp(type_str
, "es", 2) == 0) || (strmatch(type_str
, "4")))
4746 *type
= BGP_EVPN_ES_ROUTE
;
4747 else if ((strncmp(type_str
, "ea", 2) == 0) || (strmatch(type_str
, "1")))
4748 *type
= BGP_EVPN_AD_ROUTE
;
4749 else if ((strncmp(type_str
, "p", 1) == 0) || (strmatch(type_str
, "5")))
4750 *type
= BGP_EVPN_IP_PREFIX_ROUTE
;
4757 int bgp_evpn_cli_parse_type(int *type
, struct cmd_token
**argv
, int argc
)
4761 if (argv_find(argv
, argc
, "type", &type_idx
)) {
4762 /* Specific type is requested */
4763 if (bgp_evpn_cli_parse_type_cmp(type
,
4764 argv
[type_idx
+ 1]->arg
) != 0)
4772 * Display global EVPN routing table.
4774 DEFUN(show_bgp_l2vpn_evpn_route
,
4775 show_bgp_l2vpn_evpn_route_cmd
,
4776 "show bgp l2vpn evpn route [detail] [type "EVPN_TYPE_ALL_LIST
"] [json]",
4782 "Display Detailed Information\n"
4784 EVPN_TYPE_ALL_LIST_HELP_STR
4791 json_object
*json
= NULL
;
4793 uj
= use_json(argc
, argv
);
4795 bgp
= bgp_get_evpn();
4800 json
= json_object_new_object();
4802 if (bgp_evpn_cli_parse_type(&type
, argv
, argc
) < 0)
4805 if (argv_find(argv
, argc
, "detail", &detail
))
4808 evpn_show_all_routes(vty
, bgp
, type
, json
, detail
);
4811 vty_json(vty
, json
);
4816 * Display global EVPN routing table for specific RD.
4818 DEFUN(show_bgp_l2vpn_evpn_route_rd
,
4819 show_bgp_l2vpn_evpn_route_rd_cmd
,
4820 "show bgp l2vpn evpn route rd <ASN:NN_OR_IP-ADDRESS:NN|all> [type "EVPN_TYPE_ALL_LIST
"] [json]",
4826 EVPN_RT_DIST_HELP_STR
4827 EVPN_ASN_IP_HELP_STR
4828 "All VPN Route Distinguishers\n"
4830 EVPN_TYPE_ALL_LIST_HELP_STR
4835 struct prefix_rd prd
;
4838 json_object
*json
= NULL
;
4839 int idx_ext_community
= 0;
4842 bgp
= bgp_get_evpn();
4846 /* check if we need json output */
4847 uj
= use_json(argc
, argv
);
4849 json
= json_object_new_object();
4851 if (!argv_find(argv
, argc
, "all", &rd_all
)) {
4853 if (argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN",
4854 &idx_ext_community
)) {
4855 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
4858 "%% Malformed Route Distinguisher\n");
4864 if (bgp_evpn_cli_parse_type(&type
, argv
, argc
) < 0)
4868 evpn_show_all_routes(vty
, bgp
, type
, json
, 1);
4870 evpn_show_route_rd(vty
, bgp
, &prd
, type
, json
);
4873 vty_json(vty
, json
);
4879 * Display global EVPN routing table for specific RD and MACIP.
4881 DEFUN(show_bgp_l2vpn_evpn_route_rd_macip
,
4882 show_bgp_l2vpn_evpn_route_rd_macip_cmd
,
4883 "show bgp l2vpn evpn route rd <ASN:NN_OR_IP-ADDRESS:NN|all> mac WORD [ip WORD] [json]",
4889 EVPN_RT_DIST_HELP_STR
4890 EVPN_ASN_IP_HELP_STR
4891 "All VPN Route Distinguishers\n"
4893 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
4895 "IP address (IPv4 or IPv6)\n"
4900 struct prefix_rd prd
;
4903 int idx_ext_community
= 0;
4907 json_object
*json
= NULL
;
4910 memset(&mac
, 0, sizeof(struct ethaddr
));
4911 memset(&ip
, 0, sizeof(struct ipaddr
));
4913 bgp
= bgp_get_evpn();
4917 /* check if we need json output */
4918 uj
= use_json(argc
, argv
);
4920 json
= json_object_new_object();
4923 if (!argv_find(argv
, argc
, "all", &rd_all
)) {
4924 if (argv_find(argv
, argc
, "ASN:NN_OR_IP-ADDRESS:NN",
4925 &idx_ext_community
)) {
4926 ret
= str2prefix_rd(argv
[idx_ext_community
]->arg
, &prd
);
4929 "%% Malformed Route Distinguisher\n");
4936 if (argv_find(argv
, argc
, "mac", &mac_idx
)) {
4937 if (!prefix_str2mac(argv
[mac_idx
+ 1]->arg
, &mac
)) {
4938 vty_out(vty
, "%% Malformed MAC address\n");
4943 /* get the ip if specified */
4944 if (argv_find(argv
, argc
, "ip", &ip_idx
)) {
4945 if (str2ipaddr(argv
[ip_idx
+ 1]->arg
, &ip
) != 0) {
4946 vty_out(vty
, "%% Malformed IP address\n");
4952 evpn_show_route_rd_all_macip(vty
, bgp
, &mac
, &ip
, json
);
4954 evpn_show_route_rd_macip(vty
, bgp
, &prd
, &mac
, &ip
, json
);
4957 vty_json(vty
, json
);
4962 /* Display per ESI routing table */
4963 DEFUN(show_bgp_l2vpn_evpn_route_esi
,
4964 show_bgp_l2vpn_evpn_route_esi_cmd
,
4965 "show bgp l2vpn evpn route esi ESI [json]",
4971 "Ethernet Segment Identifier\n"
4977 struct bgp
*bgp
= NULL
;
4978 json_object
*json
= NULL
;
4980 memset(&esi
, 0, sizeof(esi
));
4981 bgp
= bgp_get_evpn();
4985 uj
= use_json(argc
, argv
);
4987 json
= json_object_new_object();
4989 /* get the ESI - ESI-ID is at argv[6] */
4990 if (!str_to_esi(argv
[6]->arg
, &esi
)) {
4991 vty_out(vty
, "%% Malformed ESI\n");
4995 evpn_show_routes_esi(vty
, bgp
, &esi
, json
);
4998 vty_json(vty
, json
);
5005 * Display per-VNI EVPN routing table.
5007 DEFUN(show_bgp_l2vpn_evpn_route_vni
, show_bgp_l2vpn_evpn_route_vni_cmd
,
5008 "show bgp l2vpn evpn route vni " CMD_VNI_RANGE
" [<type <ead|1|macip|2|multicast|3> | vtep A.B.C.D>] [json]",
5014 "VXLAN Network Identifier\n"
5017 EVPN_TYPE_1_HELP_STR
5018 EVPN_TYPE_1_HELP_STR
5019 EVPN_TYPE_2_HELP_STR
5020 EVPN_TYPE_2_HELP_STR
5021 EVPN_TYPE_3_HELP_STR
5022 EVPN_TYPE_3_HELP_STR
5024 "Remote VTEP IP address\n"
5029 struct in_addr vtep_ip
;
5034 json_object
*json
= NULL
;
5036 bgp
= bgp_get_evpn();
5040 /* check if we need json output */
5041 uj
= use_json(argc
, argv
);
5043 json
= json_object_new_object();
5045 if (!argv_find(argv
, argc
, "evpn", &idx
))
5050 vni
= strtoul(argv
[idx
+ 3]->arg
, NULL
, 10);
5052 if (bgp_evpn_cli_parse_type(&type
, argv
, argc
) < 0)
5055 if (argv_find(argv
, argc
, "vtep", &vtep_idx
)) {
5056 if (!inet_aton(argv
[vtep_idx
+ 1]->arg
, &vtep_ip
)) {
5057 vty_out(vty
, "%% Malformed VTEP IP address\n");
5062 evpn_show_routes_vni(vty
, bgp
, vni
, type
, false, vtep_ip
, json
);
5065 vty_json(vty
, json
);
5071 * Display per-VNI EVPN routing table for specific MACIP.
5073 DEFUN(show_bgp_l2vpn_evpn_route_vni_macip
,
5074 show_bgp_l2vpn_evpn_route_vni_macip_cmd
,
5075 "show bgp l2vpn evpn route vni " CMD_VNI_RANGE
" mac WORD [ip WORD] [json]",
5081 "VXLAN Network Identifier\n"
5084 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
5086 "IP address (IPv4 or IPv6)\n"
5095 json_object
*json
= NULL
;
5097 bgp
= bgp_get_evpn();
5101 /* check if we need json output */
5102 uj
= use_json(argc
, argv
);
5104 json
= json_object_new_object();
5106 if (!argv_find(argv
, argc
, "evpn", &idx
))
5110 vni
= strtoul(argv
[idx
+ 3]->arg
, NULL
, 10);
5113 if (!prefix_str2mac(argv
[idx
+ 5]->arg
, &mac
)) {
5114 vty_out(vty
, "%% Malformed MAC address\n");
5119 memset(&ip
, 0, sizeof(ip
));
5120 if ((!uj
&& ((argc
== (idx
+ 1 + 7)) && argv
[idx
+ 7]->arg
!= NULL
))
5122 && ((argc
== (idx
+ 1 + 8)) && argv
[idx
+ 7]->arg
!= NULL
))) {
5123 if (str2ipaddr(argv
[idx
+ 7]->arg
, &ip
) != 0) {
5124 vty_out(vty
, "%% Malformed IP address\n");
5129 evpn_show_route_vni_macip(vty
, bgp
, vni
, &mac
, &ip
, json
);
5132 vty_json(vty
, json
);
5138 * Display per-VNI EVPN routing table for specific multicast IP (remote VTEP).
5140 DEFUN(show_bgp_l2vpn_evpn_route_vni_multicast
,
5141 show_bgp_l2vpn_evpn_route_vni_multicast_cmd
,
5142 "show bgp l2vpn evpn route vni " CMD_VNI_RANGE
" multicast A.B.C.D [json]",
5148 "VXLAN Network Identifier\n"
5150 EVPN_TYPE_3_HELP_STR
5151 "Originating Router IP address\n"
5157 struct in_addr orig_ip
;
5160 json_object
*json
= NULL
;
5162 bgp
= bgp_get_evpn();
5166 /* check if we need json output */
5167 uj
= use_json(argc
, argv
);
5169 json
= json_object_new_object();
5171 if (!argv_find(argv
, argc
, "evpn", &idx
))
5175 vni
= strtoul(argv
[idx
+ 3]->arg
, NULL
, 10);
5178 ret
= inet_aton(argv
[idx
+ 5]->arg
, &orig_ip
);
5180 vty_out(vty
, "%% Malformed Originating Router IP address\n");
5184 evpn_show_route_vni_multicast(vty
, bgp
, vni
, orig_ip
, json
);
5187 vty_json(vty
, json
);
5193 * Display per-VNI EVPN routing table - for all VNIs.
5195 DEFUN(show_bgp_l2vpn_evpn_route_vni_all
,
5196 show_bgp_l2vpn_evpn_route_vni_all_cmd
,
5197 "show bgp l2vpn evpn route vni all [detail] [vtep A.B.C.D] [json]",
5203 "VXLAN Network Identifier\n"
5205 "Print Detailed Output\n"
5207 "Remote VTEP IP address\n"
5211 struct in_addr vtep_ip
;
5214 json_object
*json
= NULL
;
5215 /* Detail Adjust. Adjust indexes according to detail option */
5218 bgp
= bgp_get_evpn();
5222 /* check if we need json output */
5223 uj
= use_json(argc
, argv
);
5225 json
= json_object_new_object();
5227 if (!argv_find(argv
, argc
, "evpn", &idx
))
5230 if (argv_find(argv
, argc
, "detail", &da
))
5233 /* vtep-ip position depends on detail option */
5235 if ((!uj
&& (argc
== (idx
+ 1 + 5 + da
) && argv
[idx
+ 5 + da
]->arg
))
5237 && (argc
== (idx
+ 1 + 6 + da
) && argv
[idx
+ 5 + da
]->arg
))) {
5238 if (!inet_aton(argv
[idx
+ 5 + da
]->arg
, &vtep_ip
)) {
5239 vty_out(vty
, "%% Malformed VTEP IP address\n");
5244 evpn_show_routes_vni_all(vty
, bgp
, 0, false, vtep_ip
, json
, da
);
5247 vty_json(vty
, json
);
5248 json_object_free(json
);
5255 * Display per-VNI EVPN ALL routing tables - for all VNIs.
5257 DEFPY(show_bgp_vni_all
,
5258 show_bgp_vni_all_cmd
,
5259 "show bgp vni all [vtep A.B.C.D$addr] [detail$detail] [json$uj]",
5270 json_object
*json
= NULL
;
5272 bgp
= bgp_get_evpn();
5276 /* check if we need json output */
5278 json
= json_object_new_object();
5280 evpn_show_routes_vni_all_type_all(vty
, bgp
, addr
, json
, !!detail
);
5283 vty_json(vty
, json
);
5289 * Display per-VNI EVPN EAD routing table - for all VNIs.
5291 DEFPY(show_bgp_vni_all_ead
,
5292 show_bgp_vni_all_ead_cmd
,
5293 "show bgp vni all type <1|ead> [vtep A.B.C.D$addr] [<detail$detail|json$uj>]",
5299 EVPN_TYPE_1_HELP_STR
5300 EVPN_TYPE_1_HELP_STR
5307 json_object
*json
= NULL
;
5309 bgp
= bgp_get_evpn();
5313 /* check if we need json output */
5315 json
= json_object_new_object();
5317 evpn_show_routes_vni_all(vty
, bgp
, BGP_EVPN_AD_ROUTE
, false, addr
, json
,
5321 vty_json(vty
, json
);
5327 * Display per-VNI EVPN MAC routing table - for all VNIs.
5329 DEFPY(show_bgp_vni_all_macip_mac
,
5330 show_bgp_vni_all_macip_mac_cmd
,
5331 "show bgp vni all type <2|macip> mac [vtep A.B.C.D$addr] [<detail$detail|json$uj>]",
5337 EVPN_TYPE_2_HELP_STR
5338 EVPN_TYPE_2_HELP_STR
5346 json_object
*json
= NULL
;
5348 bgp
= bgp_get_evpn();
5352 /* check if we need json output */
5354 json
= json_object_new_object();
5356 evpn_show_routes_vni_all(vty
, bgp
, BGP_EVPN_MAC_IP_ROUTE
, true, addr
,
5360 vty_json(vty
, json
);
5366 * Display per-VNI EVPN IP routing table - for all VNIs.
5368 DEFPY(show_bgp_vni_all_macip_ip
,
5369 show_bgp_vni_all_macip_ip_cmd
,
5370 "show bgp vni all type <2|macip> ip [vtep A.B.C.D$addr] [<detail$detail|json$uj>]",
5376 EVPN_TYPE_2_HELP_STR
5377 EVPN_TYPE_2_HELP_STR
5385 json_object
*json
= NULL
;
5387 bgp
= bgp_get_evpn();
5391 /* check if we need json output */
5393 json
= json_object_new_object();
5395 evpn_show_routes_vni_all(vty
, bgp
, BGP_EVPN_MAC_IP_ROUTE
, false, addr
,
5399 vty_json(vty
, json
);
5405 * Display per-VNI EVPN Multicast routing table - for all VNIs.
5407 DEFPY(show_bgp_vni_all_imet
,
5408 show_bgp_vni_all_imet_cmd
,
5409 "show bgp vni all type <3|multicast> [vtep A.B.C.D$addr] [<detail$detail|json$uj>]",
5415 EVPN_TYPE_3_HELP_STR
5416 EVPN_TYPE_3_HELP_STR
5423 json_object
*json
= NULL
;
5425 bgp
= bgp_get_evpn();
5429 /* check if we need json output */
5431 json
= json_object_new_object();
5433 evpn_show_routes_vni_all(vty
, bgp
, BGP_EVPN_IMET_ROUTE
, false, addr
,
5437 vty_json(vty
, json
);
5443 * Display per-VNI EVPN ALL routing tables - for select VNI
5447 "show bgp vni "CMD_VNI_RANGE
"$vni [vtep A.B.C.D$addr] [json$uj]",
5457 json_object
*json
= NULL
;
5458 json_object
*json_mac
= NULL
;
5460 bgp
= bgp_get_evpn();
5464 /* check if we need json output */
5466 json
= json_object_new_object();
5467 json_mac
= json_object_new_object();
5470 evpn_show_routes_vni(vty
, bgp
, vni
, 0, false, addr
, json
);
5473 vty_out(vty
, "\n\nMAC Table:\n\n");
5475 evpn_show_routes_vni(vty
, bgp
, vni
, 0, true, addr
, json_mac
);
5478 json_object_object_add(json
, "macTable", json_mac
);
5479 vty_json(vty
, json
);
5486 * Display per-VNI EVPN EAD routing table - for select VNI
5488 DEFPY(show_bgp_vni_ead
,
5489 show_bgp_vni_ead_cmd
,
5490 "show bgp vni "CMD_VNI_RANGE
"$vni type <1|ead> [vtep A.B.C.D$addr] [json$uj]",
5496 EVPN_TYPE_1_HELP_STR
5497 EVPN_TYPE_1_HELP_STR
5503 json_object
*json
= NULL
;
5505 bgp
= bgp_get_evpn();
5509 /* check if we need json output */
5511 json
= json_object_new_object();
5513 evpn_show_routes_vni(vty
, bgp
, vni
, BGP_EVPN_AD_ROUTE
, false, addr
,
5517 vty_json(vty
, json
);
5523 * Display per-VNI EVPN MAC-IP MAC routing table - for select VNI
5525 DEFPY(show_bgp_vni_macip_mac
,
5526 show_bgp_vni_macip_mac_cmd
,
5527 "show bgp vni "CMD_VNI_RANGE
"$vni type <2|macip> mac [vtep A.B.C.D$addr] [json$uj]",
5533 EVPN_TYPE_2_HELP_STR
5534 EVPN_TYPE_2_HELP_STR
5541 json_object
*json
= NULL
;
5543 bgp
= bgp_get_evpn();
5547 /* check if we need json output */
5549 json
= json_object_new_object();
5551 evpn_show_routes_vni(vty
, bgp
, vni
, BGP_EVPN_MAC_IP_ROUTE
, true, addr
,
5555 vty_json(vty
, json
);
5561 * Display per-VNI EVPN MAC-IP IP routing table - for select VNI
5563 DEFPY(show_bgp_vni_macip_ip
,
5564 show_bgp_vni_macip_ip_cmd
,
5565 "show bgp vni "CMD_VNI_RANGE
"$vni type <2|macip> ip [vtep A.B.C.D$addr] [json$uj]",
5571 EVPN_TYPE_2_HELP_STR
5572 EVPN_TYPE_2_HELP_STR
5579 json_object
*json
= NULL
;
5581 bgp
= bgp_get_evpn();
5585 /* check if we need json output */
5587 json
= json_object_new_object();
5589 evpn_show_routes_vni(vty
, bgp
, vni
, BGP_EVPN_MAC_IP_ROUTE
, false, addr
,
5593 vty_json(vty
, json
);
5599 * Display per-VNI EVPN Multicast routing table - for select VNI
5601 DEFPY(show_bgp_vni_imet
,
5602 show_bgp_vni_imet_cmd
,
5603 "show bgp vni "CMD_VNI_RANGE
"$vni type <3|multicast> [vtep A.B.C.D$addr] [json$uj]",
5609 EVPN_TYPE_3_HELP_STR
5610 EVPN_TYPE_3_HELP_STR
5616 json_object
*json
= NULL
;
5618 bgp
= bgp_get_evpn();
5622 /* check if we need json output */
5624 json
= json_object_new_object();
5626 evpn_show_routes_vni(vty
, bgp
, vni
, BGP_EVPN_IMET_ROUTE
, false, addr
,
5630 vty_json(vty
, json
);
5636 * Display per-VNI EVPN MACIP MAC routing table - for select VNI & MAC
5638 DEFPY(show_bgp_vni_macip_mac_addr
,
5639 show_bgp_vni_macip_mac_addr_cmd
,
5640 "show bgp vni "CMD_VNI_RANGE
"$vni type <2|macip> mac X:X:X:X:X:X [json$uj]",
5646 EVPN_TYPE_2_HELP_STR
5647 EVPN_TYPE_2_HELP_STR
5653 json_object
*json
= NULL
;
5655 bgp
= bgp_get_evpn();
5659 /* check if we need json output */
5661 json
= json_object_new_object();
5663 evpn_show_route_vni_macip(vty
, bgp
, vni
, &mac
->eth_addr
, NULL
, json
);
5666 vty_json(vty
, json
);
5672 * Display per-VNI EVPN MACIP IP routing table - for select VNI & IP
5674 DEFPY(show_bgp_vni_macip_ip_addr
, show_bgp_vni_macip_ip_addr_cmd
,
5675 "show bgp vni " CMD_VNI_RANGE
5676 "$vni type <2|macip> ip <A.B.C.D|X:X::X:X> [json$uj]",
5677 SHOW_STR BGP_STR VNI_HELP_STR VNI_NUM_HELP_STR EVPN_TYPE_HELP_STR
5678 EVPN_TYPE_2_HELP_STR EVPN_TYPE_2_HELP_STR
5679 "IP Table\n" IP_ADDR_STR IP6_ADDR_STR JSON_STR
)
5682 json_object
*json
= NULL
;
5683 struct ipaddr ip_addr
= {.ipa_type
= IPADDR_NONE
};
5685 bgp
= bgp_get_evpn();
5689 /* check if we need json output */
5691 json
= json_object_new_object();
5693 if (sockunion_family(ip
) == AF_INET
) {
5694 ip_addr
.ipa_type
= IPADDR_V4
;
5695 ip_addr
.ipaddr_v4
.s_addr
= sockunion2ip(ip
);
5697 ip_addr
.ipa_type
= IPADDR_V6
;
5698 memcpy(&ip_addr
.ipaddr_v6
, &ip
->sin6
.sin6_addr
,
5699 sizeof(struct in6_addr
));
5701 evpn_show_route_vni_macip(vty
, bgp
, vni
, NULL
, &ip_addr
, json
);
5704 vty_json(vty
, json
);
5710 show_bgp_l2vpn_evpn_route_mac_ip_evi_es
,
5711 show_bgp_l2vpn_evpn_route_mac_ip_evi_es_cmd
,
5712 "show bgp l2vpn evpn route mac-ip-evi-es [NAME$esi_str|detail$detail] [json$uj]",
5713 SHOW_STR BGP_STR L2VPN_HELP_STR EVPN_HELP_STR
5714 "EVPN route information\n"
5715 "MAC IP routes in the EVI tables linked to the ES\n"
5717 "Detailed information\n" JSON_STR
)
5721 json_object
*json
= NULL
;
5724 if (!str_to_esi(esi_str
, &esi
)) {
5725 vty_out(vty
, "%% Malformed ESI\n");
5734 json
= json_object_new_object();
5735 bgp_evpn_show_routes_mac_ip_evi_es(vty
, esi_p
, json
, !!detail
);
5737 vty_json(vty
, json
);
5743 show_bgp_l2vpn_evpn_route_mac_ip_global_es
,
5744 show_bgp_l2vpn_evpn_route_mac_ip_global_es_cmd
,
5745 "show bgp l2vpn evpn route mac-ip-global-es [NAME$esi_str|detail$detail] [json$uj]",
5746 SHOW_STR BGP_STR L2VPN_HELP_STR EVPN_HELP_STR
5747 "EVPN route information\n"
5748 "MAC IP routes in the global table linked to the ES\n"
5750 "Detailed information\n" JSON_STR
)
5754 json_object
*json
= NULL
;
5757 if (!str_to_esi(esi_str
, &esi
)) {
5758 vty_out(vty
, "%% Malformed ESI\n");
5767 json
= json_object_new_object();
5768 bgp_evpn_show_routes_mac_ip_global_es(vty
, esi_p
, json
, !!detail
);
5770 vty_json(vty
, json
);
5776 * Display EVPN import route-target hash table
5778 DEFUN(show_bgp_l2vpn_evpn_vrf_import_rt
,
5779 show_bgp_l2vpn_evpn_vrf_import_rt_cmd
,
5780 "show bgp l2vpn evpn vrf-import-rt [json]",
5785 "Show vrf import route target\n"
5789 struct bgp
*bgp_evpn
= NULL
;
5790 json_object
*json
= NULL
;
5792 bgp_evpn
= bgp_get_evpn();
5796 uj
= use_json(argc
, argv
);
5798 json
= json_object_new_object();
5800 evpn_show_vrf_import_rts(vty
, bgp_evpn
, json
);
5803 vty_json(vty
, json
);
5809 * Display EVPN import route-target hash table
5811 DEFUN(show_bgp_l2vpn_evpn_import_rt
,
5812 show_bgp_l2vpn_evpn_import_rt_cmd
,
5813 "show bgp l2vpn evpn import-rt [json]",
5818 "Show import route target\n"
5823 json_object
*json
= NULL
;
5825 bgp
= bgp_get_evpn();
5829 uj
= use_json(argc
, argv
);
5831 json
= json_object_new_object();
5833 evpn_show_import_rts(vty
, bgp
, json
);
5836 vty_json(vty
, json
);
5841 DEFPY_HIDDEN(test_es_add
,
5843 "[no$no] test es NAME$esi_str [state NAME$state_str]",
5846 "Ethernet-segment\n"
5847 "Ethernet-Segment Identifier\n"
5855 struct in_addr vtep_ip
;
5858 bgp
= bgp_get_evpn();
5860 vty_out(vty
, "%% EVPN BGP instance not yet created\n");
5864 if (!str_to_esi(esi_str
, &esi
)) {
5865 vty_out(vty
, "%% Malformed ESI\n");
5870 ret
= bgp_evpn_local_es_del(bgp
, &esi
);
5872 vty_out(vty
, "%% Failed to delete ES\n");
5876 if (state_str
&& !strcmp(state_str
, "up"))
5880 vtep_ip
= bgp
->router_id
;
5882 ret
= bgp_evpn_local_es_add(bgp
, &esi
, vtep_ip
, oper_up
,
5883 EVPN_MH_DF_PREF_MIN
, false);
5885 vty_out(vty
, "%% Failed to add ES\n");
5892 DEFPY_HIDDEN(test_es_vni_add
,
5893 test_es_vni_add_cmd
,
5894 "[no$no] test es NAME$esi_str vni (1-16777215)$vni",
5897 "Ethernet-segment\n"
5898 "Ethernet-Segment Identifier\n"
5907 bgp
= bgp_get_evpn();
5909 vty_out(vty
, "%% EVPN BGP instance not yet created\n");
5913 if (!str_to_esi(esi_str
, &esi
)) {
5914 vty_out(vty
, "%% Malformed ESI\n");
5919 ret
= bgp_evpn_local_es_evi_del(bgp
, &esi
, vni
);
5921 vty_out(vty
, "%% Failed to deref ES VNI\n");
5925 ret
= bgp_evpn_local_es_evi_add(bgp
, &esi
, vni
);
5927 vty_out(vty
, "%% Failed to ref ES VNI\n");
5934 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_vni
, show_bgp_evpn_vni_cmd
,
5935 "show bgp evpn vni [" CMD_VNI_RANGE
"]", SHOW_STR BGP_STR EVPN_HELP_STR
5939 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_summary
, show_bgp_evpn_summary_cmd
,
5940 "show bgp evpn summary [json]", SHOW_STR BGP_STR EVPN_HELP_STR
5941 "Summary of BGP neighbor status\n" JSON_STR
)
5943 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route
, show_bgp_evpn_route_cmd
,
5944 "show bgp evpn route [detail] [type <macip|2|multicast|3>]",
5945 SHOW_STR BGP_STR EVPN_HELP_STR
5947 "Display Detailed Information\n"
5949 EVPN_TYPE_2_HELP_STR
5950 EVPN_TYPE_2_HELP_STR
5951 EVPN_TYPE_3_HELP_STR
5952 EVPN_TYPE_3_HELP_STR
)
5955 show_bgp_l2vpn_evpn_route_rd
, show_bgp_evpn_route_rd_cmd
,
5956 "show bgp evpn route rd ASN:NN_OR_IP-ADDRESS:NN [type <macip|2|multicast|3>]",
5957 SHOW_STR BGP_STR EVPN_HELP_STR
5959 EVPN_RT_DIST_HELP_STR
5960 EVPN_ASN_IP_HELP_STR
5962 EVPN_TYPE_2_HELP_STR
5963 EVPN_TYPE_2_HELP_STR
5964 EVPN_TYPE_3_HELP_STR
5965 EVPN_TYPE_3_HELP_STR
)
5968 show_bgp_l2vpn_evpn_route_rd_macip
, show_bgp_evpn_route_rd_macip_cmd
,
5969 "show bgp evpn route rd ASN:NN_OR_IP-ADDRESS:NN mac WORD [ip WORD]",
5970 SHOW_STR BGP_STR EVPN_HELP_STR
5972 EVPN_RT_DIST_HELP_STR
5973 EVPN_ASN_IP_HELP_STR
5975 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
5977 "IP address (IPv4 or IPv6)\n")
5980 show_bgp_l2vpn_evpn_route_vni
, show_bgp_evpn_route_vni_cmd
,
5981 "show bgp evpn route vni " CMD_VNI_RANGE
" [<type <macip|2|multicast|3> | vtep A.B.C.D>]",
5982 SHOW_STR BGP_STR EVPN_HELP_STR
5984 "VXLAN Network Identifier\n"
5987 EVPN_TYPE_2_HELP_STR
5988 EVPN_TYPE_2_HELP_STR
5989 EVPN_TYPE_3_HELP_STR
5990 EVPN_TYPE_3_HELP_STR
5992 "Remote VTEP IP address\n")
5994 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_macip
,
5995 show_bgp_evpn_route_vni_macip_cmd
,
5996 "show bgp evpn route vni " CMD_VNI_RANGE
" mac WORD [ip WORD]",
5997 SHOW_STR BGP_STR EVPN_HELP_STR
5999 "VXLAN Network Identifier\n"
6002 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
6004 "IP address (IPv4 or IPv6)\n")
6006 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_multicast
,
6007 show_bgp_evpn_route_vni_multicast_cmd
,
6008 "show bgp evpn route vni " CMD_VNI_RANGE
" multicast A.B.C.D",
6009 SHOW_STR BGP_STR EVPN_HELP_STR
6011 "VXLAN Network Identifier\n"
6013 EVPN_TYPE_3_HELP_STR
6014 "Originating Router IP address\n")
6016 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_all
, show_bgp_evpn_route_vni_all_cmd
,
6017 "show bgp evpn route vni all [detail] [vtep A.B.C.D]",
6018 SHOW_STR BGP_STR EVPN_HELP_STR
6020 "VXLAN Network Identifier\n"
6022 "Print Detailed Output\n"
6024 "Remote VTEP IP address\n")
6026 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_import_rt
, show_bgp_evpn_import_rt_cmd
,
6027 "show bgp evpn import-rt",
6028 SHOW_STR BGP_STR EVPN_HELP_STR
"Show import route target\n")
6030 DEFUN_NOSH (bgp_evpn_vni
,
6032 "vni " CMD_VNI_RANGE
,
6033 "VXLAN Network Identifier\n"
6037 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6038 struct bgpevpn
*vpn
;
6043 vni
= strtoul(argv
[1]->arg
, NULL
, 10);
6045 /* Create VNI, or mark as configured. */
6046 vpn
= evpn_create_update_vni(bgp
, vni
);
6048 vty_out(vty
, "%% Failed to create VNI \n");
6052 VTY_PUSH_CONTEXT_SUB(BGP_EVPN_VNI_NODE
, vpn
);
6056 DEFUN (no_bgp_evpn_vni
,
6057 no_bgp_evpn_vni_cmd
,
6058 "no vni " CMD_VNI_RANGE
,
6060 "VXLAN Network Identifier\n"
6064 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6065 struct bgpevpn
*vpn
;
6070 vni
= strtoul(argv
[2]->arg
, NULL
, 10);
6072 /* Check if we should disallow. */
6073 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
6075 vty_out(vty
, "%% Specified VNI does not exist\n");
6078 if (!is_vni_configured(vpn
)) {
6079 vty_out(vty
, "%% Specified VNI is not configured\n");
6083 evpn_delete_vni(bgp
, vpn
);
6087 DEFUN_NOSH (exit_vni
,
6090 "Exit from VNI mode\n")
6092 if (vty
->node
== BGP_EVPN_VNI_NODE
)
6093 vty
->node
= BGP_EVPN_NODE
;
6097 DEFUN (bgp_evpn_vrf_rd
,
6098 bgp_evpn_vrf_rd_cmd
,
6099 "rd ASN:NN_OR_IP-ADDRESS:NN",
6100 EVPN_RT_DIST_HELP_STR
6101 EVPN_ASN_IP_HELP_STR
)
6104 struct prefix_rd prd
;
6105 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
6110 ret
= str2prefix_rd(argv
[1]->arg
, &prd
);
6112 vty_out(vty
, "%% Malformed Route Distinguisher\n");
6116 /* If same as existing value, there is nothing more to do. */
6117 if (bgp_evpn_vrf_rd_matches_existing(bgp_vrf
, &prd
))
6120 /* Configure or update the RD. */
6121 evpn_configure_vrf_rd(bgp_vrf
, &prd
);
6125 DEFUN (no_bgp_evpn_vrf_rd
,
6126 no_bgp_evpn_vrf_rd_cmd
,
6127 "no rd ASN:NN_OR_IP-ADDRESS:NN",
6129 EVPN_RT_DIST_HELP_STR
6130 EVPN_ASN_IP_HELP_STR
)
6133 struct prefix_rd prd
;
6134 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
6139 ret
= str2prefix_rd(argv
[2]->arg
, &prd
);
6141 vty_out(vty
, "%% Malformed Route Distinguisher\n");
6145 /* Check if we should disallow. */
6146 if (!is_vrf_rd_configured(bgp_vrf
)) {
6147 vty_out(vty
, "%% RD is not configured for this VRF\n");
6151 if (!bgp_evpn_vrf_rd_matches_existing(bgp_vrf
, &prd
)) {
6153 "%% RD specified does not match configuration for this VRF\n");
6157 evpn_unconfigure_vrf_rd(bgp_vrf
);
6161 DEFUN (no_bgp_evpn_vrf_rd_without_val
,
6162 no_bgp_evpn_vrf_rd_without_val_cmd
,
6165 EVPN_RT_DIST_HELP_STR
)
6167 struct bgp
*bgp_vrf
= VTY_GET_CONTEXT(bgp
);
6172 /* Check if we should disallow. */
6173 if (!is_vrf_rd_configured(bgp_vrf
)) {
6174 vty_out(vty
, "%% RD is not configured for this VRF\n");
6178 evpn_unconfigure_vrf_rd(bgp_vrf
);
6182 DEFUN (bgp_evpn_vni_rd
,
6183 bgp_evpn_vni_rd_cmd
,
6184 "rd ASN:NN_OR_IP-ADDRESS:NN",
6185 EVPN_RT_DIST_HELP_STR
6186 EVPN_ASN_IP_HELP_STR
)
6188 struct prefix_rd prd
;
6189 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6190 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
6196 if (!EVPN_ENABLED(bgp
)) {
6198 "This command is only supported under EVPN VRF\n");
6202 ret
= str2prefix_rd(argv
[1]->arg
, &prd
);
6204 vty_out(vty
, "%% Malformed Route Distinguisher\n");
6208 /* If same as existing value, there is nothing more to do. */
6209 if (bgp_evpn_rd_matches_existing(vpn
, &prd
))
6212 /* Configure or update the RD. */
6213 evpn_configure_rd(bgp
, vpn
, &prd
);
6217 DEFUN (no_bgp_evpn_vni_rd
,
6218 no_bgp_evpn_vni_rd_cmd
,
6219 "no rd ASN:NN_OR_IP-ADDRESS:NN",
6221 EVPN_RT_DIST_HELP_STR
6222 EVPN_ASN_IP_HELP_STR
)
6224 struct prefix_rd prd
;
6225 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6226 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
6232 if (!EVPN_ENABLED(bgp
)) {
6234 "This command is only supported under EVPN VRF\n");
6238 ret
= str2prefix_rd(argv
[2]->arg
, &prd
);
6240 vty_out(vty
, "%% Malformed Route Distinguisher\n");
6244 /* Check if we should disallow. */
6245 if (!is_rd_configured(vpn
)) {
6246 vty_out(vty
, "%% RD is not configured for this VNI\n");
6250 if (!bgp_evpn_rd_matches_existing(vpn
, &prd
)) {
6252 "%% RD specified does not match configuration for this VNI\n");
6256 evpn_unconfigure_rd(bgp
, vpn
);
6260 DEFUN (no_bgp_evpn_vni_rd_without_val
,
6261 no_bgp_evpn_vni_rd_without_val_cmd
,
6264 EVPN_RT_DIST_HELP_STR
)
6266 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6267 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
6272 if (!EVPN_ENABLED(bgp
)) {
6274 "This command is only supported under EVPN VRF\n");
6278 /* Check if we should disallow. */
6279 if (!is_rd_configured(vpn
)) {
6280 vty_out(vty
, "%% RD is not configured for this VNI\n");
6284 evpn_unconfigure_rd(bgp
, vpn
);
6289 * Loop over all extended-communities in the route-target list rtl and
6290 * return 1 if we find ecomtarget
6292 static bool bgp_evpn_rt_matches_existing(struct list
*rtl
,
6293 struct ecommunity
*ecomtarget
)
6295 struct listnode
*node
;
6296 struct ecommunity
*ecom
;
6298 for (ALL_LIST_ELEMENTS_RO(rtl
, node
, ecom
)) {
6299 if (ecommunity_match(ecom
, ecomtarget
))
6307 * L3 RT version of above.
6309 static bool bgp_evpn_vrf_rt_matches_existing(struct list
*rtl
,
6310 struct ecommunity
*ecomtarget
)
6312 struct listnode
*node
;
6313 struct vrf_route_target
*l3rt
;
6315 for (ALL_LIST_ELEMENTS_RO(rtl
, node
, l3rt
)) {
6316 if (ecommunity_match(l3rt
->ecom
, ecomtarget
))
6323 /* display L3VNI related info for a VRF instance */
6324 DEFUN (show_bgp_vrf_l3vni_info
,
6325 show_bgp_vrf_l3vni_info_cmd
,
6326 "show bgp vrf VRFNAME vni [json]",
6334 char buf
[ETHER_ADDR_STRLEN
];
6336 const char *name
= NULL
;
6337 struct bgp
*bgp
= NULL
;
6338 struct listnode
*node
= NULL
;
6339 struct bgpevpn
*vpn
= NULL
;
6340 struct vrf_route_target
*l3rt
;
6341 json_object
*json
= NULL
;
6342 json_object
*json_vnis
= NULL
;
6343 json_object
*json_export_rts
= NULL
;
6344 json_object
*json_import_rts
= NULL
;
6345 bool uj
= use_json(argc
, argv
);
6348 json
= json_object_new_object();
6349 json_vnis
= json_object_new_array();
6350 json_export_rts
= json_object_new_array();
6351 json_import_rts
= json_object_new_array();
6354 name
= argv
[idx_vrf
]->arg
;
6355 bgp
= bgp_lookup_by_name(name
);
6356 if (strmatch(name
, VRF_DEFAULT_NAME
))
6357 bgp
= bgp_get_default();
6361 vty_out(vty
, "BGP instance for VRF %s not found\n",
6364 json_object_string_add(json
, "warning",
6365 "BGP instance not found");
6366 vty_out(vty
, "%s\n", json_object_to_json_string(json
));
6367 json_object_free(json
);
6373 vty_out(vty
, "BGP VRF: %s\n", name
);
6374 vty_out(vty
, " Local-Ip: %pI4\n", &bgp
->originator_ip
);
6375 vty_out(vty
, " L3-VNI: %u\n", bgp
->l3vni
);
6376 vty_out(vty
, " Rmac: %s\n",
6377 prefix_mac2str(&bgp
->rmac
, buf
, sizeof(buf
)));
6378 vty_out(vty
, " VNI Filter: %s\n",
6379 CHECK_FLAG(bgp
->vrf_flags
,
6380 BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)
6381 ? "prefix-routes-only"
6383 vty_out(vty
, " L2-VNI List:\n");
6385 for (ALL_LIST_ELEMENTS_RO(bgp
->l2vnis
, node
, vpn
))
6386 vty_out(vty
, "%u ", vpn
->vni
);
6388 vty_out(vty
, " Export-RTs:\n");
6390 for (ALL_LIST_ELEMENTS_RO(bgp
->vrf_export_rtl
, node
, l3rt
))
6391 vty_out(vty
, "%s ", ecommunity_str(l3rt
->ecom
));
6393 vty_out(vty
, " Import-RTs:\n");
6395 for (ALL_LIST_ELEMENTS_RO(bgp
->vrf_import_rtl
, node
, l3rt
))
6396 vty_out(vty
, "%s ", ecommunity_str(l3rt
->ecom
));
6398 vty_out(vty
, " RD: %pRD\n", &bgp
->vrf_prd
);
6400 json_object_string_add(json
, "vrf", name
);
6401 json_object_string_addf(json
, "local-ip", "%pI4",
6402 &bgp
->originator_ip
);
6403 json_object_int_add(json
, "l3vni", bgp
->l3vni
);
6404 json_object_string_add(
6406 prefix_mac2str(&bgp
->rmac
, buf
, sizeof(buf
)));
6407 json_object_string_add(
6409 CHECK_FLAG(bgp
->vrf_flags
,
6410 BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)
6411 ? "prefix-routes-only"
6413 /* list of l2vnis */
6414 for (ALL_LIST_ELEMENTS_RO(bgp
->l2vnis
, node
, vpn
))
6415 json_object_array_add(json_vnis
,
6416 json_object_new_int(vpn
->vni
));
6417 json_object_object_add(json
, "l2vnis", json_vnis
);
6420 for (ALL_LIST_ELEMENTS_RO(bgp
->vrf_export_rtl
, node
, l3rt
))
6421 json_object_array_add(
6423 json_object_new_string(
6424 ecommunity_str(l3rt
->ecom
)));
6425 json_object_object_add(json
, "export-rts", json_export_rts
);
6428 for (ALL_LIST_ELEMENTS_RO(bgp
->vrf_import_rtl
, node
, l3rt
))
6429 json_object_array_add(
6431 json_object_new_string(
6432 ecommunity_str(l3rt
->ecom
)));
6433 json_object_object_add(json
, "import-rts", json_import_rts
);
6434 json_object_string_addf(json
, "rd", "%pRD", &bgp
->vrf_prd
);
6438 vty_json(vty
, json
);
6442 static int add_rt(struct bgp
*bgp
, struct ecommunity
*ecom
, bool is_import
,
6445 /* Do nothing if we already have this route-target */
6447 if (!bgp_evpn_vrf_rt_matches_existing(bgp
->vrf_import_rtl
,
6449 bgp_evpn_configure_import_rt_for_vrf(bgp
, ecom
,
6454 if (!bgp_evpn_vrf_rt_matches_existing(bgp
->vrf_export_rtl
,
6456 bgp_evpn_configure_export_rt_for_vrf(bgp
, ecom
);
6464 static int del_rt(struct bgp
*bgp
, struct ecommunity
*ecom
, bool is_import
)
6466 /* Verify we already have this route-target */
6468 if (!bgp_evpn_vrf_rt_matches_existing(bgp
->vrf_import_rtl
,
6472 bgp_evpn_unconfigure_import_rt_for_vrf(bgp
, ecom
);
6474 if (!bgp_evpn_vrf_rt_matches_existing(bgp
->vrf_export_rtl
,
6478 bgp_evpn_unconfigure_export_rt_for_vrf(bgp
, ecom
);
6484 static int parse_rtlist(struct bgp
*bgp
, struct vty
*vty
, int argc
,
6485 struct cmd_token
**argv
, int rt_idx
, bool is_add
,
6488 int ret
= CMD_SUCCESS
;
6489 bool is_wildcard
= false;
6490 struct ecommunity
*ecom
= NULL
;
6492 for (int i
= rt_idx
; i
< argc
; i
++) {
6493 is_wildcard
= false;
6496 * Special handling for wildcard '*' here.
6498 * Let's just convert it to 0 here so we dont have to modify
6499 * the ecommunity parser.
6501 if ((argv
[i
]->arg
)[0] == '*') {
6502 (argv
[i
]->arg
)[0] = '0';
6506 ecom
= ecommunity_str2com(argv
[i
]->arg
, ECOMMUNITY_ROUTE_TARGET
,
6509 /* Put it back as was */
6511 (argv
[i
]->arg
)[0] = '*';
6514 vty_out(vty
, "%% Malformed Route Target list\n");
6519 ecommunity_str(ecom
);
6522 if (add_rt(bgp
, ecom
, is_import
, is_wildcard
) != 0) {
6524 "%% RT specified already configured for this VRF: %s\n",
6526 ecommunity_free(&ecom
);
6531 if (del_rt(bgp
, ecom
, is_import
) != 0) {
6533 "%% RT specified does not match configuration for this VRF: %s\n",
6538 ecommunity_free(&ecom
);
6545 /* import/export rt for l3vni-vrf */
6546 DEFUN (bgp_evpn_vrf_rt
,
6547 bgp_evpn_vrf_rt_cmd
,
6548 "route-target <both|import|export> RTLIST...",
6550 "import and export\n"
6553 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN|*:OPQR|*:MN)\n")
6555 int ret
= CMD_SUCCESS
;
6556 int tmp_ret
= CMD_SUCCESS
;
6558 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6561 return CMD_WARNING_CONFIG_FAILED
;
6563 if (!strcmp(argv
[1]->arg
, "import"))
6564 rt_type
= RT_TYPE_IMPORT
;
6565 else if (!strcmp(argv
[1]->arg
, "export"))
6566 rt_type
= RT_TYPE_EXPORT
;
6567 else if (!strcmp(argv
[1]->arg
, "both"))
6568 rt_type
= RT_TYPE_BOTH
;
6570 vty_out(vty
, "%% Invalid Route Target type\n");
6571 return CMD_WARNING_CONFIG_FAILED
;
6574 if (strmatch(argv
[2]->arg
, "auto")) {
6575 vty_out(vty
, "%% `auto` cannot be configured via list\n");
6576 return CMD_WARNING_CONFIG_FAILED
;
6579 if (rt_type
!= RT_TYPE_IMPORT
) {
6580 for (int i
= 2; i
< argc
; i
++) {
6581 if ((argv
[i
]->arg
)[0] == '*') {
6583 "%% Wildcard '*' only applicable for import\n");
6584 return CMD_WARNING_CONFIG_FAILED
;
6589 /* Add/update the import route-target */
6590 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_IMPORT
)
6591 tmp_ret
= parse_rtlist(bgp
, vty
, argc
, argv
, 2, true, true);
6593 if (ret
== CMD_SUCCESS
&& tmp_ret
!= CMD_SUCCESS
)
6596 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_EXPORT
)
6597 tmp_ret
= parse_rtlist(bgp
, vty
, argc
, argv
, 2, true, false);
6599 if (ret
== CMD_SUCCESS
&& tmp_ret
!= CMD_SUCCESS
)
6605 DEFPY (bgp_evpn_vrf_rt_auto
,
6606 bgp_evpn_vrf_rt_auto_cmd
,
6607 "route-target <both|import|export>$type auto",
6609 "import and export\n"
6612 "Automatically derive route target\n")
6614 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6618 return CMD_WARNING_CONFIG_FAILED
;
6620 if (strmatch(type
, "import"))
6621 rt_type
= RT_TYPE_IMPORT
;
6622 else if (strmatch(type
, "export"))
6623 rt_type
= RT_TYPE_EXPORT
;
6624 else if (strmatch(type
, "both"))
6625 rt_type
= RT_TYPE_BOTH
;
6627 vty_out(vty
, "%% Invalid Route Target type\n");
6628 return CMD_WARNING_CONFIG_FAILED
;
6631 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_IMPORT
)
6632 bgp_evpn_configure_import_auto_rt_for_vrf(bgp
);
6634 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_EXPORT
)
6635 bgp_evpn_configure_export_auto_rt_for_vrf(bgp
);
6640 DEFUN (no_bgp_evpn_vrf_rt
,
6641 no_bgp_evpn_vrf_rt_cmd
,
6642 "no route-target <both|import|export> RTLIST...",
6645 "import and export\n"
6648 "Space separated route target list (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6650 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6651 int ret
= CMD_SUCCESS
;
6652 int tmp_ret
= CMD_SUCCESS
;
6656 return CMD_WARNING_CONFIG_FAILED
;
6658 if (!strcmp(argv
[2]->arg
, "import"))
6659 rt_type
= RT_TYPE_IMPORT
;
6660 else if (!strcmp(argv
[2]->arg
, "export"))
6661 rt_type
= RT_TYPE_EXPORT
;
6662 else if (!strcmp(argv
[2]->arg
, "both"))
6663 rt_type
= RT_TYPE_BOTH
;
6665 vty_out(vty
, "%% Invalid Route Target type\n");
6666 return CMD_WARNING_CONFIG_FAILED
;
6669 if (!strcmp(argv
[3]->arg
, "auto")) {
6670 vty_out(vty
, "%% `auto` cannot be unconfigured via list\n");
6671 return CMD_WARNING_CONFIG_FAILED
;
6674 if (rt_type
== RT_TYPE_IMPORT
) {
6675 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
)) {
6677 "%% Import RT is not configured for this VRF\n");
6678 return CMD_WARNING_CONFIG_FAILED
;
6680 } else if (rt_type
== RT_TYPE_EXPORT
) {
6681 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
)) {
6683 "%% Export RT is not configured for this VRF\n");
6684 return CMD_WARNING_CONFIG_FAILED
;
6686 } else if (rt_type
== RT_TYPE_BOTH
) {
6687 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
)
6688 && !CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
)) {
6690 "%% Import/Export RT is not configured for this VRF\n");
6691 return CMD_WARNING_CONFIG_FAILED
;
6695 if (rt_type
!= RT_TYPE_IMPORT
) {
6696 for (int i
= 3; i
< argc
; i
++) {
6697 if ((argv
[i
]->arg
)[0] == '*') {
6699 "%% Wildcard '*' only applicable for import\n");
6700 return CMD_WARNING_CONFIG_FAILED
;
6705 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_IMPORT
)
6706 tmp_ret
= parse_rtlist(bgp
, vty
, argc
, argv
, 3, false, true);
6708 if (ret
== CMD_SUCCESS
&& tmp_ret
!= CMD_SUCCESS
)
6711 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_EXPORT
)
6712 tmp_ret
= parse_rtlist(bgp
, vty
, argc
, argv
, 3, false, false);
6714 if (ret
== CMD_SUCCESS
&& tmp_ret
!= CMD_SUCCESS
)
6720 DEFPY (no_bgp_evpn_vrf_rt_auto
,
6721 no_bgp_evpn_vrf_rt_auto_cmd
,
6722 "no route-target <both|import|export>$type auto",
6725 "import and export\n"
6728 "Automatically derive route target\n")
6730 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6734 return CMD_WARNING_CONFIG_FAILED
;
6736 if (strmatch(type
, "import"))
6737 rt_type
= RT_TYPE_IMPORT
;
6738 else if (strmatch(type
, "export"))
6739 rt_type
= RT_TYPE_EXPORT
;
6740 else if (strmatch(type
, "both"))
6741 rt_type
= RT_TYPE_BOTH
;
6743 vty_out(vty
, "%% Invalid Route Target type\n");
6744 return CMD_WARNING_CONFIG_FAILED
;
6747 if (rt_type
== RT_TYPE_IMPORT
) {
6748 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_AUTO_RT_CFGD
)) {
6750 "%% Import AUTO RT is not configured for this VRF\n");
6751 return CMD_WARNING_CONFIG_FAILED
;
6753 } else if (rt_type
== RT_TYPE_EXPORT
) {
6754 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_AUTO_RT_CFGD
)) {
6756 "%% Export AUTO RT is not configured for this VRF\n");
6757 return CMD_WARNING_CONFIG_FAILED
;
6759 } else if (rt_type
== RT_TYPE_BOTH
) {
6760 if (!CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_AUTO_RT_CFGD
) &&
6761 !CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_AUTO_RT_CFGD
)) {
6763 "%% Import/Export AUTO RT is not configured for this VRF\n");
6764 return CMD_WARNING_CONFIG_FAILED
;
6768 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_IMPORT
)
6769 bgp_evpn_unconfigure_import_auto_rt_for_vrf(bgp
);
6771 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_EXPORT
)
6772 bgp_evpn_unconfigure_export_auto_rt_for_vrf(bgp
);
6777 DEFPY(bgp_evpn_ead_ess_frag_evi_limit
, bgp_evpn_ead_es_frag_evi_limit_cmd
,
6778 "[no$no] ead-es-frag evi-limit (1-1000)$limit",
6780 "EAD ES fragment config\n"
6781 "EVIs per-fragment\n"
6784 bgp_mh_info
->evi_per_es_frag
=
6785 no
? BGP_EVPN_MAX_EVI_PER_ES_FRAG
: limit
;
6790 DEFUN(bgp_evpn_ead_es_rt
, bgp_evpn_ead_es_rt_cmd
,
6791 "ead-es-route-target export RT",
6792 "EAD ES Route Target\n"
6794 "Route target (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6796 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6797 struct ecommunity
*ecomadd
= NULL
;
6802 if (!EVPN_ENABLED(bgp
)) {
6803 vty_out(vty
, "This command is only supported under EVPN VRF\n");
6807 /* Add/update the export route-target */
6808 ecomadd
= ecommunity_str2com(argv
[2]->arg
, ECOMMUNITY_ROUTE_TARGET
, 0);
6810 vty_out(vty
, "%% Malformed Route Target list\n");
6813 ecommunity_str(ecomadd
);
6815 /* Do nothing if we already have this export route-target */
6816 if (!bgp_evpn_rt_matches_existing(bgp_mh_info
->ead_es_export_rtl
,
6818 bgp_evpn_mh_config_ead_export_rt(bgp
, ecomadd
, false);
6823 DEFUN(no_bgp_evpn_ead_es_rt
, no_bgp_evpn_ead_es_rt_cmd
,
6824 "no ead-es-route-target export RT",
6826 "EAD ES Route Target\n"
6827 "export\n" EVPN_ASN_IP_HELP_STR
)
6829 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6830 struct ecommunity
*ecomdel
= NULL
;
6835 if (!EVPN_ENABLED(bgp
)) {
6836 vty_out(vty
, "This command is only supported under EVPN VRF\n");
6840 ecomdel
= ecommunity_str2com(argv
[3]->arg
, ECOMMUNITY_ROUTE_TARGET
, 0);
6842 vty_out(vty
, "%% Malformed Route Target list\n");
6845 ecommunity_str(ecomdel
);
6847 if (!bgp_evpn_rt_matches_existing(bgp_mh_info
->ead_es_export_rtl
,
6849 ecommunity_free(&ecomdel
);
6851 "%% RT specified does not match EAD-ES RT configuration\n");
6854 bgp_evpn_mh_config_ead_export_rt(bgp
, ecomdel
, true);
6859 DEFUN (bgp_evpn_vni_rt
,
6860 bgp_evpn_vni_rt_cmd
,
6861 "route-target <both|import|export> RT",
6863 "import and export\n"
6866 "Route target (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
6868 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6869 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
6871 struct ecommunity
*ecomadd
= NULL
;
6876 if (!EVPN_ENABLED(bgp
)) {
6878 "This command is only supported under EVPN VRF\n");
6882 if (!strcmp(argv
[1]->text
, "import"))
6883 rt_type
= RT_TYPE_IMPORT
;
6884 else if (!strcmp(argv
[1]->text
, "export"))
6885 rt_type
= RT_TYPE_EXPORT
;
6886 else if (!strcmp(argv
[1]->text
, "both"))
6887 rt_type
= RT_TYPE_BOTH
;
6889 vty_out(vty
, "%% Invalid Route Target type\n");
6893 ecomadd
= ecommunity_str2com(argv
[2]->arg
, ECOMMUNITY_ROUTE_TARGET
, 0);
6895 vty_out(vty
, "%% Malformed Route Target list\n");
6898 ecommunity_str(ecomadd
);
6900 /* Add/update the import route-target */
6901 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_IMPORT
) {
6902 /* Do nothing if we already have this import route-target */
6903 if (!bgp_evpn_rt_matches_existing(vpn
->import_rtl
, ecomadd
))
6904 evpn_configure_import_rt(bgp
, vpn
, ecomadd
);
6907 /* Add/update the export route-target */
6908 if (rt_type
== RT_TYPE_BOTH
|| rt_type
== RT_TYPE_EXPORT
) {
6909 /* Do nothing if we already have this export route-target */
6910 if (!bgp_evpn_rt_matches_existing(vpn
->export_rtl
, ecomadd
))
6911 evpn_configure_export_rt(bgp
, vpn
, ecomadd
);
6917 DEFUN (no_bgp_evpn_vni_rt
,
6918 no_bgp_evpn_vni_rt_cmd
,
6919 "no route-target <both|import|export> RT",
6922 "import and export\n"
6925 EVPN_ASN_IP_HELP_STR
)
6927 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
6928 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
6929 int rt_type
, found_ecomdel
;
6930 struct ecommunity
*ecomdel
= NULL
;
6935 if (!EVPN_ENABLED(bgp
)) {
6937 "This command is only supported under EVPN VRF\n");
6941 if (!strcmp(argv
[2]->text
, "import"))
6942 rt_type
= RT_TYPE_IMPORT
;
6943 else if (!strcmp(argv
[2]->text
, "export"))
6944 rt_type
= RT_TYPE_EXPORT
;
6945 else if (!strcmp(argv
[2]->text
, "both"))
6946 rt_type
= RT_TYPE_BOTH
;
6948 vty_out(vty
, "%% Invalid Route Target type\n");
6952 /* The user did "no route-target import", check to see if there are any
6953 * import route-targets configured. */
6954 if (rt_type
== RT_TYPE_IMPORT
) {
6955 if (!is_import_rt_configured(vpn
)) {
6957 "%% Import RT is not configured for this VNI\n");
6960 } else if (rt_type
== RT_TYPE_EXPORT
) {
6961 if (!is_export_rt_configured(vpn
)) {
6963 "%% Export RT is not configured for this VNI\n");
6966 } else if (rt_type
== RT_TYPE_BOTH
) {
6967 if (!is_import_rt_configured(vpn
)
6968 && !is_export_rt_configured(vpn
)) {
6970 "%% Import/Export RT is not configured for this VNI\n");
6975 ecomdel
= ecommunity_str2com(argv
[3]->arg
, ECOMMUNITY_ROUTE_TARGET
, 0);
6977 vty_out(vty
, "%% Malformed Route Target list\n");
6980 ecommunity_str(ecomdel
);
6982 if (rt_type
== RT_TYPE_IMPORT
) {
6983 if (!bgp_evpn_rt_matches_existing(vpn
->import_rtl
, ecomdel
)) {
6984 ecommunity_free(&ecomdel
);
6986 "%% RT specified does not match configuration for this VNI\n");
6989 evpn_unconfigure_import_rt(bgp
, vpn
, ecomdel
);
6990 } else if (rt_type
== RT_TYPE_EXPORT
) {
6991 if (!bgp_evpn_rt_matches_existing(vpn
->export_rtl
, ecomdel
)) {
6992 ecommunity_free(&ecomdel
);
6994 "%% RT specified does not match configuration for this VNI\n");
6997 evpn_unconfigure_export_rt(bgp
, vpn
, ecomdel
);
6998 } else if (rt_type
== RT_TYPE_BOTH
) {
7001 if (bgp_evpn_rt_matches_existing(vpn
->import_rtl
, ecomdel
)) {
7002 evpn_unconfigure_import_rt(bgp
, vpn
, ecomdel
);
7006 if (bgp_evpn_rt_matches_existing(vpn
->export_rtl
, ecomdel
)) {
7007 evpn_unconfigure_export_rt(bgp
, vpn
, ecomdel
);
7011 if (!found_ecomdel
) {
7012 ecommunity_free(&ecomdel
);
7014 "%% RT specified does not match configuration for this VNI\n");
7022 DEFUN (no_bgp_evpn_vni_rt_without_val
,
7023 no_bgp_evpn_vni_rt_without_val_cmd
,
7024 "no route-target <import|export>",
7030 struct bgp
*bgp
= VTY_GET_CONTEXT(bgp
);
7031 VTY_DECLVAR_CONTEXT_SUB(bgpevpn
, vpn
);
7037 if (!EVPN_ENABLED(bgp
)) {
7039 "This command is only supported under EVPN VRF\n");
7043 if (!strcmp(argv
[2]->text
, "import")) {
7044 rt_type
= RT_TYPE_IMPORT
;
7045 } else if (!strcmp(argv
[2]->text
, "export")) {
7046 rt_type
= RT_TYPE_EXPORT
;
7048 vty_out(vty
, "%% Invalid Route Target type\n");
7052 /* Check if we should disallow. */
7053 if (rt_type
== RT_TYPE_IMPORT
) {
7054 if (!is_import_rt_configured(vpn
)) {
7056 "%% Import RT is not configured for this VNI\n");
7060 if (!is_export_rt_configured(vpn
)) {
7062 "%% Export RT is not configured for this VNI\n");
7067 /* Unconfigure the RT. */
7068 if (rt_type
== RT_TYPE_IMPORT
)
7069 evpn_unconfigure_import_rt(bgp
, vpn
, NULL
);
7071 evpn_unconfigure_export_rt(bgp
, vpn
, NULL
);
7075 static int vni_cmp(const void **a
, const void **b
)
7077 const struct bgpevpn
*first
= *a
;
7078 const struct bgpevpn
*secnd
= *b
;
7080 return secnd
->vni
- first
->vni
;
7084 * Output EVPN configuration information.
7086 void bgp_config_write_evpn_info(struct vty
*vty
, struct bgp
*bgp
, afi_t afi
,
7089 if (bgp
->advertise_all_vni
)
7090 vty_out(vty
, " advertise-all-vni\n");
7092 if (hashcount(bgp
->vnihash
)) {
7093 struct list
*vnilist
= hash_to_list(bgp
->vnihash
);
7094 struct listnode
*ln
;
7095 struct bgpevpn
*data
;
7097 list_sort(vnilist
, vni_cmp
);
7098 for (ALL_LIST_ELEMENTS_RO(vnilist
, ln
, data
))
7099 write_vni_config(vty
, data
);
7101 list_delete(&vnilist
);
7104 if (bgp
->advertise_autort_rfc8365
)
7105 vty_out(vty
, " autort rfc8365-compatible\n");
7107 if (bgp
->advertise_gw_macip
)
7108 vty_out(vty
, " advertise-default-gw\n");
7110 if (bgp
->evpn_info
->advertise_svi_macip
)
7111 vty_out(vty
, " advertise-svi-ip\n");
7113 if (bgp
->resolve_overlay_index
)
7114 vty_out(vty
, " enable-resolve-overlay-index\n");
7116 if (bgp_mh_info
->evi_per_es_frag
!= BGP_EVPN_MAX_EVI_PER_ES_FRAG
)
7117 vty_out(vty
, " ead-es-frag evi-limit %u\n",
7118 bgp_mh_info
->evi_per_es_frag
);
7120 if (bgp_mh_info
->host_routes_use_l3nhg
!=
7121 BGP_EVPN_MH_USE_ES_L3NHG_DEF
) {
7122 if (bgp_mh_info
->host_routes_use_l3nhg
)
7123 vty_out(vty
, " use-es-l3nhg\n");
7125 vty_out(vty
, " no use-es-l3nhg\n");
7128 if (bgp_mh_info
->ead_evi_rx
!= BGP_EVPN_MH_EAD_EVI_RX_DEF
) {
7129 if (bgp_mh_info
->ead_evi_rx
)
7130 vty_out(vty
, " no disable-ead-evi-rx\n");
7132 vty_out(vty
, " disable-ead-evi-rx\n");
7135 if (bgp_mh_info
->ead_evi_tx
!= BGP_EVPN_MH_EAD_EVI_TX_DEF
) {
7136 if (bgp_mh_info
->ead_evi_tx
)
7137 vty_out(vty
, " no disable-ead-evi-tx\n");
7139 vty_out(vty
, " disable-ead-evi-tx\n");
7142 if (!bgp
->evpn_info
->dup_addr_detect
)
7143 vty_out(vty
, " no dup-addr-detection\n");
7145 if (bgp
->evpn_info
->dad_max_moves
!=
7146 EVPN_DAD_DEFAULT_MAX_MOVES
||
7147 bgp
->evpn_info
->dad_time
!= EVPN_DAD_DEFAULT_TIME
)
7148 vty_out(vty
, " dup-addr-detection max-moves %u time %u\n",
7149 bgp
->evpn_info
->dad_max_moves
,
7150 bgp
->evpn_info
->dad_time
);
7152 if (bgp
->evpn_info
->dad_freeze
) {
7153 if (bgp
->evpn_info
->dad_freeze_time
)
7155 " dup-addr-detection freeze %u\n",
7156 bgp
->evpn_info
->dad_freeze_time
);
7159 " dup-addr-detection freeze permanent\n");
7162 if (bgp
->vxlan_flood_ctrl
== VXLAN_FLOOD_DISABLED
)
7163 vty_out(vty
, " flooding disable\n");
7165 if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7166 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST
)) {
7167 if (bgp
->adv_cmd_rmap
[AFI_IP
][SAFI_UNICAST
].name
)
7168 vty_out(vty
, " advertise ipv4 unicast route-map %s\n",
7169 bgp
->adv_cmd_rmap
[AFI_IP
][SAFI_UNICAST
].name
);
7172 " advertise ipv4 unicast\n");
7173 } else if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7174 BGP_L2VPN_EVPN_ADV_IPV4_UNICAST_GW_IP
)) {
7175 if (bgp
->adv_cmd_rmap
[AFI_IP
][SAFI_UNICAST
].name
)
7177 " advertise ipv4 unicast gateway-ip route-map %s\n",
7178 bgp
->adv_cmd_rmap
[AFI_IP
][SAFI_UNICAST
].name
);
7180 vty_out(vty
, " advertise ipv4 unicast gateway-ip\n");
7183 /* EAD ES export route-target */
7184 if (listcount(bgp_mh_info
->ead_es_export_rtl
)) {
7185 struct ecommunity
*ecom
;
7187 struct listnode
*node
;
7189 for (ALL_LIST_ELEMENTS_RO(bgp_mh_info
->ead_es_export_rtl
, node
,
7192 ecom_str
= ecommunity_ecom2str(
7193 ecom
, ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
7194 vty_out(vty
, " ead-es-route-target export %s\n",
7196 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
7200 if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7201 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST
)) {
7202 if (bgp
->adv_cmd_rmap
[AFI_IP6
][SAFI_UNICAST
].name
)
7204 " advertise ipv6 unicast route-map %s\n",
7205 bgp
->adv_cmd_rmap
[AFI_IP6
][SAFI_UNICAST
].name
);
7208 " advertise ipv6 unicast\n");
7209 } else if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7210 BGP_L2VPN_EVPN_ADV_IPV6_UNICAST_GW_IP
)) {
7211 if (bgp
->adv_cmd_rmap
[AFI_IP6
][SAFI_UNICAST
].name
)
7213 " advertise ipv6 unicast gateway-ip route-map %s\n",
7214 bgp
->adv_cmd_rmap
[AFI_IP6
][SAFI_UNICAST
].name
);
7216 vty_out(vty
, " advertise ipv6 unicast gateway-ip\n");
7219 if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7220 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4
))
7221 vty_out(vty
, " default-originate ipv4\n");
7223 if (CHECK_FLAG(bgp
->af_flags
[AFI_L2VPN
][SAFI_EVPN
],
7224 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6
))
7225 vty_out(vty
, " default-originate ipv6\n");
7227 if (bgp
->inst_type
== BGP_INSTANCE_TYPE_VRF
) {
7228 if (!bgp
->evpn_info
->advertise_pip
)
7229 vty_out(vty
, " no advertise-pip\n");
7230 if (bgp
->evpn_info
->advertise_pip
) {
7231 if (bgp
->evpn_info
->pip_ip_static
.s_addr
7233 vty_out(vty
, " advertise-pip ip %pI4",
7234 &bgp
->evpn_info
->pip_ip_static
);
7236 bgp
->evpn_info
->pip_rmac_static
))) {
7237 char buf
[ETHER_ADDR_STRLEN
];
7239 vty_out(vty
, " mac %s",
7249 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_RD_CFGD
))
7250 vty_out(vty
, " rd %pRD\n", &bgp
->vrf_prd
);
7252 /* import route-target */
7253 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
)) {
7255 struct listnode
*node
, *nnode
;
7256 struct vrf_route_target
*l3rt
;
7258 for (ALL_LIST_ELEMENTS(bgp
->vrf_import_rtl
, node
, nnode
,
7261 if (CHECK_FLAG(l3rt
->flags
, BGP_VRF_RT_AUTO
))
7264 ecom_str
= ecommunity_ecom2str(
7265 l3rt
->ecom
, ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
7267 if (CHECK_FLAG(l3rt
->flags
, BGP_VRF_RT_WILD
)) {
7268 char *vni_str
= NULL
;
7270 vni_str
= strchr(ecom_str
, ':');
7272 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
7276 /* Move pointer to vni */
7279 vty_out(vty
, " route-target import *:%s\n",
7283 vty_out(vty
, " route-target import %s\n",
7286 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
7290 /* import route-target auto */
7291 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_IMPORT_AUTO_RT_CFGD
))
7292 vty_out(vty
, " route-target import auto\n");
7294 /* export route-target */
7295 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
)) {
7297 struct listnode
*node
, *nnode
;
7298 struct vrf_route_target
*l3rt
;
7300 for (ALL_LIST_ELEMENTS(bgp
->vrf_export_rtl
, node
, nnode
,
7303 if (CHECK_FLAG(l3rt
->flags
, BGP_VRF_RT_AUTO
))
7306 ecom_str
= ecommunity_ecom2str(
7307 l3rt
->ecom
, ECOMMUNITY_FORMAT_ROUTE_MAP
, 0);
7308 vty_out(vty
, " route-target export %s\n", ecom_str
);
7309 XFREE(MTYPE_ECOMMUNITY_STR
, ecom_str
);
7313 /* export route-target auto */
7314 if (CHECK_FLAG(bgp
->vrf_flags
, BGP_VRF_EXPORT_AUTO_RT_CFGD
))
7315 vty_out(vty
, " route-target export auto\n");
7318 void bgp_ethernetvpn_init(void)
7320 install_element(VIEW_NODE
, &show_ip_bgp_l2vpn_evpn_cmd
);
7321 install_element(VIEW_NODE
, &show_ip_bgp_l2vpn_evpn_rd_cmd
);
7322 install_element(VIEW_NODE
, &show_ip_bgp_l2vpn_evpn_all_tags_cmd
);
7323 install_element(VIEW_NODE
, &show_ip_bgp_l2vpn_evpn_rd_tags_cmd
);
7324 install_element(VIEW_NODE
,
7325 &show_ip_bgp_l2vpn_evpn_neighbor_routes_cmd
);
7326 install_element(VIEW_NODE
,
7327 &show_ip_bgp_l2vpn_evpn_rd_neighbor_routes_cmd
);
7330 &show_ip_bgp_l2vpn_evpn_neighbor_advertised_routes_cmd
);
7333 &show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes_cmd
);
7334 install_element(VIEW_NODE
, &show_ip_bgp_evpn_rd_overlay_cmd
);
7335 install_element(VIEW_NODE
, &show_ip_bgp_l2vpn_evpn_all_overlay_cmd
);
7336 install_element(BGP_EVPN_NODE
, &no_evpnrt5_network_cmd
);
7337 install_element(BGP_EVPN_NODE
, &evpnrt5_network_cmd
);
7338 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_all_vni_cmd
);
7339 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_advertise_all_vni_cmd
);
7340 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_autort_rfc8365_cmd
);
7341 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_advertise_autort_rfc8365_cmd
);
7342 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_default_gw_cmd
);
7343 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_advertise_default_gw_cmd
);
7344 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_svi_ip_cmd
);
7345 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_type5_cmd
);
7346 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_advertise_type5_cmd
);
7347 install_element(BGP_EVPN_NODE
, &bgp_evpn_default_originate_cmd
);
7348 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_default_originate_cmd
);
7349 install_element(BGP_EVPN_NODE
, &dup_addr_detection_cmd
);
7350 install_element(BGP_EVPN_NODE
, &dup_addr_detection_auto_recovery_cmd
);
7351 install_element(BGP_EVPN_NODE
, &no_dup_addr_detection_cmd
);
7352 install_element(BGP_EVPN_NODE
, &bgp_evpn_flood_control_cmd
);
7353 install_element(BGP_EVPN_NODE
, &bgp_evpn_advertise_pip_ip_mac_cmd
);
7354 install_element(BGP_EVPN_NODE
, &bgp_evpn_use_es_l3nhg_cmd
);
7355 install_element(BGP_EVPN_NODE
, &bgp_evpn_ead_evi_rx_disable_cmd
);
7356 install_element(BGP_EVPN_NODE
, &bgp_evpn_ead_evi_tx_disable_cmd
);
7357 install_element(BGP_EVPN_NODE
,
7358 &bgp_evpn_enable_resolve_overlay_index_cmd
);
7361 install_element(BGP_EVPN_NODE
, &test_es_add_cmd
);
7362 install_element(BGP_EVPN_NODE
, &test_es_vni_add_cmd
);
7364 /* "show bgp l2vpn evpn" commands. */
7365 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_es_cmd
);
7366 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_es_evi_cmd
);
7367 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_es_vrf_cmd
);
7368 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_nh_cmd
);
7369 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_vni_cmd
);
7370 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_vni_remote_ip_hash_cmd
);
7371 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_vni_svi_hash_cmd
);
7372 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_summary_cmd
);
7373 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_cmd
);
7374 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_rd_cmd
);
7375 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_rd_macip_cmd
);
7376 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_esi_cmd
);
7377 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_vni_cmd
);
7378 install_element(VIEW_NODE
,
7379 &show_bgp_l2vpn_evpn_route_vni_multicast_cmd
);
7380 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_vni_macip_cmd
);
7381 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_route_vni_all_cmd
);
7382 install_element(VIEW_NODE
,
7383 &show_bgp_l2vpn_evpn_route_mac_ip_evi_es_cmd
);
7384 install_element(VIEW_NODE
,
7385 &show_bgp_l2vpn_evpn_route_mac_ip_global_es_cmd
);
7386 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_import_rt_cmd
);
7387 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_vrf_import_rt_cmd
);
7389 /* "show bgp vni" commands. */
7390 install_element(VIEW_NODE
, &show_bgp_vni_all_cmd
);
7391 install_element(VIEW_NODE
, &show_bgp_vni_all_ead_cmd
);
7392 install_element(VIEW_NODE
, &show_bgp_vni_all_macip_mac_cmd
);
7393 install_element(VIEW_NODE
, &show_bgp_vni_all_macip_ip_cmd
);
7394 install_element(VIEW_NODE
, &show_bgp_vni_all_imet_cmd
);
7395 install_element(VIEW_NODE
, &show_bgp_vni_cmd
);
7396 install_element(VIEW_NODE
, &show_bgp_vni_ead_cmd
);
7397 install_element(VIEW_NODE
, &show_bgp_vni_macip_mac_cmd
);
7398 install_element(VIEW_NODE
, &show_bgp_vni_macip_ip_cmd
);
7399 install_element(VIEW_NODE
, &show_bgp_vni_imet_cmd
);
7400 install_element(VIEW_NODE
, &show_bgp_vni_macip_mac_addr_cmd
);
7401 install_element(VIEW_NODE
, &show_bgp_vni_macip_ip_addr_cmd
);
7403 /* "show bgp evpn" commands. */
7404 install_element(VIEW_NODE
, &show_bgp_evpn_vni_cmd
);
7405 install_element(VIEW_NODE
, &show_bgp_evpn_summary_cmd
);
7406 install_element(VIEW_NODE
, &show_bgp_evpn_route_cmd
);
7407 install_element(VIEW_NODE
, &show_bgp_evpn_route_rd_cmd
);
7408 install_element(VIEW_NODE
, &show_bgp_evpn_route_rd_macip_cmd
);
7409 install_element(VIEW_NODE
, &show_bgp_evpn_route_vni_cmd
);
7410 install_element(VIEW_NODE
, &show_bgp_evpn_route_vni_multicast_cmd
);
7411 install_element(VIEW_NODE
, &show_bgp_evpn_route_vni_macip_cmd
);
7412 install_element(VIEW_NODE
, &show_bgp_evpn_route_vni_all_cmd
);
7413 install_element(VIEW_NODE
, &show_bgp_evpn_import_rt_cmd
);
7414 install_element(VIEW_NODE
, &show_bgp_vrf_l3vni_info_cmd
);
7415 install_element(VIEW_NODE
, &show_bgp_l2vpn_evpn_com_cmd
);
7417 install_element(BGP_EVPN_NODE
, &bgp_evpn_vni_cmd
);
7418 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_vni_cmd
);
7419 install_element(BGP_EVPN_VNI_NODE
, &exit_vni_cmd
);
7420 install_element(BGP_EVPN_VNI_NODE
, &bgp_evpn_vni_rd_cmd
);
7421 install_element(BGP_EVPN_VNI_NODE
, &no_bgp_evpn_vni_rd_cmd
);
7422 install_element(BGP_EVPN_VNI_NODE
, &no_bgp_evpn_vni_rd_without_val_cmd
);
7423 install_element(BGP_EVPN_VNI_NODE
, &bgp_evpn_vni_rt_cmd
);
7424 install_element(BGP_EVPN_VNI_NODE
, &no_bgp_evpn_vni_rt_cmd
);
7425 install_element(BGP_EVPN_VNI_NODE
, &no_bgp_evpn_vni_rt_without_val_cmd
);
7426 install_element(BGP_EVPN_NODE
, &bgp_evpn_vrf_rd_cmd
);
7427 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_vrf_rd_cmd
);
7428 install_element(BGP_NODE
, &no_bgp_evpn_vrf_rd_without_val_cmd
);
7429 install_element(BGP_EVPN_NODE
, &bgp_evpn_vrf_rt_cmd
);
7430 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_vrf_rt_cmd
);
7431 install_element(BGP_EVPN_NODE
, &bgp_evpn_vrf_rt_auto_cmd
);
7432 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_vrf_rt_auto_cmd
);
7433 install_element(BGP_EVPN_NODE
, &bgp_evpn_ead_es_rt_cmd
);
7434 install_element(BGP_EVPN_NODE
, &no_bgp_evpn_ead_es_rt_cmd
);
7435 install_element(BGP_EVPN_NODE
, &bgp_evpn_ead_es_frag_evi_limit_cmd
);
7436 install_element(BGP_EVPN_VNI_NODE
, &bgp_evpn_advertise_svi_ip_vni_cmd
);
7437 install_element(BGP_EVPN_VNI_NODE
,
7438 &bgp_evpn_advertise_default_gw_vni_cmd
);
7439 install_element(BGP_EVPN_VNI_NODE
,
7440 &no_bgp_evpn_advertise_default_gw_vni_cmd
);
7441 install_element(BGP_EVPN_VNI_NODE
, &bgp_evpn_advertise_vni_subnet_cmd
);
7442 install_element(BGP_EVPN_VNI_NODE
,
7443 &no_bgp_evpn_advertise_vni_subnet_cmd
);