]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_vty.c
projects / mirror_frr.git / blob
? search:


83c12e2bdcfb183b01274565cfc9812c7c01fd30
[mirror_frr.git] / zebra / zebra_vty.c
1 /* Zebra VTY functions
2 * Copyright (C) 2002 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <zebra.h>
22
23 #include "memory.h"
24 #include "zebra_memory.h"
25 #include "if.h"
26 #include "prefix.h"
27 #include "command.h"
28 #include "table.h"
29 #include "rib.h"
30 #include "nexthop.h"
31 #include "vrf.h"
32 #include "linklist.h"
33 #include "mpls.h"
34 #include "routemap.h"
35 #include "srcdest_table.h"
36 #include "vxlan.h"
37
38 #include "zebra/zebra_router.h"
39 #include "zebra/zserv.h"
40 #include "zebra/zebra_vrf.h"
41 #include "zebra/zebra_mpls.h"
42 #include "zebra/zebra_rnh.h"
43 #include "zebra/redistribute.h"
44 #include "zebra/zebra_routemap.h"
45 #include "lib/json.h"
46 #include "zebra/zebra_vxlan.h"
47 #ifndef VTYSH_EXTRACT_PL
48 #include "zebra/zebra_vty_clippy.c"
49 #endif
50 #include "zebra/zserv.h"
51 #include "zebra/router-id.h"
52 #include "zebra/ipforward.h"
53 #include "zebra/zebra_vxlan_private.h"
54 #include "zebra/zebra_pbr.h"
55
56 extern int allow_delete;
57
58 static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
59 safi_t safi, bool use_fib, bool use_json,
60 route_tag_t tag,
61 const struct prefix *longer_prefix_p,
62 bool supernets_only, int type,
63 unsigned short ospf_instance_id);
64 static void vty_show_ip_route_detail(struct vty *vty, struct route_node *rn,
65 int mcast);
66 static void vty_show_ip_route_summary(struct vty *vty,
67 struct route_table *table);
68 static void vty_show_ip_route_summary_prefix(struct vty *vty,
69 struct route_table *table);
70
71 DEFUN (ip_multicast_mode,
72 ip_multicast_mode_cmd,
73 "ip multicast rpf-lookup-mode <urib-only|mrib-only|mrib-then-urib|lower-distance|longer-prefix>",
74 IP_STR
75 "Multicast options\n"
76 "RPF lookup behavior\n"
77 "Lookup in unicast RIB only\n"
78 "Lookup in multicast RIB only\n"
79 "Try multicast RIB first, fall back to unicast RIB\n"
80 "Lookup both, use entry with lower distance\n"
81 "Lookup both, use entry with longer prefix\n")
82 {
83 char *mode = argv[3]->text;
84
85 if (strmatch(mode, "urib-only"))
86 multicast_mode_ipv4_set(MCAST_URIB_ONLY);
87 else if (strmatch(mode, "mrib-only"))
88 multicast_mode_ipv4_set(MCAST_MRIB_ONLY);
89 else if (strmatch(mode, "mrib-then-urib"))
90 multicast_mode_ipv4_set(MCAST_MIX_MRIB_FIRST);
91 else if (strmatch(mode, "lower-distance"))
92 multicast_mode_ipv4_set(MCAST_MIX_DISTANCE);
93 else if (strmatch(mode, "longer-prefix"))
94 multicast_mode_ipv4_set(MCAST_MIX_PFXLEN);
95 else {
96 vty_out(vty, "Invalid mode specified\n");
97 return CMD_WARNING_CONFIG_FAILED;
98 }
99
100 return CMD_SUCCESS;
101 }
102
103 DEFUN (no_ip_multicast_mode,
104 no_ip_multicast_mode_cmd,
105 "no ip multicast rpf-lookup-mode [<urib-only|mrib-only|mrib-then-urib|lower-distance|longer-prefix>]",
106 NO_STR
107 IP_STR
108 "Multicast options\n"
109 "RPF lookup behavior\n"
110 "Lookup in unicast RIB only\n"
111 "Lookup in multicast RIB only\n"
112 "Try multicast RIB first, fall back to unicast RIB\n"
113 "Lookup both, use entry with lower distance\n"
114 "Lookup both, use entry with longer prefix\n")
115 {
116 multicast_mode_ipv4_set(MCAST_NO_CONFIG);
117 return CMD_SUCCESS;
118 }
119
120
121 DEFUN (show_ip_rpf,
122 show_ip_rpf_cmd,
123 "show ip rpf [json]",
124 SHOW_STR
125 IP_STR
126 "Display RPF information for multicast source\n"
127 JSON_STR)
128 {
129 bool uj = use_json(argc, argv);
130 return do_show_ip_route(vty, VRF_DEFAULT_NAME, AFI_IP, SAFI_MULTICAST,
131 false, uj, 0, NULL, false, 0, 0);
132 }
133
134 DEFUN (show_ip_rpf_addr,
135 show_ip_rpf_addr_cmd,
136 "show ip rpf A.B.C.D",
137 SHOW_STR
138 IP_STR
139 "Display RPF information for multicast source\n"
140 "IP multicast source address (e.g. 10.0.0.0)\n")
141 {
142 int idx_ipv4 = 3;
143 struct in_addr addr;
144 struct route_node *rn;
145 struct route_entry *re;
146 int ret;
147
148 ret = inet_aton(argv[idx_ipv4]->arg, &addr);
149 if (ret == 0) {
150 vty_out(vty, "%% Malformed address\n");
151 return CMD_WARNING;
152 }
153
154 re = rib_match_ipv4_multicast(VRF_DEFAULT, addr, &rn);
155
156 if (re)
157 vty_show_ip_route_detail(vty, rn, 1);
158 else
159 vty_out(vty, "%% No match for RPF lookup\n");
160
161 return CMD_SUCCESS;
162 }
163
164 /* New RIB. Detailed information for IPv4 route. */
165 static void vty_show_ip_route_detail(struct vty *vty, struct route_node *rn,
166 int mcast)
167 {
168 struct route_entry *re;
169 struct nexthop *nexthop;
170 char buf[SRCDEST2STR_BUFFER];
171 struct zebra_vrf *zvrf;
172
173 RNODE_FOREACH_RE (rn, re) {
174 const char *mcast_info = "";
175 if (mcast) {
176 rib_table_info_t *info = srcdest_rnode_table_info(rn);
177 mcast_info = (info->safi == SAFI_MULTICAST)
178 ? " using Multicast RIB"
179 : " using Unicast RIB";
180 }
181
182 vty_out(vty, "Routing entry for %s%s\n",
183 srcdest_rnode2str(rn, buf, sizeof(buf)), mcast_info);
184 vty_out(vty, " Known via \"%s", zebra_route_string(re->type));
185 if (re->instance)
186 vty_out(vty, "[%d]", re->instance);
187 vty_out(vty, "\"");
188 vty_out(vty, ", distance %u, metric %u", re->distance,
189 re->metric);
190 if (re->tag) {
191 vty_out(vty, ", tag %u", re->tag);
192 #if defined(SUPPORT_REALMS)
193 if (re->tag > 0 && re->tag <= 255)
194 vty_out(vty, "(realm)");
195 #endif
196 }
197 if (re->mtu)
198 vty_out(vty, ", mtu %u", re->mtu);
199 if (re->vrf_id != VRF_DEFAULT) {
200 zvrf = vrf_info_lookup(re->vrf_id);
201 vty_out(vty, ", vrf %s", zvrf_name(zvrf));
202 }
203 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
204 vty_out(vty, ", best");
205 vty_out(vty, "\n");
206
207 time_t uptime;
208 struct tm *tm;
209
210 uptime = time(NULL);
211 uptime -= re->uptime;
212 tm = gmtime(&uptime);
213
214 vty_out(vty, " Last update ");
215
216 if (uptime < ONE_DAY_SECOND)
217 vty_out(vty, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
218 tm->tm_sec);
219 else if (uptime < ONE_WEEK_SECOND)
220 vty_out(vty, "%dd%02dh%02dm", tm->tm_yday, tm->tm_hour,
221 tm->tm_min);
222 else
223 vty_out(vty, "%02dw%dd%02dh", tm->tm_yday / 7,
224 tm->tm_yday - ((tm->tm_yday / 7) * 7),
225 tm->tm_hour);
226 vty_out(vty, " ago\n");
227
228 for (ALL_NEXTHOPS(re->ng, nexthop)) {
229 char addrstr[32];
230
231 vty_out(vty, " %c%s",
232 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
233 ? CHECK_FLAG(nexthop->flags,
234 NEXTHOP_FLAG_DUPLICATE)
235 ? ' '
236 : '*'
237 : ' ',
238 nexthop->rparent ? " " : "");
239
240 switch (nexthop->type) {
241 case NEXTHOP_TYPE_IPV4:
242 case NEXTHOP_TYPE_IPV4_IFINDEX:
243 vty_out(vty, " %s",
244 inet_ntoa(nexthop->gate.ipv4));
245 if (nexthop->ifindex)
246 vty_out(vty, ", via %s",
247 ifindex2ifname(
248 nexthop->ifindex,
249 nexthop->vrf_id));
250 break;
251 case NEXTHOP_TYPE_IPV6:
252 case NEXTHOP_TYPE_IPV6_IFINDEX:
253 vty_out(vty, " %s",
254 inet_ntop(AF_INET6, &nexthop->gate.ipv6,
255 buf, sizeof buf));
256 if (nexthop->ifindex)
257 vty_out(vty, ", via %s",
258 ifindex2ifname(
259 nexthop->ifindex,
260 nexthop->vrf_id));
261 break;
262 case NEXTHOP_TYPE_IFINDEX:
263 vty_out(vty, " directly connected, %s",
264 ifindex2ifname(nexthop->ifindex,
265 nexthop->vrf_id));
266 break;
267 case NEXTHOP_TYPE_BLACKHOLE:
268 vty_out(vty, " unreachable");
269 switch (nexthop->bh_type) {
270 case BLACKHOLE_REJECT:
271 vty_out(vty, " (ICMP unreachable)");
272 break;
273 case BLACKHOLE_ADMINPROHIB:
274 vty_out(vty,
275 " (ICMP admin-prohibited)");
276 break;
277 case BLACKHOLE_NULL:
278 vty_out(vty, " (blackhole)");
279 break;
280 case BLACKHOLE_UNSPEC:
281 break;
282 }
283 break;
284 default:
285 break;
286 }
287
288 if ((re->vrf_id != nexthop->vrf_id)
289 && (nexthop->type != NEXTHOP_TYPE_BLACKHOLE)) {
290 struct vrf *vrf =
291 vrf_lookup_by_id(nexthop->vrf_id);
292
293 if (vrf)
294 vty_out(vty, "(vrf %s)", vrf->name);
295 else
296 vty_out(vty, "(vrf UNKNOWN)");
297 }
298
299 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE))
300 vty_out(vty, " (duplicate nexthop removed)");
301
302 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
303 vty_out(vty, " inactive");
304
305 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK))
306 vty_out(vty, " onlink");
307
308 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
309 vty_out(vty, " (recursive)");
310
311 switch (nexthop->type) {
312 case NEXTHOP_TYPE_IPV4:
313 case NEXTHOP_TYPE_IPV4_IFINDEX:
314 if (nexthop->src.ipv4.s_addr) {
315 if (inet_ntop(AF_INET,
316 &nexthop->src.ipv4,
317 addrstr, sizeof addrstr))
318 vty_out(vty, ", src %s",
319 addrstr);
320 }
321 break;
322 case NEXTHOP_TYPE_IPV6:
323 case NEXTHOP_TYPE_IPV6_IFINDEX:
324 if (!IPV6_ADDR_SAME(&nexthop->src.ipv6,
325 &in6addr_any)) {
326 if (inet_ntop(AF_INET6,
327 &nexthop->src.ipv6,
328 addrstr, sizeof addrstr))
329 vty_out(vty, ", src %s",
330 addrstr);
331 }
332 break;
333 default:
334 break;
335 }
336
337 if (re->nexthop_mtu)
338 vty_out(vty, ", mtu %u", re->nexthop_mtu);
339
340 /* Label information */
341 if (nexthop->nh_label
342 && nexthop->nh_label->num_labels) {
343 vty_out(vty, ", label %s",
344 mpls_label2str(
345 nexthop->nh_label->num_labels,
346 nexthop->nh_label->label, buf,
347 sizeof buf, 1));
348 }
349
350 vty_out(vty, "\n");
351 }
352 vty_out(vty, "\n");
353 }
354 }
355
356 static void vty_show_ip_route(struct vty *vty, struct route_node *rn,
357 struct route_entry *re, json_object *json)
358 {
359 struct nexthop *nexthop;
360 int len = 0;
361 char buf[SRCDEST2STR_BUFFER];
362 json_object *json_nexthops = NULL;
363 json_object *json_nexthop = NULL;
364 json_object *json_route = NULL;
365 json_object *json_labels = NULL;
366 time_t uptime;
367 struct tm *tm;
368
369 uptime = time(NULL);
370 uptime -= re->uptime;
371 tm = gmtime(&uptime);
372
373 if (json) {
374 json_route = json_object_new_object();
375 json_nexthops = json_object_new_array();
376
377 json_object_string_add(json_route, "prefix",
378 srcdest_rnode2str(rn, buf, sizeof buf));
379 json_object_string_add(json_route, "protocol",
380 zebra_route_string(re->type));
381
382 if (re->instance)
383 json_object_int_add(json_route, "instance",
384 re->instance);
385
386 if (re->vrf_id)
387 json_object_int_add(json_route, "vrfId", re->vrf_id);
388
389 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
390 json_object_boolean_true_add(json_route, "selected");
391
392 if (re->type != ZEBRA_ROUTE_CONNECT) {
393 json_object_int_add(json_route, "distance",
394 re->distance);
395 json_object_int_add(json_route, "metric", re->metric);
396 }
397
398 if (re->tag)
399 json_object_int_add(json_route, "tag", re->tag);
400
401 json_object_int_add(json_route, "internalStatus",
402 re->status);
403 json_object_int_add(json_route, "internalFlags",
404 re->flags);
405 if (uptime < ONE_DAY_SECOND)
406 sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
407 tm->tm_sec);
408 else if (uptime < ONE_WEEK_SECOND)
409 sprintf(buf, "%dd%02dh%02dm", tm->tm_yday, tm->tm_hour,
410 tm->tm_min);
411 else
412 sprintf(buf, "%02dw%dd%02dh", tm->tm_yday / 7,
413 tm->tm_yday - ((tm->tm_yday / 7) * 7),
414 tm->tm_hour);
415
416 json_object_string_add(json_route, "uptime", buf);
417
418 for (ALL_NEXTHOPS(re->ng, nexthop)) {
419 json_nexthop = json_object_new_object();
420
421 json_object_int_add(json_nexthop, "flags",
422 nexthop->flags);
423
424 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE))
425 json_object_boolean_true_add(json_nexthop,
426 "duplicate");
427
428 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))
429 json_object_boolean_true_add(json_nexthop,
430 "fib");
431
432 switch (nexthop->type) {
433 case NEXTHOP_TYPE_IPV4:
434 case NEXTHOP_TYPE_IPV4_IFINDEX:
435 json_object_string_add(
436 json_nexthop, "ip",
437 inet_ntoa(nexthop->gate.ipv4));
438 json_object_string_add(json_nexthop, "afi",
439 "ipv4");
440
441 if (nexthop->ifindex) {
442 json_object_int_add(json_nexthop,
443 "interfaceIndex",
444 nexthop->ifindex);
445 json_object_string_add(
446 json_nexthop, "interfaceName",
447 ifindex2ifname(
448 nexthop->ifindex,
449 nexthop->vrf_id));
450 }
451 break;
452 case NEXTHOP_TYPE_IPV6:
453 case NEXTHOP_TYPE_IPV6_IFINDEX:
454 json_object_string_add(
455 json_nexthop, "ip",
456 inet_ntop(AF_INET6, &nexthop->gate.ipv6,
457 buf, sizeof buf));
458 json_object_string_add(json_nexthop, "afi",
459 "ipv6");
460
461 if (nexthop->ifindex) {
462 json_object_int_add(json_nexthop,
463 "interfaceIndex",
464 nexthop->ifindex);
465 json_object_string_add(
466 json_nexthop, "interfaceName",
467 ifindex2ifname(
468 nexthop->ifindex,
469 nexthop->vrf_id));
470 }
471 break;
472
473 case NEXTHOP_TYPE_IFINDEX:
474 json_object_boolean_true_add(
475 json_nexthop, "directlyConnected");
476 json_object_int_add(json_nexthop,
477 "interfaceIndex",
478 nexthop->ifindex);
479 json_object_string_add(
480 json_nexthop, "interfaceName",
481 ifindex2ifname(nexthop->ifindex,
482 nexthop->vrf_id));
483 break;
484 case NEXTHOP_TYPE_BLACKHOLE:
485 json_object_boolean_true_add(json_nexthop,
486 "unreachable");
487 switch (nexthop->bh_type) {
488 case BLACKHOLE_REJECT:
489 json_object_boolean_true_add(
490 json_nexthop, "reject");
491 break;
492 case BLACKHOLE_ADMINPROHIB:
493 json_object_boolean_true_add(
494 json_nexthop,
495 "admin-prohibited");
496 break;
497 case BLACKHOLE_NULL:
498 json_object_boolean_true_add(
499 json_nexthop, "blackhole");
500 break;
501 case BLACKHOLE_UNSPEC:
502 break;
503 }
504 break;
505 default:
506 break;
507 }
508
509 if ((nexthop->vrf_id != re->vrf_id)
510 && (nexthop->type != NEXTHOP_TYPE_BLACKHOLE)) {
511 struct vrf *vrf =
512 vrf_lookup_by_id(nexthop->vrf_id);
513
514 json_object_string_add(json_nexthop, "vrf",
515 vrf->name);
516 }
517 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE))
518 json_object_boolean_true_add(json_nexthop,
519 "duplicate");
520
521 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
522 json_object_boolean_true_add(json_nexthop,
523 "active");
524
525 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK))
526 json_object_boolean_true_add(json_nexthop,
527 "onLink");
528
529 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
530 json_object_boolean_true_add(json_nexthop,
531 "recursive");
532
533 switch (nexthop->type) {
534 case NEXTHOP_TYPE_IPV4:
535 case NEXTHOP_TYPE_IPV4_IFINDEX:
536 if (nexthop->src.ipv4.s_addr) {
537 if (inet_ntop(AF_INET,
538 &nexthop->src.ipv4, buf,
539 sizeof buf))
540 json_object_string_add(
541 json_nexthop, "source",
542 buf);
543 }
544 break;
545 case NEXTHOP_TYPE_IPV6:
546 case NEXTHOP_TYPE_IPV6_IFINDEX:
547 if (!IPV6_ADDR_SAME(&nexthop->src.ipv6,
548 &in6addr_any)) {
549 if (inet_ntop(AF_INET6,
550 &nexthop->src.ipv6, buf,
551 sizeof buf))
552 json_object_string_add(
553 json_nexthop, "source",
554 buf);
555 }
556 break;
557 default:
558 break;
559 }
560
561 if (nexthop->nh_label
562 && nexthop->nh_label->num_labels) {
563 json_labels = json_object_new_array();
564
565 for (int label_index = 0;
566 label_index
567 < nexthop->nh_label->num_labels;
568 label_index++)
569 json_object_array_add(
570 json_labels,
571 json_object_new_int(
572 nexthop->nh_label->label
573 [label_index]));
574
575 json_object_object_add(json_nexthop, "labels",
576 json_labels);
577 }
578
579 json_object_array_add(json_nexthops, json_nexthop);
580 }
581
582 json_object_object_add(json_route, "nexthops", json_nexthops);
583 json_object_array_add(json, json_route);
584 return;
585 }
586
587 /* Nexthop information. */
588 for (ALL_NEXTHOPS(re->ng, nexthop)) {
589 if (nexthop == re->ng.nexthop) {
590 /* Prefix information. */
591 len = vty_out(vty, "%c", zebra_route_char(re->type));
592 if (re->instance)
593 len += vty_out(vty, "[%d]", re->instance);
594 len += vty_out(
595 vty, "%c%c %s",
596 CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)
597 ? '>'
598 : ' ',
599 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
600 ? '*'
601 : ' ',
602 srcdest_rnode2str(rn, buf, sizeof buf));
603
604 /* Distance and metric display. */
605 if (re->type != ZEBRA_ROUTE_CONNECT)
606 len += vty_out(vty, " [%u/%u]", re->distance,
607 re->metric);
608 } else {
609 vty_out(vty, " %c%*c",
610 CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
611 ? CHECK_FLAG(nexthop->flags,
612 NEXTHOP_FLAG_DUPLICATE)
613 ? ' '
614 : '*'
615 : ' ',
616 len - 3 + (2 * nexthop_level(nexthop)), ' ');
617 }
618
619 switch (nexthop->type) {
620 case NEXTHOP_TYPE_IPV4:
621 case NEXTHOP_TYPE_IPV4_IFINDEX:
622 vty_out(vty, " via %s", inet_ntoa(nexthop->gate.ipv4));
623 if (nexthop->ifindex)
624 vty_out(vty, ", %s",
625 ifindex2ifname(nexthop->ifindex,
626 nexthop->vrf_id));
627 break;
628 case NEXTHOP_TYPE_IPV6:
629 case NEXTHOP_TYPE_IPV6_IFINDEX:
630 vty_out(vty, " via %s",
631 inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
632 sizeof buf));
633 if (nexthop->ifindex)
634 vty_out(vty, ", %s",
635 ifindex2ifname(nexthop->ifindex,
636 nexthop->vrf_id));
637 break;
638
639 case NEXTHOP_TYPE_IFINDEX:
640 vty_out(vty, " is directly connected, %s",
641 ifindex2ifname(nexthop->ifindex,
642 nexthop->vrf_id));
643 break;
644 case NEXTHOP_TYPE_BLACKHOLE:
645 vty_out(vty, " unreachable");
646 switch (nexthop->bh_type) {
647 case BLACKHOLE_REJECT:
648 vty_out(vty, " (ICMP unreachable)");
649 break;
650 case BLACKHOLE_ADMINPROHIB:
651 vty_out(vty, " (ICMP admin-prohibited)");
652 break;
653 case BLACKHOLE_NULL:
654 vty_out(vty, " (blackhole)");
655 break;
656 case BLACKHOLE_UNSPEC:
657 break;
658 }
659 break;
660 default:
661 break;
662 }
663
664 if ((nexthop->vrf_id != re->vrf_id)
665 && (nexthop->type != NEXTHOP_TYPE_BLACKHOLE)) {
666 struct vrf *vrf = vrf_lookup_by_id(nexthop->vrf_id);
667
668 if (vrf)
669 vty_out(vty, "(vrf %s)", vrf->name);
670 else
671 vty_out(vty, "(vrf UNKNOWN)");
672 }
673
674 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
675 vty_out(vty, " inactive");
676
677 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK))
678 vty_out(vty, " onlink");
679
680 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
681 vty_out(vty, " (recursive)");
682
683 switch (nexthop->type) {
684 case NEXTHOP_TYPE_IPV4:
685 case NEXTHOP_TYPE_IPV4_IFINDEX:
686 if (nexthop->src.ipv4.s_addr) {
687 if (inet_ntop(AF_INET, &nexthop->src.ipv4, buf,
688 sizeof buf))
689 vty_out(vty, ", src %s", buf);
690 }
691 break;
692 case NEXTHOP_TYPE_IPV6:
693 case NEXTHOP_TYPE_IPV6_IFINDEX:
694 if (!IPV6_ADDR_SAME(&nexthop->src.ipv6, &in6addr_any)) {
695 if (inet_ntop(AF_INET6, &nexthop->src.ipv6, buf,
696 sizeof buf))
697 vty_out(vty, ", src %s", buf);
698 }
699 break;
700 default:
701 break;
702 }
703
704 /* Label information */
705 if (nexthop->nh_label && nexthop->nh_label->num_labels) {
706 vty_out(vty, ", label %s",
707 mpls_label2str(nexthop->nh_label->num_labels,
708 nexthop->nh_label->label, buf,
709 sizeof buf, 1));
710 }
711
712 if (uptime < ONE_DAY_SECOND)
713 vty_out(vty, ", %02d:%02d:%02d", tm->tm_hour,
714 tm->tm_min, tm->tm_sec);
715 else if (uptime < ONE_WEEK_SECOND)
716 vty_out(vty, ", %dd%02dh%02dm", tm->tm_yday,
717 tm->tm_hour, tm->tm_min);
718 else
719 vty_out(vty, ", %02dw%dd%02dh", tm->tm_yday / 7,
720 tm->tm_yday - ((tm->tm_yday / 7) * 7),
721 tm->tm_hour);
722 vty_out(vty, "\n");
723 }
724 }
725
726 static void vty_show_ip_route_detail_json(struct vty *vty,
727 struct route_node *rn)
728 {
729 json_object *json = NULL;
730 json_object *json_prefix = NULL;
731 struct route_entry *re;
732 char buf[BUFSIZ];
733
734 json = json_object_new_object();
735 json_prefix = json_object_new_array();
736
737 RNODE_FOREACH_RE (rn, re) {
738 vty_show_ip_route(vty, rn, re, json_prefix);
739 }
740
741 prefix2str(&rn->p, buf, sizeof(buf));
742 json_object_object_add(json, buf, json_prefix);
743 vty_out(vty, "%s\n", json_object_to_json_string_ext(
744 json, JSON_C_TO_STRING_PRETTY));
745 json_object_free(json);
746 }
747
748 static void do_show_route_helper(struct vty *vty, struct zebra_vrf *zvrf,
749 struct route_table *table, afi_t afi,
750 bool use_fib, route_tag_t tag,
751 const struct prefix *longer_prefix_p,
752 bool supernets_only, int type,
753 unsigned short ospf_instance_id, bool use_json)
754 {
755 struct route_node *rn;
756 struct route_entry *re;
757 int first = 1;
758 rib_dest_t *dest;
759 json_object *json = NULL;
760 json_object *json_prefix = NULL;
761 uint32_t addr;
762 char buf[BUFSIZ];
763
764 if (use_json)
765 json = json_object_new_object();
766
767 /* Show all routes. */
768 for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
769 dest = rib_dest_from_rnode(rn);
770
771 RNODE_FOREACH_RE (rn, re) {
772 if (use_fib && re != dest->selected_fib)
773 continue;
774
775 if (tag && re->tag != tag)
776 continue;
777
778 if (longer_prefix_p
779 && !prefix_match(longer_prefix_p, &rn->p))
780 continue;
781
782 /* This can only be true when the afi is IPv4 */
783 if (supernets_only) {
784 addr = ntohl(rn->p.u.prefix4.s_addr);
785
786 if (IN_CLASSC(addr) && rn->p.prefixlen >= 24)
787 continue;
788
789 if (IN_CLASSB(addr) && rn->p.prefixlen >= 16)
790 continue;
791
792 if (IN_CLASSA(addr) && rn->p.prefixlen >= 8)
793 continue;
794 }
795
796 if (type && re->type != type)
797 continue;
798
799 if (ospf_instance_id
800 && (re->type != ZEBRA_ROUTE_OSPF
801 || re->instance != ospf_instance_id))
802 continue;
803
804 if (use_json) {
805 if (!json_prefix)
806 json_prefix = json_object_new_array();
807 } else {
808 if (first) {
809 if (afi == AFI_IP)
810 vty_out(vty,
811 SHOW_ROUTE_V4_HEADER);
812 else
813 vty_out(vty,
814 SHOW_ROUTE_V6_HEADER);
815
816 if (zvrf_id(zvrf) != VRF_DEFAULT)
817 vty_out(vty, "\nVRF %s:\n",
818 zvrf_name(zvrf));
819
820 first = 0;
821 }
822 }
823
824 vty_show_ip_route(vty, rn, re, json_prefix);
825 }
826
827 if (json_prefix) {
828 prefix2str(&rn->p, buf, sizeof(buf));
829 json_object_object_add(json, buf, json_prefix);
830 json_prefix = NULL;
831 }
832 }
833
834 if (use_json) {
835 vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
836 JSON_C_TO_STRING_PRETTY));
837 json_object_free(json);
838 }
839 }
840
841 static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
842 safi_t safi, bool use_fib, bool use_json,
843 route_tag_t tag,
844 const struct prefix *longer_prefix_p,
845 bool supernets_only, int type,
846 unsigned short ospf_instance_id)
847 {
848 struct route_table *table;
849 struct zebra_vrf *zvrf = NULL;
850
851 if (!(zvrf = zebra_vrf_lookup_by_name(vrf_name))) {
852 if (use_json)
853 vty_out(vty, "{}\n");
854 else
855 vty_out(vty, "vrf %s not defined\n", vrf_name);
856 return CMD_SUCCESS;
857 }
858
859 if (zvrf_id(zvrf) == VRF_UNKNOWN) {
860 if (use_json)
861 vty_out(vty, "{}\n");
862 else
863 vty_out(vty, "vrf %s inactive\n", vrf_name);
864 return CMD_SUCCESS;
865 }
866
867 table = zebra_vrf_table(afi, safi, zvrf_id(zvrf));
868 if (!table) {
869 if (use_json)
870 vty_out(vty, "{}\n");
871 return CMD_SUCCESS;
872 }
873
874 do_show_route_helper(vty, zvrf, table, afi, use_fib, tag,
875 longer_prefix_p, supernets_only, type,
876 ospf_instance_id, use_json);
877
878 return CMD_SUCCESS;
879 }
880
881 DEFPY (show_route_table,
882 show_route_table_cmd,
883 "show <ip$ipv4|ipv6$ipv6> route table (1-4294967295)$table [json$json]",
884 SHOW_STR
885 IP_STR
886 IP6_STR
887 "IP routing table\n"
888 "Table to display\n"
889 "The table number to display, if available\n"
890 JSON_STR)
891 {
892 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
893 struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
894 struct route_table *t;
895
896 t = zebra_router_find_table(zvrf, table, afi, SAFI_UNICAST);
897 if (t)
898 do_show_route_helper(vty, zvrf, t, afi, false, 0, false, false,
899 0, 0, !!json);
900
901 return CMD_SUCCESS;
902 }
903
904 DEFPY (show_route_table_vrf,
905 show_route_table_vrf_cmd,
906 "show <ip$ipv4|ipv6$ipv6> route table (1-4294967295)$table vrf NAME$vrf_name [json$json]",
907 SHOW_STR
908 IP_STR
909 IP6_STR
910 "IP routing table\n"
911 "Table to display\n"
912 "The table number to display, if available\n"
913 VRF_CMD_HELP_STR
914 JSON_STR)
915 {
916 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
917 struct zebra_vrf *zvrf;
918 struct route_table *t;
919 vrf_id_t vrf_id = VRF_DEFAULT;
920
921 if (vrf_name)
922 VRF_GET_ID(vrf_id, vrf_name, !!json);
923 zvrf = zebra_vrf_lookup_by_id(vrf_id);
924
925 t = zebra_router_find_table(zvrf, table, afi, SAFI_UNICAST);
926 if (t)
927 do_show_route_helper(vty, zvrf, t, afi, false, 0, false, false,
928 0, 0, !!json);
929
930 return CMD_SUCCESS;
931 }
932
933 DEFUN (show_ip_nht,
934 show_ip_nht_cmd,
935 "show ip nht [vrf NAME]",
936 SHOW_STR
937 IP_STR
938 "IP nexthop tracking table\n"
939 VRF_CMD_HELP_STR)
940 {
941 int idx_vrf = 4;
942 vrf_id_t vrf_id = VRF_DEFAULT;
943
944 if (argc == 5)
945 VRF_GET_ID(vrf_id, argv[idx_vrf]->arg, false);
946
947 zebra_print_rnh_table(vrf_id, AFI_IP, vty, RNH_NEXTHOP_TYPE);
948 return CMD_SUCCESS;
949 }
950
951 DEFPY (show_ip_import_check,
952 show_ip_import_check_cmd,
953 "show <ip$ipv4|ipv6$ipv6> import-check [vrf NAME$vrf_name|vrf all$vrf_all]",
954 SHOW_STR
955 IP_STR
956 IP6_STR
957 "IP import check tracking table\n"
958 VRF_CMD_HELP_STR
959 VRF_ALL_CMD_HELP_STR)
960 {
961 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
962 vrf_id_t vrf_id = VRF_DEFAULT;
963
964 if (vrf_all) {
965 struct vrf *vrf;
966 struct zebra_vrf *zvrf;
967
968 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
969 if ((zvrf = vrf->info) != NULL) {
970 vty_out(vty, "\nVRF %s:\n",
971 zvrf_name(zvrf));
972 zebra_print_rnh_table(zvrf_id(zvrf), afi, vty,
973 RNH_IMPORT_CHECK_TYPE);
974 }
975 return CMD_SUCCESS;
976 }
977 if (vrf_name)
978 VRF_GET_ID(vrf_id, vrf_name, false);
979
980 zebra_print_rnh_table(vrf_id, afi, vty, RNH_IMPORT_CHECK_TYPE);
981 return CMD_SUCCESS;
982 }
983
984 DEFUN (show_ip_nht_vrf_all,
985 show_ip_nht_vrf_all_cmd,
986 "show ip nht vrf all",
987 SHOW_STR
988 IP_STR
989 "IP nexthop tracking table\n"
990 VRF_ALL_CMD_HELP_STR)
991 {
992 struct vrf *vrf;
993 struct zebra_vrf *zvrf;
994
995 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
996 if ((zvrf = vrf->info) != NULL) {
997 vty_out(vty, "\nVRF %s:\n", zvrf_name(zvrf));
998 zebra_print_rnh_table(zvrf_id(zvrf), AFI_IP, vty,
999 RNH_NEXTHOP_TYPE);
1000 }
1001
1002 return CMD_SUCCESS;
1003 }
1004
1005 DEFUN (show_ipv6_nht,
1006 show_ipv6_nht_cmd,
1007 "show ipv6 nht [vrf NAME]",
1008 SHOW_STR
1009 IPV6_STR
1010 "IPv6 nexthop tracking table\n"
1011 VRF_CMD_HELP_STR)
1012 {
1013 int idx_vrf = 4;
1014 vrf_id_t vrf_id = VRF_DEFAULT;
1015
1016 if (argc == 5)
1017 VRF_GET_ID(vrf_id, argv[idx_vrf]->arg, false);
1018
1019 zebra_print_rnh_table(vrf_id, AFI_IP6, vty, RNH_NEXTHOP_TYPE);
1020 return CMD_SUCCESS;
1021 }
1022
1023
1024 DEFUN (show_ipv6_nht_vrf_all,
1025 show_ipv6_nht_vrf_all_cmd,
1026 "show ipv6 nht vrf all",
1027 SHOW_STR
1028 IP_STR
1029 "IPv6 nexthop tracking table\n"
1030 VRF_ALL_CMD_HELP_STR)
1031 {
1032 struct vrf *vrf;
1033 struct zebra_vrf *zvrf;
1034
1035 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
1036 if ((zvrf = vrf->info) != NULL) {
1037 vty_out(vty, "\nVRF %s:\n", zvrf_name(zvrf));
1038 zebra_print_rnh_table(zvrf_id(zvrf), AFI_IP6, vty,
1039 RNH_NEXTHOP_TYPE);
1040 }
1041
1042 return CMD_SUCCESS;
1043 }
1044
1045 DEFUN (ip_nht_default_route,
1046 ip_nht_default_route_cmd,
1047 "ip nht resolve-via-default",
1048 IP_STR
1049 "Filter Next Hop tracking route resolution\n"
1050 "Resolve via default route\n")
1051 {
1052 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1053
1054 if (!zvrf)
1055 return CMD_WARNING;
1056
1057 if (zebra_rnh_ip_default_route)
1058 return CMD_SUCCESS;
1059
1060 zebra_rnh_ip_default_route = 1;
1061
1062 zebra_evaluate_rnh(zvrf, AFI_IP, 1, RNH_NEXTHOP_TYPE, NULL);
1063 return CMD_SUCCESS;
1064 }
1065
1066 DEFUN (no_ip_nht_default_route,
1067 no_ip_nht_default_route_cmd,
1068 "no ip nht resolve-via-default",
1069 NO_STR
1070 IP_STR
1071 "Filter Next Hop tracking route resolution\n"
1072 "Resolve via default route\n")
1073 {
1074 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1075
1076 if (!zvrf)
1077 return CMD_WARNING;
1078
1079 if (!zebra_rnh_ip_default_route)
1080 return CMD_SUCCESS;
1081
1082 zebra_rnh_ip_default_route = 0;
1083 zebra_evaluate_rnh(zvrf, AFI_IP, 1, RNH_NEXTHOP_TYPE, NULL);
1084 return CMD_SUCCESS;
1085 }
1086
1087 DEFUN (ipv6_nht_default_route,
1088 ipv6_nht_default_route_cmd,
1089 "ipv6 nht resolve-via-default",
1090 IP6_STR
1091 "Filter Next Hop tracking route resolution\n"
1092 "Resolve via default route\n")
1093 {
1094 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1095
1096 if (!zvrf)
1097 return CMD_WARNING;
1098
1099 if (zebra_rnh_ipv6_default_route)
1100 return CMD_SUCCESS;
1101
1102 zebra_rnh_ipv6_default_route = 1;
1103 zebra_evaluate_rnh(zvrf, AFI_IP6, 1, RNH_NEXTHOP_TYPE, NULL);
1104 return CMD_SUCCESS;
1105 }
1106
1107 DEFUN (no_ipv6_nht_default_route,
1108 no_ipv6_nht_default_route_cmd,
1109 "no ipv6 nht resolve-via-default",
1110 NO_STR
1111 IP6_STR
1112 "Filter Next Hop tracking route resolution\n"
1113 "Resolve via default route\n")
1114 {
1115
1116 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1117
1118 if (!zvrf)
1119 return CMD_WARNING;
1120
1121 if (!zebra_rnh_ipv6_default_route)
1122 return CMD_SUCCESS;
1123
1124 zebra_rnh_ipv6_default_route = 0;
1125 zebra_evaluate_rnh(zvrf, AFI_IP6, 1, RNH_NEXTHOP_TYPE, NULL);
1126 return CMD_SUCCESS;
1127 }
1128
1129 DEFPY (show_route,
1130 show_route_cmd,
1131 "show\
1132 <\
1133 ip$ipv4 <fib$fib|route> [vrf <NAME$vrf_name|all$vrf_all>]\
1134 [{\
1135 tag (1-4294967295)\
1136 |A.B.C.D/M$prefix longer-prefixes\
1137 |supernets-only$supernets_only\
1138 }]\
1139 [<\
1140 " FRR_IP_REDIST_STR_ZEBRA "$type_str\
1141 |ospf$type_str (1-65535)$ospf_instance_id\
1142 >]\
1143 |ipv6$ipv6 <fib$fib|route> [vrf <NAME$vrf_name|all$vrf_all>]\
1144 [{\
1145 tag (1-4294967295)\
1146 |X:X::X:X/M$prefix longer-prefixes\
1147 }]\
1148 [" FRR_IP6_REDIST_STR_ZEBRA "$type_str]\
1149 >\
1150 [json$json]",
1151 SHOW_STR
1152 IP_STR
1153 "IP forwarding table\n"
1154 "IP routing table\n"
1155 VRF_FULL_CMD_HELP_STR
1156 "Show only routes with tag\n"
1157 "Tag value\n"
1158 "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
1159 "Show route matching the specified Network/Mask pair only\n"
1160 "Show supernet entries only\n"
1161 FRR_IP_REDIST_HELP_STR_ZEBRA
1162 "Open Shortest Path First (OSPFv2)\n"
1163 "Instance ID\n"
1164 IPV6_STR
1165 "IP forwarding table\n"
1166 "IP routing table\n"
1167 VRF_FULL_CMD_HELP_STR
1168 "Show only routes with tag\n"
1169 "Tag value\n"
1170 "IPv6 prefix\n"
1171 "Show route matching the specified Network/Mask pair only\n"
1172 FRR_IP6_REDIST_HELP_STR_ZEBRA
1173 JSON_STR)
1174 {
1175 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
1176 struct vrf *vrf;
1177 int type = 0;
1178
1179 if (type_str) {
1180 type = proto_redistnum(afi, type_str);
1181 if (type < 0) {
1182 vty_out(vty, "Unknown route type\n");
1183 return CMD_WARNING;
1184 }
1185 }
1186
1187 if (vrf_all) {
1188 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1189 struct zebra_vrf *zvrf;
1190 struct route_table *table;
1191
1192 if ((zvrf = vrf->info) == NULL
1193 || (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
1194 continue;
1195
1196 do_show_ip_route(
1197 vty, zvrf_name(zvrf), afi, SAFI_UNICAST, !!fib,
1198 !!json, tag, prefix_str ? prefix : NULL,
1199 !!supernets_only, type, ospf_instance_id);
1200 }
1201 } else {
1202 vrf_id_t vrf_id = VRF_DEFAULT;
1203
1204 if (vrf_name)
1205 VRF_GET_ID(vrf_id, vrf_name, !!json);
1206 vrf = vrf_lookup_by_id(vrf_id);
1207 do_show_ip_route(vty, vrf->name, afi, SAFI_UNICAST, !!fib,
1208 !!json, tag, prefix_str ? prefix : NULL,
1209 !!supernets_only, type, ospf_instance_id);
1210 }
1211
1212 return CMD_SUCCESS;
1213 }
1214
1215 DEFPY (show_route_detail,
1216 show_route_detail_cmd,
1217 "show\
1218 <\
1219 ip$ipv4 route [vrf <NAME$vrf_name|all$vrf_all>]\
1220 <\
1221 A.B.C.D$address\
1222 |A.B.C.D/M$prefix\
1223 >\
1224 |ipv6$ipv6 route [vrf <NAME$vrf_name|all$vrf_all>]\
1225 <\
1226 X:X::X:X$address\
1227 |X:X::X:X/M$prefix\
1228 >\
1229 >\
1230 [json$json]",
1231 SHOW_STR
1232 IP_STR
1233 "IP routing table\n"
1234 VRF_FULL_CMD_HELP_STR
1235 "Network in the IP routing table to display\n"
1236 "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
1237 IP6_STR
1238 "IP routing table\n"
1239 VRF_FULL_CMD_HELP_STR
1240 "IPv6 Address\n"
1241 "IPv6 prefix\n"
1242 JSON_STR)
1243 {
1244 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
1245 struct route_table *table;
1246 struct prefix p;
1247 struct route_node *rn;
1248
1249 if (address_str)
1250 prefix_str = address_str;
1251 if (str2prefix(prefix_str, &p) < 0) {
1252 vty_out(vty, "%% Malformed address\n");
1253 return CMD_WARNING;
1254 }
1255
1256 if (vrf_all) {
1257 struct vrf *vrf;
1258 struct zebra_vrf *zvrf;
1259
1260 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1261 if ((zvrf = vrf->info) == NULL
1262 || (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
1263 continue;
1264
1265 rn = route_node_match(table, &p);
1266 if (!rn)
1267 continue;
1268 if (!address_str && rn->p.prefixlen != p.prefixlen) {
1269 route_unlock_node(rn);
1270 continue;
1271 }
1272
1273 if (json)
1274 vty_show_ip_route_detail_json(vty, rn);
1275 else
1276 vty_show_ip_route_detail(vty, rn, 0);
1277
1278 route_unlock_node(rn);
1279 }
1280 } else {
1281 vrf_id_t vrf_id = VRF_DEFAULT;
1282
1283 if (vrf_name)
1284 VRF_GET_ID(vrf_id, vrf_name, false);
1285
1286 table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
1287 if (!table)
1288 return CMD_SUCCESS;
1289
1290 rn = route_node_match(table, &p);
1291 if (!rn) {
1292 vty_out(vty, "%% Network not in table\n");
1293 return CMD_WARNING;
1294 }
1295 if (!address_str && rn->p.prefixlen != p.prefixlen) {
1296 vty_out(vty, "%% Network not in table\n");
1297 route_unlock_node(rn);
1298 return CMD_WARNING;
1299 }
1300
1301 if (json)
1302 vty_show_ip_route_detail_json(vty, rn);
1303 else
1304 vty_show_ip_route_detail(vty, rn, 0);
1305
1306 route_unlock_node(rn);
1307 }
1308
1309 return CMD_SUCCESS;
1310 }
1311
1312 DEFPY (show_route_summary,
1313 show_route_summary_cmd,
1314 "show\
1315 <\
1316 ip$ipv4 route [vrf <NAME$vrf_name|all$vrf_all>]\
1317 summary [prefix$prefix]\
1318 |ipv6$ipv6 route [vrf <NAME$vrf_name|all$vrf_all>]\
1319 summary [prefix$prefix]\
1320 >",
1321 SHOW_STR
1322 IP_STR
1323 "IP routing table\n"
1324 VRF_FULL_CMD_HELP_STR
1325 "Summary of all routes\n"
1326 "Prefix routes\n"
1327 IP6_STR
1328 "IP routing table\n"
1329 VRF_FULL_CMD_HELP_STR
1330 "Summary of all routes\n"
1331 "Prefix routes\n")
1332 {
1333 afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
1334 struct route_table *table;
1335
1336 if (vrf_all) {
1337 struct vrf *vrf;
1338 struct zebra_vrf *zvrf;
1339
1340 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1341 if ((zvrf = vrf->info) == NULL
1342 || (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
1343 continue;
1344
1345 if (prefix)
1346 vty_show_ip_route_summary_prefix(vty, table);
1347 else
1348 vty_show_ip_route_summary(vty, table);
1349 }
1350 } else {
1351 vrf_id_t vrf_id = VRF_DEFAULT;
1352
1353 if (vrf_name)
1354 VRF_GET_ID(vrf_id, vrf_name, false);
1355
1356 table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
1357 if (!table)
1358 return CMD_SUCCESS;
1359
1360 if (prefix)
1361 vty_show_ip_route_summary_prefix(vty, table);
1362 else
1363 vty_show_ip_route_summary(vty, table);
1364 }
1365
1366 return CMD_SUCCESS;
1367 }
1368
1369 static void vty_show_ip_route_summary(struct vty *vty,
1370 struct route_table *table)
1371 {
1372 struct route_node *rn;
1373 struct route_entry *re;
1374 #define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
1375 #define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
1376 uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
1377 uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
1378 uint32_t i;
1379 uint32_t is_ibgp;
1380
1381 memset(&rib_cnt, 0, sizeof(rib_cnt));
1382 memset(&fib_cnt, 0, sizeof(fib_cnt));
1383 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
1384 RNODE_FOREACH_RE (rn, re) {
1385 is_ibgp = (re->type == ZEBRA_ROUTE_BGP
1386 && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP));
1387
1388 rib_cnt[ZEBRA_ROUTE_TOTAL]++;
1389 if (is_ibgp)
1390 rib_cnt[ZEBRA_ROUTE_IBGP]++;
1391 else
1392 rib_cnt[re->type]++;
1393
1394 if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)) {
1395 fib_cnt[ZEBRA_ROUTE_TOTAL]++;
1396
1397 if (is_ibgp)
1398 fib_cnt[ZEBRA_ROUTE_IBGP]++;
1399 else
1400 fib_cnt[re->type]++;
1401 }
1402 }
1403
1404 vty_out(vty, "%-20s %-20s %s (vrf %s)\n", "Route Source", "Routes",
1405 "FIB", zvrf_name(((rib_table_info_t *)route_table_get_info(table))->zvrf));
1406
1407 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
1408 if ((rib_cnt[i] > 0) || (i == ZEBRA_ROUTE_BGP
1409 && rib_cnt[ZEBRA_ROUTE_IBGP] > 0)) {
1410 if (i == ZEBRA_ROUTE_BGP) {
1411 vty_out(vty, "%-20s %-20d %-20d \n", "ebgp",
1412 rib_cnt[ZEBRA_ROUTE_BGP],
1413 fib_cnt[ZEBRA_ROUTE_BGP]);
1414 vty_out(vty, "%-20s %-20d %-20d \n", "ibgp",
1415 rib_cnt[ZEBRA_ROUTE_IBGP],
1416 fib_cnt[ZEBRA_ROUTE_IBGP]);
1417 } else
1418 vty_out(vty, "%-20s %-20d %-20d \n",
1419 zebra_route_string(i), rib_cnt[i],
1420 fib_cnt[i]);
1421 }
1422 }
1423
1424 vty_out(vty, "------\n");
1425 vty_out(vty, "%-20s %-20d %-20d \n", "Totals",
1426 rib_cnt[ZEBRA_ROUTE_TOTAL], fib_cnt[ZEBRA_ROUTE_TOTAL]);
1427 vty_out(vty, "\n");
1428 }
1429
1430 /*
1431 * Implementation of the ip route summary prefix command.
1432 *
1433 * This command prints the primary prefixes that have been installed by various
1434 * protocols on the box.
1435 *
1436 */
1437 static void vty_show_ip_route_summary_prefix(struct vty *vty,
1438 struct route_table *table)
1439 {
1440 struct route_node *rn;
1441 struct route_entry *re;
1442 struct nexthop *nexthop;
1443 #define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
1444 #define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
1445 uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
1446 uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
1447 uint32_t i;
1448 int cnt;
1449
1450 memset(&rib_cnt, 0, sizeof(rib_cnt));
1451 memset(&fib_cnt, 0, sizeof(fib_cnt));
1452 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
1453 RNODE_FOREACH_RE (rn, re) {
1454
1455 /*
1456 * In case of ECMP, count only once.
1457 */
1458 cnt = 0;
1459 for (nexthop = re->ng.nexthop; (!cnt && nexthop);
1460 nexthop = nexthop->next) {
1461 cnt++;
1462 rib_cnt[ZEBRA_ROUTE_TOTAL]++;
1463 rib_cnt[re->type]++;
1464 if (CHECK_FLAG(nexthop->flags,
1465 NEXTHOP_FLAG_FIB)) {
1466 fib_cnt[ZEBRA_ROUTE_TOTAL]++;
1467 fib_cnt[re->type]++;
1468 }
1469 if (re->type == ZEBRA_ROUTE_BGP
1470 && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP)) {
1471 rib_cnt[ZEBRA_ROUTE_IBGP]++;
1472 if (CHECK_FLAG(nexthop->flags,
1473 NEXTHOP_FLAG_FIB))
1474 fib_cnt[ZEBRA_ROUTE_IBGP]++;
1475 }
1476 }
1477 }
1478
1479 vty_out(vty, "%-20s %-20s %s (vrf %s)\n", "Route Source",
1480 "Prefix Routes", "FIB",
1481 zvrf_name(((rib_table_info_t *)route_table_get_info(table))->zvrf));
1482
1483 for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
1484 if (rib_cnt[i] > 0) {
1485 if (i == ZEBRA_ROUTE_BGP) {
1486 vty_out(vty, "%-20s %-20d %-20d \n", "ebgp",
1487 rib_cnt[ZEBRA_ROUTE_BGP]
1488 - rib_cnt[ZEBRA_ROUTE_IBGP],
1489 fib_cnt[ZEBRA_ROUTE_BGP]
1490 - fib_cnt[ZEBRA_ROUTE_IBGP]);
1491 vty_out(vty, "%-20s %-20d %-20d \n", "ibgp",
1492 rib_cnt[ZEBRA_ROUTE_IBGP],
1493 fib_cnt[ZEBRA_ROUTE_IBGP]);
1494 } else
1495 vty_out(vty, "%-20s %-20d %-20d \n",
1496 zebra_route_string(i), rib_cnt[i],
1497 fib_cnt[i]);
1498 }
1499 }
1500
1501 vty_out(vty, "------\n");
1502 vty_out(vty, "%-20s %-20d %-20d \n", "Totals",
1503 rib_cnt[ZEBRA_ROUTE_TOTAL], fib_cnt[ZEBRA_ROUTE_TOTAL]);
1504 vty_out(vty, "\n");
1505 }
1506
1507 /*
1508 * Show IPv6 mroute command.Used to dump
1509 * the Multicast routing table.
1510 */
1511 DEFUN (show_ipv6_mroute,
1512 show_ipv6_mroute_cmd,
1513 "show ipv6 mroute [vrf NAME]",
1514 SHOW_STR
1515 IP_STR
1516 "IPv6 Multicast routing table\n"
1517 VRF_CMD_HELP_STR)
1518 {
1519 struct route_table *table;
1520 struct route_node *rn;
1521 struct route_entry *re;
1522 int first = 1;
1523 vrf_id_t vrf_id = VRF_DEFAULT;
1524
1525 if (argc == 5)
1526 VRF_GET_ID(vrf_id, argv[4]->arg, false);
1527
1528 table = zebra_vrf_table(AFI_IP6, SAFI_MULTICAST, vrf_id);
1529 if (!table)
1530 return CMD_SUCCESS;
1531
1532 /* Show all IPv6 route. */
1533 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
1534 RNODE_FOREACH_RE (rn, re) {
1535 if (first) {
1536 vty_out(vty, SHOW_ROUTE_V6_HEADER);
1537 first = 0;
1538 }
1539 vty_show_ip_route(vty, rn, re, NULL);
1540 }
1541 return CMD_SUCCESS;
1542 }
1543
1544 DEFUN (show_ipv6_mroute_vrf_all,
1545 show_ipv6_mroute_vrf_all_cmd,
1546 "show ipv6 mroute vrf all",
1547 SHOW_STR
1548 IP_STR
1549 "IPv6 Multicast routing table\n"
1550 VRF_ALL_CMD_HELP_STR)
1551 {
1552 struct route_table *table;
1553 struct route_node *rn;
1554 struct route_entry *re;
1555 struct vrf *vrf;
1556 struct zebra_vrf *zvrf;
1557 int first = 1;
1558
1559 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1560 if ((zvrf = vrf->info) == NULL
1561 || (table = zvrf->table[AFI_IP6][SAFI_MULTICAST]) == NULL)
1562 continue;
1563
1564 /* Show all IPv6 route. */
1565 for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
1566 RNODE_FOREACH_RE (rn, re) {
1567 if (first) {
1568 vty_out(vty, SHOW_ROUTE_V6_HEADER);
1569 first = 0;
1570 }
1571 vty_show_ip_route(vty, rn, re, NULL);
1572 }
1573 }
1574 return CMD_SUCCESS;
1575 }
1576
1577 DEFUN (allow_external_route_update,
1578 allow_external_route_update_cmd,
1579 "allow-external-route-update",
1580 "Allow FRR routes to be overwritten by external processes\n")
1581 {
1582 allow_delete = 1;
1583
1584 return CMD_SUCCESS;
1585 }
1586
1587 DEFUN (no_allow_external_route_update,
1588 no_allow_external_route_update_cmd,
1589 "no allow-external-route-update",
1590 NO_STR
1591 "Allow FRR routes to be overwritten by external processes\n")
1592 {
1593 allow_delete = 0;
1594
1595 return CMD_SUCCESS;
1596 }
1597
1598 /* show vrf */
1599 DEFUN (show_vrf,
1600 show_vrf_cmd,
1601 "show vrf",
1602 SHOW_STR
1603 "VRF\n")
1604 {
1605 struct vrf *vrf;
1606 struct zebra_vrf *zvrf;
1607
1608 if (vrf_is_backend_netns())
1609 vty_out(vty, "netns-based vrfs\n");
1610
1611 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1612 if (!(zvrf = vrf->info))
1613 continue;
1614 if (zvrf_id(zvrf) == VRF_DEFAULT)
1615 continue;
1616
1617 vty_out(vty, "vrf %s ", zvrf_name(zvrf));
1618 if (zvrf_id(zvrf) == VRF_UNKNOWN || !zvrf_is_active(zvrf))
1619 vty_out(vty, "inactive");
1620 else if (zvrf_ns_name(zvrf))
1621 vty_out(vty, "id %u netns %s", zvrf_id(zvrf),
1622 zvrf_ns_name(zvrf));
1623 else
1624 vty_out(vty, "id %u table %u", zvrf_id(zvrf),
1625 zvrf->table_id);
1626 if (vrf_is_user_cfged(vrf))
1627 vty_out(vty, " (configured)");
1628 vty_out(vty, "\n");
1629 }
1630
1631 return CMD_SUCCESS;
1632 }
1633
1634 DEFUN_HIDDEN (default_vrf_vni_mapping,
1635 default_vrf_vni_mapping_cmd,
1636 "vni " CMD_VNI_RANGE "[prefix-routes-only]",
1637 "VNI corresponding to the DEFAULT VRF\n"
1638 "VNI-ID\n"
1639 "Prefix routes only \n")
1640 {
1641 int ret = 0;
1642 char err[ERR_STR_SZ];
1643 struct zebra_vrf *zvrf = NULL;
1644 vni_t vni = strtoul(argv[1]->arg, NULL, 10);
1645 int filter = 0;
1646
1647 zvrf = vrf_info_lookup(VRF_DEFAULT);
1648 if (!zvrf)
1649 return CMD_WARNING;
1650
1651 if (argc == 3)
1652 filter = 1;
1653
1654 ret = zebra_vxlan_process_vrf_vni_cmd(zvrf, vni, err, ERR_STR_SZ,
1655 filter, 1);
1656 if (ret != 0) {
1657 vty_out(vty, "%s\n", err);
1658 return CMD_WARNING;
1659 }
1660
1661 return CMD_SUCCESS;
1662 }
1663
1664 DEFUN_HIDDEN (no_default_vrf_vni_mapping,
1665 no_default_vrf_vni_mapping_cmd,
1666 "no vni " CMD_VNI_RANGE,
1667 NO_STR
1668 "VNI corresponding to DEFAULT VRF\n"
1669 "VNI-ID")
1670 {
1671 int ret = 0;
1672 char err[ERR_STR_SZ];
1673 vni_t vni = strtoul(argv[2]->arg, NULL, 10);
1674 struct zebra_vrf *zvrf = NULL;
1675
1676 zvrf = vrf_info_lookup(VRF_DEFAULT);
1677 if (!zvrf)
1678 return CMD_WARNING;
1679
1680 ret = zebra_vxlan_process_vrf_vni_cmd(zvrf, vni, err, ERR_STR_SZ, 0, 0);
1681 if (ret != 0) {
1682 vty_out(vty, "%s\n", err);
1683 return CMD_WARNING;
1684 }
1685
1686 return CMD_SUCCESS;
1687 }
1688
1689 DEFUN (vrf_vni_mapping,
1690 vrf_vni_mapping_cmd,
1691 "vni " CMD_VNI_RANGE "[prefix-routes-only]",
1692 "VNI corresponding to tenant VRF\n"
1693 "VNI-ID\n"
1694 "prefix-routes-only\n")
1695 {
1696 int ret = 0;
1697 int filter = 0;
1698
1699 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1700 vni_t vni = strtoul(argv[1]->arg, NULL, 10);
1701 char err[ERR_STR_SZ];
1702
1703 assert(vrf);
1704 assert(zvrf);
1705
1706 if (argc == 3)
1707 filter = 1;
1708
1709 /* Mark as having FRR configuration */
1710 vrf_set_user_cfged(vrf);
1711 ret = zebra_vxlan_process_vrf_vni_cmd(zvrf, vni, err, ERR_STR_SZ,
1712 filter, 1);
1713 if (ret != 0) {
1714 vty_out(vty, "%s\n", err);
1715 return CMD_WARNING;
1716 }
1717
1718 return CMD_SUCCESS;
1719 }
1720
1721 DEFUN (no_vrf_vni_mapping,
1722 no_vrf_vni_mapping_cmd,
1723 "no vni " CMD_VNI_RANGE "[prefix-routes-only]",
1724 NO_STR
1725 "VNI corresponding to tenant VRF\n"
1726 "VNI-ID\n"
1727 "prefix-routes-only\n")
1728 {
1729 int ret = 0;
1730 int filter = 0;
1731 char err[ERR_STR_SZ];
1732 vni_t vni = strtoul(argv[2]->arg, NULL, 10);
1733
1734 ZEBRA_DECLVAR_CONTEXT(vrf, zvrf);
1735
1736 assert(vrf);
1737 assert(zvrf);
1738
1739 if (argc == 4)
1740 filter = 1;
1741
1742 ret = zebra_vxlan_process_vrf_vni_cmd(zvrf, vni, err,
1743 ERR_STR_SZ, filter, 0);
1744 if (ret != 0) {
1745 vty_out(vty, "%s\n", err);
1746 return CMD_WARNING;
1747 }
1748
1749 /* If no other FRR config for this VRF, mark accordingly. */
1750 if (!zebra_vrf_has_config(zvrf))
1751 vrf_reset_user_cfged(vrf);
1752
1753 return CMD_SUCCESS;
1754 }
1755
1756 /* show vrf */
1757 DEFUN (show_vrf_vni,
1758 show_vrf_vni_cmd,
1759 "show vrf vni [json]",
1760 SHOW_STR
1761 "VRF\n"
1762 "VNI\n"
1763 JSON_STR)
1764 {
1765 struct vrf *vrf;
1766 struct zebra_vrf *zvrf;
1767 json_object *json = NULL;
1768 json_object *json_vrfs = NULL;
1769 bool uj = use_json(argc, argv);
1770
1771 if (uj) {
1772 json = json_object_new_object();
1773 json_vrfs = json_object_new_array();
1774 }
1775
1776 if (!uj)
1777 vty_out(vty, "%-37s %-10s %-20s %-20s %-5s %-18s\n", "VRF",
1778 "VNI", "VxLAN IF", "L3-SVI", "State", "Rmac");
1779
1780 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
1781 zvrf = vrf->info;
1782 if (!zvrf)
1783 continue;
1784
1785 zebra_vxlan_print_vrf_vni(vty, zvrf, json_vrfs);
1786 }
1787
1788 if (uj) {
1789 json_object_object_add(json, "vrfs", json_vrfs);
1790 vty_out(vty, "%s\n", json_object_to_json_string_ext(
1791 json, JSON_C_TO_STRING_PRETTY));
1792 json_object_free(json);
1793 }
1794
1795 return CMD_SUCCESS;
1796 }
1797
1798 DEFUN (show_evpn_global,
1799 show_evpn_global_cmd,
1800 "show evpn [json]",
1801 SHOW_STR
1802 "EVPN\n"
1803 JSON_STR)
1804 {
1805 bool uj = use_json(argc, argv);
1806
1807 zebra_vxlan_print_evpn(vty, uj);
1808 return CMD_SUCCESS;
1809 }
1810
1811 DEFUN (show_evpn_vni,
1812 show_evpn_vni_cmd,
1813 "show evpn vni [json]",
1814 SHOW_STR
1815 "EVPN\n"
1816 "VxLAN Network Identifier\n"
1817 JSON_STR)
1818 {
1819 struct zebra_vrf *zvrf;
1820 bool uj = use_json(argc, argv);
1821
1822 zvrf = vrf_info_lookup(VRF_DEFAULT);
1823 zebra_vxlan_print_vnis(vty, zvrf, uj);
1824 return CMD_SUCCESS;
1825 }
1826
1827 DEFUN (show_evpn_vni_detail, show_evpn_vni_detail_cmd,
1828 "show evpn vni detail [json]",
1829 SHOW_STR
1830 "EVPN\n"
1831 "VxLAN Network Identifier\n"
1832 "Detailed Information On Each VNI\n"
1833 JSON_STR)
1834 {
1835 struct zebra_vrf *zvrf;
1836 bool uj = use_json(argc, argv);
1837
1838 zvrf = vrf_info_lookup(VRF_DEFAULT);
1839 zebra_vxlan_print_vnis_detail(vty, zvrf, uj);
1840 return CMD_SUCCESS;
1841 }
1842
1843 DEFUN (show_evpn_vni_vni,
1844 show_evpn_vni_vni_cmd,
1845 "show evpn vni " CMD_VNI_RANGE "[json]",
1846 SHOW_STR
1847 "EVPN\n"
1848 "VxLAN Network Identifier\n"
1849 "VNI number\n"
1850 JSON_STR)
1851 {
1852 struct zebra_vrf *zvrf;
1853 vni_t vni;
1854 bool uj = use_json(argc, argv);
1855
1856 vni = strtoul(argv[3]->arg, NULL, 10);
1857 zvrf = vrf_info_lookup(VRF_DEFAULT);
1858 zebra_vxlan_print_vni(vty, zvrf, vni, uj);
1859 return CMD_SUCCESS;
1860 }
1861
1862 DEFUN (show_evpn_rmac_vni_mac,
1863 show_evpn_rmac_vni_mac_cmd,
1864 "show evpn rmac vni " CMD_VNI_RANGE " mac WORD [json]",
1865 SHOW_STR
1866 "EVPN\n"
1867 "RMAC\n"
1868 "L3 VNI\n"
1869 "VNI number\n"
1870 "MAC\n"
1871 "mac-address (e.g. 0a:0a:0a:0a:0a:0a)\n"
1872 JSON_STR)
1873 {
1874 vni_t l3vni = 0;
1875 struct ethaddr mac;
1876 bool uj = use_json(argc, argv);
1877
1878 l3vni = strtoul(argv[4]->arg, NULL, 10);
1879 if (!prefix_str2mac(argv[6]->arg, &mac)) {
1880 vty_out(vty, "%% Malformed MAC address\n");
1881 return CMD_WARNING;
1882 }
1883 zebra_vxlan_print_specific_rmac_l3vni(vty, l3vni, &mac, uj);
1884 return CMD_SUCCESS;
1885 }
1886
1887 DEFUN (show_evpn_rmac_vni,
1888 show_evpn_rmac_vni_cmd,
1889 "show evpn rmac vni " CMD_VNI_RANGE "[json]",
1890 SHOW_STR
1891 "EVPN\n"
1892 "RMAC\n"
1893 "L3 VNI\n"
1894 "VNI number\n"
1895 JSON_STR)
1896 {
1897 vni_t l3vni = 0;
1898 bool uj = use_json(argc, argv);
1899
1900 l3vni = strtoul(argv[4]->arg, NULL, 10);
1901 zebra_vxlan_print_rmacs_l3vni(vty, l3vni, uj);
1902
1903 return CMD_SUCCESS;
1904 }
1905
1906 DEFUN (show_evpn_rmac_vni_all,
1907 show_evpn_rmac_vni_all_cmd,
1908 "show evpn rmac vni all [json]",
1909 SHOW_STR
1910 "EVPN\n"
1911 "RMAC addresses\n"
1912 "L3 VNI\n"
1913 "All VNIs\n"
1914 JSON_STR)
1915 {
1916 bool uj = use_json(argc, argv);
1917
1918 zebra_vxlan_print_rmacs_all_l3vni(vty, uj);
1919
1920 return CMD_SUCCESS;
1921 }
1922
1923 DEFUN (show_evpn_nh_vni_ip,
1924 show_evpn_nh_vni_ip_cmd,
1925 "show evpn next-hops vni " CMD_VNI_RANGE " ip WORD [json]",
1926 SHOW_STR
1927 "EVPN\n"
1928 "Remote Vteps\n"
1929 "L3 VNI\n"
1930 "VNI number\n"
1931 "Ip address\n"
1932 "Host address (ipv4 or ipv6)\n"
1933 JSON_STR)
1934 {
1935 vni_t l3vni;
1936 struct ipaddr ip;
1937 bool uj = use_json(argc, argv);
1938
1939 l3vni = strtoul(argv[4]->arg, NULL, 10);
1940 if (str2ipaddr(argv[6]->arg, &ip) != 0) {
1941 if (!uj)
1942 vty_out(vty, "%% Malformed Neighbor address\n");
1943 return CMD_WARNING;
1944 }
1945 zebra_vxlan_print_specific_nh_l3vni(vty, l3vni, &ip, uj);
1946
1947 return CMD_SUCCESS;
1948 }
1949
1950 DEFUN (show_evpn_nh_vni,
1951 show_evpn_nh_vni_cmd,
1952 "show evpn next-hops vni " CMD_VNI_RANGE "[json]",
1953 SHOW_STR
1954 "EVPN\n"
1955 "Remote Vteps\n"
1956 "L3 VNI\n"
1957 "VNI number\n"
1958 JSON_STR)
1959 {
1960 vni_t l3vni;
1961 bool uj = use_json(argc, argv);
1962
1963 l3vni = strtoul(argv[4]->arg, NULL, 10);
1964 zebra_vxlan_print_nh_l3vni(vty, l3vni, uj);
1965
1966 return CMD_SUCCESS;
1967 }
1968
1969 DEFUN (show_evpn_nh_vni_all,
1970 show_evpn_nh_vni_all_cmd,
1971 "show evpn next-hops vni all [json]",
1972 SHOW_STR
1973 "EVPN\n"
1974 "Remote VTEPs\n"
1975 "L3 VNI\n"
1976 "All VNIs\n"
1977 JSON_STR)
1978 {
1979 bool uj = use_json(argc, argv);
1980
1981 zebra_vxlan_print_nh_all_l3vni(vty, uj);
1982
1983 return CMD_SUCCESS;
1984 }
1985
1986 DEFUN (show_evpn_mac_vni,
1987 show_evpn_mac_vni_cmd,
1988 "show evpn mac vni " CMD_VNI_RANGE "[json]",
1989 SHOW_STR
1990 "EVPN\n"
1991 "MAC addresses\n"
1992 "VxLAN Network Identifier\n"
1993 "VNI number\n"
1994 JSON_STR)
1995 {
1996 struct zebra_vrf *zvrf;
1997 vni_t vni;
1998 bool uj = use_json(argc, argv);
1999
2000 vni = strtoul(argv[4]->arg, NULL, 10);
2001 zvrf = vrf_info_lookup(VRF_DEFAULT);
2002 zebra_vxlan_print_macs_vni(vty, zvrf, vni, uj);
2003 return CMD_SUCCESS;
2004 }
2005
2006 DEFUN (show_evpn_mac_vni_all,
2007 show_evpn_mac_vni_all_cmd,
2008 "show evpn mac vni all [json]",
2009 SHOW_STR
2010 "EVPN\n"
2011 "MAC addresses\n"
2012 "VxLAN Network Identifier\n"
2013 "All VNIs\n"
2014 JSON_STR)
2015 {
2016 struct zebra_vrf *zvrf;
2017 bool uj = use_json(argc, argv);
2018
2019 zvrf = vrf_info_lookup(VRF_DEFAULT);
2020 zebra_vxlan_print_macs_all_vni(vty, zvrf, false, uj);
2021 return CMD_SUCCESS;
2022 }
2023
2024 DEFUN (show_evpn_mac_vni_all_detail, show_evpn_mac_vni_all_detail_cmd,
2025 "show evpn mac vni all detail [json]",
2026 SHOW_STR
2027 "EVPN\n"
2028 "MAC addresses\n"
2029 "VxLAN Network Identifier\n"
2030 "All VNIs\n"
2031 "Detailed Information On Each VNI MAC\n"
2032 JSON_STR)
2033 {
2034 struct zebra_vrf *zvrf;
2035 bool uj = use_json(argc, argv);
2036
2037 zvrf = vrf_info_lookup(VRF_DEFAULT);
2038 zebra_vxlan_print_macs_all_vni_detail(vty, zvrf, false, uj);
2039 return CMD_SUCCESS;
2040 }
2041
2042 DEFUN (show_evpn_mac_vni_all_vtep,
2043 show_evpn_mac_vni_all_vtep_cmd,
2044 "show evpn mac vni all vtep A.B.C.D [json]",
2045 SHOW_STR
2046 "EVPN\n"
2047 "MAC addresses\n"
2048 "VxLAN Network Identifier\n"
2049 "All VNIs\n"
2050 "Remote VTEP\n"
2051 "Remote VTEP IP address\n"
2052 JSON_STR)
2053 {
2054 struct zebra_vrf *zvrf;
2055 struct in_addr vtep_ip;
2056 bool uj = use_json(argc, argv);
2057
2058 if (!inet_aton(argv[6]->arg, &vtep_ip)) {
2059 if (!uj)
2060 vty_out(vty, "%% Malformed VTEP IP address\n");
2061 return CMD_WARNING;
2062 }
2063 zvrf = vrf_info_lookup(VRF_DEFAULT);
2064 zebra_vxlan_print_macs_all_vni_vtep(vty, zvrf, vtep_ip, uj);
2065
2066 return CMD_SUCCESS;
2067 }
2068
2069
2070 DEFUN (show_evpn_mac_vni_mac,
2071 show_evpn_mac_vni_mac_cmd,
2072 "show evpn mac vni " CMD_VNI_RANGE " mac WORD [json]",
2073 SHOW_STR
2074 "EVPN\n"
2075 "MAC addresses\n"
2076 "VxLAN Network Identifier\n"
2077 "VNI number\n"
2078 "MAC\n"
2079 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
2080 JSON_STR)
2081
2082 {
2083 struct zebra_vrf *zvrf;
2084 vni_t vni;
2085 struct ethaddr mac;
2086 bool uj = use_json(argc, argv);
2087
2088 vni = strtoul(argv[4]->arg, NULL, 10);
2089 if (!prefix_str2mac(argv[6]->arg, &mac)) {
2090 vty_out(vty, "%% Malformed MAC address");
2091 return CMD_WARNING;
2092 }
2093 zvrf = vrf_info_lookup(VRF_DEFAULT);
2094 zebra_vxlan_print_specific_mac_vni(vty, zvrf, vni, &mac, uj);
2095 return CMD_SUCCESS;
2096 }
2097
2098 DEFUN (show_evpn_mac_vni_vtep,
2099 show_evpn_mac_vni_vtep_cmd,
2100 "show evpn mac vni " CMD_VNI_RANGE " vtep A.B.C.D" "[json]",
2101 SHOW_STR
2102 "EVPN\n"
2103 "MAC addresses\n"
2104 "VxLAN Network Identifier\n"
2105 "VNI number\n"
2106 "Remote VTEP\n"
2107 "Remote VTEP IP address\n"
2108 JSON_STR)
2109 {
2110 struct zebra_vrf *zvrf;
2111 vni_t vni;
2112 struct in_addr vtep_ip;
2113 bool uj = use_json(argc, argv);
2114
2115 vni = strtoul(argv[4]->arg, NULL, 10);
2116 if (!inet_aton(argv[6]->arg, &vtep_ip)) {
2117 if (!uj)
2118 vty_out(vty, "%% Malformed VTEP IP address\n");
2119 return CMD_WARNING;
2120 }
2121
2122 zvrf = vrf_info_lookup(VRF_DEFAULT);
2123 zebra_vxlan_print_macs_vni_vtep(vty, zvrf, vni, vtep_ip, uj);
2124 return CMD_SUCCESS;
2125 }
2126
2127 DEFPY (show_evpn_mac_vni_all_dad,
2128 show_evpn_mac_vni_all_dad_cmd,
2129 "show evpn mac vni all duplicate [json]",
2130 SHOW_STR
2131 "EVPN\n"
2132 "MAC addresses\n"
2133 "VxLAN Network Identifier\n"
2134 "All VNIs\n"
2135 "Duplicate address list\n"
2136 JSON_STR)
2137 {
2138 struct zebra_vrf *zvrf;
2139 bool uj = use_json(argc, argv);
2140
2141 zvrf = vrf_info_lookup(VRF_DEFAULT);
2142 zebra_vxlan_print_macs_all_vni(vty, zvrf, true, uj);
2143 return CMD_SUCCESS;
2144 }
2145
2146
2147 DEFPY (show_evpn_mac_vni_dad,
2148 show_evpn_mac_vni_dad_cmd,
2149 "show evpn mac vni " CMD_VNI_RANGE " duplicate" "[json]",
2150 SHOW_STR
2151 "EVPN\n"
2152 "MAC addresses\n"
2153 "VxLAN Network Identifier\n"
2154 "VNI number\n"
2155 "Duplicate address list\n"
2156 JSON_STR)
2157 {
2158 struct zebra_vrf *zvrf;
2159 vni_t vni;
2160 bool uj = use_json(argc, argv);
2161
2162 vni = strtoul(argv[4]->arg, NULL, 10);
2163 zvrf = vrf_info_lookup(VRF_DEFAULT);
2164
2165 zebra_vxlan_print_macs_vni_dad(vty, zvrf, vni, uj);
2166
2167 return CMD_SUCCESS;
2168 }
2169
2170 DEFPY (show_evpn_neigh_vni_dad,
2171 show_evpn_neigh_vni_dad_cmd,
2172 "show evpn arp-cache vni " CMD_VNI_RANGE "duplicate" "[json]",
2173 SHOW_STR
2174 "EVPN\n"
2175 "ARP and ND cache\n"
2176 "VxLAN Network Identifier\n"
2177 "VNI number\n"
2178 "Duplicate address list\n"
2179 JSON_STR)
2180 {
2181 struct zebra_vrf *zvrf;
2182 vni_t vni;
2183 bool uj = use_json(argc, argv);
2184
2185 vni = strtoul(argv[4]->arg, NULL, 10);
2186 zvrf = vrf_info_lookup(VRF_DEFAULT);
2187 zebra_vxlan_print_neigh_vni_dad(vty, zvrf, vni, uj);
2188 return CMD_SUCCESS;
2189 }
2190
2191 DEFPY (show_evpn_neigh_vni_all_dad,
2192 show_evpn_neigh_vni_all_dad_cmd,
2193 "show evpn arp-cache vni all duplicate [json]",
2194 SHOW_STR
2195 "EVPN\n"
2196 "ARP and ND cache\n"
2197 "VxLAN Network Identifier\n"
2198 "All VNIs\n"
2199 "Duplicate address list\n"
2200 JSON_STR)
2201 {
2202 struct zebra_vrf *zvrf;
2203 bool uj = use_json(argc, argv);
2204
2205 zvrf = vrf_info_lookup(VRF_DEFAULT);
2206 zebra_vxlan_print_neigh_all_vni(vty, zvrf, true, uj);
2207 return CMD_SUCCESS;
2208 }
2209
2210
2211 DEFUN (show_evpn_neigh_vni,
2212 show_evpn_neigh_vni_cmd,
2213 "show evpn arp-cache vni " CMD_VNI_RANGE "[json]",
2214 SHOW_STR
2215 "EVPN\n"
2216 "ARP and ND cache\n"
2217 "VxLAN Network Identifier\n"
2218 "VNI number\n"
2219 JSON_STR)
2220 {
2221 struct zebra_vrf *zvrf;
2222 vni_t vni;
2223 bool uj = use_json(argc, argv);
2224
2225 vni = strtoul(argv[4]->arg, NULL, 10);
2226 zvrf = vrf_info_lookup(VRF_DEFAULT);
2227 zebra_vxlan_print_neigh_vni(vty, zvrf, vni, uj);
2228 return CMD_SUCCESS;
2229 }
2230
2231 DEFUN (show_evpn_neigh_vni_all,
2232 show_evpn_neigh_vni_all_cmd,
2233 "show evpn arp-cache vni all [json]",
2234 SHOW_STR
2235 "EVPN\n"
2236 "ARP and ND cache\n"
2237 "VxLAN Network Identifier\n"
2238 "All VNIs\n"
2239 JSON_STR)
2240 {
2241 struct zebra_vrf *zvrf;
2242 bool uj = use_json(argc, argv);
2243
2244 zvrf = vrf_info_lookup(VRF_DEFAULT);
2245 zebra_vxlan_print_neigh_all_vni(vty, zvrf, false, uj);
2246 return CMD_SUCCESS;
2247 }
2248
2249 DEFUN (show_evpn_neigh_vni_all_detail, show_evpn_neigh_vni_all_detail_cmd,
2250 "show evpn arp-cache vni all detail [json]",
2251 SHOW_STR
2252 "EVPN\n"
2253 "ARP and ND cache\n"
2254 "VxLAN Network Identifier\n"
2255 "All VNIs\n"
2256 "Neighbor details for all vnis in detail\n" JSON_STR)
2257 {
2258 struct zebra_vrf *zvrf;
2259 bool uj = use_json(argc, argv);
2260
2261 zvrf = vrf_info_lookup(VRF_DEFAULT);
2262 zebra_vxlan_print_neigh_all_vni_detail(vty, zvrf, false, uj);
2263 return CMD_SUCCESS;
2264 }
2265
2266 DEFUN (show_evpn_neigh_vni_neigh,
2267 show_evpn_neigh_vni_neigh_cmd,
2268 "show evpn arp-cache vni " CMD_VNI_RANGE " ip WORD [json]",
2269 SHOW_STR
2270 "EVPN\n"
2271 "ARP and ND cache\n"
2272 "VxLAN Network Identifier\n"
2273 "VNI number\n"
2274 "Neighbor\n"
2275 "Neighbor address (IPv4 or IPv6 address)\n"
2276 JSON_STR)
2277 {
2278 struct zebra_vrf *zvrf;
2279 vni_t vni;
2280 struct ipaddr ip;
2281 bool uj = use_json(argc, argv);
2282
2283 vni = strtoul(argv[4]->arg, NULL, 10);
2284 if (str2ipaddr(argv[6]->arg, &ip) != 0) {
2285 if (!uj)
2286 vty_out(vty, "%% Malformed Neighbor address\n");
2287 return CMD_WARNING;
2288 }
2289 zvrf = vrf_info_lookup(VRF_DEFAULT);
2290 zebra_vxlan_print_specific_neigh_vni(vty, zvrf, vni, &ip, uj);
2291 return CMD_SUCCESS;
2292 }
2293
2294 DEFUN (show_evpn_neigh_vni_vtep,
2295 show_evpn_neigh_vni_vtep_cmd,
2296 "show evpn arp-cache vni " CMD_VNI_RANGE " vtep A.B.C.D [json]",
2297 SHOW_STR
2298 "EVPN\n"
2299 "ARP and ND cache\n"
2300 "VxLAN Network Identifier\n"
2301 "VNI number\n"
2302 "Remote VTEP\n"
2303 "Remote VTEP IP address\n"
2304 JSON_STR)
2305 {
2306 struct zebra_vrf *zvrf;
2307 vni_t vni;
2308 struct in_addr vtep_ip;
2309 bool uj = use_json(argc, argv);
2310
2311 vni = strtoul(argv[4]->arg, NULL, 10);
2312 if (!inet_aton(argv[6]->arg, &vtep_ip)) {
2313 if (!uj)
2314 vty_out(vty, "%% Malformed VTEP IP address\n");
2315 return CMD_WARNING;
2316 }
2317
2318 zvrf = vrf_info_lookup(VRF_DEFAULT);
2319 zebra_vxlan_print_neigh_vni_vtep(vty, zvrf, vni, vtep_ip, uj);
2320 return CMD_SUCCESS;
2321 }
2322
2323 /* policy routing contexts */
2324 DEFUN (show_pbr_ipset,
2325 show_pbr_ipset_cmd,
2326 "show pbr ipset [WORD]",
2327 SHOW_STR
2328 "Policy-Based Routing\n"
2329 "IPset Context information\n"
2330 "IPset Name information\n")
2331 {
2332 int idx = 0;
2333 int found = 0;
2334 found = argv_find(argv, argc, "WORD", &idx);
2335 if (!found)
2336 zebra_pbr_show_ipset_list(vty, NULL);
2337 else
2338 zebra_pbr_show_ipset_list(vty, argv[idx]->arg);
2339 return CMD_SUCCESS;
2340 }
2341
2342 /* policy routing contexts */
2343 DEFUN (show_pbr_iptable,
2344 show_pbr_iptable_cmd,
2345 "show pbr iptable [WORD]",
2346 SHOW_STR
2347 "Policy-Based Routing\n"
2348 "IPtable Context information\n"
2349 "IPtable Name information\n")
2350 {
2351 int idx = 0;
2352 int found = 0;
2353
2354 found = argv_find(argv, argc, "WORD", &idx);
2355 if (!found)
2356 zebra_pbr_show_iptable(vty, NULL);
2357 else
2358 zebra_pbr_show_iptable(vty, argv[idx]->arg);
2359 return CMD_SUCCESS;
2360 }
2361
2362 DEFPY (clear_evpn_dup_addr,
2363 clear_evpn_dup_addr_cmd,
2364 "clear evpn dup-addr vni <all$vni_all |" CMD_VNI_RANGE"$vni_val [mac M:A:C$mac_val | ip <A.B.C.D|X:X::X:X>]>",
2365 CLEAR_STR
2366 "EVPN\n"
2367 "Duplicate address \n"
2368 "VxLAN Network Identifier\n"
2369 "VNI number\n"
2370 "All VNIs\n"
2371 "MAC\n"
2372 "MAC address (e.g., 00:e0:ec:20:12:62)\n"
2373 "IP\n"
2374 "IPv4 address\n"
2375 "IPv6 address\n")
2376 {
2377 struct zebra_vrf *zvrf;
2378 vni_t vni = 0;
2379 struct ipaddr host_ip = {.ipa_type = IPADDR_NONE };
2380 struct ethaddr mac_addr;
2381 int ret = CMD_SUCCESS;
2382
2383 zvrf = vrf_info_lookup(VRF_DEFAULT);
2384 if (vni_val) {
2385 vni = strtoul(vni_val, NULL, 10);
2386
2387 if (mac_val) {
2388 prefix_str2mac(mac_val, &mac_addr);
2389 ret = zebra_vxlan_clear_dup_detect_vni_mac(vty, zvrf,
2390 vni,
2391 &mac_addr);
2392 } else if (ip) {
2393 if (sockunion_family(ip) == AF_INET) {
2394 host_ip.ipa_type = IPADDR_V4;
2395 host_ip.ipaddr_v4.s_addr = sockunion2ip(ip);
2396 } else {
2397 host_ip.ipa_type = IPADDR_V6;
2398 memcpy(&host_ip.ipaddr_v6, &ip->sin6.sin6_addr,
2399 sizeof(struct in6_addr));
2400 }
2401 ret = zebra_vxlan_clear_dup_detect_vni_ip(vty, zvrf,
2402 vni,
2403 &host_ip);
2404 } else
2405 ret = zebra_vxlan_clear_dup_detect_vni(vty, zvrf, vni);
2406
2407 } else {
2408 ret = zebra_vxlan_clear_dup_detect_vni_all(vty, zvrf);
2409 }
2410
2411 return ret;
2412 }
2413
2414 /* Static ip route configuration write function. */
2415 static int zebra_ip_config(struct vty *vty)
2416 {
2417 int write = 0;
2418
2419 write += zebra_import_table_config(vty);
2420
2421 return write;
2422 }
2423
2424 DEFUN (ip_zebra_import_table_distance,
2425 ip_zebra_import_table_distance_cmd,
2426 "ip import-table (1-252) [distance (1-255)] [route-map WORD]",
2427 IP_STR
2428 "import routes from non-main kernel table\n"
2429 "kernel routing table id\n"
2430 "Distance for imported routes\n"
2431 "Default distance value\n"
2432 "route-map for filtering\n"
2433 "route-map name\n")
2434 {
2435 uint32_t table_id = 0;
2436
2437 table_id = strtoul(argv[2]->arg, NULL, 10);
2438 int distance = ZEBRA_TABLE_DISTANCE_DEFAULT;
2439 char *rmap =
2440 strmatch(argv[argc - 2]->text, "route-map")
2441 ? XSTRDUP(MTYPE_ROUTE_MAP_NAME, argv[argc - 1]->arg)
2442 : NULL;
2443 int ret;
2444
2445 if (argc == 7 || (argc == 5 && !rmap))
2446 distance = strtoul(argv[4]->arg, NULL, 10);
2447
2448 if (!is_zebra_valid_kernel_table(table_id)) {
2449 vty_out(vty,
2450 "Invalid routing table ID, %d. Must be in range 1-252\n",
2451 table_id);
2452 if (rmap)
2453 XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
2454 return CMD_WARNING;
2455 }
2456
2457 if (is_zebra_main_routing_table(table_id)) {
2458 vty_out(vty,
2459 "Invalid routing table ID, %d. Must be non-default table\n",
2460 table_id);
2461 if (rmap)
2462 XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
2463 return CMD_WARNING;
2464 }
2465
2466 ret = zebra_import_table(AFI_IP, table_id, distance, rmap, 1);
2467 if (rmap)
2468 XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
2469
2470 return ret;
2471 }
2472
2473 DEFUN_HIDDEN (zebra_packet_process,
2474 zebra_packet_process_cmd,
2475 "zebra zapi-packets (1-10000)",
2476 ZEBRA_STR
2477 "Zapi Protocol\n"
2478 "Number of packets to process before relinquishing thread\n")
2479 {
2480 uint32_t packets = strtoul(argv[2]->arg, NULL, 10);
2481
2482 atomic_store_explicit(&zebrad.packets_to_process, packets,
2483 memory_order_relaxed);
2484
2485 return CMD_SUCCESS;
2486 }
2487
2488 DEFUN_HIDDEN (no_zebra_packet_process,
2489 no_zebra_packet_process_cmd,
2490 "no zebra zapi-packets [(1-10000)]",
2491 NO_STR
2492 ZEBRA_STR
2493 "Zapi Protocol\n"
2494 "Number of packets to process before relinquishing thread\n")
2495 {
2496 atomic_store_explicit(&zebrad.packets_to_process,
2497 ZEBRA_ZAPI_PACKETS_TO_PROCESS,
2498 memory_order_relaxed);
2499
2500 return CMD_SUCCESS;
2501 }
2502
2503 DEFUN_HIDDEN (zebra_workqueue_timer,
2504 zebra_workqueue_timer_cmd,
2505 "zebra work-queue (0-10000)",
2506 ZEBRA_STR
2507 "Work Queue\n"
2508 "Time in milliseconds\n")
2509 {
2510 uint32_t timer = strtoul(argv[2]->arg, NULL, 10);
2511 zebrad.ribq->spec.hold = timer;
2512
2513 return CMD_SUCCESS;
2514 }
2515
2516 DEFUN_HIDDEN (no_zebra_workqueue_timer,
2517 no_zebra_workqueue_timer_cmd,
2518 "no zebra work-queue [(0-10000)]",
2519 NO_STR
2520 ZEBRA_STR
2521 "Work Queue\n"
2522 "Time in milliseconds\n")
2523 {
2524 zebrad.ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
2525
2526 return CMD_SUCCESS;
2527 }
2528
2529 DEFUN (no_ip_zebra_import_table,
2530 no_ip_zebra_import_table_cmd,
2531 "no ip import-table (1-252) [distance (1-255)] [route-map NAME]",
2532 NO_STR
2533 IP_STR
2534 "import routes from non-main kernel table\n"
2535 "kernel routing table id\n"
2536 "Distance for imported routes\n"
2537 "Default distance value\n"
2538 "route-map for filtering\n"
2539 "route-map name\n")
2540 {
2541 uint32_t table_id = 0;
2542 table_id = strtoul(argv[3]->arg, NULL, 10);
2543
2544 if (!is_zebra_valid_kernel_table(table_id)) {
2545 vty_out(vty,
2546 "Invalid routing table ID. Must be in range 1-252\n");
2547 return CMD_WARNING;
2548 }
2549
2550 if (is_zebra_main_routing_table(table_id)) {
2551 vty_out(vty,
2552 "Invalid routing table ID, %d. Must be non-default table\n",
2553 table_id);
2554 return CMD_WARNING;
2555 }
2556
2557 if (!is_zebra_import_table_enabled(AFI_IP, table_id))
2558 return CMD_SUCCESS;
2559
2560 return (zebra_import_table(AFI_IP, table_id, 0, NULL, 0));
2561 }
2562
2563 static int config_write_protocol(struct vty *vty)
2564 {
2565 if (allow_delete)
2566 vty_out(vty, "allow-external-route-update\n");
2567
2568 if (zebra_rnh_ip_default_route)
2569 vty_out(vty, "ip nht resolve-via-default\n");
2570
2571 if (zebra_rnh_ipv6_default_route)
2572 vty_out(vty, "ipv6 nht resolve-via-default\n");
2573
2574 if (zebrad.ribq->spec.hold != ZEBRA_RIB_PROCESS_HOLD_TIME)
2575 vty_out(vty, "zebra work-queue %u\n", zebrad.ribq->spec.hold);
2576
2577 if (zebrad.packets_to_process != ZEBRA_ZAPI_PACKETS_TO_PROCESS)
2578 vty_out(vty, "zebra zapi-packets %u\n",
2579 zebrad.packets_to_process);
2580
2581 enum multicast_mode ipv4_multicast_mode = multicast_mode_ipv4_get();
2582
2583 if (ipv4_multicast_mode != MCAST_NO_CONFIG)
2584 vty_out(vty, "ip multicast rpf-lookup-mode %s\n",
2585 ipv4_multicast_mode == MCAST_URIB_ONLY
2586 ? "urib-only"
2587 : ipv4_multicast_mode == MCAST_MRIB_ONLY
2588 ? "mrib-only"
2589 : ipv4_multicast_mode
2590 == MCAST_MIX_MRIB_FIRST
2591 ? "mrib-then-urib"
2592 : ipv4_multicast_mode
2593 == MCAST_MIX_DISTANCE
2594 ? "lower-distance"
2595 : "longer-prefix");
2596 return 1;
2597 }
2598
2599 #ifdef HAVE_NETLINK
2600 /* Display default rtm_table for all clients. */
2601 DEFUN (show_table,
2602 show_table_cmd,
2603 "show table",
2604 SHOW_STR
2605 "default routing table to use for all clients\n")
2606 {
2607 vty_out(vty, "table %d\n", zebrad.rtm_table_default);
2608 return CMD_SUCCESS;
2609 }
2610
2611 DEFUN (config_table,
2612 config_table_cmd,
2613 "table TABLENO",
2614 "Configure target kernel routing table\n"
2615 "TABLE integer\n")
2616 {
2617 zebrad.rtm_table_default = strtol(argv[1]->arg, (char **)0, 10);
2618 return CMD_SUCCESS;
2619 }
2620
2621 DEFUN (no_config_table,
2622 no_config_table_cmd,
2623 "no table [TABLENO]",
2624 NO_STR
2625 "Configure target kernel routing table\n"
2626 "TABLE integer\n")
2627 {
2628 zebrad.rtm_table_default = 0;
2629 return CMD_SUCCESS;
2630 }
2631 #endif
2632
2633 DEFUN (show_zebra,
2634 show_zebra_cmd,
2635 "show zebra",
2636 SHOW_STR
2637 ZEBRA_STR)
2638 {
2639 struct vrf *vrf;
2640
2641 vty_out(vty,
2642 " Route Route Neighbor LSP LSP\n");
2643 vty_out(vty,
2644 "VRF Installs Removals Updates Installs Removals\n");
2645
2646 RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
2647 struct zebra_vrf *zvrf = vrf->info;
2648
2649 vty_out(vty, "%-25s %10" PRIu64 " %10" PRIu64 " %10" PRIu64
2650 " %10" PRIu64 " %10" PRIu64 "\n",
2651 vrf->name, zvrf->installs, zvrf->removals,
2652 zvrf->neigh_updates, zvrf->lsp_installs,
2653 zvrf->lsp_removals);
2654 }
2655
2656 return CMD_SUCCESS;
2657 }
2658
2659 DEFUN (ip_forwarding,
2660 ip_forwarding_cmd,
2661 "ip forwarding",
2662 IP_STR
2663 "Turn on IP forwarding\n")
2664 {
2665 int ret;
2666
2667 ret = ipforward();
2668 if (ret == 0)
2669 ret = ipforward_on();
2670
2671 if (ret == 0) {
2672 vty_out(vty, "Can't turn on IP forwarding\n");
2673 return CMD_WARNING_CONFIG_FAILED;
2674 }
2675
2676 return CMD_SUCCESS;
2677 }
2678
2679 DEFUN (no_ip_forwarding,
2680 no_ip_forwarding_cmd,
2681 "no ip forwarding",
2682 NO_STR
2683 IP_STR
2684 "Turn off IP forwarding\n")
2685 {
2686 int ret;
2687
2688 ret = ipforward();
2689 if (ret != 0)
2690 ret = ipforward_off();
2691
2692 if (ret != 0) {
2693 vty_out(vty, "Can't turn off IP forwarding\n");
2694 return CMD_WARNING_CONFIG_FAILED;
2695 }
2696
2697 return CMD_SUCCESS;
2698 }
2699
2700 /* Only display ip forwarding is enabled or not. */
2701 DEFUN (show_ip_forwarding,
2702 show_ip_forwarding_cmd,
2703 "show ip forwarding",
2704 SHOW_STR
2705 IP_STR
2706 "IP forwarding status\n")
2707 {
2708 int ret;
2709
2710 ret = ipforward();
2711
2712 if (ret == 0)
2713 vty_out(vty, "IP forwarding is off\n");
2714 else
2715 vty_out(vty, "IP forwarding is on\n");
2716 return CMD_SUCCESS;
2717 }
2718
2719 /* Only display ipv6 forwarding is enabled or not. */
2720 DEFUN (show_ipv6_forwarding,
2721 show_ipv6_forwarding_cmd,
2722 "show ipv6 forwarding",
2723 SHOW_STR
2724 "IPv6 information\n"
2725 "Forwarding status\n")
2726 {
2727 int ret;
2728
2729 ret = ipforward_ipv6();
2730
2731 switch (ret) {
2732 case -1:
2733 vty_out(vty, "ipv6 forwarding is unknown\n");
2734 break;
2735 case 0:
2736 vty_out(vty, "ipv6 forwarding is %s\n", "off");
2737 break;
2738 case 1:
2739 vty_out(vty, "ipv6 forwarding is %s\n", "on");
2740 break;
2741 default:
2742 vty_out(vty, "ipv6 forwarding is %s\n", "off");
2743 break;
2744 }
2745 return CMD_SUCCESS;
2746 }
2747
2748 DEFUN (ipv6_forwarding,
2749 ipv6_forwarding_cmd,
2750 "ipv6 forwarding",
2751 IPV6_STR
2752 "Turn on IPv6 forwarding\n")
2753 {
2754 int ret;
2755
2756 ret = ipforward_ipv6();
2757 if (ret == 0)
2758 ret = ipforward_ipv6_on();
2759
2760 if (ret == 0) {
2761 vty_out(vty, "Can't turn on IPv6 forwarding\n");
2762 return CMD_WARNING_CONFIG_FAILED;
2763 }
2764
2765 return CMD_SUCCESS;
2766 }
2767
2768 DEFUN (no_ipv6_forwarding,
2769 no_ipv6_forwarding_cmd,
2770 "no ipv6 forwarding",
2771 NO_STR
2772 IPV6_STR
2773 "Turn off IPv6 forwarding\n")
2774 {
2775 int ret;
2776
2777 ret = ipforward_ipv6();
2778 if (ret != 0)
2779 ret = ipforward_ipv6_off();
2780
2781 if (ret != 0) {
2782 vty_out(vty, "Can't turn off IPv6 forwarding\n");
2783 return CMD_WARNING_CONFIG_FAILED;
2784 }
2785
2786 return CMD_SUCCESS;
2787 }
2788
2789 /* Display dataplane info */
2790 DEFUN (show_dataplane,
2791 show_dataplane_cmd,
2792 "show zebra dplane [detailed]",
2793 SHOW_STR
2794 ZEBRA_STR
2795 "Zebra dataplane information\n"
2796 "Detailed output\n")
2797 {
2798 int idx = 0;
2799 bool detailed = false;
2800
2801 if (argv_find(argv, argc, "detailed", &idx))
2802 detailed = true;
2803
2804 return dplane_show_helper(vty, detailed);
2805 }
2806
2807 /* Display dataplane providers info */
2808 DEFUN (show_dataplane_providers,
2809 show_dataplane_providers_cmd,
2810 "show zebra dplane providers [detailed]",
2811 SHOW_STR
2812 ZEBRA_STR
2813 "Zebra dataplane information\n"
2814 "Zebra dataplane provider information\n"
2815 "Detailed output\n")
2816 {
2817 int idx = 0;
2818 bool detailed = false;
2819
2820 if (argv_find(argv, argc, "detailed", &idx))
2821 detailed = true;
2822
2823 return dplane_show_provs_helper(vty, detailed);
2824 }
2825
2826 /* Configure dataplane incoming queue limit */
2827 DEFUN (zebra_dplane_queue_limit,
2828 zebra_dplane_queue_limit_cmd,
2829 "zebra dplane limit (0-10000)",
2830 ZEBRA_STR
2831 "Zebra dataplane\n"
2832 "Limit incoming queued updates\n"
2833 "Number of queued updates\n")
2834 {
2835 uint32_t limit = 0;
2836
2837 limit = strtoul(argv[3]->arg, NULL, 10);
2838
2839 dplane_set_in_queue_limit(limit, true);
2840
2841 return CMD_SUCCESS;
2842 }
2843
2844 /* Reset dataplane queue limit to default value */
2845 DEFUN (no_zebra_dplane_queue_limit,
2846 no_zebra_dplane_queue_limit_cmd,
2847 "no zebra dplane limit [(0-10000)]",
2848 NO_STR
2849 ZEBRA_STR
2850 "Zebra dataplane\n"
2851 "Limit incoming queued updates\n"
2852 "Number of queued updates\n")
2853 {
2854 dplane_set_in_queue_limit(0, false);
2855
2856 return CMD_SUCCESS;
2857 }
2858
2859 DEFUN (zebra_show_routing_tables_summary,
2860 zebra_show_routing_tables_summary_cmd,
2861 "show zebra router table summary",
2862 SHOW_STR
2863 ZEBRA_STR
2864 "The Zebra Router Information\n"
2865 "Table Information about this Zebra Router\n"
2866 "Summary Information\n")
2867 {
2868 zebra_router_show_table_summary(vty);
2869
2870 return CMD_SUCCESS;
2871 }
2872
2873 /* Table configuration write function. */
2874 static int config_write_table(struct vty *vty)
2875 {
2876 if (zebrad.rtm_table_default)
2877 vty_out(vty, "table %d\n", zebrad.rtm_table_default);
2878 return 0;
2879 }
2880
2881 /* IPForwarding configuration write function. */
2882 static int config_write_forwarding(struct vty *vty)
2883 {
2884 /* FIXME: Find better place for that. */
2885 router_id_write(vty);
2886
2887 if (!ipforward())
2888 vty_out(vty, "no ip forwarding\n");
2889 if (!ipforward_ipv6())
2890 vty_out(vty, "no ipv6 forwarding\n");
2891 vty_out(vty, "!\n");
2892 return 0;
2893 }
2894
2895 /* IP node for static routes. */
2896 static struct cmd_node ip_node = {IP_NODE, "", 1};
2897 static struct cmd_node protocol_node = {PROTOCOL_NODE, "", 1};
2898 /* table node for routing tables. */
2899 static struct cmd_node table_node = {TABLE_NODE,
2900 "", /* This node has no interface. */
2901 1};
2902 static struct cmd_node forwarding_node = {FORWARDING_NODE,
2903 "", /* This node has no interface. */
2904 1};
2905
2906 /* Route VTY. */
2907 void zebra_vty_init(void)
2908 {
2909 /* Install configuration write function. */
2910 install_node(&table_node, config_write_table);
2911 install_node(&forwarding_node, config_write_forwarding);
2912
2913 install_element(VIEW_NODE, &show_ip_forwarding_cmd);
2914 install_element(CONFIG_NODE, &ip_forwarding_cmd);
2915 install_element(CONFIG_NODE, &no_ip_forwarding_cmd);
2916 install_element(ENABLE_NODE, &show_zebra_cmd);
2917
2918 #ifdef HAVE_NETLINK
2919 install_element(VIEW_NODE, &show_table_cmd);
2920 install_element(CONFIG_NODE, &config_table_cmd);
2921 install_element(CONFIG_NODE, &no_config_table_cmd);
2922 #endif /* HAVE_NETLINK */
2923
2924 install_element(VIEW_NODE, &show_ipv6_forwarding_cmd);
2925 install_element(CONFIG_NODE, &ipv6_forwarding_cmd);
2926 install_element(CONFIG_NODE, &no_ipv6_forwarding_cmd);
2927
2928 /* Route-map */
2929 zebra_route_map_init();
2930
2931 install_node(&ip_node, zebra_ip_config);
2932 install_node(&protocol_node, config_write_protocol);
2933
2934 install_element(CONFIG_NODE, &allow_external_route_update_cmd);
2935 install_element(CONFIG_NODE, &no_allow_external_route_update_cmd);
2936
2937 install_element(CONFIG_NODE, &ip_multicast_mode_cmd);
2938 install_element(CONFIG_NODE, &no_ip_multicast_mode_cmd);
2939
2940 install_element(CONFIG_NODE, &ip_zebra_import_table_distance_cmd);
2941 install_element(CONFIG_NODE, &no_ip_zebra_import_table_cmd);
2942 install_element(CONFIG_NODE, &zebra_workqueue_timer_cmd);
2943 install_element(CONFIG_NODE, &no_zebra_workqueue_timer_cmd);
2944 install_element(CONFIG_NODE, &zebra_packet_process_cmd);
2945 install_element(CONFIG_NODE, &no_zebra_packet_process_cmd);
2946
2947 install_element(VIEW_NODE, &show_vrf_cmd);
2948 install_element(VIEW_NODE, &show_vrf_vni_cmd);
2949 install_element(VIEW_NODE, &show_route_cmd);
2950 install_element(VIEW_NODE, &show_route_table_cmd);
2951 if (vrf_is_backend_netns())
2952 install_element(VIEW_NODE, &show_route_table_vrf_cmd);
2953 install_element(VIEW_NODE, &show_route_detail_cmd);
2954 install_element(VIEW_NODE, &show_route_summary_cmd);
2955 install_element(VIEW_NODE, &show_ip_nht_cmd);
2956 install_element(VIEW_NODE, &show_ip_import_check_cmd);
2957 install_element(VIEW_NODE, &show_ip_nht_vrf_all_cmd);
2958 install_element(VIEW_NODE, &show_ipv6_nht_cmd);
2959 install_element(VIEW_NODE, &show_ipv6_nht_vrf_all_cmd);
2960
2961 install_element(VIEW_NODE, &show_ip_rpf_cmd);
2962 install_element(VIEW_NODE, &show_ip_rpf_addr_cmd);
2963
2964 install_element(CONFIG_NODE, &ip_nht_default_route_cmd);
2965 install_element(CONFIG_NODE, &no_ip_nht_default_route_cmd);
2966 install_element(CONFIG_NODE, &ipv6_nht_default_route_cmd);
2967 install_element(CONFIG_NODE, &no_ipv6_nht_default_route_cmd);
2968 install_element(VRF_NODE, &ip_nht_default_route_cmd);
2969 install_element(VRF_NODE, &no_ip_nht_default_route_cmd);
2970 install_element(VRF_NODE, &ipv6_nht_default_route_cmd);
2971 install_element(VRF_NODE, &no_ipv6_nht_default_route_cmd);
2972 install_element(VIEW_NODE, &show_ipv6_mroute_cmd);
2973
2974 /* Commands for VRF */
2975 install_element(VIEW_NODE, &show_ipv6_mroute_vrf_all_cmd);
2976
2977 install_element(VIEW_NODE, &show_evpn_global_cmd);
2978 install_element(VIEW_NODE, &show_evpn_vni_cmd);
2979 install_element(VIEW_NODE, &show_evpn_vni_detail_cmd);
2980 install_element(VIEW_NODE, &show_evpn_vni_vni_cmd);
2981 install_element(VIEW_NODE, &show_evpn_rmac_vni_mac_cmd);
2982 install_element(VIEW_NODE, &show_evpn_rmac_vni_cmd);
2983 install_element(VIEW_NODE, &show_evpn_rmac_vni_all_cmd);
2984 install_element(VIEW_NODE, &show_evpn_nh_vni_ip_cmd);
2985 install_element(VIEW_NODE, &show_evpn_nh_vni_cmd);
2986 install_element(VIEW_NODE, &show_evpn_nh_vni_all_cmd);
2987 install_element(VIEW_NODE, &show_evpn_mac_vni_cmd);
2988 install_element(VIEW_NODE, &show_evpn_mac_vni_all_cmd);
2989 install_element(VIEW_NODE, &show_evpn_mac_vni_all_detail_cmd);
2990 install_element(VIEW_NODE, &show_evpn_mac_vni_all_vtep_cmd);
2991 install_element(VIEW_NODE, &show_evpn_mac_vni_mac_cmd);
2992 install_element(VIEW_NODE, &show_evpn_mac_vni_vtep_cmd);
2993 install_element(VIEW_NODE, &show_evpn_mac_vni_dad_cmd);
2994 install_element(VIEW_NODE, &show_evpn_mac_vni_all_dad_cmd);
2995 install_element(VIEW_NODE, &show_evpn_neigh_vni_cmd);
2996 install_element(VIEW_NODE, &show_evpn_neigh_vni_all_cmd);
2997 install_element(VIEW_NODE, &show_evpn_neigh_vni_all_detail_cmd);
2998 install_element(VIEW_NODE, &show_evpn_neigh_vni_neigh_cmd);
2999 install_element(VIEW_NODE, &show_evpn_neigh_vni_vtep_cmd);
3000 install_element(VIEW_NODE, &show_evpn_neigh_vni_dad_cmd);
3001 install_element(VIEW_NODE, &show_evpn_neigh_vni_all_dad_cmd);
3002 install_element(ENABLE_NODE, &clear_evpn_dup_addr_cmd);
3003
3004 install_element(VIEW_NODE, &show_pbr_ipset_cmd);
3005 install_element(VIEW_NODE, &show_pbr_iptable_cmd);
3006
3007 install_element(CONFIG_NODE, &default_vrf_vni_mapping_cmd);
3008 install_element(CONFIG_NODE, &no_default_vrf_vni_mapping_cmd);
3009 install_element(VRF_NODE, &vrf_vni_mapping_cmd);
3010 install_element(VRF_NODE, &no_vrf_vni_mapping_cmd);
3011
3012 install_element(VIEW_NODE, &show_dataplane_cmd);
3013 install_element(VIEW_NODE, &show_dataplane_providers_cmd);
3014 install_element(CONFIG_NODE, &zebra_dplane_queue_limit_cmd);
3015 install_element(CONFIG_NODE, &no_zebra_dplane_queue_limit_cmd);
3016
3017 install_element(VIEW_NODE, &zebra_show_routing_tables_summary_cmd);
3018 }
FRRouting mirror