summaryrefslogtreecommitdiffstats
path: root/zebra/zebra_vty.c
diff options
context:
space:
mode:
Diffstat (limited to 'zebra/zebra_vty.c')
-rw-r--r--zebra/zebra_vty.c4705
1 files changed, 4705 insertions, 0 deletions
diff --git a/zebra/zebra_vty.c b/zebra/zebra_vty.c
new file mode 100644
index 0000000..d36c2f8
--- /dev/null
+++ b/zebra/zebra_vty.c
@@ -0,0 +1,4705 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Zebra VTY functions
+ * Copyright (C) 2002 Kunihiro Ishiguro
+ */
+
+#include <zebra.h>
+
+#include "memory.h"
+#include "if.h"
+#include "prefix.h"
+#include "command.h"
+#include "table.h"
+#include "rib.h"
+#include "nexthop.h"
+#include "vrf.h"
+#include "linklist.h"
+#include "mpls.h"
+#include "routemap.h"
+#include "srcdest_table.h"
+#include "vxlan.h"
+#include "termtable.h"
+#include "affinitymap.h"
+
+#include "zebra/zebra_router.h"
+#include "zebra/zserv.h"
+#include "zebra/zebra_vrf.h"
+#include "zebra/zebra_mpls.h"
+#include "zebra/zebra_rnh.h"
+#include "zebra/redistribute.h"
+#include "zebra/zebra_affinitymap.h"
+#include "zebra/zebra_routemap.h"
+#include "lib/json.h"
+#include "lib/route_opaque.h"
+#include "zebra/zebra_vxlan.h"
+#include "zebra/zebra_evpn_mh.h"
+#include "zebra/zebra_vty_clippy.c"
+#include "zebra/zserv.h"
+#include "zebra/router-id.h"
+#include "zebra/ipforward.h"
+#include "zebra/zebra_vxlan_private.h"
+#include "zebra/zebra_pbr.h"
+#include "zebra/zebra_nhg.h"
+#include "zebra/zebra_evpn_mh.h"
+#include "zebra/interface.h"
+#include "northbound_cli.h"
+#include "zebra/zebra_nb.h"
+#include "zebra/kernel_netlink.h"
+#include "zebra/if_netlink.h"
+#include "zebra/table_manager.h"
+#include "zebra/zebra_script.h"
+#include "zebra/rtadv.h"
+#include "zebra/zebra_neigh.h"
+
+/* context to manage dumps in multiple tables or vrfs */
+struct route_show_ctx {
+ bool multi; /* dump multiple tables or vrf */
+ bool header_done; /* common header already displayed */
+};
+
+static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
+ safi_t safi, bool use_fib, bool use_json,
+ route_tag_t tag,
+ const struct prefix *longer_prefix_p,
+ bool supernets_only, int type,
+ unsigned short ospf_instance_id, uint32_t tableid,
+ bool show_ng, struct route_show_ctx *ctx);
+static void vty_show_ip_route_detail(struct vty *vty, struct route_node *rn,
+ int mcast, bool use_fib, bool show_ng);
+static void vty_show_ip_route_summary(struct vty *vty,
+ struct route_table *table, bool use_json);
+static void vty_show_ip_route_summary_prefix(struct vty *vty,
+ struct route_table *table,
+ bool use_json);
+/* Helper api to format a nexthop in the 'detailed' output path. */
+static void show_nexthop_detail_helper(struct vty *vty,
+ const struct route_entry *re,
+ const struct nexthop *nexthop,
+ bool is_backup);
+
+static void show_ip_route_dump_vty(struct vty *vty, struct route_table *table);
+static void show_ip_route_nht_dump(struct vty *vty, struct nexthop *nexthop,
+ struct route_entry *re, unsigned int num);
+
+DEFUN (ip_multicast_mode,
+ ip_multicast_mode_cmd,
+ "ip multicast rpf-lookup-mode <urib-only|mrib-only|mrib-then-urib|lower-distance|longer-prefix>",
+ IP_STR
+ "Multicast options\n"
+ "RPF lookup behavior\n"
+ "Lookup in unicast RIB only\n"
+ "Lookup in multicast RIB only\n"
+ "Try multicast RIB first, fall back to unicast RIB\n"
+ "Lookup both, use entry with lower distance\n"
+ "Lookup both, use entry with longer prefix\n")
+{
+ char *mode = argv[3]->text;
+
+ if (strmatch(mode, "urib-only"))
+ multicast_mode_ipv4_set(MCAST_URIB_ONLY);
+ else if (strmatch(mode, "mrib-only"))
+ multicast_mode_ipv4_set(MCAST_MRIB_ONLY);
+ else if (strmatch(mode, "mrib-then-urib"))
+ multicast_mode_ipv4_set(MCAST_MIX_MRIB_FIRST);
+ else if (strmatch(mode, "lower-distance"))
+ multicast_mode_ipv4_set(MCAST_MIX_DISTANCE);
+ else if (strmatch(mode, "longer-prefix"))
+ multicast_mode_ipv4_set(MCAST_MIX_PFXLEN);
+ else {
+ vty_out(vty, "Invalid mode specified\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ip_multicast_mode,
+ no_ip_multicast_mode_cmd,
+ "no ip multicast rpf-lookup-mode [<urib-only|mrib-only|mrib-then-urib|lower-distance|longer-prefix>]",
+ NO_STR
+ IP_STR
+ "Multicast options\n"
+ "RPF lookup behavior\n"
+ "Lookup in unicast RIB only\n"
+ "Lookup in multicast RIB only\n"
+ "Try multicast RIB first, fall back to unicast RIB\n"
+ "Lookup both, use entry with lower distance\n"
+ "Lookup both, use entry with longer prefix\n")
+{
+ multicast_mode_ipv4_set(MCAST_NO_CONFIG);
+ return CMD_SUCCESS;
+}
+
+
+DEFPY (show_ip_rpf,
+ show_ip_rpf_cmd,
+ "show [ip$ip|ipv6$ipv6] rpf [json]",
+ SHOW_STR
+ IP_STR
+ IPV6_STR
+ "Display RPF information for multicast source\n"
+ JSON_STR)
+{
+ bool uj = use_json(argc, argv);
+ struct route_show_ctx ctx = {
+ .multi = false,
+ };
+
+ return do_show_ip_route(vty, VRF_DEFAULT_NAME, ip ? AFI_IP : AFI_IP6,
+ SAFI_MULTICAST, false, uj, 0, NULL, false, 0, 0,
+ 0, false, &ctx);
+}
+
+DEFPY (show_ip_rpf_addr,
+ show_ip_rpf_addr_cmd,
+ "show ip rpf A.B.C.D$address",
+ SHOW_STR
+ IP_STR
+ "Display RPF information for multicast source\n"
+ "IP multicast source address (e.g. 10.0.0.0)\n")
+{
+ struct route_node *rn;
+ struct route_entry *re;
+
+ re = rib_match_multicast(AFI_IP, VRF_DEFAULT, (union g_addr *)&address,
+ &rn);
+
+ if (re)
+ vty_show_ip_route_detail(vty, rn, 1, false, false);
+ else
+ vty_out(vty, "%% No match for RPF lookup\n");
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_ipv6_rpf_addr,
+ show_ipv6_rpf_addr_cmd,
+ "show ipv6 rpf X:X::X:X$address",
+ SHOW_STR
+ IPV6_STR
+ "Display RPF information for multicast source\n"
+ "IPv6 multicast source address\n")
+{
+ struct route_node *rn;
+ struct route_entry *re;
+
+ re = rib_match_multicast(AFI_IP6, VRF_DEFAULT, (union g_addr *)&address,
+ &rn);
+
+ if (re)
+ vty_show_ip_route_detail(vty, rn, 1, false, false);
+ else
+ vty_out(vty, "%% No match for RPF lookup\n");
+
+ return CMD_SUCCESS;
+}
+
+static char re_status_output_char(const struct route_entry *re,
+ const struct nexthop *nhop,
+ bool is_fib)
+{
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED)) {
+ bool star_p = false;
+
+ if (nhop &&
+ !CHECK_FLAG(nhop->flags, NEXTHOP_FLAG_DUPLICATE) &&
+ !CHECK_FLAG(nhop->flags, NEXTHOP_FLAG_RECURSIVE)) {
+ /* More-specific test for 'fib' output */
+ if (is_fib) {
+ star_p = !!CHECK_FLAG(nhop->flags,
+ NEXTHOP_FLAG_FIB);
+ } else
+ star_p = true;
+ }
+
+ if (zrouter.asic_offloaded &&
+ CHECK_FLAG(re->status, ROUTE_ENTRY_QUEUED))
+ return 'q';
+
+ if (zrouter.asic_offloaded
+ && CHECK_FLAG(re->flags, ZEBRA_FLAG_TRAPPED))
+ return 't';
+
+ if (zrouter.asic_offloaded
+ && CHECK_FLAG(re->flags, ZEBRA_FLAG_OFFLOAD_FAILED))
+ return 'o';
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_OUTOFSYNC))
+ return 'd';
+
+ if (star_p)
+ return '*';
+ else
+ return ' ';
+ }
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_FAILED)) {
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_QUEUED))
+ return 'q';
+
+ return 'r';
+ }
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_QUEUED))
+ return 'q';
+
+ return ' ';
+}
+
+/*
+ * Show backup nexthop info, in the 'detailed' output path
+ */
+static void show_nh_backup_helper(struct vty *vty,
+ const struct route_entry *re,
+ const struct nexthop *nexthop)
+{
+ const struct nexthop *start, *backup, *temp;
+ int i, idx;
+
+ /* Double-check that there _is_ a backup */
+ if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP) ||
+ re->nhe->backup_info == NULL || re->nhe->backup_info->nhe == NULL ||
+ re->nhe->backup_info->nhe->nhg.nexthop == NULL)
+ return;
+
+ /* Locate the backup nexthop(s) */
+ start = re->nhe->backup_info->nhe->nhg.nexthop;
+ for (i = 0; i < nexthop->backup_num; i++) {
+ /* Format the backup(s) (indented) */
+ backup = start;
+ for (idx = 0; idx < nexthop->backup_idx[i]; idx++) {
+ backup = backup->next;
+ if (backup == NULL)
+ break;
+ }
+
+ /* It's possible for backups to be recursive too,
+ * so walk the recursive resolution list if present.
+ */
+ temp = backup;
+ while (backup) {
+ vty_out(vty, " ");
+ show_nexthop_detail_helper(vty, re, backup,
+ true /*backup*/);
+ vty_out(vty, "\n");
+
+ if (backup->resolved && temp == backup)
+ backup = backup->resolved;
+ else
+ backup = nexthop_next(backup);
+
+ if (backup == temp->next)
+ break;
+ }
+ }
+
+}
+
+/*
+ * Helper api to format output for a nexthop, used in the 'detailed'
+ * output path.
+ */
+static void show_nexthop_detail_helper(struct vty *vty,
+ const struct route_entry *re,
+ const struct nexthop *nexthop,
+ bool is_backup)
+{
+ char addrstr[32];
+ char buf[MPLS_LABEL_STRLEN];
+ int i;
+
+ if (is_backup)
+ vty_out(vty, " b%s",
+ nexthop->rparent ? " " : "");
+ else
+ vty_out(vty, " %c%s",
+ re_status_output_char(re, nexthop, false),
+ nexthop->rparent ? " " : "");
+
+ switch (nexthop->type) {
+ case NEXTHOP_TYPE_IPV4:
+ case NEXTHOP_TYPE_IPV4_IFINDEX:
+ vty_out(vty, " %pI4",
+ &nexthop->gate.ipv4);
+ if (nexthop->ifindex)
+ vty_out(vty, ", via %s",
+ ifindex2ifname(
+ nexthop->ifindex,
+ nexthop->vrf_id));
+ break;
+ case NEXTHOP_TYPE_IPV6:
+ case NEXTHOP_TYPE_IPV6_IFINDEX:
+ vty_out(vty, " %s",
+ inet_ntop(AF_INET6, &nexthop->gate.ipv6,
+ buf, sizeof(buf)));
+ if (nexthop->ifindex)
+ vty_out(vty, ", via %s",
+ ifindex2ifname(
+ nexthop->ifindex,
+ nexthop->vrf_id));
+ break;
+
+ case NEXTHOP_TYPE_IFINDEX:
+ vty_out(vty, " directly connected, %s",
+ ifindex2ifname(nexthop->ifindex,
+ nexthop->vrf_id));
+ break;
+ case NEXTHOP_TYPE_BLACKHOLE:
+ vty_out(vty, " unreachable");
+ switch (nexthop->bh_type) {
+ case BLACKHOLE_REJECT:
+ vty_out(vty, " (ICMP unreachable)");
+ break;
+ case BLACKHOLE_ADMINPROHIB:
+ vty_out(vty,
+ " (ICMP admin-prohibited)");
+ break;
+ case BLACKHOLE_NULL:
+ vty_out(vty, " (blackhole)");
+ break;
+ case BLACKHOLE_UNSPEC:
+ break;
+ }
+ break;
+ }
+
+ if (re->vrf_id != nexthop->vrf_id) {
+ struct vrf *vrf = vrf_lookup_by_id(nexthop->vrf_id);
+
+ vty_out(vty, "(vrf %s)", VRF_LOGNAME(vrf));
+ }
+
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE))
+ vty_out(vty, " (duplicate nexthop removed)");
+
+ if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
+ vty_out(vty, " inactive");
+
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK))
+ vty_out(vty, " onlink");
+
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_LINKDOWN))
+ vty_out(vty, " linkdown");
+
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
+ vty_out(vty, " (recursive)");
+
+ /* Source specified? */
+ switch (nexthop->type) {
+ case NEXTHOP_TYPE_IPV4:
+ case NEXTHOP_TYPE_IPV4_IFINDEX:
+ if (nexthop->src.ipv4.s_addr) {
+ if (inet_ntop(AF_INET, &nexthop->src.ipv4,
+ addrstr, sizeof(addrstr)))
+ vty_out(vty, ", src %s",
+ addrstr);
+ }
+ break;
+
+ case NEXTHOP_TYPE_IPV6:
+ case NEXTHOP_TYPE_IPV6_IFINDEX:
+ if (!IPV6_ADDR_SAME(&nexthop->src.ipv6,
+ &in6addr_any)) {
+ if (inet_ntop(AF_INET6, &nexthop->src.ipv6,
+ addrstr, sizeof(addrstr)))
+ vty_out(vty, ", src %s",
+ addrstr);
+ }
+ break;
+
+ case NEXTHOP_TYPE_IFINDEX:
+ case NEXTHOP_TYPE_BLACKHOLE:
+ break;
+ }
+
+ if (re->nexthop_mtu)
+ vty_out(vty, ", mtu %u", re->nexthop_mtu);
+
+ /* Label information */
+ if (nexthop->nh_label && nexthop->nh_label->num_labels) {
+ vty_out(vty, ", label %s",
+ mpls_label2str(nexthop->nh_label->num_labels,
+ nexthop->nh_label->label, buf,
+ sizeof(buf), nexthop->nh_label_type,
+ 1 /*pretty*/));
+ }
+
+ if (nexthop->weight)
+ vty_out(vty, ", weight %u", nexthop->weight);
+
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP)) {
+ vty_out(vty, ", backup %d", nexthop->backup_idx[0]);
+
+ for (i = 1; i < nexthop->backup_num; i++)
+ vty_out(vty, ",%d", nexthop->backup_idx[i]);
+ }
+}
+
+static void zebra_show_ip_route_opaque(struct vty *vty, struct route_entry *re,
+ struct json_object *json)
+{
+ struct bgp_zebra_opaque bzo = {};
+ struct ospf_zebra_opaque ozo = {};
+
+ if (!re->opaque)
+ return;
+
+ switch (re->type) {
+ case ZEBRA_ROUTE_SHARP:
+ if (json)
+ json_object_string_add(json, "opaque",
+ (char *)re->opaque->data);
+ else
+ vty_out(vty, " Opaque Data: %s",
+ (char *)re->opaque->data);
+ break;
+
+ case ZEBRA_ROUTE_BGP:
+ memcpy(&bzo, re->opaque->data, re->opaque->length);
+
+ if (json) {
+ json_object_string_add(json, "asPath", bzo.aspath);
+ json_object_string_add(json, "communities",
+ bzo.community);
+ json_object_string_add(json, "largeCommunities",
+ bzo.lcommunity);
+ json_object_string_add(json, "selectionReason",
+ bzo.selection_reason);
+ } else {
+ vty_out(vty, " AS-Path : %s\n", bzo.aspath);
+
+ if (bzo.community[0] != '\0')
+ vty_out(vty, " Communities : %s\n",
+ bzo.community);
+
+ if (bzo.lcommunity[0] != '\0')
+ vty_out(vty, " Large-Communities: %s\n",
+ bzo.lcommunity);
+
+ vty_out(vty, " Selection reason : %s\n",
+ bzo.selection_reason);
+ }
+ break;
+ case ZEBRA_ROUTE_OSPF:
+ case ZEBRA_ROUTE_OSPF6:
+ memcpy(&ozo, re->opaque->data, re->opaque->length);
+
+ if (json) {
+ json_object_string_add(json, "ospfPathType",
+ ozo.path_type);
+ if (ozo.area_id[0] != '\0')
+ json_object_string_add(json, "ospfAreaId",
+ ozo.area_id);
+ if (ozo.tag[0] != '\0')
+ json_object_string_add(json, "ospfTag",
+ ozo.tag);
+ } else {
+ vty_out(vty, " OSPF path type : %s\n",
+ ozo.path_type);
+ if (ozo.area_id[0] != '\0')
+ vty_out(vty, " OSPF area ID : %s\n",
+ ozo.area_id);
+ if (ozo.tag[0] != '\0')
+ vty_out(vty, " OSPF tag : %s\n",
+ ozo.tag);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+static void uptime2str(time_t uptime, char *buf, size_t bufsize)
+{
+ time_t cur;
+
+ cur = monotime(NULL);
+ cur -= uptime;
+
+ frrtime_to_interval(cur, buf, bufsize);
+}
+
+/* New RIB. Detailed information for IPv4 route. */
+static void vty_show_ip_route_detail(struct vty *vty, struct route_node *rn,
+ int mcast, bool use_fib, bool show_ng)
+{
+ struct route_entry *re;
+ struct nexthop *nexthop;
+ char buf[SRCDEST2STR_BUFFER];
+ struct zebra_vrf *zvrf;
+ rib_dest_t *dest;
+
+ dest = rib_dest_from_rnode(rn);
+
+ RNODE_FOREACH_RE (rn, re) {
+ /*
+ * If re not selected for forwarding, skip re
+ * for "show ip/ipv6 fib <prefix>"
+ */
+ if (use_fib && re != dest->selected_fib)
+ continue;
+
+ const char *mcast_info = "";
+ if (mcast) {
+ struct rib_table_info *info =
+ srcdest_rnode_table_info(rn);
+ mcast_info = (info->safi == SAFI_MULTICAST)
+ ? " using Multicast RIB"
+ : " using Unicast RIB";
+ }
+
+ vty_out(vty, "Routing entry for %s%s\n",
+ srcdest_rnode2str(rn, buf, sizeof(buf)), mcast_info);
+ vty_out(vty, " Known via \"%s", zebra_route_string(re->type));
+ if (re->instance)
+ vty_out(vty, "[%d]", re->instance);
+ vty_out(vty, "\"");
+ vty_out(vty, ", distance %u, metric %u", re->distance,
+ re->metric);
+ if (re->tag) {
+ vty_out(vty, ", tag %u", re->tag);
+#if defined(SUPPORT_REALMS)
+ if (re->tag > 0 && re->tag <= 255)
+ vty_out(vty, "(realm)");
+#endif
+ }
+ if (re->mtu)
+ vty_out(vty, ", mtu %u", re->mtu);
+ if (re->vrf_id != VRF_DEFAULT) {
+ zvrf = zebra_vrf_lookup_by_id(re->vrf_id);
+ vty_out(vty, ", vrf %s", zvrf_name(zvrf));
+ }
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
+ vty_out(vty, ", best");
+ vty_out(vty, "\n");
+
+ uptime2str(re->uptime, buf, sizeof(buf));
+
+ vty_out(vty, " Last update %s ago\n", buf);
+
+ if (show_ng) {
+ vty_out(vty, " Nexthop Group ID: %u\n", re->nhe_id);
+ if (re->nhe_installed_id != 0
+ && re->nhe_id != re->nhe_installed_id)
+ vty_out(vty,
+ " Installed Nexthop Group ID: %u\n",
+ re->nhe_installed_id);
+ }
+
+ for (ALL_NEXTHOPS(re->nhe->nhg, nexthop)) {
+ /* Use helper to format each nexthop */
+ show_nexthop_detail_helper(vty, re, nexthop,
+ false /*not backup*/);
+ vty_out(vty, "\n");
+
+ /* Include backup(s), if present */
+ if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP))
+ show_nh_backup_helper(vty, re, nexthop);
+ }
+ zebra_show_ip_route_opaque(vty, re, NULL);
+
+ vty_out(vty, "\n");
+ }
+}
+
+static void vty_show_ip_route(struct vty *vty, struct route_node *rn,
+ struct route_entry *re, json_object *json,
+ bool is_fib, bool show_ng)
+{
+ const struct nexthop *nexthop;
+ int len = 0;
+ char buf[SRCDEST2STR_BUFFER];
+ json_object *json_nexthops = NULL;
+ json_object *json_nexthop = NULL;
+ json_object *json_route = NULL;
+ const rib_dest_t *dest = rib_dest_from_rnode(rn);
+ const struct nexthop_group *nhg;
+ char up_str[MONOTIME_STRLEN];
+ bool first_p = true;
+ bool nhg_from_backup = false;
+
+ uptime2str(re->uptime, up_str, sizeof(up_str));
+
+ /* If showing fib information, use the fib view of the
+ * nexthops.
+ */
+ if (is_fib)
+ nhg = rib_get_fib_nhg(re);
+ else
+ nhg = &(re->nhe->nhg);
+
+ if (json) {
+ json_route = json_object_new_object();
+ json_nexthops = json_object_new_array();
+
+ json_object_string_add(json_route, "prefix",
+ srcdest_rnode2str(rn, buf, sizeof(buf)));
+ json_object_int_add(json_route, "prefixLen", rn->p.prefixlen);
+ json_object_string_add(json_route, "protocol",
+ zebra_route_string(re->type));
+
+ if (re->instance)
+ json_object_int_add(json_route, "instance",
+ re->instance);
+
+ json_object_int_add(json_route, "vrfId", re->vrf_id);
+ json_object_string_add(json_route, "vrfName",
+ vrf_id_to_name(re->vrf_id));
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
+ json_object_boolean_true_add(json_route, "selected");
+
+ if (dest->selected_fib == re)
+ json_object_boolean_true_add(json_route,
+ "destSelected");
+
+ json_object_int_add(json_route, "distance",
+ re->distance);
+ json_object_int_add(json_route, "metric", re->metric);
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED))
+ json_object_boolean_true_add(json_route, "installed");
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_FAILED))
+ json_object_boolean_true_add(json_route, "failed");
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_QUEUED))
+ json_object_boolean_true_add(json_route, "queued");
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_TRAPPED))
+ json_object_boolean_true_add(json_route, "trapped");
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_OFFLOADED))
+ json_object_boolean_true_add(json_route, "offloaded");
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_OFFLOAD_FAILED))
+ json_object_boolean_false_add(json_route, "offloaded");
+
+ if (re->tag)
+ json_object_int_add(json_route, "tag", re->tag);
+
+ if (re->table)
+ json_object_int_add(json_route, "table", re->table);
+
+ json_object_int_add(json_route, "internalStatus",
+ re->status);
+ json_object_int_add(json_route, "internalFlags",
+ re->flags);
+ json_object_int_add(json_route, "internalNextHopNum",
+ nexthop_group_nexthop_num(&(re->nhe->nhg)));
+ json_object_int_add(json_route, "internalNextHopActiveNum",
+ nexthop_group_active_nexthop_num(
+ &(re->nhe->nhg)));
+ json_object_int_add(json_route, "nexthopGroupId", re->nhe_id);
+
+ if (re->nhe_installed_id != 0)
+ json_object_int_add(json_route,
+ "installedNexthopGroupId",
+ re->nhe_installed_id);
+
+ json_object_string_add(json_route, "uptime", up_str);
+
+ for (ALL_NEXTHOPS_PTR(nhg, nexthop)) {
+ json_nexthop = json_object_new_object();
+ show_nexthop_json_helper(json_nexthop,
+ nexthop, re);
+
+ json_object_array_add(json_nexthops,
+ json_nexthop);
+ }
+
+ json_object_object_add(json_route, "nexthops", json_nexthops);
+
+ /* If there are backup nexthops, include them */
+ if (is_fib)
+ nhg = rib_get_fib_backup_nhg(re);
+ else
+ nhg = zebra_nhg_get_backup_nhg(re->nhe);
+
+ if (nhg && nhg->nexthop) {
+ json_nexthops = json_object_new_array();
+
+ for (ALL_NEXTHOPS_PTR(nhg, nexthop)) {
+ json_nexthop = json_object_new_object();
+
+ show_nexthop_json_helper(json_nexthop,
+ nexthop, re);
+ json_object_array_add(json_nexthops,
+ json_nexthop);
+ }
+
+ json_object_object_add(json_route, "backupNexthops",
+ json_nexthops);
+ }
+ zebra_show_ip_route_opaque(NULL, re, json_route);
+
+ json_object_array_add(json, json_route);
+ return;
+ }
+
+ /* Prefix information, and first nexthop. If we're showing 'fib',
+ * and there are no installed primary nexthops, see if there are any
+ * backup nexthops and start with those.
+ */
+ if (is_fib && nhg->nexthop == NULL) {
+ nhg = rib_get_fib_backup_nhg(re);
+ nhg_from_backup = true;
+ }
+
+ len = vty_out(vty, "%c", zebra_route_char(re->type));
+ if (re->instance)
+ len += vty_out(vty, "[%d]", re->instance);
+ if (nhg_from_backup && nhg->nexthop) {
+ len += vty_out(
+ vty, "%cb%c %s",
+ CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED) ? '>' : ' ',
+ re_status_output_char(re, nhg->nexthop, is_fib),
+ srcdest_rnode2str(rn, buf, sizeof(buf)));
+ } else {
+ len += vty_out(
+ vty, "%c%c %s",
+ CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED) ? '>' : ' ',
+ re_status_output_char(re, nhg->nexthop, is_fib),
+ srcdest_rnode2str(rn, buf, sizeof(buf)));
+ }
+
+ /* Distance and metric display. */
+ if (((re->type == ZEBRA_ROUTE_CONNECT) &&
+ (re->distance || re->metric)) ||
+ (re->type != ZEBRA_ROUTE_CONNECT))
+ len += vty_out(vty, " [%u/%u]", re->distance,
+ re->metric);
+
+ if (show_ng)
+ len += vty_out(vty, " (%u)", re->nhe_id);
+
+ /* Nexthop information. */
+ for (ALL_NEXTHOPS_PTR(nhg, nexthop)) {
+ if (first_p) {
+ first_p = false;
+ } else if (nhg_from_backup) {
+ vty_out(vty, " b%c%*c",
+ re_status_output_char(re, nexthop, is_fib),
+ len - 3 + (2 * nexthop_level(nexthop)), ' ');
+ } else {
+ vty_out(vty, " %c%*c",
+ re_status_output_char(re, nexthop, is_fib),
+ len - 3 + (2 * nexthop_level(nexthop)), ' ');
+ }
+
+ show_route_nexthop_helper(vty, re, nexthop);
+ vty_out(vty, ", %s\n", up_str);
+ }
+
+ /* If we only had backup nexthops, we're done */
+ if (nhg_from_backup)
+ return;
+
+ /* Check for backup nexthop info if present */
+ if (is_fib)
+ nhg = rib_get_fib_backup_nhg(re);
+ else
+ nhg = zebra_nhg_get_backup_nhg(re->nhe);
+
+ if (nhg == NULL)
+ return;
+
+ /* Print backup info */
+ for (ALL_NEXTHOPS_PTR(nhg, nexthop)) {
+ bool star_p = false;
+
+ if (is_fib)
+ star_p = CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
+
+ /* TODO -- it'd be nice to be able to include
+ * the entire list of backups, *and* include the
+ * real installation state.
+ */
+ vty_out(vty, " b%c %*c",
+ (star_p ? '*' : ' '),
+ len - 3 + (2 * nexthop_level(nexthop)), ' ');
+ show_route_nexthop_helper(vty, re, nexthop);
+ vty_out(vty, "\n");
+ }
+
+}
+
+static void vty_show_ip_route_detail_json(struct vty *vty,
+ struct route_node *rn, bool use_fib)
+{
+ json_object *json = NULL;
+ json_object *json_prefix = NULL;
+ struct route_entry *re;
+ char buf[BUFSIZ];
+ rib_dest_t *dest;
+
+ dest = rib_dest_from_rnode(rn);
+
+ json = json_object_new_object();
+ json_prefix = json_object_new_array();
+
+ RNODE_FOREACH_RE (rn, re) {
+ /*
+ * If re not selected for forwarding, skip re
+ * for "show ip/ipv6 fib <prefix> json"
+ */
+ if (use_fib && re != dest->selected_fib)
+ continue;
+ vty_show_ip_route(vty, rn, re, json_prefix, use_fib, false);
+ }
+
+ prefix2str(&rn->p, buf, sizeof(buf));
+ json_object_object_add(json, buf, json_prefix);
+ vty_json(vty, json);
+}
+
+static void do_show_route_helper(struct vty *vty, struct zebra_vrf *zvrf,
+ struct route_table *table, afi_t afi,
+ bool use_fib, route_tag_t tag,
+ const struct prefix *longer_prefix_p,
+ bool supernets_only, int type,
+ unsigned short ospf_instance_id, bool use_json,
+ uint32_t tableid, bool show_ng,
+ struct route_show_ctx *ctx)
+{
+ struct route_node *rn;
+ struct route_entry *re;
+ int first = 1;
+ rib_dest_t *dest;
+ json_object *json = NULL;
+ json_object *json_prefix = NULL;
+ uint32_t addr;
+ char buf[BUFSIZ];
+
+ /*
+ * ctx->multi indicates if we are dumping multiple tables or vrfs.
+ * if set:
+ * => display the common header at most once
+ * => add newline at each call except first
+ * => always display the VRF and table
+ * else:
+ * => display the common header if at least one entry is found
+ * => display the VRF and table if specific
+ */
+
+ if (use_json)
+ json = json_object_new_object();
+
+ /* Show all routes. */
+ for (rn = route_top(table); rn; rn = srcdest_route_next(rn)) {
+ dest = rib_dest_from_rnode(rn);
+
+ RNODE_FOREACH_RE (rn, re) {
+ if (use_fib && re != dest->selected_fib)
+ continue;
+
+ if (tag && re->tag != tag)
+ continue;
+
+ if (longer_prefix_p
+ && !prefix_match(longer_prefix_p, &rn->p))
+ continue;
+
+ /* This can only be true when the afi is IPv4 */
+ if (supernets_only) {
+ addr = ntohl(rn->p.u.prefix4.s_addr);
+
+ if (IN_CLASSC(addr) && rn->p.prefixlen >= 24)
+ continue;
+
+ if (IN_CLASSB(addr) && rn->p.prefixlen >= 16)
+ continue;
+
+ if (IN_CLASSA(addr) && rn->p.prefixlen >= 8)
+ continue;
+ }
+
+ if (type && re->type != type)
+ continue;
+
+ if (ospf_instance_id
+ && (re->type != ZEBRA_ROUTE_OSPF
+ || re->instance != ospf_instance_id))
+ continue;
+
+ if (use_json) {
+ if (!json_prefix)
+ json_prefix = json_object_new_array();
+ } else if (first) {
+ if (!ctx->header_done) {
+ if (afi == AFI_IP)
+ vty_out(vty,
+ SHOW_ROUTE_V4_HEADER);
+ else
+ vty_out(vty,
+ SHOW_ROUTE_V6_HEADER);
+ }
+ if (ctx->multi && ctx->header_done)
+ vty_out(vty, "\n");
+ if (ctx->multi || zvrf_id(zvrf) != VRF_DEFAULT
+ || tableid) {
+ if (!tableid)
+ vty_out(vty, "VRF %s:\n",
+ zvrf_name(zvrf));
+ else
+ vty_out(vty,
+ "VRF %s table %u:\n",
+ zvrf_name(zvrf),
+ tableid);
+ }
+ ctx->header_done = true;
+ first = 0;
+ }
+
+ vty_show_ip_route(vty, rn, re, json_prefix, use_fib,
+ show_ng);
+ }
+
+ if (json_prefix) {
+ prefix2str(&rn->p, buf, sizeof(buf));
+ json_object_object_add(json, buf, json_prefix);
+ json_prefix = NULL;
+ }
+ }
+
+ /*
+ * This is an extremely expensive operation at scale
+ * and non-pretty reduces memory footprint significantly.
+ */
+ if (use_json)
+ vty_json_no_pretty(vty, json);
+}
+
+static void do_show_ip_route_all(struct vty *vty, struct zebra_vrf *zvrf,
+ afi_t afi, bool use_fib, bool use_json,
+ route_tag_t tag,
+ const struct prefix *longer_prefix_p,
+ bool supernets_only, int type,
+ unsigned short ospf_instance_id, bool show_ng,
+ struct route_show_ctx *ctx)
+{
+ struct zebra_router_table *zrt;
+ struct rib_table_info *info;
+
+ RB_FOREACH (zrt, zebra_router_table_head,
+ &zrouter.tables) {
+ info = route_table_get_info(zrt->table);
+
+ if (zvrf != info->zvrf)
+ continue;
+ if (zrt->afi != afi ||
+ zrt->safi != SAFI_UNICAST)
+ continue;
+
+ do_show_ip_route(vty, zvrf_name(zvrf), afi, SAFI_UNICAST,
+ use_fib, use_json, tag, longer_prefix_p,
+ supernets_only, type, ospf_instance_id,
+ zrt->tableid, show_ng, ctx);
+ }
+}
+
+static int do_show_ip_route(struct vty *vty, const char *vrf_name, afi_t afi,
+ safi_t safi, bool use_fib, bool use_json,
+ route_tag_t tag,
+ const struct prefix *longer_prefix_p,
+ bool supernets_only, int type,
+ unsigned short ospf_instance_id, uint32_t tableid,
+ bool show_ng, struct route_show_ctx *ctx)
+{
+ struct route_table *table;
+ struct zebra_vrf *zvrf = NULL;
+
+ if (!(zvrf = zebra_vrf_lookup_by_name(vrf_name))) {
+ if (use_json)
+ vty_out(vty, "{}\n");
+ else
+ vty_out(vty, "vrf %s not defined\n", vrf_name);
+ return CMD_SUCCESS;
+ }
+
+ if (zvrf_id(zvrf) == VRF_UNKNOWN) {
+ if (use_json)
+ vty_out(vty, "{}\n");
+ else
+ vty_out(vty, "vrf %s inactive\n", vrf_name);
+ return CMD_SUCCESS;
+ }
+
+ if (tableid)
+ table = zebra_router_find_table(zvrf, tableid, afi, SAFI_UNICAST);
+ else
+ table = zebra_vrf_table(afi, safi, zvrf_id(zvrf));
+ if (!table) {
+ if (use_json)
+ vty_out(vty, "{}\n");
+ return CMD_SUCCESS;
+ }
+
+ do_show_route_helper(vty, zvrf, table, afi, use_fib, tag,
+ longer_prefix_p, supernets_only, type,
+ ospf_instance_id, use_json, tableid, show_ng, ctx);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_ip_nht,
+ show_ip_nht_cmd,
+ "show <ip$ipv4|ipv6$ipv6> <nht|import-check>$type [<A.B.C.D|X:X::X:X>$addr|vrf NAME$vrf_name [<A.B.C.D|X:X::X:X>$addr]|vrf all$vrf_all] [mrib$mrib] [json]",
+ SHOW_STR
+ IP_STR
+ IP6_STR
+ "IP nexthop tracking table\n"
+ "IP import check tracking table\n"
+ "IPv4 Address\n"
+ "IPv6 Address\n"
+ VRF_CMD_HELP_STR
+ "IPv4 Address\n"
+ "IPv6 Address\n"
+ VRF_ALL_CMD_HELP_STR
+ "Show Multicast (MRIB) NHT state\n"
+ JSON_STR)
+{
+ afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
+ vrf_id_t vrf_id = VRF_DEFAULT;
+ struct prefix prefix, *p = NULL;
+ safi_t safi = mrib ? SAFI_MULTICAST : SAFI_UNICAST;
+ bool uj = use_json(argc, argv);
+ json_object *json = NULL;
+ json_object *json_vrf = NULL;
+ json_object *json_nexthop = NULL;
+ struct zebra_vrf *zvrf;
+ bool resolve_via_default = false;
+
+ if (uj)
+ json = json_object_new_object();
+
+ if (vrf_all) {
+ struct vrf *vrf;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if ((zvrf = vrf->info) != NULL) {
+ resolve_via_default =
+ (afi == AFI_IP)
+ ? zvrf->zebra_rnh_ip_default_route
+ : zvrf->zebra_rnh_ipv6_default_route;
+
+ if (uj) {
+ json_vrf = json_object_new_object();
+ json_nexthop = json_object_new_object();
+ json_object_object_add(json,
+ zvrf_name(zvrf),
+ json_vrf);
+ json_object_object_add(json_vrf,
+ (afi == AFI_IP)
+ ? "ipv4"
+ : "ipv6",
+ json_nexthop);
+ json_object_boolean_add(json_nexthop,
+ "resolveViaDefault",
+ resolve_via_default);
+ } else {
+ vty_out(vty, "\nVRF %s:\n",
+ zvrf_name(zvrf));
+ vty_out(vty,
+ " Resolve via default: %s\n",
+ resolve_via_default ? "on"
+ : "off");
+ }
+ zebra_print_rnh_table(zvrf_id(zvrf), afi, safi,
+ vty, NULL, json_nexthop);
+ }
+ }
+
+ if (uj)
+ vty_json(vty, json);
+
+ return CMD_SUCCESS;
+ }
+ if (vrf_name)
+ VRF_GET_ID(vrf_id, vrf_name, false);
+
+ memset(&prefix, 0, sizeof(prefix));
+ if (addr) {
+ p = sockunion2hostprefix(addr, &prefix);
+ if (!p) {
+ if (uj)
+ json_object_free(json);
+ return CMD_WARNING;
+ }
+ }
+
+ zvrf = zebra_vrf_lookup_by_id(vrf_id);
+ resolve_via_default = (afi == AFI_IP)
+ ? zvrf->zebra_rnh_ip_default_route
+ : zvrf->zebra_rnh_ipv6_default_route;
+
+ if (uj) {
+ json_vrf = json_object_new_object();
+ json_nexthop = json_object_new_object();
+ if (vrf_name)
+ json_object_object_add(json, vrf_name, json_vrf);
+ else
+ json_object_object_add(json, "default", json_vrf);
+
+ json_object_object_add(json_vrf,
+ (afi == AFI_IP) ? "ipv4" : "ipv6",
+ json_nexthop);
+
+ json_object_boolean_add(json_nexthop, "resolveViaDefault",
+ resolve_via_default);
+ } else {
+ vty_out(vty, "VRF %s:\n", zvrf_name(zvrf));
+ vty_out(vty, " Resolve via default: %s\n",
+ resolve_via_default ? "on" : "off");
+ }
+
+ zebra_print_rnh_table(vrf_id, afi, safi, vty, p, json_nexthop);
+
+ if (uj)
+ vty_json(vty, json);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (ip_nht_default_route,
+ ip_nht_default_route_cmd,
+ "ip nht resolve-via-default",
+ IP_STR
+ "Filter Next Hop tracking route resolution\n"
+ "Resolve via default route\n")
+{
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ if (!zvrf)
+ return CMD_WARNING;
+
+ if (zvrf->zebra_rnh_ip_default_route)
+ return CMD_SUCCESS;
+
+ zvrf->zebra_rnh_ip_default_route = true;
+
+ zebra_evaluate_rnh(zvrf, AFI_IP, 0, NULL, SAFI_UNICAST);
+ return CMD_SUCCESS;
+}
+
+static void show_nexthop_group_out(struct vty *vty, struct nhg_hash_entry *nhe,
+ json_object *json_nhe_hdr)
+{
+ struct nexthop *nexthop = NULL;
+ struct nhg_connected *rb_node_dep = NULL;
+ struct nexthop_group *backup_nhg;
+ char up_str[MONOTIME_STRLEN];
+ char time_left[MONOTIME_STRLEN];
+ json_object *json_dependants = NULL;
+ json_object *json_depends = NULL;
+ json_object *json_nexthop_array = NULL;
+ json_object *json_nexthops = NULL;
+ json_object *json = NULL;
+ json_object *json_backup_nexthop_array = NULL;
+ json_object *json_backup_nexthops = NULL;
+
+
+ uptime2str(nhe->uptime, up_str, sizeof(up_str));
+
+ if (json_nhe_hdr)
+ json = json_object_new_object();
+
+ if (json) {
+ json_object_string_add(json, "type",
+ zebra_route_string(nhe->type));
+ json_object_int_add(json, "refCount", nhe->refcnt);
+ if (event_is_scheduled(nhe->timer))
+ json_object_string_add(
+ json, "timeToDeletion",
+ event_timer_to_hhmmss(time_left,
+ sizeof(time_left),
+ nhe->timer));
+ json_object_string_add(json, "uptime", up_str);
+ json_object_string_add(json, "vrf",
+ vrf_id_to_name(nhe->vrf_id));
+
+ } else {
+ vty_out(vty, "ID: %u (%s)\n", nhe->id,
+ zebra_route_string(nhe->type));
+ vty_out(vty, " RefCnt: %u", nhe->refcnt);
+ if (event_is_scheduled(nhe->timer))
+ vty_out(vty, " Time to Deletion: %s",
+ event_timer_to_hhmmss(time_left,
+ sizeof(time_left),
+ nhe->timer));
+ vty_out(vty, "\n");
+
+ vty_out(vty, " Uptime: %s\n", up_str);
+ vty_out(vty, " VRF: %s\n", vrf_id_to_name(nhe->vrf_id));
+ }
+
+ if (CHECK_FLAG(nhe->flags, NEXTHOP_GROUP_VALID)) {
+ if (json)
+ json_object_boolean_true_add(json, "valid");
+ else
+ vty_out(vty, " Valid");
+
+ if (CHECK_FLAG(nhe->flags, NEXTHOP_GROUP_INSTALLED)) {
+ if (json)
+ json_object_boolean_true_add(json, "installed");
+ else
+ vty_out(vty, ", Installed");
+ }
+ if (!json)
+ vty_out(vty, "\n");
+ }
+ if (nhe->ifp) {
+ if (json)
+ json_object_int_add(json, "interfaceIndex",
+ nhe->ifp->ifindex);
+ else
+ vty_out(vty, " Interface Index: %d\n",
+ nhe->ifp->ifindex);
+ }
+
+ if (!zebra_nhg_depends_is_empty(nhe)) {
+ if (json)
+ json_depends = json_object_new_array();
+ else
+ vty_out(vty, " Depends:");
+ frr_each(nhg_connected_tree, &nhe->nhg_depends, rb_node_dep) {
+ if (json_depends)
+ json_object_array_add(
+ json_depends,
+ json_object_new_int(
+ rb_node_dep->nhe->id));
+ else
+ vty_out(vty, " (%u)", rb_node_dep->nhe->id);
+ }
+ if (!json_depends)
+ vty_out(vty, "\n");
+ else
+ json_object_object_add(json, "depends", json_depends);
+ }
+
+ /* Output nexthops */
+ if (json)
+ json_nexthop_array = json_object_new_array();
+
+
+ for (ALL_NEXTHOPS(nhe->nhg, nexthop)) {
+ if (json_nexthop_array) {
+ json_nexthops = json_object_new_object();
+ show_nexthop_json_helper(json_nexthops, nexthop, NULL);
+ } else {
+ if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
+ vty_out(vty, " ");
+ else
+ /* Make recursive nexthops a bit more clear */
+ vty_out(vty, " ");
+ show_route_nexthop_helper(vty, NULL, nexthop);
+ }
+
+ if (nhe->backup_info == NULL || nhe->backup_info->nhe == NULL) {
+ if (CHECK_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_HAS_BACKUP)) {
+ if (json)
+ json_object_int_add(
+ json_nexthops, "backup",
+ nexthop->backup_idx[0]);
+ else
+ vty_out(vty, " [backup %d]",
+ nexthop->backup_idx[0]);
+ }
+
+ if (!json)
+ vty_out(vty, "\n");
+ else
+ json_object_array_add(json_nexthop_array,
+ json_nexthops);
+
+ continue;
+ }
+
+ if (!json) {
+ /* TODO -- print more useful backup info */
+ if (CHECK_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_HAS_BACKUP)) {
+ int i;
+
+ vty_out(vty, "[backup");
+ for (i = 0; i < nexthop->backup_num; i++)
+ vty_out(vty, " %d",
+ nexthop->backup_idx[i]);
+ vty_out(vty, "]");
+ }
+ vty_out(vty, "\n");
+ } else {
+ json_object_array_add(json_nexthop_array,
+ json_nexthops);
+ }
+ }
+
+ if (json)
+ json_object_object_add(json, "nexthops", json_nexthop_array);
+
+ /* Output backup nexthops (if any) */
+ backup_nhg = zebra_nhg_get_backup_nhg(nhe);
+ if (backup_nhg) {
+ if (json)
+ json_backup_nexthop_array = json_object_new_array();
+ else
+ vty_out(vty, " Backups:\n");
+
+ for (ALL_NEXTHOPS_PTR(backup_nhg, nexthop)) {
+ if (json_backup_nexthop_array) {
+ json_backup_nexthops = json_object_new_object();
+ show_nexthop_json_helper(json_backup_nexthops,
+ nexthop, NULL);
+ json_object_array_add(json_backup_nexthop_array,
+ json_backup_nexthops);
+ } else {
+
+ if (!CHECK_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_RECURSIVE))
+ vty_out(vty, " ");
+ else
+ /* Make recursive nexthops a bit more
+ * clear
+ */
+ vty_out(vty, " ");
+ show_route_nexthop_helper(vty, NULL, nexthop);
+ vty_out(vty, "\n");
+ }
+ }
+
+ if (json)
+ json_object_object_add(json, "backupNexthops",
+ json_backup_nexthop_array);
+ }
+
+ if (!zebra_nhg_dependents_is_empty(nhe)) {
+ if (json)
+ json_dependants = json_object_new_array();
+ else
+ vty_out(vty, " Dependents:");
+ frr_each(nhg_connected_tree, &nhe->nhg_dependents,
+ rb_node_dep) {
+ if (json)
+ json_object_array_add(
+ json_dependants,
+ json_object_new_int(
+ rb_node_dep->nhe->id));
+ else
+ vty_out(vty, " (%u)", rb_node_dep->nhe->id);
+ }
+ if (json)
+ json_object_object_add(json, "dependents",
+ json_dependants);
+ else
+ vty_out(vty, "\n");
+ }
+
+ if (nhe->nhg.nhgr.buckets) {
+ if (json) {
+ json_object_int_add(json, "buckets",
+ nhe->nhg.nhgr.buckets);
+ json_object_int_add(json, "idleTimer",
+ nhe->nhg.nhgr.idle_timer);
+ json_object_int_add(json, "unbalancedTimer",
+ nhe->nhg.nhgr.unbalanced_timer);
+ json_object_int_add(json, "unbalancedTime",
+ nhe->nhg.nhgr.unbalanced_time);
+ } else {
+ vty_out(vty,
+ " Buckets: %u Idle Timer: %u Unbalanced Timer: %u Unbalanced time: %" PRIu64
+ "\n",
+ nhe->nhg.nhgr.buckets, nhe->nhg.nhgr.idle_timer,
+ nhe->nhg.nhgr.unbalanced_timer,
+ nhe->nhg.nhgr.unbalanced_time);
+ }
+ }
+
+ if (json_nhe_hdr)
+ json_object_object_addf(json_nhe_hdr, json, "%u", nhe->id);
+}
+
+static int show_nexthop_group_id_cmd_helper(struct vty *vty, uint32_t id,
+ json_object *json)
+{
+ struct nhg_hash_entry *nhe = NULL;
+
+ nhe = zebra_nhg_lookup_id(id);
+
+ if (nhe)
+ show_nexthop_group_out(vty, nhe, json);
+ else {
+ if (json)
+ vty_json(vty, json);
+ else
+ vty_out(vty, "Nexthop Group ID: %u does not exist\n",
+ id);
+ return CMD_WARNING;
+ }
+
+ if (json)
+ vty_json(vty, json);
+
+ return CMD_SUCCESS;
+}
+
+/* Helper function for iteration through the hash of nexthop-groups/nhe-s */
+
+struct nhe_show_context {
+ struct vty *vty;
+ vrf_id_t vrf_id;
+ afi_t afi;
+ int type;
+ json_object *json;
+};
+
+static int nhe_show_walker(struct hash_bucket *bucket, void *arg)
+{
+ struct nhe_show_context *ctx = arg;
+ struct nhg_hash_entry *nhe;
+
+ nhe = bucket->data; /* We won't be offered NULL buckets */
+
+ if (ctx->afi && nhe->afi != ctx->afi)
+ goto done;
+
+ if (ctx->vrf_id && nhe->vrf_id != ctx->vrf_id)
+ goto done;
+
+ if (ctx->type && nhe->type != ctx->type)
+ goto done;
+
+ show_nexthop_group_out(ctx->vty, nhe, ctx->json);
+
+done:
+ return HASHWALK_CONTINUE;
+}
+
+static void show_nexthop_group_cmd_helper(struct vty *vty,
+ struct zebra_vrf *zvrf, afi_t afi,
+ int type, json_object *json)
+{
+ struct nhe_show_context ctx;
+
+ ctx.vty = vty;
+ ctx.afi = afi;
+ ctx.vrf_id = zvrf->vrf->vrf_id;
+ ctx.type = type;
+ ctx.json = json;
+
+ hash_walk(zrouter.nhgs_id, nhe_show_walker, &ctx);
+}
+
+static void if_nexthop_group_dump_vty(struct vty *vty, struct interface *ifp)
+{
+ struct zebra_if *zebra_if = NULL;
+ struct nhg_connected *rb_node_dep = NULL;
+
+ zebra_if = ifp->info;
+
+ if (!if_nhg_dependents_is_empty(ifp)) {
+ vty_out(vty, "Interface %s:\n", ifp->name);
+
+ frr_each(nhg_connected_tree, &zebra_if->nhg_dependents,
+ rb_node_dep) {
+ vty_out(vty, " ");
+ show_nexthop_group_out(vty, rb_node_dep->nhe, NULL);
+ }
+ }
+}
+
+DEFPY (show_interface_nexthop_group,
+ show_interface_nexthop_group_cmd,
+ "show interface [IFNAME$if_name] nexthop-group",
+ SHOW_STR
+ "Interface status and configuration\n"
+ "Interface name\n"
+ "Show Nexthop Groups\n")
+{
+ struct vrf *vrf = NULL;
+ struct interface *ifp = NULL;
+ bool found = false;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if (if_name) {
+ ifp = if_lookup_by_name(if_name, vrf->vrf_id);
+ if (ifp) {
+ if_nexthop_group_dump_vty(vty, ifp);
+ found = true;
+ }
+ } else {
+ FOR_ALL_INTERFACES (vrf, ifp)
+ if_nexthop_group_dump_vty(vty, ifp);
+ found = true;
+ }
+ }
+
+ if (!found) {
+ vty_out(vty, "%% Can't find interface %s\n", if_name);
+ return CMD_WARNING;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_nexthop_group,
+ show_nexthop_group_cmd,
+ "show nexthop-group rib <(0-4294967295)$id|[singleton <ip$v4|ipv6$v6>] [<kernel|zebra|bgp|sharp>$type_str] [vrf <NAME$vrf_name|all$vrf_all>]> [json]",
+ SHOW_STR
+ "Show Nexthop Groups\n"
+ "RIB information\n"
+ "Nexthop Group ID\n"
+ "Show Singleton Nexthop-Groups\n"
+ IP_STR
+ IP6_STR
+ "Kernel (not installed via the zebra RIB)\n"
+ "Zebra (implicitly created by zebra)\n"
+ "Border Gateway Protocol (BGP)\n"
+ "Super Happy Advanced Routing Protocol (SHARP)\n"
+ VRF_FULL_CMD_HELP_STR
+ JSON_STR)
+{
+
+ struct zebra_vrf *zvrf = NULL;
+ afi_t afi = AFI_UNSPEC;
+ int type = 0;
+ bool uj = use_json(argc, argv);
+ json_object *json = NULL;
+ json_object *json_vrf = NULL;
+
+ if (uj)
+ json = json_object_new_object();
+
+ if (id)
+ return show_nexthop_group_id_cmd_helper(vty, id, json);
+
+ if (v4)
+ afi = AFI_IP;
+ else if (v6)
+ afi = AFI_IP6;
+
+ if (type_str) {
+ type = proto_redistnum((afi ? afi : AFI_IP), type_str);
+ if (type < 0) {
+ /* assume zebra */
+ type = ZEBRA_ROUTE_NHG;
+ }
+ }
+
+ if (!vrf_is_backend_netns() && (vrf_name || vrf_all)) {
+ if (uj)
+ vty_json(vty, json);
+ else
+ vty_out(vty,
+ "VRF subcommand does not make any sense in l3mdev based vrf's\n");
+ return CMD_WARNING;
+ }
+
+ if (vrf_all) {
+ struct vrf *vrf;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ struct zebra_vrf *zvrf;
+
+ zvrf = vrf->info;
+ if (!zvrf)
+ continue;
+ if (uj)
+ json_vrf = json_object_new_object();
+ else
+ vty_out(vty, "VRF: %s\n", vrf->name);
+
+ show_nexthop_group_cmd_helper(vty, zvrf, afi, type,
+ json_vrf);
+ if (uj)
+ json_object_object_add(json, vrf->name,
+ json_vrf);
+ }
+
+ if (uj)
+ vty_json(vty, json);
+
+ return CMD_SUCCESS;
+ }
+
+ if (vrf_name)
+ zvrf = zebra_vrf_lookup_by_name(vrf_name);
+ else
+ zvrf = zebra_vrf_lookup_by_name(VRF_DEFAULT_NAME);
+
+ if (!zvrf) {
+ if (uj)
+ vty_json(vty, json);
+ else
+ vty_out(vty, "%% VRF '%s' specified does not exist\n",
+ vrf_name);
+ return CMD_WARNING;
+ }
+
+ show_nexthop_group_cmd_helper(vty, zvrf, afi, type, json);
+
+ if (uj)
+ vty_json(vty, json);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY_HIDDEN(nexthop_group_use_enable,
+ nexthop_group_use_enable_cmd,
+ "[no] zebra nexthop kernel enable",
+ NO_STR
+ ZEBRA_STR
+ "Nexthop configuration \n"
+ "Configure use of kernel nexthops\n"
+ "Enable kernel nexthops\n")
+{
+ zebra_nhg_enable_kernel_nexthops(!no);
+ return CMD_SUCCESS;
+}
+
+DEFPY_HIDDEN(proto_nexthop_group_only, proto_nexthop_group_only_cmd,
+ "[no] zebra nexthop proto only",
+ NO_STR ZEBRA_STR
+ "Nexthop configuration\n"
+ "Configure exclusive use of proto nexthops\n"
+ "Only use proto nexthops\n")
+{
+ zebra_nhg_set_proto_nexthops_only(!no);
+ return CMD_SUCCESS;
+}
+
+DEFPY_HIDDEN(backup_nexthop_recursive_use_enable,
+ backup_nexthop_recursive_use_enable_cmd,
+ "[no] zebra nexthop resolve-via-backup",
+ NO_STR
+ ZEBRA_STR
+ "Nexthop configuration \n"
+ "Configure use of backup nexthops in recursive resolution\n")
+{
+ zebra_nhg_set_recursive_use_backups(!no);
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ip_nht_default_route,
+ no_ip_nht_default_route_cmd,
+ "no ip nht resolve-via-default",
+ NO_STR
+ IP_STR
+ "Filter Next Hop tracking route resolution\n"
+ "Resolve via default route\n")
+{
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ if (!zvrf)
+ return CMD_WARNING;
+
+ if (!zvrf->zebra_rnh_ip_default_route)
+ return CMD_SUCCESS;
+
+ zvrf->zebra_rnh_ip_default_route = false;
+ zebra_evaluate_rnh(zvrf, AFI_IP, 0, NULL, SAFI_UNICAST);
+ return CMD_SUCCESS;
+}
+
+DEFUN (ipv6_nht_default_route,
+ ipv6_nht_default_route_cmd,
+ "ipv6 nht resolve-via-default",
+ IP6_STR
+ "Filter Next Hop tracking route resolution\n"
+ "Resolve via default route\n")
+{
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ if (!zvrf)
+ return CMD_WARNING;
+
+ if (zvrf->zebra_rnh_ipv6_default_route)
+ return CMD_SUCCESS;
+
+ zvrf->zebra_rnh_ipv6_default_route = true;
+ zebra_evaluate_rnh(zvrf, AFI_IP6, 0, NULL, SAFI_UNICAST);
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ipv6_nht_default_route,
+ no_ipv6_nht_default_route_cmd,
+ "no ipv6 nht resolve-via-default",
+ NO_STR
+ IP6_STR
+ "Filter Next Hop tracking route resolution\n"
+ "Resolve via default route\n")
+{
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ if (!zvrf)
+ return CMD_WARNING;
+
+ if (!zvrf->zebra_rnh_ipv6_default_route)
+ return CMD_SUCCESS;
+
+ zvrf->zebra_rnh_ipv6_default_route = false;
+ zebra_evaluate_rnh(zvrf, AFI_IP6, 0, NULL, SAFI_UNICAST);
+ return CMD_SUCCESS;
+}
+
+DEFPY_HIDDEN(rnh_hide_backups, rnh_hide_backups_cmd,
+ "[no] ip nht hide-backup-events",
+ NO_STR
+ IP_STR
+ "Nexthop-tracking configuration\n"
+ "Hide notification about backup nexthops\n")
+{
+ rnh_set_hide_backups(!no);
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_route,
+ show_route_cmd,
+ "show\
+ <\
+ ip$ipv4 <fib$fib|route> [table <(1-4294967295)$table|all$table_all>]\
+ [vrf <NAME$vrf_name|all$vrf_all>]\
+ [{\
+ tag (1-4294967295)\
+ |A.B.C.D/M$prefix longer-prefixes\
+ |supernets-only$supernets_only\
+ }]\
+ [<\
+ " FRR_IP_REDIST_STR_ZEBRA "$type_str\
+ |ospf$type_str (1-65535)$ospf_instance_id\
+ >]\
+ |ipv6$ipv6 <fib$fib|route> [table <(1-4294967295)$table|all$table_all>]\
+ [vrf <NAME$vrf_name|all$vrf_all>]\
+ [{\
+ tag (1-4294967295)\
+ |X:X::X:X/M$prefix longer-prefixes\
+ }]\
+ [" FRR_IP6_REDIST_STR_ZEBRA "$type_str]\
+ >\
+ [<json$json|nexthop-group$ng>]",
+ SHOW_STR
+ IP_STR
+ "IP forwarding table\n"
+ "IP routing table\n"
+ "Table to display\n"
+ "The table number to display\n"
+ "All tables\n"
+ VRF_FULL_CMD_HELP_STR
+ "Show only routes with tag\n"
+ "Tag value\n"
+ "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
+ "Show route matching the specified Network/Mask pair only\n"
+ "Show supernet entries only\n"
+ FRR_IP_REDIST_HELP_STR_ZEBRA
+ "Open Shortest Path First (OSPFv2)\n"
+ "Instance ID\n"
+ IPV6_STR
+ "IP forwarding table\n"
+ "IP routing table\n"
+ "Table to display\n"
+ "The table number to display\n"
+ "All tables\n"
+ VRF_FULL_CMD_HELP_STR
+ "Show only routes with tag\n"
+ "Tag value\n"
+ "IPv6 prefix\n"
+ "Show route matching the specified Network/Mask pair only\n"
+ FRR_IP6_REDIST_HELP_STR_ZEBRA
+ JSON_STR
+ "Nexthop Group Information\n")
+{
+ afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
+ struct vrf *vrf;
+ int type = 0;
+ struct zebra_vrf *zvrf;
+ struct route_show_ctx ctx = {
+ .multi = vrf_all || table_all,
+ };
+
+ if (!vrf_is_backend_netns()) {
+ if ((vrf_all || vrf_name) && (table || table_all)) {
+ if (!!json)
+ vty_out(vty, "{}\n");
+ else {
+ vty_out(vty, "Linux vrf backend already points to table id\n");
+ vty_out(vty, "Either remove table parameter or vrf parameter\n");
+ }
+ return CMD_SUCCESS;
+ }
+ }
+ if (type_str) {
+ type = proto_redistnum(afi, type_str);
+ if (type < 0) {
+ vty_out(vty, "Unknown route type\n");
+ return CMD_WARNING;
+ }
+ }
+
+ if (vrf_all) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if ((zvrf = vrf->info) == NULL
+ || (zvrf->table[afi][SAFI_UNICAST] == NULL))
+ continue;
+
+ if (table_all)
+ do_show_ip_route_all(
+ vty, zvrf, afi, !!fib, !!json, tag,
+ prefix_str ? prefix : NULL,
+ !!supernets_only, type,
+ ospf_instance_id, !!ng, &ctx);
+ else
+ do_show_ip_route(
+ vty, zvrf_name(zvrf), afi, SAFI_UNICAST,
+ !!fib, !!json, tag,
+ prefix_str ? prefix : NULL,
+ !!supernets_only, type,
+ ospf_instance_id, table, !!ng, &ctx);
+ }
+ } else {
+ vrf_id_t vrf_id = VRF_DEFAULT;
+
+ if (vrf_name)
+ VRF_GET_ID(vrf_id, vrf_name, !!json);
+ vrf = vrf_lookup_by_id(vrf_id);
+ if (!vrf)
+ return CMD_SUCCESS;
+
+ zvrf = vrf->info;
+ if (!zvrf)
+ return CMD_SUCCESS;
+
+ if (table_all)
+ do_show_ip_route_all(vty, zvrf, afi, !!fib, !!json, tag,
+ prefix_str ? prefix : NULL,
+ !!supernets_only, type,
+ ospf_instance_id, !!ng, &ctx);
+ else
+ do_show_ip_route(vty, vrf->name, afi, SAFI_UNICAST,
+ !!fib, !!json, tag,
+ prefix_str ? prefix : NULL,
+ !!supernets_only, type,
+ ospf_instance_id, table, !!ng, &ctx);
+ }
+
+ return CMD_SUCCESS;
+}
+
+ALIAS_HIDDEN (show_route,
+ show_ro_cmd,
+ "show <ip$ipv4|ipv6$ipv6> ro",
+ SHOW_STR
+ IP_STR
+ IPV6_STR
+ "IP routing table\n");
+
+
+DEFPY (show_route_detail,
+ show_route_detail_cmd,
+ "show\
+ <\
+ ip$ipv4 <fib$fib|route> [vrf <NAME$vrf_name|all$vrf_all>]\
+ <\
+ A.B.C.D$address\
+ |A.B.C.D/M$prefix\
+ >\
+ |ipv6$ipv6 <fib$fib|route> [vrf <NAME$vrf_name|all$vrf_all>]\
+ <\
+ X:X::X:X$address\
+ |X:X::X:X/M$prefix\
+ >\
+ >\
+ [json$json] [nexthop-group$ng]",
+ SHOW_STR
+ IP_STR
+ "IP forwarding table\n"
+ "IP routing table\n"
+ VRF_FULL_CMD_HELP_STR
+ "Network in the IP routing table to display\n"
+ "IP prefix <network>/<length>, e.g., 35.0.0.0/8\n"
+ IP6_STR
+ "IPv6 forwarding table\n"
+ "IPv6 routing table\n"
+ VRF_FULL_CMD_HELP_STR
+ "IPv6 Address\n"
+ "IPv6 prefix\n"
+ JSON_STR
+ "Nexthop Group Information\n")
+{
+ afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
+ struct route_table *table;
+ struct prefix p;
+ struct route_node *rn;
+ bool use_fib = !!fib;
+ rib_dest_t *dest;
+ bool network_found = false;
+ bool show_ng = !!ng;
+
+ if (address_str)
+ prefix_str = address_str;
+ if (str2prefix(prefix_str, &p) < 0) {
+ vty_out(vty, "%% Malformed address\n");
+ return CMD_WARNING;
+ }
+
+ if (vrf_all) {
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if ((zvrf = vrf->info) == NULL
+ || (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
+ continue;
+
+ rn = route_node_match(table, &p);
+ if (!rn)
+ continue;
+ if (!address_str && rn->p.prefixlen != p.prefixlen) {
+ route_unlock_node(rn);
+ continue;
+ }
+
+ dest = rib_dest_from_rnode(rn);
+ if (use_fib && !dest->selected_fib) {
+ route_unlock_node(rn);
+ continue;
+ }
+
+ network_found = true;
+ if (json)
+ vty_show_ip_route_detail_json(vty, rn, use_fib);
+ else
+ vty_show_ip_route_detail(vty, rn, 0, use_fib,
+ show_ng);
+
+ route_unlock_node(rn);
+ }
+
+ if (!network_found) {
+ if (json)
+ vty_out(vty, "{}\n");
+ else {
+ if (use_fib)
+ vty_out(vty,
+ "%% Network not in FIB\n");
+ else
+ vty_out(vty,
+ "%% Network not in RIB\n");
+ }
+ return CMD_WARNING;
+ }
+ } else {
+ vrf_id_t vrf_id = VRF_DEFAULT;
+
+ if (vrf_name)
+ VRF_GET_ID(vrf_id, vrf_name, false);
+
+ table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
+ if (!table)
+ return CMD_SUCCESS;
+
+ rn = route_node_match(table, &p);
+ if (rn)
+ dest = rib_dest_from_rnode(rn);
+
+ if (!rn || (!address_str && rn->p.prefixlen != p.prefixlen) ||
+ (use_fib && dest && !dest->selected_fib)) {
+ if (json)
+ vty_out(vty, "{}\n");
+ else {
+ if (use_fib)
+ vty_out(vty,
+ "%% Network not in FIB\n");
+ else
+ vty_out(vty,
+ "%% Network not in table\n");
+ }
+ if (rn)
+ route_unlock_node(rn);
+ return CMD_WARNING;
+ }
+
+ if (json)
+ vty_show_ip_route_detail_json(vty, rn, use_fib);
+ else
+ vty_show_ip_route_detail(vty, rn, 0, use_fib, show_ng);
+
+ route_unlock_node(rn);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_route_summary,
+ show_route_summary_cmd,
+ "show <ip$ipv4|ipv6$ipv6> route [vrf <NAME$vrf_name|all$vrf_all>] \
+ summary [table (1-4294967295)$table_id] [prefix$prefix] [json]",
+ SHOW_STR
+ IP_STR
+ IP6_STR
+ "IP routing table\n"
+ VRF_FULL_CMD_HELP_STR
+ "Summary of all routes\n"
+ "Table to display summary for\n"
+ "The table number\n"
+ "Prefix routes\n"
+ JSON_STR)
+{
+ afi_t afi = ipv4 ? AFI_IP : AFI_IP6;
+ struct route_table *table;
+ bool uj = use_json(argc, argv);
+
+ if (vrf_all) {
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if ((zvrf = vrf->info) == NULL)
+ continue;
+
+ if (table_id == 0)
+ table = zebra_vrf_table(afi, SAFI_UNICAST,
+ zvrf->vrf->vrf_id);
+ else
+ table = zebra_vrf_lookup_table_with_table_id(
+ afi, SAFI_UNICAST, zvrf->vrf->vrf_id,
+ table_id);
+
+ if (!table)
+ continue;
+
+ if (prefix)
+ vty_show_ip_route_summary_prefix(vty, table,
+ uj);
+ else
+ vty_show_ip_route_summary(vty, table, uj);
+ }
+ } else {
+ vrf_id_t vrf_id = VRF_DEFAULT;
+
+ if (vrf_name)
+ VRF_GET_ID(vrf_id, vrf_name, false);
+
+ if (table_id == 0)
+ table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
+ else
+ table = zebra_vrf_lookup_table_with_table_id(
+ afi, SAFI_UNICAST, vrf_id, table_id);
+ if (!table)
+ return CMD_SUCCESS;
+
+ if (prefix)
+ vty_show_ip_route_summary_prefix(vty, table, uj);
+ else
+ vty_show_ip_route_summary(vty, table, uj);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (show_route_zebra_dump,
+ show_route_zebra_dump_cmd,
+ "show <ip|ipv6> zebra route dump [vrf VRFNAME]",
+ SHOW_STR
+ IP_STR
+ IP6_STR
+ "Zebra daemon\n"
+ "Routing table\n"
+ "All information\n"
+ VRF_CMD_HELP_STR)
+{
+ afi_t afi = AFI_IP;
+ struct route_table *table;
+ const char *vrf_name = NULL;
+ int idx = 0;
+
+ afi = strmatch(argv[1]->text, "ipv6") ? AFI_IP6 : AFI_IP;
+
+ if (argv_find(argv, argc, "vrf", &idx))
+ vrf_name = argv[++idx]->arg;
+
+ if (!vrf_name) {
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ zvrf = vrf->info;
+ if ((zvrf == NULL)
+ || (zvrf->table[afi][SAFI_UNICAST] == NULL))
+ continue;
+
+ table = zvrf->table[afi][SAFI_UNICAST];
+ show_ip_route_dump_vty(vty, table);
+ }
+ } else {
+ vrf_id_t vrf_id = VRF_DEFAULT;
+
+ VRF_GET_ID(vrf_id, vrf_name, true);
+
+ table = zebra_vrf_table(afi, SAFI_UNICAST, vrf_id);
+ if (!table)
+ return CMD_SUCCESS;
+
+ show_ip_route_dump_vty(vty, table);
+ }
+
+ return CMD_SUCCESS;
+}
+
+static void show_ip_route_nht_dump(struct vty *vty, struct nexthop *nexthop,
+ struct route_entry *re, unsigned int num)
+{
+
+ char buf[SRCDEST2STR_BUFFER];
+
+ vty_out(vty, " Nexthop %u:\n", num);
+ vty_out(vty, " type: %u\n", nexthop->type);
+ vty_out(vty, " flags: %u\n", nexthop->flags);
+ switch (nexthop->type) {
+ case NEXTHOP_TYPE_IPV4:
+ case NEXTHOP_TYPE_IPV4_IFINDEX:
+ vty_out(vty, " ip address: %s\n",
+ inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
+ sizeof(buf)));
+ vty_out(vty, " afi: ipv4\n");
+
+ if (nexthop->ifindex) {
+ vty_out(vty, " interface index: %d\n",
+ nexthop->ifindex);
+ vty_out(vty, " interface name: %s\n",
+ ifindex2ifname(nexthop->ifindex,
+ nexthop->vrf_id));
+ }
+
+ if (nexthop->src.ipv4.s_addr
+ && (inet_ntop(AF_INET, &nexthop->src.ipv4, buf,
+ sizeof(buf))))
+ vty_out(vty, " source: %s\n", buf);
+ break;
+ case NEXTHOP_TYPE_IPV6:
+ case NEXTHOP_TYPE_IPV6_IFINDEX:
+ vty_out(vty, " ip: %s\n",
+ inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
+ sizeof(buf)));
+ vty_out(vty, " afi: ipv6\n");
+
+ if (nexthop->ifindex) {
+ vty_out(vty, " interface index: %d\n",
+ nexthop->ifindex);
+ vty_out(vty, " interface name: %s\n",
+ ifindex2ifname(nexthop->ifindex,
+ nexthop->vrf_id));
+ }
+
+ if (!IPV6_ADDR_SAME(&nexthop->src.ipv6, &in6addr_any)) {
+ if (inet_ntop(AF_INET6, &nexthop->src.ipv6, buf,
+ sizeof(buf)))
+ vty_out(vty, " source: %s\n", buf);
+ }
+ break;
+ case NEXTHOP_TYPE_IFINDEX:
+ vty_out(vty,
+ " Nexthop is an interface (directly connected).\n");
+ vty_out(vty, " interface index: %d\n", nexthop->ifindex);
+ vty_out(vty, " interface name: %s\n",
+ ifindex2ifname(nexthop->ifindex, nexthop->vrf_id));
+ break;
+ case NEXTHOP_TYPE_BLACKHOLE:
+ vty_out(vty, " Nexthop type is blackhole.\n");
+
+ switch (nexthop->bh_type) {
+ case BLACKHOLE_REJECT:
+ vty_out(vty, " Blackhole type: reject\n");
+ break;
+ case BLACKHOLE_ADMINPROHIB:
+ vty_out(vty,
+ " Blackhole type: admin-prohibited\n");
+ break;
+ case BLACKHOLE_NULL:
+ vty_out(vty, " Blackhole type: NULL0\n");
+ break;
+ case BLACKHOLE_UNSPEC:
+ break;
+ }
+ break;
+ }
+}
+
+static void show_ip_route_dump_vty(struct vty *vty, struct route_table *table)
+{
+ struct route_node *rn;
+ struct route_entry *re;
+ char buf[SRCDEST2STR_BUFFER];
+ char time[20];
+ time_t uptime;
+ struct tm tm;
+ struct timeval tv;
+ struct nexthop *nexthop = NULL;
+ int nexthop_num = 0;
+
+ vty_out(vty, "\nIPv4/IPv6 Routing table dump\n");
+ vty_out(vty, "----------------------------\n");
+
+ for (rn = route_top(table); rn; rn = route_next(rn)) {
+ RNODE_FOREACH_RE (rn, re) {
+ vty_out(vty, "Route: %s\n",
+ srcdest_rnode2str(rn, buf, sizeof(buf)));
+ vty_out(vty, " protocol: %s\n",
+ zebra_route_string(re->type));
+ vty_out(vty, " instance: %u\n", re->instance);
+ vty_out(vty, " VRF ID: %u\n", re->vrf_id);
+ vty_out(vty, " VRF name: %s\n",
+ vrf_id_to_name(re->vrf_id));
+ vty_out(vty, " flags: %u\n", re->flags);
+
+ if (re->type != ZEBRA_ROUTE_CONNECT) {
+ vty_out(vty, " distance: %u\n", re->distance);
+ vty_out(vty, " metric: %u\n", re->metric);
+ }
+
+ vty_out(vty, " tag: %u\n", re->tag);
+
+ uptime = monotime(&tv);
+ uptime -= re->uptime;
+ gmtime_r(&uptime, &tm);
+
+ if (uptime < ONE_DAY_SECOND)
+ snprintf(time, sizeof(time), "%02d:%02d:%02d",
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
+ else if (uptime < ONE_WEEK_SECOND)
+ snprintf(time, sizeof(time), "%dd%02dh%02dm",
+ tm.tm_yday, tm.tm_hour, tm.tm_min);
+ else
+ snprintf(time, sizeof(time), "%02dw%dd%02dh",
+ tm.tm_yday / 7,
+ tm.tm_yday - ((tm.tm_yday / 7) * 7),
+ tm.tm_hour);
+
+ vty_out(vty, " status: %u\n", re->status);
+ vty_out(vty, " nexthop_num: %u\n",
+ nexthop_group_nexthop_num(&(re->nhe->nhg)));
+ vty_out(vty, " nexthop_active_num: %u\n",
+ nexthop_group_active_nexthop_num(
+ &(re->nhe->nhg)));
+ vty_out(vty, " table: %u\n", re->table);
+ vty_out(vty, " uptime: %s\n", time);
+
+ for (ALL_NEXTHOPS_PTR(&(re->nhe->nhg), nexthop)) {
+ nexthop_num++;
+ show_ip_route_nht_dump(vty, nexthop, re,
+ nexthop_num);
+ }
+
+ nexthop_num = 0;
+ vty_out(vty, "\n");
+ }
+ }
+}
+
+static void vty_show_ip_route_summary(struct vty *vty,
+ struct route_table *table, bool use_json)
+{
+ struct route_node *rn;
+ struct route_entry *re;
+#define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
+#define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
+ uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t offload_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t trap_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t i;
+ uint32_t is_ibgp;
+ json_object *json_route_summary = NULL;
+ json_object *json_route_routes = NULL;
+
+ memset(&rib_cnt, 0, sizeof(rib_cnt));
+ memset(&fib_cnt, 0, sizeof(fib_cnt));
+ memset(&offload_cnt, 0, sizeof(offload_cnt));
+ memset(&trap_cnt, 0, sizeof(trap_cnt));
+
+ if (use_json) {
+ json_route_summary = json_object_new_object();
+ json_route_routes = json_object_new_array();
+ json_object_object_add(json_route_summary, "routes",
+ json_route_routes);
+ }
+
+ for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
+ RNODE_FOREACH_RE (rn, re) {
+ is_ibgp = (re->type == ZEBRA_ROUTE_BGP
+ && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP));
+
+ rib_cnt[ZEBRA_ROUTE_TOTAL]++;
+ if (is_ibgp)
+ rib_cnt[ZEBRA_ROUTE_IBGP]++;
+ else
+ rib_cnt[re->type]++;
+
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED)) {
+ fib_cnt[ZEBRA_ROUTE_TOTAL]++;
+
+ if (is_ibgp)
+ fib_cnt[ZEBRA_ROUTE_IBGP]++;
+ else
+ fib_cnt[re->type]++;
+ }
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_TRAPPED)) {
+ if (is_ibgp)
+ trap_cnt[ZEBRA_ROUTE_IBGP]++;
+ else
+ trap_cnt[re->type]++;
+ }
+
+ if (CHECK_FLAG(re->flags, ZEBRA_FLAG_OFFLOADED)) {
+ if (is_ibgp)
+ offload_cnt[ZEBRA_ROUTE_IBGP]++;
+ else
+ offload_cnt[re->type]++;
+ }
+ }
+
+ if (!use_json)
+ vty_out(vty, "%-20s %-20s %s (vrf %s)\n", "Route Source",
+ "Routes", "FIB",
+ zvrf_name(((struct rib_table_info *)
+ route_table_get_info(table))
+ ->zvrf));
+
+ for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
+ if ((rib_cnt[i] > 0) || (i == ZEBRA_ROUTE_BGP
+ && rib_cnt[ZEBRA_ROUTE_IBGP] > 0)) {
+ if (i == ZEBRA_ROUTE_BGP) {
+ if (use_json) {
+ json_object *json_route_ebgp =
+ json_object_new_object();
+
+ json_object_int_add(
+ json_route_ebgp, "fib",
+ fib_cnt[ZEBRA_ROUTE_BGP]);
+ json_object_int_add(
+ json_route_ebgp, "rib",
+ rib_cnt[ZEBRA_ROUTE_BGP]);
+ json_object_int_add(
+ json_route_ebgp, "fibOffLoaded",
+ offload_cnt[ZEBRA_ROUTE_BGP]);
+ json_object_int_add(
+ json_route_ebgp, "fibTrapped",
+ trap_cnt[ZEBRA_ROUTE_BGP]);
+
+ json_object_string_add(json_route_ebgp,
+ "type", "ebgp");
+ json_object_array_add(json_route_routes,
+ json_route_ebgp);
+
+ json_object *json_route_ibgp =
+ json_object_new_object();
+
+ json_object_int_add(
+ json_route_ibgp, "fib",
+ fib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_int_add(
+ json_route_ibgp, "rib",
+ rib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_int_add(
+ json_route_ibgp, "fibOffLoaded",
+ offload_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_int_add(
+ json_route_ibgp, "fibTrapped",
+ trap_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_string_add(json_route_ibgp,
+ "type", "ibgp");
+ json_object_array_add(json_route_routes,
+ json_route_ibgp);
+ } else {
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ "ebgp",
+ rib_cnt[ZEBRA_ROUTE_BGP],
+ fib_cnt[ZEBRA_ROUTE_BGP]);
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ "ibgp",
+ rib_cnt[ZEBRA_ROUTE_IBGP],
+ fib_cnt[ZEBRA_ROUTE_IBGP]);
+ }
+ } else {
+ if (use_json) {
+ json_object *json_route_type =
+ json_object_new_object();
+
+ json_object_int_add(json_route_type,
+ "fib", fib_cnt[i]);
+ json_object_int_add(json_route_type,
+ "rib", rib_cnt[i]);
+
+ json_object_int_add(json_route_type,
+ "fibOffLoaded",
+ offload_cnt[i]);
+ json_object_int_add(json_route_type,
+ "fibTrapped",
+ trap_cnt[i]);
+ json_object_string_add(
+ json_route_type, "type",
+ zebra_route_string(i));
+ json_object_array_add(json_route_routes,
+ json_route_type);
+ } else
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ zebra_route_string(i),
+ rib_cnt[i], fib_cnt[i]);
+ }
+ }
+ }
+
+ if (use_json) {
+ json_object_int_add(json_route_summary, "routesTotal",
+ rib_cnt[ZEBRA_ROUTE_TOTAL]);
+ json_object_int_add(json_route_summary, "routesTotalFib",
+ fib_cnt[ZEBRA_ROUTE_TOTAL]);
+
+ vty_json(vty, json_route_summary);
+ } else {
+ vty_out(vty, "------\n");
+ vty_out(vty, "%-20s %-20d %-20d \n", "Totals",
+ rib_cnt[ZEBRA_ROUTE_TOTAL], fib_cnt[ZEBRA_ROUTE_TOTAL]);
+ vty_out(vty, "\n");
+ }
+}
+
+/*
+ * Implementation of the ip route summary prefix command.
+ *
+ * This command prints the primary prefixes that have been installed by various
+ * protocols on the box.
+ *
+ */
+static void vty_show_ip_route_summary_prefix(struct vty *vty,
+ struct route_table *table,
+ bool use_json)
+{
+ struct route_node *rn;
+ struct route_entry *re;
+ struct nexthop *nexthop;
+#define ZEBRA_ROUTE_IBGP ZEBRA_ROUTE_MAX
+#define ZEBRA_ROUTE_TOTAL (ZEBRA_ROUTE_IBGP + 1)
+ uint32_t rib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t fib_cnt[ZEBRA_ROUTE_TOTAL + 1];
+ uint32_t i;
+ int cnt;
+ json_object *json_route_summary = NULL;
+ json_object *json_route_routes = NULL;
+
+ memset(&rib_cnt, 0, sizeof(rib_cnt));
+ memset(&fib_cnt, 0, sizeof(fib_cnt));
+
+ if (use_json) {
+ json_route_summary = json_object_new_object();
+ json_route_routes = json_object_new_array();
+ json_object_object_add(json_route_summary, "prefixRoutes",
+ json_route_routes);
+ }
+
+ for (rn = route_top(table); rn; rn = srcdest_route_next(rn))
+ RNODE_FOREACH_RE (rn, re) {
+
+ /*
+ * In case of ECMP, count only once.
+ */
+ cnt = 0;
+ if (CHECK_FLAG(re->status, ROUTE_ENTRY_INSTALLED)) {
+ fib_cnt[ZEBRA_ROUTE_TOTAL]++;
+ fib_cnt[re->type]++;
+ }
+ for (nexthop = re->nhe->nhg.nexthop; (!cnt && nexthop);
+ nexthop = nexthop->next) {
+ cnt++;
+ rib_cnt[ZEBRA_ROUTE_TOTAL]++;
+ rib_cnt[re->type]++;
+ if (re->type == ZEBRA_ROUTE_BGP
+ && CHECK_FLAG(re->flags, ZEBRA_FLAG_IBGP)) {
+ rib_cnt[ZEBRA_ROUTE_IBGP]++;
+ if (CHECK_FLAG(re->status,
+ ROUTE_ENTRY_INSTALLED))
+ fib_cnt[ZEBRA_ROUTE_IBGP]++;
+ }
+ }
+ }
+
+ if (!use_json)
+ vty_out(vty, "%-20s %-20s %s (vrf %s)\n", "Route Source",
+ "Prefix Routes", "FIB",
+ zvrf_name(((struct rib_table_info *)
+ route_table_get_info(table))
+ ->zvrf));
+
+ for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
+ if (rib_cnt[i] > 0) {
+ if (i == ZEBRA_ROUTE_BGP) {
+ if (use_json) {
+ json_object *json_route_ebgp =
+ json_object_new_object();
+
+ json_object_int_add(
+ json_route_ebgp, "fib",
+ fib_cnt[ZEBRA_ROUTE_BGP]
+ - fib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_int_add(
+ json_route_ebgp, "rib",
+ rib_cnt[ZEBRA_ROUTE_BGP]
+ - rib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_string_add(json_route_ebgp,
+ "type", "ebgp");
+ json_object_array_add(json_route_routes,
+ json_route_ebgp);
+
+ json_object *json_route_ibgp =
+ json_object_new_object();
+
+ json_object_int_add(
+ json_route_ibgp, "fib",
+ fib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_int_add(
+ json_route_ibgp, "rib",
+ rib_cnt[ZEBRA_ROUTE_IBGP]);
+ json_object_string_add(json_route_ibgp,
+ "type", "ibgp");
+ json_object_array_add(json_route_routes,
+ json_route_ibgp);
+ } else {
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ "ebgp",
+ rib_cnt[ZEBRA_ROUTE_BGP]
+ - rib_cnt[ZEBRA_ROUTE_IBGP],
+ fib_cnt[ZEBRA_ROUTE_BGP]
+ - fib_cnt[ZEBRA_ROUTE_IBGP]);
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ "ibgp",
+ rib_cnt[ZEBRA_ROUTE_IBGP],
+ fib_cnt[ZEBRA_ROUTE_IBGP]);
+ }
+ } else {
+ if (use_json) {
+ json_object *json_route_type =
+ json_object_new_object();
+
+ json_object_int_add(json_route_type,
+ "fib", fib_cnt[i]);
+ json_object_int_add(json_route_type,
+ "rib", rib_cnt[i]);
+ json_object_string_add(
+ json_route_type, "type",
+ zebra_route_string(i));
+ json_object_array_add(json_route_routes,
+ json_route_type);
+ } else
+ vty_out(vty, "%-20s %-20d %-20d \n",
+ zebra_route_string(i),
+ rib_cnt[i], fib_cnt[i]);
+ }
+ }
+ }
+
+ if (use_json) {
+ json_object_int_add(json_route_summary, "prefixRoutesTotal",
+ rib_cnt[ZEBRA_ROUTE_TOTAL]);
+ json_object_int_add(json_route_summary, "prefixRoutesTotalFib",
+ fib_cnt[ZEBRA_ROUTE_TOTAL]);
+
+ vty_json(vty, json_route_summary);
+ } else {
+ vty_out(vty, "------\n");
+ vty_out(vty, "%-20s %-20d %-20d \n", "Totals",
+ rib_cnt[ZEBRA_ROUTE_TOTAL], fib_cnt[ZEBRA_ROUTE_TOTAL]);
+ vty_out(vty, "\n");
+ }
+}
+
+DEFUN (allow_external_route_update,
+ allow_external_route_update_cmd,
+ "allow-external-route-update",
+ "Allow FRR routes to be overwritten by external processes\n")
+{
+ zrouter.allow_delete = true;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_allow_external_route_update,
+ no_allow_external_route_update_cmd,
+ "no allow-external-route-update",
+ NO_STR
+ "Allow FRR routes to be overwritten by external processes\n")
+{
+ zrouter.allow_delete = false;
+
+ return CMD_SUCCESS;
+}
+
+/* show vrf */
+DEFUN (show_vrf,
+ show_vrf_cmd,
+ "show vrf",
+ SHOW_STR
+ "VRF\n")
+{
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+
+ if (vrf_is_backend_netns())
+ vty_out(vty, "netns-based vrfs\n");
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if (!(zvrf = vrf->info))
+ continue;
+ if (zvrf_id(zvrf) == VRF_DEFAULT)
+ continue;
+
+ vty_out(vty, "vrf %s ", zvrf_name(zvrf));
+ if (zvrf_id(zvrf) == VRF_UNKNOWN || !zvrf_is_active(zvrf))
+ vty_out(vty, "inactive");
+ else if (zvrf_ns_name(zvrf))
+ vty_out(vty, "id %u netns %s", zvrf_id(zvrf),
+ zvrf_ns_name(zvrf));
+ else
+ vty_out(vty, "id %u table %u", zvrf_id(zvrf),
+ zvrf->table_id);
+ if (vrf_is_user_cfged(vrf))
+ vty_out(vty, " (configured)");
+ vty_out(vty, "\n");
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (evpn_mh_mac_holdtime,
+ evpn_mh_mac_holdtime_cmd,
+ "[no$no] evpn mh mac-holdtime (0-86400)$duration",
+ NO_STR
+ "EVPN\n"
+ "Multihoming\n"
+ "MAC hold time\n"
+ "Duration in seconds\n")
+{
+ return zebra_evpn_mh_mac_holdtime_update(vty, duration,
+ no ? true : false);
+}
+
+DEFPY (evpn_mh_neigh_holdtime,
+ evpn_mh_neigh_holdtime_cmd,
+ "[no$no] evpn mh neigh-holdtime (0-86400)$duration",
+ NO_STR
+ "EVPN\n"
+ "Multihoming\n"
+ "Neighbor entry hold time\n"
+ "Duration in seconds\n")
+{
+
+ return zebra_evpn_mh_neigh_holdtime_update(vty, duration,
+ no ? true : false);
+}
+
+DEFPY (evpn_mh_startup_delay,
+ evpn_mh_startup_delay_cmd,
+ "[no] evpn mh startup-delay(0-3600)$duration",
+ NO_STR
+ "EVPN\n"
+ "Multihoming\n"
+ "Startup delay\n"
+ "duration in seconds\n")
+{
+
+ return zebra_evpn_mh_startup_delay_update(vty, duration,
+ no ? true : false);
+}
+
+DEFPY(evpn_mh_redirect_off, evpn_mh_redirect_off_cmd,
+ "[no$no] evpn mh redirect-off",
+ NO_STR
+ "EVPN\n"
+ "Multihoming\n"
+ "ES bond redirect for fast-failover off\n")
+{
+ bool redirect_off;
+
+ redirect_off = no ? false : true;
+
+ return zebra_evpn_mh_redirect_off(vty, redirect_off);
+}
+
+DEFUN (default_vrf_vni_mapping,
+ default_vrf_vni_mapping_cmd,
+ "vni " CMD_VNI_RANGE "[prefix-routes-only]",
+ "VNI corresponding to the DEFAULT VRF\n"
+ "VNI-ID\n"
+ "Prefix routes only \n")
+{
+ char xpath[XPATH_MAXLEN];
+ int filter = 0;
+
+ if (argc == 3)
+ filter = 1;
+
+ snprintf(xpath, sizeof(xpath), FRR_VRF_KEY_XPATH "/frr-zebra:zebra",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
+
+ snprintf(xpath, sizeof(xpath),
+ FRR_VRF_KEY_XPATH "/frr-zebra:zebra/l3vni-id",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, argv[1]->arg);
+
+ if (filter) {
+ snprintf(xpath, sizeof(xpath),
+ FRR_VRF_KEY_XPATH "/frr-zebra:zebra/prefix-only",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, "true");
+ }
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFUN (no_default_vrf_vni_mapping,
+ no_default_vrf_vni_mapping_cmd,
+ "no vni " CMD_VNI_RANGE "[prefix-routes-only]",
+ NO_STR
+ "VNI corresponding to DEFAULT VRF\n"
+ "VNI-ID\n"
+ "Prefix routes only \n")
+{
+ char xpath[XPATH_MAXLEN];
+ int filter = 0;
+ vni_t vni = strtoul(argv[2]->arg, NULL, 10);
+ struct zebra_vrf *zvrf = NULL;
+
+ zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
+
+ if (argc == 4)
+ filter = 1;
+
+ if (zvrf->l3vni != vni) {
+ vty_out(vty, "VNI %d doesn't exist in VRF: %s \n", vni,
+ zvrf->vrf->name);
+ return CMD_WARNING;
+ }
+
+ snprintf(xpath, sizeof(xpath),
+ FRR_VRF_KEY_XPATH "/frr-zebra:zebra/l3vni-id",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, argv[2]->arg);
+
+ if (filter) {
+ snprintf(xpath, sizeof(xpath),
+ FRR_VRF_KEY_XPATH "/frr-zebra:zebra/prefix-only",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, "true");
+ }
+
+ snprintf(xpath, sizeof(xpath), FRR_VRF_KEY_XPATH "/frr-zebra:zebra",
+ VRF_DEFAULT_NAME);
+ nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFUN (vrf_vni_mapping,
+ vrf_vni_mapping_cmd,
+ "vni " CMD_VNI_RANGE "[prefix-routes-only]",
+ "VNI corresponding to tenant VRF\n"
+ "VNI-ID\n"
+ "prefix-routes-only\n")
+{
+ int filter = 0;
+
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ assert(vrf);
+ assert(zvrf);
+
+ if (argc == 3)
+ filter = 1;
+
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra", NB_OP_CREATE, NULL);
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra/l3vni-id", NB_OP_MODIFY,
+ argv[1]->arg);
+
+ if (filter)
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra/prefix-only",
+ NB_OP_MODIFY, "true");
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+DEFUN (no_vrf_vni_mapping,
+ no_vrf_vni_mapping_cmd,
+ "no vni " CMD_VNI_RANGE "[prefix-routes-only]",
+ NO_STR
+ "VNI corresponding to tenant VRF\n"
+ "VNI-ID\n"
+ "prefix-routes-only\n")
+{
+ int filter = 0;
+
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+ vni_t vni = strtoul(argv[2]->arg, NULL, 10);
+
+ assert(vrf);
+ assert(zvrf);
+
+ if (argc == 4)
+ filter = 1;
+
+ if (zvrf->l3vni != vni) {
+ vty_out(vty, "VNI %d doesn't exist in VRF: %s \n", vni,
+ zvrf->vrf->name);
+ return CMD_WARNING;
+ }
+
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra/l3vni-id", NB_OP_DESTROY,
+ argv[2]->arg);
+
+ if (filter)
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra/prefix-only",
+ NB_OP_DESTROY, "true");
+
+ nb_cli_enqueue_change(vty, "./frr-zebra:zebra", NB_OP_DESTROY, NULL);
+
+ return nb_cli_apply_changes(vty, NULL);
+}
+
+/* show vrf */
+DEFPY (show_vrf_vni,
+ show_vrf_vni_cmd,
+ "show vrf [<NAME$vrf_name|all$vrf_all>] vni [json]",
+ SHOW_STR
+ VRF_FULL_CMD_HELP_STR
+ "VNI\n"
+ JSON_STR)
+{
+ struct vrf *vrf;
+ struct zebra_vrf *zvrf;
+ json_object *json = NULL;
+ json_object *json_vrfs = NULL;
+ bool uj = use_json(argc, argv);
+ bool use_vrf = false;
+
+ if (uj)
+ json = json_object_new_object();
+
+ /* show vrf vni used to display across all vrfs
+ * This is enhanced to support only for specific
+ * vrf based output.
+ */
+ if (vrf_all || !vrf_name) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ zvrf = vrf->info;
+ if (!zvrf)
+ continue;
+
+ use_vrf = true;
+ break;
+ }
+ if (use_vrf) {
+ if (!uj)
+ vty_out(vty,
+ "%-37s %-10s %-20s %-20s %-5s %-18s\n",
+ "VRF", "VNI", "VxLAN IF", "L3-SVI",
+ "State", "Rmac");
+ else
+ json_vrfs = json_object_new_array();
+ } else {
+ if (uj)
+ vty_json(vty, json);
+ else
+ vty_out(vty, "%% VRF does not exist\n");
+
+ return CMD_WARNING;
+ }
+ }
+
+ if (use_vrf) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ zvrf = vrf->info;
+ if (!zvrf)
+ continue;
+
+ zebra_vxlan_print_vrf_vni(vty, zvrf, json_vrfs);
+ }
+ } else if (vrf_name) {
+ zvrf = zebra_vrf_lookup_by_name(vrf_name);
+ if (!zvrf) {
+ if (uj)
+ vty_json(vty, json);
+ else
+ vty_out(vty,
+ "%% VRF '%s' specified does not exist\n",
+ vrf_name);
+
+ return CMD_WARNING;
+ }
+
+ if (!uj)
+ vty_out(vty, "%-37s %-10s %-20s %-20s %-5s %-18s\n",
+ "VRF", "VNI", "VxLAN IF", "L3-SVI", "State",
+ "Rmac");
+ else
+ json_vrfs = json_object_new_array();
+
+ zebra_vxlan_print_vrf_vni(vty, zvrf, json_vrfs);
+ }
+
+ if (uj) {
+ json_object_object_add(json, "vrfs", json_vrfs);
+ vty_json(vty, json);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_global,
+ show_evpn_global_cmd,
+ "show evpn [json]",
+ SHOW_STR
+ "EVPN\n"
+ JSON_STR)
+{
+ bool uj = use_json(argc, argv);
+
+ zebra_vxlan_print_evpn(vty, uj);
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_evpn_neigh, show_neigh_cmd, "show ip neigh",
+ SHOW_STR IP_STR "neighbors\n")
+
+{
+ zebra_neigh_show(vty);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_evpn_l2_nh,
+ show_evpn_l2_nh_cmd,
+ "show evpn l2-nh [json$json]",
+ SHOW_STR
+ "EVPN\n"
+ "Layer2 nexthops\n"
+ JSON_STR)
+{
+ bool uj = !!json;
+
+ zebra_evpn_l2_nh_show(vty, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_evpn_es,
+ show_evpn_es_cmd,
+ "show evpn es [NAME$esi_str|detail$detail] [json$json]",
+ SHOW_STR
+ "EVPN\n"
+ "Ethernet Segment\n"
+ "ES ID\n"
+ "Detailed information\n"
+ JSON_STR)
+{
+ esi_t esi;
+ bool uj = !!json;
+
+ if (esi_str) {
+ if (!str_to_esi(esi_str, &esi)) {
+ vty_out(vty, "%% Malformed ESI\n");
+ return CMD_WARNING;
+ }
+ zebra_evpn_es_show_esi(vty, uj, &esi);
+ } else {
+ if (detail)
+ zebra_evpn_es_show_detail(vty, uj);
+ else
+ zebra_evpn_es_show(vty, uj);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_evpn_es_evi,
+ show_evpn_es_evi_cmd,
+ "show evpn es-evi [vni (1-16777215)$vni] [detail$detail] [json$json]",
+ SHOW_STR
+ "EVPN\n"
+ "Ethernet Segment per EVI\n"
+ "VxLAN Network Identifier\n"
+ "VNI\n"
+ "Detailed information\n"
+ JSON_STR)
+{
+ bool uj = !!json;
+ bool ud = !!detail;
+
+ if (vni)
+ zebra_evpn_es_evi_show_vni(vty, uj, vni, ud);
+ else
+ zebra_evpn_es_evi_show(vty, uj, ud);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY(show_evpn_access_vlan, show_evpn_access_vlan_cmd,
+ "show evpn access-vlan [IFNAME$if_name (1-4094)$vid | detail$detail] [json$json]",
+ SHOW_STR
+ "EVPN\n"
+ "Access VLANs\n"
+ "Interface Name\n"
+ "VLAN ID\n"
+ "Detailed information\n" JSON_STR)
+{
+ bool uj = !!json;
+
+ if (if_name && vid) {
+ bool found = false;
+ struct vrf *vrf;
+ struct interface *ifp;
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ if (if_name) {
+ ifp = if_lookup_by_name(if_name, vrf->vrf_id);
+ if (ifp) {
+ zebra_evpn_acc_vl_show_vid(vty, uj, vid,
+ ifp);
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ vty_out(vty, "%% Can't find interface %s\n", if_name);
+ return CMD_WARNING;
+ }
+ } else {
+ if (detail)
+ zebra_evpn_acc_vl_show_detail(vty, uj);
+ else
+ zebra_evpn_acc_vl_show(vty, uj);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_vni,
+ show_evpn_vni_cmd,
+ "show evpn vni [json]",
+ SHOW_STR
+ "EVPN\n"
+ "VxLAN Network Identifier\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_vnis(vty, zvrf, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_vni_detail, show_evpn_vni_detail_cmd,
+ "show evpn vni detail [json]",
+ SHOW_STR
+ "EVPN\n"
+ "VxLAN Network Identifier\n"
+ "Detailed Information On Each VNI\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_vnis_detail(vty, zvrf, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_vni_vni,
+ show_evpn_vni_vni_cmd,
+ "show evpn vni " CMD_VNI_RANGE "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[3]->arg, NULL, 10);
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_vni(vty, zvrf, vni, uj, NULL);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_rmac_vni_mac,
+ show_evpn_rmac_vni_mac_cmd,
+ "show evpn rmac vni " CMD_VNI_RANGE " mac WORD [json]",
+ SHOW_STR
+ "EVPN\n"
+ "RMAC\n"
+ "L3 VNI\n"
+ "VNI number\n"
+ "MAC\n"
+ "mac-address (e.g. 0a:0a:0a:0a:0a:0a)\n"
+ JSON_STR)
+{
+ vni_t l3vni = 0;
+ struct ethaddr mac;
+ bool uj = use_json(argc, argv);
+
+ l3vni = strtoul(argv[4]->arg, NULL, 10);
+ if (!prefix_str2mac(argv[6]->arg, &mac)) {
+ vty_out(vty, "%% Malformed MAC address\n");
+ return CMD_WARNING;
+ }
+ zebra_vxlan_print_specific_rmac_l3vni(vty, l3vni, &mac, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_rmac_vni,
+ show_evpn_rmac_vni_cmd,
+ "show evpn rmac vni " CMD_VNI_RANGE "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "RMAC\n"
+ "L3 VNI\n"
+ "VNI number\n"
+ JSON_STR)
+{
+ vni_t l3vni = 0;
+ bool uj = use_json(argc, argv);
+
+ l3vni = strtoul(argv[4]->arg, NULL, 10);
+ zebra_vxlan_print_rmacs_l3vni(vty, l3vni, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_rmac_vni_all,
+ show_evpn_rmac_vni_all_cmd,
+ "show evpn rmac vni all [json]",
+ SHOW_STR
+ "EVPN\n"
+ "RMAC addresses\n"
+ "L3 VNI\n"
+ "All VNIs\n"
+ JSON_STR)
+{
+ bool uj = use_json(argc, argv);
+
+ zebra_vxlan_print_rmacs_all_l3vni(vty, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_nh_vni_ip,
+ show_evpn_nh_vni_ip_cmd,
+ "show evpn next-hops vni " CMD_VNI_RANGE " ip WORD [json]",
+ SHOW_STR
+ "EVPN\n"
+ "Remote Vteps\n"
+ "L3 VNI\n"
+ "VNI number\n"
+ "Ip address\n"
+ "Host address (ipv4 or ipv6)\n"
+ JSON_STR)
+{
+ vni_t l3vni;
+ struct ipaddr ip;
+ bool uj = use_json(argc, argv);
+
+ l3vni = strtoul(argv[4]->arg, NULL, 10);
+ if (str2ipaddr(argv[6]->arg, &ip) != 0) {
+ if (!uj)
+ vty_out(vty, "%% Malformed Neighbor address\n");
+ return CMD_WARNING;
+ }
+ zebra_vxlan_print_specific_nh_l3vni(vty, l3vni, &ip, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (show_evpn_nh_svd_ip,
+ show_evpn_nh_svd_ip_cmd,
+ "show evpn next-hops svd ip WORD [json]",
+ SHOW_STR
+ "EVPN\n"
+ "Remote Vteps\n"
+ "Single Vxlan Device\n"
+ "Ip address\n"
+ "Host address (ipv4 or ipv6)\n"
+ JSON_STR)
+{
+ struct ipaddr ip;
+ bool uj = use_json(argc, argv);
+
+ if (str2ipaddr(argv[5]->arg, &ip) != 0) {
+ if (!uj)
+ vty_out(vty, "%% Malformed Neighbor address\n");
+ return CMD_WARNING;
+ }
+ zebra_vxlan_print_specific_nh_l3vni(vty, 0, &ip, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_nh_vni,
+ show_evpn_nh_vni_cmd,
+ "show evpn next-hops vni " CMD_VNI_RANGE "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "Remote Vteps\n"
+ "L3 VNI\n"
+ "VNI number\n"
+ JSON_STR)
+{
+ vni_t l3vni;
+ bool uj = use_json(argc, argv);
+
+ l3vni = strtoul(argv[4]->arg, NULL, 10);
+ zebra_vxlan_print_nh_l3vni(vty, l3vni, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (show_evpn_nh_svd,
+ show_evpn_nh_svd_cmd,
+ "show evpn next-hops svd [json]",
+ SHOW_STR
+ "EVPN\n"
+ "Remote VTEPs\n"
+ "Single Vxlan Device\n"
+ JSON_STR)
+{
+ bool uj = use_json(argc, argv);
+
+ zebra_vxlan_print_nh_svd(vty, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_nh_vni_all,
+ show_evpn_nh_vni_all_cmd,
+ "show evpn next-hops vni all [json]",
+ SHOW_STR
+ "EVPN\n"
+ "Remote VTEPs\n"
+ "L3 VNI\n"
+ "All VNIs\n"
+ JSON_STR)
+{
+ bool uj = use_json(argc, argv);
+
+ zebra_vxlan_print_nh_all_l3vni(vty, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_mac_vni,
+ show_evpn_mac_vni_cmd,
+ "show evpn mac vni " CMD_VNI_RANGE "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_vni(vty, zvrf, vni, uj, false);
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_evpn_mac_vni_detail,
+ show_evpn_mac_vni_detail_cmd,
+ "show evpn mac vni " CMD_VNI_RANGE " detail [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VXLAN Network Identifier\n"
+ "VNI number\n"
+ "Detailed Information On Each VNI MAC\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_vni(vty, zvrf, vni, uj, true);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_mac_vni_all,
+ show_evpn_mac_vni_all_cmd,
+ "show evpn mac vni all [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_all_vni(vty, zvrf, false, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_mac_vni_all_detail, show_evpn_mac_vni_all_detail_cmd,
+ "show evpn mac vni all detail [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ "Detailed Information On Each VNI MAC\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_all_vni_detail(vty, zvrf, false, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_mac_vni_all_vtep,
+ show_evpn_mac_vni_all_vtep_cmd,
+ "show evpn mac vni all vtep A.B.C.D [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ "Remote VTEP\n"
+ "Remote VTEP IP address\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ struct in_addr vtep_ip;
+ bool uj = use_json(argc, argv);
+
+ if (!inet_aton(argv[6]->arg, &vtep_ip)) {
+ if (!uj)
+ vty_out(vty, "%% Malformed VTEP IP address\n");
+ return CMD_WARNING;
+ }
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_all_vni_vtep(vty, zvrf, vtep_ip, uj);
+
+ return CMD_SUCCESS;
+}
+
+
+DEFUN (show_evpn_mac_vni_mac,
+ show_evpn_mac_vni_mac_cmd,
+ "show evpn mac vni " CMD_VNI_RANGE " mac WORD [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "MAC\n"
+ "MAC address (e.g., 00:e0:ec:20:12:62)\n"
+ JSON_STR)
+
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ struct ethaddr mac;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ if (!prefix_str2mac(argv[6]->arg, &mac)) {
+ vty_out(vty, "%% Malformed MAC address\n");
+ return CMD_WARNING;
+ }
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_specific_mac_vni(vty, zvrf, vni, &mac, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_mac_vni_vtep,
+ show_evpn_mac_vni_vtep_cmd,
+ "show evpn mac vni " CMD_VNI_RANGE " vtep A.B.C.D" "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "Remote VTEP\n"
+ "Remote VTEP IP address\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ struct in_addr vtep_ip;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ if (!inet_aton(argv[6]->arg, &vtep_ip)) {
+ if (!uj)
+ vty_out(vty, "%% Malformed VTEP IP address\n");
+ return CMD_WARNING;
+ }
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_vni_vtep(vty, zvrf, vni, vtep_ip, uj);
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_evpn_mac_vni_all_dad,
+ show_evpn_mac_vni_all_dad_cmd,
+ "show evpn mac vni all duplicate [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ "Duplicate address list\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_macs_all_vni(vty, zvrf, true, uj);
+ return CMD_SUCCESS;
+}
+
+
+DEFPY (show_evpn_mac_vni_dad,
+ show_evpn_mac_vni_dad_cmd,
+ "show evpn mac vni " CMD_VNI_RANGE " duplicate [json]",
+ SHOW_STR
+ "EVPN\n"
+ "MAC addresses\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "Duplicate address list\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+
+ zebra_vxlan_print_macs_vni_dad(vty, zvrf, vni, uj);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_evpn_neigh_vni_dad,
+ show_evpn_neigh_vni_dad_cmd,
+ "show evpn arp-cache vni " CMD_VNI_RANGE "duplicate [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "Duplicate address list\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_vni_dad(vty, zvrf, vni, uj);
+ return CMD_SUCCESS;
+}
+
+DEFPY (show_evpn_neigh_vni_all_dad,
+ show_evpn_neigh_vni_all_dad_cmd,
+ "show evpn arp-cache vni all duplicate [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ "Duplicate address list\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_all_vni(vty, zvrf, true, uj);
+ return CMD_SUCCESS;
+}
+
+
+DEFUN (show_evpn_neigh_vni,
+ show_evpn_neigh_vni_cmd,
+ "show evpn arp-cache vni " CMD_VNI_RANGE "[json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_vni(vty, zvrf, vni, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_neigh_vni_all,
+ show_evpn_neigh_vni_all_cmd,
+ "show evpn arp-cache vni all [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_all_vni(vty, zvrf, false, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_neigh_vni_all_detail, show_evpn_neigh_vni_all_detail_cmd,
+ "show evpn arp-cache vni all detail [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "All VNIs\n"
+ "Neighbor details for all vnis in detail\n" JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ bool uj = use_json(argc, argv);
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_all_vni_detail(vty, zvrf, false, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_neigh_vni_neigh,
+ show_evpn_neigh_vni_neigh_cmd,
+ "show evpn arp-cache vni " CMD_VNI_RANGE " ip WORD [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "Neighbor\n"
+ "Neighbor address (IPv4 or IPv6 address)\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ struct ipaddr ip;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ if (str2ipaddr(argv[6]->arg, &ip) != 0) {
+ if (!uj)
+ vty_out(vty, "%% Malformed Neighbor address\n");
+ return CMD_WARNING;
+ }
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_specific_neigh_vni(vty, zvrf, vni, &ip, uj);
+ return CMD_SUCCESS;
+}
+
+DEFUN (show_evpn_neigh_vni_vtep,
+ show_evpn_neigh_vni_vtep_cmd,
+ "show evpn arp-cache vni " CMD_VNI_RANGE " vtep A.B.C.D [json]",
+ SHOW_STR
+ "EVPN\n"
+ "ARP and ND cache\n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "Remote VTEP\n"
+ "Remote VTEP IP address\n"
+ JSON_STR)
+{
+ struct zebra_vrf *zvrf;
+ vni_t vni;
+ struct in_addr vtep_ip;
+ bool uj = use_json(argc, argv);
+
+ vni = strtoul(argv[4]->arg, NULL, 10);
+ if (!inet_aton(argv[6]->arg, &vtep_ip)) {
+ if (!uj)
+ vty_out(vty, "%% Malformed VTEP IP address\n");
+ return CMD_WARNING;
+ }
+
+ zvrf = zebra_vrf_get_evpn();
+ zebra_vxlan_print_neigh_vni_vtep(vty, zvrf, vni, vtep_ip, uj);
+ return CMD_SUCCESS;
+}
+
+/* policy routing contexts */
+DEFUN (show_pbr_ipset,
+ show_pbr_ipset_cmd,
+ "show pbr ipset [WORD]",
+ SHOW_STR
+ "Policy-Based Routing\n"
+ "IPset Context information\n"
+ "IPset Name information\n")
+{
+ int idx = 0;
+ int found = 0;
+ found = argv_find(argv, argc, "WORD", &idx);
+ if (!found)
+ zebra_pbr_show_ipset_list(vty, NULL);
+ else
+ zebra_pbr_show_ipset_list(vty, argv[idx]->arg);
+ return CMD_SUCCESS;
+}
+
+/* policy routing contexts */
+DEFUN (show_pbr_iptable,
+ show_pbr_iptable_cmd,
+ "show pbr iptable [WORD]",
+ SHOW_STR
+ "Policy-Based Routing\n"
+ "IPtable Context information\n"
+ "IPtable Name information\n")
+{
+ int idx = 0;
+ int found = 0;
+
+ found = argv_find(argv, argc, "WORD", &idx);
+ if (!found)
+ zebra_pbr_show_iptable(vty, NULL);
+ else
+ zebra_pbr_show_iptable(vty, argv[idx]->arg);
+ return CMD_SUCCESS;
+}
+
+/* policy routing contexts */
+DEFPY (show_pbr_rule,
+ show_pbr_rule_cmd,
+ "show pbr rule",
+ SHOW_STR
+ "Policy-Based Routing\n"
+ "Rule\n")
+{
+ zebra_pbr_show_rule(vty);
+ return CMD_SUCCESS;
+}
+
+DEFPY (pbr_nexthop_resolve,
+ pbr_nexthop_resolve_cmd,
+ "[no$no] pbr nexthop-resolve",
+ NO_STR
+ "Policy Based Routing\n"
+ "Resolve nexthop for dataplane programming\n")
+{
+ zebra_pbr_expand_action_update(!no);
+ return CMD_SUCCESS;
+}
+
+DEFPY (clear_evpn_dup_addr,
+ clear_evpn_dup_addr_cmd,
+ "clear evpn dup-addr vni <all$vni_all |" CMD_VNI_RANGE"$vni [mac X:X:X:X:X:X | ip <A.B.C.D|X:X::X:X>]>",
+ CLEAR_STR
+ "EVPN\n"
+ "Duplicate address \n"
+ "VxLAN Network Identifier\n"
+ "VNI number\n"
+ "All VNIs\n"
+ "MAC\n"
+ "MAC address (e.g., 00:e0:ec:20:12:62)\n"
+ "IP\n"
+ "IPv4 address\n"
+ "IPv6 address\n")
+{
+ struct ipaddr host_ip = {.ipa_type = IPADDR_NONE };
+ int ret = CMD_SUCCESS;
+ struct list *input;
+ struct yang_data *yang_dup = NULL, *yang_dup_ip = NULL,
+ *yang_dup_mac = NULL;
+
+ input = list_new();
+
+ if (!vni_str) {
+ yang_dup = yang_data_new(
+ "/frr-zebra:clear-evpn-dup-addr/input/clear-dup-choice",
+ "all-case");
+ } else {
+ yang_dup = yang_data_new_uint32(
+ "/frr-zebra:clear-evpn-dup-addr/input/clear-dup-choice/single-case/vni-id",
+ vni);
+ if (!is_zero_mac(&mac->eth_addr)) {
+ yang_dup_mac = yang_data_new_mac(
+ "/frr-zebra:clear-evpn-dup-addr/input/clear-dup-choice/single-case/vni-id/mac-addr",
+ &mac->eth_addr);
+ if (yang_dup_mac)
+ listnode_add(input, yang_dup_mac);
+ } else if (ip) {
+ if (sockunion_family(ip) == AF_INET) {
+ host_ip.ipa_type = IPADDR_V4;
+ host_ip.ipaddr_v4.s_addr = sockunion2ip(ip);
+ } else {
+ host_ip.ipa_type = IPADDR_V6;
+ memcpy(&host_ip.ipaddr_v6, &ip->sin6.sin6_addr,
+ sizeof(struct in6_addr));
+ }
+
+ yang_dup_ip = yang_data_new_ip(
+ "/frr-zebra:clear-evpn-dup-addr/input/clear-dup-choice/single-case/vni-id/vni-ipaddr",
+ &host_ip);
+
+ if (yang_dup_ip)
+ listnode_add(input, yang_dup_ip);
+ }
+ }
+
+ if (yang_dup) {
+ listnode_add(input, yang_dup);
+ ret = nb_cli_rpc(vty, "/frr-zebra:clear-evpn-dup-addr", input,
+ NULL);
+ }
+
+ list_delete(&input);
+
+ return ret;
+}
+
+DEFPY_HIDDEN (evpn_accept_bgp_seq,
+ evpn_accept_bgp_seq_cmd,
+ "evpn accept-bgp-seq",
+ "EVPN\n"
+ "Accept all sequence numbers from BGP\n")
+{
+ zebra_vxlan_set_accept_bgp_seq(true);
+ return CMD_SUCCESS;
+}
+
+DEFPY_HIDDEN (no_evpn_accept_bgp_seq,
+ no_evpn_accept_bgp_seq_cmd,
+ "no evpn accept-bgp-seq",
+ NO_STR
+ "EVPN\n"
+ "Accept all sequence numbers from BGP\n")
+{
+ zebra_vxlan_set_accept_bgp_seq(false);
+ return CMD_SUCCESS;
+}
+
+/* Static ip route configuration write function. */
+static int zebra_ip_config(struct vty *vty)
+{
+ int write = 0;
+
+ write += zebra_import_table_config(vty, VRF_DEFAULT);
+
+ return write;
+}
+
+DEFUN (ip_zebra_import_table_distance,
+ ip_zebra_import_table_distance_cmd,
+ "ip import-table (1-252) [distance (1-255)] [route-map RMAP_NAME]",
+ IP_STR
+ "import routes from non-main kernel table\n"
+ "kernel routing table id\n"
+ "Distance for imported routes\n"
+ "Default distance value\n"
+ "route-map for filtering\n"
+ "route-map name\n")
+{
+ uint32_t table_id = 0;
+
+ table_id = strtoul(argv[2]->arg, NULL, 10);
+ int distance = ZEBRA_TABLE_DISTANCE_DEFAULT;
+ char *rmap =
+ strmatch(argv[argc - 2]->text, "route-map")
+ ? XSTRDUP(MTYPE_ROUTE_MAP_NAME, argv[argc - 1]->arg)
+ : NULL;
+ int ret;
+
+ if (argc == 7 || (argc == 5 && !rmap))
+ distance = strtoul(argv[4]->arg, NULL, 10);
+
+ if (!is_zebra_valid_kernel_table(table_id)) {
+ vty_out(vty,
+ "Invalid routing table ID, %d. Must be in range 1-252\n",
+ table_id);
+ if (rmap)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
+ return CMD_WARNING;
+ }
+
+ if (is_zebra_main_routing_table(table_id)) {
+ vty_out(vty,
+ "Invalid routing table ID, %d. Must be non-default table\n",
+ table_id);
+ if (rmap)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
+ return CMD_WARNING;
+ }
+
+ ret = zebra_import_table(AFI_IP, VRF_DEFAULT, table_id,
+ distance, rmap, 1);
+ if (rmap)
+ XFREE(MTYPE_ROUTE_MAP_NAME, rmap);
+
+ return ret;
+}
+
+DEFUN_HIDDEN (zebra_packet_process,
+ zebra_packet_process_cmd,
+ "zebra zapi-packets (1-10000)",
+ ZEBRA_STR
+ "Zapi Protocol\n"
+ "Number of packets to process before relinquishing thread\n")
+{
+ uint32_t packets = strtoul(argv[2]->arg, NULL, 10);
+
+ atomic_store_explicit(&zrouter.packets_to_process, packets,
+ memory_order_relaxed);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (no_zebra_packet_process,
+ no_zebra_packet_process_cmd,
+ "no zebra zapi-packets [(1-10000)]",
+ NO_STR
+ ZEBRA_STR
+ "Zapi Protocol\n"
+ "Number of packets to process before relinquishing thread\n")
+{
+ atomic_store_explicit(&zrouter.packets_to_process,
+ ZEBRA_ZAPI_PACKETS_TO_PROCESS,
+ memory_order_relaxed);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (zebra_workqueue_timer,
+ zebra_workqueue_timer_cmd,
+ "zebra work-queue (0-10000)",
+ ZEBRA_STR
+ "Work Queue\n"
+ "Time in milliseconds\n")
+{
+ uint32_t timer = strtoul(argv[2]->arg, NULL, 10);
+ zrouter.ribq->spec.hold = timer;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN (no_zebra_workqueue_timer,
+ no_zebra_workqueue_timer_cmd,
+ "no zebra work-queue [(0-10000)]",
+ NO_STR
+ ZEBRA_STR
+ "Work Queue\n"
+ "Time in milliseconds\n")
+{
+ zrouter.ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ip_zebra_import_table,
+ no_ip_zebra_import_table_cmd,
+ "no ip import-table (1-252) [distance (1-255)] [route-map NAME]",
+ NO_STR
+ IP_STR
+ "import routes from non-main kernel table\n"
+ "kernel routing table id\n"
+ "Distance for imported routes\n"
+ "Default distance value\n"
+ "route-map for filtering\n"
+ "route-map name\n")
+{
+ uint32_t table_id = 0;
+ table_id = strtoul(argv[3]->arg, NULL, 10);
+
+ if (!is_zebra_valid_kernel_table(table_id)) {
+ vty_out(vty,
+ "Invalid routing table ID. Must be in range 1-252\n");
+ return CMD_WARNING;
+ }
+
+ if (is_zebra_main_routing_table(table_id)) {
+ vty_out(vty,
+ "Invalid routing table ID, %d. Must be non-default table\n",
+ table_id);
+ return CMD_WARNING;
+ }
+
+ if (!is_zebra_import_table_enabled(AFI_IP, VRF_DEFAULT, table_id))
+ return CMD_SUCCESS;
+
+ return (zebra_import_table(AFI_IP, VRF_DEFAULT, table_id, 0, NULL, 0));
+}
+
+DEFPY (zebra_nexthop_group_keep,
+ zebra_nexthop_group_keep_cmd,
+ "[no] zebra nexthop-group keep (1-3600)",
+ NO_STR
+ ZEBRA_STR
+ "Nexthop-Group\n"
+ "How long to keep\n"
+ "Time in seconds from 1-3600\n")
+{
+ if (no)
+ zrouter.nhg_keep = ZEBRA_DEFAULT_NHG_KEEP_TIMER;
+ else
+ zrouter.nhg_keep = keep;
+
+ return CMD_SUCCESS;
+}
+
+static int config_write_protocol(struct vty *vty)
+{
+ if (zrouter.allow_delete)
+ vty_out(vty, "allow-external-route-update\n");
+
+ if (zrouter.nhg_keep != ZEBRA_DEFAULT_NHG_KEEP_TIMER)
+ vty_out(vty, "zebra nexthop-group keep %u\n", zrouter.nhg_keep);
+
+ if (zrouter.ribq->spec.hold != ZEBRA_RIB_PROCESS_HOLD_TIME)
+ vty_out(vty, "zebra work-queue %u\n", zrouter.ribq->spec.hold);
+
+ if (zrouter.packets_to_process != ZEBRA_ZAPI_PACKETS_TO_PROCESS)
+ vty_out(vty, "zebra zapi-packets %u\n",
+ zrouter.packets_to_process);
+
+ enum multicast_mode ipv4_multicast_mode = multicast_mode_ipv4_get();
+
+ if (ipv4_multicast_mode != MCAST_NO_CONFIG)
+ vty_out(vty, "ip multicast rpf-lookup-mode %s\n",
+ ipv4_multicast_mode == MCAST_URIB_ONLY
+ ? "urib-only"
+ : ipv4_multicast_mode == MCAST_MRIB_ONLY
+ ? "mrib-only"
+ : ipv4_multicast_mode
+ == MCAST_MIX_MRIB_FIRST
+ ? "mrib-then-urib"
+ : ipv4_multicast_mode
+ == MCAST_MIX_DISTANCE
+ ? "lower-distance"
+ : "longer-prefix");
+
+ /* Include dataplane info */
+ dplane_config_write_helper(vty);
+
+ zebra_evpn_mh_config_write(vty);
+
+ zebra_pbr_config_write(vty);
+
+ if (!zebra_vxlan_get_accept_bgp_seq())
+ vty_out(vty, "no evpn accept-bgp-seq\n");
+
+ /* Include nexthop-group config */
+ if (!zebra_nhg_kernel_nexthops_enabled())
+ vty_out(vty, "no zebra nexthop kernel enable\n");
+
+ if (zebra_nhg_proto_nexthops_only())
+ vty_out(vty, "zebra nexthop proto only\n");
+
+ if (!zebra_nhg_recursive_use_backups())
+ vty_out(vty, "no zebra nexthop resolve-via-backup\n");
+
+ if (rnh_get_hide_backups())
+ vty_out(vty, "ip nht hide-backup-events\n");
+
+#ifdef HAVE_NETLINK
+ /* Include netlink info */
+ netlink_config_write_helper(vty);
+#endif /* HAVE_NETLINK */
+
+ return 1;
+}
+
+DEFUN (show_zebra,
+ show_zebra_cmd,
+ "show zebra",
+ SHOW_STR
+ ZEBRA_STR)
+{
+ struct vrf *vrf;
+ struct ttable *table = ttable_new(&ttable_styles[TTSTYLE_BLANK]);
+ char *out;
+
+ ttable_rowseps(table, 0, BOTTOM, true, '-');
+ ttable_add_row(table, "OS|%s(%s)", cmd_system_get(), cmd_release_get());
+ ttable_add_row(table, "ECMP Maximum|%d", zrouter.multipath_num);
+ ttable_add_row(table, "v4 Forwarding|%s", ipforward() ? "On" : "Off");
+ ttable_add_row(table, "v6 Forwarding|%s",
+ ipforward_ipv6() ? "On" : "Off");
+ ttable_add_row(table, "MPLS|%s", mpls_enabled ? "On" : "Off");
+ ttable_add_row(table, "EVPN|%s", is_evpn_enabled() ? "On" : "Off");
+ ttable_add_row(table, "Kernel socket buffer size|%d", rcvbufsize);
+
+
+#ifdef GNU_LINUX
+ if (!vrf_is_backend_netns())
+ ttable_add_row(table, "VRF|l3mdev Available");
+ else
+ ttable_add_row(table, "VRF|Namespaces");
+#else
+ ttable_add_row(table, "VRF|Not Available");
+#endif
+
+ ttable_add_row(table, "v6 with v4 nexthop|%s",
+ zrouter.v6_with_v4_nexthop ? "Used" : "Unavaliable");
+
+ ttable_add_row(table, "ASIC offload|%s",
+ zrouter.asic_offloaded ? "Used" : "Unavailable");
+
+ /*
+ * Do not display this unless someone is actually using it
+ *
+ * Why this distinction? I think this is effectively dead code
+ * and should not be exposed. Maybe someone proves me wrong.
+ */
+ if (zrouter.asic_notification_nexthop_control)
+ ttable_add_row(table, "ASIC offload and nexthop control|Used");
+
+ ttable_add_row(table, "RA|%s",
+ rtadv_compiled_in() ? "Compiled in" : "Not Compiled in");
+ ttable_add_row(table, "RFC 5549|%s",
+ rtadv_get_interfaces_configured_from_bgp()
+ ? "BGP is using"
+ : "BGP is not using");
+
+ ttable_add_row(table, "Kernel NHG|%s",
+ zrouter.supports_nhgs ? "Available" : "Unavailable");
+
+ ttable_add_row(table, "Allow Non FRR route deletion|%s",
+ zrouter.allow_delete ? "Yes" : "No");
+ ttable_add_row(table, "v4 All LinkDown Routes|%s",
+ zrouter.all_linkdownv4 ? "On" : "Off");
+ ttable_add_row(table, "v4 Default LinkDown Routes|%s",
+ zrouter.default_linkdownv4 ? "On" : "Off");
+ ttable_add_row(table, "v6 All LinkDown Routes|%s",
+ zrouter.all_linkdownv6 ? "On" : "Off");
+ ttable_add_row(table, "v6 Default LinkDown Routes|%s",
+ zrouter.default_linkdownv6 ? "On" : "Off");
+
+ ttable_add_row(table, "v4 All MC Forwarding|%s",
+ zrouter.all_mc_forwardingv4 ? "On" : "Off");
+ ttable_add_row(table, "v4 Default MC Forwarding|%s",
+ zrouter.default_mc_forwardingv4 ? "On" : "Off");
+ ttable_add_row(table, "v6 All MC Forwarding|%s",
+ zrouter.all_mc_forwardingv6 ? "On" : "Off");
+ ttable_add_row(table, "v6 Default MC Forwarding|%s",
+ zrouter.default_mc_forwardingv6 ? "On" : "Off");
+
+ out = ttable_dump(table, "\n");
+ vty_out(vty, "%s\n", out);
+ XFREE(MTYPE_TMP, out);
+
+ ttable_del(table);
+ vty_out(vty,
+ " Route Route Neighbor LSP LSP\n");
+ vty_out(vty,
+ "VRF Installs Removals Updates Installs Removals\n");
+
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
+ struct zebra_vrf *zvrf = vrf->info;
+
+ vty_out(vty, "%-25s %10" PRIu64 " %10" PRIu64 " %10" PRIu64" %10" PRIu64 " %10" PRIu64 "\n",
+ vrf->name, zvrf->installs, zvrf->removals,
+ zvrf->neigh_updates, zvrf->lsp_installs,
+ zvrf->lsp_removals);
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (ip_forwarding,
+ ip_forwarding_cmd,
+ "ip forwarding",
+ IP_STR
+ "Turn on IP forwarding\n")
+{
+ int ret;
+
+ ret = ipforward();
+ if (ret == 0)
+ ret = ipforward_on();
+
+ if (ret == 0) {
+ vty_out(vty, "Can't turn on IP forwarding\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ip_forwarding,
+ no_ip_forwarding_cmd,
+ "no ip forwarding",
+ NO_STR
+ IP_STR
+ "Turn off IP forwarding\n")
+{
+ int ret;
+
+ ret = ipforward();
+ if (ret != 0)
+ ret = ipforward_off();
+
+ if (ret != 0) {
+ vty_out(vty, "Can't turn off IP forwarding\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return CMD_SUCCESS;
+}
+
+/* Only display ip forwarding is enabled or not. */
+DEFUN (show_ip_forwarding,
+ show_ip_forwarding_cmd,
+ "show ip forwarding",
+ SHOW_STR
+ IP_STR
+ "IP forwarding status\n")
+{
+ int ret;
+
+ ret = ipforward();
+
+ if (ret == 0)
+ vty_out(vty, "IP forwarding is off\n");
+ else
+ vty_out(vty, "IP forwarding is on\n");
+ return CMD_SUCCESS;
+}
+
+/* Only display ipv6 forwarding is enabled or not. */
+DEFUN (show_ipv6_forwarding,
+ show_ipv6_forwarding_cmd,
+ "show ipv6 forwarding",
+ SHOW_STR
+ "IPv6 information\n"
+ "Forwarding status\n")
+{
+ int ret;
+
+ ret = ipforward_ipv6();
+
+ switch (ret) {
+ case -1:
+ vty_out(vty, "ipv6 forwarding is unknown\n");
+ break;
+ case 0:
+ vty_out(vty, "ipv6 forwarding is %s\n", "off");
+ break;
+ case 1:
+ vty_out(vty, "ipv6 forwarding is %s\n", "on");
+ break;
+ default:
+ vty_out(vty, "ipv6 forwarding is %s\n", "off");
+ break;
+ }
+ return CMD_SUCCESS;
+}
+
+DEFUN (ipv6_forwarding,
+ ipv6_forwarding_cmd,
+ "ipv6 forwarding",
+ IPV6_STR
+ "Turn on IPv6 forwarding\n")
+{
+ int ret;
+
+ ret = ipforward_ipv6();
+ if (ret == 0)
+ ret = ipforward_ipv6_on();
+
+ if (ret == 0) {
+ vty_out(vty, "Can't turn on IPv6 forwarding\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (no_ipv6_forwarding,
+ no_ipv6_forwarding_cmd,
+ "no ipv6 forwarding",
+ NO_STR
+ IPV6_STR
+ "Turn off IPv6 forwarding\n")
+{
+ int ret;
+
+ ret = ipforward_ipv6();
+ if (ret != 0)
+ ret = ipforward_ipv6_off();
+
+ if (ret != 0) {
+ vty_out(vty, "Can't turn off IPv6 forwarding\n");
+ return CMD_WARNING_CONFIG_FAILED;
+ }
+
+ return CMD_SUCCESS;
+}
+
+/* Display dataplane info */
+DEFUN (show_dataplane,
+ show_dataplane_cmd,
+ "show zebra dplane [detailed]",
+ SHOW_STR
+ ZEBRA_STR
+ "Zebra dataplane information\n"
+ "Detailed output\n")
+{
+ int idx = 0;
+ bool detailed = false;
+
+ if (argv_find(argv, argc, "detailed", &idx))
+ detailed = true;
+
+ return dplane_show_helper(vty, detailed);
+}
+
+/* Display dataplane providers info */
+DEFUN (show_dataplane_providers,
+ show_dataplane_providers_cmd,
+ "show zebra dplane providers [detailed]",
+ SHOW_STR
+ ZEBRA_STR
+ "Zebra dataplane information\n"
+ "Zebra dataplane provider information\n"
+ "Detailed output\n")
+{
+ int idx = 0;
+ bool detailed = false;
+
+ if (argv_find(argv, argc, "detailed", &idx))
+ detailed = true;
+
+ return dplane_show_provs_helper(vty, detailed);
+}
+
+/* Configure dataplane incoming queue limit */
+DEFUN (zebra_dplane_queue_limit,
+ zebra_dplane_queue_limit_cmd,
+ "zebra dplane limit (0-10000)",
+ ZEBRA_STR
+ "Zebra dataplane\n"
+ "Limit incoming queued updates\n"
+ "Number of queued updates\n")
+{
+ uint32_t limit = 0;
+
+ limit = strtoul(argv[3]->arg, NULL, 10);
+
+ dplane_set_in_queue_limit(limit, true);
+
+ return CMD_SUCCESS;
+}
+
+/* Reset dataplane queue limit to default value */
+DEFUN (no_zebra_dplane_queue_limit,
+ no_zebra_dplane_queue_limit_cmd,
+ "no zebra dplane limit [(0-10000)]",
+ NO_STR
+ ZEBRA_STR
+ "Zebra dataplane\n"
+ "Limit incoming queued updates\n"
+ "Number of queued updates\n")
+{
+ dplane_set_in_queue_limit(0, false);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN (zebra_show_routing_tables_summary,
+ zebra_show_routing_tables_summary_cmd,
+ "show zebra router table summary",
+ SHOW_STR
+ ZEBRA_STR
+ "The Zebra Router Information\n"
+ "Table Information about this Zebra Router\n"
+ "Summary Information\n")
+{
+ zebra_router_show_table_summary(vty);
+
+ return CMD_SUCCESS;
+}
+
+/* Table configuration write function. */
+static int config_write_table(struct vty *vty)
+{
+ return 0;
+}
+
+/* IPForwarding configuration write function. */
+static int config_write_forwarding(struct vty *vty)
+{
+ if (!ipforward())
+ vty_out(vty, "no ip forwarding\n");
+ if (!ipforward_ipv6())
+ vty_out(vty, "no ipv6 forwarding\n");
+ vty_out(vty, "!\n");
+ return 0;
+}
+
+DEFUN_HIDDEN (show_frr,
+ show_frr_cmd,
+ "show frr",
+ SHOW_STR
+ "FRR\n")
+{
+ vty_out(vty, "........ .. . .. . ..... ...77:................................................\n");
+ vty_out(vty, ".............................7777:..............................................\n");
+ vty_out(vty, ".............................777777,............................................\n");
+ vty_out(vty, "... .........................77777777,..........................................\n");
+ vty_out(vty, "............................=7777777777:........................................\n");
+ vty_out(vty, "........................:7777777777777777,......................................\n");
+ vty_out(vty, ".................... ~7777777777777?~,..........................................\n");
+ vty_out(vty, "...................I7777777777+.................................................\n");
+ vty_out(vty, "................,777777777?............ .......................................\n");
+ vty_out(vty, "..............:77777777?..........~?77777.......................................\n");
+ vty_out(vty, ".............77777777~........=7777777777.......................................\n");
+ vty_out(vty, ".......... +7777777,.......?7777777777777.......................................\n");
+ vty_out(vty, "..........7777777~......:7777777777777777......77?,.............................\n");
+ vty_out(vty, "........:777777?......+777777777777777777......777777I,.........................\n");
+ vty_out(vty, ".......?777777,.....+77777777777777777777......777777777?.......................\n");
+ vty_out(vty, "......?777777......7777777777777777777777......,?777777777?.....................\n");
+ vty_out(vty, ".....?77777?.....=7777777777777777777I~............,I7777777~...................\n");
+ vty_out(vty, "....+77777+.....I77777777777777777:...................+777777I..................\n");
+ vty_out(vty, "...~77777+.....7777777777777777=........................?777777...... .......\n");
+ vty_out(vty, "...77777I.....I77777777777777~.........:?................,777777.....I777.......\n");
+ vty_out(vty, "..777777.....I7777777777777I .......?7777..................777777.....777?......\n");
+ vty_out(vty, ".~77777,....=7777777777777:......,7777777..................,77777+....+777......\n");
+ vty_out(vty, ".77777I.....7777777777777,......777777777.......ONNNN.......=77777.....777~.....\n");
+ vty_out(vty, ",77777.....I777777777777,.....:7777777777......DNNNNNN.......77777+ ...7777.....\n");
+ vty_out(vty, "I7777I.....777777777777=.....~77777777777......NNNNNNN~......=7777I....=777.....\n");
+ vty_out(vty, "77777:....=777777777777.....,777777777777......$NNNNND ......:77777....:777.....\n");
+ vty_out(vty, "77777. ...777777777777~.....7777777777777........7DZ,........:77777.....777.....\n");
+ vty_out(vty, "????? . ..777777777777.....,7777777777777....................:77777I....777.....\n");
+ vty_out(vty, "....... ..777777777777.....+7777777777777....................=7777777+...?7.....\n");
+ vty_out(vty, "..........77777777777I.....I7777777777777....................7777777777:........\n");
+ vty_out(vty, "..........77777777777I.....?7777777777777...................~777777777777.......\n");
+ vty_out(vty, "..........777777777777.....~7777777777777..................,77777777777777+.....\n");
+ vty_out(vty, "..........777777777777......7777777777777..................77777777777777777,...\n");
+ vty_out(vty, "..... ....?77777777777I.....~777777777777................,777777.....,:+77777I..\n");
+ vty_out(vty, "........ .:777777777777,.....?77777777777...............?777777..............,:=\n");
+ vty_out(vty, ".......... 7777777777777..... ?7777777777.............=7777777.....~777I........\n");
+ vty_out(vty, "...........:777777777777I......~777777777...........I7777777~.....+777I.........\n");
+ vty_out(vty, "..... ......7777777777777I.......I7777777.......+777777777I......7777I..........\n");
+ vty_out(vty, ".............77777777777777........?77777......777777777?......=7777=...........\n");
+ vty_out(vty, ".............,77777777777777+.........~77......777777I,......:77777.............\n");
+ vty_out(vty, "..............~777777777777777~................777777......:77777=..............\n");
+ vty_out(vty, "...............:7777777777777777?..............:777777,.....=77=................\n");
+ vty_out(vty, "................,777777777777777777?,...........,777777:.....,..................\n");
+ vty_out(vty, "........... ......I777777777777777777777I.........777777~.......................\n");
+ vty_out(vty, "...................,777777777777777777777..........777777+......................\n");
+ vty_out(vty, ".....................+7777777777777777777...........777777?.....................\n");
+ vty_out(vty, ".......................=77777777777777777............777777I....................\n");
+ vty_out(vty, ".........................:777777777777777.............I77777I...................\n");
+ vty_out(vty, "............................~777777777777..............+777777..................\n");
+ vty_out(vty, "................................~77777777...............=777777.................\n");
+ vty_out(vty, ".....................................:=?I................~777777................\n");
+ vty_out(vty, "..........................................................:777777,..............\n");
+ vty_out(vty, ".... ... ... . . .... ....... ....... ....................:777777..............\n");
+
+ return CMD_SUCCESS;
+}
+
+#ifdef HAVE_NETLINK
+DEFUN_HIDDEN(zebra_kernel_netlink_batch_tx_buf,
+ zebra_kernel_netlink_batch_tx_buf_cmd,
+ "zebra kernel netlink batch-tx-buf (1-1048576) (1-1048576)",
+ ZEBRA_STR
+ "Zebra kernel interface\n"
+ "Set Netlink parameters\n"
+ "Set batch buffer size and send threshold\n"
+ "Size of the buffer\n"
+ "Send threshold\n")
+{
+ uint32_t bufsize = 0, threshold = 0;
+
+ bufsize = strtoul(argv[4]->arg, NULL, 10);
+ threshold = strtoul(argv[5]->arg, NULL, 10);
+
+ netlink_set_batch_buffer_size(bufsize, threshold, true);
+
+ return CMD_SUCCESS;
+}
+
+DEFUN_HIDDEN(no_zebra_kernel_netlink_batch_tx_buf,
+ no_zebra_kernel_netlink_batch_tx_buf_cmd,
+ "no zebra kernel netlink batch-tx-buf [(0-1048576)] [(0-1048576)]",
+ NO_STR ZEBRA_STR
+ "Zebra kernel interface\n"
+ "Set Netlink parameters\n"
+ "Set batch buffer size and send threshold\n"
+ "Size of the buffer\n"
+ "Send threshold\n")
+{
+ netlink_set_batch_buffer_size(0, 0, false);
+
+ return CMD_SUCCESS;
+}
+
+DEFPY (zebra_protodown_bit,
+ zebra_protodown_bit_cmd,
+ "zebra protodown reason-bit (0-31)$bit",
+ ZEBRA_STR
+ "Protodown Configuration\n"
+ "Reason Bit used in the kernel for application\n"
+ "Reason Bit range\n")
+{
+ if_netlink_set_frr_protodown_r_bit(bit);
+ return CMD_SUCCESS;
+}
+
+DEFPY (no_zebra_protodown_bit,
+ no_zebra_protodown_bit_cmd,
+ "no zebra protodown reason-bit [(0-31)$bit]",
+ NO_STR
+ ZEBRA_STR
+ "Protodown Configuration\n"
+ "Reason Bit used in the kernel for setting protodown\n"
+ "Reason Bit Range\n")
+{
+ if_netlink_unset_frr_protodown_r_bit();
+ return CMD_SUCCESS;
+}
+
+#endif /* HAVE_NETLINK */
+
+DEFUN(ip_table_range, ip_table_range_cmd,
+ "[no] ip table range (1-4294967295) (1-4294967295)",
+ NO_STR IP_STR
+ "table configuration\n"
+ "Configure table range\n"
+ "Start Routing Table\n"
+ "End Routing Table\n")
+{
+ ZEBRA_DECLVAR_CONTEXT_VRF(vrf, zvrf);
+
+ if (!zvrf)
+ return CMD_WARNING;
+
+ if (zvrf_id(zvrf) != VRF_DEFAULT && !vrf_is_backend_netns()) {
+ vty_out(vty,
+ "VRF subcommand does not make any sense in l3mdev based vrf's\n");
+ return CMD_WARNING;
+ }
+
+ if (strmatch(argv[0]->text, "no"))
+ return table_manager_range(vty, false, zvrf, NULL, NULL);
+
+ return table_manager_range(vty, true, zvrf, argv[3]->arg, argv[4]->arg);
+}
+
+#ifdef HAVE_SCRIPTING
+
+DEFUN(zebra_on_rib_process_script, zebra_on_rib_process_script_cmd,
+ "zebra on-rib-process script SCRIPT",
+ ZEBRA_STR
+ "on_rib_process_dplane_results hook call\n"
+ "Set a script\n"
+ "Script name (same as filename in /etc/frr/scripts/, without .lua)\n")
+{
+
+ if (frrscript_names_set_script_name(ZEBRA_ON_RIB_PROCESS_HOOK_CALL,
+ argv[3]->arg)
+ == 0) {
+ vty_out(vty, "Successfully added script %s for hook call %s\n",
+ argv[3]->arg, ZEBRA_ON_RIB_PROCESS_HOOK_CALL);
+ } else {
+ vty_out(vty, "Failed to add script %s for hook call %s\n",
+ argv[3]->arg, ZEBRA_ON_RIB_PROCESS_HOOK_CALL);
+ }
+ return CMD_SUCCESS;
+}
+
+#endif /* HAVE_SCRIPTING */
+
+/* IP node for static routes. */
+static int zebra_ip_config(struct vty *vty);
+static struct cmd_node ip_node = {
+ .name = "static ip",
+ .node = IP_NODE,
+ .prompt = "",
+ .config_write = zebra_ip_config,
+};
+static int config_write_protocol(struct vty *vty);
+static struct cmd_node protocol_node = {
+ .name = "protocol",
+ .node = PROTOCOL_NODE,
+ .prompt = "",
+ .config_write = config_write_protocol,
+};
+/* table node for routing tables. */
+static int config_write_table(struct vty *vty);
+static struct cmd_node table_node = {
+ .name = "table",
+ .node = TABLE_NODE,
+ .prompt = "",
+ .config_write = config_write_table,
+};
+static int config_write_forwarding(struct vty *vty);
+static struct cmd_node forwarding_node = {
+ .name = "forwarding",
+ .node = FORWARDING_NODE,
+ .prompt = "",
+ .config_write = config_write_forwarding,
+};
+
+/* Route VTY. */
+void zebra_vty_init(void)
+{
+ /* Install configuration write function. */
+ install_node(&table_node);
+ install_node(&forwarding_node);
+
+ install_element(VIEW_NODE, &show_ip_forwarding_cmd);
+ install_element(CONFIG_NODE, &ip_forwarding_cmd);
+ install_element(CONFIG_NODE, &no_ip_forwarding_cmd);
+ install_element(ENABLE_NODE, &show_zebra_cmd);
+
+ install_element(VIEW_NODE, &show_ipv6_forwarding_cmd);
+ install_element(CONFIG_NODE, &ipv6_forwarding_cmd);
+ install_element(CONFIG_NODE, &no_ipv6_forwarding_cmd);
+
+ /* Route-map */
+ zebra_route_map_init();
+
+ zebra_affinity_map_init();
+
+ install_node(&ip_node);
+ install_node(&protocol_node);
+
+ install_element(CONFIG_NODE, &allow_external_route_update_cmd);
+ install_element(CONFIG_NODE, &no_allow_external_route_update_cmd);
+
+ install_element(CONFIG_NODE, &ip_multicast_mode_cmd);
+ install_element(CONFIG_NODE, &no_ip_multicast_mode_cmd);
+
+ install_element(CONFIG_NODE, &zebra_nexthop_group_keep_cmd);
+ install_element(CONFIG_NODE, &ip_zebra_import_table_distance_cmd);
+ install_element(CONFIG_NODE, &no_ip_zebra_import_table_cmd);
+ install_element(CONFIG_NODE, &zebra_workqueue_timer_cmd);
+ install_element(CONFIG_NODE, &no_zebra_workqueue_timer_cmd);
+ install_element(CONFIG_NODE, &zebra_packet_process_cmd);
+ install_element(CONFIG_NODE, &no_zebra_packet_process_cmd);
+ install_element(CONFIG_NODE, &nexthop_group_use_enable_cmd);
+ install_element(CONFIG_NODE, &proto_nexthop_group_only_cmd);
+ install_element(CONFIG_NODE, &backup_nexthop_recursive_use_enable_cmd);
+
+ install_element(VIEW_NODE, &show_nexthop_group_cmd);
+ install_element(VIEW_NODE, &show_interface_nexthop_group_cmd);
+
+ install_element(VIEW_NODE, &show_vrf_cmd);
+ install_element(VIEW_NODE, &show_vrf_vni_cmd);
+ install_element(VIEW_NODE, &show_route_cmd);
+ install_element(VIEW_NODE, &show_ro_cmd);
+ install_element(VIEW_NODE, &show_route_detail_cmd);
+ install_element(VIEW_NODE, &show_route_summary_cmd);
+ install_element(VIEW_NODE, &show_ip_nht_cmd);
+
+ install_element(VIEW_NODE, &show_ip_rpf_cmd);
+ install_element(VIEW_NODE, &show_ip_rpf_addr_cmd);
+ install_element(VIEW_NODE, &show_ipv6_rpf_addr_cmd);
+
+ install_element(CONFIG_NODE, &ip_nht_default_route_cmd);
+ install_element(CONFIG_NODE, &no_ip_nht_default_route_cmd);
+ install_element(CONFIG_NODE, &ipv6_nht_default_route_cmd);
+ install_element(CONFIG_NODE, &no_ipv6_nht_default_route_cmd);
+ install_element(VRF_NODE, &ip_nht_default_route_cmd);
+ install_element(VRF_NODE, &no_ip_nht_default_route_cmd);
+ install_element(VRF_NODE, &ipv6_nht_default_route_cmd);
+ install_element(VRF_NODE, &no_ipv6_nht_default_route_cmd);
+ install_element(CONFIG_NODE, &rnh_hide_backups_cmd);
+
+ install_element(VIEW_NODE, &show_frr_cmd);
+ install_element(VIEW_NODE, &show_evpn_global_cmd);
+ install_element(VIEW_NODE, &show_evpn_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_vni_detail_cmd);
+ install_element(VIEW_NODE, &show_evpn_vni_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_l2_nh_cmd);
+ install_element(VIEW_NODE, &show_evpn_es_cmd);
+ install_element(VIEW_NODE, &show_evpn_es_evi_cmd);
+ install_element(VIEW_NODE, &show_evpn_access_vlan_cmd);
+ install_element(VIEW_NODE, &show_evpn_rmac_vni_mac_cmd);
+ install_element(VIEW_NODE, &show_evpn_rmac_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_rmac_vni_all_cmd);
+ install_element(VIEW_NODE, &show_evpn_nh_vni_ip_cmd);
+ install_element(VIEW_NODE, &show_evpn_nh_svd_ip_cmd);
+ install_element(VIEW_NODE, &show_evpn_nh_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_nh_svd_cmd);
+ install_element(VIEW_NODE, &show_evpn_nh_vni_all_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_all_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_all_detail_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_detail_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_all_vtep_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_mac_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_vtep_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_dad_cmd);
+ install_element(VIEW_NODE, &show_evpn_mac_vni_all_dad_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_all_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_all_detail_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_neigh_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_vtep_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_dad_cmd);
+ install_element(VIEW_NODE, &show_evpn_neigh_vni_all_dad_cmd);
+ install_element(ENABLE_NODE, &clear_evpn_dup_addr_cmd);
+ install_element(CONFIG_NODE, &evpn_accept_bgp_seq_cmd);
+ install_element(CONFIG_NODE, &no_evpn_accept_bgp_seq_cmd);
+
+ install_element(VIEW_NODE, &show_neigh_cmd);
+
+ install_element(VIEW_NODE, &show_pbr_ipset_cmd);
+ install_element(VIEW_NODE, &show_pbr_iptable_cmd);
+ install_element(VIEW_NODE, &show_pbr_rule_cmd);
+ install_element(CONFIG_NODE, &pbr_nexthop_resolve_cmd);
+ install_element(VIEW_NODE, &show_route_zebra_dump_cmd);
+
+ install_element(CONFIG_NODE, &evpn_mh_mac_holdtime_cmd);
+ install_element(CONFIG_NODE, &evpn_mh_neigh_holdtime_cmd);
+ install_element(CONFIG_NODE, &evpn_mh_startup_delay_cmd);
+ install_element(CONFIG_NODE, &evpn_mh_redirect_off_cmd);
+ install_element(CONFIG_NODE, &default_vrf_vni_mapping_cmd);
+ install_element(CONFIG_NODE, &no_default_vrf_vni_mapping_cmd);
+ install_element(VRF_NODE, &vrf_vni_mapping_cmd);
+ install_element(VRF_NODE, &no_vrf_vni_mapping_cmd);
+
+ install_element(VIEW_NODE, &show_dataplane_cmd);
+ install_element(VIEW_NODE, &show_dataplane_providers_cmd);
+ install_element(CONFIG_NODE, &zebra_dplane_queue_limit_cmd);
+ install_element(CONFIG_NODE, &no_zebra_dplane_queue_limit_cmd);
+
+ install_element(CONFIG_NODE, &ip_table_range_cmd);
+ install_element(VRF_NODE, &ip_table_range_cmd);
+
+#ifdef HAVE_NETLINK
+ install_element(CONFIG_NODE, &zebra_kernel_netlink_batch_tx_buf_cmd);
+ install_element(CONFIG_NODE, &no_zebra_kernel_netlink_batch_tx_buf_cmd);
+ install_element(CONFIG_NODE, &zebra_protodown_bit_cmd);
+ install_element(CONFIG_NODE, &no_zebra_protodown_bit_cmd);
+#endif /* HAVE_NETLINK */
+
+#ifdef HAVE_SCRIPTING
+ install_element(CONFIG_NODE, &zebra_on_rib_process_script_cmd);
+#endif /* HAVE_SCRIPTING */
+
+ install_element(VIEW_NODE, &zebra_show_routing_tables_summary_cmd);
+}