]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_evpn_vty.c
projects / mirror_frr.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #3017 from pacovn/devbuild_Wshadow_flag
[mirror_frr.git] / bgpd / bgp_evpn_vty.c
1 /* Ethernet-VPN Packet and vty Processing File
2 * Copyright (C) 2017 6WIND
3 *
4 * This file is part of FRRouting
5 *
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
9 * later version.
10 *
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.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22 #include "command.h"
23 #include "prefix.h"
24 #include "lib/json.h"
25 #include "stream.h"
26
27 #include "bgpd/bgpd.h"
28 #include "bgpd/bgp_table.h"
29 #include "bgpd/bgp_attr.h"
30 #include "bgpd/bgp_route.h"
31 #include "bgpd/bgp_mplsvpn.h"
32 #include "bgpd/bgp_vpn.h"
33 #include "bgpd/bgp_evpn_vty.h"
34 #include "bgpd/bgp_evpn.h"
35 #include "bgpd/bgp_evpn_private.h"
36 #include "bgpd/bgp_zebra.h"
37 #include "bgpd/bgp_vty.h"
38 #include "bgpd/bgp_errors.h"
39 #include "bgpd/bgp_ecommunity.h"
40
41 #define SHOW_DISPLAY_STANDARD 0
42 #define SHOW_DISPLAY_TAGS 1
43 #define SHOW_DISPLAY_OVERLAY 2
44 #define VNI_STR_LEN 32
45
46 /*
47 * Context for VNI hash walk - used by callbacks.
48 */
49 struct vni_walk_ctx {
50 struct bgp *bgp;
51 struct vty *vty;
52 struct in_addr vtep_ip;
53 json_object *json;
54 };
55
56 static void display_vrf_import_rt(struct vty *vty, struct vrf_irt_node *irt,
57 json_object *json)
58 {
59 uint8_t *pnt;
60 uint8_t type, sub_type;
61 struct ecommunity_as eas;
62 struct ecommunity_ip eip;
63 struct listnode *node, *nnode;
64 struct bgp *tmp_bgp_vrf = NULL;
65 json_object *json_rt = NULL;
66 json_object *json_vrfs = NULL;
67 char rt_buf[RT_ADDRSTRLEN];
68
69 if (json) {
70 json_rt = json_object_new_object();
71 json_vrfs = json_object_new_array();
72 }
73
74 pnt = (uint8_t *)&irt->rt.val;
75 type = *pnt++;
76 sub_type = *pnt++;
77 if (sub_type != ECOMMUNITY_ROUTE_TARGET)
78 return;
79
80 memset(&eas, 0, sizeof(eas));
81 switch (type) {
82 case ECOMMUNITY_ENCODE_AS:
83 eas.as = (*pnt++ << 8);
84 eas.as |= (*pnt++);
85 ptr_get_be32(pnt, &eas.val);
86
87 snprintf(rt_buf, RT_ADDRSTRLEN, "%u:%u", eas.as, eas.val);
88
89 if (json)
90 json_object_string_add(json_rt, "rt", rt_buf);
91 else
92 vty_out(vty, "Route-target: %s", rt_buf);
93
94 break;
95
96 case ECOMMUNITY_ENCODE_IP:
97 memcpy(&eip.ip, pnt, 4);
98 pnt += 4;
99 eip.val = (*pnt++ << 8);
100 eip.val |= (*pnt++);
101
102 snprintf(rt_buf, RT_ADDRSTRLEN, "%s:%u", inet_ntoa(eip.ip),
103 eip.val);
104
105 if (json)
106 json_object_string_add(json_rt, "rt", rt_buf);
107 else
108 vty_out(vty, "Route-target: %s", rt_buf);
109
110 break;
111
112 case ECOMMUNITY_ENCODE_AS4:
113 pnt = ptr_get_be32(pnt, &eas.val);
114 eas.val = (*pnt++ << 8);
115 eas.val |= (*pnt++);
116
117 snprintf(rt_buf, RT_ADDRSTRLEN, "%u:%u", eas.as, eas.val);
118
119 if (json)
120 json_object_string_add(json_rt, "rt", rt_buf);
121 else
122 vty_out(vty, "Route-target: %s", rt_buf);
123
124 break;
125
126 default:
127 return;
128 }
129
130 if (!json) {
131 vty_out(vty,
132 "\nList of VRFs importing routes with this route-target:\n");
133 }
134
135 for (ALL_LIST_ELEMENTS(irt->vrfs, node, nnode, tmp_bgp_vrf)) {
136 if (json)
137 json_object_array_add(
138 json_vrfs,
139 json_object_new_string(
140 vrf_id_to_name(tmp_bgp_vrf->vrf_id)));
141 else
142 vty_out(vty, " %s\n",
143 vrf_id_to_name(tmp_bgp_vrf->vrf_id));
144 }
145
146 if (json) {
147 json_object_object_add(json_rt, "vrfs", json_vrfs);
148 json_object_object_add(json, rt_buf, json_rt);
149 }
150 }
151
152 static void show_vrf_import_rt_entry(struct hash_backet *backet, void *args[])
153 {
154 json_object *json = NULL;
155 struct vty *vty = NULL;
156 struct vrf_irt_node *irt = (struct vrf_irt_node *)backet->data;
157
158 vty = (struct vty *)args[0];
159 json = (struct json_object *)args[1];
160
161 display_vrf_import_rt(vty, irt, json);
162 }
163
164 static void display_import_rt(struct vty *vty, struct irt_node *irt,
165 json_object *json)
166 {
167 uint8_t *pnt;
168 uint8_t type, sub_type;
169 struct ecommunity_as eas;
170 struct ecommunity_ip eip;
171 struct listnode *node, *nnode;
172 struct bgpevpn *tmp_vpn;
173 json_object *json_rt = NULL;
174 json_object *json_vnis = NULL;
175 char rt_buf[RT_ADDRSTRLEN];
176
177 if (json) {
178 json_rt = json_object_new_object();
179 json_vnis = json_object_new_array();
180 }
181
182 /* TODO: This needs to go into a function */
183
184 pnt = (uint8_t *)&irt->rt.val;
185 type = *pnt++;
186 sub_type = *pnt++;
187 if (sub_type != ECOMMUNITY_ROUTE_TARGET)
188 return;
189
190 memset(&eas, 0, sizeof(eas));
191 switch (type) {
192 case ECOMMUNITY_ENCODE_AS:
193 eas.as = (*pnt++ << 8);
194 eas.as |= (*pnt++);
195 ptr_get_be32(pnt, &eas.val);
196
197 snprintf(rt_buf, RT_ADDRSTRLEN, "%u:%u", eas.as, eas.val);
198
199 if (json)
200 json_object_string_add(json_rt, "rt", rt_buf);
201 else
202 vty_out(vty, "Route-target: %s", rt_buf);
203
204 break;
205
206 case ECOMMUNITY_ENCODE_IP:
207 memcpy(&eip.ip, pnt, 4);
208 pnt += 4;
209 eip.val = (*pnt++ << 8);
210 eip.val |= (*pnt++);
211
212 snprintf(rt_buf, RT_ADDRSTRLEN, "%s:%u", inet_ntoa(eip.ip),
213 eip.val);
214
215 if (json)
216 json_object_string_add(json_rt, "rt", rt_buf);
217 else
218 vty_out(vty, "Route-target: %s", rt_buf);
219
220 break;
221
222 case ECOMMUNITY_ENCODE_AS4:
223 pnt = ptr_get_be32(pnt, &eas.val);
224 eas.val = (*pnt++ << 8);
225 eas.val |= (*pnt++);
226
227 snprintf(rt_buf, RT_ADDRSTRLEN, "%u:%u", eas.as, eas.val);
228
229 if (json)
230 json_object_string_add(json_rt, "rt", rt_buf);
231 else
232 vty_out(vty, "Route-target: %s", rt_buf);
233
234 break;
235
236 default:
237 return;
238 }
239
240 if (!json) {
241 vty_out(vty,
242 "\nList of VNIs importing routes with this route-target:\n");
243 }
244
245 for (ALL_LIST_ELEMENTS(irt->vnis, node, nnode, tmp_vpn)) {
246 if (json)
247 json_object_array_add(
248 json_vnis, json_object_new_int(tmp_vpn->vni));
249 else
250 vty_out(vty, " %u\n", tmp_vpn->vni);
251 }
252
253 if (json) {
254 json_object_object_add(json_rt, "vnis", json_vnis);
255 json_object_object_add(json, rt_buf, json_rt);
256 }
257 }
258
259 static void show_import_rt_entry(struct hash_backet *backet, void *args[])
260 {
261 json_object *json = NULL;
262 struct vty *vty = NULL;
263 struct irt_node *irt = (struct irt_node *)backet->data;
264
265 vty = args[0];
266 json = args[1];
267
268 display_import_rt(vty, irt, json);
269
270 return;
271 }
272
273 static void bgp_evpn_show_route_rd_header(struct vty *vty,
274 struct bgp_node *rd_rn,
275 json_object *json)
276 {
277 uint16_t type;
278 struct rd_as rd_as;
279 struct rd_ip rd_ip;
280 uint8_t *pnt;
281 char rd_str[RD_ADDRSTRLEN];
282
283 pnt = rd_rn->p.u.val;
284
285 /* Decode RD type. */
286 type = decode_rd_type(pnt);
287
288 if (json)
289 return;
290
291 vty_out(vty, "Route Distinguisher: ");
292
293 switch (type) {
294 case RD_TYPE_AS:
295 decode_rd_as(pnt + 2, &rd_as);
296 snprintf(rd_str, RD_ADDRSTRLEN, "%u:%d", rd_as.as, rd_as.val);
297 break;
298
299 case RD_TYPE_IP:
300 decode_rd_ip(pnt + 2, &rd_ip);
301 snprintf(rd_str, RD_ADDRSTRLEN, "%s:%d", inet_ntoa(rd_ip.ip),
302 rd_ip.val);
303 break;
304
305 default:
306 snprintf(rd_str, RD_ADDRSTRLEN, "Unknown RD type");
307 break;
308 }
309
310 vty_out(vty, "%s\n", rd_str);
311 }
312
313 static void bgp_evpn_show_route_header(struct vty *vty, struct bgp *bgp,
314 uint64_t tbl_ver, json_object *json)
315 {
316 char ri_header[] =
317 " Network Next Hop Metric LocPrf Weight Path\n";
318
319 if (json)
320 return;
321
322 vty_out(vty, "BGP table version is %" PRIu64 ", local router ID is %s\n",
323 tbl_ver, inet_ntoa(bgp->router_id));
324 vty_out(vty,
325 "Status codes: s suppressed, d damped, h history, "
326 "* valid, > best, i - internal\n");
327 vty_out(vty, "Origin codes: i - IGP, e - EGP, ? - incomplete\n");
328 vty_out(vty,
329 "EVPN type-2 prefix: [2]:[EthTag]:[MAClen]:[MAC]:[IPlen]:[IP]\n");
330 vty_out(vty, "EVPN type-3 prefix: [3]:[EthTag]:[IPlen]:[OrigIP]\n");
331 vty_out(vty, "EVPN type-4 prefix: [4]:[ESI]:[IPlen]:[OrigIP]\n");
332 vty_out(vty, "EVPN type-5 prefix: [5]:[EthTag]:[IPlen]:[IP]\n\n");
333 vty_out(vty, "%s", ri_header);
334 }
335
336 static void display_l3vni(struct vty *vty, struct bgp *bgp_vrf,
337 json_object *json)
338 {
339 char buf1[INET6_ADDRSTRLEN];
340 char *ecom_str;
341 struct listnode *node, *nnode;
342 struct ecommunity *ecom;
343 json_object *json_import_rtl = NULL;
344 json_object *json_export_rtl = NULL;
345
346 json_import_rtl = json_export_rtl = 0;
347
348 if (json) {
349 json_import_rtl = json_object_new_array();
350 json_export_rtl = json_object_new_array();
351 json_object_int_add(json, "vni", bgp_vrf->l3vni);
352 json_object_string_add(json, "type", "L3");
353 json_object_string_add(json, "kernelFlag", "Yes");
354 json_object_string_add(
355 json, "rd",
356 prefix_rd2str(&bgp_vrf->vrf_prd, buf1, RD_ADDRSTRLEN));
357 json_object_string_add(json, "originatorIp",
358 inet_ntoa(bgp_vrf->originator_ip));
359 json_object_string_add(json, "advertiseGatewayMacip", "n/a");
360 } else {
361 vty_out(vty, "VNI: %d", bgp_vrf->l3vni);
362 vty_out(vty, " (known to the kernel)");
363 vty_out(vty, "\n");
364
365 vty_out(vty, " Type: %s\n", "L3");
366 vty_out(vty, " Tenant VRF: %s\n",
367 vrf_id_to_name(bgp_vrf->vrf_id));
368 vty_out(vty, " RD: %s\n",
369 prefix_rd2str(&bgp_vrf->vrf_prd, buf1, RD_ADDRSTRLEN));
370 vty_out(vty, " Originator IP: %s\n",
371 inet_ntoa(bgp_vrf->originator_ip));
372 vty_out(vty, " Advertise-gw-macip : %s\n", "n/a");
373 }
374
375 if (!json)
376 vty_out(vty, " Import Route Target:\n");
377
378 for (ALL_LIST_ELEMENTS(bgp_vrf->vrf_import_rtl, node, nnode, ecom)) {
379 ecom_str = ecommunity_ecom2str(ecom,
380 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
381
382 if (json)
383 json_object_array_add(json_import_rtl,
384 json_object_new_string(ecom_str));
385 else
386 vty_out(vty, " %s\n", ecom_str);
387
388 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
389 }
390
391 if (json)
392 json_object_object_add(json, "importRts", json_import_rtl);
393 else
394 vty_out(vty, " Export Route Target:\n");
395
396 for (ALL_LIST_ELEMENTS(bgp_vrf->vrf_export_rtl, node, nnode, ecom)) {
397 ecom_str = ecommunity_ecom2str(ecom,
398 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
399
400 if (json)
401 json_object_array_add(json_export_rtl,
402 json_object_new_string(ecom_str));
403 else
404 vty_out(vty, " %s\n", ecom_str);
405
406 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
407 }
408
409 if (json)
410 json_object_object_add(json, "exportRts", json_export_rtl);
411 }
412
413 static void display_es(struct vty *vty, struct evpnes *es, json_object *json)
414 {
415 struct in_addr *vtep;
416 char buf[ESI_STR_LEN];
417 char buf1[RD_ADDRSTRLEN];
418 char buf2[INET6_ADDRSTRLEN];
419 struct listnode *node = NULL;
420 json_object *json_vteps = NULL;
421
422 if (json) {
423 json_vteps = json_object_new_array();
424 json_object_string_add(json, "esi",
425 esi_to_str(&es->esi, buf, sizeof(buf)));
426 json_object_string_add(json, "rd",
427 prefix_rd2str(&es->prd, buf1,
428 sizeof(buf1)));
429 json_object_string_add(
430 json, "originatorIp",
431 ipaddr2str(&es->originator_ip, buf2, sizeof(buf2)));
432 if (es->vtep_list) {
433 for (ALL_LIST_ELEMENTS_RO(es->vtep_list, node, vtep))
434 json_object_array_add(
435 json_vteps, json_object_new_string(
436 inet_ntoa(*vtep)));
437 }
438 json_object_object_add(json, "vteps", json_vteps);
439 } else {
440 vty_out(vty, "ESI: %s\n",
441 esi_to_str(&es->esi, buf, sizeof(buf)));
442 vty_out(vty, " RD: %s\n", prefix_rd2str(&es->prd, buf1,
443 sizeof(buf1)));
444 vty_out(vty, " Originator-IP: %s\n",
445 ipaddr2str(&es->originator_ip, buf2, sizeof(buf2)));
446 if (es->vtep_list) {
447 vty_out(vty, " VTEP List:\n");
448 for (ALL_LIST_ELEMENTS_RO(es->vtep_list, node, vtep))
449 vty_out(vty, " %s\n", inet_ntoa(*vtep));
450 }
451 }
452 }
453
454 static void display_vni(struct vty *vty, struct bgpevpn *vpn, json_object *json)
455 {
456 char buf1[RD_ADDRSTRLEN];
457 char *ecom_str;
458 struct listnode *node, *nnode;
459 struct ecommunity *ecom;
460 json_object *json_import_rtl = NULL;
461 json_object *json_export_rtl = NULL;
462
463 if (json) {
464 json_import_rtl = json_object_new_array();
465 json_export_rtl = json_object_new_array();
466 json_object_int_add(json, "vni", vpn->vni);
467 json_object_string_add(json, "type", "L2");
468 json_object_string_add(json, "kernelFlag",
469 is_vni_live(vpn) ? "Yes" : "No");
470 json_object_string_add(
471 json, "rd",
472 prefix_rd2str(&vpn->prd, buf1, sizeof(buf1)));
473 json_object_string_add(json, "originatorIp",
474 inet_ntoa(vpn->originator_ip));
475 json_object_string_add(json, "advertiseGatewayMacip",
476 vpn->advertise_gw_macip ? "Yes" : "No");
477 } else {
478 vty_out(vty, "VNI: %d", vpn->vni);
479 if (is_vni_live(vpn))
480 vty_out(vty, " (known to the kernel)");
481 vty_out(vty, "\n");
482
483 vty_out(vty, " Type: %s\n", "L2");
484 vty_out(vty, " Tenant-Vrf: %s\n",
485 vrf_id_to_name(vpn->tenant_vrf_id));
486 vty_out(vty, " RD: %s\n",
487 prefix_rd2str(&vpn->prd, buf1, sizeof(buf1)));
488 vty_out(vty, " Originator IP: %s\n",
489 inet_ntoa(vpn->originator_ip));
490 vty_out(vty, " Advertise-gw-macip : %s\n",
491 vpn->advertise_gw_macip ? "Yes" : "No");
492 }
493
494 if (!json)
495 vty_out(vty, " Import Route Target:\n");
496
497 for (ALL_LIST_ELEMENTS(vpn->import_rtl, node, nnode, ecom)) {
498 ecom_str = ecommunity_ecom2str(ecom,
499 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
500
501 if (json)
502 json_object_array_add(json_import_rtl,
503 json_object_new_string(ecom_str));
504 else
505 vty_out(vty, " %s\n", ecom_str);
506
507 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
508 }
509
510 if (json)
511 json_object_object_add(json, "importRts", json_import_rtl);
512 else
513 vty_out(vty, " Export Route Target:\n");
514
515 for (ALL_LIST_ELEMENTS(vpn->export_rtl, node, nnode, ecom)) {
516 ecom_str = ecommunity_ecom2str(ecom,
517 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
518
519 if (json)
520 json_object_array_add(json_export_rtl,
521 json_object_new_string(ecom_str));
522 else
523 vty_out(vty, " %s\n", ecom_str);
524
525 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
526 }
527
528 if (json)
529 json_object_object_add(json, "exportRts", json_export_rtl);
530 }
531
532 static void show_esi_routes(struct bgp *bgp,
533 struct evpnes *es,
534 struct vty *vty,
535 json_object *json)
536 {
537 int header = 1;
538 struct bgp_node *rn;
539 struct bgp_info *ri;
540 uint32_t prefix_cnt, path_cnt;
541 uint64_t tbl_ver;
542
543 prefix_cnt = path_cnt = 0;
544
545 tbl_ver = es->route_table->version;
546 for (rn = bgp_table_top(es->route_table); rn;
547 rn = bgp_route_next(rn)) {
548 int add_prefix_to_json = 0;
549 char prefix_str[BUFSIZ];
550 json_object *json_paths = NULL;
551 json_object *json_prefix = NULL;
552
553 bgp_evpn_route2str((struct prefix_evpn *)&rn->p, prefix_str,
554 sizeof(prefix_str));
555
556 if (json)
557 json_prefix = json_object_new_object();
558
559 if (rn->info) {
560 /* Overall header/legend displayed once. */
561 if (header) {
562 bgp_evpn_show_route_header(vty, bgp,
563 tbl_ver, json);
564 header = 0;
565 }
566
567 prefix_cnt++;
568 }
569
570 if (json)
571 json_paths = json_object_new_array();
572
573 /* For EVPN, the prefix is displayed for each path (to fit in
574 * with code that already exists).
575 */
576 for (ri = rn->info; ri; ri = ri->next) {
577 json_object *json_path = NULL;
578
579 if (json)
580 json_path = json_object_new_array();
581
582 route_vty_out(vty, &rn->p, ri, 0, SAFI_EVPN, json_path);
583
584 if (json)
585 json_object_array_add(json_paths, json_path);
586
587 path_cnt++;
588 add_prefix_to_json = 1;
589 }
590
591 if (json && add_prefix_to_json) {
592 json_object_string_add(json_prefix, "prefix",
593 prefix_str);
594 json_object_int_add(json_prefix, "prefixLen",
595 rn->p.prefixlen);
596 json_object_object_add(json_prefix, "paths",
597 json_paths);
598 json_object_object_add(json, prefix_str, json_prefix);
599 }
600 }
601
602 if (json) {
603 json_object_int_add(json, "numPrefix", prefix_cnt);
604 json_object_int_add(json, "numPaths", path_cnt);
605 } else {
606 if (prefix_cnt == 0)
607 vty_out(vty, "No EVPN prefixes exist for this ESI\n");
608 else
609 vty_out(vty, "\nDisplayed %u prefixes (%u paths)\n",
610 prefix_cnt, path_cnt);
611 }
612 }
613
614 static void show_vni_routes(struct bgp *bgp, struct bgpevpn *vpn, int type,
615 struct vty *vty, struct in_addr vtep_ip,
616 json_object *json)
617 {
618 struct bgp_node *rn;
619 struct bgp_info *ri;
620 struct bgp_table *table;
621 int header = 1;
622 uint64_t tbl_ver;
623 uint32_t prefix_cnt, path_cnt;
624
625 prefix_cnt = path_cnt = 0;
626
627 table = vpn->route_table;
628 tbl_ver = table->version;
629 for (rn = bgp_table_top(table); rn;
630 rn = bgp_route_next(rn)) {
631 struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p;
632 int add_prefix_to_json = 0;
633 char prefix_str[BUFSIZ];
634 json_object *json_paths = NULL;
635 json_object *json_prefix = NULL;
636
637 bgp_evpn_route2str((struct prefix_evpn *)&rn->p, prefix_str,
638 sizeof(prefix_str));
639
640 if (type && evp->prefix.route_type != type)
641 continue;
642
643 if (json)
644 json_prefix = json_object_new_object();
645
646 if (rn->info) {
647 /* Overall header/legend displayed once. */
648 if (header) {
649 bgp_evpn_show_route_header(vty, bgp,
650 tbl_ver, json);
651 header = 0;
652 }
653
654 prefix_cnt++;
655 }
656
657 if (json)
658 json_paths = json_object_new_array();
659
660 /* For EVPN, the prefix is displayed for each path (to fit in
661 * with code that already exists).
662 */
663 for (ri = rn->info; ri; ri = ri->next) {
664 json_object *json_path = NULL;
665
666 if (vtep_ip.s_addr
667 && !IPV4_ADDR_SAME(&(vtep_ip),
668 &(ri->attr->nexthop)))
669 continue;
670
671 if (json)
672 json_path = json_object_new_array();
673
674 route_vty_out(vty, &rn->p, ri, 0, SAFI_EVPN, json_path);
675
676 if (json)
677 json_object_array_add(json_paths, json_path);
678
679 path_cnt++;
680 add_prefix_to_json = 1;
681 }
682
683 if (json && add_prefix_to_json) {
684 json_object_string_add(json_prefix, "prefix",
685 prefix_str);
686 json_object_int_add(json_prefix, "prefixLen",
687 rn->p.prefixlen);
688 json_object_object_add(json_prefix, "paths",
689 json_paths);
690 json_object_object_add(json, prefix_str, json_prefix);
691 }
692 }
693
694 if (json) {
695 json_object_int_add(json, "numPrefix", prefix_cnt);
696 json_object_int_add(json, "numPaths", path_cnt);
697 } else {
698 if (prefix_cnt == 0)
699 vty_out(vty, "No EVPN prefixes %sexist for this VNI",
700 type ? "(of requested type) " : "");
701 else
702 vty_out(vty, "\nDisplayed %u prefixes (%u paths)%s\n",
703 prefix_cnt, path_cnt,
704 type ? " (of requested type)" : "");
705 }
706 }
707
708 static void show_vni_routes_hash(struct hash_backet *backet, void *arg)
709 {
710 struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
711 struct vni_walk_ctx *wctx = arg;
712 struct vty *vty = wctx->vty;
713 json_object *json = wctx->json;
714 json_object *json_vni = NULL;
715 char vni_str[VNI_STR_LEN];
716
717 snprintf(vni_str, VNI_STR_LEN, "%d", vpn->vni);
718 if (json) {
719 json_vni = json_object_new_object();
720 json_object_int_add(json_vni, "vni", vpn->vni);
721 } else {
722 vty_out(vty, "\nVNI: %d\n\n", vpn->vni);
723 }
724
725 show_vni_routes(wctx->bgp, vpn, 0, wctx->vty, wctx->vtep_ip, json_vni);
726
727 if (json)
728 json_object_object_add(json, vni_str, json_vni);
729 }
730
731 static void show_l3vni_entry(struct vty *vty, struct bgp *bgp,
732 json_object *json)
733 {
734 json_object *json_vni = NULL;
735 json_object *json_import_rtl = NULL;
736 json_object *json_export_rtl = NULL;
737 char buf1[10];
738 char buf2[INET6_ADDRSTRLEN];
739 char rt_buf[25];
740 char *ecom_str;
741 struct listnode *node, *nnode;
742 struct ecommunity *ecom;
743
744 if (!bgp->l3vni)
745 return;
746
747 if (json) {
748 json_vni = json_object_new_object();
749 json_import_rtl = json_object_new_array();
750 json_export_rtl = json_object_new_array();
751 }
752
753 /* if an l3vni is present in bgp it is live */
754 buf1[0] = '\0';
755 sprintf(buf1, "*");
756
757 if (json) {
758 json_object_int_add(json_vni, "vni", bgp->l3vni);
759 json_object_string_add(json_vni, "type", "L3");
760 json_object_string_add(json_vni, "inKernel", "True");
761 json_object_string_add(json_vni, "originatorIp",
762 inet_ntoa(bgp->originator_ip));
763 json_object_string_add(
764 json_vni, "rd",
765 prefix_rd2str(&bgp->vrf_prd, buf2, RD_ADDRSTRLEN));
766 } else {
767 vty_out(vty, "%-1s %-10u %-4s %-21s", buf1, bgp->l3vni, "L3",
768 prefix_rd2str(&bgp->vrf_prd, buf2, RD_ADDRSTRLEN));
769 }
770
771 for (ALL_LIST_ELEMENTS(bgp->vrf_import_rtl, node, nnode, ecom)) {
772 ecom_str = ecommunity_ecom2str(ecom,
773 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
774
775 if (json) {
776 json_object_array_add(json_import_rtl,
777 json_object_new_string(ecom_str));
778 } else {
779 if (listcount(bgp->vrf_import_rtl) > 1)
780 sprintf(rt_buf, "%s, ...", ecom_str);
781 else
782 sprintf(rt_buf, "%s", ecom_str);
783 vty_out(vty, " %-25s", rt_buf);
784 }
785
786 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
787
788 /* If there are multiple import RTs we break here and show only
789 * one */
790 if (!json)
791 break;
792 }
793
794 if (json)
795 json_object_object_add(json_vni, "importRTs", json_import_rtl);
796
797 for (ALL_LIST_ELEMENTS(bgp->vrf_export_rtl, node, nnode, ecom)) {
798 ecom_str = ecommunity_ecom2str(ecom,
799 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
800
801 if (json) {
802 json_object_array_add(json_export_rtl,
803 json_object_new_string(ecom_str));
804 } else {
805 if (listcount(bgp->vrf_export_rtl) > 1)
806 sprintf(rt_buf, "%s, ...", ecom_str);
807 else
808 sprintf(rt_buf, "%s", ecom_str);
809 vty_out(vty, " %-25s", rt_buf);
810 }
811
812 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
813
814 /* If there are multiple export RTs we break here and show only
815 * one */
816 if (!json)
817 break;
818 }
819
820 if (!json)
821 vty_out(vty, "%-37s", vrf_id_to_name(bgp->vrf_id));
822
823 if (json) {
824 char vni_str[VNI_STR_LEN];
825
826 json_object_object_add(json_vni, "exportRTs", json_export_rtl);
827 snprintf(vni_str, VNI_STR_LEN, "%u", bgp->l3vni);
828 json_object_object_add(json, vni_str, json_vni);
829 } else {
830 vty_out(vty, "\n");
831 }
832 }
833
834 static void show_es_entry(struct hash_backet *backet, void *args[])
835 {
836 char buf[ESI_STR_LEN];
837 char buf1[RD_ADDRSTRLEN];
838 char buf2[INET6_ADDRSTRLEN];
839 struct in_addr *vtep = NULL;
840 struct vty *vty = args[0];
841 json_object *json = args[1];
842 json_object *json_vteps = NULL;
843 struct listnode *node = NULL;
844 struct evpnes *es = (struct evpnes *)backet->data;
845
846 if (json) {
847 json_vteps = json_object_new_array();
848 json_object_string_add(json, "esi",
849 esi_to_str(&es->esi, buf, sizeof(buf)));
850 json_object_string_add(json, "type",
851 is_es_local(es) ? "Local" : "Remote");
852 json_object_string_add(json, "rd",
853 prefix_rd2str(&es->prd, buf1,
854 sizeof(buf1)));
855 json_object_string_add(
856 json, "originatorIp",
857 ipaddr2str(&es->originator_ip, buf2, sizeof(buf2)));
858 if (es->vtep_list) {
859 for (ALL_LIST_ELEMENTS_RO(es->vtep_list, node, vtep))
860 json_object_array_add(json_vteps,
861 json_object_new_string(
862 inet_ntoa(*vtep)));
863 }
864 json_object_object_add(json, "vteps", json_vteps);
865 } else {
866 vty_out(vty, "%-30s %-6s %-21s %-15s %-6d\n",
867 esi_to_str(&es->esi, buf, sizeof(buf)),
868 is_es_local(es) ? "Local" : "Remote",
869 prefix_rd2str(&es->prd, buf1, sizeof(buf1)),
870 ipaddr2str(&es->originator_ip, buf2,
871 sizeof(buf2)),
872 es->vtep_list ? listcount(es->vtep_list) : 0);
873 }
874 }
875
876 static void show_vni_entry(struct hash_backet *backet, void *args[])
877 {
878 struct vty *vty;
879 json_object *json;
880 json_object *json_vni = NULL;
881 json_object *json_import_rtl = NULL;
882 json_object *json_export_rtl = NULL;
883 struct bgpevpn *vpn = (struct bgpevpn *)backet->data;
884 char buf1[10];
885 char buf2[RD_ADDRSTRLEN];
886 char rt_buf[25];
887 char *ecom_str;
888 struct listnode *node, *nnode;
889 struct ecommunity *ecom;
890
891 vty = args[0];
892 json = args[1];
893
894 if (json) {
895 json_vni = json_object_new_object();
896 json_import_rtl = json_object_new_array();
897 json_export_rtl = json_object_new_array();
898 }
899
900 buf1[0] = '\0';
901 if (is_vni_live(vpn))
902 sprintf(buf1, "*");
903
904 if (json) {
905 json_object_int_add(json_vni, "vni", vpn->vni);
906 json_object_string_add(json_vni, "type", "L2");
907 json_object_string_add(json_vni, "inKernel",
908 is_vni_live(vpn) ? "True" : "False");
909 json_object_string_add(json_vni, "originatorIp",
910 inet_ntoa(vpn->originator_ip));
911 json_object_string_add(json_vni, "originatorIp",
912 inet_ntoa(vpn->originator_ip));
913 json_object_string_add(
914 json_vni, "rd",
915 prefix_rd2str(&vpn->prd, buf2, sizeof(buf2)));
916 } else {
917 vty_out(vty, "%-1s %-10u %-4s %-21s", buf1, vpn->vni, "L2",
918 prefix_rd2str(&vpn->prd, buf2, RD_ADDRSTRLEN));
919 }
920
921 for (ALL_LIST_ELEMENTS(vpn->import_rtl, node, nnode, ecom)) {
922 ecom_str = ecommunity_ecom2str(ecom,
923 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
924
925 if (json) {
926 json_object_array_add(json_import_rtl,
927 json_object_new_string(ecom_str));
928 } else {
929 if (listcount(vpn->import_rtl) > 1)
930 sprintf(rt_buf, "%s, ...", ecom_str);
931 else
932 sprintf(rt_buf, "%s", ecom_str);
933 vty_out(vty, " %-25s", rt_buf);
934 }
935
936 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
937
938 /* If there are multiple import RTs we break here and show only
939 * one */
940 if (!json)
941 break;
942 }
943
944 if (json)
945 json_object_object_add(json_vni, "importRTs", json_import_rtl);
946
947 for (ALL_LIST_ELEMENTS(vpn->export_rtl, node, nnode, ecom)) {
948 ecom_str = ecommunity_ecom2str(ecom,
949 ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
950
951 if (json) {
952 json_object_array_add(json_export_rtl,
953 json_object_new_string(ecom_str));
954 } else {
955 if (listcount(vpn->export_rtl) > 1)
956 sprintf(rt_buf, "%s, ...", ecom_str);
957 else
958 sprintf(rt_buf, "%s", ecom_str);
959 vty_out(vty, " %-25s", rt_buf);
960 }
961
962 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
963
964 /* If there are multiple export RTs we break here and show only
965 * one */
966 if (!json)
967 break;
968 }
969
970 if (!json)
971 vty_out(vty, "%-37s", vrf_id_to_name(vpn->tenant_vrf_id));
972
973 if (json) {
974 char vni_str[VNI_STR_LEN];
975
976 json_object_object_add(json_vni, "exportRTs", json_export_rtl);
977 snprintf(vni_str, VNI_STR_LEN, "%u", vpn->vni);
978 json_object_object_add(json, vni_str, json_vni);
979 } else {
980 vty_out(vty, "\n");
981 }
982 }
983
984 static int bgp_show_ethernet_vpn(struct vty *vty, struct prefix_rd *prd,
985 enum bgp_show_type type, void *output_arg,
986 int option, bool use_json)
987 {
988 afi_t afi = AFI_L2VPN;
989 struct bgp *bgp;
990 struct bgp_table *table;
991 struct bgp_node *rn;
992 struct bgp_node *rm;
993 struct bgp_info *ri;
994 int rd_header;
995 int header = 1;
996
997 unsigned long output_count = 0;
998 unsigned long total_count = 0;
999 json_object *json = NULL;
1000 json_object *json_nroute = NULL;
1001 json_object *json_array = NULL;
1002 json_object *json_scode = NULL;
1003 json_object *json_ocode = NULL;
1004
1005 bgp = bgp_get_default();
1006 if (bgp == NULL) {
1007 if (!use_json)
1008 vty_out(vty, "No BGP process is configured\n");
1009 else
1010 vty_out(vty, "{}\n");
1011 return CMD_WARNING;
1012 }
1013
1014 if (use_json) {
1015 json_scode = json_object_new_object();
1016 json_ocode = json_object_new_object();
1017 json = json_object_new_object();
1018 json_nroute = json_object_new_object();
1019
1020 json_object_string_add(json_scode, "suppressed", "s");
1021 json_object_string_add(json_scode, "damped", "d");
1022 json_object_string_add(json_scode, "history", "h");
1023 json_object_string_add(json_scode, "valid", "*");
1024 json_object_string_add(json_scode, "best", ">");
1025 json_object_string_add(json_scode, "internal", "i");
1026
1027 json_object_string_add(json_ocode, "igp", "i");
1028 json_object_string_add(json_ocode, "egp", "e");
1029 json_object_string_add(json_ocode, "incomplete", "?");
1030 }
1031
1032 for (rn = bgp_table_top(bgp->rib[afi][SAFI_EVPN]); rn;
1033 rn = bgp_route_next(rn)) {
1034 uint64_t tbl_ver;
1035
1036 if (use_json)
1037 continue; /* XXX json TODO */
1038
1039 if (prd && memcmp(rn->p.u.val, prd->val, 8) != 0)
1040 continue;
1041
1042 if ((table = rn->info) == NULL)
1043 continue;
1044
1045 rd_header = 1;
1046 tbl_ver = table->version;
1047
1048 for (rm = bgp_table_top(table); rm; rm = bgp_route_next(rm))
1049 for (ri = rm->info; ri; ri = ri->next) {
1050 total_count++;
1051 if (type == bgp_show_type_neighbor) {
1052 union sockunion *su = output_arg;
1053
1054 if (ri->peer->su_remote == NULL
1055 || !sockunion_same(
1056 ri->peer->su_remote, su))
1057 continue;
1058 }
1059 if (header == 0) {
1060 if (use_json) {
1061 if (option
1062 == SHOW_DISPLAY_TAGS) {
1063 json_object_int_add(
1064 json,
1065 "bgpTableVersion",
1066 tbl_ver);
1067 json_object_string_add(
1068 json,
1069 "bgpLocalRouterId",
1070 inet_ntoa(
1071 bgp->router_id));
1072 json_object_object_add(
1073 json,
1074 "bgpStatusCodes",
1075 json_scode);
1076 json_object_object_add(
1077 json,
1078 "bgpOriginCodes",
1079 json_ocode);
1080 }
1081 } else {
1082 if (option == SHOW_DISPLAY_TAGS)
1083 vty_out(vty,
1084 V4_HEADER_TAG);
1085 else if (
1086 option
1087 == SHOW_DISPLAY_OVERLAY)
1088 vty_out(vty,
1089 V4_HEADER_OVERLAY);
1090 else {
1091 vty_out(vty,
1092 "BGP table version is %" PRIu64 ", local router ID is %s\n",
1093 tbl_ver,
1094 inet_ntoa(
1095 bgp->router_id));
1096 vty_out(vty,
1097 "Status codes: s suppressed, d damped, h history, * valid, > best, i - internal\n");
1098 vty_out(vty,
1099 "Origin codes: i - IGP, e - EGP, ? - incomplete\n\n");
1100 vty_out(vty, V4_HEADER);
1101 }
1102 }
1103 header = 0;
1104 }
1105 if (rd_header) {
1106 uint16_t type;
1107 struct rd_as rd_as;
1108 struct rd_ip rd_ip;
1109 uint8_t *pnt;
1110
1111 pnt = rn->p.u.val;
1112
1113 /* Decode RD type. */
1114 type = decode_rd_type(pnt);
1115 /* Decode RD value. */
1116 if (type == RD_TYPE_AS)
1117 decode_rd_as(pnt + 2, &rd_as);
1118 else if (type == RD_TYPE_AS4)
1119 decode_rd_as4(pnt + 2, &rd_as);
1120 else if (type == RD_TYPE_IP)
1121 decode_rd_ip(pnt + 2, &rd_ip);
1122 if (use_json) {
1123 char buffer[BUFSIZ];
1124 if (type == RD_TYPE_AS
1125 || type == RD_TYPE_AS4)
1126 sprintf(buffer, "%u:%d",
1127 rd_as.as,
1128 rd_as.val);
1129 else if (type == RD_TYPE_IP)
1130 sprintf(buffer, "%s:%d",
1131 inet_ntoa(
1132 rd_ip.ip),
1133 rd_ip.val);
1134 json_object_string_add(
1135 json_nroute,
1136 "routeDistinguisher",
1137 buffer);
1138 } else {
1139 vty_out(vty,
1140 "Route Distinguisher: ");
1141 if (type == RD_TYPE_AS)
1142 vty_out(vty,
1143 "as2 %u:%d",
1144 rd_as.as,
1145 rd_as.val);
1146 else if (type == RD_TYPE_AS4)
1147 vty_out(vty,
1148 "as4 %u:%d",
1149 rd_as.as,
1150 rd_as.val);
1151 else if (type == RD_TYPE_IP)
1152 vty_out(vty, "ip %s:%d",
1153 inet_ntoa(
1154 rd_ip.ip),
1155 rd_ip.val);
1156 vty_out(vty, "\n\n");
1157 }
1158 rd_header = 0;
1159 }
1160 if (use_json)
1161 json_array = json_object_new_array();
1162 else
1163 json_array = NULL;
1164 if (option == SHOW_DISPLAY_TAGS)
1165 route_vty_out_tag(vty, &rm->p, ri, 0,
1166 SAFI_EVPN,
1167 json_array);
1168 else if (option == SHOW_DISPLAY_OVERLAY)
1169 route_vty_out_overlay(vty, &rm->p, ri,
1170 0, json_array);
1171 else
1172 route_vty_out(vty, &rm->p, ri, 0,
1173 SAFI_EVPN, json_array);
1174 output_count++;
1175 }
1176 /* XXX json */
1177 }
1178 if (output_count == 0)
1179 vty_out(vty, "No prefixes displayed, %ld exist\n", total_count);
1180 else
1181 vty_out(vty, "\nDisplayed %ld out of %ld total prefixes\n",
1182 output_count, total_count);
1183 return CMD_SUCCESS;
1184 }
1185
1186 DEFUN(show_ip_bgp_l2vpn_evpn,
1187 show_ip_bgp_l2vpn_evpn_cmd,
1188 "show [ip] bgp l2vpn evpn [json]",
1189 SHOW_STR IP_STR BGP_STR L2VPN_HELP_STR EVPN_HELP_STR JSON_STR)
1190 {
1191 return bgp_show_ethernet_vpn(vty, NULL, bgp_show_type_normal, NULL, 0,
1192 use_json(argc, argv));
1193 }
1194
1195 DEFUN(show_ip_bgp_l2vpn_evpn_rd,
1196 show_ip_bgp_l2vpn_evpn_rd_cmd,
1197 "show [ip] bgp l2vpn evpn rd ASN:NN_OR_IP-ADDRESS:NN [json]",
1198 SHOW_STR
1199 IP_STR
1200 BGP_STR
1201 L2VPN_HELP_STR
1202 EVPN_HELP_STR
1203 "Display information for a route distinguisher\n"
1204 "VPN Route Distinguisher\n" JSON_STR)
1205 {
1206 int idx_ext_community = 0;
1207 int ret;
1208 struct prefix_rd prd;
1209
1210 argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
1211
1212 ret = str2prefix_rd(argv[idx_ext_community]->arg, &prd);
1213 if (!ret) {
1214 vty_out(vty, "%% Malformed Route Distinguisher\n");
1215 return CMD_WARNING;
1216 }
1217 return bgp_show_ethernet_vpn(vty, &prd, bgp_show_type_normal, NULL, 0,
1218 use_json(argc, argv));
1219 }
1220
1221 DEFUN(show_ip_bgp_l2vpn_evpn_all_tags,
1222 show_ip_bgp_l2vpn_evpn_all_tags_cmd,
1223 "show [ip] bgp l2vpn evpn all tags",
1224 SHOW_STR
1225 IP_STR
1226 BGP_STR
1227 L2VPN_HELP_STR
1228 EVPN_HELP_STR
1229 "Display information about all EVPN NLRIs\n"
1230 "Display BGP tags for prefixes\n")
1231 {
1232 return bgp_show_ethernet_vpn(vty, NULL, bgp_show_type_normal, NULL, 1,
1233 0);
1234 }
1235
1236 DEFUN(show_ip_bgp_l2vpn_evpn_rd_tags,
1237 show_ip_bgp_l2vpn_evpn_rd_tags_cmd,
1238 "show [ip] bgp l2vpn evpn rd ASN:NN_OR_IP-ADDRESS:NN tags",
1239 SHOW_STR
1240 IP_STR
1241 BGP_STR
1242 L2VPN_HELP_STR
1243 EVPN_HELP_STR
1244 "Display information for a route distinguisher\n"
1245 "VPN Route Distinguisher\n" "Display BGP tags for prefixes\n")
1246 {
1247 int idx_ext_community = 0;
1248 int ret;
1249 struct prefix_rd prd;
1250
1251 argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
1252
1253 ret = str2prefix_rd(argv[idx_ext_community]->arg, &prd);
1254 if (!ret) {
1255 vty_out(vty, "%% Malformed Route Distinguisher\n");
1256 return CMD_WARNING;
1257 }
1258 return bgp_show_ethernet_vpn(vty, &prd, bgp_show_type_normal, NULL, 1,
1259 0);
1260 }
1261
1262 DEFUN(show_ip_bgp_l2vpn_evpn_all_neighbor_routes,
1263 show_ip_bgp_l2vpn_evpn_all_neighbor_routes_cmd,
1264 "show [ip] bgp l2vpn evpn all neighbors A.B.C.D routes [json]",
1265 SHOW_STR
1266 IP_STR
1267 BGP_STR
1268 L2VPN_HELP_STR
1269 EVPN_HELP_STR
1270 "Display information about all EVPN NLRIs\n"
1271 "Detailed information on TCP and BGP neighbor connections\n"
1272 "Neighbor to display information about\n"
1273 "Display routes learned from neighbor\n" JSON_STR)
1274 {
1275 int idx_ipv4 = 0;
1276 union sockunion su;
1277 struct peer *peer;
1278 int ret;
1279 bool uj = use_json(argc, argv);
1280
1281 argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
1282
1283 ret = str2sockunion(argv[idx_ipv4]->arg, &su);
1284 if (ret < 0) {
1285 if (uj) {
1286 json_object *json_no = NULL;
1287 json_no = json_object_new_object();
1288 json_object_string_add(json_no, "warning",
1289 "Malformed address");
1290 vty_out(vty, "%s\n",
1291 json_object_to_json_string(json_no));
1292 json_object_free(json_no);
1293 } else
1294 vty_out(vty, "Malformed address: %s\n",
1295 argv[idx_ipv4]->arg);
1296 return CMD_WARNING;
1297 }
1298
1299 peer = peer_lookup(NULL, &su);
1300 if (!peer || !peer->afc[AFI_L2VPN][SAFI_EVPN]) {
1301 if (uj) {
1302 json_object *json_no = NULL;
1303 json_no = json_object_new_object();
1304 json_object_string_add(
1305 json_no, "warning",
1306 "No such neighbor or address family");
1307 vty_out(vty, "%s\n",
1308 json_object_to_json_string(json_no));
1309 json_object_free(json_no);
1310 } else
1311 vty_out(vty, "%% No such neighbor or address family\n");
1312 return CMD_WARNING;
1313 }
1314
1315 return bgp_show_ethernet_vpn(vty, NULL, bgp_show_type_neighbor, &su, 0,
1316 uj);
1317 }
1318
1319 DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_routes,
1320 show_ip_bgp_l2vpn_evpn_rd_neighbor_routes_cmd,
1321 "show [ip] bgp l2vpn evpn rd ASN:NN_OR_IP-ADDRESS:NN neighbors A.B.C.D routes [json]",
1322 SHOW_STR
1323 IP_STR
1324 BGP_STR
1325 L2VPN_HELP_STR
1326 EVPN_HELP_STR
1327 "Display information for a route distinguisher\n"
1328 "VPN Route Distinguisher\n"
1329 "Detailed information on TCP and BGP neighbor connections\n"
1330 "Neighbor to display information about\n"
1331 "Display routes learned from neighbor\n" JSON_STR)
1332 {
1333 int idx_ext_community = 0;
1334 int idx_ipv4 = 0;
1335 int ret;
1336 union sockunion su;
1337 struct peer *peer;
1338 struct prefix_rd prd;
1339 bool uj = use_json(argc, argv);
1340
1341 argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
1342 argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
1343
1344 ret = str2prefix_rd(argv[idx_ext_community]->arg, &prd);
1345 if (!ret) {
1346 if (uj) {
1347 json_object *json_no = NULL;
1348 json_no = json_object_new_object();
1349 json_object_string_add(json_no, "warning",
1350 "Malformed Route Distinguisher");
1351 vty_out(vty, "%s\n",
1352 json_object_to_json_string(json_no));
1353 json_object_free(json_no);
1354 } else
1355 vty_out(vty, "%% Malformed Route Distinguisher\n");
1356 return CMD_WARNING;
1357 }
1358
1359 ret = str2sockunion(argv[idx_ipv4]->arg, &su);
1360 if (ret < 0) {
1361 if (uj) {
1362 json_object *json_no = NULL;
1363 json_no = json_object_new_object();
1364 json_object_string_add(json_no, "warning",
1365 "Malformed address");
1366 vty_out(vty, "%s\n",
1367 json_object_to_json_string(json_no));
1368 json_object_free(json_no);
1369 } else
1370 vty_out(vty, "Malformed address: %s\n",
1371 argv[idx_ext_community]->arg);
1372 return CMD_WARNING;
1373 }
1374
1375 peer = peer_lookup(NULL, &su);
1376 if (!peer || !peer->afc[AFI_L2VPN][SAFI_EVPN]) {
1377 if (uj) {
1378 json_object *json_no = NULL;
1379 json_no = json_object_new_object();
1380 json_object_string_add(
1381 json_no, "warning",
1382 "No such neighbor or address family");
1383 vty_out(vty, "%s\n",
1384 json_object_to_json_string(json_no));
1385 json_object_free(json_no);
1386 } else
1387 vty_out(vty, "%% No such neighbor or address family\n");
1388 return CMD_WARNING;
1389 }
1390
1391 return bgp_show_ethernet_vpn(vty, &prd, bgp_show_type_neighbor, &su, 0,
1392 uj);
1393 }
1394
1395 DEFUN(show_ip_bgp_l2vpn_evpn_all_neighbor_advertised_routes,
1396 show_ip_bgp_l2vpn_evpn_all_neighbor_advertised_routes_cmd,
1397 "show [ip] bgp l2vpn evpn all neighbors A.B.C.D advertised-routes [json]",
1398 SHOW_STR
1399 IP_STR
1400 BGP_STR
1401 L2VPN_HELP_STR
1402 EVPN_HELP_STR
1403 "Display information about all EVPN NLRIs\n"
1404 "Detailed information on TCP and BGP neighbor connections\n"
1405 "Neighbor to display information about\n"
1406 "Display the routes advertised to a BGP neighbor\n" JSON_STR)
1407 {
1408 int idx_ipv4 = 0;
1409 int ret;
1410 struct peer *peer;
1411 union sockunion su;
1412 bool uj = use_json(argc, argv);
1413
1414 argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
1415
1416 ret = str2sockunion(argv[idx_ipv4]->arg, &su);
1417 if (ret < 0) {
1418 if (uj) {
1419 json_object *json_no = NULL;
1420 json_no = json_object_new_object();
1421 json_object_string_add(json_no, "warning",
1422 "Malformed address");
1423 vty_out(vty, "%s\n",
1424 json_object_to_json_string(json_no));
1425 json_object_free(json_no);
1426 } else
1427 vty_out(vty, "Malformed address: %s\n",
1428 argv[idx_ipv4]->arg);
1429 return CMD_WARNING;
1430 }
1431 peer = peer_lookup(NULL, &su);
1432 if (!peer || !peer->afc[AFI_L2VPN][SAFI_EVPN]) {
1433 if (uj) {
1434 json_object *json_no = NULL;
1435 json_no = json_object_new_object();
1436 json_object_string_add(
1437 json_no, "warning",
1438 "No such neighbor or address family");
1439 vty_out(vty, "%s\n",
1440 json_object_to_json_string(json_no));
1441 json_object_free(json_no);
1442 } else
1443 vty_out(vty, "%% No such neighbor or address family\n");
1444 return CMD_WARNING;
1445 }
1446
1447 return show_adj_route_vpn(vty, peer, NULL, AFI_L2VPN, SAFI_EVPN, uj);
1448 }
1449
1450 DEFUN(show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes,
1451 show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes_cmd,
1452 "show [ip] bgp l2vpn evpn rd ASN:NN_OR_IP-ADDRESS:NN neighbors A.B.C.D advertised-routes [json]",
1453 SHOW_STR
1454 IP_STR
1455 BGP_STR
1456 L2VPN_HELP_STR
1457 EVPN_HELP_STR
1458 "Display information for a route distinguisher\n"
1459 "VPN Route Distinguisher\n"
1460 "Detailed information on TCP and BGP neighbor connections\n"
1461 "Neighbor to display information about\n"
1462 "Display the routes advertised to a BGP neighbor\n" JSON_STR)
1463 {
1464 int idx_ext_community = 0;
1465 int idx_ipv4 = 0;
1466 int ret;
1467 struct peer *peer;
1468 struct prefix_rd prd;
1469 union sockunion su;
1470 bool uj = use_json(argc, argv);
1471
1472 argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
1473 argv_find(argv, argc, "A.B.C.D", &idx_ipv4);
1474
1475 ret = str2sockunion(argv[idx_ipv4]->arg, &su);
1476 if (ret < 0) {
1477 if (uj) {
1478 json_object *json_no = NULL;
1479 json_no = json_object_new_object();
1480 json_object_string_add(json_no, "warning",
1481 "Malformed address");
1482 vty_out(vty, "%s\n",
1483 json_object_to_json_string(json_no));
1484 json_object_free(json_no);
1485 } else
1486 vty_out(vty, "Malformed address: %s\n",
1487 argv[idx_ext_community]->arg);
1488 return CMD_WARNING;
1489 }
1490 peer = peer_lookup(NULL, &su);
1491 if (!peer || !peer->afc[AFI_L2VPN][SAFI_EVPN]) {
1492 if (uj) {
1493 json_object *json_no = NULL;
1494 json_no = json_object_new_object();
1495 json_object_string_add(
1496 json_no, "warning",
1497 "No such neighbor or address family");
1498 vty_out(vty, "%s\n",
1499 json_object_to_json_string(json_no));
1500 json_object_free(json_no);
1501 } else
1502 vty_out(vty, "%% No such neighbor or address family\n");
1503 return CMD_WARNING;
1504 }
1505
1506 ret = str2prefix_rd(argv[idx_ext_community]->arg, &prd);
1507 if (!ret) {
1508 if (uj) {
1509 json_object *json_no = NULL;
1510 json_no = json_object_new_object();
1511 json_object_string_add(json_no, "warning",
1512 "Malformed Route Distinguisher");
1513 vty_out(vty, "%s\n",
1514 json_object_to_json_string(json_no));
1515 json_object_free(json_no);
1516 } else
1517 vty_out(vty, "%% Malformed Route Distinguisher\n");
1518 return CMD_WARNING;
1519 }
1520
1521 return show_adj_route_vpn(vty, peer, &prd, AFI_L2VPN, SAFI_EVPN, uj);
1522 }
1523
1524 DEFUN(show_ip_bgp_l2vpn_evpn_all_overlay,
1525 show_ip_bgp_l2vpn_evpn_all_overlay_cmd,
1526 "show [ip] bgp l2vpn evpn all overlay",
1527 SHOW_STR
1528 IP_STR
1529 BGP_STR
1530 L2VPN_HELP_STR
1531 EVPN_HELP_STR
1532 "Display information about all EVPN NLRIs\n"
1533 "Display BGP Overlay Information for prefixes\n")
1534 {
1535 return bgp_show_ethernet_vpn(vty, NULL, bgp_show_type_normal, NULL,
1536 SHOW_DISPLAY_OVERLAY,
1537 use_json(argc, argv));
1538 }
1539
1540 DEFUN(show_ip_bgp_evpn_rd_overlay,
1541 show_ip_bgp_evpn_rd_overlay_cmd,
1542 "show [ip] bgp l2vpn evpn rd ASN:NN_OR_IP-ADDRESS:NN overlay",
1543 SHOW_STR
1544 IP_STR
1545 BGP_STR
1546 L2VPN_HELP_STR
1547 EVPN_HELP_STR
1548 "Display information for a route distinguisher\n"
1549 "VPN Route Distinguisher\n"
1550 "Display BGP Overlay Information for prefixes\n")
1551 {
1552 int idx_ext_community = 0;
1553 int ret;
1554 struct prefix_rd prd;
1555
1556 argv_find(argv, argc, "ASN:NN_OR_IP-ADDRESS:NN", &idx_ext_community);
1557
1558 ret = str2prefix_rd(argv[idx_ext_community]->arg, &prd);
1559 if (!ret) {
1560 vty_out(vty, "%% Malformed Route Distinguisher\n");
1561 return CMD_WARNING;
1562 }
1563 return bgp_show_ethernet_vpn(vty, &prd, bgp_show_type_normal, NULL,
1564 SHOW_DISPLAY_OVERLAY,
1565 use_json(argc, argv));
1566 }
1567
1568 /* For testing purpose, static route of MPLS-VPN. */
1569 DEFUN(evpnrt5_network,
1570 evpnrt5_network_cmd,
1571 "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 WORD]",
1572 "Specify a network to announce via BGP\n"
1573 "IP prefix\n"
1574 "IPv6 prefix\n"
1575 "Specify Route Distinguisher\n"
1576 "VPN Route Distinguisher\n"
1577 "Ethernet Tag\n"
1578 "Ethernet Tag Value\n"
1579 "BGP label\n"
1580 "label value\n"
1581 "Ethernet Segment Identifier\n"
1582 "ESI value ( 00:11:22:33:44:55:66:77:88:99 format) \n"
1583 "Gateway IP\n"
1584 "Gateway IP ( A.B.C.D )\n"
1585 "Gateway IPv6 ( X:X::X:X )\n"
1586 "Router Mac Ext Comm\n"
1587 "Router Mac address Value ( aa:bb:cc:dd:ee:ff format)\n"
1588 "Route-map to modify the attributes\n"
1589 "Name of the route map\n")
1590 {
1591 int idx_ipv4_prefixlen = 1;
1592 int idx_route_distinguisher = 3;
1593 int idx_label = 7;
1594 int idx_esi = 9;
1595 int idx_gwip = 11;
1596 int idx_ethtag = 5;
1597 int idx_routermac = 13;
1598
1599 return bgp_static_set_safi(
1600 AFI_L2VPN, SAFI_EVPN, vty, argv[idx_ipv4_prefixlen]->arg,
1601 argv[idx_route_distinguisher]->arg, argv[idx_label]->arg, NULL,
1602 BGP_EVPN_IP_PREFIX_ROUTE, argv[idx_esi]->arg,
1603 argv[idx_gwip]->arg, argv[idx_ethtag]->arg,
1604 argv[idx_routermac]->arg);
1605 }
1606
1607 /* For testing purpose, static route of MPLS-VPN. */
1608 DEFUN(no_evpnrt5_network,
1609 no_evpnrt5_network_cmd,
1610 "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>",
1611 NO_STR
1612 "Specify a network to announce via BGP\n"
1613 "IP prefix\n"
1614 "IPv6 prefix\n"
1615 "Specify Route Distinguisher\n"
1616 "VPN Route Distinguisher\n"
1617 "Ethernet Tag\n"
1618 "Ethernet Tag Value\n"
1619 "BGP label\n"
1620 "label value\n"
1621 "Ethernet Segment Identifier\n"
1622 "ESI value ( 00:11:22:33:44:55:66:77:88:99 format) \n"
1623 "Gateway IP\n" "Gateway IP ( A.B.C.D )\n" "Gateway IPv6 ( X:X::X:X )\n")
1624 {
1625 int idx_ipv4_prefixlen = 2;
1626 int idx_ext_community = 4;
1627 int idx_label = 8;
1628 int idx_ethtag = 6;
1629 int idx_esi = 10;
1630 int idx_gwip = 12;
1631 return bgp_static_unset_safi(
1632 AFI_L2VPN, SAFI_EVPN, vty, argv[idx_ipv4_prefixlen]->arg,
1633 argv[idx_ext_community]->arg, argv[idx_label]->arg,
1634 BGP_EVPN_IP_PREFIX_ROUTE, argv[idx_esi]->arg,
1635 argv[idx_gwip]->arg, argv[idx_ethtag]->arg);
1636 }
1637
1638 static void evpn_import_rt_delete_auto(struct bgp *bgp, struct bgpevpn *vpn)
1639 {
1640 evpn_rt_delete_auto(bgp, vpn->vni, vpn->import_rtl);
1641 }
1642
1643 static void evpn_export_rt_delete_auto(struct bgp *bgp, struct bgpevpn *vpn)
1644 {
1645 evpn_rt_delete_auto(bgp, vpn->vni, vpn->export_rtl);
1646 }
1647
1648 /*
1649 * Configure the Import RTs for a VNI (vty handler). Caller expected to
1650 * check that this is a change.
1651 */
1652 static void evpn_configure_import_rt(struct bgp *bgp, struct bgpevpn *vpn,
1653 struct ecommunity *ecomadd)
1654 {
1655 /* If the VNI is "live", we need to uninstall routes using the current
1656 * import RT(s) first before we update the import RT, and subsequently
1657 * install routes.
1658 */
1659 if (is_vni_live(vpn))
1660 bgp_evpn_uninstall_routes(bgp, vpn);
1661
1662 /* Cleanup the RT to VNI mapping and get rid of existing import RT. */
1663 bgp_evpn_unmap_vni_from_its_rts(bgp, vpn);
1664
1665 /* If the auto route-target is in use we must remove it */
1666 evpn_import_rt_delete_auto(bgp, vpn);
1667
1668 /* Add new RT and rebuild the RT to VNI mapping */
1669 listnode_add_sort(vpn->import_rtl, ecomadd);
1670
1671 SET_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD);
1672 bgp_evpn_map_vni_to_its_rts(bgp, vpn);
1673
1674 /* Install routes that match new import RT */
1675 if (is_vni_live(vpn))
1676 bgp_evpn_install_routes(bgp, vpn);
1677 }
1678
1679 /*
1680 * Unconfigure Import RT(s) for a VNI (vty handler).
1681 */
1682 static void evpn_unconfigure_import_rt(struct bgp *bgp, struct bgpevpn *vpn,
1683 struct ecommunity *ecomdel)
1684 {
1685 struct listnode *node, *nnode, *node_to_del;
1686 struct ecommunity *ecom;
1687
1688 /* Along the lines of "configure" except we have to reset to the
1689 * automatic value.
1690 */
1691 if (is_vni_live(vpn))
1692 bgp_evpn_uninstall_routes(bgp, vpn);
1693
1694 /* Cleanup the RT to VNI mapping and get rid of existing import RT. */
1695 bgp_evpn_unmap_vni_from_its_rts(bgp, vpn);
1696
1697 /* Delete all import RTs */
1698 if (ecomdel == NULL) {
1699 for (ALL_LIST_ELEMENTS(vpn->import_rtl, node, nnode, ecom))
1700 ecommunity_free(&ecom);
1701
1702 list_delete_all_node(vpn->import_rtl);
1703 }
1704
1705 /* Delete a specific import RT */
1706 else {
1707 node_to_del = NULL;
1708
1709 for (ALL_LIST_ELEMENTS(vpn->import_rtl, node, nnode, ecom)) {
1710 if (ecommunity_match(ecom, ecomdel)) {
1711 ecommunity_free(&ecom);
1712 node_to_del = node;
1713 break;
1714 }
1715 }
1716
1717 if (node_to_del)
1718 list_delete_node(vpn->import_rtl, node_to_del);
1719 }
1720
1721 assert(vpn->import_rtl);
1722 /* Reset to auto RT - this also rebuilds the RT to VNI mapping */
1723 if (list_isempty(vpn->import_rtl)) {
1724 UNSET_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD);
1725 bgp_evpn_derive_auto_rt_import(bgp, vpn);
1726 }
1727 /* Rebuild the RT to VNI mapping */
1728 else
1729 bgp_evpn_map_vni_to_its_rts(bgp, vpn);
1730
1731 /* Install routes that match new import RT */
1732 if (is_vni_live(vpn))
1733 bgp_evpn_install_routes(bgp, vpn);
1734 }
1735
1736 /*
1737 * Configure the Export RT for a VNI (vty handler). Caller expected to
1738 * check that this is a change. Note that only a single export RT is
1739 * allowed for a VNI and any change to configuration is implemented as
1740 * a "replace" (similar to other configuration).
1741 */
1742 static void evpn_configure_export_rt(struct bgp *bgp, struct bgpevpn *vpn,
1743 struct ecommunity *ecomadd)
1744 {
1745 /* If the auto route-target is in use we must remove it */
1746 evpn_export_rt_delete_auto(bgp, vpn);
1747
1748 listnode_add_sort(vpn->export_rtl, ecomadd);
1749 SET_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD);
1750
1751 if (is_vni_live(vpn))
1752 bgp_evpn_handle_export_rt_change(bgp, vpn);
1753 }
1754
1755 /*
1756 * Unconfigure the Export RT for a VNI (vty handler)
1757 */
1758 static void evpn_unconfigure_export_rt(struct bgp *bgp, struct bgpevpn *vpn,
1759 struct ecommunity *ecomdel)
1760 {
1761 struct listnode *node, *nnode, *node_to_del;
1762 struct ecommunity *ecom;
1763
1764 /* Delete all export RTs */
1765 if (ecomdel == NULL) {
1766 /* Reset to default and process all routes. */
1767 for (ALL_LIST_ELEMENTS(vpn->export_rtl, node, nnode, ecom))
1768 ecommunity_free(&ecom);
1769
1770 list_delete_all_node(vpn->export_rtl);
1771 }
1772
1773 /* Delete a specific export RT */
1774 else {
1775 node_to_del = NULL;
1776
1777 for (ALL_LIST_ELEMENTS(vpn->export_rtl, node, nnode, ecom)) {
1778 if (ecommunity_match(ecom, ecomdel)) {
1779 ecommunity_free(&ecom);
1780 node_to_del = node;
1781 break;
1782 }
1783 }
1784
1785 if (node_to_del)
1786 list_delete_node(vpn->export_rtl, node_to_del);
1787 }
1788
1789 assert(vpn->export_rtl);
1790 if (list_isempty(vpn->export_rtl)) {
1791 UNSET_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD);
1792 bgp_evpn_derive_auto_rt_export(bgp, vpn);
1793 }
1794
1795 if (is_vni_live(vpn))
1796 bgp_evpn_handle_export_rt_change(bgp, vpn);
1797 }
1798
1799 /*
1800 * Configure RD for VRF
1801 */
1802 static void evpn_configure_vrf_rd(struct bgp *bgp_vrf, struct prefix_rd *rd)
1803 {
1804 /* If we have already advertise type-5 routes with a diffrent RD, we
1805 * have to delete and withdraw them firs
1806 */
1807 bgp_evpn_handle_vrf_rd_change(bgp_vrf, 1);
1808
1809 /* update RD */
1810 memcpy(&bgp_vrf->vrf_prd, rd, sizeof(struct prefix_rd));
1811 SET_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD);
1812
1813 /* We have a new RD for VRF.
1814 * Advertise all type-5 routes again with the new RD
1815 */
1816 bgp_evpn_handle_vrf_rd_change(bgp_vrf, 0);
1817 }
1818
1819 /*
1820 * Unconfigure RD for VRF
1821 */
1822 static void evpn_unconfigure_vrf_rd(struct bgp *bgp_vrf)
1823 {
1824 /* If we have already advertise type-5 routes with a diffrent RD, we
1825 * have to delete and withdraw them firs
1826 */
1827 bgp_evpn_handle_vrf_rd_change(bgp_vrf, 1);
1828
1829 /* fall back to default RD */
1830 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf);
1831 UNSET_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD);
1832
1833 /* We have a new RD for VRF.
1834 * Advertise all type-5 routes again with the new RD
1835 */
1836 bgp_evpn_handle_vrf_rd_change(bgp_vrf, 0);
1837 }
1838
1839 /*
1840 * Configure RD for a VNI (vty handler)
1841 */
1842 static void evpn_configure_rd(struct bgp *bgp, struct bgpevpn *vpn,
1843 struct prefix_rd *rd)
1844 {
1845 /* If the VNI is "live", we need to delete and withdraw this VNI's
1846 * local routes with the prior RD first. Then, after updating RD,
1847 * need to re-advertise.
1848 */
1849 if (is_vni_live(vpn))
1850 bgp_evpn_handle_rd_change(bgp, vpn, 1);
1851
1852 /* update RD */
1853 memcpy(&vpn->prd, rd, sizeof(struct prefix_rd));
1854 SET_FLAG(vpn->flags, VNI_FLAG_RD_CFGD);
1855
1856 if (is_vni_live(vpn))
1857 bgp_evpn_handle_rd_change(bgp, vpn, 0);
1858 }
1859
1860 /*
1861 * Unconfigure RD for a VNI (vty handler)
1862 */
1863 static void evpn_unconfigure_rd(struct bgp *bgp, struct bgpevpn *vpn)
1864 {
1865 /* If the VNI is "live", we need to delete and withdraw this VNI's
1866 * local routes with the prior RD first. Then, after resetting RD
1867 * to automatic value, need to re-advertise.
1868 */
1869 if (is_vni_live(vpn))
1870 bgp_evpn_handle_rd_change(bgp, vpn, 1);
1871
1872 /* reset RD to default */
1873 bgp_evpn_derive_auto_rd(bgp, vpn);
1874
1875 if (is_vni_live(vpn))
1876 bgp_evpn_handle_rd_change(bgp, vpn, 0);
1877 }
1878
1879 /*
1880 * Create VNI, if not already present (VTY handler). Mark as configured.
1881 */
1882 static struct bgpevpn *evpn_create_update_vni(struct bgp *bgp, vni_t vni)
1883 {
1884 struct bgpevpn *vpn;
1885
1886 if (!bgp->vnihash)
1887 return NULL;
1888
1889 vpn = bgp_evpn_lookup_vni(bgp, vni);
1890 if (!vpn) {
1891 /* Check if this L2VNI is already configured as L3VNI */
1892 if (bgp_evpn_lookup_l3vni_l2vni_table(vni)) {
1893 flog_err(
1894 EC_BGP_VNI,
1895 "%u: Failed to create L2VNI %u, it is configured as L3VNI",
1896 bgp->vrf_id, vni);
1897 return NULL;
1898 }
1899
1900 /* tenant vrf will be updated when we get local_vni_add from
1901 * zebra
1902 */
1903 vpn = bgp_evpn_new(bgp, vni, bgp->router_id, 0);
1904 if (!vpn) {
1905 flog_err(
1906 EC_BGP_VNI,
1907 "%u: Failed to allocate VNI entry for VNI %u - at Config",
1908 bgp->vrf_id, vni);
1909 return NULL;
1910 }
1911 }
1912
1913 /* Mark as configured. */
1914 SET_FLAG(vpn->flags, VNI_FLAG_CFGD);
1915 return vpn;
1916 }
1917
1918 /*
1919 * Delete VNI. If VNI does not exist in the system (i.e., just
1920 * configuration), all that is needed is to free it. Otherwise,
1921 * any parameters configured for the VNI need to be reset (with
1922 * appropriate action) and the VNI marked as unconfigured; the
1923 * VNI will continue to exist, purely as a "learnt" entity.
1924 */
1925 static int evpn_delete_vni(struct bgp *bgp, struct bgpevpn *vpn)
1926 {
1927 assert(bgp->vnihash);
1928
1929 if (!is_vni_live(vpn)) {
1930 bgp_evpn_free(bgp, vpn);
1931 return 0;
1932 }
1933
1934 /* We need to take the unconfigure action for each parameter of this VNI
1935 * that is configured. Some optimization is possible, but not worth the
1936 * additional code for an operation that should be pretty rare.
1937 */
1938 UNSET_FLAG(vpn->flags, VNI_FLAG_CFGD);
1939
1940 /* First, deal with the export side - RD and export RT changes. */
1941 if (is_rd_configured(vpn))
1942 evpn_unconfigure_rd(bgp, vpn);
1943 if (is_export_rt_configured(vpn))
1944 evpn_unconfigure_export_rt(bgp, vpn, NULL);
1945
1946 /* Next, deal with the import side. */
1947 if (is_import_rt_configured(vpn))
1948 evpn_unconfigure_import_rt(bgp, vpn, NULL);
1949
1950 return 0;
1951 }
1952
1953 /*
1954 * Display import RT mapping to VRFs (vty handler)
1955 * bgp_def: default bgp instance
1956 */
1957 static void evpn_show_vrf_import_rts(struct vty *vty, struct bgp *bgp_def,
1958 json_object *json)
1959 {
1960 void *args[2];
1961
1962 args[0] = vty;
1963 args[1] = json;
1964
1965 hash_iterate(bgp_def->vrf_import_rt_hash,
1966 (void (*)(struct hash_backet *,
1967 void *))show_vrf_import_rt_entry,
1968 args);
1969 }
1970
1971 /*
1972 * Display import RT mapping to VNIs (vty handler)
1973 */
1974 static void evpn_show_import_rts(struct vty *vty, struct bgp *bgp,
1975 json_object *json)
1976 {
1977 void *args[2];
1978
1979 args[0] = vty;
1980 args[1] = json;
1981
1982 hash_iterate(
1983 bgp->import_rt_hash,
1984 (void (*)(struct hash_backet *, void *))show_import_rt_entry,
1985 args);
1986 }
1987
1988 /*
1989 * Display EVPN routes for all VNIs - vty handler.
1990 */
1991 static void evpn_show_routes_vni_all(struct vty *vty, struct bgp *bgp,
1992 struct in_addr vtep_ip, json_object *json)
1993 {
1994 uint32_t num_vnis;
1995 struct vni_walk_ctx wctx;
1996
1997 num_vnis = hashcount(bgp->vnihash);
1998 if (!num_vnis)
1999 return;
2000 memset(&wctx, 0, sizeof(struct vni_walk_ctx));
2001 wctx.bgp = bgp;
2002 wctx.vty = vty;
2003 wctx.vtep_ip = vtep_ip;
2004 wctx.json = json;
2005 hash_iterate(bgp->vnihash, (void (*)(struct hash_backet *,
2006 void *))show_vni_routes_hash,
2007 &wctx);
2008 }
2009
2010 /*
2011 * Display EVPN routes for a VNI -- for specific type-3 route (vty handler).
2012 */
2013 static void evpn_show_route_vni_multicast(struct vty *vty, struct bgp *bgp,
2014 vni_t vni, struct in_addr orig_ip,
2015 json_object *json)
2016 {
2017 struct bgpevpn *vpn;
2018 struct prefix_evpn p;
2019 struct bgp_node *rn;
2020 struct bgp_info *ri;
2021 uint32_t path_cnt = 0;
2022 afi_t afi;
2023 safi_t safi;
2024 json_object *json_paths = NULL;
2025
2026 afi = AFI_L2VPN;
2027 safi = SAFI_EVPN;
2028
2029 /* Locate VNI. */
2030 vpn = bgp_evpn_lookup_vni(bgp, vni);
2031 if (!vpn) {
2032 vty_out(vty, "VNI not found\n");
2033 return;
2034 }
2035
2036 /* See if route exists. */
2037 build_evpn_type3_prefix(&p, orig_ip);
2038 rn = bgp_node_lookup(vpn->route_table, (struct prefix *)&p);
2039 if (!rn || !rn->info) {
2040 if (!json)
2041 vty_out(vty, "%% Network not in table\n");
2042 return;
2043 }
2044
2045 if (json)
2046 json_paths = json_object_new_array();
2047
2048 /* Prefix and num paths displayed once per prefix. */
2049 route_vty_out_detail_header(vty, bgp, rn, NULL, afi, safi, json);
2050
2051 /* Display each path for this prefix. */
2052 for (ri = rn->info; ri; ri = ri->next) {
2053 json_object *json_path = NULL;
2054
2055 if (json)
2056 json_path = json_object_new_array();
2057
2058 route_vty_out_detail(vty, bgp, &rn->p, ri, afi, safi,
2059 json_path);
2060
2061 if (json)
2062 json_object_array_add(json_paths, json_path);
2063
2064 path_cnt++;
2065 }
2066
2067 if (json) {
2068 if (path_cnt)
2069 json_object_object_add(json, "paths", json_paths);
2070
2071 json_object_int_add(json, "numPaths", path_cnt);
2072 } else {
2073 vty_out(vty, "\nDisplayed %u paths for requested prefix\n",
2074 path_cnt);
2075 }
2076 }
2077
2078 /*
2079 * Display EVPN routes for a VNI -- for specific MAC and/or IP (vty handler).
2080 * By definition, only matching type-2 route will be displayed.
2081 */
2082 static void evpn_show_route_vni_macip(struct vty *vty, struct bgp *bgp,
2083 vni_t vni, struct ethaddr *mac,
2084 struct ipaddr *ip, json_object *json)
2085 {
2086 struct bgpevpn *vpn;
2087 struct prefix_evpn p;
2088 struct bgp_node *rn;
2089 struct bgp_info *ri;
2090 uint32_t path_cnt = 0;
2091 afi_t afi;
2092 safi_t safi;
2093 json_object *json_paths = NULL;
2094
2095 afi = AFI_L2VPN;
2096 safi = SAFI_EVPN;
2097
2098 /* Locate VNI. */
2099 vpn = bgp_evpn_lookup_vni(bgp, vni);
2100 if (!vpn) {
2101 if (!json)
2102 vty_out(vty, "VNI not found\n");
2103 return;
2104 }
2105
2106 /* See if route exists. Look for both non-sticky and sticky. */
2107 build_evpn_type2_prefix(&p, mac, ip);
2108 rn = bgp_node_lookup(vpn->route_table, (struct prefix *)&p);
2109 if (!rn || !rn->info) {
2110 if (!json)
2111 vty_out(vty, "%% Network not in table\n");
2112 return;
2113 }
2114
2115 if (json)
2116 json_paths = json_object_new_array();
2117
2118 /* Prefix and num paths displayed once per prefix. */
2119 route_vty_out_detail_header(vty, bgp, rn, NULL, afi, safi, json);
2120
2121 /* Display each path for this prefix. */
2122 for (ri = rn->info; ri; ri = ri->next) {
2123 json_object *json_path = NULL;
2124
2125 if (json)
2126 json_path = json_object_new_array();
2127
2128 route_vty_out_detail(vty, bgp, &rn->p, ri, afi, safi,
2129 json_path);
2130
2131 if (json)
2132 json_object_array_add(json_paths, json_path);
2133
2134 path_cnt++;
2135 }
2136
2137 if (json) {
2138 if (path_cnt)
2139 json_object_object_add(json, "paths", json_paths);
2140
2141 json_object_int_add(json, "numPaths", path_cnt);
2142 } else {
2143 vty_out(vty, "\nDisplayed %u paths for requested prefix\n",
2144 path_cnt);
2145 }
2146 }
2147
2148 /* Disaplay EVPN routes for a ESI - VTY handler */
2149 static void evpn_show_routes_esi(struct vty *vty, struct bgp *bgp,
2150 esi_t *esi, json_object *json)
2151 {
2152 struct evpnes *es = NULL;
2153
2154 /* locate the ES */
2155 es = bgp_evpn_lookup_es(bgp, esi);
2156 if (!es) {
2157 if (!json)
2158 vty_out(vty, "ESI not found\n");
2159 return;
2160 }
2161
2162 show_esi_routes(bgp, es, vty, json);
2163 }
2164
2165 /*
2166 * Display EVPN routes for a VNI - vty handler.
2167 * If 'type' is non-zero, only routes matching that type are shown.
2168 * If the vtep_ip is non zero, only routes behind that vtep are shown
2169 */
2170 static void evpn_show_routes_vni(struct vty *vty, struct bgp *bgp, vni_t vni,
2171 int type, struct in_addr vtep_ip,
2172 json_object *json)
2173 {
2174 struct bgpevpn *vpn;
2175
2176 /* Locate VNI. */
2177 vpn = bgp_evpn_lookup_vni(bgp, vni);
2178 if (!vpn) {
2179 if (!json)
2180 vty_out(vty, "VNI not found\n");
2181 return;
2182 }
2183
2184 /* Walk this VNI's route table and display appropriate routes. */
2185 show_vni_routes(bgp, vpn, type, vty, vtep_ip, json);
2186 }
2187
2188 /*
2189 * Display BGP EVPN routing table -- for specific RD and MAC and/or
2190 * IP (vty handler). By definition, only matching type-2 route will be
2191 * displayed.
2192 */
2193 static void evpn_show_route_rd_macip(struct vty *vty, struct bgp *bgp,
2194 struct prefix_rd *prd, struct ethaddr *mac,
2195 struct ipaddr *ip, json_object *json)
2196 {
2197 struct prefix_evpn p;
2198 struct bgp_node *rn;
2199 struct bgp_info *ri;
2200 afi_t afi;
2201 safi_t safi;
2202 uint32_t path_cnt = 0;
2203 json_object *json_paths = NULL;
2204 char prefix_str[BUFSIZ];
2205
2206 afi = AFI_L2VPN;
2207 safi = SAFI_EVPN;
2208
2209 /* See if route exists. Look for both non-sticky and sticky. */
2210 build_evpn_type2_prefix(&p, mac, ip);
2211 rn = bgp_afi_node_lookup(bgp->rib[afi][safi], afi, safi,
2212 (struct prefix *)&p, prd);
2213 if (!rn || !rn->info) {
2214 if (!json)
2215 vty_out(vty, "%% Network not in table\n");
2216 return;
2217 }
2218
2219 bgp_evpn_route2str((struct prefix_evpn *)&p, prefix_str,
2220 sizeof(prefix_str));
2221
2222 /* Prefix and num paths displayed once per prefix. */
2223 route_vty_out_detail_header(vty, bgp, rn, prd, afi, safi, json);
2224
2225 if (json)
2226 json_paths = json_object_new_array();
2227
2228 /* Display each path for this prefix. */
2229 for (ri = rn->info; ri; ri = ri->next) {
2230 json_object *json_path = NULL;
2231
2232 if (json)
2233 json_path = json_object_new_array();
2234
2235 route_vty_out_detail(vty, bgp, &rn->p, ri, afi, safi,
2236 json_path);
2237
2238 if (json)
2239 json_object_array_add(json_paths, json_path);
2240
2241 path_cnt++;
2242 }
2243
2244 if (json && path_cnt) {
2245 if (path_cnt)
2246 json_object_object_add(json, prefix_str, json_paths);
2247 json_object_int_add(json, "numPaths", path_cnt);
2248 } else {
2249 vty_out(vty, "\nDisplayed %u paths for requested prefix\n",
2250 path_cnt);
2251 }
2252 }
2253
2254 /*
2255 * Display BGP EVPN routing table -- for specific RD (vty handler)
2256 * If 'type' is non-zero, only routes matching that type are shown.
2257 */
2258 static void evpn_show_route_rd(struct vty *vty, struct bgp *bgp,
2259 struct prefix_rd *prd, int type,
2260 json_object *json)
2261 {
2262 struct bgp_node *rd_rn;
2263 struct bgp_table *table;
2264 struct bgp_node *rn;
2265 struct bgp_info *ri;
2266 int rd_header = 1;
2267 afi_t afi;
2268 safi_t safi;
2269 uint32_t prefix_cnt, path_cnt;
2270 char rd_str[RD_ADDRSTRLEN];
2271 json_object *json_rd = NULL;
2272 int add_rd_to_json = 0;
2273
2274 afi = AFI_L2VPN;
2275 safi = SAFI_EVPN;
2276 prefix_cnt = path_cnt = 0;
2277
2278 prefix_rd2str((struct prefix_rd *)prd, rd_str, sizeof(rd_str));
2279
2280 rd_rn = bgp_node_lookup(bgp->rib[afi][safi], (struct prefix *)prd);
2281 if (!rd_rn)
2282 return;
2283
2284 table = (struct bgp_table *)rd_rn->info;
2285 if (table == NULL)
2286 return;
2287
2288 if (json) {
2289 json_rd = json_object_new_object();
2290 json_object_string_add(json_rd, "rd", rd_str);
2291 }
2292
2293 /* Display all prefixes with this RD. */
2294 for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) {
2295 struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p;
2296 json_object *json_prefix = NULL;
2297 json_object *json_paths = NULL;
2298 char prefix_str[BUFSIZ];
2299 int add_prefix_to_json = 0;
2300
2301 bgp_evpn_route2str((struct prefix_evpn *)&rn->p, prefix_str,
2302 sizeof(prefix_str));
2303
2304 if (type && evp->prefix.route_type != type)
2305 continue;
2306
2307 if (json)
2308 json_prefix = json_object_new_object();
2309
2310 if (rn->info) {
2311 /* RD header and legend - once overall. */
2312 if (rd_header && !json) {
2313 vty_out(vty,
2314 "EVPN type-2 prefix: [2]:[EthTag]:[MAClen]:[MAC]\n");
2315 vty_out(vty,
2316 "EVPN type-3 prefix: [3]:[EthTag]:[IPlen]:[OrigIP]\n");
2317 vty_out(vty,
2318 "EVPN type-5 prefix: [5]:[EthTag]:[IPlen]:[IP]\n\n");
2319 rd_header = 0;
2320 }
2321
2322 /* Prefix and num paths displayed once per prefix. */
2323 route_vty_out_detail_header(vty, bgp, rn, prd, afi,
2324 safi, json_prefix);
2325
2326 prefix_cnt++;
2327 }
2328
2329 if (json)
2330 json_paths = json_object_new_array();
2331
2332 /* Display each path for this prefix. */
2333 for (ri = rn->info; ri; ri = ri->next) {
2334 json_object *json_path = NULL;
2335
2336 if (json)
2337 json_path = json_object_new_array();
2338
2339 route_vty_out_detail(vty, bgp, &rn->p, ri, afi, safi,
2340 json_path);
2341
2342 if (json)
2343 json_object_array_add(json_paths, json_path);
2344
2345 path_cnt++;
2346 add_prefix_to_json = 1;
2347 add_rd_to_json = 1;
2348 }
2349
2350 if (json && add_prefix_to_json) {
2351 json_object_object_add(json_prefix, "paths",
2352 json_paths);
2353 json_object_object_add(json_rd, prefix_str,
2354 json_prefix);
2355 }
2356 }
2357
2358 if (json && add_rd_to_json)
2359 json_object_object_add(json, rd_str, json_rd);
2360
2361 if (json) {
2362 json_object_int_add(json, "numPrefix", prefix_cnt);
2363 json_object_int_add(json, "numPaths", path_cnt);
2364 } else {
2365 if (prefix_cnt == 0)
2366 vty_out(vty, "No prefixes exist with this RD%s\n",
2367 type ? " (of requested type)" : "");
2368 else
2369 vty_out(vty,
2370 "\nDisplayed %u prefixes (%u paths) with this RD%s\n",
2371 prefix_cnt, path_cnt,
2372 type ? " (of requested type)" : "");
2373 }
2374 }
2375
2376 /*
2377 * Display BGP EVPN routing table - all routes (vty handler).
2378 * If 'type' is non-zero, only routes matching that type are shown.
2379 */
2380 static void evpn_show_all_routes(struct vty *vty, struct bgp *bgp, int type,
2381 json_object *json)
2382 {
2383 struct bgp_node *rd_rn;
2384 struct bgp_table *table;
2385 struct bgp_node *rn;
2386 struct bgp_info *ri;
2387 int header = 1;
2388 int rd_header;
2389 afi_t afi;
2390 safi_t safi;
2391 uint32_t prefix_cnt, path_cnt;
2392
2393 afi = AFI_L2VPN;
2394 safi = SAFI_EVPN;
2395 prefix_cnt = path_cnt = 0;
2396
2397 /* EVPN routing table is a 2-level table with the first level being
2398 * the RD.
2399 */
2400 for (rd_rn = bgp_table_top(bgp->rib[afi][safi]); rd_rn;
2401 rd_rn = bgp_route_next(rd_rn)) {
2402 char rd_str[RD_ADDRSTRLEN];
2403 json_object *json_rd = NULL; /* contains routes for an RD */
2404 int add_rd_to_json = 0;
2405 uint64_t tbl_ver;
2406
2407 table = (struct bgp_table *)rd_rn->info;
2408 if (table == NULL)
2409 continue;
2410
2411 tbl_ver = table->version;
2412 prefix_rd2str((struct prefix_rd *)&rd_rn->p, rd_str,
2413 sizeof(rd_str));
2414
2415 if (json) {
2416 json_rd = json_object_new_object();
2417 json_object_string_add(json_rd, "rd", rd_str);
2418 }
2419
2420 rd_header = 1;
2421
2422 /* Display all prefixes for an RD */
2423 for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn)) {
2424 json_object *json_prefix =
2425 NULL; /* contains prefix under a RD */
2426 json_object *json_paths =
2427 NULL; /* array of paths under a prefix*/
2428 struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p;
2429 char prefix_str[BUFSIZ];
2430 int add_prefix_to_json = 0;
2431
2432 bgp_evpn_route2str((struct prefix_evpn *)&rn->p,
2433 prefix_str, sizeof(prefix_str));
2434
2435 if (type && evp->prefix.route_type != type)
2436 continue;
2437
2438 if (rn->info) {
2439 /* Overall header/legend displayed once. */
2440 if (header) {
2441 bgp_evpn_show_route_header(vty, bgp,
2442 tbl_ver,
2443 json);
2444 header = 0;
2445 }
2446
2447 /* RD header - per RD. */
2448 if (rd_header) {
2449 bgp_evpn_show_route_rd_header(
2450 vty, rd_rn, json);
2451 rd_header = 0;
2452 }
2453
2454 prefix_cnt++;
2455 }
2456
2457 if (json) {
2458 json_prefix = json_object_new_object();
2459 json_paths = json_object_new_array();
2460 json_object_string_add(json_prefix, "prefix",
2461 prefix_str);
2462 json_object_int_add(json_prefix, "prefixLen",
2463 rn->p.prefixlen);
2464 }
2465
2466 /* For EVPN, the prefix is displayed for each path (to
2467 * fit in
2468 * with code that already exists).
2469 */
2470 for (ri = rn->info; ri; ri = ri->next) {
2471 json_object *json_path = NULL;
2472 path_cnt++;
2473 add_prefix_to_json = 1;
2474 add_rd_to_json = 1;
2475
2476 if (json)
2477 json_path = json_object_new_array();
2478
2479 route_vty_out(vty, &rn->p, ri, 0, SAFI_EVPN,
2480 json_path);
2481
2482 if (json)
2483 json_object_array_add(json_paths,
2484 json_path);
2485 }
2486
2487 if (json && add_prefix_to_json) {
2488 json_object_object_add(json_prefix, "paths",
2489 json_paths);
2490 json_object_object_add(json_rd, prefix_str,
2491 json_prefix);
2492 }
2493 }
2494
2495 if (json && add_rd_to_json)
2496 json_object_object_add(json, rd_str, json_rd);
2497 }
2498
2499 if (json) {
2500 json_object_int_add(json, "numPrefix", prefix_cnt);
2501 json_object_int_add(json, "numPaths", path_cnt);
2502 } else {
2503 if (prefix_cnt == 0) {
2504 vty_out(vty, "No EVPN prefixes %sexist\n",
2505 type ? "(of requested type) " : "");
2506 } else {
2507 vty_out(vty, "\nDisplayed %u prefixes (%u paths)%s\n",
2508 prefix_cnt, path_cnt,
2509 type ? " (of requested type)" : "");
2510 }
2511 }
2512 }
2513
2514 /* Display specific ES */
2515 static void evpn_show_es(struct vty *vty, struct bgp *bgp, esi_t *esi,
2516 json_object *json)
2517 {
2518 struct evpnes *es = NULL;
2519
2520 es = bgp_evpn_lookup_es(bgp, esi);
2521 if (es) {
2522 display_es(vty, es, json);
2523 } else {
2524 if (json) {
2525 vty_out(vty, "{}\n");
2526 } else {
2527 vty_out(vty, "ESI not found\n");
2528 return;
2529 }
2530 }
2531 }
2532
2533 /* Display all ESs */
2534 static void evpn_show_all_es(struct vty *vty, struct bgp *bgp,
2535 json_object *json)
2536 {
2537 void *args[2];
2538
2539 if (!json)
2540 vty_out(vty, "%-30s %-6s %-21s %-15s %-6s\n",
2541 "ESI", "Type", "RD", "Originator-IP", "#VTEPs");
2542
2543 /* print all ESs */
2544 args[0] = vty;
2545 args[1] = json;
2546 hash_iterate(bgp->esihash,
2547 (void (*)(struct hash_backet *, void *))show_es_entry,
2548 args);
2549 }
2550
2551 /*
2552 * Display specified VNI (vty handler)
2553 */
2554 static void evpn_show_vni(struct vty *vty, struct bgp *bgp, vni_t vni,
2555 json_object *json)
2556 {
2557 uint8_t found = 0;
2558 struct bgpevpn *vpn;
2559
2560 vpn = bgp_evpn_lookup_vni(bgp, vni);
2561 if (vpn) {
2562 found = 1;
2563 display_vni(vty, vpn, json);
2564 } else {
2565 struct bgp *bgp_temp;
2566 struct listnode *node = NULL;
2567
2568 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_temp)) {
2569 if (bgp_temp->l3vni == vni) {
2570 found = 1;
2571 display_l3vni(vty, bgp_temp, json);
2572 }
2573 }
2574 }
2575
2576 if (!found) {
2577 if (json) {
2578 vty_out(vty, "{}\n");
2579 } else {
2580 vty_out(vty, "VNI not found\n");
2581 return;
2582 }
2583 }
2584 }
2585
2586 /*
2587 * Display a VNI (upon user query).
2588 */
2589 static void evpn_show_all_vnis(struct vty *vty, struct bgp *bgp,
2590 json_object *json)
2591 {
2592 void *args[2];
2593 struct bgp *bgp_temp = NULL;
2594 struct listnode *node;
2595
2596
2597 if (!json) {
2598 vty_out(vty, "Flags: * - Kernel\n");
2599 vty_out(vty, " %-10s %-4s %-21s %-25s %-25s %-37s\n", "VNI",
2600 "Type", "RD", "Import RT", "Export RT", "Tenant VRF");
2601 }
2602
2603 /* print all L2 VNIS */
2604 args[0] = vty;
2605 args[1] = json;
2606 hash_iterate(bgp->vnihash,
2607 (void (*)(struct hash_backet *, void *))show_vni_entry,
2608 args);
2609
2610 /* print all L3 VNIs */
2611 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_temp))
2612 show_l3vni_entry(vty, bgp_temp, json);
2613 }
2614
2615 /*
2616 * evpn - enable advertisement of default g/w
2617 */
2618 static void evpn_set_advertise_default_gw(struct bgp *bgp, struct bgpevpn *vpn)
2619 {
2620 if (!vpn) {
2621 if (bgp->advertise_gw_macip)
2622 return;
2623
2624 bgp->advertise_gw_macip = 1;
2625 bgp_zebra_advertise_gw_macip(bgp, bgp->advertise_gw_macip, 0);
2626 } else {
2627 if (vpn->advertise_gw_macip)
2628 return;
2629
2630 vpn->advertise_gw_macip = 1;
2631 bgp_zebra_advertise_gw_macip(bgp, vpn->advertise_gw_macip,
2632 vpn->vni);
2633 }
2634 return;
2635 }
2636
2637 /*
2638 * evpn - disable advertisement of default g/w
2639 */
2640 static void evpn_unset_advertise_default_gw(struct bgp *bgp,
2641 struct bgpevpn *vpn)
2642 {
2643 if (!vpn) {
2644 if (!bgp->advertise_gw_macip)
2645 return;
2646
2647 bgp->advertise_gw_macip = 0;
2648 bgp_zebra_advertise_gw_macip(bgp, bgp->advertise_gw_macip, 0);
2649 } else {
2650 if (!vpn->advertise_gw_macip)
2651 return;
2652
2653 vpn->advertise_gw_macip = 0;
2654 bgp_zebra_advertise_gw_macip(bgp, vpn->advertise_gw_macip,
2655 vpn->vni);
2656 }
2657 return;
2658 }
2659
2660 /*
2661 * evpn - enable advertisement of default g/w
2662 */
2663 static void evpn_process_default_originate_cmd(struct bgp *bgp_vrf,
2664 afi_t afi, int add)
2665 {
2666 struct prefix ip_prefix;
2667 safi_t safi = SAFI_UNICAST; /* ipv4/ipv6 unicast */
2668
2669 /* form the default prefix 0.0.0.0/0 */
2670 memset(&ip_prefix, 0, sizeof(struct prefix));
2671 ip_prefix.family = afi2family(afi);
2672 ip_prefix.prefixlen = 0;
2673
2674 if (add) {
2675 /* bail if we are already advertising default route */
2676 if (evpn_default_originate_set(bgp_vrf, afi, safi))
2677 return;
2678
2679 if (afi == AFI_IP)
2680 SET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
2681 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4);
2682 else if (afi == AFI_IP6)
2683 SET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
2684 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6);
2685 bgp_evpn_advertise_type5_route(bgp_vrf, &ip_prefix,
2686 NULL, afi, safi);
2687 } else {
2688 /* bail out if we havent advertised the default route */
2689 if (!evpn_default_originate_set(bgp_vrf, afi, safi))
2690 return;
2691 if (afi == AFI_IP)
2692 UNSET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
2693 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4);
2694 else if (afi == AFI_IP6)
2695 UNSET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
2696 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6);
2697 bgp_evpn_withdraw_type5_route(bgp_vrf, &ip_prefix,
2698 afi, safi);
2699 }
2700 }
2701
2702 /*
2703 * evpn - enable advertisement of default g/w
2704 */
2705 static void evpn_set_advertise_subnet(struct bgp *bgp,
2706 struct bgpevpn *vpn)
2707 {
2708 if (vpn->advertise_subnet)
2709 return;
2710
2711 vpn->advertise_subnet = 1;
2712 bgp_zebra_advertise_subnet(bgp, vpn->advertise_subnet, vpn->vni);
2713 }
2714
2715 /*
2716 * evpn - disable advertisement of default g/w
2717 */
2718 static void evpn_unset_advertise_subnet(struct bgp *bgp, struct bgpevpn *vpn)
2719 {
2720 if (!vpn->advertise_subnet)
2721 return;
2722
2723 vpn->advertise_subnet = 0;
2724 bgp_zebra_advertise_subnet(bgp, vpn->advertise_subnet, vpn->vni);
2725 }
2726
2727 /*
2728 * EVPN (VNI advertisement) enabled. Register with zebra.
2729 */
2730 static void evpn_set_advertise_all_vni(struct bgp *bgp)
2731 {
2732 bgp->advertise_all_vni = 1;
2733 bgp_zebra_advertise_all_vni(bgp, bgp->advertise_all_vni);
2734 }
2735
2736 /*
2737 * EVPN (VNI advertisement) disabled. De-register with zebra. Cleanup VNI
2738 * cache, EVPN routes (delete and withdraw from peers).
2739 */
2740 static void evpn_unset_advertise_all_vni(struct bgp *bgp)
2741 {
2742 bgp->advertise_all_vni = 0;
2743 bgp_zebra_advertise_all_vni(bgp, bgp->advertise_all_vni);
2744 bgp_evpn_cleanup_on_disable(bgp);
2745 }
2746
2747 /*
2748 * EVPN - use RFC8365 to auto-derive RT
2749 */
2750 static void evpn_set_advertise_autort_rfc8365(struct bgp *bgp)
2751 {
2752 bgp->advertise_autort_rfc8365 = 1;
2753 bgp_evpn_handle_autort_change(bgp);
2754 }
2755
2756 /*
2757 * EVPN - don't use RFC8365 to auto-derive RT
2758 */
2759 static void evpn_unset_advertise_autort_rfc8365(struct bgp *bgp)
2760 {
2761 bgp->advertise_autort_rfc8365 = 0;
2762 bgp_evpn_handle_autort_change(bgp);
2763 }
2764
2765 static void write_vni_config(struct vty *vty, struct bgpevpn *vpn)
2766 {
2767 char buf1[RD_ADDRSTRLEN];
2768 char *ecom_str;
2769 struct listnode *node, *nnode;
2770 struct ecommunity *ecom;
2771
2772 if (is_vni_configured(vpn)) {
2773 vty_out(vty, " vni %d\n", vpn->vni);
2774 if (is_rd_configured(vpn))
2775 vty_out(vty, " rd %s\n",
2776 prefix_rd2str(&vpn->prd, buf1, sizeof(buf1)));
2777
2778 if (is_import_rt_configured(vpn)) {
2779 for (ALL_LIST_ELEMENTS(vpn->import_rtl, node, nnode,
2780 ecom)) {
2781 ecom_str = ecommunity_ecom2str(
2782 ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
2783 vty_out(vty, " route-target import %s\n",
2784 ecom_str);
2785 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
2786 }
2787 }
2788
2789 if (is_export_rt_configured(vpn)) {
2790 for (ALL_LIST_ELEMENTS(vpn->export_rtl, node, nnode,
2791 ecom)) {
2792 ecom_str = ecommunity_ecom2str(
2793 ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
2794 vty_out(vty, " route-target export %s\n",
2795 ecom_str);
2796 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
2797 }
2798 }
2799
2800 if (vpn->advertise_gw_macip)
2801 vty_out(vty, " advertise-default-gw\n");
2802
2803 if (vpn->advertise_subnet)
2804 vty_out(vty, " advertise-subnet\n");
2805
2806 vty_out(vty, " exit-vni\n");
2807 }
2808 }
2809
2810 DEFUN (bgp_evpn_advertise_default_gw_vni,
2811 bgp_evpn_advertise_default_gw_vni_cmd,
2812 "advertise-default-gw",
2813 "Advertise default g/w mac-ip routes in EVPN for a VNI\n")
2814 {
2815 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2816 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
2817
2818 if (!bgp)
2819 return CMD_WARNING;
2820
2821 evpn_set_advertise_default_gw(bgp, vpn);
2822
2823 return CMD_SUCCESS;
2824 }
2825
2826 DEFUN (no_bgp_evpn_advertise_default_vni_gw,
2827 no_bgp_evpn_advertise_default_gw_vni_cmd,
2828 "no advertise-default-gw",
2829 NO_STR
2830 "Withdraw default g/w mac-ip routes from EVPN for a VNI\n")
2831 {
2832 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2833 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
2834
2835 if (!bgp)
2836 return CMD_WARNING;
2837
2838 evpn_unset_advertise_default_gw(bgp, vpn);
2839
2840 return CMD_SUCCESS;
2841 }
2842
2843
2844 DEFUN (bgp_evpn_advertise_default_gw,
2845 bgp_evpn_advertise_default_gw_cmd,
2846 "advertise-default-gw",
2847 "Advertise All default g/w mac-ip routes in EVPN\n")
2848 {
2849 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2850
2851 if (!bgp)
2852 return CMD_WARNING;
2853
2854 evpn_set_advertise_default_gw(bgp, NULL);
2855
2856 return CMD_SUCCESS;
2857 }
2858
2859 DEFUN (no_bgp_evpn_advertise_default_gw,
2860 no_bgp_evpn_advertise_default_gw_cmd,
2861 "no advertise-default-gw",
2862 NO_STR
2863 "Withdraw All default g/w mac-ip routes from EVPN\n")
2864 {
2865 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2866
2867 if (!bgp)
2868 return CMD_WARNING;
2869
2870 evpn_unset_advertise_default_gw(bgp, NULL);
2871
2872 return CMD_SUCCESS;
2873 }
2874
2875 DEFUN (bgp_evpn_advertise_all_vni,
2876 bgp_evpn_advertise_all_vni_cmd,
2877 "advertise-all-vni",
2878 "Advertise All local VNIs\n")
2879 {
2880 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2881
2882 if (!bgp)
2883 return CMD_WARNING;
2884 evpn_set_advertise_all_vni(bgp);
2885 return CMD_SUCCESS;
2886 }
2887
2888 DEFUN (no_bgp_evpn_advertise_all_vni,
2889 no_bgp_evpn_advertise_all_vni_cmd,
2890 "no advertise-all-vni",
2891 NO_STR
2892 "Advertise All local VNIs\n")
2893 {
2894 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2895
2896 if (!bgp)
2897 return CMD_WARNING;
2898 evpn_unset_advertise_all_vni(bgp);
2899 return CMD_SUCCESS;
2900 }
2901
2902 DEFUN (bgp_evpn_advertise_autort_rfc8365,
2903 bgp_evpn_advertise_autort_rfc8365_cmd,
2904 "autort rfc8365-compatible",
2905 "Auto-derivation of RT\n"
2906 "Auto-derivation of RT using RFC8365\n")
2907 {
2908 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2909
2910 if (!bgp)
2911 return CMD_WARNING;
2912 evpn_set_advertise_autort_rfc8365(bgp);
2913 return CMD_SUCCESS;
2914 }
2915
2916 DEFUN (no_bgp_evpn_advertise_autort_rfc8365,
2917 no_bgp_evpn_advertise_autort_rfc8365_cmd,
2918 "no autort rfc8365-compatible",
2919 NO_STR
2920 "Auto-derivation of RT\n"
2921 "Auto-derivation of RT using RFC8365\n")
2922 {
2923 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2924
2925 if (!bgp)
2926 return CMD_WARNING;
2927 evpn_unset_advertise_autort_rfc8365(bgp);
2928 return CMD_SUCCESS;
2929 }
2930
2931 DEFUN (bgp_evpn_default_originate,
2932 bgp_evpn_default_originate_cmd,
2933 "default-originate <ipv4 | ipv6>",
2934 "originate a default route\n"
2935 "ipv4 address family\n"
2936 "ipv6 address family\n")
2937 {
2938 afi_t afi = 0;
2939 int idx_afi = 0;
2940 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp);
2941
2942 if (!bgp_vrf)
2943 return CMD_WARNING;
2944 argv_find_and_parse_afi(argv, argc, &idx_afi, &afi);
2945 evpn_process_default_originate_cmd(bgp_vrf, afi, 1);
2946 return CMD_SUCCESS;
2947 }
2948
2949 DEFUN (no_bgp_evpn_default_originate,
2950 no_bgp_evpn_default_originate_cmd,
2951 "no default-originate <ipv4 | ipv6>",
2952 NO_STR
2953 "withdraw a default route\n"
2954 "ipv4 address family\n"
2955 "ipv6 address family\n")
2956 {
2957 afi_t afi = 0;
2958 int idx_afi = 0;
2959 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp);
2960
2961 if (!bgp_vrf)
2962 return CMD_WARNING;
2963 argv_find_and_parse_afi(argv, argc, &idx_afi, &afi);
2964 evpn_process_default_originate_cmd(bgp_vrf, afi, 0);
2965 return CMD_SUCCESS;
2966 }
2967
2968 DEFUN_HIDDEN (bgp_evpn_advertise_vni_subnet,
2969 bgp_evpn_advertise_vni_subnet_cmd,
2970 "advertise-subnet",
2971 "Advertise the subnet corresponding to VNI\n")
2972 {
2973 struct bgp *bgp_vrf = NULL;
2974 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2975 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
2976
2977 if (!bgp)
2978 return CMD_WARNING;
2979
2980 bgp_vrf = bgp_lookup_by_vrf_id(vpn->tenant_vrf_id);
2981 if (!bgp_vrf)
2982 return CMD_WARNING;
2983
2984 evpn_set_advertise_subnet(bgp, vpn);
2985 return CMD_SUCCESS;
2986 }
2987
2988 DEFUN_HIDDEN (no_bgp_evpn_advertise_vni_subnet,
2989 no_bgp_evpn_advertise_vni_subnet_cmd,
2990 "no advertise-subnet",
2991 NO_STR
2992 "Advertise All local VNIs\n")
2993 {
2994 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
2995 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
2996
2997 if (!bgp)
2998 return CMD_WARNING;
2999
3000 evpn_unset_advertise_subnet(bgp, vpn);
3001 return CMD_SUCCESS;
3002 }
3003
3004 DEFUN (bgp_evpn_advertise_type5,
3005 bgp_evpn_advertise_type5_cmd,
3006 "advertise " BGP_AFI_CMD_STR "" BGP_SAFI_CMD_STR " [route-map WORD]",
3007 "Advertise prefix routes\n"
3008 BGP_AFI_HELP_STR
3009 BGP_SAFI_HELP_STR
3010 "route-map for filtering specific routes\n"
3011 "Name of the route map\n")
3012 {
3013 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp); /* bgp vrf instance */
3014 int idx_afi = 0;
3015 int idx_safi = 0;
3016 int idx_rmap = 0;
3017 afi_t afi = 0;
3018 safi_t safi = 0;
3019 int ret = 0;
3020 int rmap_changed = 0;
3021
3022 argv_find_and_parse_afi(argv, argc, &idx_afi, &afi);
3023 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
3024 ret = argv_find(argv, argc, "route-map", &idx_rmap);
3025 if (ret) {
3026 if (!bgp_vrf->adv_cmd_rmap[afi][safi].name)
3027 rmap_changed = 1;
3028 else if (strcmp(argv[idx_rmap + 1]->arg,
3029 bgp_vrf->adv_cmd_rmap[afi][safi].name)
3030 != 0)
3031 rmap_changed = 1;
3032 } else if (bgp_vrf->adv_cmd_rmap[afi][safi].name) {
3033 rmap_changed = 1;
3034 }
3035
3036 if (!(afi == AFI_IP || afi == AFI_IP6)) {
3037 vty_out(vty,
3038 "%%only ipv4 or ipv6 address families are supported");
3039 return CMD_WARNING;
3040 }
3041
3042 if (safi != SAFI_UNICAST) {
3043 vty_out(vty,
3044 "%%only ipv4 unicast or ipv6 unicast are supported");
3045 return CMD_WARNING;
3046 }
3047
3048 if (afi == AFI_IP) {
3049
3050 /* if we are already advertising ipv4 prefix as type-5
3051 * nothing to do
3052 */
3053 if (!rmap_changed &&
3054 CHECK_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3055 BGP_L2VPN_EVPN_ADVERTISE_IPV4_UNICAST))
3056 return CMD_WARNING;
3057 SET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3058 BGP_L2VPN_EVPN_ADVERTISE_IPV4_UNICAST);
3059 } else {
3060
3061 /* if we are already advertising ipv6 prefix as type-5
3062 * nothing to do
3063 */
3064 if (!rmap_changed &&
3065 CHECK_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3066 BGP_L2VPN_EVPN_ADVERTISE_IPV6_UNICAST))
3067 return CMD_WARNING;
3068 SET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3069 BGP_L2VPN_EVPN_ADVERTISE_IPV6_UNICAST);
3070 }
3071
3072 if (rmap_changed) {
3073 bgp_evpn_withdraw_type5_routes(bgp_vrf, afi, safi);
3074 if (bgp_vrf->adv_cmd_rmap[afi][safi].name) {
3075 XFREE(MTYPE_ROUTE_MAP_NAME,
3076 bgp_vrf->adv_cmd_rmap[afi][safi].name);
3077 bgp_vrf->adv_cmd_rmap[afi][safi].name = NULL;
3078 bgp_vrf->adv_cmd_rmap[afi][safi].map = NULL;
3079 }
3080 }
3081
3082 /* set the route-map for advertise command */
3083 if (ret && argv[idx_rmap + 1]->arg) {
3084 bgp_vrf->adv_cmd_rmap[afi][safi].name =
3085 XSTRDUP(MTYPE_ROUTE_MAP_NAME, argv[idx_rmap + 1]->arg);
3086 bgp_vrf->adv_cmd_rmap[afi][safi].map =
3087 route_map_lookup_by_name(argv[idx_rmap + 1]->arg);
3088 }
3089
3090 /* advertise type-5 routes */
3091 bgp_evpn_advertise_type5_routes(bgp_vrf, afi, safi);
3092 return CMD_SUCCESS;
3093 }
3094
3095 DEFUN (no_bgp_evpn_advertise_type5,
3096 no_bgp_evpn_advertise_type5_cmd,
3097 "no advertise " BGP_AFI_CMD_STR "" BGP_SAFI_CMD_STR,
3098 NO_STR
3099 "Advertise prefix routes\n"
3100 BGP_AFI_HELP_STR
3101 BGP_SAFI_HELP_STR)
3102 {
3103 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp); /* bgp vrf instance */
3104 int idx_afi = 0;
3105 int idx_safi = 0;
3106 afi_t afi = 0;
3107 safi_t safi = 0;
3108
3109 argv_find_and_parse_afi(argv, argc, &idx_afi, &afi);
3110 argv_find_and_parse_safi(argv, argc, &idx_safi, &safi);
3111
3112 if (!(afi == AFI_IP || afi == AFI_IP6)) {
3113 vty_out(vty,
3114 "%%only ipv4 or ipv6 address families are supported");
3115 return CMD_WARNING;
3116 }
3117
3118 if (safi != SAFI_UNICAST) {
3119 vty_out(vty,
3120 "%%only ipv4 unicast or ipv6 unicast are supported");
3121 return CMD_WARNING;
3122 }
3123
3124 if (afi == AFI_IP) {
3125
3126 /* if we are not advertising ipv4 prefix as type-5
3127 * nothing to do
3128 */
3129 if (CHECK_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3130 BGP_L2VPN_EVPN_ADVERTISE_IPV4_UNICAST)) {
3131 bgp_evpn_withdraw_type5_routes(bgp_vrf, afi, safi);
3132 UNSET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3133 BGP_L2VPN_EVPN_ADVERTISE_IPV4_UNICAST);
3134 }
3135 } else {
3136
3137 /* if we are not advertising ipv6 prefix as type-5
3138 * nothing to do
3139 */
3140 if (CHECK_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3141 BGP_L2VPN_EVPN_ADVERTISE_IPV6_UNICAST)) {
3142 bgp_evpn_withdraw_type5_routes(bgp_vrf, afi, safi);
3143 UNSET_FLAG(bgp_vrf->af_flags[AFI_L2VPN][SAFI_EVPN],
3144 BGP_L2VPN_EVPN_ADVERTISE_IPV6_UNICAST);
3145 }
3146 }
3147
3148 /* clear the route-map information for advertise ipv4/ipv6 unicast */
3149 if (bgp_vrf->adv_cmd_rmap[afi][safi].name) {
3150 XFREE(MTYPE_ROUTE_MAP_NAME,
3151 bgp_vrf->adv_cmd_rmap[afi][safi].name);
3152 bgp_vrf->adv_cmd_rmap[afi][safi].name = NULL;
3153 bgp_vrf->adv_cmd_rmap[afi][safi].map = NULL;
3154 }
3155
3156 return CMD_SUCCESS;
3157 }
3158
3159 /*
3160 * Display VNI information - for all or a specific VNI
3161 */
3162 DEFUN(show_bgp_l2vpn_evpn_vni,
3163 show_bgp_l2vpn_evpn_vni_cmd,
3164 "show bgp l2vpn evpn vni [(1-16777215)] [json]",
3165 SHOW_STR
3166 BGP_STR
3167 L2VPN_HELP_STR
3168 EVPN_HELP_STR
3169 "Show VNI\n"
3170 "VNI number\n"
3171 JSON_STR)
3172 {
3173 struct bgp *bgp_def;
3174 vni_t vni;
3175 int idx = 0;
3176 bool uj = false;
3177 json_object *json = NULL;
3178 uint32_t num_l2vnis = 0;
3179 uint32_t num_l3vnis = 0;
3180 uint32_t num_vnis = 0;
3181 struct listnode *node = NULL;
3182 struct bgp *bgp_temp = NULL;
3183
3184 uj = use_json(argc, argv);
3185
3186 bgp_def = bgp_get_default();
3187 if (!bgp_def)
3188 return CMD_WARNING;
3189
3190 if (!argv_find(argv, argc, "evpn", &idx))
3191 return CMD_WARNING;
3192
3193 if (uj)
3194 json = json_object_new_object();
3195
3196 if ((uj && argc == ((idx + 1) + 2)) || (!uj && argc == (idx + 1) + 1)) {
3197
3198 num_l2vnis = hashcount(bgp_def->vnihash);
3199
3200 for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_temp)) {
3201 if (bgp_temp->l3vni)
3202 num_l3vnis++;
3203 }
3204 num_vnis = num_l2vnis + num_l3vnis;
3205 if (uj) {
3206 json_object_string_add(json, "advertiseGatewayMacip",
3207 bgp_def->advertise_gw_macip
3208 ? "Enabled"
3209 : "Disabled");
3210 json_object_string_add(json, "advertiseAllVnis",
3211 is_evpn_enabled() ? "Enabled"
3212 : "Disabled");
3213 json_object_int_add(json, "numVnis", num_vnis);
3214 json_object_int_add(json, "numL2Vnis", num_l2vnis);
3215 json_object_int_add(json, "numL3Vnis", num_l3vnis);
3216 } else {
3217 vty_out(vty, "Advertise Gateway Macip: %s\n",
3218 bgp_def->advertise_gw_macip ? "Enabled"
3219 : "Disabled");
3220 vty_out(vty, "Advertise All VNI flag: %s\n",
3221 is_evpn_enabled() ? "Enabled" : "Disabled");
3222 vty_out(vty, "Number of L2 VNIs: %u\n", num_l2vnis);
3223 vty_out(vty, "Number of L3 VNIs: %u\n", num_l3vnis);
3224 }
3225 evpn_show_all_vnis(vty, bgp_def, json);
3226 } else {
3227 int vni_idx = 0;
3228
3229 if (!argv_find(argv, argc, "vni", &vni_idx))
3230 return CMD_WARNING;
3231
3232 /* Display specific VNI */
3233 vni = strtoul(argv[vni_idx + 1]->arg, NULL, 10);
3234 evpn_show_vni(vty, bgp_def, vni, json);
3235 }
3236
3237 if (uj) {
3238 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3239 json, JSON_C_TO_STRING_PRETTY));
3240 json_object_free(json);
3241 }
3242
3243 return CMD_SUCCESS;
3244 }
3245
3246 /* Disaply ES */
3247 DEFUN(show_bgp_l2vpn_evpn_es,
3248 show_bgp_l2vpn_evpn_es_cmd,
3249 "show bgp l2vpn evpn es [ESI] [json]",
3250 SHOW_STR
3251 BGP_STR
3252 L2VPN_HELP_STR
3253 EVPN_HELP_STR
3254 "ethernet-Segment\n"
3255 "Ethernet-Segment Identifier\n"
3256 JSON_STR)
3257 {
3258 int idx = 0;
3259 bool uj = false;
3260 esi_t esi;
3261 json_object *json = NULL;
3262 struct bgp *bgp = NULL;
3263
3264 memset(&esi, 0, sizeof(esi));
3265 uj = use_json(argc, argv);
3266
3267 bgp = bgp_get_default();
3268 if (!bgp)
3269 return CMD_WARNING;
3270
3271 if (!argv_find(argv, argc, "evpn", &idx))
3272 return CMD_WARNING;
3273
3274 if ((uj && argc == ((idx + 1) + 2)) ||
3275 (!uj && argc == (idx + 1) + 1)) {
3276
3277 /* show all ESs */
3278 evpn_show_all_es(vty, bgp, json);
3279 } else {
3280
3281 /* show a specific ES */
3282
3283 /* get the ESI - ESI-ID is at argv[5] */
3284 if (!str_to_esi(argv[idx + 2]->arg, &esi)) {
3285 vty_out(vty, "%% Malformed ESI\n");
3286 return CMD_WARNING;
3287 }
3288 evpn_show_es(vty, bgp, &esi, json);
3289 }
3290
3291 if (uj) {
3292 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3293 json, JSON_C_TO_STRING_PRETTY));
3294 json_object_free(json);
3295 }
3296
3297 return CMD_SUCCESS;
3298 }
3299
3300 /*
3301 * Display EVPN neighbor summary.
3302 */
3303 DEFUN(show_bgp_l2vpn_evpn_summary,
3304 show_bgp_l2vpn_evpn_summary_cmd,
3305 "show bgp [vrf VRFNAME] l2vpn evpn summary [json]",
3306 SHOW_STR
3307 BGP_STR
3308 "bgp vrf\n"
3309 "vrf name\n"
3310 L2VPN_HELP_STR
3311 EVPN_HELP_STR
3312 "Summary of BGP neighbor status\n"
3313 JSON_STR)
3314 {
3315 int idx_vrf = 0;
3316 bool uj = use_json(argc, argv);
3317 char *vrf = NULL;
3318
3319 if (argv_find(argv, argc, "vrf", &idx_vrf))
3320 vrf = argv[++idx_vrf]->arg;
3321 return bgp_show_summary_vty(vty, vrf, AFI_L2VPN, SAFI_EVPN, uj);
3322 }
3323
3324 /*
3325 * Display global EVPN routing table.
3326 */
3327 DEFUN(show_bgp_l2vpn_evpn_route,
3328 show_bgp_l2vpn_evpn_route_cmd,
3329 "show bgp l2vpn evpn route [type <macip|multicast|es|prefix>] [json]",
3330 SHOW_STR
3331 BGP_STR
3332 L2VPN_HELP_STR
3333 EVPN_HELP_STR
3334 "EVPN route information\n"
3335 "Specify Route type\n"
3336 "MAC-IP (Type-2) route\n"
3337 "Multicast (Type-3) route\n"
3338 "Ethernet Segment (type-4) route \n"
3339 "Prefix (type-5 )route\n"
3340 JSON_STR)
3341 {
3342 struct bgp *bgp;
3343 int type_idx = 0;
3344 int type = 0;
3345 bool uj = false;
3346 json_object *json = NULL;
3347
3348 uj = use_json(argc, argv);
3349
3350 bgp = bgp_get_default();
3351 if (!bgp)
3352 return CMD_WARNING;
3353
3354 if (uj)
3355 json = json_object_new_object();
3356
3357 /* get the type */
3358 if (argv_find(argv, argc, "type", &type_idx)) {
3359 /* Specific type is requested */
3360 if (strncmp(argv[type_idx + 1]->arg, "ma", 2) == 0)
3361 type = BGP_EVPN_MAC_IP_ROUTE;
3362 else if (strncmp(argv[type_idx + 1]->arg, "mu", 2) == 0)
3363 type = BGP_EVPN_IMET_ROUTE;
3364 else if (strncmp(argv[type_idx + 1]->arg, "es", 2) == 0)
3365 type = BGP_EVPN_ES_ROUTE;
3366 else if (strncmp(argv[type_idx + 1]->arg, "pr", 2) == 0)
3367 type = BGP_EVPN_IP_PREFIX_ROUTE;
3368 else
3369 return CMD_WARNING;
3370 }
3371
3372 evpn_show_all_routes(vty, bgp, type, json);
3373
3374 if (uj) {
3375 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3376 json, JSON_C_TO_STRING_PRETTY));
3377 json_object_free(json);
3378 }
3379 return CMD_SUCCESS;
3380 }
3381
3382 /*
3383 * Display global EVPN routing table for specific RD.
3384 */
3385 DEFUN(show_bgp_l2vpn_evpn_route_rd,
3386 show_bgp_l2vpn_evpn_route_rd_cmd,
3387 "show bgp l2vpn evpn route rd ASN:NN_OR_IP-ADDRESS:NN [type <macip|multicast|es|prefix>] [json]",
3388 SHOW_STR
3389 BGP_STR
3390 L2VPN_HELP_STR
3391 EVPN_HELP_STR
3392 "EVPN route information\n"
3393 "Route Distinguisher\n"
3394 "ASN:XX or A.B.C.D:XX\n"
3395 "Specify Route type\n"
3396 "MAC-IP (Type-2) route\n"
3397 "Multicast (Type-3) route\n"
3398 "Ethernet Segment route\n"
3399 "Prefix route\n"
3400 JSON_STR)
3401 {
3402 struct bgp *bgp;
3403 int ret;
3404 struct prefix_rd prd;
3405 int type = 0;
3406 int rd_idx = 0;
3407 int type_idx = 0;
3408 bool uj = false;
3409 json_object *json = NULL;
3410
3411 bgp = bgp_get_default();
3412 if (!bgp)
3413 return CMD_WARNING;
3414
3415 /* check if we need json output */
3416 uj = use_json(argc, argv);
3417 if (uj)
3418 json = json_object_new_object();
3419
3420 /* get the RD */
3421 if (argv_find(argv, argc, "rd", &rd_idx)) {
3422 ret = str2prefix_rd(argv[rd_idx + 1]->arg, &prd);
3423
3424 if (!ret) {
3425 vty_out(vty, "%% Malformed Route Distinguisher\n");
3426 return CMD_WARNING;
3427 }
3428 }
3429
3430 /* get the type */
3431 if (argv_find(argv, argc, "type", &type_idx)) {
3432 /* Specific type is requested */
3433 if (strncmp(argv[type_idx + 1]->arg, "ma", 2) == 0)
3434 type = BGP_EVPN_MAC_IP_ROUTE;
3435 else if (strncmp(argv[type_idx + 1]->arg, "mu", 2) == 0)
3436 type = BGP_EVPN_IMET_ROUTE;
3437 else if (strncmp(argv[type_idx + 1]->arg, "pr", 2) == 0)
3438 type = BGP_EVPN_IP_PREFIX_ROUTE;
3439 else
3440 return CMD_WARNING;
3441 }
3442
3443 evpn_show_route_rd(vty, bgp, &prd, type, json);
3444
3445 if (uj) {
3446 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3447 json, JSON_C_TO_STRING_PRETTY));
3448 json_object_free(json);
3449 }
3450
3451 return CMD_SUCCESS;
3452 }
3453
3454 /*
3455 * Display global EVPN routing table for specific RD and MACIP.
3456 */
3457 DEFUN(show_bgp_l2vpn_evpn_route_rd_macip,
3458 show_bgp_l2vpn_evpn_route_rd_macip_cmd,
3459 "show bgp l2vpn evpn route rd ASN:NN_OR_IP-ADDRESS:NN mac WORD [ip WORD] [json]",
3460 SHOW_STR
3461 BGP_STR
3462 L2VPN_HELP_STR
3463 EVPN_HELP_STR
3464 "EVPN route information\n"
3465 "Route Distinguisher\n"
3466 "ASN:XX or A.B.C.D:XX\n"
3467 "MAC\n"
3468 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
3469 "IP\n"
3470 "IP address (IPv4 or IPv6)\n"
3471 JSON_STR)
3472 {
3473 struct bgp *bgp;
3474 int ret;
3475 struct prefix_rd prd;
3476 struct ethaddr mac;
3477 struct ipaddr ip;
3478 int rd_idx = 0;
3479 int mac_idx = 0;
3480 int ip_idx = 0;
3481 bool uj = false;
3482 json_object *json = NULL;
3483
3484 memset(&mac, 0, sizeof(struct ethaddr));
3485 memset(&ip, 0, sizeof(struct ipaddr));
3486
3487 bgp = bgp_get_default();
3488 if (!bgp)
3489 return CMD_WARNING;
3490
3491 /* check if we need json output */
3492 uj = use_json(argc, argv);
3493 if (uj)
3494 json = json_object_new_object();
3495
3496 /* get the prd */
3497 if (argv_find(argv, argc, "rd", &rd_idx)) {
3498 ret = str2prefix_rd(argv[rd_idx + 1]->arg, &prd);
3499 if (!ret) {
3500 vty_out(vty, "%% Malformed Route Distinguisher\n");
3501 return CMD_WARNING;
3502 }
3503 }
3504
3505 /* get the mac */
3506 if (argv_find(argv, argc, "mac", &mac_idx)) {
3507 if (!prefix_str2mac(argv[mac_idx + 1]->arg, &mac)) {
3508 vty_out(vty, "%% Malformed MAC address\n");
3509 return CMD_WARNING;
3510 }
3511 }
3512
3513 /* get the ip if specified */
3514 if (argv_find(argv, argc, "ip", &ip_idx)) {
3515 if (str2ipaddr(argv[ip_idx + 1]->arg, &ip) != 0) {
3516 vty_out(vty, "%% Malformed IP address\n");
3517 return CMD_WARNING;
3518 }
3519 }
3520
3521 evpn_show_route_rd_macip(vty, bgp, &prd, &mac, &ip, json);
3522
3523 if (uj) {
3524 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3525 json, JSON_C_TO_STRING_PRETTY));
3526 json_object_free(json);
3527 }
3528
3529 return CMD_SUCCESS;
3530 }
3531
3532 /* Display per ESI routing table */
3533 DEFUN(show_bgp_l2vpn_evpn_route_esi,
3534 show_bgp_l2vpn_evpn_route_esi_cmd,
3535 "show bgp l2vpn evpn route esi ESI [json]",
3536 SHOW_STR
3537 BGP_STR
3538 L2VPN_HELP_STR
3539 EVPN_HELP_STR
3540 "EVPN route information\n"
3541 "Ethernet Segment Identifier\n"
3542 "ESI ID\n"
3543 JSON_STR)
3544 {
3545 bool uj = false;
3546 esi_t esi;
3547 struct bgp *bgp = NULL;
3548 json_object *json = NULL;
3549
3550 memset(&esi, 0, sizeof(esi));
3551 bgp = bgp_get_default();
3552 if (!bgp)
3553 return CMD_WARNING;
3554
3555 uj = use_json(argc, argv);
3556 if (uj)
3557 json = json_object_new_object();
3558
3559 /* get the ESI - ESI-ID is at argv[6] */
3560 if (!str_to_esi(argv[6]->arg, &esi)) {
3561 vty_out(vty, "%% Malformed ESI\n");
3562 return CMD_WARNING;
3563 }
3564
3565 evpn_show_routes_esi(vty, bgp, &esi, json);
3566
3567 if (uj) {
3568 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3569 json, JSON_C_TO_STRING_PRETTY));
3570 json_object_free(json);
3571 }
3572
3573 return CMD_SUCCESS;
3574 }
3575
3576
3577 /*
3578 * Display per-VNI EVPN routing table.
3579 */
3580 DEFUN(show_bgp_l2vpn_evpn_route_vni, show_bgp_l2vpn_evpn_route_vni_cmd,
3581 "show bgp l2vpn evpn route vni (1-16777215) [<type <macip|multicast> | vtep A.B.C.D>] [json]",
3582 SHOW_STR
3583 BGP_STR
3584 L2VPN_HELP_STR
3585 EVPN_HELP_STR
3586 "EVPN route information\n"
3587 "VXLAN Network Identifier\n"
3588 "VNI number\n"
3589 "Specify Route type\n"
3590 "MAC-IP (Type-2) route\n"
3591 "Multicast (Type-3) route\n"
3592 "Remote VTEP\n"
3593 "Remote VTEP IP address\n"
3594 JSON_STR)
3595 {
3596 vni_t vni;
3597 struct bgp *bgp;
3598 struct in_addr vtep_ip;
3599 int type = 0;
3600 int idx = 0;
3601 bool uj = false;
3602 json_object *json = NULL;
3603
3604 bgp = bgp_get_default();
3605 if (!bgp)
3606 return CMD_WARNING;
3607
3608 /* check if we need json output */
3609 uj = use_json(argc, argv);
3610 if (uj)
3611 json = json_object_new_object();
3612
3613 if (!argv_find(argv, argc, "evpn", &idx))
3614 return CMD_WARNING;
3615
3616 vtep_ip.s_addr = 0;
3617
3618 vni = strtoul(argv[idx + 3]->arg, NULL, 10);
3619
3620 if ((!uj && ((argc == (idx + 1 + 5)) && argv[idx + 4]->arg))
3621 || (uj && ((argc == (idx + 1 + 6)) && argv[idx + 4]->arg))) {
3622 if (strncmp(argv[idx + 4]->arg, "type", 4) == 0) {
3623 if (strncmp(argv[idx + 5]->arg, "ma", 2) == 0)
3624 type = BGP_EVPN_MAC_IP_ROUTE;
3625 else if (strncmp(argv[idx + 5]->arg, "mu", 2) == 0)
3626 type = BGP_EVPN_IMET_ROUTE;
3627 else
3628 return CMD_WARNING;
3629 } else if (strncmp(argv[idx + 4]->arg, "vtep", 4) == 0) {
3630 if (!inet_aton(argv[idx + 5]->arg, &vtep_ip)) {
3631 vty_out(vty, "%% Malformed VTEP IP address\n");
3632 return CMD_WARNING;
3633 }
3634 } else
3635 return CMD_WARNING;
3636 }
3637
3638 evpn_show_routes_vni(vty, bgp, vni, type, vtep_ip, json);
3639
3640 if (uj) {
3641 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3642 json, JSON_C_TO_STRING_PRETTY));
3643 json_object_free(json);
3644 }
3645
3646 return CMD_SUCCESS;
3647 }
3648
3649 /*
3650 * Display per-VNI EVPN routing table for specific MACIP.
3651 */
3652 DEFUN(show_bgp_l2vpn_evpn_route_vni_macip,
3653 show_bgp_l2vpn_evpn_route_vni_macip_cmd,
3654 "show bgp l2vpn evpn route vni (1-16777215) mac WORD [ip WORD] [json]",
3655 SHOW_STR
3656 BGP_STR
3657 L2VPN_HELP_STR
3658 EVPN_HELP_STR
3659 "EVPN route information\n"
3660 "VXLAN Network Identifier\n"
3661 "VNI number\n"
3662 "MAC\n"
3663 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
3664 "IP\n"
3665 "IP address (IPv4 or IPv6)\n"
3666 JSON_STR)
3667 {
3668 vni_t vni;
3669 struct bgp *bgp;
3670 struct ethaddr mac;
3671 struct ipaddr ip;
3672 int idx = 0;
3673 bool uj = false;
3674 json_object *json = NULL;
3675
3676 bgp = bgp_get_default();
3677 if (!bgp)
3678 return CMD_WARNING;
3679
3680 /* check if we need json output */
3681 uj = use_json(argc, argv);
3682 if (uj)
3683 json = json_object_new_object();
3684
3685 if (!argv_find(argv, argc, "evpn", &idx))
3686 return CMD_WARNING;
3687
3688 /* get the VNI */
3689 vni = strtoul(argv[idx + 3]->arg, NULL, 10);
3690
3691 /* get the mac */
3692 if (!prefix_str2mac(argv[idx + 5]->arg, &mac)) {
3693 vty_out(vty, "%% Malformed MAC address\n");
3694 return CMD_WARNING;
3695 }
3696
3697 /* get the ip */
3698 memset(&ip, 0, sizeof(ip));
3699 if ((!uj && ((argc == (idx + 1 + 7)) && argv[idx + 7]->arg != NULL))
3700 || (uj
3701 && ((argc == (idx + 1 + 8)) && argv[idx + 7]->arg != NULL))) {
3702 if (str2ipaddr(argv[idx + 7]->arg, &ip) != 0) {
3703 vty_out(vty, "%% Malformed IP address\n");
3704 return CMD_WARNING;
3705 }
3706 }
3707
3708 evpn_show_route_vni_macip(vty, bgp, vni, &mac, &ip, json);
3709
3710 if (uj) {
3711 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3712 json, JSON_C_TO_STRING_PRETTY));
3713 json_object_free(json);
3714 }
3715
3716 return CMD_SUCCESS;
3717 }
3718
3719 /*
3720 * Display per-VNI EVPN routing table for specific multicast IP (remote VTEP).
3721 */
3722 DEFUN(show_bgp_l2vpn_evpn_route_vni_multicast,
3723 show_bgp_l2vpn_evpn_route_vni_multicast_cmd,
3724 "show bgp l2vpn evpn route vni (1-16777215) multicast A.B.C.D [json]",
3725 SHOW_STR
3726 BGP_STR
3727 L2VPN_HELP_STR
3728 EVPN_HELP_STR
3729 "EVPN route information\n"
3730 "VXLAN Network Identifier\n"
3731 "VNI number\n"
3732 "Multicast (Type-3) route\n"
3733 "Originating Router IP address\n"
3734 JSON_STR)
3735 {
3736 vni_t vni;
3737 struct bgp *bgp;
3738 int ret;
3739 struct in_addr orig_ip;
3740 int idx = 0;
3741 bool uj = false;
3742 json_object *json = NULL;
3743
3744 bgp = bgp_get_default();
3745 if (!bgp)
3746 return CMD_WARNING;
3747
3748 /* check if we need json output */
3749 uj = use_json(argc, argv);
3750 if (uj)
3751 json = json_object_new_object();
3752
3753 if (!argv_find(argv, argc, "evpn", &idx))
3754 return CMD_WARNING;
3755
3756 /* get the VNI */
3757 vni = strtoul(argv[idx + 3]->arg, NULL, 10);
3758
3759 /* get the ip */
3760 ret = inet_aton(argv[idx + 5]->arg, &orig_ip);
3761 if (!ret) {
3762 vty_out(vty, "%% Malformed Originating Router IP address\n");
3763 return CMD_WARNING;
3764 }
3765
3766 evpn_show_route_vni_multicast(vty, bgp, vni, orig_ip, json);
3767
3768 if (uj) {
3769 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3770 json, JSON_C_TO_STRING_PRETTY));
3771 json_object_free(json);
3772 }
3773
3774 return CMD_SUCCESS;
3775 }
3776
3777 /*
3778 * Display per-VNI EVPN routing table - for all VNIs.
3779 */
3780 DEFUN(show_bgp_l2vpn_evpn_route_vni_all,
3781 show_bgp_l2vpn_evpn_route_vni_all_cmd,
3782 "show bgp l2vpn evpn route vni all [vtep A.B.C.D] [json]",
3783 SHOW_STR
3784 BGP_STR
3785 L2VPN_HELP_STR
3786 EVPN_HELP_STR
3787 "EVPN route information\n"
3788 "VXLAN Network Identifier\n"
3789 "All VNIs\n"
3790 "Remote VTEP\n"
3791 "Remote VTEP IP address\n"
3792 JSON_STR)
3793 {
3794 struct bgp *bgp;
3795 struct in_addr vtep_ip;
3796 int idx = 0;
3797 bool uj = false;
3798 json_object *json = NULL;
3799
3800 bgp = bgp_get_default();
3801 if (!bgp)
3802 return CMD_WARNING;
3803
3804 /* check if we need json output */
3805 uj = use_json(argc, argv);
3806 if (uj)
3807 json = json_object_new_object();
3808
3809 if (!argv_find(argv, argc, "evpn", &idx))
3810 return CMD_WARNING;
3811
3812 vtep_ip.s_addr = 0;
3813 if ((!uj && (argc == (idx + 1 + 5) && argv[idx + 5]->arg))
3814 || (uj && (argc == (idx + 1 + 6) && argv[idx + 5]->arg))) {
3815 if (!inet_aton(argv[idx + 5]->arg, &vtep_ip)) {
3816 vty_out(vty, "%% Malformed VTEP IP address\n");
3817 return CMD_WARNING;
3818 }
3819 }
3820
3821 evpn_show_routes_vni_all(vty, bgp, vtep_ip, json);
3822
3823 if (uj) {
3824 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3825 json, JSON_C_TO_STRING_PRETTY));
3826 json_object_free(json);
3827 }
3828
3829 return CMD_SUCCESS;
3830 }
3831
3832 /*
3833 * Display EVPN import route-target hash table
3834 */
3835 DEFUN(show_bgp_l2vpn_evpn_vrf_import_rt,
3836 show_bgp_l2vpn_evpn_vrf_import_rt_cmd,
3837 "show bgp l2vpn evpn vrf-import-rt [json]",
3838 SHOW_STR
3839 BGP_STR
3840 L2VPN_HELP_STR
3841 EVPN_HELP_STR
3842 "Show vrf import route target\n"
3843 JSON_STR)
3844 {
3845 bool uj = false;
3846 struct bgp *bgp_def = NULL;
3847 json_object *json = NULL;
3848
3849 bgp_def = bgp_get_default();
3850 if (!bgp_def)
3851 return CMD_WARNING;
3852
3853 uj = use_json(argc, argv);
3854 if (uj)
3855 json = json_object_new_object();
3856
3857 evpn_show_vrf_import_rts(vty, bgp_def, json);
3858
3859 if (uj) {
3860 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3861 json, JSON_C_TO_STRING_PRETTY));
3862 json_object_free(json);
3863 }
3864
3865 return CMD_SUCCESS;
3866 }
3867
3868 /*
3869 * Display EVPN import route-target hash table
3870 */
3871 DEFUN(show_bgp_l2vpn_evpn_import_rt,
3872 show_bgp_l2vpn_evpn_import_rt_cmd,
3873 "show bgp l2vpn evpn import-rt [json]",
3874 SHOW_STR
3875 BGP_STR
3876 L2VPN_HELP_STR
3877 EVPN_HELP_STR
3878 "Show import route target\n"
3879 JSON_STR)
3880 {
3881 struct bgp *bgp;
3882 bool uj = false;
3883 json_object *json = NULL;
3884
3885 bgp = bgp_get_default();
3886 if (!bgp)
3887 return CMD_WARNING;
3888
3889 uj = use_json(argc, argv);
3890 if (uj)
3891 json = json_object_new_object();
3892
3893 evpn_show_import_rts(vty, bgp, json);
3894
3895 if (uj) {
3896 vty_out(vty, "%s\n", json_object_to_json_string_ext(
3897 json, JSON_C_TO_STRING_PRETTY));
3898 json_object_free(json);
3899 }
3900
3901 return CMD_SUCCESS;
3902 }
3903
3904 DEFUN(test_adv_evpn_type4_route,
3905 test_adv_evpn_type4_route_cmd,
3906 "advertise es ESI",
3907 "Advertise EVPN ES route\n"
3908 "Ethernet-segment\n"
3909 "Ethernet-Segment Identifier\n")
3910 {
3911 int ret = 0;
3912 esi_t esi;
3913 struct bgp *bgp;
3914 struct ipaddr vtep_ip;
3915
3916 bgp = bgp_get_default();
3917 if (!bgp) {
3918 vty_out(vty, "%%Default BGP instance not yet created\n");
3919 return CMD_WARNING;
3920 }
3921
3922 if (!str_to_esi(argv[2]->arg, &esi)) {
3923 vty_out(vty, "%%Malformed ESI\n");
3924 return CMD_WARNING;
3925 }
3926
3927 vtep_ip.ipa_type = IPADDR_V4;
3928 vtep_ip.ipaddr_v4 = bgp->router_id;
3929
3930 ret = bgp_evpn_local_es_add(bgp, &esi, &vtep_ip);
3931 if (ret == -1) {
3932 vty_out(vty, "%%Failed to EVPN advertise type-4 route\n");
3933 return CMD_WARNING;
3934 }
3935 return CMD_SUCCESS;
3936 }
3937
3938 DEFUN(test_withdraw_evpn_type4_route,
3939 test_withdraw_evpn_type4_route_cmd,
3940 "withdraw es ESI",
3941 "Advertise EVPN ES route\n"
3942 "Ethernet-segment\n"
3943 "Ethernet-Segment Identifier\n")
3944 {
3945 int ret = 0;
3946 esi_t esi;
3947 struct bgp *bgp;
3948 struct ipaddr vtep_ip;
3949
3950 bgp = bgp_get_default();
3951 if (!bgp) {
3952 vty_out(vty, "%%Default BGP instance not yet created\n");
3953 return CMD_WARNING;
3954 }
3955
3956 if (!bgp->peer_self) {
3957 vty_out(vty, "%%BGP instance doesnt have self peer\n");
3958 return CMD_WARNING;
3959 }
3960
3961 if (!str_to_esi(argv[2]->arg, &esi)) {
3962 vty_out(vty, "%%Malformed ESI\n");
3963 return CMD_WARNING;
3964 }
3965
3966 vtep_ip.ipa_type = IPADDR_V4;
3967 vtep_ip.ipaddr_v4 = bgp->router_id;
3968 ret = bgp_evpn_local_es_del(bgp, &esi, &vtep_ip);
3969 if (ret == -1) {
3970 vty_out(vty, "%%Failed to withdraw EVPN type-4 route\n");
3971 return CMD_WARNING;
3972 }
3973 return CMD_SUCCESS;
3974 }
3975
3976 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_vni, show_bgp_evpn_vni_cmd,
3977 "show bgp evpn vni [(1-16777215)]", SHOW_STR BGP_STR EVPN_HELP_STR
3978 "Show VNI\n"
3979 "VNI number\n")
3980
3981 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_summary, show_bgp_evpn_summary_cmd,
3982 "show bgp evpn summary [json]", SHOW_STR BGP_STR EVPN_HELP_STR
3983 "Summary of BGP neighbor status\n" JSON_STR)
3984
3985 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route, show_bgp_evpn_route_cmd,
3986 "show bgp evpn route [type <macip|multicast>]",
3987 SHOW_STR BGP_STR EVPN_HELP_STR
3988 "EVPN route information\n"
3989 "Specify Route type\n"
3990 "MAC-IP (Type-2) route\n"
3991 "Multicast (Type-3) route\n")
3992
3993 ALIAS_HIDDEN(
3994 show_bgp_l2vpn_evpn_route_rd, show_bgp_evpn_route_rd_cmd,
3995 "show bgp evpn route rd ASN:NN_OR_IP-ADDRESS:NN [type <macip|multicast>]",
3996 SHOW_STR BGP_STR EVPN_HELP_STR
3997 "EVPN route information\n"
3998 "Route Distinguisher\n"
3999 "ASN:XX or A.B.C.D:XX\n"
4000 "Specify Route type\n"
4001 "MAC-IP (Type-2) route\n"
4002 "Multicast (Type-3) route\n")
4003
4004 ALIAS_HIDDEN(
4005 show_bgp_l2vpn_evpn_route_rd_macip, show_bgp_evpn_route_rd_macip_cmd,
4006 "show bgp evpn route rd ASN:NN_OR_IP-ADDRESS:NN mac WORD [ip WORD]",
4007 SHOW_STR BGP_STR EVPN_HELP_STR
4008 "EVPN route information\n"
4009 "Route Distinguisher\n"
4010 "ASN:XX or A.B.C.D:XX\n"
4011 "MAC\n"
4012 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
4013 "IP\n"
4014 "IP address (IPv4 or IPv6)\n")
4015
4016 ALIAS_HIDDEN(
4017 show_bgp_l2vpn_evpn_route_vni, show_bgp_evpn_route_vni_cmd,
4018 "show bgp evpn route vni (1-16777215) [<type <macip|multicast> | vtep A.B.C.D>]",
4019 SHOW_STR BGP_STR EVPN_HELP_STR
4020 "EVPN route information\n"
4021 "VXLAN Network Identifier\n"
4022 "VNI number\n"
4023 "Specify Route type\n"
4024 "MAC-IP (Type-2) route\n"
4025 "Multicast (Type-3) route\n"
4026 "Remote VTEP\n"
4027 "Remote VTEP IP address\n")
4028
4029 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_macip,
4030 show_bgp_evpn_route_vni_macip_cmd,
4031 "show bgp evpn route vni (1-16777215) mac WORD [ip WORD]",
4032 SHOW_STR BGP_STR EVPN_HELP_STR
4033 "EVPN route information\n"
4034 "VXLAN Network Identifier\n"
4035 "VNI number\n"
4036 "MAC\n"
4037 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
4038 "IP\n"
4039 "IP address (IPv4 or IPv6)\n")
4040
4041 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_multicast,
4042 show_bgp_evpn_route_vni_multicast_cmd,
4043 "show bgp evpn route vni (1-16777215) multicast A.B.C.D",
4044 SHOW_STR BGP_STR EVPN_HELP_STR
4045 "EVPN route information\n"
4046 "VXLAN Network Identifier\n"
4047 "VNI number\n"
4048 "Multicast (Type-3) route\n"
4049 "Originating Router IP address\n")
4050
4051 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route_vni_all, show_bgp_evpn_route_vni_all_cmd,
4052 "show bgp evpn route vni all [vtep A.B.C.D]",
4053 SHOW_STR BGP_STR EVPN_HELP_STR
4054 "EVPN route information\n"
4055 "VXLAN Network Identifier\n"
4056 "All VNIs\n"
4057 "Remote VTEP\n"
4058 "Remote VTEP IP address\n")
4059
4060 ALIAS_HIDDEN(show_bgp_l2vpn_evpn_import_rt, show_bgp_evpn_import_rt_cmd,
4061 "show bgp evpn import-rt",
4062 SHOW_STR BGP_STR EVPN_HELP_STR "Show import route target\n")
4063
4064 DEFUN_NOSH (bgp_evpn_vni,
4065 bgp_evpn_vni_cmd,
4066 "vni (1-16777215)",
4067 "VXLAN Network Identifier\n"
4068 "VNI number\n")
4069 {
4070 vni_t vni;
4071 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4072 struct bgpevpn *vpn;
4073
4074 if (!bgp)
4075 return CMD_WARNING;
4076
4077 vni = strtoul(argv[1]->arg, NULL, 10);
4078
4079 /* Create VNI, or mark as configured. */
4080 vpn = evpn_create_update_vni(bgp, vni);
4081 if (!vpn) {
4082 vty_out(vty, "%% Failed to create VNI \n");
4083 return CMD_WARNING;
4084 }
4085
4086 VTY_PUSH_CONTEXT_SUB(BGP_EVPN_VNI_NODE, vpn);
4087 return CMD_SUCCESS;
4088 }
4089
4090 DEFUN (no_bgp_evpn_vni,
4091 no_bgp_evpn_vni_cmd,
4092 "no vni (1-16777215)",
4093 NO_STR
4094 "VXLAN Network Identifier\n"
4095 "VNI number\n")
4096 {
4097 vni_t vni;
4098 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4099 struct bgpevpn *vpn;
4100
4101 if (!bgp)
4102 return CMD_WARNING;
4103
4104 vni = strtoul(argv[2]->arg, NULL, 10);
4105
4106 /* Check if we should disallow. */
4107 vpn = bgp_evpn_lookup_vni(bgp, vni);
4108 if (!vpn) {
4109 vty_out(vty, "%% Specified VNI does not exist\n");
4110 return CMD_WARNING;
4111 }
4112 if (!is_vni_configured(vpn)) {
4113 vty_out(vty, "%% Specified VNI is not configured\n");
4114 return CMD_WARNING;
4115 }
4116
4117 evpn_delete_vni(bgp, vpn);
4118 return CMD_SUCCESS;
4119 }
4120
4121 DEFUN_NOSH (exit_vni,
4122 exit_vni_cmd,
4123 "exit-vni",
4124 "Exit from VNI mode\n")
4125 {
4126 if (vty->node == BGP_EVPN_VNI_NODE)
4127 vty->node = BGP_EVPN_NODE;
4128 return CMD_SUCCESS;
4129 }
4130
4131 DEFUN (bgp_evpn_vrf_rd,
4132 bgp_evpn_vrf_rd_cmd,
4133 "rd ASN:NN_OR_IP-ADDRESS:NN",
4134 "Route Distinguisher\n"
4135 "ASN:XX or A.B.C.D:XX\n")
4136 {
4137 int ret;
4138 struct prefix_rd prd;
4139 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp);
4140
4141 if (!bgp_vrf)
4142 return CMD_WARNING;
4143
4144 ret = str2prefix_rd(argv[1]->arg, &prd);
4145 if (!ret) {
4146 vty_out(vty, "%% Malformed Route Distinguisher\n");
4147 return CMD_WARNING;
4148 }
4149
4150 /* If same as existing value, there is nothing more to do. */
4151 if (bgp_evpn_vrf_rd_matches_existing(bgp_vrf, &prd))
4152 return CMD_SUCCESS;
4153
4154 /* Configure or update the RD. */
4155 evpn_configure_vrf_rd(bgp_vrf, &prd);
4156 return CMD_SUCCESS;
4157 }
4158
4159 DEFUN (no_bgp_evpn_vrf_rd,
4160 no_bgp_evpn_vrf_rd_cmd,
4161 "no rd ASN:NN_OR_IP-ADDRESS:NN",
4162 NO_STR
4163 "Route Distinguisher\n"
4164 "ASN:XX or A.B.C.D:XX\n")
4165 {
4166 int ret;
4167 struct prefix_rd prd;
4168 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp);
4169
4170 if (!bgp_vrf)
4171 return CMD_WARNING;
4172
4173 ret = str2prefix_rd(argv[2]->arg, &prd);
4174 if (!ret) {
4175 vty_out(vty, "%% Malformed Route Distinguisher\n");
4176 return CMD_WARNING;
4177 }
4178
4179 /* Check if we should disallow. */
4180 if (!is_vrf_rd_configured(bgp_vrf)) {
4181 vty_out(vty, "%% RD is not configured for this VRF\n");
4182 return CMD_WARNING;
4183 }
4184
4185 if (!bgp_evpn_vrf_rd_matches_existing(bgp_vrf, &prd)) {
4186 vty_out(vty,
4187 "%% RD specified does not match configuration for this VRF\n");
4188 return CMD_WARNING;
4189 }
4190
4191 evpn_unconfigure_vrf_rd(bgp_vrf);
4192 return CMD_SUCCESS;
4193 }
4194
4195 DEFUN (no_bgp_evpn_vrf_rd_without_val,
4196 no_bgp_evpn_vrf_rd_without_val_cmd,
4197 "no rd",
4198 NO_STR
4199 "Route Distinguisher\n")
4200 {
4201 struct bgp *bgp_vrf = VTY_GET_CONTEXT(bgp);
4202
4203 if (!bgp_vrf)
4204 return CMD_WARNING;
4205
4206 /* Check if we should disallow. */
4207 if (!is_vrf_rd_configured(bgp_vrf)) {
4208 vty_out(vty, "%% RD is not configured for this VRF\n");
4209 return CMD_WARNING;
4210 }
4211
4212 evpn_unconfigure_vrf_rd(bgp_vrf);
4213 return CMD_SUCCESS;
4214 }
4215
4216 DEFUN (bgp_evpn_vni_rd,
4217 bgp_evpn_vni_rd_cmd,
4218 "rd ASN:NN_OR_IP-ADDRESS:NN",
4219 "Route Distinguisher\n"
4220 "ASN:XX or A.B.C.D:XX\n")
4221 {
4222 struct prefix_rd prd;
4223 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4224 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4225 int ret;
4226
4227 if (!bgp)
4228 return CMD_WARNING;
4229
4230 if (bgp->vrf_id != VRF_DEFAULT) {
4231 vty_out(vty,
4232 "This command is only supported under Default VRF\n");
4233 return CMD_WARNING;
4234 }
4235
4236 ret = str2prefix_rd(argv[1]->arg, &prd);
4237 if (!ret) {
4238 vty_out(vty, "%% Malformed Route Distinguisher\n");
4239 return CMD_WARNING;
4240 }
4241
4242 /* If same as existing value, there is nothing more to do. */
4243 if (bgp_evpn_rd_matches_existing(vpn, &prd))
4244 return CMD_SUCCESS;
4245
4246 /* Configure or update the RD. */
4247 evpn_configure_rd(bgp, vpn, &prd);
4248 return CMD_SUCCESS;
4249 }
4250
4251 DEFUN (no_bgp_evpn_vni_rd,
4252 no_bgp_evpn_vni_rd_cmd,
4253 "no rd ASN:NN_OR_IP-ADDRESS:NN",
4254 NO_STR
4255 "Route Distinguisher\n"
4256 "ASN:XX or A.B.C.D:XX\n")
4257 {
4258 struct prefix_rd prd;
4259 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4260 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4261 int ret;
4262
4263 if (!bgp)
4264 return CMD_WARNING;
4265
4266 if (bgp->vrf_id != VRF_DEFAULT) {
4267 vty_out(vty,
4268 "This command is only supported under Default VRF\n");
4269 return CMD_WARNING;
4270 }
4271
4272 ret = str2prefix_rd(argv[2]->arg, &prd);
4273 if (!ret) {
4274 vty_out(vty, "%% Malformed Route Distinguisher\n");
4275 return CMD_WARNING;
4276 }
4277
4278 /* Check if we should disallow. */
4279 if (!is_rd_configured(vpn)) {
4280 vty_out(vty, "%% RD is not configured for this VNI\n");
4281 return CMD_WARNING;
4282 }
4283
4284 if (!bgp_evpn_rd_matches_existing(vpn, &prd)) {
4285 vty_out(vty,
4286 "%% RD specified does not match configuration for this VNI\n");
4287 return CMD_WARNING;
4288 }
4289
4290 evpn_unconfigure_rd(bgp, vpn);
4291 return CMD_SUCCESS;
4292 }
4293
4294 DEFUN (no_bgp_evpn_vni_rd_without_val,
4295 no_bgp_evpn_vni_rd_without_val_cmd,
4296 "no rd",
4297 NO_STR
4298 "Route Distinguisher\n")
4299 {
4300 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4301 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4302
4303 if (!bgp)
4304 return CMD_WARNING;
4305
4306 if (bgp->vrf_id != VRF_DEFAULT) {
4307 vty_out(vty,
4308 "This command is only supported under Default VRF\n");
4309 return CMD_WARNING;
4310 }
4311
4312 /* Check if we should disallow. */
4313 if (!is_rd_configured(vpn)) {
4314 vty_out(vty, "%% RD is not configured for this VNI\n");
4315 return CMD_WARNING;
4316 }
4317
4318 evpn_unconfigure_rd(bgp, vpn);
4319 return CMD_SUCCESS;
4320 }
4321
4322 /*
4323 * Loop over all extended-communities in the route-target list rtl and
4324 * return 1 if we find ecomtarget
4325 */
4326 static int bgp_evpn_rt_matches_existing(struct list *rtl,
4327 struct ecommunity *ecomtarget)
4328 {
4329 struct listnode *node, *nnode;
4330 struct ecommunity *ecom;
4331
4332 for (ALL_LIST_ELEMENTS(rtl, node, nnode, ecom)) {
4333 if (ecommunity_match(ecom, ecomtarget))
4334 return 1;
4335 }
4336
4337 return 0;
4338 }
4339
4340 /* display L3VNI related info for a VRF instance */
4341 DEFUN (show_bgp_vrf_l3vni_info,
4342 show_bgp_vrf_l3vni_info_cmd,
4343 "show bgp vrf VRFNAME vni [json]",
4344 SHOW_STR
4345 BGP_STR
4346 "show bgp vrf\n"
4347 "VRF Name\n"
4348 "L3-VNI\n"
4349 JSON_STR)
4350 {
4351 char buf[ETHER_ADDR_STRLEN];
4352 char buf1[INET6_ADDRSTRLEN];
4353 int idx_vrf = 3;
4354 const char *name = NULL;
4355 struct bgp *bgp = NULL;
4356 struct listnode *node = NULL;
4357 struct bgpevpn *vpn = NULL;
4358 struct ecommunity *ecom = NULL;
4359 json_object *json = NULL;
4360 json_object *json_vnis = NULL;
4361 json_object *json_export_rts = NULL;
4362 json_object *json_import_rts = NULL;
4363 bool uj = use_json(argc, argv);
4364
4365 if (uj) {
4366 json = json_object_new_object();
4367 json_vnis = json_object_new_array();
4368 json_export_rts = json_object_new_array();
4369 json_import_rts = json_object_new_array();
4370 }
4371
4372 name = argv[idx_vrf]->arg;
4373 bgp = bgp_lookup_by_name(name);
4374 if (!bgp) {
4375 if (!uj)
4376 vty_out(vty, "BGP instance for VRF %s not found", name);
4377 else {
4378 json_object_string_add(json, "warning",
4379 "BGP instance not found");
4380 vty_out(vty, "%s\n", json_object_to_json_string(json));
4381 json_object_free(json);
4382 }
4383 return CMD_WARNING;
4384 }
4385
4386 if (!json) {
4387 vty_out(vty, "BGP VRF: %s\n", name);
4388 vty_out(vty, " Local-Ip: %s\n", inet_ntoa(bgp->originator_ip));
4389 vty_out(vty, " L3-VNI: %u\n", bgp->l3vni);
4390 vty_out(vty, " Rmac: %s\n",
4391 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
4392 vty_out(vty, " VNI Filter: %s\n",
4393 CHECK_FLAG(bgp->vrf_flags,
4394 BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY)
4395 ? "prefix-routes-only"
4396 : "none");
4397 vty_out(vty, " L2-VNI List:\n");
4398 vty_out(vty, " ");
4399 for (ALL_LIST_ELEMENTS_RO(bgp->l2vnis, node, vpn))
4400 vty_out(vty, "%u ", vpn->vni);
4401 vty_out(vty, "\n");
4402 vty_out(vty, " Export-RTs:\n");
4403 vty_out(vty, " ");
4404 for (ALL_LIST_ELEMENTS_RO(bgp->vrf_export_rtl, node, ecom))
4405 vty_out(vty, "%s ", ecommunity_str(ecom));
4406 vty_out(vty, "\n");
4407 vty_out(vty, " Import-RTs:\n");
4408 vty_out(vty, " ");
4409 for (ALL_LIST_ELEMENTS_RO(bgp->vrf_import_rtl, node, ecom))
4410 vty_out(vty, "%s ", ecommunity_str(ecom));
4411 vty_out(vty, "\n");
4412 vty_out(vty, " RD: %s\n",
4413 prefix_rd2str(&bgp->vrf_prd, buf1, RD_ADDRSTRLEN));
4414 } else {
4415 json_object_string_add(json, "vrf", name);
4416 json_object_string_add(json, "local-ip",
4417 inet_ntoa(bgp->originator_ip));
4418 json_object_int_add(json, "l3vni", bgp->l3vni);
4419 json_object_string_add(
4420 json, "rmac",
4421 prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
4422 json_object_string_add(
4423 json, "vniFilter",
4424 CHECK_FLAG(bgp->vrf_flags,
4425 BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY)
4426 ? "prefix-routes-only"
4427 : "none");
4428 /* list of l2vnis */
4429 for (ALL_LIST_ELEMENTS_RO(bgp->l2vnis, node, vpn))
4430 json_object_array_add(json_vnis,
4431 json_object_new_int(vpn->vni));
4432 json_object_object_add(json, "l2vnis", json_vnis);
4433
4434 /* export rts */
4435 for (ALL_LIST_ELEMENTS_RO(bgp->vrf_export_rtl, node, ecom))
4436 json_object_array_add(
4437 json_export_rts,
4438 json_object_new_string(ecommunity_str(ecom)));
4439 json_object_object_add(json, "export-rts", json_export_rts);
4440
4441 /* import rts */
4442 for (ALL_LIST_ELEMENTS_RO(bgp->vrf_import_rtl, node, ecom))
4443 json_object_array_add(
4444 json_import_rts,
4445 json_object_new_string(ecommunity_str(ecom)));
4446 json_object_object_add(json, "import-rts", json_import_rts);
4447 json_object_string_add(
4448 json, "rd",
4449 prefix_rd2str(&bgp->vrf_prd, buf1, RD_ADDRSTRLEN));
4450 }
4451
4452 if (uj) {
4453 vty_out(vty, "%s\n", json_object_to_json_string_ext(
4454 json, JSON_C_TO_STRING_PRETTY));
4455 json_object_free(json);
4456 }
4457 return CMD_SUCCESS;
4458 }
4459
4460 /* import/export rt for l3vni-vrf */
4461 DEFUN (bgp_evpn_vrf_rt,
4462 bgp_evpn_vrf_rt_cmd,
4463 "route-target <both|import|export> RT",
4464 "Route Target\n"
4465 "import and export\n"
4466 "import\n"
4467 "export\n"
4468 "Route target (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
4469 {
4470 int rt_type;
4471 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4472 struct ecommunity *ecomadd = NULL;
4473
4474 if (!bgp)
4475 return CMD_WARNING;
4476
4477 if (!strcmp(argv[1]->arg, "import"))
4478 rt_type = RT_TYPE_IMPORT;
4479 else if (!strcmp(argv[1]->arg, "export"))
4480 rt_type = RT_TYPE_EXPORT;
4481 else if (!strcmp(argv[1]->arg, "both"))
4482 rt_type = RT_TYPE_BOTH;
4483 else {
4484 vty_out(vty, "%% Invalid Route Target type\n");
4485 return CMD_WARNING;
4486 }
4487
4488 /* Add/update the import route-target */
4489 if (rt_type == RT_TYPE_BOTH || rt_type == RT_TYPE_IMPORT) {
4490 ecomadd = ecommunity_str2com(argv[2]->arg,
4491 ECOMMUNITY_ROUTE_TARGET, 0);
4492 if (!ecomadd) {
4493 vty_out(vty, "%% Malformed Route Target list\n");
4494 return CMD_WARNING;
4495 }
4496 ecommunity_str(ecomadd);
4497
4498 /* Do nothing if we already have this import route-target */
4499 if (!bgp_evpn_rt_matches_existing(bgp->vrf_import_rtl, ecomadd))
4500 bgp_evpn_configure_import_rt_for_vrf(bgp, ecomadd);
4501 }
4502
4503 /* Add/update the export route-target */
4504 if (rt_type == RT_TYPE_BOTH || rt_type == RT_TYPE_EXPORT) {
4505 ecomadd = ecommunity_str2com(argv[2]->arg,
4506 ECOMMUNITY_ROUTE_TARGET, 0);
4507 if (!ecomadd) {
4508 vty_out(vty, "%% Malformed Route Target list\n");
4509 return CMD_WARNING;
4510 }
4511 ecommunity_str(ecomadd);
4512
4513 /* Do nothing if we already have this export route-target */
4514 if (!bgp_evpn_rt_matches_existing(bgp->vrf_export_rtl, ecomadd))
4515 bgp_evpn_configure_export_rt_for_vrf(bgp, ecomadd);
4516 }
4517
4518 return CMD_SUCCESS;
4519 }
4520
4521 DEFUN (no_bgp_evpn_vrf_rt,
4522 no_bgp_evpn_vrf_rt_cmd,
4523 "no route-target <both|import|export> RT",
4524 NO_STR
4525 "Route Target\n"
4526 "import and export\n"
4527 "import\n"
4528 "export\n"
4529 "ASN:XX or A.B.C.D:XX\n")
4530 {
4531 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4532 int rt_type, found_ecomdel;
4533 struct ecommunity *ecomdel = NULL;
4534
4535 if (!bgp)
4536 return CMD_WARNING;
4537
4538 if (!strcmp(argv[2]->arg, "import"))
4539 rt_type = RT_TYPE_IMPORT;
4540 else if (!strcmp(argv[2]->arg, "export"))
4541 rt_type = RT_TYPE_EXPORT;
4542 else if (!strcmp(argv[2]->arg, "both"))
4543 rt_type = RT_TYPE_BOTH;
4544 else {
4545 vty_out(vty, "%% Invalid Route Target type\n");
4546 return CMD_WARNING;
4547 }
4548
4549 if (rt_type == RT_TYPE_IMPORT) {
4550 if (!CHECK_FLAG(bgp->vrf_flags, BGP_VRF_IMPORT_RT_CFGD)) {
4551 vty_out(vty,
4552 "%% Import RT is not configured for this VRF\n");
4553 return CMD_WARNING;
4554 }
4555 } else if (rt_type == RT_TYPE_EXPORT) {
4556 if (!CHECK_FLAG(bgp->vrf_flags, BGP_VRF_EXPORT_RT_CFGD)) {
4557 vty_out(vty,
4558 "%% Export RT is not configured for this VRF\n");
4559 return CMD_WARNING;
4560 }
4561 } else if (rt_type == RT_TYPE_BOTH) {
4562 if (!CHECK_FLAG(bgp->vrf_flags, BGP_VRF_IMPORT_RT_CFGD)
4563 && !CHECK_FLAG(bgp->vrf_flags, BGP_VRF_EXPORT_RT_CFGD)) {
4564 vty_out(vty,
4565 "%% Import/Export RT is not configured for this VRF\n");
4566 return CMD_WARNING;
4567 }
4568 }
4569
4570 ecomdel = ecommunity_str2com(argv[3]->arg, ECOMMUNITY_ROUTE_TARGET, 0);
4571 if (!ecomdel) {
4572 vty_out(vty, "%% Malformed Route Target list\n");
4573 return CMD_WARNING;
4574 }
4575 ecommunity_str(ecomdel);
4576
4577 if (rt_type == RT_TYPE_IMPORT) {
4578 if (!bgp_evpn_rt_matches_existing(bgp->vrf_import_rtl,
4579 ecomdel)) {
4580 vty_out(vty,
4581 "%% RT specified does not match configuration for this VRF\n");
4582 return CMD_WARNING;
4583 }
4584 bgp_evpn_unconfigure_import_rt_for_vrf(bgp, ecomdel);
4585 } else if (rt_type == RT_TYPE_EXPORT) {
4586 if (!bgp_evpn_rt_matches_existing(bgp->vrf_export_rtl,
4587 ecomdel)) {
4588 vty_out(vty,
4589 "%% RT specified does not match configuration for this VRF\n");
4590 return CMD_WARNING;
4591 }
4592 bgp_evpn_unconfigure_export_rt_for_vrf(bgp, ecomdel);
4593 } else if (rt_type == RT_TYPE_BOTH) {
4594 found_ecomdel = 0;
4595
4596 if (bgp_evpn_rt_matches_existing(bgp->vrf_import_rtl,
4597 ecomdel)) {
4598 bgp_evpn_unconfigure_import_rt_for_vrf(bgp, ecomdel);
4599 found_ecomdel = 1;
4600 }
4601
4602 if (bgp_evpn_rt_matches_existing(bgp->vrf_export_rtl,
4603 ecomdel)) {
4604 bgp_evpn_unconfigure_export_rt_for_vrf(bgp, ecomdel);
4605 found_ecomdel = 1;
4606 }
4607
4608 if (!found_ecomdel) {
4609 vty_out(vty,
4610 "%% RT specified does not match configuration for this VRF\n");
4611 return CMD_WARNING;
4612 }
4613 }
4614
4615 return CMD_SUCCESS;
4616 }
4617
4618 DEFUN (bgp_evpn_vni_rt,
4619 bgp_evpn_vni_rt_cmd,
4620 "route-target <both|import|export> RT",
4621 "Route Target\n"
4622 "import and export\n"
4623 "import\n"
4624 "export\n"
4625 "Route target (A.B.C.D:MN|EF:OPQR|GHJK:MN)\n")
4626 {
4627 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4628 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4629 int rt_type;
4630 struct ecommunity *ecomadd = NULL;
4631
4632 if (!bgp)
4633 return CMD_WARNING;
4634
4635 if (bgp->vrf_id != VRF_DEFAULT) {
4636 vty_out(vty,
4637 "This command is only supported under Default VRF\n");
4638 return CMD_WARNING;
4639 }
4640
4641 if (!strcmp(argv[1]->text, "import"))
4642 rt_type = RT_TYPE_IMPORT;
4643 else if (!strcmp(argv[1]->text, "export"))
4644 rt_type = RT_TYPE_EXPORT;
4645 else if (!strcmp(argv[1]->text, "both"))
4646 rt_type = RT_TYPE_BOTH;
4647 else {
4648 vty_out(vty, "%% Invalid Route Target type\n");
4649 return CMD_WARNING;
4650 }
4651
4652 /* Add/update the import route-target */
4653 if (rt_type == RT_TYPE_BOTH || rt_type == RT_TYPE_IMPORT) {
4654 ecomadd = ecommunity_str2com(argv[2]->arg,
4655 ECOMMUNITY_ROUTE_TARGET, 0);
4656 if (!ecomadd) {
4657 vty_out(vty, "%% Malformed Route Target list\n");
4658 return CMD_WARNING;
4659 }
4660 ecommunity_str(ecomadd);
4661
4662 /* Do nothing if we already have this import route-target */
4663 if (!bgp_evpn_rt_matches_existing(vpn->import_rtl, ecomadd))
4664 evpn_configure_import_rt(bgp, vpn, ecomadd);
4665 }
4666
4667 /* Add/update the export route-target */
4668 if (rt_type == RT_TYPE_BOTH || rt_type == RT_TYPE_EXPORT) {
4669 ecomadd = ecommunity_str2com(argv[2]->arg,
4670 ECOMMUNITY_ROUTE_TARGET, 0);
4671 if (!ecomadd) {
4672 vty_out(vty, "%% Malformed Route Target list\n");
4673 return CMD_WARNING;
4674 }
4675 ecommunity_str(ecomadd);
4676
4677 /* Do nothing if we already have this export route-target */
4678 if (!bgp_evpn_rt_matches_existing(vpn->export_rtl, ecomadd))
4679 evpn_configure_export_rt(bgp, vpn, ecomadd);
4680 }
4681
4682 return CMD_SUCCESS;
4683 }
4684
4685 DEFUN (no_bgp_evpn_vni_rt,
4686 no_bgp_evpn_vni_rt_cmd,
4687 "no route-target <both|import|export> RT",
4688 NO_STR
4689 "Route Target\n"
4690 "import and export\n"
4691 "import\n"
4692 "export\n"
4693 "ASN:XX or A.B.C.D:XX\n")
4694 {
4695 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4696 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4697 int rt_type, found_ecomdel;
4698 struct ecommunity *ecomdel = NULL;
4699
4700 if (!bgp)
4701 return CMD_WARNING;
4702
4703 if (bgp->vrf_id != VRF_DEFAULT) {
4704 vty_out(vty,
4705 "This command is only supported under Default VRF\n");
4706 return CMD_WARNING;
4707 }
4708
4709 if (!strcmp(argv[2]->text, "import"))
4710 rt_type = RT_TYPE_IMPORT;
4711 else if (!strcmp(argv[2]->text, "export"))
4712 rt_type = RT_TYPE_EXPORT;
4713 else if (!strcmp(argv[2]->text, "both"))
4714 rt_type = RT_TYPE_BOTH;
4715 else {
4716 vty_out(vty, "%% Invalid Route Target type\n");
4717 return CMD_WARNING;
4718 }
4719
4720 /* The user did "no route-target import", check to see if there are any
4721 * import route-targets configured. */
4722 if (rt_type == RT_TYPE_IMPORT) {
4723 if (!is_import_rt_configured(vpn)) {
4724 vty_out(vty,
4725 "%% Import RT is not configured for this VNI\n");
4726 return CMD_WARNING;
4727 }
4728 } else if (rt_type == RT_TYPE_EXPORT) {
4729 if (!is_export_rt_configured(vpn)) {
4730 vty_out(vty,
4731 "%% Export RT is not configured for this VNI\n");
4732 return CMD_WARNING;
4733 }
4734 } else if (rt_type == RT_TYPE_BOTH) {
4735 if (!is_import_rt_configured(vpn)
4736 && !is_export_rt_configured(vpn)) {
4737 vty_out(vty,
4738 "%% Import/Export RT is not configured for this VNI\n");
4739 return CMD_WARNING;
4740 }
4741 }
4742
4743 ecomdel = ecommunity_str2com(argv[3]->arg, ECOMMUNITY_ROUTE_TARGET, 0);
4744 if (!ecomdel) {
4745 vty_out(vty, "%% Malformed Route Target list\n");
4746 return CMD_WARNING;
4747 }
4748 ecommunity_str(ecomdel);
4749
4750 if (rt_type == RT_TYPE_IMPORT) {
4751 if (!bgp_evpn_rt_matches_existing(vpn->import_rtl, ecomdel)) {
4752 vty_out(vty,
4753 "%% RT specified does not match configuration for this VNI\n");
4754 return CMD_WARNING;
4755 }
4756 evpn_unconfigure_import_rt(bgp, vpn, ecomdel);
4757 } else if (rt_type == RT_TYPE_EXPORT) {
4758 if (!bgp_evpn_rt_matches_existing(vpn->export_rtl, ecomdel)) {
4759 vty_out(vty,
4760 "%% RT specified does not match configuration for this VNI\n");
4761 return CMD_WARNING;
4762 }
4763 evpn_unconfigure_export_rt(bgp, vpn, ecomdel);
4764 } else if (rt_type == RT_TYPE_BOTH) {
4765 found_ecomdel = 0;
4766
4767 if (bgp_evpn_rt_matches_existing(vpn->import_rtl, ecomdel)) {
4768 evpn_unconfigure_import_rt(bgp, vpn, ecomdel);
4769 found_ecomdel = 1;
4770 }
4771
4772 if (bgp_evpn_rt_matches_existing(vpn->export_rtl, ecomdel)) {
4773 evpn_unconfigure_export_rt(bgp, vpn, ecomdel);
4774 found_ecomdel = 1;
4775 }
4776
4777 if (!found_ecomdel) {
4778 vty_out(vty,
4779 "%% RT specified does not match configuration for this VNI\n");
4780 return CMD_WARNING;
4781 }
4782 }
4783
4784 return CMD_SUCCESS;
4785 }
4786
4787 DEFUN (no_bgp_evpn_vni_rt_without_val,
4788 no_bgp_evpn_vni_rt_without_val_cmd,
4789 "no route-target <import|export>",
4790 NO_STR
4791 "Route Target\n"
4792 "import\n"
4793 "export\n")
4794 {
4795 struct bgp *bgp = VTY_GET_CONTEXT(bgp);
4796 VTY_DECLVAR_CONTEXT_SUB(bgpevpn, vpn);
4797 int rt_type;
4798
4799 if (!bgp)
4800 return CMD_WARNING;
4801
4802 if (bgp->vrf_id != VRF_DEFAULT) {
4803 vty_out(vty,
4804 "This command is only supported under Default VRF\n");
4805 return CMD_WARNING;
4806 }
4807
4808 if (!strcmp(argv[2]->text, "import")) {
4809 rt_type = RT_TYPE_IMPORT;
4810 } else if (!strcmp(argv[2]->text, "export")) {
4811 rt_type = RT_TYPE_EXPORT;
4812 } else {
4813 vty_out(vty, "%% Invalid Route Target type\n");
4814 return CMD_WARNING;
4815 }
4816
4817 /* Check if we should disallow. */
4818 if (rt_type == RT_TYPE_IMPORT) {
4819 if (!is_import_rt_configured(vpn)) {
4820 vty_out(vty,
4821 "%% Import RT is not configured for this VNI\n");
4822 return CMD_WARNING;
4823 }
4824 } else {
4825 if (!is_export_rt_configured(vpn)) {
4826 vty_out(vty,
4827 "%% Export RT is not configured for this VNI\n");
4828 return CMD_WARNING;
4829 }
4830 }
4831
4832 /* Unconfigure the RT. */
4833 if (rt_type == RT_TYPE_IMPORT)
4834 evpn_unconfigure_import_rt(bgp, vpn, NULL);
4835 else
4836 evpn_unconfigure_export_rt(bgp, vpn, NULL);
4837 return CMD_SUCCESS;
4838 }
4839
4840 static int vni_cmp(const void **a, const void **b)
4841 {
4842 const struct bgpevpn *first = *a;
4843 const struct bgpevpn *secnd = *b;
4844
4845 return secnd->vni - first->vni;
4846 }
4847
4848 /*
4849 * Output EVPN configuration information.
4850 */
4851 void bgp_config_write_evpn_info(struct vty *vty, struct bgp *bgp, afi_t afi,
4852 safi_t safi)
4853 {
4854 char buf1[RD_ADDRSTRLEN];
4855
4856 if (bgp->vnihash) {
4857 struct list *vnilist = hash_to_list(bgp->vnihash);
4858 struct listnode *ln;
4859 struct bgpevpn *data;
4860
4861 list_sort(vnilist, vni_cmp);
4862 for (ALL_LIST_ELEMENTS_RO(vnilist, ln, data))
4863 write_vni_config(vty, data);
4864
4865 list_delete_and_null(&vnilist);
4866 }
4867
4868 if (bgp->advertise_all_vni)
4869 vty_out(vty, " advertise-all-vni\n");
4870
4871 if (bgp->advertise_autort_rfc8365)
4872 vty_out(vty, " autort rfc8365-compatible\n");
4873
4874 if (bgp->advertise_gw_macip)
4875 vty_out(vty, " advertise-default-gw\n");
4876
4877 if (CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
4878 BGP_L2VPN_EVPN_ADVERTISE_IPV4_UNICAST)) {
4879 if (bgp->adv_cmd_rmap[AFI_IP][SAFI_UNICAST].name)
4880 vty_out(vty, " advertise ipv4 unicast route-map %s\n",
4881 bgp->adv_cmd_rmap[AFI_IP][SAFI_UNICAST].name);
4882 else
4883 vty_out(vty, " advertise ipv4 unicast\n");
4884 }
4885
4886 if (CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
4887 BGP_L2VPN_EVPN_ADVERTISE_IPV6_UNICAST)) {
4888 if (bgp->adv_cmd_rmap[AFI_IP6][SAFI_UNICAST].name)
4889 vty_out(vty, " advertise ipv6 unicast route-map %s\n",
4890 bgp->adv_cmd_rmap[AFI_IP6][SAFI_UNICAST].name);
4891 else
4892 vty_out(vty, " advertise ipv6 unicast\n");
4893 }
4894
4895 if (CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
4896 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4))
4897 vty_out(vty, " default-originate ipv4\n");
4898
4899 if (CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
4900 BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6))
4901 vty_out(vty, " default-originate ipv6\n");
4902
4903 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_RD_CFGD))
4904 vty_out(vty, " rd %s\n",
4905 prefix_rd2str(&bgp->vrf_prd, buf1, sizeof(buf1)));
4906
4907 /* import route-target */
4908 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_IMPORT_RT_CFGD)) {
4909 char *ecom_str;
4910 struct listnode *node, *nnode;
4911 struct ecommunity *ecom;
4912
4913 for (ALL_LIST_ELEMENTS(bgp->vrf_import_rtl, node, nnode,
4914 ecom)) {
4915 ecom_str = ecommunity_ecom2str(
4916 ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
4917 vty_out(vty, " route-target import %s\n", ecom_str);
4918 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
4919 }
4920 }
4921
4922 /* export route-target */
4923 if (CHECK_FLAG(bgp->vrf_flags, BGP_VRF_EXPORT_RT_CFGD)) {
4924 char *ecom_str;
4925 struct listnode *node, *nnode;
4926 struct ecommunity *ecom;
4927
4928 for (ALL_LIST_ELEMENTS(bgp->vrf_export_rtl, node, nnode,
4929 ecom)) {
4930 ecom_str = ecommunity_ecom2str(
4931 ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
4932 vty_out(vty, " route-target export %s\n", ecom_str);
4933 XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
4934 }
4935 }
4936 }
4937
4938 void bgp_ethernetvpn_init(void)
4939 {
4940 install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_cmd);
4941 install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_rd_cmd);
4942 install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_all_tags_cmd);
4943 install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_rd_tags_cmd);
4944 install_element(VIEW_NODE,
4945 &show_ip_bgp_l2vpn_evpn_all_neighbor_routes_cmd);
4946 install_element(VIEW_NODE,
4947 &show_ip_bgp_l2vpn_evpn_rd_neighbor_routes_cmd);
4948 install_element(
4949 VIEW_NODE,
4950 &show_ip_bgp_l2vpn_evpn_all_neighbor_advertised_routes_cmd);
4951 install_element(
4952 VIEW_NODE,
4953 &show_ip_bgp_l2vpn_evpn_rd_neighbor_advertised_routes_cmd);
4954 install_element(VIEW_NODE, &show_ip_bgp_evpn_rd_overlay_cmd);
4955 install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_all_overlay_cmd);
4956 install_element(BGP_EVPN_NODE, &no_evpnrt5_network_cmd);
4957 install_element(BGP_EVPN_NODE, &evpnrt5_network_cmd);
4958 install_element(BGP_EVPN_NODE, &bgp_evpn_advertise_all_vni_cmd);
4959 install_element(BGP_EVPN_NODE, &no_bgp_evpn_advertise_all_vni_cmd);
4960 install_element(BGP_EVPN_NODE, &bgp_evpn_advertise_autort_rfc8365_cmd);
4961 install_element(BGP_EVPN_NODE, &no_bgp_evpn_advertise_autort_rfc8365_cmd);
4962 install_element(BGP_EVPN_NODE, &bgp_evpn_advertise_default_gw_cmd);
4963 install_element(BGP_EVPN_NODE, &no_bgp_evpn_advertise_default_gw_cmd);
4964 install_element(BGP_EVPN_NODE, &bgp_evpn_advertise_type5_cmd);
4965 install_element(BGP_EVPN_NODE, &no_bgp_evpn_advertise_type5_cmd);
4966 install_element(BGP_EVPN_NODE, &bgp_evpn_default_originate_cmd);
4967 install_element(BGP_EVPN_NODE, &no_bgp_evpn_default_originate_cmd);
4968
4969 /* test commands */
4970 install_element(BGP_EVPN_NODE, &test_adv_evpn_type4_route_cmd);
4971 install_element(BGP_EVPN_NODE, &test_withdraw_evpn_type4_route_cmd);
4972
4973 /* "show bgp l2vpn evpn" commands. */
4974 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_es_cmd);
4975 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_vni_cmd);
4976 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_summary_cmd);
4977 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_cmd);
4978 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_rd_cmd);
4979 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_rd_macip_cmd);
4980 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_esi_cmd);
4981 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_vni_cmd);
4982 install_element(VIEW_NODE,
4983 &show_bgp_l2vpn_evpn_route_vni_multicast_cmd);
4984 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_vni_macip_cmd);
4985 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_route_vni_all_cmd);
4986 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_import_rt_cmd);
4987 install_element(VIEW_NODE, &show_bgp_l2vpn_evpn_vrf_import_rt_cmd);
4988
4989 /* "show bgp evpn" commands. */
4990 install_element(VIEW_NODE, &show_bgp_evpn_vni_cmd);
4991 install_element(VIEW_NODE, &show_bgp_evpn_summary_cmd);
4992 install_element(VIEW_NODE, &show_bgp_evpn_route_cmd);
4993 install_element(VIEW_NODE, &show_bgp_evpn_route_rd_cmd);
4994 install_element(VIEW_NODE, &show_bgp_evpn_route_rd_macip_cmd);
4995 install_element(VIEW_NODE, &show_bgp_evpn_route_vni_cmd);
4996 install_element(VIEW_NODE, &show_bgp_evpn_route_vni_multicast_cmd);
4997 install_element(VIEW_NODE, &show_bgp_evpn_route_vni_macip_cmd);
4998 install_element(VIEW_NODE, &show_bgp_evpn_route_vni_all_cmd);
4999 install_element(VIEW_NODE, &show_bgp_evpn_import_rt_cmd);
5000 install_element(VIEW_NODE, &show_bgp_vrf_l3vni_info_cmd);
5001
5002 install_element(BGP_EVPN_NODE, &bgp_evpn_vni_cmd);
5003 install_element(BGP_EVPN_NODE, &no_bgp_evpn_vni_cmd);
5004 install_element(BGP_EVPN_VNI_NODE, &exit_vni_cmd);
5005 install_element(BGP_EVPN_VNI_NODE, &bgp_evpn_vni_rd_cmd);
5006 install_element(BGP_EVPN_VNI_NODE, &no_bgp_evpn_vni_rd_cmd);
5007 install_element(BGP_EVPN_VNI_NODE, &no_bgp_evpn_vni_rd_without_val_cmd);
5008 install_element(BGP_EVPN_VNI_NODE, &bgp_evpn_vni_rt_cmd);
5009 install_element(BGP_EVPN_VNI_NODE, &no_bgp_evpn_vni_rt_cmd);
5010 install_element(BGP_EVPN_VNI_NODE, &no_bgp_evpn_vni_rt_without_val_cmd);
5011 install_element(BGP_EVPN_NODE, &bgp_evpn_vrf_rd_cmd);
5012 install_element(BGP_EVPN_NODE, &no_bgp_evpn_vrf_rd_cmd);
5013 install_element(BGP_NODE, &no_bgp_evpn_vrf_rd_without_val_cmd);
5014 install_element(BGP_EVPN_NODE, &bgp_evpn_vrf_rt_cmd);
5015 install_element(BGP_EVPN_NODE, &no_bgp_evpn_vrf_rt_cmd);
5016 install_element(BGP_EVPN_VNI_NODE,
5017 &bgp_evpn_advertise_default_gw_vni_cmd);
5018 install_element(BGP_EVPN_VNI_NODE,
5019 &no_bgp_evpn_advertise_default_gw_vni_cmd);
5020 install_element(BGP_EVPN_VNI_NODE, &bgp_evpn_advertise_vni_subnet_cmd);
5021 install_element(BGP_EVPN_VNI_NODE,
5022 &no_bgp_evpn_advertise_vni_subnet_cmd);
5023 }
FRRouting mirror