Adding upstream version 9.1.upstream/9.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 15995 insertions, 0 deletions

diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c
new file mode 100644
index 0000000..3a850a4
--- /dev/null
+++ b/bgpd/bgp_route.c
@@ -0,0 +1,15995 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* BGP routing information
+ * Copyright (C) 1996, 97, 98, 99 Kunihiro Ishiguro
+ * Copyright (C) 2016 Job Snijders <job@instituut.net>
+ */
+
+#include <zebra.h>
+#include <math.h>
+
+#include "printfrr.h"
+#include "frrstr.h"
+#include "prefix.h"
+#include "linklist.h"
+#include "memory.h"
+#include "command.h"
+#include "stream.h"
+#include "filter.h"
+#include "log.h"
+#include "routemap.h"
+#include "buffer.h"
+#include "sockunion.h"
+#include "plist.h"
+#include "frrevent.h"
+#include "workqueue.h"
+#include "queue.h"
+#include "memory.h"
+#include "srv6.h"
+#include "lib/json.h"
+#include "lib_errors.h"
+#include "zclient.h"
+#include "bgpd/bgpd.h"
+#include "bgpd/bgp_table.h"
+#include "bgpd/bgp_route.h"
+#include "bgpd/bgp_attr.h"
+#include "bgpd/bgp_debug.h"
+#include "bgpd/bgp_errors.h"
+#include "bgpd/bgp_aspath.h"
+#include "bgpd/bgp_regex.h"
+#include "bgpd/bgp_community.h"
+#include "bgpd/bgp_community_alias.h"
+#include "bgpd/bgp_ecommunity.h"
+#include "bgpd/bgp_lcommunity.h"
+#include "bgpd/bgp_clist.h"
+#include "bgpd/bgp_packet.h"
+#include "bgpd/bgp_filter.h"
+#include "bgpd/bgp_fsm.h"
+#include "bgpd/bgp_mplsvpn.h"
+#include "bgpd/bgp_nexthop.h"
+#include "bgpd/bgp_damp.h"
+#include "bgpd/bgp_advertise.h"
+#include "bgpd/bgp_zebra.h"
+#include "bgpd/bgp_vty.h"
+#include "bgpd/bgp_mpath.h"
+#include "bgpd/bgp_nht.h"
+#include "bgpd/bgp_updgrp.h"
+#include "bgpd/bgp_label.h"
+#include "bgpd/bgp_addpath.h"
+#include "bgpd/bgp_mac.h"
+#include "bgpd/bgp_network.h"
+#include "bgpd/bgp_trace.h"
+#include "bgpd/bgp_rpki.h"
+
+#ifdef ENABLE_BGP_VNC
+#include "bgpd/rfapi/rfapi_backend.h"
+#include "bgpd/rfapi/vnc_import_bgp.h"
+#include "bgpd/rfapi/vnc_export_bgp.h"
+#endif
+#include "bgpd/bgp_encap_types.h"
+#include "bgpd/bgp_encap_tlv.h"
+#include "bgpd/bgp_evpn.h"
+#include "bgpd/bgp_evpn_mh.h"
+#include "bgpd/bgp_evpn_vty.h"
+#include "bgpd/bgp_flowspec.h"
+#include "bgpd/bgp_flowspec_util.h"
+#include "bgpd/bgp_pbr.h"
+
+#include "bgpd/bgp_route_clippy.c"
+
+DEFINE_HOOK(bgp_snmp_update_stats,
+	    (struct bgp_dest *rn, struct bgp_path_info *pi, bool added),
+	    (rn, pi, added));
+
+DEFINE_HOOK(bgp_rpki_prefix_status,
+	    (struct peer *peer, struct attr *attr,
+	     const struct prefix *prefix),
+	    (peer, attr, prefix));
+
+/* Extern from bgp_dump.c */
+extern const char *bgp_origin_str[];
+extern const char *bgp_origin_long_str[];
+
+/* PMSI strings. */
+#define PMSI_TNLTYPE_STR_NO_INFO "No info"
+#define PMSI_TNLTYPE_STR_DEFAULT PMSI_TNLTYPE_STR_NO_INFO
+static const struct message bgp_pmsi_tnltype_str[] = {
+	{PMSI_TNLTYPE_NO_INFO, PMSI_TNLTYPE_STR_NO_INFO},
+	{PMSI_TNLTYPE_RSVP_TE_P2MP, "RSVP-TE P2MP"},
+	{PMSI_TNLTYPE_MLDP_P2MP, "mLDP P2MP"},
+	{PMSI_TNLTYPE_PIM_SSM, "PIM-SSM"},
+	{PMSI_TNLTYPE_PIM_SM, "PIM-SM"},
+	{PMSI_TNLTYPE_PIM_BIDIR, "PIM-BIDIR"},
+	{PMSI_TNLTYPE_INGR_REPL, "Ingress Replication"},
+	{PMSI_TNLTYPE_MLDP_MP2MP, "mLDP MP2MP"},
+	{0}
+};
+
+#define VRFID_NONE_STR "-"
+#define SOFT_RECONFIG_TASK_MAX_PREFIX 25000
+
+DEFINE_HOOK(bgp_process,
+	    (struct bgp * bgp, afi_t afi, safi_t safi, struct bgp_dest *bn,
+	     struct peer *peer, bool withdraw),
+	    (bgp, afi, safi, bn, peer, withdraw));
+
+/** Test if path is suppressed. */
+static bool bgp_path_suppressed(struct bgp_path_info *pi)
+{
+	if (pi->extra == NULL || pi->extra->aggr_suppressors == NULL)
+		return false;
+
+	return listcount(pi->extra->aggr_suppressors) > 0;
+}
+
+struct bgp_dest *bgp_afi_node_get(struct bgp_table *table, afi_t afi,
+				  safi_t safi, const struct prefix *p,
+				  struct prefix_rd *prd)
+{
+	struct bgp_dest *dest;
+	struct bgp_dest *pdest = NULL;
+
+	assert(table);
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+	    || (safi == SAFI_EVPN)) {
+		pdest = bgp_node_get(table, (struct prefix *)prd);
+
+		if (!bgp_dest_has_bgp_path_info_data(pdest))
+			bgp_dest_set_bgp_table_info(
+				pdest, bgp_table_init(table->bgp, afi, safi));
+		else
+			pdest = bgp_dest_unlock_node(pdest);
+
+		assert(pdest);
+		table = bgp_dest_get_bgp_table_info(pdest);
+	}
+
+	dest = bgp_node_get(table, p);
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+	    || (safi == SAFI_EVPN))
+		dest->pdest = pdest;
+
+	return dest;
+}
+
+struct bgp_dest *bgp_safi_node_lookup(struct bgp_table *table, safi_t safi,
+				      const struct prefix *p,
+				      struct prefix_rd *prd)
+{
+	struct bgp_dest *dest;
+	struct bgp_dest *pdest = NULL;
+
+	if (!table)
+		return NULL;
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+	    || (safi == SAFI_EVPN)) {
+		pdest = bgp_node_lookup(table, (struct prefix *)prd);
+		if (!pdest)
+			return NULL;
+
+		if (!bgp_dest_has_bgp_path_info_data(pdest)) {
+			bgp_dest_unlock_node(pdest);
+			return NULL;
+		}
+
+		table = bgp_dest_get_bgp_table_info(pdest);
+	}
+
+	dest = bgp_node_lookup(table, p);
+
+	return dest;
+}
+
+/* Allocate bgp_path_info_extra */
+static struct bgp_path_info_extra *bgp_path_info_extra_new(void)
+{
+	struct bgp_path_info_extra *new;
+	new = XCALLOC(MTYPE_BGP_ROUTE_EXTRA,
+		      sizeof(struct bgp_path_info_extra));
+	new->label[0] = MPLS_INVALID_LABEL;
+	new->num_labels = 0;
+	new->flowspec = NULL;
+	return new;
+}
+
+void bgp_path_info_extra_free(struct bgp_path_info_extra **extra)
+{
+	struct bgp_path_info_extra *e;
+
+	if (!extra || !*extra)
+		return;
+
+	e = *extra;
+	if (e->damp_info)
+		bgp_damp_info_free(e->damp_info, 0, e->damp_info->afi,
+				   e->damp_info->safi);
+
+	e->damp_info = NULL;
+	if (e->vrfleak && e->vrfleak->parent) {
+		struct bgp_path_info *bpi =
+			(struct bgp_path_info *)e->vrfleak->parent;
+
+		if (bpi->net) {
+			/* FIXME: since multiple e may have the same e->parent
+			 * and e->parent->net is holding a refcount for each
+			 * of them, we need to do some fudging here.
+			 *
+			 * WARNING: if bpi->net->lock drops to 0, bpi may be
+			 * freed as well (because bpi->net was holding the
+			 * last reference to bpi) => write after free!
+			 */
+			unsigned refcount;
+
+			bpi = bgp_path_info_lock(bpi);
+			refcount = bgp_dest_get_lock_count(bpi->net) - 1;
+			bgp_dest_unlock_node((struct bgp_dest *)bpi->net);
+			if (!refcount)
+				bpi->net = NULL;
+			bgp_path_info_unlock(bpi);
+		}
+		bgp_path_info_unlock(e->vrfleak->parent);
+		e->vrfleak->parent = NULL;
+	}
+
+	if (e->vrfleak && e->vrfleak->bgp_orig)
+		bgp_unlock(e->vrfleak->bgp_orig);
+
+	if (e->vrfleak && e->vrfleak->peer_orig)
+		peer_unlock(e->vrfleak->peer_orig);
+
+	if (e->aggr_suppressors)
+		list_delete(&e->aggr_suppressors);
+
+	if (e->evpn && e->evpn->mh_info)
+		bgp_evpn_path_mh_info_free(e->evpn->mh_info);
+
+	if ((*extra)->flowspec && (*extra)->flowspec->bgp_fs_iprule)
+		list_delete(&((*extra)->flowspec->bgp_fs_iprule));
+	if ((*extra)->flowspec && (*extra)->flowspec->bgp_fs_pbr)
+		list_delete(&((*extra)->flowspec->bgp_fs_pbr));
+
+	if (e->evpn)
+		XFREE(MTYPE_BGP_ROUTE_EXTRA_EVPN, e->evpn);
+	if (e->flowspec)
+		XFREE(MTYPE_BGP_ROUTE_EXTRA_FS, e->flowspec);
+	if (e->vrfleak)
+		XFREE(MTYPE_BGP_ROUTE_EXTRA_VRFLEAK, e->vrfleak);
+
+	XFREE(MTYPE_BGP_ROUTE_EXTRA, *extra);
+}
+
+/* Get bgp_path_info extra information for the given bgp_path_info, lazy
+ * allocated if required.
+ */
+struct bgp_path_info_extra *bgp_path_info_extra_get(struct bgp_path_info *pi)
+{
+	if (!pi->extra)
+		pi->extra = bgp_path_info_extra_new();
+	if (!pi->extra->evpn && pi->net && pi->net->rn->p.family == AF_EVPN)
+		pi->extra->evpn =
+			XCALLOC(MTYPE_BGP_ROUTE_EXTRA_EVPN,
+				sizeof(struct bgp_path_info_extra_evpn));
+	return pi->extra;
+}
+
+/* Free bgp route information. */
+void bgp_path_info_free_with_caller(const char *name,
+				    struct bgp_path_info *path)
+{
+	frrtrace(2, frr_bgp, bgp_path_info_free, path, name);
+	bgp_attr_unintern(&path->attr);
+
+	bgp_unlink_nexthop(path);
+	bgp_path_info_extra_free(&path->extra);
+	bgp_path_info_mpath_free(&path->mpath);
+	if (path->net)
+		bgp_addpath_free_info_data(&path->tx_addpath,
+					   &path->net->tx_addpath);
+
+	peer_unlock(path->peer); /* bgp_path_info peer reference */
+
+	XFREE(MTYPE_BGP_ROUTE, path);
+}
+
+struct bgp_path_info *bgp_path_info_lock(struct bgp_path_info *path)
+{
+	path->lock++;
+	return path;
+}
+
+struct bgp_path_info *bgp_path_info_unlock(struct bgp_path_info *path)
+{
+	assert(path && path->lock > 0);
+	path->lock--;
+
+	if (path->lock == 0) {
+		bgp_path_info_free(path);
+		return NULL;
+	}
+
+	return path;
+}
+
+bool bgp_path_info_nexthop_changed(struct bgp_path_info *pi, struct peer *to,
+				   afi_t afi)
+{
+	if (pi->peer->sort == BGP_PEER_IBGP && to->sort == BGP_PEER_IBGP &&
+	    !CHECK_FLAG(to->af_flags[afi][SAFI_MPLS_VPN],
+			PEER_FLAG_FORCE_NEXTHOP_SELF))
+		/* IBGP RR with no nexthop self force configured */
+		return false;
+
+	if (to->sort == BGP_PEER_IBGP &&
+	    !CHECK_FLAG(to->af_flags[afi][SAFI_MPLS_VPN],
+			PEER_FLAG_NEXTHOP_SELF))
+		/* IBGP RR with no nexthop self configured */
+		return false;
+
+	if (CHECK_FLAG(to->af_flags[afi][SAFI_MPLS_VPN],
+		       PEER_FLAG_NEXTHOP_UNCHANGED))
+		/* IBGP or EBGP with nexthop attribute unchanged */
+		return false;
+
+	return true;
+}
+
+/* This function sets flag BGP_NODE_SELECT_DEFER based on condition */
+static int bgp_dest_set_defer_flag(struct bgp_dest *dest, bool delete)
+{
+	struct peer *peer;
+	struct bgp_path_info *old_pi, *nextpi;
+	bool set_flag = false;
+	struct bgp *bgp = NULL;
+	struct bgp_table *table = NULL;
+	afi_t afi = 0;
+	safi_t safi = 0;
+
+	/* If the flag BGP_NODE_SELECT_DEFER is set and new path is added
+	 * then the route selection is deferred
+	 */
+	if (CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER) && (!delete))
+		return 0;
+
+	if (CHECK_FLAG(dest->flags, BGP_NODE_PROCESS_SCHEDULED)) {
+		if (BGP_DEBUG(update, UPDATE_OUT)) {
+			table = bgp_dest_table(dest);
+			if (table)
+				bgp = table->bgp;
+
+			zlog_debug(
+				"Route %pBD(%s) is in workqueue and being processed, not deferred.",
+				dest, bgp ? bgp->name_pretty : "(Unknown)");
+		}
+
+		return 0;
+	}
+
+	table = bgp_dest_table(dest);
+	if (table) {
+		bgp = table->bgp;
+		afi = table->afi;
+		safi = table->safi;
+	}
+
+	for (old_pi = bgp_dest_get_bgp_path_info(dest);
+	     (old_pi != NULL) && (nextpi = old_pi->next, 1); old_pi = nextpi) {
+		if (CHECK_FLAG(old_pi->flags, BGP_PATH_SELECTED))
+			continue;
+
+		/* Route selection is deferred if there is a stale path which
+		 * which indicates peer is in restart mode
+		 */
+		if (CHECK_FLAG(old_pi->flags, BGP_PATH_STALE)
+		    && (old_pi->sub_type == BGP_ROUTE_NORMAL)) {
+			set_flag = true;
+		} else {
+			/* If the peer is graceful restart capable and peer is
+			 * restarting mode, set the flag BGP_NODE_SELECT_DEFER
+			 */
+			peer = old_pi->peer;
+			if (BGP_PEER_GRACEFUL_RESTART_CAPABLE(peer)
+			    && BGP_PEER_RESTARTING_MODE(peer)
+			    && (old_pi
+				&& old_pi->sub_type == BGP_ROUTE_NORMAL)) {
+				set_flag = true;
+			}
+		}
+		if (set_flag)
+			break;
+	}
+
+	/* Set the flag BGP_NODE_SELECT_DEFER if route selection deferral timer
+	 * is active
+	 */
+	if (set_flag && table) {
+		if (bgp && (bgp->gr_info[afi][safi].t_select_deferral)) {
+			if (!CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER))
+				bgp->gr_info[afi][safi].gr_deferred++;
+			SET_FLAG(dest->flags, BGP_NODE_SELECT_DEFER);
+			if (BGP_DEBUG(update, UPDATE_OUT))
+				zlog_debug("DEFER route %pBD(%s), dest %p",
+					   dest, bgp->name_pretty, dest);
+			return 0;
+		}
+	}
+	return -1;
+}
+
+void bgp_path_info_add_with_caller(const char *name, struct bgp_dest *dest,
+				   struct bgp_path_info *pi)
+{
+	frrtrace(3, frr_bgp, bgp_path_info_add, dest, pi, name);
+	struct bgp_path_info *top;
+
+	top = bgp_dest_get_bgp_path_info(dest);
+
+	pi->next = top;
+	pi->prev = NULL;
+	if (top)
+		top->prev = pi;
+	bgp_dest_set_bgp_path_info(dest, pi);
+
+	bgp_path_info_lock(pi);
+	bgp_dest_lock_node(dest);
+	peer_lock(pi->peer); /* bgp_path_info peer reference */
+	bgp_dest_set_defer_flag(dest, false);
+	hook_call(bgp_snmp_update_stats, dest, pi, true);
+}
+
+/* Do the actual removal of info from RIB, for use by bgp_process
+   completion callback *only* */
+struct bgp_dest *bgp_path_info_reap(struct bgp_dest *dest,
+				    struct bgp_path_info *pi)
+{
+	if (pi->next)
+		pi->next->prev = pi->prev;
+	if (pi->prev)
+		pi->prev->next = pi->next;
+	else
+		bgp_dest_set_bgp_path_info(dest, pi->next);
+
+	bgp_path_info_mpath_dequeue(pi);
+	bgp_path_info_unlock(pi);
+	hook_call(bgp_snmp_update_stats, dest, pi, false);
+
+	return bgp_dest_unlock_node(dest);
+}
+
+void bgp_path_info_delete(struct bgp_dest *dest, struct bgp_path_info *pi)
+{
+	bgp_path_info_set_flag(dest, pi, BGP_PATH_REMOVED);
+	/* set of previous already took care of pcount */
+	UNSET_FLAG(pi->flags, BGP_PATH_VALID);
+}
+
+/* undo the effects of a previous call to bgp_path_info_delete; typically
+   called when a route is deleted and then quickly re-added before the
+   deletion has been processed */
+void bgp_path_info_restore(struct bgp_dest *dest, struct bgp_path_info *pi)
+{
+	bgp_path_info_unset_flag(dest, pi, BGP_PATH_REMOVED);
+	/* unset of previous already took care of pcount */
+	SET_FLAG(pi->flags, BGP_PATH_VALID);
+}
+
+/* Adjust pcount as required */
+static void bgp_pcount_adjust(struct bgp_dest *dest, struct bgp_path_info *pi)
+{
+	struct bgp_table *table;
+
+	assert(dest && bgp_dest_table(dest));
+	assert(pi && pi->peer && pi->peer->bgp);
+
+	table = bgp_dest_table(dest);
+
+	if (pi->peer == pi->peer->bgp->peer_self)
+		return;
+
+	if (!BGP_PATH_COUNTABLE(pi)
+	    && CHECK_FLAG(pi->flags, BGP_PATH_COUNTED)) {
+
+		UNSET_FLAG(pi->flags, BGP_PATH_COUNTED);
+
+		/* slight hack, but more robust against errors. */
+		if (pi->peer->pcount[table->afi][table->safi])
+			pi->peer->pcount[table->afi][table->safi]--;
+		else
+			flog_err(EC_LIB_DEVELOPMENT,
+				 "Asked to decrement 0 prefix count for peer");
+	} else if (BGP_PATH_COUNTABLE(pi)
+		   && !CHECK_FLAG(pi->flags, BGP_PATH_COUNTED)) {
+		SET_FLAG(pi->flags, BGP_PATH_COUNTED);
+		pi->peer->pcount[table->afi][table->safi]++;
+	}
+}
+
+static int bgp_label_index_differs(struct bgp_path_info *pi1,
+				   struct bgp_path_info *pi2)
+{
+	return (!(pi1->attr->label_index == pi2->attr->label_index));
+}
+
+/* Set/unset bgp_path_info flags, adjusting any other state as needed.
+ * This is here primarily to keep prefix-count in check.
+ */
+void bgp_path_info_set_flag(struct bgp_dest *dest, struct bgp_path_info *pi,
+			    uint32_t flag)
+{
+	SET_FLAG(pi->flags, flag);
+
+	/* early bath if we know it's not a flag that changes countability state
+	 */
+	if (!CHECK_FLAG(flag,
+			BGP_PATH_VALID | BGP_PATH_HISTORY | BGP_PATH_REMOVED))
+		return;
+
+	bgp_pcount_adjust(dest, pi);
+}
+
+void bgp_path_info_unset_flag(struct bgp_dest *dest, struct bgp_path_info *pi,
+			      uint32_t flag)
+{
+	UNSET_FLAG(pi->flags, flag);
+
+	/* early bath if we know it's not a flag that changes countability state
+	 */
+	if (!CHECK_FLAG(flag,
+			BGP_PATH_VALID | BGP_PATH_HISTORY | BGP_PATH_REMOVED))
+		return;
+
+	bgp_pcount_adjust(dest, pi);
+}
+
+/* Get MED value.  If MED value is missing and "bgp bestpath
+   missing-as-worst" is specified, treat it as the worst value. */
+static uint32_t bgp_med_value(struct attr *attr, struct bgp *bgp)
+{
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
+		return attr->med;
+	else {
+		if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST))
+			return BGP_MED_MAX;
+		else
+			return 0;
+	}
+}
+
+void bgp_path_info_path_with_addpath_rx_str(struct bgp_path_info *pi, char *buf,
+					    size_t buf_len)
+{
+	struct peer *peer;
+
+	if (pi->sub_type == BGP_ROUTE_IMPORTED &&
+	    bgp_get_imported_bpi_ultimate(pi))
+		peer = bgp_get_imported_bpi_ultimate(pi)->peer;
+	else
+		peer = pi->peer;
+
+	if (pi->addpath_rx_id)
+		snprintf(buf, buf_len, "path %s (addpath rxid %d)", peer->host,
+			 pi->addpath_rx_id);
+	else
+		snprintf(buf, buf_len, "path %s", peer->host);
+}
+
+
+/*
+ * Get the ultimate path info.
+ */
+struct bgp_path_info *bgp_get_imported_bpi_ultimate(struct bgp_path_info *info)
+{
+	struct bgp_path_info *bpi_ultimate;
+
+	if (info->sub_type != BGP_ROUTE_IMPORTED)
+		return info;
+
+	for (bpi_ultimate = info;
+	     bpi_ultimate->extra && bpi_ultimate->extra->vrfleak &&
+	     bpi_ultimate->extra->vrfleak->parent;
+	     bpi_ultimate = bpi_ultimate->extra->vrfleak->parent)
+		;
+
+	return bpi_ultimate;
+}
+
+/* Compare two bgp route entity.  If 'new' is preferable over 'exist' return 1.
+ */
+int bgp_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
+		      struct bgp_path_info *exist, int *paths_eq,
+		      struct bgp_maxpaths_cfg *mpath_cfg, bool debug,
+		      char *pfx_buf, afi_t afi, safi_t safi,
+		      enum bgp_path_selection_reason *reason)
+{
+	const struct prefix *new_p;
+	struct attr *newattr, *existattr;
+	enum bgp_peer_sort new_sort;
+	enum bgp_peer_sort exist_sort;
+	uint32_t new_pref;
+	uint32_t exist_pref;
+	uint32_t new_med;
+	uint32_t exist_med;
+	uint32_t new_weight;
+	uint32_t exist_weight;
+	uint32_t newm, existm;
+	struct in_addr new_id;
+	struct in_addr exist_id;
+	int new_cluster;
+	int exist_cluster;
+	int internal_as_route;
+	int confed_as_route;
+	int ret = 0;
+	int igp_metric_ret = 0;
+	int peer_sort_ret = -1;
+	char new_buf[PATH_ADDPATH_STR_BUFFER];
+	char exist_buf[PATH_ADDPATH_STR_BUFFER];
+	uint32_t new_mm_seq;
+	uint32_t exist_mm_seq;
+	int nh_cmp;
+	esi_t *exist_esi;
+	esi_t *new_esi;
+	bool same_esi;
+	bool old_proxy;
+	bool new_proxy;
+	bool new_origin, exist_origin;
+	struct bgp_path_info *bpi_ultimate;
+	struct peer *peer_new, *peer_exist;
+
+	*paths_eq = 0;
+
+	/* 0. Null check. */
+	if (new == NULL) {
+		*reason = bgp_path_selection_none;
+		if (debug)
+			zlog_debug("%s: new is NULL", pfx_buf);
+		return 0;
+	}
+
+	if (debug) {
+		bpi_ultimate = bgp_get_imported_bpi_ultimate(new);
+		bgp_path_info_path_with_addpath_rx_str(bpi_ultimate, new_buf,
+						       sizeof(new_buf));
+	}
+
+	if (exist == NULL) {
+		*reason = bgp_path_selection_first;
+		if (debug)
+			zlog_debug("%s(%s): %s is the initial bestpath",
+				   pfx_buf, bgp->name_pretty, new_buf);
+		return 1;
+	}
+
+	if (debug) {
+		bpi_ultimate = bgp_get_imported_bpi_ultimate(exist);
+		bgp_path_info_path_with_addpath_rx_str(bpi_ultimate, exist_buf,
+						       sizeof(exist_buf));
+		zlog_debug("%s(%s): Comparing %s flags 0x%x with %s flags 0x%x",
+			   pfx_buf, bgp->name_pretty, new_buf, new->flags,
+			   exist_buf, exist->flags);
+	}
+
+	newattr = new->attr;
+	existattr = exist->attr;
+
+	/* A BGP speaker that has advertised the "Long-lived Graceful Restart
+	 * Capability" to a neighbor MUST perform the following upon receiving
+	 * a route from that neighbor with the "LLGR_STALE" community, or upon
+	 * attaching the "LLGR_STALE" community itself per Section 4.2:
+	 *
+	 * Treat the route as the least-preferred in route selection (see
+	 * below). See the Risks of Depreferencing Routes section (Section 5.2)
+	 * for a discussion of potential risks inherent in doing this.
+	 */
+	if (bgp_attr_get_community(newattr) &&
+	    community_include(bgp_attr_get_community(newattr),
+			      COMMUNITY_LLGR_STALE)) {
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to LLGR_STALE community",
+				pfx_buf, new_buf, exist_buf);
+		return 0;
+	}
+
+	if (bgp_attr_get_community(existattr) &&
+	    community_include(bgp_attr_get_community(existattr),
+			      COMMUNITY_LLGR_STALE)) {
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to LLGR_STALE community",
+				pfx_buf, new_buf, exist_buf);
+		return 1;
+	}
+
+	new_p = bgp_dest_get_prefix(new->net);
+
+	/* For EVPN routes, we cannot just go by local vs remote, we have to
+	 * look at the MAC mobility sequence number, if present.
+	 */
+	if ((safi == SAFI_EVPN)
+	    && (new_p->u.prefix_evpn.route_type == BGP_EVPN_MAC_IP_ROUTE)) {
+		/* This is an error condition described in RFC 7432 Section
+		 * 15.2. The RFC
+		 * states that in this scenario "the PE MUST alert the operator"
+		 * but it
+		 * does not state what other action to take. In order to provide
+		 * some
+		 * consistency in this scenario we are going to prefer the path
+		 * with the
+		 * sticky flag.
+		 */
+		if (newattr->sticky != existattr->sticky) {
+			if (newattr->sticky && !existattr->sticky) {
+				*reason = bgp_path_selection_evpn_sticky_mac;
+				if (debug)
+					zlog_debug(
+						"%s: %s wins over %s due to sticky MAC flag",
+						pfx_buf, new_buf, exist_buf);
+				return 1;
+			}
+
+			if (!newattr->sticky && existattr->sticky) {
+				*reason = bgp_path_selection_evpn_sticky_mac;
+				if (debug)
+					zlog_debug(
+						"%s: %s loses to %s due to sticky MAC flag",
+						pfx_buf, new_buf, exist_buf);
+				return 0;
+			}
+		}
+
+		new_esi = bgp_evpn_attr_get_esi(newattr);
+		exist_esi = bgp_evpn_attr_get_esi(existattr);
+		if (bgp_evpn_is_esi_valid(new_esi) &&
+				!memcmp(new_esi, exist_esi, sizeof(esi_t))) {
+			same_esi = true;
+		} else {
+			same_esi = false;
+		}
+
+		/* If both paths have the same non-zero ES and
+		 * one path is local it wins.
+		 * PS: Note the local path wins even if the remote
+		 * has the higher MM seq. The local path's
+		 * MM seq will be fixed up to match the highest
+		 * rem seq, subsequently.
+		 */
+		if (same_esi) {
+			char esi_buf[ESI_STR_LEN];
+
+			if (bgp_evpn_is_path_local(bgp, new)) {
+				*reason = bgp_path_selection_evpn_local_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s wins over %s as ES %s is same and local",
+						pfx_buf, new_buf, exist_buf,
+						esi_to_str(new_esi, esi_buf,
+						sizeof(esi_buf)));
+				return 1;
+			}
+			if (bgp_evpn_is_path_local(bgp, exist)) {
+				*reason = bgp_path_selection_evpn_local_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s loses to %s as ES %s is same and local",
+						pfx_buf, new_buf, exist_buf,
+						esi_to_str(new_esi, esi_buf,
+						sizeof(esi_buf)));
+				return 0;
+			}
+		}
+
+		new_mm_seq = mac_mobility_seqnum(newattr);
+		exist_mm_seq = mac_mobility_seqnum(existattr);
+
+		if (new_mm_seq > exist_mm_seq) {
+			*reason = bgp_path_selection_evpn_seq;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to MM seq %u > %u",
+					pfx_buf, new_buf, exist_buf, new_mm_seq,
+					exist_mm_seq);
+			return 1;
+		}
+
+		if (new_mm_seq < exist_mm_seq) {
+			*reason = bgp_path_selection_evpn_seq;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to MM seq %u < %u",
+					pfx_buf, new_buf, exist_buf, new_mm_seq,
+					exist_mm_seq);
+			return 0;
+		}
+
+		/* if the sequence numbers and ESI are the same and one path
+		 * is non-proxy it wins (over proxy)
+		 */
+		new_proxy = bgp_evpn_attr_is_proxy(newattr);
+		old_proxy = bgp_evpn_attr_is_proxy(existattr);
+		if (same_esi && bgp_evpn_attr_is_local_es(newattr) &&
+				old_proxy != new_proxy) {
+			if (!new_proxy) {
+				*reason = bgp_path_selection_evpn_non_proxy;
+				if (debug)
+					zlog_debug(
+						"%s: %s wins over %s, same seq/es and non-proxy",
+						pfx_buf, new_buf, exist_buf);
+				return 1;
+			}
+
+			*reason = bgp_path_selection_evpn_non_proxy;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s, same seq/es and non-proxy",
+					pfx_buf, new_buf, exist_buf);
+			return 0;
+		}
+
+		/*
+		 * if sequence numbers are the same path with the lowest IP
+		 * wins
+		 */
+		nh_cmp = bgp_path_info_nexthop_cmp(new, exist);
+		if (nh_cmp < 0) {
+			*reason = bgp_path_selection_evpn_lower_ip;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to same MM seq %u and lower IP %pI4",
+					pfx_buf, new_buf, exist_buf, new_mm_seq,
+					&new->attr->nexthop);
+			return 1;
+		}
+		if (nh_cmp > 0) {
+			*reason = bgp_path_selection_evpn_lower_ip;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to same MM seq %u and higher IP %pI4",
+					pfx_buf, new_buf, exist_buf, new_mm_seq,
+					&new->attr->nexthop);
+			return 0;
+		}
+	}
+
+	/* 1. Weight check. */
+	new_weight = newattr->weight;
+	exist_weight = existattr->weight;
+
+	if (new_weight > exist_weight) {
+		*reason = bgp_path_selection_weight;
+		if (debug)
+			zlog_debug("%s: %s wins over %s due to weight %d > %d",
+				   pfx_buf, new_buf, exist_buf, new_weight,
+				   exist_weight);
+		return 1;
+	}
+
+	if (new_weight < exist_weight) {
+		*reason = bgp_path_selection_weight;
+		if (debug)
+			zlog_debug("%s: %s loses to %s due to weight %d < %d",
+				   pfx_buf, new_buf, exist_buf, new_weight,
+				   exist_weight);
+		return 0;
+	}
+
+	/* 2. Local preference check. */
+	new_pref = exist_pref = bgp->default_local_pref;
+
+	if (newattr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
+		new_pref = newattr->local_pref;
+	if (existattr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
+		exist_pref = existattr->local_pref;
+
+	if (new_pref > exist_pref) {
+		*reason = bgp_path_selection_local_pref;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to localpref %d > %d",
+				pfx_buf, new_buf, exist_buf, new_pref,
+				exist_pref);
+		return 1;
+	}
+
+	if (new_pref < exist_pref) {
+		*reason = bgp_path_selection_local_pref;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to localpref %d < %d",
+				pfx_buf, new_buf, exist_buf, new_pref,
+				exist_pref);
+		return 0;
+	}
+
+	/* If a BGP speaker supports ACCEPT_OWN and is configured for the
+	 * extensions defined in this document, the following step is inserted
+	 * after the LOCAL_PREF comparison step in the BGP decision process:
+	 *	When comparing a pair of routes for a BGP destination, the
+	 *	route with the ACCEPT_OWN community attached is preferred over
+	 *	the route that does not have the community.
+	 * This extra step MUST only be invoked during the best path selection
+	 * process of VPN-IP routes.
+	 */
+	if (safi == SAFI_MPLS_VPN &&
+	    (CHECK_FLAG(new->peer->af_flags[afi][safi], PEER_FLAG_ACCEPT_OWN) ||
+	     CHECK_FLAG(exist->peer->af_flags[afi][safi],
+			PEER_FLAG_ACCEPT_OWN))) {
+		bool new_accept_own = false;
+		bool exist_accept_own = false;
+		uint32_t accept_own = COMMUNITY_ACCEPT_OWN;
+
+		if (newattr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))
+			new_accept_own = community_include(
+				bgp_attr_get_community(newattr), accept_own);
+		if (existattr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))
+			exist_accept_own = community_include(
+				bgp_attr_get_community(existattr), accept_own);
+
+		if (new_accept_own && !exist_accept_own) {
+			*reason = bgp_path_selection_accept_own;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to accept-own",
+					pfx_buf, new_buf, exist_buf);
+			return 1;
+		}
+
+		if (!new_accept_own && exist_accept_own) {
+			*reason = bgp_path_selection_accept_own;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to accept-own",
+					pfx_buf, new_buf, exist_buf);
+			return 0;
+		}
+	}
+
+	/* Tie-breaker - AIGP (Metric TLV) attribute */
+	if (CHECK_FLAG(newattr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) &&
+	    CHECK_FLAG(existattr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) &&
+	    CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_AIGP)) {
+		uint64_t new_aigp = bgp_attr_get_aigp_metric(newattr);
+		uint64_t exist_aigp = bgp_attr_get_aigp_metric(existattr);
+
+		if (new_aigp < exist_aigp) {
+			*reason = bgp_path_selection_aigp;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to AIGP %" PRIu64
+					" < %" PRIu64,
+					pfx_buf, new_buf, exist_buf, new_aigp,
+					exist_aigp);
+			return 1;
+		}
+
+		if (new_aigp > exist_aigp) {
+			*reason = bgp_path_selection_aigp;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to AIGP %" PRIu64
+					" > %" PRIu64,
+					pfx_buf, new_buf, exist_buf, new_aigp,
+					exist_aigp);
+			return 0;
+		}
+	}
+
+	/* 3. Local route check. We prefer:
+	 *  - BGP_ROUTE_STATIC
+	 *  - BGP_ROUTE_AGGREGATE
+	 *  - BGP_ROUTE_REDISTRIBUTE
+	 */
+	new_origin = !(new->sub_type == BGP_ROUTE_NORMAL ||
+		       new->sub_type == BGP_ROUTE_IMPORTED);
+	exist_origin = !(exist->sub_type == BGP_ROUTE_NORMAL ||
+			 exist->sub_type == BGP_ROUTE_IMPORTED);
+
+	if (new_origin && !exist_origin) {
+		*reason = bgp_path_selection_local_route;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to preferred BGP_ROUTE type",
+				pfx_buf, new_buf, exist_buf);
+		return 1;
+	}
+
+	if (!new_origin && exist_origin) {
+		*reason = bgp_path_selection_local_route;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to preferred BGP_ROUTE type",
+				pfx_buf, new_buf, exist_buf);
+		return 0;
+	}
+
+	/* Here if these are imported routes then get ultimate pi for
+	 * path compare.
+	 */
+	new = bgp_get_imported_bpi_ultimate(new);
+	exist = bgp_get_imported_bpi_ultimate(exist);
+	newattr = new->attr;
+	existattr = exist->attr;
+
+	/* 4. AS path length check. */
+	if (!CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_IGNORE)) {
+		int exist_hops = aspath_count_hops(existattr->aspath);
+		int exist_confeds = aspath_count_confeds(existattr->aspath);
+
+		if (CHECK_FLAG(bgp->flags, BGP_FLAG_ASPATH_CONFED)) {
+			int aspath_hops;
+
+			aspath_hops = aspath_count_hops(newattr->aspath);
+			aspath_hops += aspath_count_confeds(newattr->aspath);
+
+			if (aspath_hops < (exist_hops + exist_confeds)) {
+				*reason = bgp_path_selection_confed_as_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s wins over %s due to aspath (with confeds) hopcount %d < %d",
+						pfx_buf, new_buf, exist_buf,
+						aspath_hops,
+						(exist_hops + exist_confeds));
+				return 1;
+			}
+
+			if (aspath_hops > (exist_hops + exist_confeds)) {
+				*reason = bgp_path_selection_confed_as_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s loses to %s due to aspath (with confeds) hopcount %d > %d",
+						pfx_buf, new_buf, exist_buf,
+						aspath_hops,
+						(exist_hops + exist_confeds));
+				return 0;
+			}
+		} else {
+			int newhops = aspath_count_hops(newattr->aspath);
+
+			if (newhops < exist_hops) {
+				*reason = bgp_path_selection_as_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s wins over %s due to aspath hopcount %d < %d",
+						pfx_buf, new_buf, exist_buf,
+						newhops, exist_hops);
+				return 1;
+			}
+
+			if (newhops > exist_hops) {
+				*reason = bgp_path_selection_as_path;
+				if (debug)
+					zlog_debug(
+						"%s: %s loses to %s due to aspath hopcount %d > %d",
+						pfx_buf, new_buf, exist_buf,
+						newhops, exist_hops);
+				return 0;
+			}
+		}
+	}
+
+	/* 5. Origin check. */
+	if (newattr->origin < existattr->origin) {
+		*reason = bgp_path_selection_origin;
+		if (debug)
+			zlog_debug("%s: %s wins over %s due to ORIGIN %s < %s",
+				   pfx_buf, new_buf, exist_buf,
+				   bgp_origin_long_str[newattr->origin],
+				   bgp_origin_long_str[existattr->origin]);
+		return 1;
+	}
+
+	if (newattr->origin > existattr->origin) {
+		*reason = bgp_path_selection_origin;
+		if (debug)
+			zlog_debug("%s: %s loses to %s due to ORIGIN %s > %s",
+				   pfx_buf, new_buf, exist_buf,
+				   bgp_origin_long_str[newattr->origin],
+				   bgp_origin_long_str[existattr->origin]);
+		return 0;
+	}
+
+	/* 6. MED check. */
+	internal_as_route = (aspath_count_hops(newattr->aspath) == 0
+			     && aspath_count_hops(existattr->aspath) == 0);
+	confed_as_route = (aspath_count_confeds(newattr->aspath) > 0
+			   && aspath_count_confeds(existattr->aspath) > 0
+			   && aspath_count_hops(newattr->aspath) == 0
+			   && aspath_count_hops(existattr->aspath) == 0);
+
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_ALWAYS_COMPARE_MED)
+	    || (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_CONFED) && confed_as_route)
+	    || aspath_cmp_left(newattr->aspath, existattr->aspath)
+	    || aspath_cmp_left_confed(newattr->aspath, existattr->aspath)
+	    || internal_as_route) {
+		new_med = bgp_med_value(new->attr, bgp);
+		exist_med = bgp_med_value(exist->attr, bgp);
+
+		if (new_med < exist_med) {
+			*reason = bgp_path_selection_med;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to MED %d < %d",
+					pfx_buf, new_buf, exist_buf, new_med,
+					exist_med);
+			return 1;
+		}
+
+		if (new_med > exist_med) {
+			*reason = bgp_path_selection_med;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to MED %d > %d",
+					pfx_buf, new_buf, exist_buf, new_med,
+					exist_med);
+			return 0;
+		}
+	}
+
+	if (exist->sub_type == BGP_ROUTE_IMPORTED) {
+		bpi_ultimate = bgp_get_imported_bpi_ultimate(exist);
+		peer_exist = bpi_ultimate->peer;
+	} else
+		peer_exist = exist->peer;
+
+	if (new->sub_type == BGP_ROUTE_IMPORTED) {
+		bpi_ultimate = bgp_get_imported_bpi_ultimate(new);
+		peer_new = bpi_ultimate->peer;
+	} else
+		peer_new = new->peer;
+
+	/* 7. Peer type check. */
+	new_sort = peer_new->sort;
+	exist_sort = peer_exist->sort;
+
+	if (new_sort == BGP_PEER_EBGP
+	    && (exist_sort == BGP_PEER_IBGP || exist_sort == BGP_PEER_CONFED)) {
+		*reason = bgp_path_selection_peer;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to eBGP peer > iBGP peer",
+				pfx_buf, new_buf, exist_buf);
+		if (!CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
+			return 1;
+		peer_sort_ret = 1;
+	}
+
+	if (exist_sort == BGP_PEER_EBGP
+	    && (new_sort == BGP_PEER_IBGP || new_sort == BGP_PEER_CONFED)) {
+		*reason = bgp_path_selection_peer;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to iBGP peer < eBGP peer",
+				pfx_buf, new_buf, exist_buf);
+		if (!CHECK_FLAG(bgp->flags, BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
+			return 0;
+		peer_sort_ret = 0;
+	}
+
+	/* 8. IGP metric check. */
+	newm = existm = 0;
+
+	if (new->extra)
+		newm = new->extra->igpmetric;
+	if (exist->extra)
+		existm = exist->extra->igpmetric;
+
+	if (newm < existm) {
+		if (debug && peer_sort_ret < 0)
+			zlog_debug(
+				"%s: %s wins over %s due to IGP metric %u < %u",
+				pfx_buf, new_buf, exist_buf, newm, existm);
+		igp_metric_ret = 1;
+	}
+
+	if (newm > existm) {
+		if (debug && peer_sort_ret < 0)
+			zlog_debug(
+				"%s: %s loses to %s due to IGP metric %u > %u",
+				pfx_buf, new_buf, exist_buf, newm, existm);
+		igp_metric_ret = 0;
+	}
+
+	/* 9. Same IGP metric. Compare the cluster list length as
+	   representative of IGP hops metric. Rewrite the metric value
+	   pair (newm, existm) with the cluster list length. Prefer the
+	   path with smaller cluster list length.                       */
+	if (newm == existm) {
+		if (peer_sort_lookup(peer_new) == BGP_PEER_IBGP &&
+		    peer_sort_lookup(peer_exist) == BGP_PEER_IBGP &&
+		    (mpath_cfg == NULL || mpath_cfg->same_clusterlen)) {
+			newm = BGP_CLUSTER_LIST_LENGTH(new->attr);
+			existm = BGP_CLUSTER_LIST_LENGTH(exist->attr);
+
+			if (newm < existm) {
+				if (debug && peer_sort_ret < 0)
+					zlog_debug(
+						"%s: %s wins over %s due to CLUSTER_LIST length %u < %u",
+						pfx_buf, new_buf, exist_buf,
+						newm, existm);
+				igp_metric_ret = 1;
+			}
+
+			if (newm > existm) {
+				if (debug && peer_sort_ret < 0)
+					zlog_debug(
+						"%s: %s loses to %s due to CLUSTER_LIST length %u > %u",
+						pfx_buf, new_buf, exist_buf,
+						newm, existm);
+				igp_metric_ret = 0;
+			}
+		}
+	}
+
+	/* 10. confed-external vs. confed-internal */
+	if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)) {
+		if (new_sort == BGP_PEER_CONFED
+		    && exist_sort == BGP_PEER_IBGP) {
+			*reason = bgp_path_selection_confed;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to confed-external peer > confed-internal peer",
+					pfx_buf, new_buf, exist_buf);
+			if (!CHECK_FLAG(bgp->flags,
+					BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
+				return 1;
+			peer_sort_ret = 1;
+		}
+
+		if (exist_sort == BGP_PEER_CONFED
+		    && new_sort == BGP_PEER_IBGP) {
+			*reason = bgp_path_selection_confed;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to confed-internal peer < confed-external peer",
+					pfx_buf, new_buf, exist_buf);
+			if (!CHECK_FLAG(bgp->flags,
+					BGP_FLAG_PEERTYPE_MULTIPATH_RELAX))
+				return 0;
+			peer_sort_ret = 0;
+		}
+	}
+
+	/* 11. Maximum path check. */
+	if (newm == existm) {
+		/* If one path has a label but the other does not, do not treat
+		 * them as equals for multipath
+		 */
+		int newl, existl;
+
+		newl = existl = 0;
+
+		if (new->extra)
+			newl = new->extra->num_labels;
+		if (exist->extra)
+			existl = exist->extra->num_labels;
+		if (((new->extra &&bgp_is_valid_label(&new->extra->label[0])) !=
+		     (exist->extra &&
+		      bgp_is_valid_label(&exist->extra->label[0]))) ||
+		    (newl != existl)) {
+			if (debug)
+				zlog_debug(
+					"%s: %s and %s cannot be multipath, one has a label while the other does not",
+					pfx_buf, new_buf, exist_buf);
+		} else if (CHECK_FLAG(bgp->flags,
+				      BGP_FLAG_ASPATH_MULTIPATH_RELAX)) {
+
+			/*
+			 * For the two paths, all comparison steps till IGP
+			 * metric
+			 * have succeeded - including AS_PATH hop count. Since
+			 * 'bgp
+			 * bestpath as-path multipath-relax' knob is on, we
+			 * don't need
+			 * an exact match of AS_PATH. Thus, mark the paths are
+			 * equal.
+			 * That will trigger both these paths to get into the
+			 * multipath
+			 * array.
+			 */
+			*paths_eq = 1;
+
+			if (debug)
+				zlog_debug(
+					"%s: %s and %s are equal via multipath-relax",
+					pfx_buf, new_buf, exist_buf);
+		} else if (peer_new->sort == BGP_PEER_IBGP) {
+			if (aspath_cmp(new->attr->aspath,
+				       exist->attr->aspath)) {
+				*paths_eq = 1;
+
+				if (debug)
+					zlog_debug(
+						"%s: %s and %s are equal via matching aspaths",
+						pfx_buf, new_buf, exist_buf);
+			}
+		} else if (peer_new->as == peer_exist->as) {
+			*paths_eq = 1;
+
+			if (debug)
+				zlog_debug(
+					"%s: %s and %s are equal via same remote-as",
+					pfx_buf, new_buf, exist_buf);
+		}
+	} else {
+		/*
+		 * TODO: If unequal cost ibgp multipath is enabled we can
+		 * mark the paths as equal here instead of returning
+		 */
+
+		/* Prior to the addition of BGP_FLAG_PEERTYPE_MULTIPATH_RELAX,
+		 * if either step 7 or 10 (peer type checks) yielded a winner,
+		 * that result was returned immediately. Returning from step 10
+		 * ignored the return value computed in steps 8 and 9 (IGP
+		 * metric checks). In order to preserve that behavior, if
+		 * peer_sort_ret is set, return that rather than igp_metric_ret.
+		 */
+		ret = peer_sort_ret;
+		if (peer_sort_ret < 0) {
+			ret = igp_metric_ret;
+			if (debug) {
+				if (ret == 1)
+					zlog_debug(
+						"%s: %s wins over %s after IGP metric comparison",
+						pfx_buf, new_buf, exist_buf);
+				else
+					zlog_debug(
+						"%s: %s loses to %s after IGP metric comparison",
+						pfx_buf, new_buf, exist_buf);
+			}
+			*reason = bgp_path_selection_igp_metric;
+		}
+		return ret;
+	}
+
+	/*
+	 * At this point, the decision whether to set *paths_eq = 1 has been
+	 * completed. If we deferred returning because of bestpath peer-type
+	 * relax configuration, return now.
+	 */
+	if (peer_sort_ret >= 0)
+		return peer_sort_ret;
+
+	/* 12. If both paths are external, prefer the path that was received
+	   first (the oldest one).  This step minimizes route-flap, since a
+	   newer path won't displace an older one, even if it was the
+	   preferred route based on the additional decision criteria below.  */
+	if (!CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_ROUTER_ID)
+	    && new_sort == BGP_PEER_EBGP && exist_sort == BGP_PEER_EBGP) {
+		if (CHECK_FLAG(new->flags, BGP_PATH_SELECTED)) {
+			*reason = bgp_path_selection_older;
+			if (debug)
+				zlog_debug(
+					"%s: %s wins over %s due to oldest external",
+					pfx_buf, new_buf, exist_buf);
+			return 1;
+		}
+
+		if (CHECK_FLAG(exist->flags, BGP_PATH_SELECTED)) {
+			*reason = bgp_path_selection_older;
+			if (debug)
+				zlog_debug(
+					"%s: %s loses to %s due to oldest external",
+					pfx_buf, new_buf, exist_buf);
+			return 0;
+		}
+	}
+
+	/* 13. Router-ID comparison. */
+	/* If one of the paths is "stale", the corresponding peer router-id will
+	 * be 0 and would always win over the other path. If originator id is
+	 * used for the comparison, it will decide which path is better.
+	 */
+	if (newattr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
+		new_id.s_addr = newattr->originator_id.s_addr;
+	else
+		new_id.s_addr = peer_new->remote_id.s_addr;
+	if (existattr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
+		exist_id.s_addr = existattr->originator_id.s_addr;
+	else
+		exist_id.s_addr = peer_exist->remote_id.s_addr;
+
+	if (ntohl(new_id.s_addr) < ntohl(exist_id.s_addr)) {
+		*reason = bgp_path_selection_router_id;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to Router-ID comparison",
+				pfx_buf, new_buf, exist_buf);
+		return 1;
+	}
+
+	if (ntohl(new_id.s_addr) > ntohl(exist_id.s_addr)) {
+		*reason = bgp_path_selection_router_id;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to Router-ID comparison",
+				pfx_buf, new_buf, exist_buf);
+		return 0;
+	}
+
+	/* 14. Cluster length comparison. */
+	new_cluster = BGP_CLUSTER_LIST_LENGTH(new->attr);
+	exist_cluster = BGP_CLUSTER_LIST_LENGTH(exist->attr);
+
+	if (new_cluster < exist_cluster) {
+		*reason = bgp_path_selection_cluster_length;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to CLUSTER_LIST length %d < %d",
+				pfx_buf, new_buf, exist_buf, new_cluster,
+				exist_cluster);
+		return 1;
+	}
+
+	if (new_cluster > exist_cluster) {
+		*reason = bgp_path_selection_cluster_length;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to CLUSTER_LIST length %d > %d",
+				pfx_buf, new_buf, exist_buf, new_cluster,
+				exist_cluster);
+		return 0;
+	}
+
+	/* 15. Neighbor address comparison. */
+	/* Do this only if neither path is "stale" as stale paths do not have
+	 * valid peer information (as the connection may or may not be up).
+	 */
+	if (CHECK_FLAG(exist->flags, BGP_PATH_STALE)) {
+		*reason = bgp_path_selection_stale;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to latter path being STALE",
+				pfx_buf, new_buf, exist_buf);
+		return 1;
+	}
+
+	if (CHECK_FLAG(new->flags, BGP_PATH_STALE)) {
+		*reason = bgp_path_selection_stale;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to former path being STALE",
+				pfx_buf, new_buf, exist_buf);
+		return 0;
+	}
+
+	/* locally configured routes to advertise do not have su_remote */
+	if (peer_new->su_remote == NULL) {
+		*reason = bgp_path_selection_local_configured;
+		return 0;
+	}
+
+	if (peer_exist->su_remote == NULL) {
+		*reason = bgp_path_selection_local_configured;
+		return 1;
+	}
+
+	ret = sockunion_cmp(peer_new->su_remote, peer_exist->su_remote);
+
+	if (ret == 1) {
+		*reason = bgp_path_selection_neighbor_ip;
+		if (debug)
+			zlog_debug(
+				"%s: %s loses to %s due to Neighor IP comparison",
+				pfx_buf, new_buf, exist_buf);
+		return 0;
+	}
+
+	if (ret == -1) {
+		*reason = bgp_path_selection_neighbor_ip;
+		if (debug)
+			zlog_debug(
+				"%s: %s wins over %s due to Neighor IP comparison",
+				pfx_buf, new_buf, exist_buf);
+		return 1;
+	}
+
+	*reason = bgp_path_selection_default;
+	if (debug)
+		zlog_debug("%s: %s wins over %s due to nothing left to compare",
+			   pfx_buf, new_buf, exist_buf);
+
+	return 1;
+}
+
+
+int bgp_evpn_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
+			   struct bgp_path_info *exist, int *paths_eq,
+			   bool debug)
+{
+	enum bgp_path_selection_reason reason;
+	char pfx_buf[PREFIX2STR_BUFFER] = {};
+
+	if (debug)
+		prefix2str(bgp_dest_get_prefix(new->net), pfx_buf,
+			   sizeof(pfx_buf));
+
+	return bgp_path_info_cmp(bgp, new, exist, paths_eq, NULL, debug,
+				 pfx_buf, AFI_L2VPN, SAFI_EVPN, &reason);
+}
+
+/* Compare two bgp route entity.  Return -1 if new is preferred, 1 if exist
+ * is preferred, or 0 if they are the same (usually will only occur if
+ * multipath is enabled
+ * This version is compatible with */
+int bgp_path_info_cmp_compatible(struct bgp *bgp, struct bgp_path_info *new,
+				 struct bgp_path_info *exist, char *pfx_buf,
+				 afi_t afi, safi_t safi,
+				 enum bgp_path_selection_reason *reason)
+{
+	int paths_eq;
+	int ret;
+	bool debug = false;
+
+	ret = bgp_path_info_cmp(bgp, new, exist, &paths_eq, NULL, debug,
+				pfx_buf, afi, safi, reason);
+
+	if (paths_eq)
+		ret = 0;
+	else {
+		if (ret == 1)
+			ret = -1;
+		else
+			ret = 1;
+	}
+	return ret;
+}
+
+static enum filter_type bgp_input_filter(struct peer *peer,
+					 const struct prefix *p,
+					 struct attr *attr, afi_t afi,
+					 safi_t safi)
+{
+	struct bgp_filter *filter;
+	enum filter_type ret = FILTER_PERMIT;
+
+	filter = &peer->filter[afi][safi];
+
+#define FILTER_EXIST_WARN(F, f, filter)                                        \
+	if (BGP_DEBUG(update, UPDATE_IN) && !(F##_IN(filter)))                 \
+		zlog_debug("%s: Could not find configured input %s-list %s!",  \
+			   peer->host, #f, F##_IN_NAME(filter));
+
+	if (DISTRIBUTE_IN_NAME(filter)) {
+		FILTER_EXIST_WARN(DISTRIBUTE, distribute, filter);
+
+		if (access_list_apply(DISTRIBUTE_IN(filter), p)
+		    == FILTER_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+	if (PREFIX_LIST_IN_NAME(filter)) {
+		FILTER_EXIST_WARN(PREFIX_LIST, prefix, filter);
+
+		if (prefix_list_apply(PREFIX_LIST_IN(filter), p)
+		    == PREFIX_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+	if (FILTER_LIST_IN_NAME(filter)) {
+		FILTER_EXIST_WARN(FILTER_LIST, as, filter);
+
+		if (as_list_apply(FILTER_LIST_IN(filter), attr->aspath)
+		    == AS_FILTER_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+done:
+	if (frrtrace_enabled(frr_bgp, input_filter)) {
+		char pfxprint[PREFIX2STR_BUFFER];
+
+		prefix2str(p, pfxprint, sizeof(pfxprint));
+		frrtrace(5, frr_bgp, input_filter, peer, pfxprint, afi, safi,
+			 ret == FILTER_PERMIT ? "permit" : "deny");
+	}
+
+	return ret;
+#undef FILTER_EXIST_WARN
+}
+
+static enum filter_type bgp_output_filter(struct peer *peer,
+					  const struct prefix *p,
+					  struct attr *attr, afi_t afi,
+					  safi_t safi)
+{
+	struct bgp_filter *filter;
+	enum filter_type ret = FILTER_PERMIT;
+
+	filter = &peer->filter[afi][safi];
+
+#define FILTER_EXIST_WARN(F, f, filter)                                        \
+	if (BGP_DEBUG(update, UPDATE_OUT) && !(F##_OUT(filter)))               \
+		zlog_debug("%s: Could not find configured output %s-list %s!", \
+			   peer->host, #f, F##_OUT_NAME(filter));
+
+	if (DISTRIBUTE_OUT_NAME(filter)) {
+		FILTER_EXIST_WARN(DISTRIBUTE, distribute, filter);
+
+		if (access_list_apply(DISTRIBUTE_OUT(filter), p)
+		    == FILTER_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+	if (PREFIX_LIST_OUT_NAME(filter)) {
+		FILTER_EXIST_WARN(PREFIX_LIST, prefix, filter);
+
+		if (prefix_list_apply(PREFIX_LIST_OUT(filter), p)
+		    == PREFIX_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+	if (FILTER_LIST_OUT_NAME(filter)) {
+		FILTER_EXIST_WARN(FILTER_LIST, as, filter);
+
+		if (as_list_apply(FILTER_LIST_OUT(filter), attr->aspath)
+		    == AS_FILTER_DENY) {
+			ret = FILTER_DENY;
+			goto done;
+		}
+	}
+
+	if (frrtrace_enabled(frr_bgp, output_filter)) {
+		char pfxprint[PREFIX2STR_BUFFER];
+
+		prefix2str(p, pfxprint, sizeof(pfxprint));
+		frrtrace(5, frr_bgp, output_filter, peer, pfxprint, afi, safi,
+			 ret == FILTER_PERMIT ? "permit" : "deny");
+	}
+
+done:
+	return ret;
+#undef FILTER_EXIST_WARN
+}
+
+/* If community attribute includes no_export then return 1. */
+static bool bgp_community_filter(struct peer *peer, struct attr *attr)
+{
+	if (bgp_attr_get_community(attr)) {
+		/* NO_ADVERTISE check. */
+		if (community_include(bgp_attr_get_community(attr),
+				      COMMUNITY_NO_ADVERTISE))
+			return true;
+
+		/* NO_EXPORT check. */
+		if (peer->sort == BGP_PEER_EBGP &&
+		    community_include(bgp_attr_get_community(attr),
+				      COMMUNITY_NO_EXPORT))
+			return true;
+
+		/* NO_EXPORT_SUBCONFED check. */
+		if (peer->sort == BGP_PEER_EBGP
+		    || peer->sort == BGP_PEER_CONFED)
+			if (community_include(bgp_attr_get_community(attr),
+					      COMMUNITY_NO_EXPORT_SUBCONFED))
+				return true;
+	}
+	return false;
+}
+
+/* Route reflection loop check.  */
+static bool bgp_cluster_filter(struct peer *peer, struct attr *attr)
+{
+	struct in_addr cluster_id;
+	struct cluster_list *cluster = bgp_attr_get_cluster(attr);
+
+	if (cluster) {
+		if (peer->bgp->config & BGP_CONFIG_CLUSTER_ID)
+			cluster_id = peer->bgp->cluster_id;
+		else
+			cluster_id = peer->bgp->router_id;
+
+		if (cluster_loop_check(cluster, cluster_id))
+			return true;
+	}
+	return false;
+}
+
+static bool bgp_otc_filter(struct peer *peer, struct attr *attr)
+{
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_OTC)) {
+		if (peer->local_role == ROLE_PROVIDER ||
+		    peer->local_role == ROLE_RS_SERVER)
+			return true;
+		if (peer->local_role == ROLE_PEER && attr->otc != peer->as)
+			return true;
+		return false;
+	}
+	if (peer->local_role == ROLE_CUSTOMER ||
+	    peer->local_role == ROLE_PEER ||
+	    peer->local_role == ROLE_RS_CLIENT) {
+		attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_OTC);
+		attr->otc = peer->as;
+	}
+	return false;
+}
+
+static bool bgp_otc_egress(struct peer *peer, struct attr *attr)
+{
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_OTC)) {
+		if (peer->local_role == ROLE_CUSTOMER ||
+		    peer->local_role == ROLE_RS_CLIENT ||
+		    peer->local_role == ROLE_PEER)
+			return true;
+		return false;
+	}
+	if (peer->local_role == ROLE_PROVIDER ||
+	    peer->local_role == ROLE_PEER ||
+	    peer->local_role == ROLE_RS_SERVER) {
+		attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_OTC);
+		attr->otc = peer->bgp->as;
+	}
+	return false;
+}
+
+static bool bgp_check_role_applicability(afi_t afi, safi_t safi)
+{
+	return ((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_UNICAST);
+}
+
+static int bgp_input_modifier(struct peer *peer, const struct prefix *p,
+			      struct attr *attr, afi_t afi, safi_t safi,
+			      const char *rmap_name, mpls_label_t *label,
+			      uint32_t num_labels, struct bgp_dest *dest)
+{
+	struct bgp_filter *filter;
+	struct bgp_path_info rmap_path = { 0 };
+	struct bgp_path_info_extra extra = { 0 };
+	route_map_result_t ret;
+	struct route_map *rmap = NULL;
+
+	filter = &peer->filter[afi][safi];
+
+	/* Apply default weight value. */
+	if (peer->weight[afi][safi])
+		attr->weight = peer->weight[afi][safi];
+
+	if (rmap_name) {
+		rmap = route_map_lookup_by_name(rmap_name);
+
+		if (rmap == NULL)
+			return RMAP_DENY;
+	} else {
+		if (ROUTE_MAP_IN_NAME(filter)) {
+			rmap = ROUTE_MAP_IN(filter);
+
+			if (rmap == NULL)
+				return RMAP_DENY;
+		}
+	}
+
+	/* Route map apply. */
+	if (rmap) {
+		memset(&rmap_path, 0, sizeof(rmap_path));
+		/* Duplicate current value to new structure for modification. */
+		rmap_path.peer = peer;
+		rmap_path.attr = attr;
+		rmap_path.extra = &extra;
+		rmap_path.net = dest;
+
+		extra.num_labels = num_labels;
+		if (label && num_labels && num_labels <= BGP_MAX_LABELS)
+			memcpy(extra.label, label,
+				num_labels * sizeof(mpls_label_t));
+
+		SET_FLAG(peer->rmap_type, PEER_RMAP_TYPE_IN);
+
+		/* Apply BGP route map to the attribute. */
+		ret = route_map_apply(rmap, p, &rmap_path);
+
+		peer->rmap_type = 0;
+
+		if (ret == RMAP_DENYMATCH)
+			return RMAP_DENY;
+	}
+	return RMAP_PERMIT;
+}
+
+static int bgp_output_modifier(struct peer *peer, const struct prefix *p,
+			       struct attr *attr, afi_t afi, safi_t safi,
+			       const char *rmap_name)
+{
+	struct bgp_path_info rmap_path;
+	route_map_result_t ret;
+	struct route_map *rmap = NULL;
+	uint8_t rmap_type;
+
+	/*
+	 * So if we get to this point and have no rmap_name
+	 * we want to just show the output as it currently
+	 * exists.
+	 */
+	if (!rmap_name)
+		return RMAP_PERMIT;
+
+	/* Apply default weight value. */
+	if (peer->weight[afi][safi])
+		attr->weight = peer->weight[afi][safi];
+
+	rmap = route_map_lookup_by_name(rmap_name);
+
+	/*
+	 * If we have a route map name and we do not find
+	 * the routemap that means we have an implicit
+	 * deny.
+	 */
+	if (rmap == NULL)
+		return RMAP_DENY;
+
+	memset(&rmap_path, 0, sizeof(rmap_path));
+	/* Route map apply. */
+	/* Duplicate current value to new structure for modification. */
+	rmap_path.peer = peer;
+	rmap_path.attr = attr;
+
+	rmap_type = peer->rmap_type;
+	SET_FLAG(peer->rmap_type, PEER_RMAP_TYPE_OUT);
+
+	/* Apply BGP route map to the attribute. */
+	ret = route_map_apply(rmap, p, &rmap_path);
+
+	peer->rmap_type = rmap_type;
+
+	if (ret == RMAP_DENYMATCH)
+		/*
+		 * caller has multiple error paths with bgp_attr_flush()
+		 */
+		return RMAP_DENY;
+
+	return RMAP_PERMIT;
+}
+
+/* If this is an EBGP peer with remove-private-AS */
+static void bgp_peer_remove_private_as(struct bgp *bgp, afi_t afi, safi_t safi,
+				       struct peer *peer, struct attr *attr)
+{
+	if (peer->sort == BGP_PEER_EBGP
+	    && (peer_af_flag_check(peer, afi, safi,
+				   PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE)
+		|| peer_af_flag_check(peer, afi, safi,
+				      PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE)
+		|| peer_af_flag_check(peer, afi, safi,
+				      PEER_FLAG_REMOVE_PRIVATE_AS_ALL)
+		|| peer_af_flag_check(peer, afi, safi,
+				      PEER_FLAG_REMOVE_PRIVATE_AS))) {
+		// Take action on the entire aspath
+		if (peer_af_flag_check(peer, afi, safi,
+				       PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE)
+		    || peer_af_flag_check(peer, afi, safi,
+					  PEER_FLAG_REMOVE_PRIVATE_AS_ALL)) {
+			if (peer_af_flag_check(
+				    peer, afi, safi,
+				    PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE))
+				attr->aspath = aspath_replace_private_asns(
+					attr->aspath, bgp->as, peer->as);
+
+			/*
+			 * Even if the aspath consists of just private ASNs we
+			 * need to walk the AS-Path to maintain all instances
+			 * of the peer's ASN to break possible loops.
+			 */
+			else
+				attr->aspath = aspath_remove_private_asns(
+					attr->aspath, peer->as);
+		}
+
+		// 'all' was not specified so the entire aspath must be private
+		// ASNs
+		// for us to do anything
+		else if (aspath_private_as_check(attr->aspath)) {
+			if (peer_af_flag_check(
+				    peer, afi, safi,
+				    PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE))
+				attr->aspath = aspath_replace_private_asns(
+					attr->aspath, bgp->as, peer->as);
+			else
+				/*
+				 * Walk the aspath to retain any instances of
+				 * the peer_asn
+				 */
+				attr->aspath = aspath_remove_private_asns(
+					attr->aspath, peer->as);
+		}
+	}
+}
+
+/* If this is an EBGP peer with as-override */
+static void bgp_peer_as_override(struct bgp *bgp, afi_t afi, safi_t safi,
+				 struct peer *peer, struct attr *attr)
+{
+	struct aspath *aspath;
+
+	if (peer->sort == BGP_PEER_EBGP &&
+	    peer_af_flag_check(peer, afi, safi, PEER_FLAG_AS_OVERRIDE)) {
+		if (attr->aspath->refcnt)
+			aspath = aspath_dup(attr->aspath);
+		else
+			aspath = attr->aspath;
+
+		attr->aspath = aspath_intern(
+			aspath_replace_specific_asn(aspath, peer->as, bgp->as));
+
+		aspath_free(aspath);
+	}
+}
+
+void bgp_attr_add_llgr_community(struct attr *attr)
+{
+	struct community *old;
+	struct community *new;
+	struct community *merge;
+	struct community *llgr;
+
+	old = bgp_attr_get_community(attr);
+	llgr = community_str2com("llgr-stale");
+
+	assert(llgr);
+
+	if (old) {
+		merge = community_merge(community_dup(old), llgr);
+
+		if (old->refcnt == 0)
+			community_free(&old);
+
+		new = community_uniq_sort(merge);
+		community_free(&merge);
+	} else {
+		new = community_dup(llgr);
+	}
+
+	community_free(&llgr);
+
+	bgp_attr_set_community(attr, new);
+}
+
+void bgp_attr_add_gshut_community(struct attr *attr)
+{
+	struct community *old;
+	struct community *new;
+	struct community *merge;
+	struct community *gshut;
+
+	old = bgp_attr_get_community(attr);
+	gshut = community_str2com("graceful-shutdown");
+
+	assert(gshut);
+
+	if (old) {
+		merge = community_merge(community_dup(old), gshut);
+
+		if (old->refcnt == 0)
+			community_free(&old);
+
+		new = community_uniq_sort(merge);
+		community_free(&merge);
+	} else {
+		new = community_dup(gshut);
+	}
+
+	community_free(&gshut);
+	bgp_attr_set_community(attr, new);
+
+	/* When we add the graceful-shutdown community we must also
+	 * lower the local-preference */
+	attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF);
+	attr->local_pref = BGP_GSHUT_LOCAL_PREF;
+}
+
+
+/* Notify BGP Conditional advertisement scanner process. */
+void bgp_notify_conditional_adv_scanner(struct update_subgroup *subgrp)
+{
+	struct peer *peer = SUBGRP_PEER(subgrp);
+	afi_t afi = SUBGRP_AFI(subgrp);
+	safi_t safi = SUBGRP_SAFI(subgrp);
+	struct bgp_filter *filter = &peer->filter[afi][safi];
+
+	if (!ADVERTISE_MAP_NAME(filter))
+		return;
+
+	if (!CHECK_FLAG(peer->flags, PEER_FLAG_CONFIG_NODE))
+		return;
+
+	peer->advmap_table_change = true;
+}
+
+
+void subgroup_announce_reset_nhop(uint8_t family, struct attr *attr)
+{
+	if (family == AF_INET) {
+		attr->nexthop.s_addr = INADDR_ANY;
+		attr->mp_nexthop_global_in.s_addr = INADDR_ANY;
+	}
+	if (family == AF_INET6)
+		memset(&attr->mp_nexthop_global, 0, IPV6_MAX_BYTELEN);
+	if (family == AF_EVPN)
+		memset(&attr->mp_nexthop_global_in, 0, BGP_ATTR_NHLEN_IPV4);
+}
+
+bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
+			     struct update_subgroup *subgrp,
+			     const struct prefix *p, struct attr *attr,
+			     struct attr *post_attr)
+{
+	struct bgp_filter *filter;
+	struct peer *from;
+	struct peer *peer;
+	struct peer *onlypeer;
+	struct bgp *bgp;
+	struct attr *piattr;
+	route_map_result_t ret;
+	int transparent;
+	int reflect;
+	afi_t afi;
+	safi_t safi;
+	int samepeer_safe = 0; /* for synthetic mplsvpns routes */
+	bool nh_reset = false;
+	uint64_t cum_bw;
+	mpls_label_t label;
+
+	if (DISABLE_BGP_ANNOUNCE)
+		return false;
+
+	afi = SUBGRP_AFI(subgrp);
+	safi = SUBGRP_SAFI(subgrp);
+	peer = SUBGRP_PEER(subgrp);
+	onlypeer = NULL;
+	if (CHECK_FLAG(peer->flags, PEER_FLAG_LONESOUL))
+		onlypeer = SUBGRP_PFIRST(subgrp)->peer;
+
+	from = pi->peer;
+	filter = &peer->filter[afi][safi];
+	bgp = SUBGRP_INST(subgrp);
+	piattr = bgp_path_info_mpath_count(pi) ? bgp_path_info_mpath_attr(pi)
+					       : pi->attr;
+
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX_OUT) &&
+	    peer->pmax_out[afi][safi] != 0 &&
+	    subgrp->pscount >= peer->pmax_out[afi][safi]) {
+		if (BGP_DEBUG(update, UPDATE_OUT) ||
+		    BGP_DEBUG(update, UPDATE_PREFIX)) {
+			zlog_debug("%s reached maximum prefix to be send (%u)",
+				   peer->host, peer->pmax_out[afi][safi]);
+		}
+		return false;
+	}
+
+#ifdef ENABLE_BGP_VNC
+	if (((afi == AFI_IP) || (afi == AFI_IP6)) && (safi == SAFI_MPLS_VPN)
+	    && ((pi->type == ZEBRA_ROUTE_BGP_DIRECT)
+		|| (pi->type == ZEBRA_ROUTE_BGP_DIRECT_EXT))) {
+
+		/*
+		 * direct and direct_ext type routes originate internally even
+		 * though they can have peer pointers that reference other
+		 * systems
+		 */
+		zlog_debug("%s: pfx %pFX bgp_direct->vpn route peer safe",
+			   __func__, p);
+		samepeer_safe = 1;
+	}
+#endif
+
+	if (((afi == AFI_IP) || (afi == AFI_IP6))
+	    && ((safi == SAFI_MPLS_VPN) || (safi == SAFI_UNICAST))
+	    && (pi->type == ZEBRA_ROUTE_BGP)
+	    && (pi->sub_type == BGP_ROUTE_IMPORTED)) {
+
+		/* Applies to routes leaked vpn->vrf and vrf->vpn */
+
+		samepeer_safe = 1;
+	}
+
+	/* With addpath we may be asked to TX all kinds of paths so make sure
+	 * pi is valid */
+	if (!CHECK_FLAG(pi->flags, BGP_PATH_VALID)
+	    || CHECK_FLAG(pi->flags, BGP_PATH_HISTORY)
+	    || CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)) {
+		return false;
+	}
+
+	/* If this is not the bestpath then check to see if there is an enabled
+	 * addpath
+	 * feature that requires us to advertise it */
+	if (!CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+		if (!bgp_addpath_capable(pi, peer, afi, safi))
+			return false;
+
+	/* Aggregate-address suppress check. */
+	if (bgp_path_suppressed(pi) && !UNSUPPRESS_MAP_NAME(filter))
+		return false;
+
+	/*
+	 * If we are doing VRF 2 VRF leaking via the import
+	 * statement, we want to prevent the route going
+	 * off box as that the RT and RD created are localy
+	 * significant and globaly useless.
+	 */
+	if (safi == SAFI_MPLS_VPN && pi->extra && pi->extra->num_labels
+	    && pi->extra->label[0] == BGP_PREVENT_VRF_2_VRF_LEAK)
+		return false;
+
+	/* If it's labeled safi, make sure the route has a valid label. */
+	if (safi == SAFI_LABELED_UNICAST) {
+		label = bgp_adv_label(dest, pi, peer, afi, safi);
+		if (!bgp_is_valid_label(&label)) {
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug("u%" PRIu64 ":s%" PRIu64
+					   " %pFX is filtered - no label (%p)",
+					   subgrp->update_group->id, subgrp->id,
+					   p, &label);
+			return false;
+		}
+	} else if (safi == SAFI_MPLS_VPN &&
+		   CHECK_FLAG(pi->flags, BGP_PATH_MPLSVPN_NH_LABEL_BIND) &&
+		   pi->mplsvpn.bmnc.nh_label_bind_cache && peer &&
+		   pi->peer != peer && pi->sub_type != BGP_ROUTE_IMPORTED &&
+		   pi->sub_type != BGP_ROUTE_STATIC &&
+		   bgp_mplsvpn_path_uses_valid_mpls_label(pi) &&
+		   bgp_path_info_nexthop_changed(pi, peer, afi)) {
+		/* Redistributed mpls vpn route between distinct
+		 * peers from 'pi->peer' to 'to',
+		 * and an mpls label is used in this path,
+		 * and there is a nh label bind entry,
+		 * then get appropriate mpls local label
+		 * and check its validity
+		 */
+		label = bgp_mplsvpn_nh_label_bind_get_label(pi);
+		if (!bgp_is_valid_label(&label)) {
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug("u%" PRIu64 ":s%" PRIu64
+					   " %pFX is filtered - no valid label",
+					   subgrp->update_group->id, subgrp->id,
+					   p);
+			return false;
+		}
+	}
+
+	/* Do not send back route to sender. */
+	if (onlypeer && from == onlypeer) {
+		return false;
+	}
+
+	/* Do not send the default route in the BGP table if the neighbor is
+	 * configured for default-originate */
+	if (CHECK_FLAG(peer->af_flags[afi][safi],
+		       PEER_FLAG_DEFAULT_ORIGINATE)) {
+		if (p->family == AF_INET && p->u.prefix4.s_addr == INADDR_ANY)
+			return false;
+		else if (p->family == AF_INET6 && p->prefixlen == 0)
+			return false;
+	}
+
+	/* Transparency check. */
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)
+	    && CHECK_FLAG(from->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT))
+		transparent = 1;
+	else
+		transparent = 0;
+
+	/* If community is not disabled check the no-export and local. */
+	if (!transparent && bgp_community_filter(peer, piattr)) {
+		if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+			zlog_debug("%s: community filter check fail for %pFX",
+				   __func__, p);
+		return false;
+	}
+
+	/* If the attribute has originator-id and it is same as remote
+	   peer's id. */
+	if (onlypeer && piattr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)
+	    && (IPV4_ADDR_SAME(&onlypeer->remote_id, &piattr->originator_id))) {
+		if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+			zlog_debug(
+				"%pBP [Update:SEND] %pFX originator-id is same as remote router-id",
+				onlypeer, p);
+		return false;
+	}
+
+	/* ORF prefix-list filter check */
+	if (CHECK_FLAG(peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV) &&
+	    CHECK_FLAG(peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_RCV))
+		if (peer->orf_plist[afi][safi]) {
+			if (prefix_list_apply(peer->orf_plist[afi][safi], p)
+			    == PREFIX_DENY) {
+				if (bgp_debug_update(NULL, p,
+						     subgrp->update_group, 0))
+					zlog_debug(
+						"%pBP [Update:SEND] %pFX is filtered via ORF",
+						peer, p);
+				return false;
+			}
+		}
+
+	/* Output filter check. */
+	if (bgp_output_filter(peer, p, piattr, afi, safi) == FILTER_DENY) {
+		if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+			zlog_debug("%pBP [Update:SEND] %pFX is filtered", peer,
+				   p);
+		return false;
+	}
+
+	/* AS path loop check. */
+	if (peer->as_path_loop_detection &&
+	    aspath_loop_check(piattr->aspath, peer->as)) {
+		if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+			zlog_debug(
+				"%pBP [Update:SEND] suppress announcement to peer AS %u that is part of AS path.",
+				peer, peer->as);
+		return false;
+	}
+
+	/* If we're a CONFED we need to loop check the CONFED ID too */
+	if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)) {
+		if (aspath_loop_check_confed(piattr->aspath, bgp->confed_id)) {
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug(
+					"%pBP [Update:SEND] suppress announcement to peer AS %u is AS path.",
+					peer, bgp->confed_id);
+			return false;
+		}
+	}
+
+	/* Route-Reflect check. */
+	if (from->sort == BGP_PEER_IBGP && peer->sort == BGP_PEER_IBGP)
+		reflect = 1;
+	else
+		reflect = 0;
+
+	/* IBGP reflection check. */
+	if (reflect && !samepeer_safe) {
+		/* A route from a Client peer. */
+		if (CHECK_FLAG(from->af_flags[afi][safi],
+			       PEER_FLAG_REFLECTOR_CLIENT)) {
+			/* Reflect to all the Non-Client peers and also to the
+			   Client peers other than the originator.  Originator
+			   check
+			   is already done.  So there is noting to do. */
+			/* no bgp client-to-client reflection check. */
+			if (CHECK_FLAG(bgp->flags,
+				       BGP_FLAG_NO_CLIENT_TO_CLIENT))
+				if (CHECK_FLAG(peer->af_flags[afi][safi],
+					       PEER_FLAG_REFLECTOR_CLIENT))
+					return false;
+		} else {
+			/* A route from a Non-client peer. Reflect to all other
+			   clients. */
+			if (!CHECK_FLAG(peer->af_flags[afi][safi],
+					PEER_FLAG_REFLECTOR_CLIENT))
+				return false;
+		}
+	}
+
+	/* For modify attribute, copy it to temporary structure.
+	 * post_attr comes from BGP conditional advertisements, where
+	 * attributes are already processed by advertise-map route-map,
+	 * and this needs to be saved instead of overwriting from the
+	 * path attributes.
+	 */
+	if (post_attr)
+		*attr = *post_attr;
+	else
+		*attr = *piattr;
+
+	/* don't confuse inbound and outbound setting */
+	RESET_FLAG(attr->rmap_change_flags);
+
+	/* If local-preference is not set. */
+	if ((peer->sort == BGP_PEER_IBGP || peer->sort == BGP_PEER_CONFED)
+	    && (!(attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))) {
+		attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF);
+		attr->local_pref = bgp->default_local_pref;
+	}
+
+	/* If originator-id is not set and the route is to be reflected,
+	   set the originator id */
+	if (reflect
+	    && (!(attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))) {
+		IPV4_ADDR_COPY(&(attr->originator_id), &(from->remote_id));
+		SET_FLAG(attr->flag, BGP_ATTR_ORIGINATOR_ID);
+	}
+
+	/* Remove MED if its an EBGP peer - will get overwritten by route-maps
+	 */
+	if (peer->sort == BGP_PEER_EBGP
+	    && attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)) {
+		if (from != bgp->peer_self && !transparent
+		    && !CHECK_FLAG(peer->af_flags[afi][safi],
+				   PEER_FLAG_MED_UNCHANGED))
+			attr->flag &=
+				~(ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC));
+	}
+
+	/* Since the nexthop attribute can vary per peer, it is not explicitly
+	 * set
+	 * in announce check, only certain flags and length (or number of
+	 * nexthops
+	 * -- for IPv6/MP_REACH) are set here in order to guide the update
+	 * formation
+	 * code in setting the nexthop(s) on a per peer basis in
+	 * reformat_peer().
+	 * Typically, the source nexthop in the attribute is preserved but in
+	 * the
+	 * scenarios where we know it will always be overwritten, we reset the
+	 * nexthop to "0" in an attempt to achieve better Update packing. An
+	 * example of this is when a prefix from each of 2 IBGP peers needs to
+	 * be
+	 * announced to an EBGP peer (and they have the same attributes barring
+	 * their nexthop).
+	 */
+	if (reflect)
+		SET_FLAG(attr->rmap_change_flags, BATTR_REFLECTED);
+
+#define NEXTHOP_IS_V6                                                          \
+	((safi != SAFI_ENCAP && safi != SAFI_MPLS_VPN                          \
+	  && (p->family == AF_INET6 || peer_cap_enhe(peer, afi, safi)))        \
+	 || ((safi == SAFI_ENCAP || safi == SAFI_MPLS_VPN)                     \
+	     && attr->mp_nexthop_len >= IPV6_MAX_BYTELEN))
+
+	/* IPv6/MP starts with 1 nexthop. The link-local address is passed only
+	 * if
+	 * the peer (group) is configured to receive link-local nexthop
+	 * unchanged
+	 * and it is available in the prefix OR we're not reflecting the route,
+	 * link-local nexthop address is valid and
+	 * the peer (group) to whom we're going to announce is on a shared
+	 * network
+	 * and this is either a self-originated route or the peer is EBGP.
+	 * By checking if nexthop LL address is valid we are sure that
+	 * we do not announce LL address as `::`.
+	 */
+	if (NEXTHOP_IS_V6) {
+		attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
+		if ((CHECK_FLAG(peer->af_flags[afi][safi],
+				PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED)
+		     && IN6_IS_ADDR_LINKLOCAL(&attr->mp_nexthop_local))
+		    || (!reflect && !transparent
+			&& IN6_IS_ADDR_LINKLOCAL(&peer->nexthop.v6_local)
+			&& peer->shared_network
+			&& (from == bgp->peer_self
+			    || peer->sort == BGP_PEER_EBGP))) {
+			if (safi == SAFI_MPLS_VPN)
+				attr->mp_nexthop_len =
+					BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL;
+			else
+				attr->mp_nexthop_len =
+					BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL;
+		}
+
+		/* Clear off link-local nexthop in source, whenever it is not
+		 * needed to
+		 * ensure more prefixes share the same attribute for
+		 * announcement.
+		 */
+		if (!(CHECK_FLAG(peer->af_flags[afi][safi],
+				 PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED)))
+			memset(&attr->mp_nexthop_local, 0, IPV6_MAX_BYTELEN);
+	}
+
+	if (bgp_check_role_applicability(afi, safi) &&
+	    bgp_otc_egress(peer, attr))
+		return false;
+
+	if (filter->advmap.update_type == UPDATE_TYPE_WITHDRAW &&
+	    filter->advmap.aname &&
+	    route_map_lookup_by_name(filter->advmap.aname)) {
+		struct bgp_path_info rmap_path = {0};
+		struct bgp_path_info_extra dummy_rmap_path_extra = {0};
+		struct attr dummy_attr = *attr;
+
+		/* Fill temp path_info */
+		prep_for_rmap_apply(&rmap_path, &dummy_rmap_path_extra, dest,
+				    pi, peer, &dummy_attr);
+
+		struct route_map *amap =
+			route_map_lookup_by_name(filter->advmap.aname);
+
+		ret = route_map_apply(amap, p, &rmap_path);
+
+		bgp_attr_flush(&dummy_attr);
+
+		/*
+		 * The conditional advertisement mode is Withdraw and this
+		 * prefix is a conditional prefix. Don't advertise it
+		 */
+		if (ret == RMAP_PERMITMATCH)
+			return false;
+	}
+
+	/* Route map & unsuppress-map apply. */
+	if (!post_attr &&
+	    (ROUTE_MAP_OUT_NAME(filter) || bgp_path_suppressed(pi))) {
+		struct bgp_path_info rmap_path = {0};
+		struct bgp_path_info_extra dummy_rmap_path_extra = {0};
+		struct attr dummy_attr = {0};
+
+		/* Fill temp path_info */
+		prep_for_rmap_apply(&rmap_path, &dummy_rmap_path_extra, dest,
+				    pi, peer, attr);
+		/*
+		 * The route reflector is not allowed to modify the attributes
+		 * of the reflected IBGP routes unless explicitly allowed.
+		 */
+		if ((from->sort == BGP_PEER_IBGP && peer->sort == BGP_PEER_IBGP)
+		    && !CHECK_FLAG(bgp->flags,
+				   BGP_FLAG_RR_ALLOW_OUTBOUND_POLICY)) {
+			dummy_attr = *attr;
+			rmap_path.attr = &dummy_attr;
+		}
+
+		SET_FLAG(peer->rmap_type, PEER_RMAP_TYPE_OUT);
+
+		if (bgp_path_suppressed(pi))
+			ret = route_map_apply(UNSUPPRESS_MAP(filter), p,
+					      &rmap_path);
+		else
+			ret = route_map_apply(ROUTE_MAP_OUT(filter), p,
+					      &rmap_path);
+
+		bgp_attr_flush(&dummy_attr);
+		peer->rmap_type = 0;
+
+		if (ret == RMAP_DENYMATCH) {
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug(
+					"%pBP [Update:SEND] %pFX is filtered by route-map '%s'",
+					peer, p,
+					bgp_path_suppressed(pi)
+						? UNSUPPRESS_MAP_NAME(filter)
+						: ROUTE_MAP_OUT_NAME(filter));
+			bgp_attr_flush(rmap_path.attr);
+			return false;
+		}
+	}
+
+	bgp_peer_remove_private_as(bgp, afi, safi, peer, attr);
+	bgp_peer_as_override(bgp, afi, safi, peer, attr);
+
+	/* RFC 8212 to prevent route leaks.
+	 * This specification intends to improve this situation by requiring the
+	 * explicit configuration of both BGP Import and Export Policies for any
+	 * External BGP (EBGP) session such as customers, peers, or
+	 * confederation boundaries for all enabled address families. Through
+	 * codification of the aforementioned requirement, operators will
+	 * benefit from consistent behavior across different BGP
+	 * implementations.
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY))
+		if (!bgp_outbound_policy_exists(peer, filter)) {
+			if (monotime_since(&bgp->ebgprequirespolicywarning,
+					   NULL) > FIFTEENMINUTE2USEC ||
+			    bgp->ebgprequirespolicywarning.tv_sec == 0) {
+				zlog_warn(
+					"EBGP inbound/outbound policy not properly setup, please configure in order for your peering to work correctly");
+				monotime(&bgp->ebgprequirespolicywarning);
+			}
+			return false;
+		}
+
+	/* draft-ietf-idr-deprecate-as-set-confed-set
+	 * Filter routes having AS_SET or AS_CONFED_SET in the path.
+	 * Eventually, This document (if approved) updates RFC 4271
+	 * and RFC 5065 by eliminating AS_SET and AS_CONFED_SET types,
+	 * and obsoletes RFC 6472.
+	 */
+	if (peer->bgp->reject_as_sets)
+		if (aspath_check_as_sets(attr->aspath))
+			return false;
+
+	/* If neighbor soo is configured, then check if the route has
+	 * SoO extended community and validate against the configured
+	 * one. If they match, do not announce, to prevent routing
+	 * loops.
+	 */
+	if ((attr->flag & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) &&
+	    peer->soo[afi][safi]) {
+		struct ecommunity *ecomm_soo = peer->soo[afi][safi];
+		struct ecommunity *ecomm = bgp_attr_get_ecommunity(attr);
+
+		if ((ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_AS,
+				       ECOMMUNITY_SITE_ORIGIN) ||
+		     ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_AS4,
+				       ECOMMUNITY_SITE_ORIGIN) ||
+		     ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_IP,
+				       ECOMMUNITY_SITE_ORIGIN)) &&
+		    ecommunity_include(ecomm, ecomm_soo)) {
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug(
+					"%pBP [Update:SEND] %pFX is filtered by SoO extcommunity '%s'",
+					peer, p, ecommunity_str(ecomm_soo));
+			return false;
+		}
+	}
+
+	/* Codification of AS 0 Processing */
+	if (aspath_check_as_zero(attr->aspath))
+		return false;
+
+	if (bgp_in_graceful_shutdown(bgp)) {
+		if (peer->sort == BGP_PEER_IBGP
+		    || peer->sort == BGP_PEER_CONFED) {
+			attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF);
+			attr->local_pref = BGP_GSHUT_LOCAL_PREF;
+		} else {
+			bgp_attr_add_gshut_community(attr);
+		}
+	}
+
+	/* A BGP speaker that has advertised the "Long-lived Graceful Restart
+	 * Capability" to a neighbor MUST perform the following upon receiving
+	 * a route from that neighbor with the "LLGR_STALE" community, or upon
+	 * attaching the "LLGR_STALE" community itself per Section 4.2:
+	 *
+	 * The route SHOULD NOT be advertised to any neighbor from which the
+	 * Long-lived Graceful Restart Capability has not been received.
+	 */
+	if (bgp_attr_get_community(attr) &&
+	    community_include(bgp_attr_get_community(attr),
+			      COMMUNITY_LLGR_STALE) &&
+	    !CHECK_FLAG(peer->cap, PEER_CAP_LLGR_RCV) &&
+	    !CHECK_FLAG(peer->cap, PEER_CAP_LLGR_ADV))
+		return false;
+
+	/* After route-map has been applied, we check to see if the nexthop to
+	 * be carried in the attribute (that is used for the announcement) can
+	 * be cleared off or not. We do this in all cases where we would be
+	 * setting the nexthop to "ourselves". For IPv6, we only need to
+	 * consider
+	 * the global nexthop here; the link-local nexthop would have been
+	 * cleared
+	 * already, and if not, it is required by the update formation code.
+	 * Also see earlier comments in this function.
+	 */
+	/*
+	 * If route-map has performed some operation on the nexthop or the peer
+	 * configuration says to pass it unchanged, we cannot reset the nexthop
+	 * here, so only attempt to do it if these aren't true. Note that the
+	 * route-map handler itself might have cleared the nexthop, if for
+	 * example,
+	 * it is configured as 'peer-address'.
+	 */
+	if (!bgp_rmap_nhop_changed(attr->rmap_change_flags,
+				   piattr->rmap_change_flags)
+	    && !transparent
+	    && !CHECK_FLAG(peer->af_flags[afi][safi],
+			   PEER_FLAG_NEXTHOP_UNCHANGED)) {
+		/* We can reset the nexthop, if setting (or forcing) it to
+		 * 'self' */
+		if (CHECK_FLAG(peer->af_flags[afi][safi],
+			       PEER_FLAG_NEXTHOP_SELF)
+		    || CHECK_FLAG(peer->af_flags[afi][safi],
+				  PEER_FLAG_FORCE_NEXTHOP_SELF)) {
+			if (!reflect
+			    || CHECK_FLAG(peer->af_flags[afi][safi],
+					  PEER_FLAG_FORCE_NEXTHOP_SELF)) {
+				subgroup_announce_reset_nhop(
+					(peer_cap_enhe(peer, afi, safi)
+						 ? AF_INET6
+						 : p->family),
+					attr);
+				nh_reset = true;
+			}
+		} else if (peer->sort == BGP_PEER_EBGP) {
+			/* Can also reset the nexthop if announcing to EBGP, but
+			 * only if
+			 * no peer in the subgroup is on a shared subnet.
+			 * Note: 3rd party nexthop currently implemented for
+			 * IPv4 only.
+			 */
+			if ((p->family == AF_INET) &&
+				(!bgp_subgrp_multiaccess_check_v4(
+					piattr->nexthop,
+					subgrp, from))) {
+				subgroup_announce_reset_nhop(
+					(peer_cap_enhe(peer, afi, safi)
+						 ? AF_INET6
+						 : p->family),
+						attr);
+				nh_reset = true;
+			}
+
+			if ((p->family == AF_INET6) &&
+				(!bgp_subgrp_multiaccess_check_v6(
+					piattr->mp_nexthop_global,
+					subgrp, from))) {
+				subgroup_announce_reset_nhop(
+					(peer_cap_enhe(peer, afi, safi)
+						? AF_INET6
+						: p->family),
+						attr);
+				nh_reset = true;
+			}
+
+
+
+		} else if (CHECK_FLAG(pi->flags, BGP_PATH_ANNC_NH_SELF)) {
+			/*
+			 * This flag is used for leaked vpn-vrf routes
+			 */
+			int family = p->family;
+
+			if (peer_cap_enhe(peer, afi, safi))
+				family = AF_INET6;
+
+			if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
+				zlog_debug(
+					"%s: %pFX BGP_PATH_ANNC_NH_SELF, family=%s",
+					__func__, p, family2str(family));
+			subgroup_announce_reset_nhop(family, attr);
+			nh_reset = true;
+		}
+	}
+
+	/* If IPv6/MP and nexthop does not have any override and happens
+	 * to
+	 * be a link-local address, reset it so that we don't pass along
+	 * the
+	 * source's link-local IPv6 address to recipients who may not be
+	 * on
+	 * the same interface.
+	 */
+	if (p->family == AF_INET6 || peer_cap_enhe(peer, afi, safi)) {
+		if (IN6_IS_ADDR_LINKLOCAL(&attr->mp_nexthop_global)) {
+			subgroup_announce_reset_nhop(AF_INET6, attr);
+				nh_reset = true;
+			}
+	}
+
+	/* If this is an iBGP, send Origin Validation State (OVS)
+	 * extended community (rfc8097).
+	 */
+	if (peer->sort == BGP_PEER_IBGP) {
+		enum rpki_states rpki_state = RPKI_NOT_BEING_USED;
+
+		rpki_state = hook_call(bgp_rpki_prefix_status, peer, attr, p);
+
+		if (rpki_state != RPKI_NOT_BEING_USED)
+			bgp_attr_set_ecommunity(
+				attr, ecommunity_add_origin_validation_state(
+					      rpki_state,
+					      bgp_attr_get_ecommunity(attr)));
+	}
+
+	/*
+	 * When the next hop is set to ourselves, if all multipaths have
+	 * link-bandwidth announce the cumulative bandwidth as that makes
+	 * the most sense. However, don't modify if the link-bandwidth has
+	 * been explicitly set by user policy.
+	 */
+	if (nh_reset &&
+	    bgp_path_info_mpath_chkwtd(bgp, pi) &&
+	    (cum_bw = bgp_path_info_mpath_cumbw(pi)) != 0 &&
+	    !CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_LINK_BW_SET))
+		bgp_attr_set_ecommunity(
+			attr,
+			ecommunity_replace_linkbw(
+				bgp->as, bgp_attr_get_ecommunity(attr), cum_bw,
+				CHECK_FLAG(
+					peer->flags,
+					PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE)));
+
+	return true;
+}
+
+static void bgp_route_select_timer_expire(struct event *thread)
+{
+	struct afi_safi_info *info;
+	afi_t afi;
+	safi_t safi;
+	struct bgp *bgp;
+
+	info = EVENT_ARG(thread);
+	afi = info->afi;
+	safi = info->safi;
+	bgp = info->bgp;
+
+	bgp->gr_info[afi][safi].t_route_select = NULL;
+	XFREE(MTYPE_TMP, info);
+
+	/* Best path selection */
+	bgp_best_path_select_defer(bgp, afi, safi);
+}
+
+void bgp_best_selection(struct bgp *bgp, struct bgp_dest *dest,
+			struct bgp_maxpaths_cfg *mpath_cfg,
+			struct bgp_path_info_pair *result, afi_t afi,
+			safi_t safi)
+{
+	struct bgp_path_info *new_select;
+	struct bgp_path_info *old_select;
+	struct bgp_path_info *pi;
+	struct bgp_path_info *pi1;
+	struct bgp_path_info *pi2;
+	struct bgp_path_info *nextpi = NULL;
+	int paths_eq, do_mpath;
+	bool debug;
+	struct list mp_list;
+	char pfx_buf[PREFIX2STR_BUFFER] = {};
+	char path_buf[PATH_ADDPATH_STR_BUFFER];
+
+	bgp_mp_list_init(&mp_list);
+	do_mpath =
+		(mpath_cfg->maxpaths_ebgp > 1 || mpath_cfg->maxpaths_ibgp > 1);
+
+	debug = bgp_debug_bestpath(dest);
+
+	if (debug)
+		prefix2str(bgp_dest_get_prefix(dest), pfx_buf, sizeof(pfx_buf));
+
+	dest->reason = bgp_path_selection_none;
+	/* bgp deterministic-med */
+	new_select = NULL;
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)) {
+
+		/* Clear BGP_PATH_DMED_SELECTED for all paths */
+		for (pi1 = bgp_dest_get_bgp_path_info(dest); pi1;
+		     pi1 = pi1->next)
+			bgp_path_info_unset_flag(dest, pi1,
+						 BGP_PATH_DMED_SELECTED);
+
+		for (pi1 = bgp_dest_get_bgp_path_info(dest); pi1;
+		     pi1 = pi1->next) {
+			if (CHECK_FLAG(pi1->flags, BGP_PATH_DMED_CHECK))
+				continue;
+			if (BGP_PATH_HOLDDOWN(pi1))
+				continue;
+			if (pi1->peer != bgp->peer_self &&
+			    !CHECK_FLAG(pi1->peer->sflags,
+					PEER_STATUS_NSF_WAIT)) {
+				if (!peer_established(pi1->peer->connection))
+					continue;
+			}
+
+			new_select = pi1;
+			if (pi1->next) {
+				for (pi2 = pi1->next; pi2; pi2 = pi2->next) {
+					if (CHECK_FLAG(pi2->flags,
+						       BGP_PATH_DMED_CHECK))
+						continue;
+					if (BGP_PATH_HOLDDOWN(pi2))
+						continue;
+					if (pi2->peer != bgp->peer_self &&
+					    !CHECK_FLAG(pi2->peer->sflags,
+							PEER_STATUS_NSF_WAIT) &&
+					    !peer_established(
+						    pi2->peer->connection))
+						continue;
+
+					if (!aspath_cmp_left(pi1->attr->aspath,
+							     pi2->attr->aspath)
+					    && !aspath_cmp_left_confed(
+						       pi1->attr->aspath,
+						       pi2->attr->aspath))
+						continue;
+
+					if (bgp_path_info_cmp(
+						    bgp, pi2, new_select,
+						    &paths_eq, mpath_cfg, debug,
+						    pfx_buf, afi, safi,
+						    &dest->reason)) {
+						bgp_path_info_unset_flag(
+							dest, new_select,
+							BGP_PATH_DMED_SELECTED);
+						new_select = pi2;
+					}
+
+					bgp_path_info_set_flag(
+						dest, pi2, BGP_PATH_DMED_CHECK);
+				}
+			}
+			bgp_path_info_set_flag(dest, new_select,
+					       BGP_PATH_DMED_CHECK);
+			bgp_path_info_set_flag(dest, new_select,
+					       BGP_PATH_DMED_SELECTED);
+
+			if (debug) {
+				bgp_path_info_path_with_addpath_rx_str(
+					new_select, path_buf, sizeof(path_buf));
+				zlog_debug(
+					"%pBD(%s): %s is the bestpath from AS %u",
+					dest, bgp->name_pretty, path_buf,
+					aspath_get_first_as(
+						new_select->attr->aspath));
+			}
+		}
+	}
+
+	/* Check old selected route and new selected route. */
+	old_select = NULL;
+	new_select = NULL;
+	for (pi = bgp_dest_get_bgp_path_info(dest);
+	     (pi != NULL) && (nextpi = pi->next, 1); pi = nextpi) {
+		enum bgp_path_selection_reason reason;
+
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+			old_select = pi;
+
+		if (BGP_PATH_HOLDDOWN(pi)) {
+			/* reap REMOVED routes, if needs be
+			 * selected route must stay for a while longer though
+			 */
+			if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED) &&
+			    (pi != old_select)) {
+				dest = bgp_path_info_reap(dest, pi);
+				assert(dest);
+			}
+
+			if (debug)
+				zlog_debug(
+					"%s: %pBD(%s) pi from %s in holddown",
+					__func__, dest, bgp->name_pretty,
+					pi->peer->host);
+
+			continue;
+		}
+
+		if (pi->peer && pi->peer != bgp->peer_self
+		    && !CHECK_FLAG(pi->peer->sflags, PEER_STATUS_NSF_WAIT))
+			if (!peer_established(pi->peer->connection)) {
+				if (debug)
+					zlog_debug(
+						"%s: %pBD(%s) non self peer %s not estab state",
+						__func__, dest,
+						bgp->name_pretty,
+						pi->peer->host);
+
+				continue;
+			}
+
+		if (CHECK_FLAG(bgp->flags, BGP_FLAG_DETERMINISTIC_MED)
+		    && (!CHECK_FLAG(pi->flags, BGP_PATH_DMED_SELECTED))) {
+			bgp_path_info_unset_flag(dest, pi, BGP_PATH_DMED_CHECK);
+			if (debug)
+				zlog_debug("%s: %pBD(%s) pi %s dmed", __func__,
+					   dest, bgp->name_pretty,
+					   pi->peer->host);
+			continue;
+		}
+
+		bgp_path_info_unset_flag(dest, pi, BGP_PATH_DMED_CHECK);
+
+		reason = dest->reason;
+		if (bgp_path_info_cmp(bgp, pi, new_select, &paths_eq, mpath_cfg,
+				      debug, pfx_buf, afi, safi,
+				      &dest->reason)) {
+			if (new_select == NULL &&
+			    reason != bgp_path_selection_none)
+				dest->reason = reason;
+			new_select = pi;
+		}
+	}
+
+	/* Now that we know which path is the bestpath see if any of the other
+	 * paths
+	 * qualify as multipaths
+	 */
+	if (debug) {
+		if (new_select)
+			bgp_path_info_path_with_addpath_rx_str(
+				new_select, path_buf, sizeof(path_buf));
+		else
+			snprintf(path_buf, sizeof(path_buf), "NONE");
+		zlog_debug(
+			"%pBD(%s): After path selection, newbest is %s oldbest was %s",
+			dest, bgp->name_pretty, path_buf,
+			old_select ? old_select->peer->host : "NONE");
+	}
+
+	if (do_mpath && new_select) {
+		for (pi = bgp_dest_get_bgp_path_info(dest);
+		     (pi != NULL) && (nextpi = pi->next, 1); pi = nextpi) {
+
+			if (debug)
+				bgp_path_info_path_with_addpath_rx_str(
+					pi, path_buf, sizeof(path_buf));
+
+			if (pi == new_select) {
+				if (debug)
+					zlog_debug(
+						"%pBD(%s): %s is the bestpath, add to the multipath list",
+						dest, bgp->name_pretty,
+						path_buf);
+				bgp_mp_list_add(&mp_list, pi);
+				continue;
+			}
+
+			if (BGP_PATH_HOLDDOWN(pi))
+				continue;
+
+			if (pi->peer && pi->peer != bgp->peer_self
+			    && !CHECK_FLAG(pi->peer->sflags,
+					   PEER_STATUS_NSF_WAIT))
+				if (!peer_established(pi->peer->connection))
+					continue;
+
+			if (!bgp_path_info_nexthop_cmp(pi, new_select)) {
+				if (debug)
+					zlog_debug(
+						"%pBD(%s): %s has the same nexthop as the bestpath, skip it",
+						dest, bgp->name_pretty,
+						path_buf);
+				continue;
+			}
+
+			bgp_path_info_cmp(bgp, pi, new_select, &paths_eq,
+					  mpath_cfg, debug, pfx_buf, afi, safi,
+					  &dest->reason);
+
+			if (paths_eq) {
+				if (debug)
+					zlog_debug(
+						"%pBD(%s): %s is equivalent to the bestpath, add to the multipath list",
+						dest, bgp->name_pretty,
+						path_buf);
+				bgp_mp_list_add(&mp_list, pi);
+			}
+		}
+	}
+
+	bgp_path_info_mpath_update(bgp, dest, new_select, old_select, &mp_list,
+				   mpath_cfg);
+	bgp_path_info_mpath_aggregate_update(new_select, old_select);
+	bgp_mp_list_clear(&mp_list);
+
+	bgp_addpath_update_ids(bgp, dest, afi, safi);
+
+	result->old = old_select;
+	result->new = new_select;
+
+	return;
+}
+
+/*
+ * A new route/change in bestpath of an existing route. Evaluate the path
+ * for advertisement to the subgroup.
+ */
+void subgroup_process_announce_selected(struct update_subgroup *subgrp,
+					struct bgp_path_info *selected,
+					struct bgp_dest *dest, afi_t afi,
+					safi_t safi, uint32_t addpath_tx_id)
+{
+	const struct prefix *p;
+	struct peer *onlypeer;
+	struct attr attr;
+	struct bgp *bgp;
+	bool advertise;
+
+	p = bgp_dest_get_prefix(dest);
+	bgp = SUBGRP_INST(subgrp);
+	onlypeer = ((SUBGRP_PCOUNT(subgrp) == 1) ? (SUBGRP_PFIRST(subgrp))->peer
+						 : NULL);
+
+	if (BGP_DEBUG(update, UPDATE_OUT))
+		zlog_debug("%s: p=%pFX, selected=%p", __func__, p, selected);
+
+	/* First update is deferred until ORF or ROUTE-REFRESH is received */
+	if (onlypeer && CHECK_FLAG(onlypeer->af_sflags[afi][safi],
+				   PEER_STATUS_ORF_WAIT_REFRESH))
+		return;
+
+	memset(&attr, 0, sizeof(attr));
+	/* It's initialized in bgp_announce_check() */
+
+	/* Announcement to the subgroup. If the route is filtered withdraw it.
+	 * If BGP_NODE_FIB_INSTALL_PENDING is set and data plane install status
+	 * is pending (BGP_NODE_FIB_INSTALL_PENDING), do not advertise the
+	 * route
+	 */
+	advertise = bgp_check_advertise(bgp, dest, safi);
+
+	if (selected) {
+		if (subgroup_announce_check(dest, selected, subgrp, p, &attr,
+					    NULL)) {
+			/* Route is selected, if the route is already installed
+			 * in FIB, then it is advertised
+			 */
+			if (advertise) {
+				if (!bgp_check_withdrawal(bgp, dest, safi)) {
+					struct attr *adv_attr =
+						bgp_attr_intern(&attr);
+
+					bgp_adj_out_set_subgroup(dest, subgrp,
+								 adv_attr,
+								 selected);
+				} else
+					bgp_adj_out_unset_subgroup(
+						dest, subgrp, 1, addpath_tx_id);
+			}
+		} else
+			bgp_adj_out_unset_subgroup(dest, subgrp, 1,
+						   addpath_tx_id);
+	}
+
+	/* If selected is NULL we must withdraw the path using addpath_tx_id */
+	else {
+		bgp_adj_out_unset_subgroup(dest, subgrp, 1, addpath_tx_id);
+	}
+}
+
+/*
+ * Clear IGP changed flag and attribute changed flag for a route (all paths).
+ * This is called at the end of route processing.
+ */
+void bgp_zebra_clear_route_change_flags(struct bgp_dest *dest)
+{
+	struct bgp_path_info *pi;
+
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+		if (BGP_PATH_HOLDDOWN(pi))
+			continue;
+		UNSET_FLAG(pi->flags, BGP_PATH_IGP_CHANGED);
+		UNSET_FLAG(pi->flags, BGP_PATH_ATTR_CHANGED);
+	}
+}
+
+/*
+ * Has the route changed from the RIB's perspective? This is invoked only
+ * if the route selection returns the same best route as earlier - to
+ * determine if we need to update zebra or not.
+ */
+bool bgp_zebra_has_route_changed(struct bgp_path_info *selected)
+{
+	struct bgp_path_info *mpinfo;
+
+	/* If this is multipath, check all selected paths for any nexthop
+	 * change or attribute change. Some attribute changes (e.g., community)
+	 * aren't of relevance to the RIB, but we'll update zebra to ensure
+	 * we handle the case of BGP nexthop change. This is the behavior
+	 * when the best path has an attribute change anyway.
+	 */
+	if (CHECK_FLAG(selected->flags, BGP_PATH_IGP_CHANGED)
+	    || CHECK_FLAG(selected->flags, BGP_PATH_MULTIPATH_CHG)
+	    || CHECK_FLAG(selected->flags, BGP_PATH_LINK_BW_CHG))
+		return true;
+
+	/*
+	 * If this is multipath, check all selected paths for any nexthop change
+	 */
+	for (mpinfo = bgp_path_info_mpath_first(selected); mpinfo;
+	     mpinfo = bgp_path_info_mpath_next(mpinfo)) {
+		if (CHECK_FLAG(mpinfo->flags, BGP_PATH_IGP_CHANGED)
+		    || CHECK_FLAG(mpinfo->flags, BGP_PATH_ATTR_CHANGED))
+			return true;
+	}
+
+	/* Nothing has changed from the RIB's perspective. */
+	return false;
+}
+
+struct bgp_process_queue {
+	struct bgp *bgp;
+	STAILQ_HEAD(, bgp_dest) pqueue;
+#define BGP_PROCESS_QUEUE_EOIU_MARKER		(1 << 0)
+	unsigned int flags;
+	unsigned int queued;
+};
+
+static void bgp_process_evpn_route_injection(struct bgp *bgp, afi_t afi,
+					     safi_t safi, struct bgp_dest *dest,
+					     struct bgp_path_info *new_select,
+					     struct bgp_path_info *old_select)
+{
+	const struct prefix *p = bgp_dest_get_prefix(dest);
+
+	if ((afi != AFI_IP && afi != AFI_IP6) || (safi != SAFI_UNICAST))
+		return;
+
+	if (advertise_type5_routes(bgp, afi) && new_select
+	    && is_route_injectable_into_evpn(new_select)) {
+
+		/* apply the route-map */
+		if (bgp->adv_cmd_rmap[afi][safi].map) {
+			route_map_result_t ret;
+			struct bgp_path_info rmap_path;
+			struct bgp_path_info_extra rmap_path_extra;
+			struct attr dummy_attr;
+
+			dummy_attr = *new_select->attr;
+
+			/* Fill temp path_info */
+			prep_for_rmap_apply(&rmap_path, &rmap_path_extra, dest,
+					    new_select, new_select->peer,
+					    &dummy_attr);
+
+			RESET_FLAG(dummy_attr.rmap_change_flags);
+
+			ret = route_map_apply(bgp->adv_cmd_rmap[afi][safi].map,
+					      p, &rmap_path);
+
+			if (ret == RMAP_DENYMATCH) {
+				bgp_attr_flush(&dummy_attr);
+				bgp_evpn_withdraw_type5_route(bgp, p, afi,
+							      safi);
+			} else
+				bgp_evpn_advertise_type5_route(
+					bgp, p, &dummy_attr, afi, safi);
+		} else {
+			bgp_evpn_advertise_type5_route(bgp, p, new_select->attr,
+						       afi, safi);
+		}
+	} else if (advertise_type5_routes(bgp, afi) && old_select
+		   && is_route_injectable_into_evpn(old_select))
+		bgp_evpn_withdraw_type5_route(bgp, p, afi, safi);
+}
+
+/*
+ * Utility to determine whether a particular path_info should use
+ * the IMPLICIT_NULL label. This is pretty specialized: it's only called
+ * in a path where we basically _know_ this is a BGP-LU route.
+ */
+static bool bgp_lu_need_null_label(struct bgp *bgp,
+				   const struct bgp_path_info *new_select,
+				   afi_t afi, mpls_label_t *label)
+{
+	/* Certain types get imp null; so do paths where the nexthop is
+	 * not labeled.
+	 */
+	if (new_select->sub_type == BGP_ROUTE_STATIC
+	    || new_select->sub_type == BGP_ROUTE_AGGREGATE
+	    || new_select->sub_type == BGP_ROUTE_REDISTRIBUTE)
+		goto need_null_label;
+	else if (new_select->extra &&
+		 bgp_is_valid_label(&new_select->extra->label[0]))
+		return false;
+need_null_label:
+	if (label == NULL)
+		return true;
+	/* Disable PHP : explicit-null */
+	if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_LU_IPV4_EXPLICIT_NULL) &&
+	    afi == AFI_IP)
+		*label = MPLS_LABEL_IPV4_EXPLICIT_NULL;
+	else if (!!CHECK_FLAG(bgp->flags, BGP_FLAG_LU_IPV6_EXPLICIT_NULL) &&
+		 afi == AFI_IP6)
+		*label = MPLS_LABEL_IPV6_EXPLICIT_NULL;
+	else
+		/* Enforced PHP popping: implicit-null */
+		*label = MPLS_LABEL_IMPLICIT_NULL;
+
+	return true;
+}
+
+/* Right now, since we only deal with per-prefix labels, it is not
+ * necessary to do this upon changes to best path. Exceptions:
+ * - label index has changed -> recalculate resulting label
+ * - path_info sub_type changed -> switch to/from null label value
+ * - no valid label (due to removed static label binding) -> get new one
+ */
+static void bgp_lu_handle_label_allocation(struct bgp *bgp,
+					   struct bgp_dest *dest,
+					   struct bgp_path_info *new_select,
+					   struct bgp_path_info *old_select,
+					   afi_t afi)
+{
+	mpls_label_t mpls_label_null;
+
+	if (bgp->allocate_mpls_labels[afi][SAFI_UNICAST]) {
+		if (new_select) {
+			if (!old_select ||
+			    bgp_label_index_differs(new_select, old_select) ||
+			    new_select->sub_type != old_select->sub_type ||
+			    !bgp_is_valid_label(&dest->local_label)) {
+				/* control label imposition for local
+				 * routes, aggregate and redistributed
+				 * routes
+				 */
+				mpls_label_null = MPLS_LABEL_IMPLICIT_NULL;
+				if (bgp_lu_need_null_label(bgp, new_select, afi,
+							   &mpls_label_null)) {
+					if (CHECK_FLAG(
+						    dest->flags,
+						    BGP_NODE_REGISTERED_FOR_LABEL) ||
+					    CHECK_FLAG(
+						    dest->flags,
+						    BGP_NODE_LABEL_REQUESTED))
+						bgp_unregister_for_label(dest);
+					dest->local_label = mpls_lse_encode(
+						mpls_label_null, 0, 0, 1);
+					bgp_set_valid_label(&dest->local_label);
+				} else
+					bgp_register_for_label(dest,
+							       new_select);
+			}
+		} else if (CHECK_FLAG(dest->flags,
+				      BGP_NODE_REGISTERED_FOR_LABEL) ||
+			   CHECK_FLAG(dest->flags, BGP_NODE_LABEL_REQUESTED)) {
+			bgp_unregister_for_label(dest);
+		}
+	} else if (CHECK_FLAG(dest->flags, BGP_NODE_REGISTERED_FOR_LABEL) ||
+		   CHECK_FLAG(dest->flags, BGP_NODE_LABEL_REQUESTED)) {
+		bgp_unregister_for_label(dest);
+	}
+}
+
+static struct interface *
+bgp_label_get_resolved_nh_iface(const struct bgp_path_info *pi)
+{
+	struct nexthop *nh;
+
+	if (pi->nexthop == NULL || pi->nexthop->nexthop == NULL ||
+	    !CHECK_FLAG(pi->nexthop->flags, BGP_NEXTHOP_VALID))
+		/* next-hop is not valid */
+		return NULL;
+
+	nh = pi->nexthop->nexthop;
+	if (nh->ifindex == IFINDEX_INTERNAL &&
+	    nh->type != NEXTHOP_TYPE_IPV4_IFINDEX &&
+	    nh->type != NEXTHOP_TYPE_IPV6_IFINDEX)
+		/* next-hop does not contain valid interface */
+		return NULL;
+
+	return if_lookup_by_index(nh->ifindex, nh->vrf_id);
+}
+
+static void
+bgp_mplsvpn_handle_label_allocation(struct bgp *bgp, struct bgp_dest *dest,
+				    struct bgp_path_info *new_select,
+				    struct bgp_path_info *old_select, afi_t afi)
+{
+	struct interface *ifp;
+	struct bgp_interface *bgp_ifp;
+
+	if (bgp->allocate_mpls_labels[afi][SAFI_MPLS_VPN] && new_select) {
+		ifp = bgp_label_get_resolved_nh_iface(new_select);
+		if (ifp)
+			bgp_ifp = (struct bgp_interface *)(ifp->info);
+		else
+			bgp_ifp = NULL;
+		if (bgp_ifp &&
+		    CHECK_FLAG(bgp_ifp->flags,
+			       BGP_INTERFACE_MPLS_L3VPN_SWITCHING) &&
+		    bgp_mplsvpn_path_uses_valid_mpls_label(new_select) &&
+		    new_select->sub_type != BGP_ROUTE_IMPORTED &&
+		    new_select->sub_type != BGP_ROUTE_STATIC)
+			bgp_mplsvpn_nh_label_bind_register_local_label(
+				bgp, dest, new_select);
+		else
+			bgp_mplsvpn_path_nh_label_bind_unlink(new_select);
+	} else {
+		if (new_select)
+			/* no mpls vpn allocation */
+			bgp_mplsvpn_path_nh_label_bind_unlink(new_select);
+		else if (old_select)
+			/* unlink old selection if any */
+			bgp_mplsvpn_path_nh_label_bind_unlink(old_select);
+	}
+}
+
+/*
+ * old_select = The old best path
+ * new_select = the new best path
+ *
+ * if (!old_select && new_select)
+ *     We are sending new information on.
+ *
+ * if (old_select && new_select) {
+ *         if (new_select != old_select)
+ *                 We have a new best path send a change
+ *         else
+ *                 We've received a update with new attributes that needs
+ *                 to be passed on.
+ * }
+ *
+ * if (old_select && !new_select)
+ *     We have no eligible route that we can announce or the rn
+ *     is being removed.
+ */
+static void bgp_process_main_one(struct bgp *bgp, struct bgp_dest *dest,
+				 afi_t afi, safi_t safi)
+{
+	struct bgp_path_info *new_select;
+	struct bgp_path_info *old_select;
+	struct bgp_path_info_pair old_and_new;
+	int debug = 0;
+
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS)) {
+		if (dest)
+			debug = bgp_debug_bestpath(dest);
+		if (debug)
+			zlog_debug(
+				"%s: bgp delete in progress, ignoring event, p=%pBD(%s)",
+				__func__, dest, bgp->name_pretty);
+		return;
+	}
+	/* Is it end of initial update? (after startup) */
+	if (!dest) {
+		frr_timestamp(3, bgp->update_delay_zebra_resume_time,
+			      sizeof(bgp->update_delay_zebra_resume_time));
+
+		bgp->main_zebra_update_hold = 0;
+		FOREACH_AFI_SAFI (afi, safi) {
+			if (bgp_fibupd_safi(safi))
+				bgp_zebra_announce_table(bgp, afi, safi);
+		}
+		bgp->main_peers_update_hold = 0;
+
+		bgp_start_routeadv(bgp);
+		return;
+	}
+
+	const struct prefix *p = bgp_dest_get_prefix(dest);
+
+	debug = bgp_debug_bestpath(dest);
+	if (debug)
+		zlog_debug("%s: p=%pBD(%s) afi=%s, safi=%s start", __func__,
+			   dest, bgp->name_pretty, afi2str(afi),
+			   safi2str(safi));
+
+	/* The best path calculation for the route is deferred if
+	 * BGP_NODE_SELECT_DEFER is set
+	 */
+	if (CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER)) {
+		if (BGP_DEBUG(update, UPDATE_OUT))
+			zlog_debug("SELECT_DEFER flag set for route %p(%s)",
+				   dest, bgp->name_pretty);
+		return;
+	}
+
+	/* Best path selection. */
+	bgp_best_selection(bgp, dest, &bgp->maxpaths[afi][safi], &old_and_new,
+			   afi, safi);
+	old_select = old_and_new.old;
+	new_select = old_and_new.new;
+
+	if (safi == SAFI_UNICAST || safi == SAFI_LABELED_UNICAST)
+		/* label unicast path :
+		 * Do we need to allocate or free labels?
+		 */
+		bgp_lu_handle_label_allocation(bgp, dest, new_select,
+					       old_select, afi);
+	else if (safi == SAFI_MPLS_VPN)
+		/* mpls vpn path:
+		 * Do we need to allocate or free labels?
+		 */
+		bgp_mplsvpn_handle_label_allocation(bgp, dest, new_select,
+						    old_select, afi);
+
+	if (debug)
+		zlog_debug(
+			"%s: p=%pBD(%s) afi=%s, safi=%s, old_select=%p, new_select=%p",
+			__func__, dest, bgp->name_pretty, afi2str(afi),
+			safi2str(safi), old_select, new_select);
+
+	/* If best route remains the same and this is not due to user-initiated
+	 * clear, see exactly what needs to be done.
+	 */
+	if (old_select && old_select == new_select &&
+	    !CHECK_FLAG(dest->flags, BGP_NODE_USER_CLEAR) &&
+	    !CHECK_FLAG(dest->flags, BGP_NODE_PROCESS_CLEAR) &&
+	    !CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED) &&
+	    !bgp_addpath_is_addpath_used(&bgp->tx_addpath, afi, safi)) {
+		if (bgp_zebra_has_route_changed(old_select)) {
+#ifdef ENABLE_BGP_VNC
+			vnc_import_bgp_add_route(bgp, p, old_select);
+			vnc_import_bgp_exterior_add_route(bgp, p, old_select);
+#endif
+			if (bgp_fibupd_safi(safi)
+			    && !bgp_option_check(BGP_OPT_NO_FIB)) {
+
+				if (new_select->type == ZEBRA_ROUTE_BGP
+				    && (new_select->sub_type == BGP_ROUTE_NORMAL
+					|| new_select->sub_type
+						   == BGP_ROUTE_IMPORTED))
+
+					bgp_zebra_announce(dest, p, old_select,
+							   bgp, afi, safi);
+			}
+		}
+
+		/* If there is a change of interest to peers, reannounce the
+		 * route. */
+		if (CHECK_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED)
+		    || CHECK_FLAG(old_select->flags, BGP_PATH_LINK_BW_CHG)
+		    || CHECK_FLAG(dest->flags, BGP_NODE_LABEL_CHANGED)) {
+			group_announce_route(bgp, afi, safi, dest, new_select);
+
+			/* unicast routes must also be annouced to
+			 * labeled-unicast update-groups */
+			if (safi == SAFI_UNICAST)
+				group_announce_route(bgp, afi,
+						     SAFI_LABELED_UNICAST, dest,
+						     new_select);
+
+			UNSET_FLAG(old_select->flags, BGP_PATH_ATTR_CHANGED);
+			UNSET_FLAG(dest->flags, BGP_NODE_LABEL_CHANGED);
+		}
+
+		/* advertise/withdraw type-5 routes */
+		if (CHECK_FLAG(old_select->flags, BGP_PATH_LINK_BW_CHG)
+		    || CHECK_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG))
+			bgp_process_evpn_route_injection(
+				bgp, afi, safi, dest, old_select, old_select);
+
+		UNSET_FLAG(old_select->flags, BGP_PATH_MULTIPATH_CHG);
+		UNSET_FLAG(old_select->flags, BGP_PATH_LINK_BW_CHG);
+		bgp_zebra_clear_route_change_flags(dest);
+		UNSET_FLAG(dest->flags, BGP_NODE_PROCESS_SCHEDULED);
+		return;
+	}
+
+	/* If the user did "clear ip bgp prefix x.x.x.x" this flag will be set
+	 */
+	UNSET_FLAG(dest->flags, BGP_NODE_USER_CLEAR);
+
+	/* If the process wants to force deletion this flag will be set
+	 */
+	UNSET_FLAG(dest->flags, BGP_NODE_PROCESS_CLEAR);
+
+	/* bestpath has changed; bump version */
+	if (old_select || new_select) {
+		bgp_bump_version(dest);
+
+		if (!bgp->t_rmap_def_originate_eval)
+			event_add_timer(
+				bm->master,
+				update_group_refresh_default_originate_route_map,
+				bgp, bgp->rmap_def_originate_eval_timer,
+				&bgp->t_rmap_def_originate_eval);
+	}
+
+	if (old_select)
+		bgp_path_info_unset_flag(dest, old_select, BGP_PATH_SELECTED);
+	if (new_select) {
+		if (debug)
+			zlog_debug("%s: setting SELECTED flag", __func__);
+		bgp_path_info_set_flag(dest, new_select, BGP_PATH_SELECTED);
+		bgp_path_info_unset_flag(dest, new_select,
+					 BGP_PATH_ATTR_CHANGED);
+		UNSET_FLAG(new_select->flags, BGP_PATH_MULTIPATH_CHG);
+		UNSET_FLAG(new_select->flags, BGP_PATH_LINK_BW_CHG);
+	}
+
+#ifdef ENABLE_BGP_VNC
+	if ((afi == AFI_IP || afi == AFI_IP6) && (safi == SAFI_UNICAST)) {
+		if (old_select != new_select) {
+			if (old_select) {
+				vnc_import_bgp_exterior_del_route(bgp, p,
+								  old_select);
+				vnc_import_bgp_del_route(bgp, p, old_select);
+			}
+			if (new_select) {
+				vnc_import_bgp_exterior_add_route(bgp, p,
+								  new_select);
+				vnc_import_bgp_add_route(bgp, p, new_select);
+			}
+		}
+	}
+#endif
+
+	group_announce_route(bgp, afi, safi, dest, new_select);
+
+	/* unicast routes must also be annouced to labeled-unicast update-groups
+	 */
+	if (safi == SAFI_UNICAST)
+		group_announce_route(bgp, afi, SAFI_LABELED_UNICAST, dest,
+				     new_select);
+
+	/* FIB update. */
+	if (bgp_fibupd_safi(safi) && (bgp->inst_type != BGP_INSTANCE_TYPE_VIEW)
+	    && !bgp_option_check(BGP_OPT_NO_FIB)) {
+
+		if (new_select && new_select->type == ZEBRA_ROUTE_BGP
+		    && (new_select->sub_type == BGP_ROUTE_NORMAL
+			|| new_select->sub_type == BGP_ROUTE_AGGREGATE
+			|| new_select->sub_type == BGP_ROUTE_IMPORTED)) {
+
+			/* if this is an evpn imported type-5 prefix,
+			 * we need to withdraw the route first to clear
+			 * the nh neigh and the RMAC entry.
+			 */
+			if (old_select &&
+			    is_route_parent_evpn(old_select))
+				bgp_zebra_withdraw(p, old_select, bgp, safi);
+
+			bgp_zebra_announce(dest, p, new_select, bgp, afi, safi);
+		} else {
+			/* Withdraw the route from the kernel. */
+			if (old_select && old_select->type == ZEBRA_ROUTE_BGP
+			    && (old_select->sub_type == BGP_ROUTE_NORMAL
+				|| old_select->sub_type == BGP_ROUTE_AGGREGATE
+				|| old_select->sub_type == BGP_ROUTE_IMPORTED))
+
+				bgp_zebra_withdraw(p, old_select, bgp, safi);
+		}
+	}
+
+	bgp_process_evpn_route_injection(bgp, afi, safi, dest, new_select,
+					 old_select);
+
+	/* Clear any route change flags. */
+	bgp_zebra_clear_route_change_flags(dest);
+
+	UNSET_FLAG(dest->flags, BGP_NODE_PROCESS_SCHEDULED);
+
+	/* Reap old select bgp_path_info, if it has been removed */
+	if (old_select && CHECK_FLAG(old_select->flags, BGP_PATH_REMOVED))
+		bgp_path_info_reap(dest, old_select);
+
+	return;
+}
+
+/* Process the routes with the flag BGP_NODE_SELECT_DEFER set */
+void bgp_best_path_select_defer(struct bgp *bgp, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest;
+	int cnt = 0;
+	struct afi_safi_info *thread_info;
+
+	if (bgp->gr_info[afi][safi].t_route_select) {
+		struct event *t = bgp->gr_info[afi][safi].t_route_select;
+
+		thread_info = EVENT_ARG(t);
+		XFREE(MTYPE_TMP, thread_info);
+		EVENT_OFF(bgp->gr_info[afi][safi].t_route_select);
+	}
+
+	if (BGP_DEBUG(update, UPDATE_OUT)) {
+		zlog_debug("%s: processing route for %s : cnt %d", __func__,
+			   get_afi_safi_str(afi, safi, false),
+			   bgp->gr_info[afi][safi].gr_deferred);
+	}
+
+	/* Process the route list */
+	for (dest = bgp_table_top(bgp->rib[afi][safi]);
+	     dest && bgp->gr_info[afi][safi].gr_deferred != 0 &&
+	     cnt < BGP_MAX_BEST_ROUTE_SELECT;
+	     dest = bgp_route_next(dest)) {
+		if (!CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER))
+			continue;
+
+		UNSET_FLAG(dest->flags, BGP_NODE_SELECT_DEFER);
+		bgp->gr_info[afi][safi].gr_deferred--;
+		bgp_process_main_one(bgp, dest, afi, safi);
+		cnt++;
+	}
+	/* If iteration stopped before the entire table was traversed then the
+	 * node needs to be unlocked.
+	 */
+	if (dest) {
+		bgp_dest_unlock_node(dest);
+		dest = NULL;
+	}
+
+	/* Send EOR message when all routes are processed */
+	if (!bgp->gr_info[afi][safi].gr_deferred) {
+		bgp_send_delayed_eor(bgp);
+		/* Send route processing complete message to RIB */
+		bgp_zebra_update(bgp, afi, safi,
+				 ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE);
+		return;
+	}
+
+	thread_info = XMALLOC(MTYPE_TMP, sizeof(struct afi_safi_info));
+
+	thread_info->afi = afi;
+	thread_info->safi = safi;
+	thread_info->bgp = bgp;
+
+	/* If there are more routes to be processed, start the
+	 * selection timer
+	 */
+	event_add_timer(bm->master, bgp_route_select_timer_expire, thread_info,
+			BGP_ROUTE_SELECT_DELAY,
+			&bgp->gr_info[afi][safi].t_route_select);
+}
+
+static wq_item_status bgp_process_wq(struct work_queue *wq, void *data)
+{
+	struct bgp_process_queue *pqnode = data;
+	struct bgp *bgp = pqnode->bgp;
+	struct bgp_table *table;
+	struct bgp_dest *dest;
+
+	/* eoiu marker */
+	if (CHECK_FLAG(pqnode->flags, BGP_PROCESS_QUEUE_EOIU_MARKER)) {
+		bgp_process_main_one(bgp, NULL, 0, 0);
+		/* should always have dedicated wq call */
+		assert(STAILQ_FIRST(&pqnode->pqueue) == NULL);
+		return WQ_SUCCESS;
+	}
+
+	while (!STAILQ_EMPTY(&pqnode->pqueue)) {
+		dest = STAILQ_FIRST(&pqnode->pqueue);
+		STAILQ_REMOVE_HEAD(&pqnode->pqueue, pq);
+		STAILQ_NEXT(dest, pq) = NULL; /* complete unlink */
+		table = bgp_dest_table(dest);
+		/* note, new DESTs may be added as part of processing */
+		bgp_process_main_one(bgp, dest, table->afi, table->safi);
+
+		bgp_dest_unlock_node(dest);
+		bgp_table_unlock(table);
+	}
+
+	return WQ_SUCCESS;
+}
+
+static void bgp_processq_del(struct work_queue *wq, void *data)
+{
+	struct bgp_process_queue *pqnode = data;
+
+	bgp_unlock(pqnode->bgp);
+
+	XFREE(MTYPE_BGP_PROCESS_QUEUE, pqnode);
+}
+
+void bgp_process_queue_init(struct bgp *bgp)
+{
+	if (!bgp->process_queue) {
+		char name[BUFSIZ];
+
+		snprintf(name, BUFSIZ, "process_queue %s", bgp->name_pretty);
+		bgp->process_queue = work_queue_new(bm->master, name);
+	}
+
+	bgp->process_queue->spec.workfunc = &bgp_process_wq;
+	bgp->process_queue->spec.del_item_data = &bgp_processq_del;
+	bgp->process_queue->spec.max_retries = 0;
+	bgp->process_queue->spec.hold = 50;
+	/* Use a higher yield value of 50ms for main queue processing */
+	bgp->process_queue->spec.yield = 50 * 1000L;
+}
+
+static struct bgp_process_queue *bgp_processq_alloc(struct bgp *bgp)
+{
+	struct bgp_process_queue *pqnode;
+
+	pqnode = XCALLOC(MTYPE_BGP_PROCESS_QUEUE,
+			 sizeof(struct bgp_process_queue));
+
+	/* unlocked in bgp_processq_del */
+	pqnode->bgp = bgp_lock(bgp);
+	STAILQ_INIT(&pqnode->pqueue);
+
+	return pqnode;
+}
+
+void bgp_process(struct bgp *bgp, struct bgp_dest *dest, afi_t afi, safi_t safi)
+{
+#define ARBITRARY_PROCESS_QLEN		10000
+	struct work_queue *wq = bgp->process_queue;
+	struct bgp_process_queue *pqnode;
+	int pqnode_reuse = 0;
+
+	/* already scheduled for processing? */
+	if (CHECK_FLAG(dest->flags, BGP_NODE_PROCESS_SCHEDULED))
+		return;
+
+	/* If the flag BGP_NODE_SELECT_DEFER is set, do not add route to
+	 * the workqueue
+	 */
+	if (CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER)) {
+		if (BGP_DEBUG(update, UPDATE_OUT))
+			zlog_debug("BGP_NODE_SELECT_DEFER set for route %p",
+				   dest);
+		return;
+	}
+
+	if (CHECK_FLAG(dest->flags, BGP_NODE_SOFT_RECONFIG)) {
+		if (BGP_DEBUG(update, UPDATE_OUT))
+			zlog_debug(
+				"Soft reconfigure table in progress for route %p",
+				dest);
+		return;
+	}
+
+	if (wq == NULL)
+		return;
+
+	/* Add route nodes to an existing work queue item until reaching the
+	   limit only if is from the same BGP view and it's not an EOIU marker
+	 */
+	if (work_queue_item_count(wq)) {
+		struct work_queue_item *item = work_queue_last_item(wq);
+		pqnode = item->data;
+
+		if (CHECK_FLAG(pqnode->flags, BGP_PROCESS_QUEUE_EOIU_MARKER)
+		    || pqnode->bgp != bgp
+		    || pqnode->queued >= ARBITRARY_PROCESS_QLEN)
+			pqnode = bgp_processq_alloc(bgp);
+		else
+			pqnode_reuse = 1;
+	} else
+		pqnode = bgp_processq_alloc(bgp);
+	/* all unlocked in bgp_process_wq */
+	bgp_table_lock(bgp_dest_table(dest));
+
+	SET_FLAG(dest->flags, BGP_NODE_PROCESS_SCHEDULED);
+	bgp_dest_lock_node(dest);
+
+	/* can't be enqueued twice */
+	assert(STAILQ_NEXT(dest, pq) == NULL);
+	STAILQ_INSERT_TAIL(&pqnode->pqueue, dest, pq);
+	pqnode->queued++;
+
+	if (!pqnode_reuse)
+		work_queue_add(wq, pqnode);
+
+	return;
+}
+
+void bgp_add_eoiu_mark(struct bgp *bgp)
+{
+	struct bgp_process_queue *pqnode;
+
+	if (bgp->process_queue == NULL)
+		return;
+
+	pqnode = bgp_processq_alloc(bgp);
+
+	SET_FLAG(pqnode->flags, BGP_PROCESS_QUEUE_EOIU_MARKER);
+	work_queue_add(bgp->process_queue, pqnode);
+}
+
+static void bgp_maximum_prefix_restart_timer(struct event *thread)
+{
+	struct peer_connection *connection = EVENT_ARG(thread);
+	struct peer *peer = connection->peer;
+
+	if (bgp_debug_neighbor_events(peer))
+		zlog_debug(
+			"%s Maximum-prefix restart timer expired, restore peering",
+			peer->host);
+
+	if ((peer_clear(peer, NULL) < 0) && bgp_debug_neighbor_events(peer))
+		zlog_debug("%s: %s peer_clear failed", __func__, peer->host);
+}
+
+static uint32_t bgp_filtered_routes_count(struct peer *peer, afi_t afi,
+					  safi_t safi)
+{
+	uint32_t count = 0;
+	bool filtered = false;
+	struct bgp_dest *dest;
+	struct bgp_adj_in *ain;
+	struct attr attr = {};
+	struct bgp_table *table = peer->bgp->rib[afi][safi];
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		for (ain = dest->adj_in; ain; ain = ain->next) {
+			const struct prefix *rn_p = bgp_dest_get_prefix(dest);
+
+			attr = *ain->attr;
+
+			if (bgp_input_filter(peer, rn_p, &attr, afi, safi)
+			    == FILTER_DENY)
+				filtered = true;
+
+			if (bgp_input_modifier(
+				    peer, rn_p, &attr, afi, safi,
+				    ROUTE_MAP_IN_NAME(&peer->filter[afi][safi]),
+				    NULL, 0, NULL)
+			    == RMAP_DENY)
+				filtered = true;
+
+			if (filtered)
+				count++;
+
+			bgp_attr_flush(&attr);
+		}
+	}
+
+	return count;
+}
+
+bool bgp_maximum_prefix_overflow(struct peer *peer, afi_t afi, safi_t safi,
+				 int always)
+{
+	iana_afi_t pkt_afi;
+	iana_safi_t pkt_safi;
+	uint32_t pcount = (CHECK_FLAG(peer->af_flags[afi][safi],
+				      PEER_FLAG_MAX_PREFIX_FORCE))
+				  ? bgp_filtered_routes_count(peer, afi, safi)
+					    + peer->pcount[afi][safi]
+				  : peer->pcount[afi][safi];
+	struct peer_connection *connection = peer->connection;
+
+	if (!CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_MAX_PREFIX))
+		return false;
+
+	if (pcount > peer->pmax[afi][safi]) {
+		if (CHECK_FLAG(peer->af_sflags[afi][safi],
+			       PEER_STATUS_PREFIX_LIMIT)
+		    && !always)
+			return false;
+
+		zlog_info(
+			"%%MAXPFXEXCEED: No. of %s prefix received from %pBP %u exceed, limit %u",
+			get_afi_safi_str(afi, safi, false), peer, pcount,
+			peer->pmax[afi][safi]);
+		SET_FLAG(peer->af_sflags[afi][safi], PEER_STATUS_PREFIX_LIMIT);
+
+		if (CHECK_FLAG(peer->af_flags[afi][safi],
+			       PEER_FLAG_MAX_PREFIX_WARNING))
+			return false;
+
+		/* Convert AFI, SAFI to values for packet. */
+		pkt_afi = afi_int2iana(afi);
+		pkt_safi = safi_int2iana(safi);
+		{
+			uint8_t ndata[7];
+
+			ndata[0] = (pkt_afi >> 8);
+			ndata[1] = pkt_afi;
+			ndata[2] = pkt_safi;
+			ndata[3] = (peer->pmax[afi][safi] >> 24);
+			ndata[4] = (peer->pmax[afi][safi] >> 16);
+			ndata[5] = (peer->pmax[afi][safi] >> 8);
+			ndata[6] = (peer->pmax[afi][safi]);
+
+			SET_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW);
+			bgp_notify_send_with_data(connection, BGP_NOTIFY_CEASE,
+						  BGP_NOTIFY_CEASE_MAX_PREFIX,
+						  ndata, 7);
+		}
+
+		/* Dynamic peers will just close their connection. */
+		if (peer_dynamic_neighbor(peer))
+			return true;
+
+		/* restart timer start */
+		if (peer->pmax_restart[afi][safi]) {
+			peer->v_pmax_restart =
+				peer->pmax_restart[afi][safi] * 60;
+
+			if (bgp_debug_neighbor_events(peer))
+				zlog_debug(
+					"%pBP Maximum-prefix restart timer started for %d secs",
+					peer, peer->v_pmax_restart);
+
+			BGP_TIMER_ON(connection->t_pmax_restart,
+				     bgp_maximum_prefix_restart_timer,
+				     peer->v_pmax_restart);
+		}
+
+		return true;
+	} else
+		UNSET_FLAG(peer->af_sflags[afi][safi],
+			   PEER_STATUS_PREFIX_LIMIT);
+
+	if (pcount
+	    > (peer->pmax[afi][safi] * peer->pmax_threshold[afi][safi] / 100)) {
+		if (CHECK_FLAG(peer->af_sflags[afi][safi],
+			       PEER_STATUS_PREFIX_THRESHOLD)
+		    && !always)
+			return false;
+
+		zlog_info(
+			"%%MAXPFX: No. of %s prefix received from %pBP reaches %u, max %u",
+			get_afi_safi_str(afi, safi, false), peer, pcount,
+			peer->pmax[afi][safi]);
+		SET_FLAG(peer->af_sflags[afi][safi],
+			 PEER_STATUS_PREFIX_THRESHOLD);
+	} else
+		UNSET_FLAG(peer->af_sflags[afi][safi],
+			   PEER_STATUS_PREFIX_THRESHOLD);
+	return false;
+}
+
+/* Unconditionally remove the route from the RIB, without taking
+ * damping into consideration (eg, because the session went down)
+ */
+void bgp_rib_remove(struct bgp_dest *dest, struct bgp_path_info *pi,
+		    struct peer *peer, afi_t afi, safi_t safi)
+{
+
+	struct bgp *bgp = NULL;
+	bool delete_route = false;
+
+	bgp_aggregate_decrement(peer->bgp, bgp_dest_get_prefix(dest), pi, afi,
+				safi);
+
+	if (!CHECK_FLAG(pi->flags, BGP_PATH_HISTORY)) {
+		bgp_path_info_delete(dest, pi); /* keep historical info */
+
+		/* If the selected path is removed, reset BGP_NODE_SELECT_DEFER
+		 * flag
+		 */
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+			delete_route = true;
+		else if (bgp_dest_set_defer_flag(dest, true) < 0)
+			delete_route = true;
+		if (delete_route) {
+			if (CHECK_FLAG(dest->flags, BGP_NODE_SELECT_DEFER)) {
+				UNSET_FLAG(dest->flags, BGP_NODE_SELECT_DEFER);
+				bgp = pi->peer->bgp;
+				bgp->gr_info[afi][safi].gr_deferred--;
+			}
+		}
+	}
+
+	hook_call(bgp_process, peer->bgp, afi, safi, dest, peer, true);
+	bgp_process(peer->bgp, dest, afi, safi);
+}
+
+static void bgp_rib_withdraw(struct bgp_dest *dest, struct bgp_path_info *pi,
+			     struct peer *peer, afi_t afi, safi_t safi,
+			     struct prefix_rd *prd)
+{
+	const struct prefix *p = bgp_dest_get_prefix(dest);
+
+	/* apply dampening, if result is suppressed, we'll be retaining
+	 * the bgp_path_info in the RIB for historical reference.
+	 */
+	if (CHECK_FLAG(peer->bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)
+	    && peer->sort == BGP_PEER_EBGP)
+		if ((bgp_damp_withdraw(pi, dest, afi, safi, 0))
+		    == BGP_DAMP_SUPPRESSED) {
+			bgp_aggregate_decrement(peer->bgp, p, pi, afi,
+						safi);
+			return;
+		}
+
+#ifdef ENABLE_BGP_VNC
+	if (safi == SAFI_MPLS_VPN) {
+		struct bgp_dest *pdest = NULL;
+		struct bgp_table *table = NULL;
+
+		pdest = bgp_node_get(peer->bgp->rib[afi][safi],
+				     (struct prefix *)prd);
+		if (bgp_dest_has_bgp_path_info_data(pdest)) {
+			table = bgp_dest_get_bgp_table_info(pdest);
+
+			vnc_import_bgp_del_vnc_host_route_mode_resolve_nve(
+				peer->bgp, prd, table, p, pi);
+		}
+		bgp_dest_unlock_node(pdest);
+	}
+	if ((afi == AFI_IP || afi == AFI_IP6) && (safi == SAFI_UNICAST)) {
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)) {
+
+			vnc_import_bgp_del_route(peer->bgp, p, pi);
+			vnc_import_bgp_exterior_del_route(peer->bgp, p, pi);
+		}
+	}
+#endif
+
+	/* If this is an EVPN route, process for un-import. */
+	if (safi == SAFI_EVPN)
+		bgp_evpn_unimport_route(peer->bgp, afi, safi, p, pi);
+
+	bgp_rib_remove(dest, pi, peer, afi, safi);
+}
+
+struct bgp_path_info *info_make(int type, int sub_type, unsigned short instance,
+				struct peer *peer, struct attr *attr,
+				struct bgp_dest *dest)
+{
+	struct bgp_path_info *new;
+
+	/* Make new BGP info. */
+	new = XCALLOC(MTYPE_BGP_ROUTE, sizeof(struct bgp_path_info));
+	new->type = type;
+	new->instance = instance;
+	new->sub_type = sub_type;
+	new->peer = peer;
+	new->attr = attr;
+	new->uptime = monotime(NULL);
+	new->net = dest;
+	return new;
+}
+
+/* Check if received nexthop is valid or not. */
+bool bgp_update_martian_nexthop(struct bgp *bgp, afi_t afi, safi_t safi,
+				uint8_t type, uint8_t stype, struct attr *attr,
+				struct bgp_dest *dest)
+{
+	bool ret = false;
+	bool is_bgp_static_route =
+		(type == ZEBRA_ROUTE_BGP && stype == BGP_ROUTE_STATIC) ? true
+								       : false;
+
+	/* If `bgp allow-martian-nexthop` is turned on, return next-hop
+	 * as good.
+	 */
+	if (bgp->allow_martian)
+		return false;
+
+	/*
+	 * Only validated for unicast and multicast currently.
+	 * Also valid for EVPN where the nexthop is an IP address.
+	 * If we are a bgp static route being checked then there is
+	 * no need to check to see if the nexthop is martian as
+	 * that it should be ok.
+	 */
+	if (is_bgp_static_route ||
+	    (safi != SAFI_UNICAST && safi != SAFI_MULTICAST && safi != SAFI_EVPN))
+		return false;
+
+	/* If NEXT_HOP is present, validate it. */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) {
+		if (attr->nexthop.s_addr == INADDR_ANY ||
+		    !ipv4_unicast_valid(&attr->nexthop) ||
+		    bgp_nexthop_self(bgp, afi, type, stype, attr, dest))
+			return true;
+	}
+
+	/* If MP_NEXTHOP is present, validate it. */
+	/* Note: For IPv6 nexthops, we only validate the global (1st) nexthop;
+	 * there is code in bgp_attr.c to ignore the link-local (2nd) nexthop if
+	 * it is not an IPv6 link-local address.
+	 *
+	 * If we receive an UPDATE with nexthop length set to 32 bytes
+	 * we shouldn't discard an UPDATE if it's set to (::).
+	 * The link-local (2st) is validated along the code path later.
+	 */
+	if (attr->mp_nexthop_len) {
+		switch (attr->mp_nexthop_len) {
+		case BGP_ATTR_NHLEN_IPV4:
+		case BGP_ATTR_NHLEN_VPNV4:
+			ret = (attr->mp_nexthop_global_in.s_addr ==
+				       INADDR_ANY ||
+			       !ipv4_unicast_valid(
+				       &attr->mp_nexthop_global_in) ||
+			       bgp_nexthop_self(bgp, afi, type, stype, attr,
+						dest));
+			break;
+
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL:
+		case BGP_ATTR_NHLEN_VPNV6_GLOBAL:
+			ret = (IN6_IS_ADDR_UNSPECIFIED(
+					&attr->mp_nexthop_global)
+			       || IN6_IS_ADDR_LOOPBACK(&attr->mp_nexthop_global)
+			       || IN6_IS_ADDR_MULTICAST(
+				       &attr->mp_nexthop_global)
+			       || bgp_nexthop_self(bgp, afi, type, stype, attr,
+						   dest));
+			break;
+		case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
+			ret = (IN6_IS_ADDR_LOOPBACK(&attr->mp_nexthop_global)
+			       || IN6_IS_ADDR_MULTICAST(
+				       &attr->mp_nexthop_global)
+			       || bgp_nexthop_self(bgp, afi, type, stype, attr,
+						   dest));
+			break;
+
+		default:
+			ret = true;
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static void bgp_attr_add_no_export_community(struct attr *attr)
+{
+	struct community *old;
+	struct community *new;
+	struct community *merge;
+	struct community *no_export;
+
+	old = bgp_attr_get_community(attr);
+	no_export = community_str2com("no-export");
+
+	assert(no_export);
+
+	if (old) {
+		merge = community_merge(community_dup(old), no_export);
+
+		if (!old->refcnt)
+			community_free(&old);
+
+		new = community_uniq_sort(merge);
+		community_free(&merge);
+	} else {
+		new = community_dup(no_export);
+	}
+
+	community_free(&no_export);
+
+	bgp_attr_set_community(attr, new);
+}
+
+static bool bgp_accept_own(struct peer *peer, afi_t afi, safi_t safi,
+			   struct attr *attr, const struct prefix *prefix,
+			   int *sub_type)
+{
+	struct listnode *node, *nnode;
+	struct bgp *bgp;
+	bool accept_own_found = false;
+
+	if (safi != SAFI_MPLS_VPN)
+		return false;
+
+	/* Processing of the ACCEPT_OWN community is enabled by configuration */
+	if (!CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_ACCEPT_OWN))
+		return false;
+
+	/* The route in question carries the ACCEPT_OWN community */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)) {
+		struct community *comm = bgp_attr_get_community(attr);
+
+		if (community_include(comm, COMMUNITY_ACCEPT_OWN))
+			accept_own_found = true;
+	}
+
+	/* The route in question is targeted to one or more destination VRFs
+	 * on the router (as determined by inspecting the Route Target(s)).
+	 */
+	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
+		if (bgp->inst_type != BGP_INSTANCE_TYPE_VRF)
+			continue;
+
+		if (accept_own_found &&
+		    ecommunity_include(
+			    bgp->vpn_policy[afi]
+				    .rtlist[BGP_VPN_POLICY_DIR_TOVPN],
+			    bgp_attr_get_ecommunity(attr))) {
+			if (bgp_debug_update(peer, prefix, NULL, 1))
+				zlog_debug(
+					"%pBP prefix %pFX has ORIGINATOR_ID, but it's accepted due to ACCEPT_OWN",
+					peer, prefix);
+
+			/* Treat this route as imported, because it's leaked
+			 * already from another VRF, and we got an updated
+			 * version from route-reflector with ACCEPT_OWN
+			 * community.
+			 */
+			*sub_type = BGP_ROUTE_IMPORTED;
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void bgp_update(struct peer *peer, const struct prefix *p, uint32_t addpath_id,
+		struct attr *attr, afi_t afi, safi_t safi, int type,
+		int sub_type, struct prefix_rd *prd, mpls_label_t *label,
+		uint32_t num_labels, int soft_reconfig,
+		struct bgp_route_evpn *evpn)
+{
+	int ret;
+	int aspath_loop_count = 0;
+	struct bgp_dest *dest;
+	struct bgp *bgp;
+	struct attr new_attr;
+	struct attr *attr_new;
+	struct bgp_path_info *pi;
+	struct bgp_path_info *new = NULL;
+	struct bgp_path_info_extra *extra;
+	const char *reason;
+	char pfx_buf[BGP_PRD_PATH_STRLEN];
+	int connected = 0;
+	int do_loop_check = 1;
+	int has_valid_label = 0;
+	afi_t nh_afi;
+	bool force_evpn_import = false;
+	safi_t orig_safi = safi;
+	int allowas_in = 0;
+
+	if (frrtrace_enabled(frr_bgp, process_update)) {
+		char pfxprint[PREFIX2STR_BUFFER];
+
+		prefix2str(p, pfxprint, sizeof(pfxprint));
+		frrtrace(6, frr_bgp, process_update, peer, pfxprint, addpath_id,
+			 afi, safi, attr);
+	}
+
+#ifdef ENABLE_BGP_VNC
+	int vnc_implicit_withdraw = 0;
+#endif
+	int same_attr = 0;
+	const struct prefix *bgp_nht_param_prefix;
+
+	/* Special case for BGP-LU - map LU safi to ordinary unicast safi */
+	if (orig_safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	memset(&new_attr, 0, sizeof(new_attr));
+	new_attr.label_index = BGP_INVALID_LABEL_INDEX;
+	new_attr.label = MPLS_INVALID_LABEL;
+
+	bgp = peer->bgp;
+	dest = bgp_afi_node_get(bgp->rib[afi][safi], afi, safi, p, prd);
+	/* TODO: Check to see if we can get rid of "is_valid_label" */
+	if (afi == AFI_L2VPN && safi == SAFI_EVPN)
+		has_valid_label = (num_labels > 0) ? 1 : 0;
+	else
+		has_valid_label = bgp_is_valid_label(label);
+
+	if (has_valid_label)
+		assert(label != NULL);
+
+
+	/* When peer's soft reconfiguration enabled.  Record input packet in
+	   Adj-RIBs-In.  */
+	if (!soft_reconfig &&
+	    CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG) &&
+	    peer != bgp->peer_self) {
+		/*
+		 * If the trigger is not from soft_reconfig and if
+		 * PEER_FLAG_SOFT_RECONFIG is enabled for the peer, then attr
+		 * will not be interned. In which case, it is ok to update the
+		 * attr->evpn_overlay, so that, this can be stored in adj_in.
+		 */
+		if ((afi == AFI_L2VPN) && evpn) {
+			memcpy(&attr->evpn_overlay, evpn,
+			       sizeof(struct bgp_route_evpn));
+		}
+		bgp_adj_in_set(dest, peer, attr, addpath_id);
+	}
+
+	/* Update permitted loop count */
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN))
+		allowas_in = peer->allowas_in[afi][safi];
+
+	/* Check previously received route. */
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == peer && pi->type == type
+		    && pi->sub_type == sub_type
+		    && pi->addpath_rx_id == addpath_id)
+			break;
+
+	/* AS path local-as loop check. */
+	if (peer->change_local_as) {
+		if (allowas_in)
+			aspath_loop_count = allowas_in;
+		else if (!CHECK_FLAG(peer->flags,
+				     PEER_FLAG_LOCAL_AS_NO_PREPEND))
+			aspath_loop_count = 1;
+
+		if (aspath_loop_check(attr->aspath, peer->change_local_as)
+		    > aspath_loop_count) {
+			peer->stat_pfx_aspath_loop++;
+			reason = "as-path contains our own AS;";
+			goto filtered;
+		}
+	}
+
+	/* If the peer is configured for "allowas-in origin" and the last ASN in
+	 * the
+	 * as-path is our ASN then we do not need to call aspath_loop_check
+	 */
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_ALLOWAS_IN_ORIGIN))
+		if (aspath_get_last_as(attr->aspath) == bgp->as)
+			do_loop_check = 0;
+
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_REFLECTOR_CLIENT))
+		bgp_nht_param_prefix = NULL;
+	else
+		bgp_nht_param_prefix = p;
+
+	/* AS path loop check. */
+	if (do_loop_check) {
+		if (aspath_loop_check(attr->aspath, bgp->as) >
+		    peer->allowas_in[afi][safi]) {
+			peer->stat_pfx_aspath_loop++;
+			reason = "as-path contains our own AS;";
+			goto filtered;
+		}
+	}
+
+	/* If we're a CONFED we need to loop check the CONFED ID too */
+	if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION) && do_loop_check)
+		if (aspath_loop_check_confed(attr->aspath, bgp->confed_id) >
+		    peer->allowas_in[afi][safi]) {
+			peer->stat_pfx_aspath_loop++;
+			reason = "as-path contains our own confed AS;";
+			goto filtered;
+		}
+
+	/* Route reflector originator ID check. If ACCEPT_OWN mechanism is
+	 * enabled, then take care of that too.
+	 */
+	bool accept_own = false;
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)
+	    && IPV4_ADDR_SAME(&bgp->router_id, &attr->originator_id)) {
+		accept_own =
+			bgp_accept_own(peer, afi, safi, attr, p, &sub_type);
+		if (!accept_own) {
+			peer->stat_pfx_originator_loop++;
+			reason = "originator is us;";
+			goto filtered;
+		}
+	}
+
+	/* Route reflector cluster ID check.  */
+	if (bgp_cluster_filter(peer, attr)) {
+		peer->stat_pfx_cluster_loop++;
+		reason = "reflected from the same cluster;";
+		goto filtered;
+	}
+
+	/* Apply incoming filter.  */
+	if (bgp_input_filter(peer, p, attr, afi, orig_safi) == FILTER_DENY) {
+		peer->stat_pfx_filter++;
+		reason = "filter;";
+		goto filtered;
+	}
+
+	if ((afi == AFI_IP || afi == AFI_IP6) && safi == SAFI_MPLS_VPN &&
+	    bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT &&
+	    !CHECK_FLAG(bgp->af_flags[afi][safi],
+			BGP_VPNVX_RETAIN_ROUTE_TARGET_ALL) &&
+	    vpn_leak_to_vrf_no_retain_filter_check(bgp, attr, afi)) {
+		reason =
+			"no import. Filtered by no bgp retain route-target all";
+		goto filtered;
+	}
+
+	/* If the route has Node Target Extended Communities, check
+	 * if it's allowed to be installed locally.
+	 */
+	if ((attr->flag & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+		struct ecommunity *ecomm = bgp_attr_get_ecommunity(attr);
+
+		if (ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_IP,
+				      ECOMMUNITY_NODE_TARGET) &&
+		    !ecommunity_node_target_match(ecomm, &peer->local_id)) {
+			reason =
+				"Node-Target Extended Communities do not contain own BGP Identifier;";
+			goto filtered;
+		}
+	}
+
+	/* RFC 8212 to prevent route leaks.
+	 * This specification intends to improve this situation by requiring the
+	 * explicit configuration of both BGP Import and Export Policies for any
+	 * External BGP (EBGP) session such as customers, peers, or
+	 * confederation boundaries for all enabled address families. Through
+	 * codification of the aforementioned requirement, operators will
+	 * benefit from consistent behavior across different BGP
+	 * implementations.
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_EBGP_REQUIRES_POLICY))
+		if (!bgp_inbound_policy_exists(peer,
+					       &peer->filter[afi][safi])) {
+			reason = "inbound policy missing";
+			if (monotime_since(&bgp->ebgprequirespolicywarning,
+					   NULL) > FIFTEENMINUTE2USEC ||
+			    bgp->ebgprequirespolicywarning.tv_sec == 0) {
+				zlog_warn(
+					"EBGP inbound/outbound policy not properly setup, please configure in order for your peering to work correctly");
+				monotime(&bgp->ebgprequirespolicywarning);
+			}
+			goto filtered;
+		}
+
+	/* draft-ietf-idr-deprecate-as-set-confed-set
+	 * Filter routes having AS_SET or AS_CONFED_SET in the path.
+	 * Eventually, This document (if approved) updates RFC 4271
+	 * and RFC 5065 by eliminating AS_SET and AS_CONFED_SET types,
+	 * and obsoletes RFC 6472.
+	 */
+	if (peer->bgp->reject_as_sets)
+		if (aspath_check_as_sets(attr->aspath)) {
+			reason =
+				"as-path contains AS_SET or AS_CONFED_SET type;";
+			goto filtered;
+		}
+
+	new_attr = *attr;
+	/*
+	 * If bgp_update is called with soft_reconfig set then
+	 * attr is interned. In this case, do not overwrite the
+	 * attr->evpn_overlay with evpn directly. Instead memcpy
+	 * evpn to new_atr.evpn_overlay before it is interned.
+	 */
+	if (soft_reconfig && (afi == AFI_L2VPN) && evpn)
+		memcpy(&new_attr.evpn_overlay, evpn,
+		       sizeof(struct bgp_route_evpn));
+
+	/* Apply incoming route-map.
+	 * NB: new_attr may now contain newly allocated values from route-map
+	 * "set"
+	 * commands, so we need bgp_attr_flush in the error paths, until we
+	 * intern
+	 * the attr (which takes over the memory references) */
+	if (bgp_input_modifier(peer, p, &new_attr, afi, orig_safi, NULL, label,
+			       num_labels, dest)
+	    == RMAP_DENY) {
+		peer->stat_pfx_filter++;
+		reason = "route-map;";
+		bgp_attr_flush(&new_attr);
+		goto filtered;
+	}
+
+	if (pi && pi->attr->rmap_table_id != new_attr.rmap_table_id) {
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+			/* remove from RIB previous entry */
+			bgp_zebra_withdraw(p, pi, bgp, safi);
+	}
+
+	if (peer->sort == BGP_PEER_EBGP) {
+
+		/* rfc7999:
+		 * A BGP speaker receiving an announcement tagged with the
+		 * BLACKHOLE community SHOULD add the NO_ADVERTISE or
+		 * NO_EXPORT community as defined in RFC1997, or a
+		 * similar community, to prevent propagation of the
+		 * prefix outside the local AS. The community to prevent
+		 * propagation SHOULD be chosen according to the operator's
+		 * routing policy.
+		 */
+		if (bgp_attr_get_community(&new_attr) &&
+		    community_include(bgp_attr_get_community(&new_attr),
+				      COMMUNITY_BLACKHOLE))
+			bgp_attr_add_no_export_community(&new_attr);
+
+		/* If we receive the graceful-shutdown community from an eBGP
+		 * peer we must lower local-preference */
+		if (bgp_attr_get_community(&new_attr) &&
+		    community_include(bgp_attr_get_community(&new_attr),
+				      COMMUNITY_GSHUT)) {
+			new_attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF);
+			new_attr.local_pref = BGP_GSHUT_LOCAL_PREF;
+
+			/* If graceful-shutdown is configured globally or
+			 * per neighbor, then add the GSHUT community to
+			 * all paths received from eBGP peers. */
+		} else if (bgp_in_graceful_shutdown(peer->bgp) ||
+			   CHECK_FLAG(peer->flags, PEER_FLAG_GRACEFUL_SHUTDOWN))
+			bgp_attr_add_gshut_community(&new_attr);
+	}
+
+	/* next hop check.  */
+	if (!CHECK_FLAG(peer->flags, PEER_FLAG_IS_RFAPI_HD) &&
+	    bgp_update_martian_nexthop(bgp, afi, safi, type, sub_type,
+				       &new_attr, dest)) {
+		peer->stat_pfx_nh_invalid++;
+		reason = "martian or self next-hop;";
+		bgp_attr_flush(&new_attr);
+		goto filtered;
+	}
+
+	if (bgp_mac_entry_exists(p) || bgp_mac_exist(&attr->rmac)) {
+		peer->stat_pfx_nh_invalid++;
+		reason = "self mac;";
+		bgp_attr_flush(&new_attr);
+		goto filtered;
+	}
+
+	if (bgp_check_role_applicability(afi, safi) &&
+	    bgp_otc_filter(peer, &new_attr)) {
+		reason = "failing otc validation";
+		bgp_attr_flush(&new_attr);
+		goto filtered;
+	}
+
+	/* If neighbor soo is configured, tag all incoming routes with
+	 * this SoO tag and then filter out advertisements in
+	 * subgroup_announce_check() if it matches the configured SoO
+	 * on the other peer.
+	 */
+	if (peer->soo[afi][safi]) {
+		struct ecommunity *old_ecomm =
+			bgp_attr_get_ecommunity(&new_attr);
+		struct ecommunity *ecomm_soo = peer->soo[afi][safi];
+		struct ecommunity *new_ecomm;
+
+		if (old_ecomm) {
+			new_ecomm = ecommunity_merge(ecommunity_dup(old_ecomm),
+						     ecomm_soo);
+
+			if (!old_ecomm->refcnt)
+				ecommunity_free(&old_ecomm);
+		} else {
+			new_ecomm = ecommunity_dup(ecomm_soo);
+		}
+
+		bgp_attr_set_ecommunity(&new_attr, new_ecomm);
+	}
+
+	attr_new = bgp_attr_intern(&new_attr);
+
+	/* If the update is implicit withdraw. */
+	if (pi) {
+		pi->uptime = monotime(NULL);
+		same_attr = attrhash_cmp(pi->attr, attr_new);
+
+		hook_call(bgp_process, bgp, afi, safi, dest, peer, true);
+
+		/* Same attribute comes in. */
+		if (!CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)
+		    && same_attr
+		    && (!has_valid_label
+			|| memcmp(&(bgp_path_info_extra_get(pi))->label, label,
+				  num_labels * sizeof(mpls_label_t))
+				   == 0)) {
+			if (CHECK_FLAG(bgp->af_flags[afi][safi],
+				       BGP_CONFIG_DAMPENING)
+			    && peer->sort == BGP_PEER_EBGP
+			    && CHECK_FLAG(pi->flags, BGP_PATH_HISTORY)) {
+				if (bgp_debug_update(peer, p, NULL, 1)) {
+					bgp_debug_rdpfxpath2str(
+						afi, safi, prd, p, label,
+						num_labels, addpath_id ? 1 : 0,
+						addpath_id, evpn, pfx_buf,
+						sizeof(pfx_buf));
+					zlog_debug("%pBP rcvd %s", peer,
+						   pfx_buf);
+				}
+
+				if (bgp_damp_update(pi, dest, afi, safi)
+				    != BGP_DAMP_SUPPRESSED) {
+					bgp_aggregate_increment(bgp, p, pi, afi,
+								safi);
+					bgp_process(bgp, dest, afi, safi);
+				}
+			} else /* Duplicate - odd */
+			{
+				if (bgp_debug_update(peer, p, NULL, 1)) {
+					if (!peer->rcvd_attr_printed) {
+						zlog_debug(
+							"%pBP rcvd UPDATE w/ attr: %s",
+							peer,
+							peer->rcvd_attr_str);
+						peer->rcvd_attr_printed = 1;
+					}
+
+					bgp_debug_rdpfxpath2str(
+						afi, safi, prd, p, label,
+						num_labels, addpath_id ? 1 : 0,
+						addpath_id, evpn, pfx_buf,
+						sizeof(pfx_buf));
+					zlog_debug(
+						"%pBP rcvd %s...duplicate ignored",
+						peer, pfx_buf);
+				}
+
+				/* graceful restart STALE flag unset. */
+				if (CHECK_FLAG(pi->flags, BGP_PATH_STALE)) {
+					bgp_path_info_unset_flag(
+						dest, pi, BGP_PATH_STALE);
+					bgp_dest_set_defer_flag(dest, false);
+					bgp_process(bgp, dest, afi, safi);
+				}
+			}
+
+			bgp_dest_unlock_node(dest);
+			bgp_attr_unintern(&attr_new);
+
+			return;
+		}
+
+		/* Withdraw/Announce before we fully processed the withdraw */
+		if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)) {
+			if (bgp_debug_update(peer, p, NULL, 1)) {
+				bgp_debug_rdpfxpath2str(
+					afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, evpn,
+					pfx_buf, sizeof(pfx_buf));
+				zlog_debug(
+					"%pBP rcvd %s, flapped quicker than processing",
+					peer, pfx_buf);
+			}
+
+			bgp_path_info_restore(dest, pi);
+
+			/*
+			 * If the BGP_PATH_REMOVED flag is set, then EVPN
+			 * routes would have been unimported already when a
+			 * prior BGP withdraw processing happened. Such routes
+			 * need to be imported again, so flag accordingly.
+			 */
+			force_evpn_import = true;
+		} else {
+			/* implicit withdraw, decrement aggregate and pcount
+			 * here. only if update is accepted, they'll increment
+			 * below.
+			 */
+			bgp_aggregate_decrement(bgp, p, pi, afi, safi);
+		}
+
+		/* Received Logging. */
+		if (bgp_debug_update(peer, p, NULL, 1)) {
+			bgp_debug_rdpfxpath2str(afi, safi, prd, p, label,
+						num_labels, addpath_id ? 1 : 0,
+						addpath_id, evpn, pfx_buf,
+						sizeof(pfx_buf));
+			zlog_debug("%pBP rcvd %s", peer, pfx_buf);
+		}
+
+		/* graceful restart STALE flag unset. */
+		if (CHECK_FLAG(pi->flags, BGP_PATH_STALE)) {
+			bgp_path_info_unset_flag(dest, pi, BGP_PATH_STALE);
+			bgp_dest_set_defer_flag(dest, false);
+		}
+
+		/* The attribute is changed. */
+		bgp_path_info_set_flag(dest, pi, BGP_PATH_ATTR_CHANGED);
+
+		/* Update bgp route dampening information.  */
+		if (CHECK_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)
+		    && peer->sort == BGP_PEER_EBGP) {
+			/* This is implicit withdraw so we should update
+			   dampening
+			   information.  */
+			if (!CHECK_FLAG(pi->flags, BGP_PATH_HISTORY))
+				bgp_damp_withdraw(pi, dest, afi, safi, 1);
+		}
+#ifdef ENABLE_BGP_VNC
+		if (safi == SAFI_MPLS_VPN) {
+			struct bgp_dest *pdest = NULL;
+			struct bgp_table *table = NULL;
+
+			pdest = bgp_node_get(bgp->rib[afi][safi],
+					     (struct prefix *)prd);
+			if (bgp_dest_has_bgp_path_info_data(pdest)) {
+				table = bgp_dest_get_bgp_table_info(pdest);
+
+				vnc_import_bgp_del_vnc_host_route_mode_resolve_nve(
+					bgp, prd, table, p, pi);
+			}
+			bgp_dest_unlock_node(pdest);
+		}
+		if ((afi == AFI_IP || afi == AFI_IP6)
+		    && (safi == SAFI_UNICAST)) {
+			if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)) {
+				/*
+				 * Implicit withdraw case.
+				 */
+				++vnc_implicit_withdraw;
+				vnc_import_bgp_del_route(bgp, p, pi);
+				vnc_import_bgp_exterior_del_route(bgp, p, pi);
+			}
+		}
+#endif
+
+		/* Special handling for EVPN update of an existing route. If the
+		 * extended community attribute has changed, we need to
+		 * un-import
+		 * the route using its existing extended community. It will be
+		 * subsequently processed for import with the new extended
+		 * community.
+		 */
+		if (((safi == SAFI_EVPN) || (safi == SAFI_MPLS_VPN))
+		    && !same_attr) {
+			if ((pi->attr->flag
+			     & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))
+			    && (attr_new->flag
+				& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+				int cmp;
+
+				cmp = ecommunity_cmp(
+					bgp_attr_get_ecommunity(pi->attr),
+					bgp_attr_get_ecommunity(attr_new));
+				if (!cmp) {
+					if (bgp_debug_update(peer, p, NULL, 1))
+						zlog_debug(
+							"Change in EXT-COMM, existing %s new %s",
+							ecommunity_str(
+								bgp_attr_get_ecommunity(
+									pi->attr)),
+							ecommunity_str(
+								bgp_attr_get_ecommunity(
+									attr_new)));
+					if (safi == SAFI_EVPN)
+						bgp_evpn_unimport_route(
+							bgp, afi, safi, p, pi);
+					else /* SAFI_MPLS_VPN */
+						vpn_leak_to_vrf_withdraw(pi);
+				}
+			}
+		}
+
+		/* Update to new attribute.  */
+		bgp_attr_unintern(&pi->attr);
+		pi->attr = attr_new;
+
+		/* Update MPLS label */
+		if (has_valid_label) {
+			extra = bgp_path_info_extra_get(pi);
+			if (extra->label != label) {
+				memcpy(&extra->label, label,
+				       num_labels * sizeof(mpls_label_t));
+				extra->num_labels = num_labels;
+			}
+			if (!(afi == AFI_L2VPN && safi == SAFI_EVPN))
+				bgp_set_valid_label(&extra->label[0]);
+		}
+
+#ifdef ENABLE_BGP_VNC
+		if ((afi == AFI_IP || afi == AFI_IP6)
+		    && (safi == SAFI_UNICAST)) {
+			if (vnc_implicit_withdraw) {
+				/*
+				 * Add back the route with its new attributes
+				 * (e.g., nexthop).
+				 * The route is still selected, until the route
+				 * selection
+				 * queued by bgp_process actually runs. We have
+				 * to make this
+				 * update to the VNC side immediately to avoid
+				 * racing against
+				 * configuration changes (e.g., route-map
+				 * changes) which
+				 * trigger re-importation of the entire RIB.
+				 */
+				vnc_import_bgp_add_route(bgp, p, pi);
+				vnc_import_bgp_exterior_add_route(bgp, p, pi);
+			}
+		}
+#endif
+
+		/* Update bgp route dampening information.  */
+		if (CHECK_FLAG(bgp->af_flags[afi][safi], BGP_CONFIG_DAMPENING)
+		    && peer->sort == BGP_PEER_EBGP) {
+			/* Now we do normal update dampening.  */
+			ret = bgp_damp_update(pi, dest, afi, safi);
+			if (ret == BGP_DAMP_SUPPRESSED) {
+				bgp_dest_unlock_node(dest);
+				return;
+			}
+		}
+
+		/* Nexthop reachability check - for unicast and
+		 * labeled-unicast.. */
+		if (((afi == AFI_IP || afi == AFI_IP6) &&
+		     (safi == SAFI_UNICAST || safi == SAFI_LABELED_UNICAST ||
+		      (safi == SAFI_MPLS_VPN &&
+		       pi->sub_type != BGP_ROUTE_IMPORTED))) ||
+		    (safi == SAFI_EVPN &&
+		     bgp_evpn_is_prefix_nht_supported(p))) {
+			if (safi != SAFI_EVPN && peer->sort == BGP_PEER_EBGP
+			    && peer->ttl == BGP_DEFAULT_TTL
+			    && !CHECK_FLAG(peer->flags,
+					   PEER_FLAG_DISABLE_CONNECTED_CHECK)
+			    && !CHECK_FLAG(bgp->flags,
+					   BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
+				connected = 1;
+			else
+				connected = 0;
+
+			struct bgp *bgp_nexthop = bgp;
+
+			if (pi->extra && pi->extra->vrfleak &&
+			    pi->extra->vrfleak->bgp_orig)
+				bgp_nexthop = pi->extra->vrfleak->bgp_orig;
+
+			nh_afi = BGP_ATTR_NH_AFI(afi, pi->attr);
+
+			if (bgp_find_or_add_nexthop(bgp, bgp_nexthop, nh_afi,
+						    safi, pi, NULL, connected,
+						    bgp_nht_param_prefix) ||
+			    CHECK_FLAG(peer->flags, PEER_FLAG_IS_RFAPI_HD)) {
+				if (accept_own)
+					bgp_path_info_set_flag(
+						dest, pi, BGP_PATH_ACCEPT_OWN);
+
+				bgp_path_info_set_flag(dest, pi,
+						       BGP_PATH_VALID);
+			} else {
+				if (BGP_DEBUG(nht, NHT)) {
+					zlog_debug("%s(%pI4): NH unresolved",
+						   __func__,
+						   (in_addr_t *)&attr_new->nexthop);
+				}
+				bgp_path_info_unset_flag(dest, pi,
+							 BGP_PATH_VALID);
+			}
+		} else {
+			/* case mpls-vpn routes with accept-own community
+			 * (which have the BGP_ROUTE_IMPORTED subtype)
+			 * case other afi/safi not supporting nexthop tracking
+			 */
+			if (accept_own)
+				bgp_path_info_set_flag(dest, pi,
+						       BGP_PATH_ACCEPT_OWN);
+			bgp_path_info_set_flag(dest, pi, BGP_PATH_VALID);
+		}
+
+#ifdef ENABLE_BGP_VNC
+		if (safi == SAFI_MPLS_VPN) {
+			struct bgp_dest *pdest = NULL;
+			struct bgp_table *table = NULL;
+
+			pdest = bgp_node_get(bgp->rib[afi][safi],
+					     (struct prefix *)prd);
+			if (bgp_dest_has_bgp_path_info_data(pdest)) {
+				table = bgp_dest_get_bgp_table_info(pdest);
+
+				vnc_import_bgp_add_vnc_host_route_mode_resolve_nve(
+					bgp, prd, table, p, pi);
+			}
+			bgp_dest_unlock_node(pdest);
+		}
+#endif
+
+		/* If this is an EVPN route and some attribute has changed,
+		 * or we are explicitly told to perform a route import, process
+		 * route for import. If the extended community has changed, we
+		 * would
+		 * have done the un-import earlier and the import would result
+		 * in the
+		 * route getting injected into appropriate L2 VNIs. If it is
+		 * just
+		 * some other attribute change, the import will result in
+		 * updating
+		 * the attributes for the route in the VNI(s).
+		 */
+		if (safi == SAFI_EVPN &&
+		    (!same_attr || force_evpn_import) &&
+		    CHECK_FLAG(pi->flags, BGP_PATH_VALID))
+			bgp_evpn_import_route(bgp, afi, safi, p, pi);
+
+		/* Process change. */
+		bgp_aggregate_increment(bgp, p, pi, afi, safi);
+
+		bgp_process(bgp, dest, afi, safi);
+		bgp_dest_unlock_node(dest);
+
+		if (SAFI_UNICAST == safi
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
+			|| bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+			vpn_leak_from_vrf_update(bgp_get_default(), bgp, pi);
+		}
+		if ((SAFI_MPLS_VPN == safi)
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+			vpn_leak_to_vrf_update(bgp, pi, prd);
+		}
+
+#ifdef ENABLE_BGP_VNC
+		if (SAFI_MPLS_VPN == safi) {
+			mpls_label_t label_decoded = decode_label(label);
+
+			rfapiProcessUpdate(peer, NULL, p, prd, attr, afi, safi,
+					   type, sub_type, &label_decoded);
+		}
+		if (SAFI_ENCAP == safi) {
+			rfapiProcessUpdate(peer, NULL, p, prd, attr, afi, safi,
+					   type, sub_type, NULL);
+		}
+#endif
+		return;
+	} // End of implicit withdraw
+
+	/* Received Logging. */
+	if (bgp_debug_update(peer, p, NULL, 1)) {
+		if (!peer->rcvd_attr_printed) {
+			zlog_debug("%pBP rcvd UPDATE w/ attr: %s", peer,
+				   peer->rcvd_attr_str);
+			peer->rcvd_attr_printed = 1;
+		}
+
+		bgp_debug_rdpfxpath2str(afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, evpn,
+					pfx_buf, sizeof(pfx_buf));
+		zlog_debug("%pBP rcvd %s", peer, pfx_buf);
+	}
+
+	/* Make new BGP info. */
+	new = info_make(type, sub_type, 0, peer, attr_new, dest);
+
+	/* Update MPLS label */
+	if (has_valid_label) {
+		extra = bgp_path_info_extra_get(new);
+		if (extra->label != label) {
+			memcpy(&extra->label, label,
+			       num_labels * sizeof(mpls_label_t));
+			extra->num_labels = num_labels;
+		}
+		if (!(afi == AFI_L2VPN && safi == SAFI_EVPN))
+			bgp_set_valid_label(&extra->label[0]);
+	}
+
+	/* Nexthop reachability check. */
+	if (((afi == AFI_IP || afi == AFI_IP6) &&
+	     (safi == SAFI_UNICAST || safi == SAFI_LABELED_UNICAST ||
+	      (safi == SAFI_MPLS_VPN &&
+	       new->sub_type != BGP_ROUTE_IMPORTED))) ||
+	    (safi == SAFI_EVPN && bgp_evpn_is_prefix_nht_supported(p))) {
+		if (safi != SAFI_EVPN && peer->sort == BGP_PEER_EBGP
+		    && peer->ttl == BGP_DEFAULT_TTL
+		    && !CHECK_FLAG(peer->flags,
+				   PEER_FLAG_DISABLE_CONNECTED_CHECK)
+		    && !CHECK_FLAG(bgp->flags,
+				   BGP_FLAG_DISABLE_NH_CONNECTED_CHK))
+			connected = 1;
+		else
+			connected = 0;
+
+		nh_afi = BGP_ATTR_NH_AFI(afi, new->attr);
+
+		if (bgp_find_or_add_nexthop(bgp, bgp, nh_afi, safi, new, NULL,
+					    connected, bgp_nht_param_prefix) ||
+		    CHECK_FLAG(peer->flags, PEER_FLAG_IS_RFAPI_HD)) {
+			if (accept_own)
+				bgp_path_info_set_flag(dest, new,
+						       BGP_PATH_ACCEPT_OWN);
+
+			bgp_path_info_set_flag(dest, new, BGP_PATH_VALID);
+		} else {
+			if (BGP_DEBUG(nht, NHT))
+				zlog_debug("%s(%pI4): NH unresolved", __func__,
+					   &attr_new->nexthop);
+			bgp_path_info_unset_flag(dest, new, BGP_PATH_VALID);
+		}
+	} else {
+		/* case mpls-vpn routes with accept-own community
+		 * (which have the BGP_ROUTE_IMPORTED subtype)
+		 * case other afi/safi not supporting nexthop tracking
+		 */
+		if (accept_own)
+			bgp_path_info_set_flag(dest, new, BGP_PATH_ACCEPT_OWN);
+		bgp_path_info_set_flag(dest, new, BGP_PATH_VALID);
+	}
+
+	/* If maximum prefix count is configured and current prefix
+	 * count exeed it.
+	 */
+	if (bgp_maximum_prefix_overflow(peer, afi, safi, 0)) {
+		reason = "maximum-prefix overflow";
+		bgp_attr_flush(&new_attr);
+		goto filtered;
+	}
+
+	/* Addpath ID */
+	new->addpath_rx_id = addpath_id;
+
+	/* Increment prefix */
+	bgp_aggregate_increment(bgp, p, new, afi, safi);
+
+	/* Register new BGP information. */
+	bgp_path_info_add(dest, new);
+
+	/* route_node_get lock */
+	bgp_dest_unlock_node(dest);
+
+#ifdef ENABLE_BGP_VNC
+	if (safi == SAFI_MPLS_VPN) {
+		struct bgp_dest *pdest = NULL;
+		struct bgp_table *table = NULL;
+
+		pdest = bgp_node_get(bgp->rib[afi][safi], (struct prefix *)prd);
+		if (bgp_dest_has_bgp_path_info_data(pdest)) {
+			table = bgp_dest_get_bgp_table_info(pdest);
+
+			vnc_import_bgp_add_vnc_host_route_mode_resolve_nve(
+				bgp, prd, table, p, new);
+		}
+		bgp_dest_unlock_node(pdest);
+	}
+#endif
+
+	/* If this is an EVPN route, process for import. */
+	if (safi == SAFI_EVPN && CHECK_FLAG(new->flags, BGP_PATH_VALID))
+		bgp_evpn_import_route(bgp, afi, safi, p, new);
+
+	hook_call(bgp_process, bgp, afi, safi, dest, peer, false);
+
+	/* Process change. */
+	bgp_process(bgp, dest, afi, safi);
+
+	if (SAFI_UNICAST == safi
+	    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
+		|| bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+		vpn_leak_from_vrf_update(bgp_get_default(), bgp, new);
+	}
+	if ((SAFI_MPLS_VPN == safi)
+	    && (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+		vpn_leak_to_vrf_update(bgp, new, prd);
+	}
+#ifdef ENABLE_BGP_VNC
+	if (SAFI_MPLS_VPN == safi) {
+		mpls_label_t label_decoded = decode_label(label);
+
+		rfapiProcessUpdate(peer, NULL, p, prd, attr, afi, safi, type,
+				   sub_type, &label_decoded);
+	}
+	if (SAFI_ENCAP == safi) {
+		rfapiProcessUpdate(peer, NULL, p, prd, attr, afi, safi, type,
+				   sub_type, NULL);
+	}
+#endif
+
+	return;
+
+/* This BGP update is filtered.  Log the reason then update BGP
+   entry.  */
+filtered:
+	if (new) {
+		bgp_unlink_nexthop(new);
+		bgp_path_info_delete(dest, new);
+		bgp_path_info_extra_free(&new->extra);
+		XFREE(MTYPE_BGP_ROUTE, new);
+	}
+
+	hook_call(bgp_process, bgp, afi, safi, dest, peer, true);
+
+	if (bgp_debug_update(peer, p, NULL, 1)) {
+		if (!peer->rcvd_attr_printed) {
+			zlog_debug("%pBP rcvd UPDATE w/ attr: %s", peer,
+				   peer->rcvd_attr_str);
+			peer->rcvd_attr_printed = 1;
+		}
+
+		bgp_debug_rdpfxpath2str(afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, evpn,
+					pfx_buf, sizeof(pfx_buf));
+		zlog_debug("%pBP rcvd UPDATE about %s -- DENIED due to: %s",
+			   peer, pfx_buf, reason);
+	}
+
+	if (pi) {
+		/* If this is an EVPN route, un-import it as it is now filtered.
+		 */
+		if (safi == SAFI_EVPN)
+			bgp_evpn_unimport_route(bgp, afi, safi, p, pi);
+
+		if (SAFI_UNICAST == safi
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
+			|| bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+			vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp, pi);
+		}
+		if ((SAFI_MPLS_VPN == safi)
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+			vpn_leak_to_vrf_withdraw(pi);
+		}
+
+		bgp_rib_remove(dest, pi, peer, afi, safi);
+	}
+
+	bgp_dest_unlock_node(dest);
+
+#ifdef ENABLE_BGP_VNC
+	/*
+	 * Filtered update is treated as an implicit withdrawal (see
+	 * bgp_rib_remove()
+	 * a few lines above)
+	 */
+	if ((SAFI_MPLS_VPN == safi) || (SAFI_ENCAP == safi)) {
+		rfapiProcessWithdraw(peer, NULL, p, prd, NULL, afi, safi, type,
+				     0);
+	}
+#endif
+
+	return;
+}
+
+void bgp_withdraw(struct peer *peer, const struct prefix *p,
+		  uint32_t addpath_id, afi_t afi, safi_t safi, int type,
+		  int sub_type, struct prefix_rd *prd, mpls_label_t *label,
+		  uint32_t num_labels, struct bgp_route_evpn *evpn)
+{
+	struct bgp *bgp;
+	char pfx_buf[BGP_PRD_PATH_STRLEN];
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+
+#ifdef ENABLE_BGP_VNC
+	if ((SAFI_MPLS_VPN == safi) || (SAFI_ENCAP == safi)) {
+		rfapiProcessWithdraw(peer, NULL, p, prd, NULL, afi, safi, type,
+				     0);
+	}
+#endif
+
+	bgp = peer->bgp;
+
+	/* Lookup node. */
+	dest = bgp_afi_node_get(bgp->rib[afi][safi], afi, safi, p, prd);
+
+	/* If peer is soft reconfiguration enabled.  Record input packet for
+	 * further calculation.
+	 *
+	 * Cisco IOS 12.4(24)T4 on session establishment sends withdraws for all
+	 * routes that are filtered.  This tanks out Quagga RS pretty badly due
+	 * to
+	 * the iteration over all RS clients.
+	 * Since we need to remove the entry from adj_in anyway, do that first
+	 * and
+	 * if there was no entry, we don't need to do anything more.
+	 */
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG)
+	    && peer != bgp->peer_self)
+		if (!bgp_adj_in_unset(&dest, peer, addpath_id)) {
+			assert(dest);
+			peer->stat_pfx_dup_withdraw++;
+
+			if (bgp_debug_update(peer, p, NULL, 1)) {
+				bgp_debug_rdpfxpath2str(
+					afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, NULL,
+					pfx_buf, sizeof(pfx_buf));
+				zlog_debug(
+					"%s withdrawing route %s not in adj-in",
+					peer->host, pfx_buf);
+			}
+			bgp_dest_unlock_node(dest);
+			return;
+		}
+
+	/* Lookup withdrawn route. */
+	assert(dest);
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == peer && pi->type == type
+		    && pi->sub_type == sub_type
+		    && pi->addpath_rx_id == addpath_id)
+			break;
+
+	/* Logging. */
+	if (bgp_debug_update(peer, p, NULL, 1)) {
+		bgp_debug_rdpfxpath2str(afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, NULL,
+					pfx_buf, sizeof(pfx_buf));
+		zlog_debug("%pBP rcvd UPDATE about %s -- withdrawn", peer,
+			   pfx_buf);
+	}
+
+	/* Withdraw specified route from routing table. */
+	if (pi && !CHECK_FLAG(pi->flags, BGP_PATH_HISTORY)) {
+		bgp_rib_withdraw(dest, pi, peer, afi, safi, prd);
+		if (SAFI_UNICAST == safi
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
+			|| bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+			vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp, pi);
+		}
+		if ((SAFI_MPLS_VPN == safi)
+		    && (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+			vpn_leak_to_vrf_withdraw(pi);
+		}
+	} else if (bgp_debug_update(peer, p, NULL, 1)) {
+		bgp_debug_rdpfxpath2str(afi, safi, prd, p, label, num_labels,
+					addpath_id ? 1 : 0, addpath_id, NULL,
+					pfx_buf, sizeof(pfx_buf));
+		zlog_debug("%s Can't find the route %s", peer->host, pfx_buf);
+	}
+
+	/* Unlock bgp_node_get() lock. */
+	bgp_dest_unlock_node(dest);
+
+	return;
+}
+
+void bgp_default_originate(struct peer *peer, afi_t afi, safi_t safi,
+			   int withdraw)
+{
+	struct update_subgroup *subgrp;
+	subgrp = peer_subgroup(peer, afi, safi);
+	subgroup_default_originate(subgrp, withdraw);
+}
+
+
+/*
+ * bgp_stop_announce_route_timer
+ */
+void bgp_stop_announce_route_timer(struct peer_af *paf)
+{
+	if (!paf->t_announce_route)
+		return;
+
+	EVENT_OFF(paf->t_announce_route);
+}
+
+/*
+ * bgp_announce_route_timer_expired
+ *
+ * Callback that is invoked when the route announcement timer for a
+ * peer_af expires.
+ */
+static void bgp_announce_route_timer_expired(struct event *t)
+{
+	struct peer_af *paf;
+	struct peer *peer;
+
+	paf = EVENT_ARG(t);
+	peer = paf->peer;
+
+	if (!peer_established(peer->connection))
+		return;
+
+	if (!peer->afc_nego[paf->afi][paf->safi])
+		return;
+
+	peer_af_announce_route(paf, 1);
+
+	/* Notify BGP conditional advertisement scanner percess */
+	peer->advmap_config_change[paf->afi][paf->safi] = true;
+}
+
+/*
+ * bgp_announce_route
+ *
+ * *Triggers* announcement of routes of a given AFI/SAFI to a peer.
+ *
+ * if force is true we will force an update even if the update
+ * limiting code is attempted to kick in.
+ */
+void bgp_announce_route(struct peer *peer, afi_t afi, safi_t safi, bool force)
+{
+	struct peer_af *paf;
+	struct update_subgroup *subgrp;
+
+	paf = peer_af_find(peer, afi, safi);
+	if (!paf)
+		return;
+	subgrp = PAF_SUBGRP(paf);
+
+	/*
+	 * Ignore if subgroup doesn't exist (implies AF is not negotiated)
+	 * or a refresh has already been triggered.
+	 */
+	if (!subgrp || paf->t_announce_route)
+		return;
+
+	if (force)
+		SET_FLAG(subgrp->sflags, SUBGRP_STATUS_FORCE_UPDATES);
+
+	/*
+	 * Start a timer to stagger/delay the announce. This serves
+	 * two purposes - announcement can potentially be combined for
+	 * multiple peers and the announcement doesn't happen in the
+	 * vty context.
+	 */
+	event_add_timer_msec(bm->master, bgp_announce_route_timer_expired, paf,
+			     (subgrp->peer_count == 1)
+				     ? BGP_ANNOUNCE_ROUTE_SHORT_DELAY_MS
+				     : BGP_ANNOUNCE_ROUTE_DELAY_MS,
+			     &paf->t_announce_route);
+}
+
+/*
+ * Announce routes from all AF tables to a peer.
+ *
+ * This should ONLY be called when there is a need to refresh the
+ * routes to the peer based on a policy change for this peer alone
+ * or a route refresh request received from the peer.
+ * The operation will result in splitting the peer from its existing
+ * subgroups and putting it in new subgroups.
+ */
+void bgp_announce_route_all(struct peer *peer)
+{
+	afi_t afi;
+	safi_t safi;
+
+	FOREACH_AFI_SAFI (afi, safi)
+		bgp_announce_route(peer, afi, safi, false);
+}
+
+/* Flag or unflag bgp_dest to determine whether it should be treated by
+ * bgp_soft_reconfig_table_task.
+ * Flag if flag is true. Unflag if flag is false.
+ */
+static void bgp_soft_reconfig_table_flag(struct bgp_table *table, bool flag)
+{
+	struct bgp_dest *dest;
+	struct bgp_adj_in *ain;
+
+	if (!table)
+		return;
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		for (ain = dest->adj_in; ain; ain = ain->next) {
+			if (ain->peer != NULL)
+				break;
+		}
+		if (flag && ain != NULL && ain->peer != NULL)
+			SET_FLAG(dest->flags, BGP_NODE_SOFT_RECONFIG);
+		else
+			UNSET_FLAG(dest->flags, BGP_NODE_SOFT_RECONFIG);
+	}
+}
+
+static void bgp_soft_reconfig_table_update(struct peer *peer,
+					   struct bgp_dest *dest,
+					   struct bgp_adj_in *ain, afi_t afi,
+					   safi_t safi, struct prefix_rd *prd)
+{
+	struct bgp_path_info *pi;
+	uint32_t num_labels = 0;
+	mpls_label_t *label_pnt = NULL;
+	struct bgp_route_evpn evpn;
+
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == peer)
+			break;
+
+	if (pi && pi->extra)
+		num_labels = pi->extra->num_labels;
+	if (num_labels)
+		label_pnt = &pi->extra->label[0];
+	if (pi)
+		memcpy(&evpn, bgp_attr_get_evpn_overlay(pi->attr),
+		       sizeof(evpn));
+	else
+		memset(&evpn, 0, sizeof(evpn));
+
+	bgp_update(peer, bgp_dest_get_prefix(dest), ain->addpath_rx_id,
+		   ain->attr, afi, safi, ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, prd,
+		   label_pnt, num_labels, 1, &evpn);
+}
+
+static void bgp_soft_reconfig_table(struct peer *peer, afi_t afi, safi_t safi,
+				    struct bgp_table *table,
+				    struct prefix_rd *prd)
+{
+	struct bgp_dest *dest;
+	struct bgp_adj_in *ain;
+
+	if (!table)
+		table = peer->bgp->rib[afi][safi];
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest))
+		for (ain = dest->adj_in; ain; ain = ain->next) {
+			if (ain->peer != peer)
+				continue;
+
+			bgp_soft_reconfig_table_update(peer, dest, ain, afi,
+						       safi, prd);
+		}
+}
+
+/* Do soft reconfig table per bgp table.
+ * Walk on SOFT_RECONFIG_TASK_MAX_PREFIX bgp_dest,
+ * when BGP_NODE_SOFT_RECONFIG is set,
+ * reconfig bgp_dest for list of table->soft_reconfig_peers peers.
+ * Schedule a new thread to continue the job.
+ * Without splitting the full job into several part,
+ * vtysh waits for the job to finish before responding to a BGP command
+ */
+static void bgp_soft_reconfig_table_task(struct event *thread)
+{
+	uint32_t iter, max_iter;
+	struct bgp_dest *dest;
+	struct bgp_adj_in *ain;
+	struct peer *peer;
+	struct bgp_table *table;
+	struct prefix_rd *prd;
+	struct listnode *node, *nnode;
+
+	table = EVENT_ARG(thread);
+	prd = NULL;
+
+	max_iter = SOFT_RECONFIG_TASK_MAX_PREFIX;
+	if (table->soft_reconfig_init) {
+		/* first call of the function with a new srta structure.
+		 * Don't do any treatment this time on nodes
+		 * in order vtysh to respond quickly
+		 */
+		max_iter = 0;
+	}
+
+	for (iter = 0, dest = bgp_table_top(table); (dest && iter < max_iter);
+	     dest = bgp_route_next(dest)) {
+		if (!CHECK_FLAG(dest->flags, BGP_NODE_SOFT_RECONFIG))
+			continue;
+
+		UNSET_FLAG(dest->flags, BGP_NODE_SOFT_RECONFIG);
+
+		for (ain = dest->adj_in; ain; ain = ain->next) {
+			for (ALL_LIST_ELEMENTS(table->soft_reconfig_peers, node,
+					       nnode, peer)) {
+				if (ain->peer != peer)
+					continue;
+
+				bgp_soft_reconfig_table_update(
+					peer, dest, ain, table->afi,
+					table->safi, prd);
+				iter++;
+			}
+		}
+	}
+
+	/* we're either starting the initial iteration,
+	 * or we're going to continue an ongoing iteration
+	 */
+	if (dest || table->soft_reconfig_init) {
+		table->soft_reconfig_init = false;
+		event_add_event(bm->master, bgp_soft_reconfig_table_task, table,
+				0, &table->soft_reconfig_thread);
+		return;
+	}
+	/* we're done, clean up the background iteration context info and
+	schedule route annoucement
+	*/
+	for (ALL_LIST_ELEMENTS(table->soft_reconfig_peers, node, nnode, peer)) {
+		listnode_delete(table->soft_reconfig_peers, peer);
+		bgp_announce_route(peer, table->afi, table->safi, false);
+	}
+
+	list_delete(&table->soft_reconfig_peers);
+}
+
+
+/* Cancel soft_reconfig_table task matching bgp instance, bgp_table
+ * and peer.
+ * - bgp cannot be NULL
+ * - if table and peer are NULL, cancel all threads within the bgp instance
+ * - if table is NULL and peer is not,
+ * remove peer in all threads within the bgp instance
+ * - if peer is NULL, cancel all threads matching table within the bgp instance
+ */
+void bgp_soft_reconfig_table_task_cancel(const struct bgp *bgp,
+					 const struct bgp_table *table,
+					 const struct peer *peer)
+{
+	struct peer *npeer;
+	struct listnode *node, *nnode;
+	int afi, safi;
+	struct bgp_table *ntable;
+
+	if (!bgp)
+		return;
+
+	FOREACH_AFI_SAFI (afi, safi) {
+		ntable = bgp->rib[afi][safi];
+		if (!ntable)
+			continue;
+		if (table && table != ntable)
+			continue;
+
+		for (ALL_LIST_ELEMENTS(ntable->soft_reconfig_peers, node, nnode,
+				       npeer)) {
+			if (peer && peer != npeer)
+				continue;
+			listnode_delete(ntable->soft_reconfig_peers, npeer);
+		}
+
+		if (!ntable->soft_reconfig_peers
+		    || !list_isempty(ntable->soft_reconfig_peers))
+			continue;
+
+		list_delete(&ntable->soft_reconfig_peers);
+		bgp_soft_reconfig_table_flag(ntable, false);
+		EVENT_OFF(ntable->soft_reconfig_thread);
+	}
+}
+
+/*
+ * Returns false if the peer is not configured for soft reconfig in
+ */
+bool bgp_soft_reconfig_in(struct peer *peer, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	struct listnode *node, *nnode;
+	struct peer *npeer;
+	struct peer_af *paf;
+
+	if (!CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SOFT_RECONFIG))
+		return false;
+
+	if ((safi != SAFI_MPLS_VPN) && (safi != SAFI_ENCAP)
+	    && (safi != SAFI_EVPN)) {
+		table = peer->bgp->rib[afi][safi];
+		if (!table)
+			return true;
+
+		table->soft_reconfig_init = true;
+
+		if (!table->soft_reconfig_peers)
+			table->soft_reconfig_peers = list_new();
+		npeer = NULL;
+		/* add peer to the table soft_reconfig_peers if not already
+		 * there
+		 */
+		for (ALL_LIST_ELEMENTS(table->soft_reconfig_peers, node, nnode,
+				       npeer)) {
+			if (peer == npeer)
+				break;
+		}
+		if (peer != npeer)
+			listnode_add(table->soft_reconfig_peers, peer);
+
+		/* (re)flag all bgp_dest in table. Existing soft_reconfig_in job
+		 * on table would start back at the beginning.
+		 */
+		bgp_soft_reconfig_table_flag(table, true);
+
+		if (!table->soft_reconfig_thread)
+			event_add_event(bm->master,
+					bgp_soft_reconfig_table_task, table, 0,
+					&table->soft_reconfig_thread);
+		/* Cancel bgp_announce_route_timer_expired threads.
+		 * bgp_announce_route_timer_expired threads have been scheduled
+		 * to announce routes as soon as the soft_reconfigure process
+		 * finishes.
+		 * In this case, soft_reconfigure is also scheduled by using
+		 * a thread but is planned after the
+		 * bgp_announce_route_timer_expired threads. It means that,
+		 * without cancelling the threads, the route announcement task
+		 * would run before the soft reconfiguration one. That would
+		 * useless and would block vtysh during several seconds. Route
+		 * announcements are rescheduled as soon as the soft_reconfigure
+		 * process finishes.
+		 */
+		paf = peer_af_find(peer, afi, safi);
+		if (paf)
+			bgp_stop_announce_route_timer(paf);
+	} else
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			table = bgp_dest_get_bgp_table_info(dest);
+
+			if (table == NULL)
+				continue;
+
+			const struct prefix *p = bgp_dest_get_prefix(dest);
+			struct prefix_rd prd;
+
+			prd.family = AF_UNSPEC;
+			prd.prefixlen = 64;
+			memcpy(&prd.val, p->u.val, 8);
+
+			bgp_soft_reconfig_table(peer, afi, safi, table, &prd);
+		}
+
+	return true;
+}
+
+
+struct bgp_clear_node_queue {
+	struct bgp_dest *dest;
+};
+
+static wq_item_status bgp_clear_route_node(struct work_queue *wq, void *data)
+{
+	struct bgp_clear_node_queue *cnq = data;
+	struct bgp_dest *dest = cnq->dest;
+	struct peer *peer = wq->spec.data;
+	struct bgp_path_info *pi;
+	struct bgp *bgp;
+	afi_t afi = bgp_dest_table(dest)->afi;
+	safi_t safi = bgp_dest_table(dest)->safi;
+
+	assert(dest && peer);
+	bgp = peer->bgp;
+
+	/* It is possible that we have multiple paths for a prefix from a peer
+	 * if that peer is using AddPath.
+	 */
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+		if (pi->peer != peer)
+			continue;
+
+		/* graceful restart STALE flag set. */
+		if (((CHECK_FLAG(peer->sflags, PEER_STATUS_NSF_WAIT)
+		      && peer->nsf[afi][safi])
+		     || CHECK_FLAG(peer->af_sflags[afi][safi],
+				   PEER_STATUS_ENHANCED_REFRESH))
+		    && !CHECK_FLAG(pi->flags, BGP_PATH_STALE)
+		    && !CHECK_FLAG(pi->flags, BGP_PATH_UNUSEABLE))
+			bgp_path_info_set_flag(dest, pi, BGP_PATH_STALE);
+		else {
+			/* If this is an EVPN route, process for
+			 * un-import. */
+			if (safi == SAFI_EVPN)
+				bgp_evpn_unimport_route(
+					bgp, afi, safi,
+					bgp_dest_get_prefix(dest), pi);
+			/* Handle withdraw for VRF route-leaking and L3VPN */
+			if (SAFI_UNICAST == safi
+			    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF ||
+				bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+				vpn_leak_from_vrf_withdraw(bgp_get_default(),
+							   bgp, pi);
+			}
+			if (SAFI_MPLS_VPN == safi &&
+			    bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
+				vpn_leak_to_vrf_withdraw(pi);
+			}
+
+			bgp_rib_remove(dest, pi, peer, afi, safi);
+		}
+	}
+	return WQ_SUCCESS;
+}
+
+static void bgp_clear_node_queue_del(struct work_queue *wq, void *data)
+{
+	struct bgp_clear_node_queue *cnq = data;
+	struct bgp_dest *dest = cnq->dest;
+	struct bgp_table *table = bgp_dest_table(dest);
+
+	bgp_dest_unlock_node(dest);
+	bgp_table_unlock(table);
+	XFREE(MTYPE_BGP_CLEAR_NODE_QUEUE, cnq);
+}
+
+static void bgp_clear_node_complete(struct work_queue *wq)
+{
+	struct peer *peer = wq->spec.data;
+
+	/* Tickle FSM to start moving again */
+	BGP_EVENT_ADD(peer->connection, Clearing_Completed);
+
+	peer_unlock(peer); /* bgp_clear_route */
+}
+
+static void bgp_clear_node_queue_init(struct peer *peer)
+{
+	char wname[sizeof("clear xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx")];
+
+	snprintf(wname, sizeof(wname), "clear %s", peer->host);
+#undef CLEAR_QUEUE_NAME_LEN
+
+	peer->clear_node_queue = work_queue_new(bm->master, wname);
+	peer->clear_node_queue->spec.hold = 10;
+	peer->clear_node_queue->spec.workfunc = &bgp_clear_route_node;
+	peer->clear_node_queue->spec.del_item_data = &bgp_clear_node_queue_del;
+	peer->clear_node_queue->spec.completion_func = &bgp_clear_node_complete;
+	peer->clear_node_queue->spec.max_retries = 0;
+
+	/* we only 'lock' this peer reference when the queue is actually active
+	 */
+	peer->clear_node_queue->spec.data = peer;
+}
+
+static void bgp_clear_route_table(struct peer *peer, afi_t afi, safi_t safi,
+				  struct bgp_table *table)
+{
+	struct bgp_dest *dest;
+	int force = peer->bgp->process_queue ? 0 : 1;
+
+	if (!table)
+		table = peer->bgp->rib[afi][safi];
+
+	/* If still no table => afi/safi isn't configured at all or smth. */
+	if (!table)
+		return;
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		struct bgp_path_info *pi, *next;
+		struct bgp_adj_in *ain;
+		struct bgp_adj_in *ain_next;
+
+		/* XXX:TODO: This is suboptimal, every non-empty route_node is
+		 * queued for every clearing peer, regardless of whether it is
+		 * relevant to the peer at hand.
+		 *
+		 * Overview: There are 3 different indices which need to be
+		 * scrubbed, potentially, when a peer is removed:
+		 *
+		 * 1 peer's routes visible via the RIB (ie accepted routes)
+		 * 2 peer's routes visible by the (optional) peer's adj-in index
+		 * 3 other routes visible by the peer's adj-out index
+		 *
+		 * 3 there is no hurry in scrubbing, once the struct peer is
+		 * removed from bgp->peer, we could just GC such deleted peer's
+		 * adj-outs at our leisure.
+		 *
+		 * 1 and 2 must be 'scrubbed' in some way, at least made
+		 * invisible via RIB index before peer session is allowed to be
+		 * brought back up. So one needs to know when such a 'search' is
+		 * complete.
+		 *
+		 * Ideally:
+		 *
+		 * - there'd be a single global queue or a single RIB walker
+		 * - rather than tracking which route_nodes still need to be
+		 *   examined on a peer basis, we'd track which peers still
+		 *   aren't cleared
+		 *
+		 * Given that our per-peer prefix-counts now should be reliable,
+		 * this may actually be achievable. It doesn't seem to be a huge
+		 * problem at this time,
+		 *
+		 * It is possible that we have multiple paths for a prefix from
+		 * a peer
+		 * if that peer is using AddPath.
+		 */
+		ain = dest->adj_in;
+		while (ain) {
+			ain_next = ain->next;
+
+			if (ain->peer == peer)
+				bgp_adj_in_remove(&dest, ain);
+
+			ain = ain_next;
+
+			assert(dest);
+		}
+
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = next) {
+			next = pi->next;
+			if (pi->peer != peer)
+				continue;
+
+			if (force) {
+				dest = bgp_path_info_reap(dest, pi);
+				assert(dest);
+			} else {
+				struct bgp_clear_node_queue *cnq;
+
+				/* both unlocked in bgp_clear_node_queue_del */
+				bgp_table_lock(bgp_dest_table(dest));
+				bgp_dest_lock_node(dest);
+				cnq = XCALLOC(
+					MTYPE_BGP_CLEAR_NODE_QUEUE,
+					sizeof(struct bgp_clear_node_queue));
+				cnq->dest = dest;
+				work_queue_add(peer->clear_node_queue, cnq);
+				break;
+			}
+		}
+	}
+	return;
+}
+
+void bgp_clear_route(struct peer *peer, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+
+	if (peer->clear_node_queue == NULL)
+		bgp_clear_node_queue_init(peer);
+
+	/* bgp_fsm.c keeps sessions in state Clearing, not transitioning to
+	 * Idle until it receives a Clearing_Completed event. This protects
+	 * against peers which flap faster than we can we clear, which could
+	 * lead to:
+	 *
+	 * a) race with routes from the new session being installed before
+	 *    clear_route_node visits the node (to delete the route of that
+	 *    peer)
+	 * b) resource exhaustion, clear_route_node likely leads to an entry
+	 *    on the process_main queue. Fast-flapping could cause that queue
+	 *    to grow and grow.
+	 */
+
+	/* lock peer in assumption that clear-node-queue will get nodes; if so,
+	 * the unlock will happen upon work-queue completion; other wise, the
+	 * unlock happens at the end of this function.
+	 */
+	if (!peer->clear_node_queue->thread)
+		peer_lock(peer);
+
+	if (safi != SAFI_MPLS_VPN && safi != SAFI_ENCAP && safi != SAFI_EVPN)
+		bgp_clear_route_table(peer, afi, safi, NULL);
+	else
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			bgp_clear_route_table(peer, afi, safi, table);
+		}
+
+	/* unlock if no nodes got added to the clear-node-queue. */
+	if (!peer->clear_node_queue->thread)
+		peer_unlock(peer);
+}
+
+void bgp_clear_route_all(struct peer *peer)
+{
+	afi_t afi;
+	safi_t safi;
+
+	FOREACH_AFI_SAFI (afi, safi)
+		bgp_clear_route(peer, afi, safi);
+
+#ifdef ENABLE_BGP_VNC
+	rfapiProcessPeerDown(peer);
+#endif
+}
+
+void bgp_clear_adj_in(struct peer *peer, afi_t afi, safi_t safi)
+{
+	struct bgp_table *table;
+	struct bgp_dest *dest;
+	struct bgp_adj_in *ain;
+	struct bgp_adj_in *ain_next;
+
+	table = peer->bgp->rib[afi][safi];
+
+	/* It is possible that we have multiple paths for a prefix from a peer
+	 * if that peer is using AddPath.
+	 */
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		ain = dest->adj_in;
+
+		while (ain) {
+			ain_next = ain->next;
+
+			if (ain->peer == peer)
+				bgp_adj_in_remove(&dest, ain);
+
+			ain = ain_next;
+
+			assert(dest);
+		}
+	}
+}
+
+/* If any of the routes from the peer have been marked with the NO_LLGR
+ * community, either as sent by the peer, or as the result of a configured
+ * policy, they MUST NOT be retained, but MUST be removed as per the normal
+ * operation of [RFC4271].
+ */
+void bgp_clear_stale_route(struct peer *peer, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct bgp_table *table;
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) {
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			struct bgp_dest *rm;
+
+			/* look for neighbor in tables */
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			for (rm = bgp_table_top(table); rm;
+			     rm = bgp_route_next(rm))
+				for (pi = bgp_dest_get_bgp_path_info(rm); pi;
+				     pi = pi->next) {
+					if (pi->peer != peer)
+						continue;
+					if (CHECK_FLAG(
+						    peer->af_sflags[afi][safi],
+						    PEER_STATUS_LLGR_WAIT) &&
+					    bgp_attr_get_community(pi->attr) &&
+					    !community_include(
+						    bgp_attr_get_community(
+							    pi->attr),
+						    COMMUNITY_NO_LLGR))
+						continue;
+					if (!CHECK_FLAG(pi->flags,
+							BGP_PATH_STALE))
+						continue;
+
+					/*
+					 * If this is VRF leaked route
+					 * process for withdraw.
+					 */
+					if (pi->sub_type ==
+						    BGP_ROUTE_IMPORTED &&
+					    peer->bgp->inst_type ==
+						    BGP_INSTANCE_TYPE_DEFAULT)
+						vpn_leak_to_vrf_withdraw(pi);
+
+					bgp_rib_remove(rm, pi, peer, afi, safi);
+					break;
+				}
+		}
+	} else {
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest))
+			for (pi = bgp_dest_get_bgp_path_info(dest); pi;
+			     pi = pi->next) {
+				if (pi->peer != peer)
+					continue;
+				if (CHECK_FLAG(peer->af_sflags[afi][safi],
+					       PEER_STATUS_LLGR_WAIT) &&
+				    bgp_attr_get_community(pi->attr) &&
+				    !community_include(
+					    bgp_attr_get_community(pi->attr),
+					    COMMUNITY_NO_LLGR))
+					continue;
+				if (!CHECK_FLAG(pi->flags, BGP_PATH_STALE))
+					continue;
+				if (safi == SAFI_UNICAST &&
+				    (peer->bgp->inst_type ==
+					     BGP_INSTANCE_TYPE_VRF ||
+				     peer->bgp->inst_type ==
+					     BGP_INSTANCE_TYPE_DEFAULT))
+					vpn_leak_from_vrf_withdraw(
+						bgp_get_default(), peer->bgp,
+						pi);
+
+				bgp_rib_remove(dest, pi, peer, afi, safi);
+				break;
+			}
+	}
+}
+
+void bgp_set_stale_route(struct peer *peer, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest, *ndest;
+	struct bgp_path_info *pi;
+	struct bgp_table *table;
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) {
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			for (ndest = bgp_table_top(table); ndest;
+			     ndest = bgp_route_next(ndest)) {
+				for (pi = bgp_dest_get_bgp_path_info(ndest); pi;
+				     pi = pi->next) {
+					if (pi->peer != peer)
+						continue;
+
+					if ((CHECK_FLAG(
+						    peer->af_sflags[afi][safi],
+						    PEER_STATUS_ENHANCED_REFRESH))
+					    && !CHECK_FLAG(pi->flags,
+							   BGP_PATH_STALE)
+					    && !CHECK_FLAG(
+						       pi->flags,
+						       BGP_PATH_UNUSEABLE)) {
+						if (bgp_debug_neighbor_events(
+							    peer))
+							zlog_debug(
+								"%pBP route-refresh for %s/%s, marking prefix %pFX as stale",
+								peer,
+								afi2str(afi),
+								safi2str(safi),
+								bgp_dest_get_prefix(
+									ndest));
+
+						bgp_path_info_set_flag(
+							ndest, pi,
+							BGP_PATH_STALE);
+					}
+				}
+			}
+		}
+	} else {
+		for (dest = bgp_table_top(peer->bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			for (pi = bgp_dest_get_bgp_path_info(dest); pi;
+			     pi = pi->next) {
+				if (pi->peer != peer)
+					continue;
+
+				if ((CHECK_FLAG(peer->af_sflags[afi][safi],
+						PEER_STATUS_ENHANCED_REFRESH))
+				    && !CHECK_FLAG(pi->flags, BGP_PATH_STALE)
+				    && !CHECK_FLAG(pi->flags,
+						   BGP_PATH_UNUSEABLE)) {
+					if (bgp_debug_neighbor_events(peer))
+						zlog_debug(
+							"%pBP route-refresh for %s/%s, marking prefix %pFX as stale",
+							peer, afi2str(afi),
+							safi2str(safi),
+							bgp_dest_get_prefix(
+								dest));
+
+					bgp_path_info_set_flag(dest, pi,
+							       BGP_PATH_STALE);
+				}
+			}
+		}
+	}
+}
+
+bool bgp_outbound_policy_exists(struct peer *peer, struct bgp_filter *filter)
+{
+	if (peer->sort == BGP_PEER_IBGP)
+		return true;
+
+	if (peer->sort == BGP_PEER_EBGP
+	    && (ROUTE_MAP_OUT_NAME(filter) || PREFIX_LIST_OUT_NAME(filter)
+		|| FILTER_LIST_OUT_NAME(filter)
+		|| DISTRIBUTE_OUT_NAME(filter)))
+		return true;
+	return false;
+}
+
+bool bgp_inbound_policy_exists(struct peer *peer, struct bgp_filter *filter)
+{
+	if (peer->sort == BGP_PEER_IBGP)
+		return true;
+
+	if (peer->sort == BGP_PEER_EBGP
+	    && (ROUTE_MAP_IN_NAME(filter) || PREFIX_LIST_IN_NAME(filter)
+		|| FILTER_LIST_IN_NAME(filter)
+		|| DISTRIBUTE_IN_NAME(filter)))
+		return true;
+	return false;
+}
+
+static void bgp_cleanup_table(struct bgp *bgp, struct bgp_table *table,
+			      safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct bgp_path_info *next;
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest))
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = next) {
+			const struct prefix *p = bgp_dest_get_prefix(dest);
+
+			next = pi->next;
+
+			/* Unimport EVPN routes from VRFs */
+			if (safi == SAFI_EVPN)
+				bgp_evpn_unimport_route(bgp, AFI_L2VPN,
+							SAFI_EVPN, p, pi);
+
+			if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)
+			    && pi->type == ZEBRA_ROUTE_BGP
+			    && (pi->sub_type == BGP_ROUTE_NORMAL
+				|| pi->sub_type == BGP_ROUTE_AGGREGATE
+				|| pi->sub_type == BGP_ROUTE_IMPORTED)) {
+
+				if (bgp_fibupd_safi(safi))
+					bgp_zebra_withdraw(p, pi, bgp, safi);
+			}
+
+			dest = bgp_path_info_reap(dest, pi);
+			assert(dest);
+		}
+}
+
+/* Delete all kernel routes. */
+void bgp_cleanup_routes(struct bgp *bgp)
+{
+	afi_t afi;
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+
+	for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
+		if (afi == AFI_L2VPN)
+			continue;
+		bgp_cleanup_table(bgp, bgp->rib[afi][SAFI_UNICAST],
+				  SAFI_UNICAST);
+		/*
+		 * VPN and ENCAP and EVPN tables are two-level (RD is top level)
+		 */
+		if (afi != AFI_L2VPN) {
+			safi_t safi;
+			safi = SAFI_MPLS_VPN;
+			for (dest = bgp_table_top(bgp->rib[afi][safi]); dest;
+			     dest = bgp_route_next(dest)) {
+				table = bgp_dest_get_bgp_table_info(dest);
+				if (table != NULL) {
+					bgp_cleanup_table(bgp, table, safi);
+					bgp_table_finish(&table);
+					bgp_dest_set_bgp_table_info(dest, NULL);
+					dest = bgp_dest_unlock_node(dest);
+
+					assert(dest);
+				}
+			}
+			safi = SAFI_ENCAP;
+			for (dest = bgp_table_top(bgp->rib[afi][safi]); dest;
+			     dest = bgp_route_next(dest)) {
+				table = bgp_dest_get_bgp_table_info(dest);
+				if (table != NULL) {
+					bgp_cleanup_table(bgp, table, safi);
+					bgp_table_finish(&table);
+					bgp_dest_set_bgp_table_info(dest, NULL);
+					dest = bgp_dest_unlock_node(dest);
+
+					assert(dest);
+				}
+			}
+		}
+	}
+	for (dest = bgp_table_top(bgp->rib[AFI_L2VPN][SAFI_EVPN]); dest;
+	     dest = bgp_route_next(dest)) {
+		table = bgp_dest_get_bgp_table_info(dest);
+		if (table != NULL) {
+			bgp_cleanup_table(bgp, table, SAFI_EVPN);
+			bgp_table_finish(&table);
+			bgp_dest_set_bgp_table_info(dest, NULL);
+			dest = bgp_dest_unlock_node(dest);
+
+			assert(dest);
+		}
+	}
+}
+
+void bgp_reset(void)
+{
+	vty_reset();
+	bgp_zclient_reset();
+	access_list_reset();
+	prefix_list_reset();
+}
+
+bool bgp_addpath_encode_rx(struct peer *peer, afi_t afi, safi_t safi)
+{
+	return (CHECK_FLAG(peer->af_cap[afi][safi], PEER_CAP_ADDPATH_AF_RX_ADV)
+		&& CHECK_FLAG(peer->af_cap[afi][safi],
+			      PEER_CAP_ADDPATH_AF_TX_RCV));
+}
+
+/* Parse NLRI stream.  Withdraw NLRI is recognized by NULL attr
+   value. */
+int bgp_nlri_parse_ip(struct peer *peer, struct attr *attr,
+		      struct bgp_nlri *packet)
+{
+	uint8_t *pnt;
+	uint8_t *lim;
+	struct prefix p;
+	int psize;
+	afi_t afi;
+	safi_t safi;
+	bool addpath_capable;
+	uint32_t addpath_id;
+
+	pnt = packet->nlri;
+	lim = pnt + packet->length;
+	afi = packet->afi;
+	safi = packet->safi;
+	addpath_id = 0;
+	addpath_capable = bgp_addpath_encode_rx(peer, afi, safi);
+
+	/* RFC4271 6.3 The NLRI field in the UPDATE message is checked for
+	   syntactic validity.  If the field is syntactically incorrect,
+	   then the Error Subcode is set to Invalid Network Field. */
+	for (; pnt < lim; pnt += psize) {
+		/* Clear prefix structure. */
+		memset(&p, 0, sizeof(p));
+
+		if (addpath_capable) {
+
+			/* When packet overflow occurs return immediately. */
+			if (pnt + BGP_ADDPATH_ID_LEN >= lim)
+				return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW;
+
+			memcpy(&addpath_id, pnt, BGP_ADDPATH_ID_LEN);
+			addpath_id = ntohl(addpath_id);
+			pnt += BGP_ADDPATH_ID_LEN;
+		}
+
+		/* Fetch prefix length. */
+		p.prefixlen = *pnt++;
+		/* afi/safi validity already verified by caller,
+		 * bgp_update_receive */
+		p.family = afi2family(afi);
+
+		/* Prefix length check. */
+		if (p.prefixlen > prefix_blen(&p) * 8) {
+			flog_err(
+				EC_BGP_UPDATE_RCV,
+				"%s [Error] Update packet error (wrong prefix length %d for afi %u)",
+				peer->host, p.prefixlen, packet->afi);
+			return BGP_NLRI_PARSE_ERROR_PREFIX_LENGTH;
+		}
+
+		/* Packet size overflow check. */
+		psize = PSIZE(p.prefixlen);
+
+		/* When packet overflow occur return immediately. */
+		if (pnt + psize > lim) {
+			flog_err(
+				EC_BGP_UPDATE_RCV,
+				"%s [Error] Update packet error (prefix length %d overflows packet)",
+				peer->host, p.prefixlen);
+			return BGP_NLRI_PARSE_ERROR_PACKET_OVERFLOW;
+		}
+
+		/* Defensive coding, double-check the psize fits in a struct
+		 * prefix for the v4 and v6 afi's and unicast/multicast */
+		if (psize > (ssize_t)sizeof(p.u.val)) {
+			flog_err(
+				EC_BGP_UPDATE_RCV,
+				"%s [Error] Update packet error (prefix length %d too large for prefix storage %zu)",
+				peer->host, p.prefixlen, sizeof(p.u.val));
+			return BGP_NLRI_PARSE_ERROR_PACKET_LENGTH;
+		}
+
+		/* Fetch prefix from NLRI packet. */
+		memcpy(p.u.val, pnt, psize);
+
+		/* Check address. */
+		if (afi == AFI_IP && safi == SAFI_UNICAST) {
+			if (IN_CLASSD(ntohl(p.u.prefix4.s_addr))) {
+				/* From RFC4271 Section 6.3:
+				 *
+				 * If a prefix in the NLRI field is semantically
+				 * incorrect
+				 * (e.g., an unexpected multicast IP address),
+				 * an error SHOULD
+				 * be logged locally, and the prefix SHOULD be
+				 * ignored.
+				 */
+				flog_err(
+					EC_BGP_UPDATE_RCV,
+					"%s: IPv4 unicast NLRI is multicast address %pI4, ignoring",
+					peer->host, &p.u.prefix4);
+				continue;
+			}
+		}
+
+		/* Check address. */
+		if (afi == AFI_IP6 && safi == SAFI_UNICAST) {
+			if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)) {
+				flog_err(
+					EC_BGP_UPDATE_RCV,
+					"%s: IPv6 unicast NLRI is link-local address %pI6, ignoring",
+					peer->host, &p.u.prefix6);
+
+				continue;
+			}
+			if (IN6_IS_ADDR_MULTICAST(&p.u.prefix6)) {
+				flog_err(
+					EC_BGP_UPDATE_RCV,
+					"%s: IPv6 unicast NLRI is multicast address %pI6, ignoring",
+					peer->host, &p.u.prefix6);
+
+				continue;
+			}
+		}
+
+		/* Normal process. */
+		if (attr)
+			bgp_update(peer, &p, addpath_id, attr, afi, safi,
+				   ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, NULL,
+				   NULL, 0, 0, NULL);
+		else
+			bgp_withdraw(peer, &p, addpath_id, afi, safi,
+				     ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL, NULL,
+				     NULL, 0, NULL);
+
+		/* Do not send BGP notification twice when maximum-prefix count
+		 * overflow. */
+		if (CHECK_FLAG(peer->sflags, PEER_STATUS_PREFIX_OVERFLOW))
+			return BGP_NLRI_PARSE_ERROR_PREFIX_OVERFLOW;
+	}
+
+	/* Packet length consistency check. */
+	if (pnt != lim) {
+		flog_err(
+			EC_BGP_UPDATE_RCV,
+			"%s [Error] Update packet error (prefix length mismatch with total length)",
+			peer->host);
+		return BGP_NLRI_PARSE_ERROR_PACKET_LENGTH;
+	}
+
+	return BGP_NLRI_PARSE_OK;
+}
+
+static void bgp_nexthop_reachability_check(afi_t afi, safi_t safi,
+					   struct bgp_path_info *bpi,
+					   const struct prefix *p,
+					   struct bgp_dest *dest,
+					   struct bgp *bgp)
+{
+	/* Nexthop reachability check. */
+	if (safi == SAFI_UNICAST || safi == SAFI_LABELED_UNICAST) {
+		if (CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK)) {
+			if (bgp_find_or_add_nexthop(bgp, bgp, afi, safi, bpi,
+						    NULL, 0, p))
+				bgp_path_info_set_flag(dest, bpi,
+						       BGP_PATH_VALID);
+			else {
+				if (BGP_DEBUG(nht, NHT)) {
+					char buf1[INET6_ADDRSTRLEN];
+
+					inet_ntop(p->family, &p->u.prefix, buf1,
+						  sizeof(buf1));
+					zlog_debug("%s(%s): Route not in table, not advertising",
+						   __func__, buf1);
+				}
+				bgp_path_info_unset_flag(dest, bpi,
+							 BGP_PATH_VALID);
+			}
+		} else {
+			/* Delete the NHT structure if any, if we're toggling between
+			* enabling/disabling import check. We deregister the route
+			* from NHT to avoid overloading NHT and the process interaction
+			*/
+			bgp_unlink_nexthop(bpi);
+
+			bgp_path_info_set_flag(dest, bpi, BGP_PATH_VALID);
+		}
+	}
+}
+
+static struct bgp_static *bgp_static_new(void)
+{
+	return XCALLOC(MTYPE_BGP_STATIC, sizeof(struct bgp_static));
+}
+
+static void bgp_static_free(struct bgp_static *bgp_static)
+{
+	XFREE(MTYPE_ROUTE_MAP_NAME, bgp_static->rmap.name);
+	route_map_counter_decrement(bgp_static->rmap.map);
+
+	if (bgp_static->prd_pretty)
+		XFREE(MTYPE_BGP, bgp_static->prd_pretty);
+	XFREE(MTYPE_ATTR, bgp_static->eth_s_id);
+	XFREE(MTYPE_BGP_STATIC, bgp_static);
+}
+
+void bgp_static_update(struct bgp *bgp, const struct prefix *p,
+		       struct bgp_static *bgp_static, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct bgp_path_info *new;
+	struct bgp_path_info rmap_path;
+	struct attr attr;
+	struct attr *attr_new;
+	route_map_result_t ret;
+#ifdef ENABLE_BGP_VNC
+	int vnc_implicit_withdraw = 0;
+	mpls_label_t label = 0;
+#endif
+	uint32_t num_labels = 0;
+
+	assert(bgp_static);
+
+	if ((safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) &&
+	    bgp_static->label != MPLS_INVALID_LABEL)
+		num_labels = 1;
+
+	dest = bgp_afi_node_get(bgp->rib[afi][safi], afi, safi, p,
+				&bgp_static->prd);
+
+	bgp_attr_default_set(&attr, bgp, BGP_ORIGIN_IGP);
+
+	attr.nexthop = bgp_static->igpnexthop;
+	attr.med = bgp_static->igpmetric;
+	attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC);
+
+	if (afi == AFI_IP)
+		attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
+
+	if (bgp_static->igpmetric)
+		bgp_attr_set_aigp_metric(&attr, bgp_static->igpmetric);
+
+	if (bgp_static->atomic)
+		attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE);
+
+	/* Store label index, if required. */
+	if (bgp_static->label_index != BGP_INVALID_LABEL_INDEX) {
+		attr.label_index = bgp_static->label_index;
+		attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID);
+	}
+
+	if (safi == SAFI_EVPN || safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP) {
+		if (afi == AFI_IP) {
+			attr.mp_nexthop_global_in = bgp_static->igpnexthop;
+			attr.mp_nexthop_len = IPV4_MAX_BYTELEN;
+		}
+	}
+
+	if (afi == AFI_L2VPN) {
+		if (bgp_static->gatewayIp.family == AF_INET) {
+			SET_IPADDR_V4(&attr.evpn_overlay.gw_ip);
+			memcpy(&attr.evpn_overlay.gw_ip.ipaddr_v4,
+			       &bgp_static->gatewayIp.u.prefix4,
+			       IPV4_MAX_BYTELEN);
+		} else if (bgp_static->gatewayIp.family == AF_INET6) {
+			SET_IPADDR_V6(&attr.evpn_overlay.gw_ip);
+			memcpy(&attr.evpn_overlay.gw_ip.ipaddr_v6,
+			       &bgp_static->gatewayIp.u.prefix6,
+			       IPV6_MAX_BYTELEN);
+		}
+		memcpy(&attr.esi, bgp_static->eth_s_id, sizeof(esi_t));
+		if (bgp_static->encap_tunneltype == BGP_ENCAP_TYPE_VXLAN) {
+			struct bgp_encap_type_vxlan bet;
+			memset(&bet, 0, sizeof(bet));
+			bet.vnid = p->u.prefix_evpn.prefix_addr.eth_tag;
+			bgp_encap_type_vxlan_to_tlv(&bet, &attr);
+		}
+		if (bgp_static->router_mac) {
+			bgp_add_routermac_ecom(&attr, bgp_static->router_mac);
+		}
+	}
+
+	/* Apply route-map. */
+	if (bgp_static->rmap.name) {
+		struct attr attr_tmp = attr;
+
+		memset(&rmap_path, 0, sizeof(rmap_path));
+		rmap_path.peer = bgp->peer_self;
+		rmap_path.attr = &attr_tmp;
+
+		SET_FLAG(bgp->peer_self->rmap_type, PEER_RMAP_TYPE_NETWORK);
+
+		ret = route_map_apply(bgp_static->rmap.map, p, &rmap_path);
+
+		bgp->peer_self->rmap_type = 0;
+
+		if (ret == RMAP_DENYMATCH) {
+			/* Free uninterned attribute. */
+			bgp_attr_flush(&attr_tmp);
+
+			/* Unintern original. */
+			aspath_unintern(&attr.aspath);
+			bgp_static_withdraw(bgp, p, afi, safi, &bgp_static->prd);
+			bgp_dest_unlock_node(dest);
+			return;
+		}
+
+		if (bgp_in_graceful_shutdown(bgp))
+			bgp_attr_add_gshut_community(&attr_tmp);
+
+		attr_new = bgp_attr_intern(&attr_tmp);
+	} else {
+
+		if (bgp_in_graceful_shutdown(bgp))
+			bgp_attr_add_gshut_community(&attr);
+
+		attr_new = bgp_attr_intern(&attr);
+	}
+
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == bgp->peer_self && pi->type == ZEBRA_ROUTE_BGP
+		    && pi->sub_type == BGP_ROUTE_STATIC)
+			break;
+
+	if (pi) {
+		if (attrhash_cmp(pi->attr, attr_new)
+		    && !CHECK_FLAG(pi->flags, BGP_PATH_REMOVED)
+		    && !CHECK_FLAG(bgp->flags, BGP_FLAG_FORCE_STATIC_PROCESS)) {
+			bgp_dest_unlock_node(dest);
+			bgp_attr_unintern(&attr_new);
+			aspath_unintern(&attr.aspath);
+			return;
+		} else {
+			/* The attribute is changed. */
+			bgp_path_info_set_flag(dest, pi, BGP_PATH_ATTR_CHANGED);
+
+			/* Rewrite BGP route information. */
+			if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED))
+				bgp_path_info_restore(dest, pi);
+			else
+				bgp_aggregate_decrement(bgp, p, pi, afi, safi);
+#ifdef ENABLE_BGP_VNC
+			if ((afi == AFI_IP || afi == AFI_IP6) &&
+			    safi == SAFI_UNICAST) {
+				if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)) {
+					/*
+					 * Implicit withdraw case.
+					 * We have to do this before pi is
+					 * changed
+					 */
+					++vnc_implicit_withdraw;
+					vnc_import_bgp_del_route(bgp, p, pi);
+					vnc_import_bgp_exterior_del_route(
+						bgp, p, pi);
+				}
+			}
+#endif
+			bgp_attr_unintern(&pi->attr);
+			pi->attr = attr_new;
+			pi->uptime = monotime(NULL);
+#ifdef ENABLE_BGP_VNC
+			if ((afi == AFI_IP || afi == AFI_IP6) &&
+			    safi == SAFI_UNICAST) {
+				if (vnc_implicit_withdraw) {
+					vnc_import_bgp_add_route(bgp, p, pi);
+					vnc_import_bgp_exterior_add_route(
+						bgp, p, pi);
+				}
+			} else {
+				if (pi->extra)
+					label = decode_label(
+						&pi->extra->label[0]);
+			}
+#endif
+
+			bgp_nexthop_reachability_check(afi, safi, pi, p, dest,
+						       bgp);
+
+			/* Process change. */
+			bgp_aggregate_increment(bgp, p, pi, afi, safi);
+			bgp_process(bgp, dest, afi, safi);
+
+			if (SAFI_MPLS_VPN == safi &&
+			    bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
+				vpn_leak_to_vrf_update(bgp, pi,
+						       &bgp_static->prd);
+			}
+#ifdef ENABLE_BGP_VNC
+			if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP ||
+			    safi == SAFI_EVPN)
+				rfapiProcessUpdate(pi->peer, NULL, p,
+						   &bgp_static->prd, pi->attr,
+						   afi, safi, pi->type,
+						   pi->sub_type, &label);
+#endif
+
+			if (SAFI_UNICAST == safi
+			    && (bgp->inst_type == BGP_INSTANCE_TYPE_VRF
+				|| bgp->inst_type
+					   == BGP_INSTANCE_TYPE_DEFAULT)) {
+				vpn_leak_from_vrf_update(bgp_get_default(), bgp,
+							 pi);
+			}
+
+			bgp_dest_unlock_node(dest);
+			aspath_unintern(&attr.aspath);
+			return;
+		}
+	}
+
+	/* Make new BGP info. */
+	new = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0, bgp->peer_self,
+			attr_new, dest);
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) {
+		SET_FLAG(new->flags, BGP_PATH_VALID);
+		bgp_path_info_extra_get(new);
+		if (num_labels) {
+			new->extra->label[0] = bgp_static->label;
+			new->extra->num_labels = num_labels;
+		}
+#ifdef ENABLE_BGP_VNC
+		label = decode_label(&bgp_static->label);
+#endif
+	}
+
+	bgp_nexthop_reachability_check(afi, safi, new, p, dest, bgp);
+
+	/* Aggregate address increment. */
+	bgp_aggregate_increment(bgp, p, new, afi, safi);
+
+	/* Register new BGP information. */
+	bgp_path_info_add(dest, new);
+
+	/* route_node_get lock */
+	bgp_dest_unlock_node(dest);
+
+	/* Process change. */
+	bgp_process(bgp, dest, afi, safi);
+
+	if (SAFI_UNICAST == safi &&
+	    (bgp->inst_type == BGP_INSTANCE_TYPE_VRF ||
+	     bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+		vpn_leak_from_vrf_update(bgp_get_default(), bgp, new);
+	}
+
+	if (SAFI_MPLS_VPN == safi &&
+	    bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
+		vpn_leak_to_vrf_update(bgp, new, &bgp_static->prd);
+	}
+#ifdef ENABLE_BGP_VNC
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN)
+		rfapiProcessUpdate(new->peer, NULL, p, &bgp_static->prd,
+				   new->attr, afi, safi, new->type,
+				   new->sub_type, &label);
+#endif
+
+	/* Unintern original. */
+	aspath_unintern(&attr.aspath);
+}
+
+void bgp_static_withdraw(struct bgp *bgp, const struct prefix *p, afi_t afi,
+			 safi_t safi, struct prefix_rd *prd)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+
+	dest = bgp_afi_node_get(bgp->rib[afi][safi], afi, safi, p, prd);
+
+	/* Check selected route and self inserted route. */
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == bgp->peer_self && pi->type == ZEBRA_ROUTE_BGP
+		    && pi->sub_type == BGP_ROUTE_STATIC)
+			break;
+
+	/* Withdraw static BGP route from routing table. */
+	if (pi) {
+#ifdef ENABLE_BGP_VNC
+		if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP)
+			rfapiProcessWithdraw(pi->peer, NULL, p, prd, pi->attr,
+					     afi, safi, pi->type,
+					     1); /* Kill, since it is an administrative change */
+#endif
+		if (SAFI_UNICAST == safi &&
+		    (bgp->inst_type == BGP_INSTANCE_TYPE_VRF ||
+		     bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+			vpn_leak_from_vrf_withdraw(bgp_get_default(), bgp, pi);
+		}
+		if (SAFI_MPLS_VPN == safi
+		    && bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT) {
+			vpn_leak_to_vrf_withdraw(pi);
+		}
+		bgp_aggregate_decrement(bgp, p, pi, afi, safi);
+		bgp_unlink_nexthop(pi);
+		bgp_path_info_delete(dest, pi);
+		bgp_process(bgp, dest, afi, safi);
+	}
+
+	/* Unlock bgp_node_lookup. */
+	bgp_dest_unlock_node(dest);
+}
+
+/* Configure static BGP network.  When user don't run zebra, static
+   route should be installed as valid.  */
+int bgp_static_set(struct vty *vty, bool negate, const char *ip_str,
+		   const char *rd_str, const char *label_str, afi_t afi,
+		   safi_t safi, const char *rmap, int backdoor,
+		   uint32_t label_index, int evpn_type, const char *esi,
+		   const char *gwip, const char *ethtag, const char *routermac)
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	int ret;
+	struct prefix p;
+	struct bgp_static *bgp_static;
+	struct prefix_rd prd = {};
+	struct bgp_dest *pdest;
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	uint8_t need_update = 0;
+	mpls_label_t label = MPLS_INVALID_LABEL;
+	struct prefix gw_ip;
+
+	/* Convert IP prefix string to struct prefix. */
+	ret = str2prefix(ip_str, &p);
+	if (!ret) {
+		vty_out(vty, "%% Malformed prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+	if (afi == AFI_IP6 && IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)) {
+		vty_out(vty, "%% Malformed prefix (link-local address)\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	apply_mask(&p);
+
+	if (afi == AFI_L2VPN &&
+	    (bgp_build_evpn_prefix(evpn_type, ethtag != NULL ? atol(ethtag) : 0,
+				   &p))) {
+		vty_out(vty, "%% L2VPN prefix could not be forged\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_EVPN) {
+		ret = str2prefix_rd(rd_str, &prd);
+		if (!ret) {
+			vty_out(vty, "%% Malformed rd\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+
+		if (label_str) {
+			unsigned long label_val;
+
+			label_val = strtoul(label_str, NULL, 10);
+			encode_label(label_val, &label);
+		}
+	}
+
+	if (safi == SAFI_EVPN) {
+		if (esi && str2esi(esi, NULL) == 0) {
+			vty_out(vty, "%% Malformed ESI\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+		if (routermac && prefix_str2mac(routermac, NULL) == 0) {
+			vty_out(vty, "%% Malformed Router MAC\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+		if (gwip) {
+			memset(&gw_ip, 0, sizeof(gw_ip));
+			ret = str2prefix(gwip, &gw_ip);
+			if (!ret) {
+				vty_out(vty, "%% Malformed GatewayIp\n");
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+			if ((gw_ip.family == AF_INET &&
+			     is_evpn_prefix_ipaddr_v6((struct prefix_evpn *)&p)) ||
+			    (gw_ip.family == AF_INET6 &&
+			     is_evpn_prefix_ipaddr_v4(
+				     (struct prefix_evpn *)&p))) {
+				vty_out(vty,
+					"%% GatewayIp family differs with IP prefix\n");
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+		}
+	}
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_EVPN) {
+		pdest = bgp_node_get(bgp->route[afi][safi],
+				     (struct prefix *)&prd);
+		if (!bgp_dest_has_bgp_path_info_data(pdest))
+			bgp_dest_set_bgp_table_info(pdest,
+						    bgp_table_init(bgp, afi,
+								   safi));
+		table = bgp_dest_get_bgp_table_info(pdest);
+	} else {
+		table = bgp->route[afi][safi];
+	}
+
+	if (negate) {
+		/* Set BGP static route configuration. */
+		dest = bgp_node_lookup(bgp->route[afi][safi], &p);
+
+		if (!dest) {
+			vty_out(vty, "%% Can't find static route specified\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+
+		bgp_static = bgp_dest_get_bgp_static_info(dest);
+		if (bgp_static) {
+			if ((label_index != BGP_INVALID_LABEL_INDEX) &&
+			    (label_index != bgp_static->label_index)) {
+				vty_out(vty,
+					"%% label-index doesn't match static route\n");
+				bgp_dest_unlock_node(dest);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+
+			if ((rmap && bgp_static->rmap.name) &&
+			    strcmp(rmap, bgp_static->rmap.name)) {
+				vty_out(vty,
+					"%% route-map name doesn't match static route\n");
+				bgp_dest_unlock_node(dest);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+
+			/* Update BGP RIB. */
+			if (!bgp_static->backdoor)
+				bgp_static_withdraw(bgp, &p, afi, safi, NULL);
+
+			/* Clear configuration. */
+			bgp_static_free(bgp_static);
+		}
+
+		bgp_dest_set_bgp_static_info(dest, NULL);
+		dest = bgp_dest_unlock_node(dest);
+		assert(dest);
+		bgp_dest_unlock_node(dest);
+	} else {
+		dest = bgp_node_get(table, &p);
+
+		bgp_static = bgp_dest_get_bgp_static_info(dest);
+		if (bgp_static) {
+			/* Configuration change. */
+			/* Label index cannot be changed. */
+			if (bgp_static->label_index != label_index) {
+				vty_out(vty, "%% cannot change label-index\n");
+				bgp_dest_unlock_node(dest);
+				return CMD_WARNING_CONFIG_FAILED;
+			}
+
+			/* Check previous routes are installed into BGP.  */
+			if (bgp_static->valid
+			    && bgp_static->backdoor != backdoor)
+				need_update = 1;
+
+			bgp_static->backdoor = backdoor;
+
+			if (rmap) {
+				XFREE(MTYPE_ROUTE_MAP_NAME,
+				      bgp_static->rmap.name);
+				route_map_counter_decrement(
+					bgp_static->rmap.map);
+				bgp_static->rmap.name =
+					XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
+				bgp_static->rmap.map =
+					route_map_lookup_by_name(rmap);
+				route_map_counter_increment(
+					bgp_static->rmap.map);
+			} else {
+				XFREE(MTYPE_ROUTE_MAP_NAME,
+				      bgp_static->rmap.name);
+				route_map_counter_decrement(
+					bgp_static->rmap.map);
+				bgp_static->rmap.map = NULL;
+				bgp_static->valid = 0;
+			}
+			bgp_dest_unlock_node(dest);
+		} else {
+			/* New configuration. */
+			bgp_static = bgp_static_new();
+			bgp_static->backdoor = backdoor;
+			bgp_static->valid = 0;
+			bgp_static->igpmetric = 0;
+			bgp_static->igpnexthop.s_addr = INADDR_ANY;
+			bgp_static->label_index = label_index;
+			bgp_static->label = label;
+			bgp_static->prd = prd;
+
+			if (rmap) {
+				XFREE(MTYPE_ROUTE_MAP_NAME,
+				      bgp_static->rmap.name);
+				route_map_counter_decrement(
+					bgp_static->rmap.map);
+				bgp_static->rmap.name =
+					XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
+				bgp_static->rmap.map =
+					route_map_lookup_by_name(rmap);
+				route_map_counter_increment(
+					bgp_static->rmap.map);
+			}
+
+			if (safi == SAFI_EVPN) {
+				if (esi) {
+					bgp_static->eth_s_id =
+						XCALLOC(MTYPE_ATTR,
+							sizeof(esi_t));
+					str2esi(esi, bgp_static->eth_s_id);
+				}
+				if (routermac) {
+					bgp_static->router_mac =
+						XCALLOC(MTYPE_ATTR,
+							ETH_ALEN + 1);
+					(void)prefix_str2mac(routermac,
+							     bgp_static->router_mac);
+				}
+				if (gwip)
+					prefix_copy(&bgp_static->gatewayIp,
+						    &gw_ip);
+			}
+
+			bgp_dest_set_bgp_static_info(dest, bgp_static);
+		}
+
+		bgp_static->valid = 1;
+		if (need_update)
+			bgp_static_withdraw(bgp, &p, afi, safi, NULL);
+
+		if (!bgp_static->backdoor)
+			bgp_static_update(bgp, &p, bgp_static, afi, safi);
+	}
+
+	return CMD_SUCCESS;
+}
+
+void bgp_static_add(struct bgp *bgp)
+{
+	afi_t afi;
+	safi_t safi;
+	struct bgp_dest *dest;
+	struct bgp_dest *rm;
+	struct bgp_table *table;
+	struct bgp_static *bgp_static;
+
+	SET_FLAG(bgp->flags, BGP_FLAG_FORCE_STATIC_PROCESS);
+	FOREACH_AFI_SAFI (afi, safi)
+		for (dest = bgp_table_top(bgp->route[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			if (!bgp_dest_has_bgp_path_info_data(dest))
+				continue;
+
+			if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+			    || (safi == SAFI_EVPN)) {
+				table = bgp_dest_get_bgp_table_info(dest);
+
+				for (rm = bgp_table_top(table); rm;
+				     rm = bgp_route_next(rm)) {
+					bgp_static =
+						bgp_dest_get_bgp_static_info(
+							rm);
+					bgp_static_update(bgp,
+							  bgp_dest_get_prefix(rm),
+							  bgp_static, afi, safi);
+				}
+			} else {
+				bgp_static_update(
+					bgp, bgp_dest_get_prefix(dest),
+					bgp_dest_get_bgp_static_info(dest), afi,
+					safi);
+			}
+		}
+	UNSET_FLAG(bgp->flags, BGP_FLAG_FORCE_STATIC_PROCESS);
+}
+
+/* Called from bgp_delete().  Delete all static routes from the BGP
+   instance. */
+void bgp_static_delete(struct bgp *bgp)
+{
+	afi_t afi;
+	safi_t safi;
+	struct bgp_dest *dest;
+	struct bgp_dest *rm;
+	struct bgp_table *table;
+	struct bgp_static *bgp_static;
+
+	FOREACH_AFI_SAFI (afi, safi)
+		for (dest = bgp_table_top(bgp->route[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			if (!bgp_dest_has_bgp_path_info_data(dest))
+				continue;
+
+			if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+			    || (safi == SAFI_EVPN)) {
+				table = bgp_dest_get_bgp_table_info(dest);
+
+				for (rm = bgp_table_top(table); rm;
+				     rm = bgp_route_next(rm)) {
+					bgp_static =
+						bgp_dest_get_bgp_static_info(
+							rm);
+					if (!bgp_static)
+						continue;
+
+					bgp_static_withdraw(bgp,
+							    bgp_dest_get_prefix(
+								    rm),
+							    AFI_IP, safi,
+							    (struct prefix_rd *)
+								    bgp_dest_get_prefix(
+									    dest));
+					bgp_static_free(bgp_static);
+					bgp_dest_set_bgp_static_info(rm,
+								     NULL);
+					rm = bgp_dest_unlock_node(rm);
+					assert(rm);
+				}
+			} else {
+				bgp_static = bgp_dest_get_bgp_static_info(dest);
+				bgp_static_withdraw(bgp,
+						    bgp_dest_get_prefix(dest),
+						    afi, safi, NULL);
+				bgp_static_free(bgp_static);
+				bgp_dest_set_bgp_static_info(dest, NULL);
+				dest = bgp_dest_unlock_node(dest);
+				assert(dest);
+			}
+		}
+}
+
+void bgp_static_redo_import_check(struct bgp *bgp)
+{
+	afi_t afi;
+	safi_t safi;
+	struct bgp_dest *dest;
+	struct bgp_dest *rm;
+	struct bgp_table *table;
+	struct bgp_static *bgp_static;
+
+	/* Use this flag to force reprocessing of the route */
+	SET_FLAG(bgp->flags, BGP_FLAG_FORCE_STATIC_PROCESS);
+	FOREACH_AFI_SAFI (afi, safi) {
+		for (dest = bgp_table_top(bgp->route[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			if (!bgp_dest_has_bgp_path_info_data(dest))
+				continue;
+
+			if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+			    || (safi == SAFI_EVPN)) {
+				table = bgp_dest_get_bgp_table_info(dest);
+
+				for (rm = bgp_table_top(table); rm;
+				     rm = bgp_route_next(rm)) {
+					bgp_static =
+						bgp_dest_get_bgp_static_info(
+							rm);
+					bgp_static_update(bgp,
+							  bgp_dest_get_prefix(rm),
+							  bgp_static, afi, safi);
+				}
+			} else {
+				bgp_static = bgp_dest_get_bgp_static_info(dest);
+				bgp_static_update(bgp,
+						  bgp_dest_get_prefix(dest),
+						  bgp_static, afi, safi);
+			}
+		}
+	}
+	UNSET_FLAG(bgp->flags, BGP_FLAG_FORCE_STATIC_PROCESS);
+}
+
+static void bgp_purge_af_static_redist_routes(struct bgp *bgp, afi_t afi,
+					      safi_t safi)
+{
+	struct bgp_table *table;
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+
+	/* Do not install the aggregate route if BGP is in the
+	 * process of termination.
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS)
+	    || (bgp->peer_self == NULL))
+		return;
+
+	table = bgp->rib[afi][safi];
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+			if (pi->peer == bgp->peer_self
+			    && ((pi->type == ZEBRA_ROUTE_BGP
+				 && pi->sub_type == BGP_ROUTE_STATIC)
+				|| (pi->type != ZEBRA_ROUTE_BGP
+				    && pi->sub_type
+					       == BGP_ROUTE_REDISTRIBUTE))) {
+				bgp_aggregate_decrement(
+					bgp, bgp_dest_get_prefix(dest), pi, afi,
+					safi);
+				bgp_unlink_nexthop(pi);
+				bgp_path_info_delete(dest, pi);
+				bgp_process(bgp, dest, afi, safi);
+			}
+		}
+	}
+}
+
+/*
+ * Purge all networks and redistributed routes from routing table.
+ * Invoked upon the instance going down.
+ */
+void bgp_purge_static_redist_routes(struct bgp *bgp)
+{
+	afi_t afi;
+	safi_t safi;
+
+	FOREACH_AFI_SAFI (afi, safi)
+		bgp_purge_af_static_redist_routes(bgp, afi, safi);
+}
+
+static int bgp_table_map_set(struct vty *vty, afi_t afi, safi_t safi,
+			     const char *rmap_name)
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	struct bgp_rmap *rmap;
+
+	rmap = &bgp->table_map[afi][safi];
+	if (rmap_name) {
+		XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
+		route_map_counter_decrement(rmap->map);
+		rmap->name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap_name);
+		rmap->map = route_map_lookup_by_name(rmap_name);
+		route_map_counter_increment(rmap->map);
+	} else {
+		XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
+		route_map_counter_decrement(rmap->map);
+		rmap->map = NULL;
+	}
+
+	if (bgp_fibupd_safi(safi))
+		bgp_zebra_announce_table(bgp, afi, safi);
+
+	return CMD_SUCCESS;
+}
+
+static int bgp_table_map_unset(struct vty *vty, afi_t afi, safi_t safi,
+			       const char *rmap_name)
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	struct bgp_rmap *rmap;
+
+	rmap = &bgp->table_map[afi][safi];
+	XFREE(MTYPE_ROUTE_MAP_NAME, rmap->name);
+	route_map_counter_decrement(rmap->map);
+	rmap->map = NULL;
+
+	if (bgp_fibupd_safi(safi))
+		bgp_zebra_announce_table(bgp, afi, safi);
+
+	return CMD_SUCCESS;
+}
+
+void bgp_config_write_table_map(struct vty *vty, struct bgp *bgp, afi_t afi,
+				safi_t safi)
+{
+	if (bgp->table_map[afi][safi].name) {
+		vty_out(vty, "  table-map %s\n",
+			bgp->table_map[afi][safi].name);
+	}
+}
+
+DEFUN (bgp_table_map,
+       bgp_table_map_cmd,
+       "table-map WORD",
+       "BGP table to RIB route download filter\n"
+       "Name of the route map\n")
+{
+	int idx_word = 1;
+	return bgp_table_map_set(vty, bgp_node_afi(vty), bgp_node_safi(vty),
+				 argv[idx_word]->arg);
+}
+DEFUN (no_bgp_table_map,
+       no_bgp_table_map_cmd,
+       "no table-map WORD",
+       NO_STR
+       "BGP table to RIB route download filter\n"
+       "Name of the route map\n")
+{
+	int idx_word = 2;
+	return bgp_table_map_unset(vty, bgp_node_afi(vty), bgp_node_safi(vty),
+				   argv[idx_word]->arg);
+}
+
+DEFPY(bgp_network,
+	bgp_network_cmd,
+	"[no] network \
+	<A.B.C.D/M$prefix|A.B.C.D$address [mask A.B.C.D$netmask]> \
+	[{route-map RMAP_NAME$map_name|label-index (0-1048560)$label_index| \
+	backdoor$backdoor}]",
+	NO_STR
+	"Specify a network to announce via BGP\n"
+	"IPv4 prefix\n"
+	"Network number\n"
+	"Network mask\n"
+	"Network mask\n"
+	"Route-map to modify the attributes\n"
+	"Name of the route map\n"
+	"Label index to associate with the prefix\n"
+	"Label index value\n"
+	"Specify a BGP backdoor route\n")
+{
+	char addr_prefix_str[BUFSIZ];
+
+	if (address_str) {
+		int ret;
+
+		ret = netmask_str2prefix_str(address_str, netmask_str,
+					     addr_prefix_str,
+					     sizeof(addr_prefix_str));
+		if (!ret) {
+			vty_out(vty, "%% Inconsistent address and mask\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+	}
+
+	return bgp_static_set(vty, no,
+			      address_str ? addr_prefix_str : prefix_str, NULL,
+			      NULL, AFI_IP, bgp_node_safi(vty), map_name,
+			      backdoor ? 1 : 0,
+			      label_index ? (uint32_t)label_index
+					  : BGP_INVALID_LABEL_INDEX,
+			      0, NULL, NULL, NULL, NULL);
+}
+
+DEFPY(ipv6_bgp_network,
+	ipv6_bgp_network_cmd,
+	"[no] network X:X::X:X/M$prefix \
+	[{route-map RMAP_NAME$map_name|label-index (0-1048560)$label_index}]",
+	NO_STR
+	"Specify a network to announce via BGP\n"
+	"IPv6 prefix\n"
+	"Route-map to modify the attributes\n"
+	"Name of the route map\n"
+	"Label index to associate with the prefix\n"
+	"Label index value\n")
+{
+	return bgp_static_set(vty, no, prefix_str, NULL, NULL, AFI_IP6,
+			      bgp_node_safi(vty), map_name, 0,
+			      label_index ? (uint32_t)label_index
+					  : BGP_INVALID_LABEL_INDEX,
+			      0, NULL, NULL, NULL, NULL);
+}
+
+static struct bgp_aggregate *bgp_aggregate_new(void)
+{
+	return XCALLOC(MTYPE_BGP_AGGREGATE, sizeof(struct bgp_aggregate));
+}
+
+void bgp_aggregate_free(struct bgp_aggregate *aggregate)
+{
+	XFREE(MTYPE_ROUTE_MAP_NAME, aggregate->suppress_map_name);
+	route_map_counter_decrement(aggregate->suppress_map);
+	XFREE(MTYPE_ROUTE_MAP_NAME, aggregate->rmap.name);
+	route_map_counter_decrement(aggregate->rmap.map);
+	XFREE(MTYPE_BGP_AGGREGATE, aggregate);
+}
+
+/**
+ * Helper function to avoid repeated code: prepare variables for a
+ * `route_map_apply` call.
+ *
+ * \returns `true` on route map match, otherwise `false`.
+ */
+static bool aggr_suppress_map_test(struct bgp *bgp,
+				   struct bgp_aggregate *aggregate,
+				   struct bgp_path_info *pi)
+{
+	const struct prefix *p = bgp_dest_get_prefix(pi->net);
+	route_map_result_t rmr = RMAP_DENYMATCH;
+	struct bgp_path_info rmap_path = {};
+	struct attr attr = {};
+
+	/* No route map entries created, just don't match. */
+	if (aggregate->suppress_map == NULL)
+		return false;
+
+	/* Call route map matching and return result. */
+	attr.aspath = aspath_empty(bgp->asnotation);
+	rmap_path.peer = bgp->peer_self;
+	rmap_path.attr = &attr;
+
+	SET_FLAG(bgp->peer_self->rmap_type, PEER_RMAP_TYPE_AGGREGATE);
+	rmr = route_map_apply(aggregate->suppress_map, p, &rmap_path);
+	bgp->peer_self->rmap_type = 0;
+
+	bgp_attr_flush(&attr);
+	aspath_unintern(&attr.aspath);
+
+	return rmr == RMAP_PERMITMATCH;
+}
+
+/** Test whether the aggregation has suppressed this path or not. */
+static bool aggr_suppress_exists(struct bgp_aggregate *aggregate,
+				 struct bgp_path_info *pi)
+{
+	if (pi->extra == NULL || pi->extra->aggr_suppressors == NULL)
+		return false;
+
+	return listnode_lookup(pi->extra->aggr_suppressors, aggregate) != NULL;
+}
+
+/**
+ * Suppress this path and keep the reference.
+ *
+ * \returns `true` if needs processing otherwise `false`.
+ */
+static bool aggr_suppress_path(struct bgp_aggregate *aggregate,
+			       struct bgp_path_info *pi)
+{
+	struct bgp_path_info_extra *pie;
+
+	/* Path is already suppressed by this aggregation. */
+	if (aggr_suppress_exists(aggregate, pi))
+		return false;
+
+	pie = bgp_path_info_extra_get(pi);
+
+	/* This is the first suppression, allocate memory and list it. */
+	if (pie->aggr_suppressors == NULL)
+		pie->aggr_suppressors = list_new();
+
+	listnode_add(pie->aggr_suppressors, aggregate);
+
+	/* Only mark for processing if suppressed. */
+	if (listcount(pie->aggr_suppressors) == 1) {
+		if (BGP_DEBUG(update, UPDATE_OUT))
+			zlog_debug("aggregate-address suppressing: %pFX",
+				   bgp_dest_get_prefix(pi->net));
+
+		bgp_path_info_set_flag(pi->net, pi, BGP_PATH_ATTR_CHANGED);
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Unsuppress this path and remove the reference.
+ *
+ * \returns `true` if needs processing otherwise `false`.
+ */
+static bool aggr_unsuppress_path(struct bgp_aggregate *aggregate,
+				 struct bgp_path_info *pi)
+{
+	/* Path wasn't suppressed. */
+	if (!aggr_suppress_exists(aggregate, pi))
+		return false;
+
+	listnode_delete(pi->extra->aggr_suppressors, aggregate);
+
+	/* Unsuppress and free extra memory if last item. */
+	if (listcount(pi->extra->aggr_suppressors) == 0) {
+		if (BGP_DEBUG(update, UPDATE_OUT))
+			zlog_debug("aggregate-address unsuppressing: %pFX",
+				   bgp_dest_get_prefix(pi->net));
+
+		list_delete(&pi->extra->aggr_suppressors);
+		bgp_path_info_set_flag(pi->net, pi, BGP_PATH_ATTR_CHANGED);
+		return true;
+	}
+
+	return false;
+}
+
+static bool bgp_aggregate_info_same(struct bgp_path_info *pi, uint8_t origin,
+				    struct aspath *aspath,
+				    struct community *comm,
+				    struct ecommunity *ecomm,
+				    struct lcommunity *lcomm)
+{
+	static struct aspath *ae = NULL;
+	enum asnotation_mode asnotation;
+
+	asnotation = bgp_get_asnotation(NULL);
+
+	if (!aspath)
+		ae = aspath_empty(asnotation);
+
+	if (!pi)
+		return false;
+
+	if (origin != pi->attr->origin)
+		return false;
+
+	if (!aspath_cmp(pi->attr->aspath, (aspath) ? aspath : ae))
+		return false;
+
+	if (!community_cmp(bgp_attr_get_community(pi->attr), comm))
+		return false;
+
+	if (!ecommunity_cmp(bgp_attr_get_ecommunity(pi->attr), ecomm))
+		return false;
+
+	if (!lcommunity_cmp(bgp_attr_get_lcommunity(pi->attr), lcomm))
+		return false;
+
+	if (!CHECK_FLAG(pi->flags, BGP_PATH_VALID))
+		return false;
+
+	return true;
+}
+
+static void bgp_aggregate_install(
+	struct bgp *bgp, afi_t afi, safi_t safi, const struct prefix *p,
+	uint8_t origin, struct aspath *aspath, struct community *community,
+	struct ecommunity *ecommunity, struct lcommunity *lcommunity,
+	uint8_t atomic_aggregate, struct bgp_aggregate *aggregate)
+{
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	struct bgp_path_info *pi, *orig, *new;
+	struct attr *attr;
+
+	table = bgp->rib[afi][safi];
+
+	dest = bgp_node_get(table, p);
+
+	for (orig = pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+		if (pi->peer == bgp->peer_self && pi->type == ZEBRA_ROUTE_BGP
+		    && pi->sub_type == BGP_ROUTE_AGGREGATE)
+			break;
+
+	/*
+	 * If we have paths with different MEDs, then don't install
+	 * (or uninstall) the aggregate route.
+	 */
+	if (aggregate->match_med && aggregate->med_mismatched)
+		goto uninstall_aggregate_route;
+
+	if (aggregate->count > 0) {
+		/*
+		 * If the aggregate information has not changed
+		 * no need to re-install it again.
+		 */
+		if (pi && bgp_aggregate_info_same(pi, origin, aspath, community,
+						  ecommunity, lcommunity)) {
+			bgp_dest_unlock_node(dest);
+
+			if (aspath)
+				aspath_free(aspath);
+			if (community)
+				community_free(&community);
+			if (ecommunity)
+				ecommunity_free(&ecommunity);
+			if (lcommunity)
+				lcommunity_free(&lcommunity);
+
+			return;
+		}
+
+		/*
+		 * Mark the old as unusable
+		 */
+		if (pi)
+			bgp_path_info_delete(dest, pi);
+
+		attr = bgp_attr_aggregate_intern(
+			bgp, origin, aspath, community, ecommunity, lcommunity,
+			aggregate, atomic_aggregate, p);
+
+		if (!attr) {
+			aspath_free(aspath);
+			community_free(&community);
+			ecommunity_free(&ecommunity);
+			lcommunity_free(&lcommunity);
+			bgp_dest_unlock_node(dest);
+			bgp_aggregate_delete(bgp, p, afi, safi, aggregate);
+			if (BGP_DEBUG(update_groups, UPDATE_GROUPS))
+				zlog_debug("%s: %pFX null attribute", __func__,
+					   p);
+			return;
+		}
+
+		new = info_make(ZEBRA_ROUTE_BGP, BGP_ROUTE_AGGREGATE, 0,
+				bgp->peer_self, attr, dest);
+
+		SET_FLAG(new->flags, BGP_PATH_VALID);
+
+		bgp_path_info_add(dest, new);
+		bgp_process(bgp, dest, afi, safi);
+	} else {
+	uninstall_aggregate_route:
+		for (pi = orig; pi; pi = pi->next)
+			if (pi->peer == bgp->peer_self
+			    && pi->type == ZEBRA_ROUTE_BGP
+			    && pi->sub_type == BGP_ROUTE_AGGREGATE)
+				break;
+
+		/* Withdraw static BGP route from routing table. */
+		if (pi) {
+			bgp_path_info_delete(dest, pi);
+			bgp_process(bgp, dest, afi, safi);
+		}
+	}
+
+	bgp_dest_unlock_node(dest);
+}
+
+/**
+ * Check if the current path has different MED than other known paths.
+ *
+ * \returns `true` if the MED matched the others else `false`.
+ */
+static bool bgp_aggregate_med_match(struct bgp_aggregate *aggregate,
+				    struct bgp *bgp, struct bgp_path_info *pi)
+{
+	uint32_t cur_med = bgp_med_value(pi->attr, bgp);
+
+	/* This is the first route being analyzed. */
+	if (!aggregate->med_initialized) {
+		aggregate->med_initialized = true;
+		aggregate->med_mismatched = false;
+		aggregate->med_matched_value = cur_med;
+	} else {
+		/* Check if routes with different MED showed up. */
+		if (cur_med != aggregate->med_matched_value)
+			aggregate->med_mismatched = true;
+	}
+
+	return !aggregate->med_mismatched;
+}
+
+/**
+ * Initializes and tests all routes in the aggregate address path for MED
+ * values.
+ *
+ * \returns `true` if all MEDs are the same otherwise `false`.
+ */
+static bool bgp_aggregate_test_all_med(struct bgp_aggregate *aggregate,
+				       struct bgp *bgp, const struct prefix *p,
+				       afi_t afi, safi_t safi)
+{
+	struct bgp_table *table = bgp->rib[afi][safi];
+	const struct prefix *dest_p;
+	struct bgp_dest *dest, *top;
+	struct bgp_path_info *pi;
+	bool med_matched = true;
+
+	aggregate->med_initialized = false;
+
+	top = bgp_node_get(table, p);
+	for (dest = bgp_node_get(table, p); dest;
+	     dest = bgp_route_next_until(dest, top)) {
+		dest_p = bgp_dest_get_prefix(dest);
+		if (dest_p->prefixlen <= p->prefixlen)
+			continue;
+
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+			if (BGP_PATH_HOLDDOWN(pi))
+				continue;
+			if (pi->sub_type == BGP_ROUTE_AGGREGATE)
+				continue;
+			if (!bgp_aggregate_med_match(aggregate, bgp, pi)) {
+				med_matched = false;
+				break;
+			}
+		}
+		if (!med_matched)
+			break;
+	}
+	bgp_dest_unlock_node(top);
+
+	return med_matched;
+}
+
+/**
+ * Toggles the route suppression status for this aggregate address
+ * configuration.
+ */
+void bgp_aggregate_toggle_suppressed(struct bgp_aggregate *aggregate,
+				     struct bgp *bgp, const struct prefix *p,
+				     afi_t afi, safi_t safi, bool suppress)
+{
+	struct bgp_table *table = bgp->rib[afi][safi];
+	const struct prefix *dest_p;
+	struct bgp_dest *dest, *top;
+	struct bgp_path_info *pi;
+	bool toggle_suppression;
+
+	/* We've found a different MED we must revert any suppressed routes. */
+	top = bgp_node_get(table, p);
+	for (dest = bgp_node_get(table, p); dest;
+	     dest = bgp_route_next_until(dest, top)) {
+		dest_p = bgp_dest_get_prefix(dest);
+		if (dest_p->prefixlen <= p->prefixlen)
+			continue;
+
+		toggle_suppression = false;
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+			if (BGP_PATH_HOLDDOWN(pi))
+				continue;
+			if (pi->sub_type == BGP_ROUTE_AGGREGATE)
+				continue;
+
+			/* We are toggling suppression back. */
+			if (suppress) {
+				/* Suppress route if not suppressed already. */
+				if (aggr_suppress_path(aggregate, pi))
+					toggle_suppression = true;
+				continue;
+			}
+
+			/* Install route if there is no more suppression. */
+			if (aggr_unsuppress_path(aggregate, pi))
+				toggle_suppression = true;
+		}
+
+		if (toggle_suppression)
+			bgp_process(bgp, dest, afi, safi);
+	}
+	bgp_dest_unlock_node(top);
+}
+
+/**
+ * Aggregate address MED matching incremental test: this function is called
+ * when the initial aggregation occurred and we are only testing a single
+ * new path.
+ *
+ * In addition to testing and setting the MED validity it also installs back
+ * suppressed routes (if summary is configured).
+ *
+ * Must not be called in `bgp_aggregate_route`.
+ */
+static void bgp_aggregate_med_update(struct bgp_aggregate *aggregate,
+				     struct bgp *bgp, const struct prefix *p,
+				     afi_t afi, safi_t safi,
+				     struct bgp_path_info *pi)
+{
+	/* MED matching disabled. */
+	if (!aggregate->match_med)
+		return;
+
+	/* Aggregation with different MED, recheck if we have got equal MEDs
+	 * now.
+	 */
+	if (aggregate->med_mismatched &&
+	    bgp_aggregate_test_all_med(aggregate, bgp, p, afi, safi) &&
+	    aggregate->summary_only)
+		bgp_aggregate_toggle_suppressed(aggregate, bgp, p, afi, safi,
+						true);
+	else
+		bgp_aggregate_med_match(aggregate, bgp, pi);
+
+	/* No mismatches, just quit. */
+	if (!aggregate->med_mismatched)
+		return;
+
+	/* Route summarization is disabled. */
+	if (!aggregate->summary_only)
+		return;
+
+	bgp_aggregate_toggle_suppressed(aggregate, bgp, p, afi, safi, false);
+}
+
+/* Update an aggregate as routes are added/removed from the BGP table */
+bool bgp_aggregate_route(struct bgp *bgp, const struct prefix *p, afi_t afi,
+			 safi_t safi, struct bgp_aggregate *aggregate)
+{
+	struct bgp_table *table;
+	struct bgp_dest *top;
+	struct bgp_dest *dest;
+	uint8_t origin;
+	struct aspath *aspath = NULL;
+	struct community *community = NULL;
+	struct ecommunity *ecommunity = NULL;
+	struct lcommunity *lcommunity = NULL;
+	struct bgp_path_info *pi;
+	unsigned long match = 0;
+	uint8_t atomic_aggregate = 0;
+
+	/* If the bgp instance is being deleted or self peer is deleted
+	 * then do not create aggregate route
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS) ||
+	    bgp->peer_self == NULL)
+		return false;
+
+	/* Initialize and test routes for MED difference. */
+	if (aggregate->match_med)
+		bgp_aggregate_test_all_med(aggregate, bgp, p, afi, safi);
+
+	/*
+	 * Reset aggregate count: we might've been called from route map
+	 * update so in that case we must retest all more specific routes.
+	 *
+	 * \see `bgp_route_map_process_update`.
+	 */
+	aggregate->count = 0;
+	aggregate->incomplete_origin_count = 0;
+	aggregate->incomplete_origin_count = 0;
+	aggregate->egp_origin_count = 0;
+
+	/* ORIGIN attribute: If at least one route among routes that are
+	   aggregated has ORIGIN with the value INCOMPLETE, then the
+	   aggregated route must have the ORIGIN attribute with the value
+	   INCOMPLETE. Otherwise, if at least one route among routes that
+	   are aggregated has ORIGIN with the value EGP, then the aggregated
+	   route must have the origin attribute with the value EGP. In all
+	   other case the value of the ORIGIN attribute of the aggregated
+	   route is INTERNAL. */
+	origin = BGP_ORIGIN_IGP;
+
+	table = bgp->rib[afi][safi];
+
+	top = bgp_node_get(table, p);
+	for (dest = bgp_node_get(table, p); dest;
+	     dest = bgp_route_next_until(dest, top)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		if (dest_p->prefixlen <= p->prefixlen)
+			continue;
+
+		/* If suppress fib is enabled and route not installed
+		 * in FIB, skip the route
+		 */
+		if (!bgp_check_advertise(bgp, dest, safi))
+			continue;
+
+		match = 0;
+
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+			if (BGP_PATH_HOLDDOWN(pi))
+				continue;
+
+			if (pi->attr->flag
+			    & ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE))
+				atomic_aggregate = 1;
+
+			if (pi->sub_type == BGP_ROUTE_AGGREGATE)
+				continue;
+
+			/*
+			 * summary-only aggregate route suppress
+			 * aggregated route announcements.
+			 *
+			 * MED matching:
+			 * Don't create summaries if MED didn't match
+			 * otherwise neither the specific routes and the
+			 * aggregation will be announced.
+			 */
+			if (aggregate->summary_only
+			    && AGGREGATE_MED_VALID(aggregate)) {
+				if (aggr_suppress_path(aggregate, pi))
+					match++;
+			}
+
+			/*
+			 * Suppress more specific routes that match the route
+			 * map results.
+			 *
+			 * MED matching:
+			 * Don't suppress routes if MED matching is enabled and
+			 * it mismatched otherwise we might end up with no
+			 * routes for this path.
+			 */
+			if (aggregate->suppress_map_name
+			    && AGGREGATE_MED_VALID(aggregate)
+			    && aggr_suppress_map_test(bgp, aggregate, pi)) {
+				if (aggr_suppress_path(aggregate, pi))
+					match++;
+			}
+
+			aggregate->count++;
+
+			/*
+                        * If at least one route among routes that are
+                        * aggregated has ORIGIN with the value INCOMPLETE,
+                        * then the aggregated route MUST have the ORIGIN
+                        * attribute with the value INCOMPLETE.  Otherwise, if
+                        * at least one route among routes that are aggregated
+                        * has ORIGIN with the value EGP, then the aggregated
+                        * route MUST have the ORIGIN attribute with the value
+                        * EGP.
+                        */
+			switch (pi->attr->origin) {
+			case BGP_ORIGIN_INCOMPLETE:
+				aggregate->incomplete_origin_count++;
+			break;
+			case BGP_ORIGIN_EGP:
+				aggregate->egp_origin_count++;
+			break;
+			default:
+				/*Do nothing.
+				 */
+			break;
+			}
+
+			if (!aggregate->as_set)
+				continue;
+
+			/*
+			 * as-set aggregate route generate origin, as path,
+			 * and community aggregation.
+			 */
+			/* Compute aggregate route's as-path.
+			 */
+			bgp_compute_aggregate_aspath_hash(aggregate,
+							  pi->attr->aspath);
+
+			/* Compute aggregate route's community.
+			 */
+			if (bgp_attr_get_community(pi->attr))
+				bgp_compute_aggregate_community_hash(
+					aggregate,
+					bgp_attr_get_community(pi->attr));
+
+			/* Compute aggregate route's extended community.
+			 */
+			if (bgp_attr_get_ecommunity(pi->attr))
+				bgp_compute_aggregate_ecommunity_hash(
+					aggregate,
+					bgp_attr_get_ecommunity(pi->attr));
+
+			/* Compute aggregate route's large community.
+			 */
+			if (bgp_attr_get_lcommunity(pi->attr))
+				bgp_compute_aggregate_lcommunity_hash(
+					aggregate,
+					bgp_attr_get_lcommunity(pi->attr));
+		}
+		if (match)
+			bgp_process(bgp, dest, afi, safi);
+	}
+	if (aggregate->as_set) {
+		bgp_compute_aggregate_aspath_val(aggregate);
+		bgp_compute_aggregate_community_val(aggregate);
+		bgp_compute_aggregate_ecommunity_val(aggregate);
+		bgp_compute_aggregate_lcommunity_val(aggregate);
+	}
+
+
+	bgp_dest_unlock_node(top);
+
+
+	if (aggregate->incomplete_origin_count > 0)
+		origin = BGP_ORIGIN_INCOMPLETE;
+	else if (aggregate->egp_origin_count > 0)
+		origin = BGP_ORIGIN_EGP;
+
+	if (aggregate->origin != BGP_ORIGIN_UNSPECIFIED)
+		origin = aggregate->origin;
+
+	if (aggregate->as_set) {
+		if (aggregate->aspath)
+			/* Retrieve aggregate route's as-path.
+			 */
+			aspath = aspath_dup(aggregate->aspath);
+
+		if (aggregate->community)
+			/* Retrieve aggregate route's community.
+			 */
+			community = community_dup(aggregate->community);
+
+		if (aggregate->ecommunity)
+			/* Retrieve aggregate route's ecommunity.
+			 */
+			ecommunity = ecommunity_dup(aggregate->ecommunity);
+
+		if (aggregate->lcommunity)
+			/* Retrieve aggregate route's lcommunity.
+			 */
+			lcommunity = lcommunity_dup(aggregate->lcommunity);
+	}
+
+	bgp_aggregate_install(bgp, afi, safi, p, origin, aspath, community,
+			      ecommunity, lcommunity, atomic_aggregate,
+			      aggregate);
+
+	return true;
+}
+
+void bgp_aggregate_delete(struct bgp *bgp, const struct prefix *p, afi_t afi,
+			  safi_t safi, struct bgp_aggregate *aggregate)
+{
+	struct bgp_table *table;
+	struct bgp_dest *top;
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	unsigned long match;
+
+	table = bgp->rib[afi][safi];
+
+	/* If routes exists below this node, generate aggregate routes. */
+	top = bgp_node_get(table, p);
+	for (dest = bgp_node_get(table, p); dest;
+	     dest = bgp_route_next_until(dest, top)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		if (dest_p->prefixlen <= p->prefixlen)
+			continue;
+		match = 0;
+
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+			if (BGP_PATH_HOLDDOWN(pi))
+				continue;
+
+			if (pi->sub_type == BGP_ROUTE_AGGREGATE)
+				continue;
+
+			/*
+			 * This route is suppressed: attempt to unsuppress it.
+			 *
+			 * `aggr_unsuppress_path` will fail if this particular
+			 * aggregate route was not the suppressor.
+			 */
+			if (pi->extra && pi->extra->aggr_suppressors &&
+			    listcount(pi->extra->aggr_suppressors)) {
+				if (aggr_unsuppress_path(aggregate, pi))
+					match++;
+			}
+
+			aggregate->count--;
+
+			if (pi->attr->origin == BGP_ORIGIN_INCOMPLETE)
+				aggregate->incomplete_origin_count--;
+			else if (pi->attr->origin == BGP_ORIGIN_EGP)
+				aggregate->egp_origin_count--;
+
+			if (aggregate->as_set) {
+				/* Remove as-path from aggregate.
+				 */
+				bgp_remove_aspath_from_aggregate_hash(
+							aggregate,
+							pi->attr->aspath);
+
+				if (bgp_attr_get_community(pi->attr))
+					/* Remove community from aggregate.
+					 */
+					bgp_remove_comm_from_aggregate_hash(
+						aggregate,
+						bgp_attr_get_community(
+							pi->attr));
+
+				if (bgp_attr_get_ecommunity(pi->attr))
+					/* Remove ecommunity from aggregate.
+					 */
+					bgp_remove_ecomm_from_aggregate_hash(
+						aggregate,
+						bgp_attr_get_ecommunity(
+							pi->attr));
+
+				if (bgp_attr_get_lcommunity(pi->attr))
+					/* Remove lcommunity from aggregate.
+					 */
+					bgp_remove_lcomm_from_aggregate_hash(
+						aggregate,
+						bgp_attr_get_lcommunity(
+							pi->attr));
+			}
+		}
+
+		/* If this node was suppressed, process the change. */
+		if (match)
+			bgp_process(bgp, dest, afi, safi);
+	}
+	if (aggregate->as_set) {
+		aspath_free(aggregate->aspath);
+		aggregate->aspath = NULL;
+		if (aggregate->community)
+			community_free(&aggregate->community);
+		if (aggregate->ecommunity)
+			ecommunity_free(&aggregate->ecommunity);
+		if (aggregate->lcommunity)
+			lcommunity_free(&aggregate->lcommunity);
+	}
+
+	bgp_dest_unlock_node(top);
+}
+
+static void bgp_add_route_to_aggregate(struct bgp *bgp,
+				       const struct prefix *aggr_p,
+				       struct bgp_path_info *pinew, afi_t afi,
+				       safi_t safi,
+				       struct bgp_aggregate *aggregate)
+{
+	uint8_t origin;
+	struct aspath *aspath = NULL;
+	uint8_t atomic_aggregate = 0;
+	struct community *community = NULL;
+	struct ecommunity *ecommunity = NULL;
+	struct lcommunity *lcommunity = NULL;
+
+	/* If the bgp instance is being deleted or self peer is deleted
+	 * then do not create aggregate route
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS)
+	    || (bgp->peer_self == NULL))
+		return;
+
+	/* ORIGIN attribute: If at least one route among routes that are
+	 * aggregated has ORIGIN with the value INCOMPLETE, then the
+	 * aggregated route must have the ORIGIN attribute with the value
+	 * INCOMPLETE. Otherwise, if at least one route among routes that
+	 * are aggregated has ORIGIN with the value EGP, then the aggregated
+	 * route must have the origin attribute with the value EGP. In all
+	 * other case the value of the ORIGIN attribute of the aggregated
+	 * route is INTERNAL.
+	 */
+	origin = BGP_ORIGIN_IGP;
+
+	aggregate->count++;
+
+	/*
+	 * This must be called before `summary` check to avoid
+	 * "suppressing" twice.
+	 */
+	if (aggregate->match_med)
+		bgp_aggregate_med_update(aggregate, bgp, aggr_p, afi, safi,
+					 pinew);
+
+	if (aggregate->summary_only && AGGREGATE_MED_VALID(aggregate))
+		aggr_suppress_path(aggregate, pinew);
+
+	if (aggregate->suppress_map_name && AGGREGATE_MED_VALID(aggregate)
+	    && aggr_suppress_map_test(bgp, aggregate, pinew))
+		aggr_suppress_path(aggregate, pinew);
+
+	switch (pinew->attr->origin) {
+	case BGP_ORIGIN_INCOMPLETE:
+		aggregate->incomplete_origin_count++;
+	break;
+	case BGP_ORIGIN_EGP:
+		aggregate->egp_origin_count++;
+	break;
+	default:
+		/* Do nothing.
+		 */
+	break;
+	}
+
+	if (aggregate->incomplete_origin_count > 0)
+		origin = BGP_ORIGIN_INCOMPLETE;
+	else if (aggregate->egp_origin_count > 0)
+		origin = BGP_ORIGIN_EGP;
+
+	if (aggregate->origin != BGP_ORIGIN_UNSPECIFIED)
+		origin = aggregate->origin;
+
+	if (aggregate->as_set) {
+		/* Compute aggregate route's as-path.
+		 */
+		bgp_compute_aggregate_aspath(aggregate,
+					     pinew->attr->aspath);
+
+		/* Compute aggregate route's community.
+		 */
+		if (bgp_attr_get_community(pinew->attr))
+			bgp_compute_aggregate_community(
+				aggregate, bgp_attr_get_community(pinew->attr));
+
+		/* Compute aggregate route's extended community.
+		 */
+		if (bgp_attr_get_ecommunity(pinew->attr))
+			bgp_compute_aggregate_ecommunity(
+				aggregate,
+				bgp_attr_get_ecommunity(pinew->attr));
+
+		/* Compute aggregate route's large community.
+		 */
+		if (bgp_attr_get_lcommunity(pinew->attr))
+			bgp_compute_aggregate_lcommunity(
+				aggregate,
+				bgp_attr_get_lcommunity(pinew->attr));
+
+		/* Retrieve aggregate route's as-path.
+		 */
+		if (aggregate->aspath)
+			aspath = aspath_dup(aggregate->aspath);
+
+		/* Retrieve aggregate route's community.
+		 */
+		if (aggregate->community)
+			community = community_dup(aggregate->community);
+
+		/* Retrieve aggregate route's ecommunity.
+		 */
+		if (aggregate->ecommunity)
+			ecommunity = ecommunity_dup(aggregate->ecommunity);
+
+		/* Retrieve aggregate route's lcommunity.
+		 */
+		if (aggregate->lcommunity)
+			lcommunity = lcommunity_dup(aggregate->lcommunity);
+	}
+
+	bgp_aggregate_install(bgp, afi, safi, aggr_p, origin,
+			      aspath, community, ecommunity,
+			      lcommunity, atomic_aggregate, aggregate);
+}
+
+static void bgp_remove_route_from_aggregate(struct bgp *bgp, afi_t afi,
+					    safi_t safi,
+					    struct bgp_path_info *pi,
+					    struct bgp_aggregate *aggregate,
+					    const struct prefix *aggr_p)
+{
+	uint8_t origin;
+	struct aspath *aspath = NULL;
+	uint8_t atomic_aggregate = 0;
+	struct community *community = NULL;
+	struct ecommunity *ecommunity = NULL;
+	struct lcommunity *lcommunity = NULL;
+	unsigned long match = 0;
+
+	/* If the bgp instance is being deleted or self peer is deleted
+	 * then do not create aggregate route
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS)
+	    || (bgp->peer_self == NULL))
+		return;
+
+	if (BGP_PATH_HOLDDOWN(pi))
+		return;
+
+	if (pi->sub_type == BGP_ROUTE_AGGREGATE)
+		return;
+
+	if (aggregate->summary_only && AGGREGATE_MED_VALID(aggregate))
+		if (aggr_unsuppress_path(aggregate, pi))
+			match++;
+
+	if (aggregate->suppress_map_name && AGGREGATE_MED_VALID(aggregate)
+	    && aggr_suppress_map_test(bgp, aggregate, pi))
+		if (aggr_unsuppress_path(aggregate, pi))
+			match++;
+
+	/*
+	 * This must be called after `summary`, `suppress-map` check to avoid
+	 * "unsuppressing" twice.
+	 */
+	if (aggregate->match_med)
+		bgp_aggregate_med_update(aggregate, bgp, aggr_p, afi, safi, pi);
+
+	if (aggregate->count > 0)
+		aggregate->count--;
+
+	if (pi->attr->origin == BGP_ORIGIN_INCOMPLETE)
+		aggregate->incomplete_origin_count--;
+	else if (pi->attr->origin == BGP_ORIGIN_EGP)
+		aggregate->egp_origin_count--;
+
+	if (aggregate->as_set) {
+		/* Remove as-path from aggregate.
+		 */
+		bgp_remove_aspath_from_aggregate(aggregate,
+						 pi->attr->aspath);
+
+		if (bgp_attr_get_community(pi->attr))
+			/* Remove community from aggregate.
+			 */
+			bgp_remove_community_from_aggregate(
+				aggregate, bgp_attr_get_community(pi->attr));
+
+		if (bgp_attr_get_ecommunity(pi->attr))
+			/* Remove ecommunity from aggregate.
+			 */
+			bgp_remove_ecommunity_from_aggregate(
+				aggregate, bgp_attr_get_ecommunity(pi->attr));
+
+		if (bgp_attr_get_lcommunity(pi->attr))
+			/* Remove lcommunity from aggregate.
+			 */
+			bgp_remove_lcommunity_from_aggregate(
+				aggregate, bgp_attr_get_lcommunity(pi->attr));
+	}
+
+	/* If this node was suppressed, process the change. */
+	if (match)
+		bgp_process(bgp, pi->net, afi, safi);
+
+	origin = BGP_ORIGIN_IGP;
+	if (aggregate->incomplete_origin_count > 0)
+		origin = BGP_ORIGIN_INCOMPLETE;
+	else if (aggregate->egp_origin_count > 0)
+		origin = BGP_ORIGIN_EGP;
+
+	if (aggregate->origin != BGP_ORIGIN_UNSPECIFIED)
+		origin = aggregate->origin;
+
+	if (aggregate->as_set) {
+		/* Retrieve aggregate route's as-path.
+		 */
+		if (aggregate->aspath)
+			aspath = aspath_dup(aggregate->aspath);
+
+		/* Retrieve aggregate route's community.
+		 */
+		if (aggregate->community)
+			community = community_dup(aggregate->community);
+
+		/* Retrieve aggregate route's ecommunity.
+		 */
+		if (aggregate->ecommunity)
+			ecommunity = ecommunity_dup(aggregate->ecommunity);
+
+		/* Retrieve aggregate route's lcommunity.
+		 */
+		if (aggregate->lcommunity)
+			lcommunity = lcommunity_dup(aggregate->lcommunity);
+	}
+
+	bgp_aggregate_install(bgp, afi, safi, aggr_p, origin,
+			      aspath, community, ecommunity,
+			      lcommunity, atomic_aggregate, aggregate);
+}
+
+void bgp_aggregate_increment(struct bgp *bgp, const struct prefix *p,
+			     struct bgp_path_info *pi, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *child;
+	struct bgp_dest *dest;
+	struct bgp_aggregate *aggregate;
+	struct bgp_table *table;
+
+	table = bgp->aggregate[afi][safi];
+
+	/* No aggregates configured. */
+	if (bgp_table_top_nolock(table) == NULL)
+		return;
+
+	if (p->prefixlen == 0)
+		return;
+
+	if (BGP_PATH_HOLDDOWN(pi))
+		return;
+
+	/* If suppress fib is enabled and route not installed
+	 * in FIB, do not update the aggregate route
+	 */
+	if (!bgp_check_advertise(bgp, pi->net, safi))
+		return;
+
+	child = bgp_node_get(table, p);
+
+	/* Aggregate address configuration check. */
+	for (dest = child; dest; dest = bgp_dest_parent_nolock(dest)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		aggregate = bgp_dest_get_bgp_aggregate_info(dest);
+		if (aggregate != NULL && dest_p->prefixlen < p->prefixlen) {
+			bgp_add_route_to_aggregate(bgp, dest_p, pi, afi, safi,
+						   aggregate);
+		}
+	}
+	bgp_dest_unlock_node(child);
+}
+
+void bgp_aggregate_decrement(struct bgp *bgp, const struct prefix *p,
+			     struct bgp_path_info *del, afi_t afi, safi_t safi)
+{
+	struct bgp_dest *child;
+	struct bgp_dest *dest;
+	struct bgp_aggregate *aggregate;
+	struct bgp_table *table;
+
+	table = bgp->aggregate[afi][safi];
+
+	/* No aggregates configured. */
+	if (bgp_table_top_nolock(table) == NULL)
+		return;
+
+	if (p->prefixlen == 0)
+		return;
+
+	child = bgp_node_get(table, p);
+
+	/* Aggregate address configuration check. */
+	for (dest = child; dest; dest = bgp_dest_parent_nolock(dest)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		aggregate = bgp_dest_get_bgp_aggregate_info(dest);
+		if (aggregate != NULL && dest_p->prefixlen < p->prefixlen) {
+			bgp_remove_route_from_aggregate(bgp, afi, safi, del,
+							aggregate, dest_p);
+		}
+	}
+	bgp_dest_unlock_node(child);
+}
+
+/* Aggregate route attribute. */
+#define AGGREGATE_SUMMARY_ONLY 1
+#define AGGREGATE_AS_SET       1
+#define AGGREGATE_AS_UNSET     0
+
+static const char *bgp_origin2str(uint8_t origin)
+{
+	switch (origin) {
+	case BGP_ORIGIN_IGP:
+		return "igp";
+	case BGP_ORIGIN_EGP:
+		return "egp";
+	case BGP_ORIGIN_INCOMPLETE:
+		return "incomplete";
+	}
+	return "n/a";
+}
+
+static const char *bgp_rpki_validation2str(enum rpki_states v_state)
+{
+	switch (v_state) {
+	case RPKI_NOT_BEING_USED:
+		return "not used";
+	case RPKI_VALID:
+		return "valid";
+	case RPKI_NOTFOUND:
+		return "not found";
+	case RPKI_INVALID:
+		return "invalid";
+	}
+
+	assert(!"We should never get here this is a dev escape");
+	return "ERROR";
+}
+
+static int bgp_aggregate_unset(struct vty *vty, const char *prefix_str,
+			       afi_t afi, safi_t safi)
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	int ret;
+	struct prefix p;
+	struct bgp_dest *dest;
+	struct bgp_aggregate *aggregate;
+
+	/* Convert string to prefix structure. */
+	ret = str2prefix(prefix_str, &p);
+	if (!ret) {
+		vty_out(vty, "Malformed prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+	apply_mask(&p);
+
+	/* Old configuration check. */
+	dest = bgp_node_lookup(bgp->aggregate[afi][safi], &p);
+	if (!dest) {
+		vty_out(vty,
+			"%% There is no aggregate-address configuration.\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	aggregate = bgp_dest_get_bgp_aggregate_info(dest);
+	bgp_aggregate_delete(bgp, &p, afi, safi, aggregate);
+	bgp_aggregate_install(bgp, afi, safi, &p, 0, NULL, NULL,
+			      NULL, NULL,  0, aggregate);
+
+	/* Unlock aggregate address configuration. */
+	bgp_dest_set_bgp_aggregate_info(dest, NULL);
+
+	bgp_free_aggregate_info(aggregate);
+	dest = bgp_dest_unlock_node(dest);
+	assert(dest);
+	bgp_dest_unlock_node(dest);
+
+	return CMD_SUCCESS;
+}
+
+static int bgp_aggregate_set(struct vty *vty, const char *prefix_str, afi_t afi,
+			     safi_t safi, const char *rmap,
+			     uint8_t summary_only, uint8_t as_set,
+			     uint8_t origin, bool match_med,
+			     const char *suppress_map)
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	int ret;
+	struct prefix p;
+	struct bgp_dest *dest;
+	struct bgp_aggregate *aggregate;
+	uint8_t as_set_new = as_set;
+
+	if (suppress_map && summary_only) {
+		vty_out(vty,
+			"'summary-only' and 'suppress-map' can't be used at the same time\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	/* Convert string to prefix structure. */
+	ret = str2prefix(prefix_str, &p);
+	if (!ret) {
+		vty_out(vty, "Malformed prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+	apply_mask(&p);
+
+	if ((afi == AFI_IP && p.prefixlen == IPV4_MAX_BITLEN) ||
+	    (afi == AFI_IP6 && p.prefixlen == IPV6_MAX_BITLEN)) {
+		vty_out(vty, "Specified prefix: %s will not result in any useful aggregation, disallowing\n",
+			prefix_str);
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	/* Old configuration check. */
+	dest = bgp_node_get(bgp->aggregate[afi][safi], &p);
+	aggregate = bgp_dest_get_bgp_aggregate_info(dest);
+
+	if (aggregate) {
+		vty_out(vty, "There is already same aggregate network.\n");
+		/* try to remove the old entry */
+		ret = bgp_aggregate_unset(vty, prefix_str, afi, safi);
+		if (ret) {
+			vty_out(vty, "Error deleting aggregate.\n");
+			bgp_dest_unlock_node(dest);
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+	}
+
+	/* Make aggregate address structure. */
+	aggregate = bgp_aggregate_new();
+	aggregate->summary_only = summary_only;
+	aggregate->match_med = match_med;
+
+	/* Network operators MUST NOT locally generate any new
+	 * announcements containing AS_SET or AS_CONFED_SET. If they have
+	 * announced routes with AS_SET or AS_CONFED_SET in them, then they
+	 * SHOULD withdraw those routes and re-announce routes for the
+	 * aggregate or component prefixes (i.e., the more-specific routes
+	 * subsumed by the previously aggregated route) without AS_SET
+	 * or AS_CONFED_SET in the updates.
+	 */
+	if (bgp->reject_as_sets) {
+		if (as_set == AGGREGATE_AS_SET) {
+			as_set_new = AGGREGATE_AS_UNSET;
+			zlog_warn(
+				"%s: Ignoring as-set because `bgp reject-as-sets` is enabled.",
+				__func__);
+			vty_out(vty,
+				"Ignoring as-set because `bgp reject-as-sets` is enabled.\n");
+		}
+	}
+
+	aggregate->as_set = as_set_new;
+	aggregate->safi = safi;
+	/* Override ORIGIN attribute if defined.
+	 * E.g.: Cisco and Juniper set ORIGIN for aggregated address
+	 * to IGP which is not what rfc4271 says.
+	 * This enables the same behavior, optionally.
+	 */
+	aggregate->origin = origin;
+
+	if (rmap) {
+		XFREE(MTYPE_ROUTE_MAP_NAME, aggregate->rmap.name);
+		route_map_counter_decrement(aggregate->rmap.map);
+		aggregate->rmap.name =
+			XSTRDUP(MTYPE_ROUTE_MAP_NAME, rmap);
+		aggregate->rmap.map = route_map_lookup_by_name(rmap);
+		route_map_counter_increment(aggregate->rmap.map);
+	}
+
+	if (suppress_map) {
+		XFREE(MTYPE_ROUTE_MAP_NAME, aggregate->suppress_map_name);
+		route_map_counter_decrement(aggregate->suppress_map);
+
+		aggregate->suppress_map_name =
+			XSTRDUP(MTYPE_ROUTE_MAP_NAME, suppress_map);
+		aggregate->suppress_map =
+			route_map_lookup_by_name(aggregate->suppress_map_name);
+		route_map_counter_increment(aggregate->suppress_map);
+	}
+
+	bgp_dest_set_bgp_aggregate_info(dest, aggregate);
+
+	/* Aggregate address insert into BGP routing table. */
+	if (!bgp_aggregate_route(bgp, &p, afi, safi, aggregate)) {
+		bgp_aggregate_free(aggregate);
+		bgp_dest_unlock_node(dest);
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFPY(aggregate_addressv4, aggregate_addressv4_cmd,
+      "[no] aggregate-address <A.B.C.D/M$prefix|A.B.C.D$addr A.B.C.D$mask> [{"
+      "as-set$as_set_s"
+      "|summary-only$summary_only"
+      "|route-map RMAP_NAME$rmap_name"
+      "|origin <egp|igp|incomplete>$origin_s"
+      "|matching-MED-only$match_med"
+      "|suppress-map RMAP_NAME$suppress_map"
+      "}]",
+      NO_STR
+      "Configure BGP aggregate entries\n"
+      "Aggregate prefix\n"
+      "Aggregate address\n"
+      "Aggregate mask\n"
+      "Generate AS set path information\n"
+      "Filter more specific routes from updates\n"
+      "Apply route map to aggregate network\n"
+      "Route map name\n"
+      "BGP origin code\n"
+      "Remote EGP\n"
+      "Local IGP\n"
+      "Unknown heritage\n"
+      "Only aggregate routes with matching MED\n"
+      "Suppress the selected more specific routes\n"
+      "Route map with the route selectors\n")
+{
+	const char *prefix_s = NULL;
+	safi_t safi = bgp_node_safi(vty);
+	uint8_t origin = BGP_ORIGIN_UNSPECIFIED;
+	int as_set = AGGREGATE_AS_UNSET;
+	char prefix_buf[PREFIX2STR_BUFFER];
+
+	if (addr_str) {
+		if (netmask_str2prefix_str(addr_str, mask_str, prefix_buf,
+					   sizeof(prefix_buf))
+		    == 0) {
+			vty_out(vty, "%% Inconsistent address and mask\n");
+			return CMD_WARNING_CONFIG_FAILED;
+		}
+		prefix_s = prefix_buf;
+	} else
+		prefix_s = prefix_str;
+
+	if (origin_s) {
+		if (strcmp(origin_s, "egp") == 0)
+			origin = BGP_ORIGIN_EGP;
+		else if (strcmp(origin_s, "igp") == 0)
+			origin = BGP_ORIGIN_IGP;
+		else if (strcmp(origin_s, "incomplete") == 0)
+			origin = BGP_ORIGIN_INCOMPLETE;
+	}
+
+	if (as_set_s)
+		as_set = AGGREGATE_AS_SET;
+
+	/* Handle configuration removal, otherwise installation. */
+	if (no)
+		return bgp_aggregate_unset(vty, prefix_s, AFI_IP, safi);
+
+	return bgp_aggregate_set(vty, prefix_s, AFI_IP, safi, rmap_name,
+				 summary_only != NULL, as_set, origin,
+				 match_med != NULL, suppress_map);
+}
+
+void bgp_free_aggregate_info(struct bgp_aggregate *aggregate)
+{
+	if (aggregate->community)
+		community_free(&aggregate->community);
+
+	hash_clean_and_free(&aggregate->community_hash,
+			    bgp_aggr_community_remove);
+
+	if (aggregate->ecommunity)
+		ecommunity_free(&aggregate->ecommunity);
+
+	hash_clean_and_free(&aggregate->ecommunity_hash,
+			    bgp_aggr_ecommunity_remove);
+
+	if (aggregate->lcommunity)
+		lcommunity_free(&aggregate->lcommunity);
+
+	hash_clean_and_free(&aggregate->lcommunity_hash,
+			    bgp_aggr_lcommunity_remove);
+
+	if (aggregate->aspath)
+		aspath_free(aggregate->aspath);
+
+	hash_clean_and_free(&aggregate->aspath_hash, bgp_aggr_aspath_remove);
+
+	bgp_aggregate_free(aggregate);
+}
+
+DEFPY(aggregate_addressv6, aggregate_addressv6_cmd,
+      "[no] aggregate-address X:X::X:X/M$prefix [{"
+      "as-set$as_set_s"
+      "|summary-only$summary_only"
+      "|route-map RMAP_NAME$rmap_name"
+      "|origin <egp|igp|incomplete>$origin_s"
+      "|matching-MED-only$match_med"
+      "|suppress-map RMAP_NAME$suppress_map"
+      "}]",
+      NO_STR
+      "Configure BGP aggregate entries\n"
+      "Aggregate prefix\n"
+      "Generate AS set path information\n"
+      "Filter more specific routes from updates\n"
+      "Apply route map to aggregate network\n"
+      "Route map name\n"
+      "BGP origin code\n"
+      "Remote EGP\n"
+      "Local IGP\n"
+      "Unknown heritage\n"
+      "Only aggregate routes with matching MED\n"
+      "Suppress the selected more specific routes\n"
+      "Route map with the route selectors\n")
+{
+	uint8_t origin = BGP_ORIGIN_UNSPECIFIED;
+	int as_set = AGGREGATE_AS_UNSET;
+
+	if (origin_s) {
+		if (strcmp(origin_s, "egp") == 0)
+			origin = BGP_ORIGIN_EGP;
+		else if (strcmp(origin_s, "igp") == 0)
+			origin = BGP_ORIGIN_IGP;
+		else if (strcmp(origin_s, "incomplete") == 0)
+			origin = BGP_ORIGIN_INCOMPLETE;
+	}
+
+	if (as_set_s)
+		as_set = AGGREGATE_AS_SET;
+
+	/* Handle configuration removal, otherwise installation. */
+	if (no)
+		return bgp_aggregate_unset(vty, prefix_str, AFI_IP6,
+					   SAFI_UNICAST);
+
+	return bgp_aggregate_set(vty, prefix_str, AFI_IP6, SAFI_UNICAST,
+				 rmap_name, summary_only != NULL, as_set,
+				 origin, match_med != NULL, suppress_map);
+}
+
+/* Redistribute route treatment. */
+void bgp_redistribute_add(struct bgp *bgp, struct prefix *p,
+			  const union g_addr *nexthop, ifindex_t ifindex,
+			  enum nexthop_types_t nhtype, uint8_t distance,
+			  enum blackhole_type bhtype, uint32_t metric,
+			  uint8_t type, unsigned short instance,
+			  route_tag_t tag)
+{
+	struct bgp_path_info *new;
+	struct bgp_path_info *bpi;
+	struct bgp_path_info rmap_path;
+	struct bgp_dest *bn;
+	struct attr attr;
+	struct attr *new_attr;
+	afi_t afi;
+	route_map_result_t ret;
+	struct bgp_redist *red;
+
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_DELETE_IN_PROGRESS) ||
+	    bgp->peer_self == NULL)
+		return;
+
+	/* Make default attribute. */
+	bgp_attr_default_set(&attr, bgp, BGP_ORIGIN_INCOMPLETE);
+	/*
+	 * This must not be NULL to satisfy Coverity SA
+	 */
+	assert(attr.aspath);
+
+	if (p->family == AF_INET6)
+		UNSET_FLAG(attr.flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP));
+
+	switch (nhtype) {
+	case NEXTHOP_TYPE_IFINDEX:
+		switch (p->family) {
+		case AF_INET:
+			attr.nexthop.s_addr = INADDR_ANY;
+			attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
+			attr.mp_nexthop_global_in.s_addr = INADDR_ANY;
+			break;
+		case AF_INET6:
+			memset(&attr.mp_nexthop_global, 0,
+			       sizeof(attr.mp_nexthop_global));
+			attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
+			break;
+		}
+		break;
+	case NEXTHOP_TYPE_IPV4:
+	case NEXTHOP_TYPE_IPV4_IFINDEX:
+		attr.nexthop = nexthop->ipv4;
+		attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
+		attr.mp_nexthop_global_in = nexthop->ipv4;
+		break;
+	case NEXTHOP_TYPE_IPV6:
+	case NEXTHOP_TYPE_IPV6_IFINDEX:
+		attr.mp_nexthop_global = nexthop->ipv6;
+		attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
+		break;
+	case NEXTHOP_TYPE_BLACKHOLE:
+		switch (p->family) {
+		case AF_INET:
+			attr.nexthop.s_addr = INADDR_ANY;
+			attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4;
+			attr.mp_nexthop_global_in.s_addr = INADDR_ANY;
+			break;
+		case AF_INET6:
+			memset(&attr.mp_nexthop_global, 0,
+			       sizeof(attr.mp_nexthop_global));
+			attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
+			break;
+		}
+		attr.bh_type = bhtype;
+		break;
+	}
+	attr.nh_type = nhtype;
+	attr.nh_ifindex = ifindex;
+
+	attr.med = metric;
+	attr.distance = distance;
+	attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC);
+	attr.tag = tag;
+
+	if (metric)
+		bgp_attr_set_aigp_metric(&attr, metric);
+
+	afi = family2afi(p->family);
+
+	red = bgp_redist_lookup(bgp, afi, type, instance);
+	if (red) {
+		struct attr attr_new;
+
+		/* Copy attribute for modification. */
+		attr_new = attr;
+
+		if (red->redist_metric_flag) {
+			attr_new.med = red->redist_metric;
+			bgp_attr_set_aigp_metric(&attr_new, red->redist_metric);
+		}
+
+		/* Apply route-map. */
+		if (red->rmap.name) {
+			memset(&rmap_path, 0, sizeof(rmap_path));
+			rmap_path.peer = bgp->peer_self;
+			rmap_path.attr = &attr_new;
+
+			SET_FLAG(bgp->peer_self->rmap_type,
+				 PEER_RMAP_TYPE_REDISTRIBUTE);
+
+			ret = route_map_apply(red->rmap.map, p, &rmap_path);
+
+			bgp->peer_self->rmap_type = 0;
+
+			if (ret == RMAP_DENYMATCH) {
+				/* Free uninterned attribute. */
+				bgp_attr_flush(&attr_new);
+
+				/* Unintern original. */
+				aspath_unintern(&attr.aspath);
+				bgp_redistribute_delete(bgp, p, type, instance);
+				return;
+			}
+		}
+
+		if (bgp_in_graceful_shutdown(bgp))
+			bgp_attr_add_gshut_community(&attr_new);
+
+		bn = bgp_afi_node_get(bgp->rib[afi][SAFI_UNICAST], afi,
+				      SAFI_UNICAST, p, NULL);
+
+		new_attr = bgp_attr_intern(&attr_new);
+
+		for (bpi = bgp_dest_get_bgp_path_info(bn); bpi; bpi = bpi->next)
+			if (bpi->peer == bgp->peer_self
+			    && bpi->sub_type == BGP_ROUTE_REDISTRIBUTE)
+				break;
+
+		if (bpi) {
+			/* Ensure the (source route) type is updated. */
+			bpi->type = type;
+			if (attrhash_cmp(bpi->attr, new_attr)
+			    && !CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED)) {
+				bgp_attr_unintern(&new_attr);
+				aspath_unintern(&attr.aspath);
+				bgp_dest_unlock_node(bn);
+				return;
+			} else {
+				/* The attribute is changed. */
+				bgp_path_info_set_flag(bn, bpi,
+						       BGP_PATH_ATTR_CHANGED);
+
+				/* Rewrite BGP route information. */
+				if (CHECK_FLAG(bpi->flags, BGP_PATH_REMOVED))
+					bgp_path_info_restore(bn, bpi);
+				else
+					bgp_aggregate_decrement(
+						bgp, p, bpi, afi, SAFI_UNICAST);
+				bgp_attr_unintern(&bpi->attr);
+				bpi->attr = new_attr;
+				bpi->uptime = monotime(NULL);
+
+				/* Process change. */
+				bgp_aggregate_increment(bgp, p, bpi, afi,
+							SAFI_UNICAST);
+				bgp_process(bgp, bn, afi, SAFI_UNICAST);
+				bgp_dest_unlock_node(bn);
+				aspath_unintern(&attr.aspath);
+
+				if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
+				    || (bgp->inst_type
+					== BGP_INSTANCE_TYPE_DEFAULT)) {
+
+					vpn_leak_from_vrf_update(
+						bgp_get_default(), bgp, bpi);
+				}
+				return;
+			}
+		}
+
+		new = info_make(type, BGP_ROUTE_REDISTRIBUTE, instance,
+				bgp->peer_self, new_attr, bn);
+		SET_FLAG(new->flags, BGP_PATH_VALID);
+
+		bgp_aggregate_increment(bgp, p, new, afi, SAFI_UNICAST);
+		bgp_path_info_add(bn, new);
+		bgp_dest_unlock_node(bn);
+		SET_FLAG(bn->flags, BGP_NODE_FIB_INSTALLED);
+		bgp_process(bgp, bn, afi, SAFI_UNICAST);
+
+		if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
+		    || (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+			vpn_leak_from_vrf_update(bgp_get_default(), bgp, new);
+		}
+	}
+
+	/* Unintern original. */
+	aspath_unintern(&attr.aspath);
+}
+
+void bgp_redistribute_delete(struct bgp *bgp, struct prefix *p, uint8_t type,
+			     unsigned short instance)
+{
+	afi_t afi;
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct bgp_redist *red;
+
+	afi = family2afi(p->family);
+
+	red = bgp_redist_lookup(bgp, afi, type, instance);
+	if (red) {
+		dest = bgp_afi_node_get(bgp->rib[afi][SAFI_UNICAST], afi,
+					SAFI_UNICAST, p, NULL);
+
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+			if (pi->peer == bgp->peer_self && pi->type == type)
+				break;
+
+		if (pi) {
+			if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
+			    || (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+				vpn_leak_from_vrf_withdraw(bgp_get_default(),
+							   bgp, pi);
+			}
+			bgp_aggregate_decrement(bgp, p, pi, afi, SAFI_UNICAST);
+			bgp_path_info_delete(dest, pi);
+			bgp_process(bgp, dest, afi, SAFI_UNICAST);
+		}
+		bgp_dest_unlock_node(dest);
+	}
+}
+
+/* Withdraw specified route type's route. */
+void bgp_redistribute_withdraw(struct bgp *bgp, afi_t afi, int type,
+			       unsigned short instance)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct bgp_table *table;
+
+	table = bgp->rib[afi][SAFI_UNICAST];
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next)
+			if (pi->peer == bgp->peer_self && pi->type == type
+			    && pi->instance == instance)
+				break;
+
+		if (pi) {
+			if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
+			    || (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)) {
+
+				vpn_leak_from_vrf_withdraw(bgp_get_default(),
+							   bgp, pi);
+			}
+			bgp_aggregate_decrement(bgp, bgp_dest_get_prefix(dest),
+						pi, afi, SAFI_UNICAST);
+			bgp_path_info_delete(dest, pi);
+			if (!CHECK_FLAG(bgp->flags,
+					BGP_FLAG_DELETE_IN_PROGRESS))
+				bgp_process(bgp, dest, afi, SAFI_UNICAST);
+			else {
+				dest = bgp_path_info_reap(dest, pi);
+				assert(dest);
+			}
+		}
+	}
+}
+
+/* Static function to display route. */
+static void route_vty_out_route(struct bgp_dest *dest, const struct prefix *p,
+				struct vty *vty, json_object *json, bool wide)
+{
+	int len = 0;
+	char buf[INET6_ADDRSTRLEN];
+
+	if (p->family == AF_INET) {
+		if (!json) {
+			len = vty_out(vty, "%pFX", p);
+		} else {
+			json_object_string_add(json, "prefix",
+					       inet_ntop(p->family,
+							 &p->u.prefix, buf,
+							 sizeof(buf)));
+			json_object_int_add(json, "prefixLen", p->prefixlen);
+			json_object_string_addf(json, "network", "%pFX", p);
+			json_object_int_add(json, "version", dest->version);
+		}
+	} else if (p->family == AF_ETHERNET) {
+		len = vty_out(vty, "%pFX", p);
+	} else if (p->family == AF_EVPN) {
+		if (!json)
+			len = vty_out(vty, "%pFX", (struct prefix_evpn *)p);
+		else
+			bgp_evpn_route2json((struct prefix_evpn *)p, json);
+	} else if (p->family == AF_FLOWSPEC) {
+		route_vty_out_flowspec(vty, p, NULL,
+			       json ?
+			       NLRI_STRING_FORMAT_JSON_SIMPLE :
+			       NLRI_STRING_FORMAT_MIN, json);
+	} else {
+		if (!json)
+			len = vty_out(vty, "%pFX", p);
+		else {
+			json_object_string_add(json, "prefix",
+					       inet_ntop(p->family,
+							 &p->u.prefix, buf,
+							 sizeof(buf)));
+			json_object_int_add(json, "prefixLen", p->prefixlen);
+			json_object_string_addf(json, "network", "%pFX", p);
+			json_object_int_add(json, "version", dest->version);
+		}
+	}
+
+	if (!json) {
+		len = wide ? (45 - len) : (17 - len);
+		if (len < 1)
+			vty_out(vty, "\n%*s", 20, " ");
+		else
+			vty_out(vty, "%*s", len, " ");
+	}
+}
+
+enum bgp_display_type {
+	normal_list,
+};
+
+const char *bgp_path_selection_reason2str(enum bgp_path_selection_reason reason)
+{
+	switch (reason) {
+	case bgp_path_selection_none:
+		return "Nothing to Select";
+	case bgp_path_selection_first:
+		return "First path received";
+	case bgp_path_selection_evpn_sticky_mac:
+		return "EVPN Sticky Mac";
+	case bgp_path_selection_evpn_seq:
+		return "EVPN sequence number";
+	case bgp_path_selection_evpn_lower_ip:
+		return "EVPN lower IP";
+	case bgp_path_selection_evpn_local_path:
+		return "EVPN local ES path";
+	case bgp_path_selection_evpn_non_proxy:
+		return "EVPN non proxy";
+	case bgp_path_selection_weight:
+		return "Weight";
+	case bgp_path_selection_local_pref:
+		return "Local Pref";
+	case bgp_path_selection_accept_own:
+		return "Accept Own";
+	case bgp_path_selection_local_route:
+		return "Local Route";
+	case bgp_path_selection_aigp:
+		return "AIGP";
+	case bgp_path_selection_confed_as_path:
+		return "Confederation based AS Path";
+	case bgp_path_selection_as_path:
+		return "AS Path";
+	case bgp_path_selection_origin:
+		return "Origin";
+	case bgp_path_selection_med:
+		return "MED";
+	case bgp_path_selection_peer:
+		return "Peer Type";
+	case bgp_path_selection_confed:
+		return "Confed Peer Type";
+	case bgp_path_selection_igp_metric:
+		return "IGP Metric";
+	case bgp_path_selection_older:
+		return "Older Path";
+	case bgp_path_selection_router_id:
+		return "Router ID";
+	case bgp_path_selection_cluster_length:
+		return "Cluster length";
+	case bgp_path_selection_stale:
+		return "Path Staleness";
+	case bgp_path_selection_local_configured:
+		return "Locally configured route";
+	case bgp_path_selection_neighbor_ip:
+		return "Neighbor IP";
+	case bgp_path_selection_default:
+		return "Nothing left to compare";
+	}
+	return "Invalid (internal error)";
+}
+
+/* Print the short form route status for a bgp_path_info */
+static void route_vty_short_status_out(struct vty *vty,
+				       struct bgp_path_info *path,
+				       const struct prefix *p,
+				       json_object *json_path)
+{
+	enum rpki_states rpki_state = RPKI_NOT_BEING_USED;
+
+	if (json_path) {
+
+		/* Route status display. */
+		if (CHECK_FLAG(path->flags, BGP_PATH_REMOVED))
+			json_object_boolean_true_add(json_path, "removed");
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_STALE))
+			json_object_boolean_true_add(json_path, "stale");
+
+		if (path->extra && bgp_path_suppressed(path))
+			json_object_boolean_true_add(json_path, "suppressed");
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_VALID)
+		    && !CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+			json_object_boolean_true_add(json_path, "valid");
+
+		/* Selected */
+		if (CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+			json_object_boolean_true_add(json_path, "history");
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_DAMPED))
+			json_object_boolean_true_add(json_path, "damped");
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED)) {
+			json_object_boolean_true_add(json_path, "bestpath");
+			json_object_string_add(json_path, "selectionReason",
+					       bgp_path_selection_reason2str(
+						       path->net->reason));
+		}
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_MULTIPATH))
+			json_object_boolean_true_add(json_path, "multipath");
+
+		/* Internal route. */
+		if ((path->peer->as)
+		    && (path->peer->as == path->peer->local_as))
+			json_object_string_add(json_path, "pathFrom",
+					       "internal");
+		else
+			json_object_string_add(json_path, "pathFrom",
+					       "external");
+
+		return;
+	}
+
+	/* RPKI validation state */
+	rpki_state =
+		hook_call(bgp_rpki_prefix_status, path->peer, path->attr, p);
+
+	if (rpki_state == RPKI_VALID)
+		vty_out(vty, "V");
+	else if (rpki_state == RPKI_INVALID)
+		vty_out(vty, "I");
+	else if (rpki_state == RPKI_NOTFOUND)
+		vty_out(vty, "N");
+	else
+		vty_out(vty, " ");
+
+	/* Route status display. */
+	if (CHECK_FLAG(path->flags, BGP_PATH_REMOVED))
+		vty_out(vty, "R");
+	else if (CHECK_FLAG(path->flags, BGP_PATH_STALE))
+		vty_out(vty, "S");
+	else if (bgp_path_suppressed(path))
+		vty_out(vty, "s");
+	else if (CHECK_FLAG(path->flags, BGP_PATH_VALID)
+		 && !CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+		vty_out(vty, "*");
+	else
+		vty_out(vty, " ");
+
+	/* Selected */
+	if (CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+		vty_out(vty, "h");
+	else if (CHECK_FLAG(path->flags, BGP_PATH_DAMPED))
+		vty_out(vty, "d");
+	else if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
+		vty_out(vty, ">");
+	else if (CHECK_FLAG(path->flags, BGP_PATH_MULTIPATH))
+		vty_out(vty, "=");
+	else
+		vty_out(vty, " ");
+
+	/* Internal route. */
+	if (path->peer && (path->peer->as)
+	    && (path->peer->as == path->peer->local_as))
+		vty_out(vty, "i");
+	else
+		vty_out(vty, " ");
+}
+
+static char *bgp_nexthop_hostname(struct peer *peer,
+				  struct bgp_nexthop_cache *bnc)
+{
+	if (peer->hostname
+	    && CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHOW_NEXTHOP_HOSTNAME))
+		return peer->hostname;
+	return NULL;
+}
+
+/* called from terminal list command */
+void route_vty_out(struct vty *vty, const struct prefix *p,
+		   struct bgp_path_info *path, int display, safi_t safi,
+		   json_object *json_paths, bool wide)
+{
+	int len;
+	struct attr *attr = path->attr;
+	json_object *json_path = NULL;
+	json_object *json_nexthops = NULL;
+	json_object *json_nexthop_global = NULL;
+	json_object *json_nexthop_ll = NULL;
+	json_object *json_ext_community = NULL;
+	char vrf_id_str[VRF_NAMSIZ] = {0};
+	bool nexthop_self =
+		CHECK_FLAG(path->flags, BGP_PATH_ANNC_NH_SELF) ? true : false;
+	bool nexthop_othervrf = false;
+	vrf_id_t nexthop_vrfid = VRF_DEFAULT;
+	const char *nexthop_vrfname = VRF_DEFAULT_NAME;
+	char *nexthop_hostname =
+		bgp_nexthop_hostname(path->peer, path->nexthop);
+	char esi_buf[ESI_STR_LEN];
+
+	if (json_paths)
+		json_path = json_object_new_object();
+
+	/* short status lead text */
+	route_vty_short_status_out(vty, path, p, json_path);
+
+	if (!json_paths) {
+		/* print prefix and mask */
+		if (!display)
+			route_vty_out_route(path->net, p, vty, json_path, wide);
+		else
+			vty_out(vty, "%*s", (wide ? 45 : 17), " ");
+	} else {
+		route_vty_out_route(path->net, p, vty, json_path, wide);
+	}
+
+	/*
+	 * If vrf id of nexthop is different from that of prefix,
+	 * set up printable string to append
+	 */
+	if (path->extra && path->extra->vrfleak &&
+	    path->extra->vrfleak->bgp_orig) {
+		const char *self = "";
+
+		if (nexthop_self)
+			self = "<";
+
+		nexthop_othervrf = true;
+		nexthop_vrfid = path->extra->vrfleak->bgp_orig->vrf_id;
+
+		if (path->extra->vrfleak->bgp_orig->vrf_id == VRF_UNKNOWN)
+			snprintf(vrf_id_str, sizeof(vrf_id_str),
+				"@%s%s", VRFID_NONE_STR, self);
+		else
+			snprintf(vrf_id_str, sizeof(vrf_id_str), "@%u%s",
+				 path->extra->vrfleak->bgp_orig->vrf_id, self);
+
+		if (path->extra->vrfleak->bgp_orig->inst_type !=
+		    BGP_INSTANCE_TYPE_DEFAULT)
+
+			nexthop_vrfname = path->extra->vrfleak->bgp_orig->name;
+	} else {
+		const char *self = "";
+
+		if (nexthop_self)
+			self = "<";
+
+		snprintf(vrf_id_str, sizeof(vrf_id_str), "%s", self);
+	}
+
+	/*
+	 * For ENCAP and EVPN routes, nexthop address family is not
+	 * neccessarily the same as the prefix address family.
+	 * Both SAFI_MPLS_VPN and SAFI_ENCAP use the MP nexthop field
+	 * EVPN routes are also exchanged with a MP nexthop. Currently,
+	 * this
+	 * is only IPv4, the value will be present in either
+	 * attr->nexthop or
+	 * attr->mp_nexthop_global_in
+	 */
+	if ((safi == SAFI_ENCAP) || (safi == SAFI_MPLS_VPN)) {
+		char nexthop[128];
+		int af = NEXTHOP_FAMILY(attr->mp_nexthop_len);
+
+		switch (af) {
+		case AF_INET:
+			snprintfrr(nexthop, sizeof(nexthop), "%pI4",
+				   &attr->mp_nexthop_global_in);
+			break;
+		case AF_INET6:
+			snprintfrr(nexthop, sizeof(nexthop), "%pI6",
+				   &attr->mp_nexthop_global);
+			break;
+		default:
+			snprintf(nexthop, sizeof(nexthop), "?");
+			break;
+		}
+
+		if (json_paths) {
+			json_nexthop_global = json_object_new_object();
+
+			json_object_string_add(json_nexthop_global, "ip",
+					       nexthop);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_global,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_global, "afi",
+					       (af == AF_INET) ? "ipv4"
+							       : "ipv6");
+			json_object_boolean_true_add(json_nexthop_global,
+						     "used");
+		} else {
+			if (nexthop_hostname)
+				len = vty_out(vty, "%s(%s)%s", nexthop,
+					      nexthop_hostname, vrf_id_str);
+			else
+				len = vty_out(vty, "%s%s", nexthop, vrf_id_str);
+
+			len = wide ? (41 - len) : (16 - len);
+			if (len < 1)
+				vty_out(vty, "\n%*s", 36, " ");
+			else
+				vty_out(vty, "%*s", len, " ");
+		}
+	} else if (safi == SAFI_EVPN) {
+		if (json_paths) {
+			json_nexthop_global = json_object_new_object();
+
+			json_object_string_addf(json_nexthop_global, "ip",
+						"%pI4",
+						&attr->mp_nexthop_global_in);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_global,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_global, "afi",
+					       "ipv4");
+			json_object_boolean_true_add(json_nexthop_global,
+						     "used");
+		} else {
+			if (nexthop_hostname)
+				len = vty_out(vty, "%pI4(%s)%s",
+					      &attr->mp_nexthop_global_in,
+					      nexthop_hostname, vrf_id_str);
+			else
+				len = vty_out(vty, "%pI4%s",
+					      &attr->mp_nexthop_global_in,
+					      vrf_id_str);
+
+			len = wide ? (41 - len) : (16 - len);
+			if (len < 1)
+				vty_out(vty, "\n%*s", 36, " ");
+			else
+				vty_out(vty, "%*s", len, " ");
+		}
+	} else if (safi == SAFI_FLOWSPEC) {
+		if (attr->nexthop.s_addr != INADDR_ANY) {
+			if (json_paths) {
+				json_nexthop_global = json_object_new_object();
+
+				json_object_string_add(json_nexthop_global,
+						       "afi", "ipv4");
+				json_object_string_addf(json_nexthop_global,
+							"ip", "%pI4",
+							&attr->nexthop);
+
+				if (path->peer->hostname)
+					json_object_string_add(
+						json_nexthop_global, "hostname",
+						path->peer->hostname);
+
+				json_object_boolean_true_add(
+							json_nexthop_global,
+							     "used");
+			} else {
+				if (nexthop_hostname)
+					len = vty_out(vty, "%pI4(%s)%s",
+						      &attr->nexthop,
+						      nexthop_hostname,
+						      vrf_id_str);
+				else
+					len = vty_out(vty, "%pI4%s",
+						      &attr->nexthop,
+						      vrf_id_str);
+
+				len = wide ? (41 - len) : (16 - len);
+				if (len < 1)
+					vty_out(vty, "\n%*s", 36, " ");
+				else
+					vty_out(vty, "%*s", len, " ");
+			}
+		}
+	} else if (p->family == AF_INET && !BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr)) {
+		if (json_paths) {
+			json_nexthop_global = json_object_new_object();
+
+			json_object_string_addf(json_nexthop_global, "ip",
+						"%pI4", &attr->nexthop);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_global,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_global, "afi",
+					       "ipv4");
+			json_object_boolean_true_add(json_nexthop_global,
+						     "used");
+		} else {
+			if (nexthop_hostname)
+				len = vty_out(vty, "%pI4(%s)%s", &attr->nexthop,
+					      nexthop_hostname, vrf_id_str);
+			else
+				len = vty_out(vty, "%pI4%s", &attr->nexthop,
+					      vrf_id_str);
+
+			len = wide ? (41 - len) : (16 - len);
+			if (len < 1)
+				vty_out(vty, "\n%*s", 36, " ");
+			else
+				vty_out(vty, "%*s", len, " ");
+		}
+	}
+
+	/* IPv6 Next Hop */
+	else if (p->family == AF_INET6 || BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr)) {
+		if (json_paths) {
+			json_nexthop_global = json_object_new_object();
+			json_object_string_addf(json_nexthop_global, "ip",
+						"%pI6",
+						&attr->mp_nexthop_global);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_global,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_global, "afi",
+					       "ipv6");
+			json_object_string_add(json_nexthop_global, "scope",
+					       "global");
+
+			/* We display both LL & GL if both have been
+			 * received */
+			if ((attr->mp_nexthop_len
+			     == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
+			    || (path->peer->conf_if)) {
+				json_nexthop_ll = json_object_new_object();
+				json_object_string_addf(
+					json_nexthop_ll, "ip", "%pI6",
+					&attr->mp_nexthop_local);
+
+				if (path->peer->hostname)
+					json_object_string_add(
+						json_nexthop_ll, "hostname",
+						path->peer->hostname);
+
+				json_object_string_add(json_nexthop_ll, "afi",
+						       "ipv6");
+				json_object_string_add(json_nexthop_ll, "scope",
+						       "link-local");
+
+				if ((IPV6_ADDR_CMP(&attr->mp_nexthop_global,
+						   &attr->mp_nexthop_local)
+				     != 0)
+				    && !attr->mp_nexthop_prefer_global)
+					json_object_boolean_true_add(
+						json_nexthop_ll, "used");
+				else
+					json_object_boolean_true_add(
+						json_nexthop_global, "used");
+			} else
+				json_object_boolean_true_add(
+					json_nexthop_global, "used");
+		} else {
+			/* Display LL if LL/Global both in table unless
+			 * prefer-global is set */
+			if (((attr->mp_nexthop_len
+			      == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL)
+			     && !attr->mp_nexthop_prefer_global)
+			    || (path->peer->conf_if)) {
+				if (path->peer->conf_if) {
+					len = vty_out(vty, "%s",
+						      path->peer->conf_if);
+					/* len of IPv6 addr + max len of def
+					 * ifname */
+					len = wide ? (41 - len) : (16 - len);
+
+					if (len < 1)
+						vty_out(vty, "\n%*s", 36, " ");
+					else
+						vty_out(vty, "%*s", len, " ");
+				} else {
+					if (nexthop_hostname)
+						len = vty_out(
+							vty, "%pI6(%s)%s",
+							&attr->mp_nexthop_local,
+							nexthop_hostname,
+							vrf_id_str);
+					else
+						len = vty_out(
+							vty, "%pI6%s",
+							&attr->mp_nexthop_local,
+							vrf_id_str);
+
+					len = wide ? (41 - len) : (16 - len);
+
+					if (len < 1)
+						vty_out(vty, "\n%*s", 36, " ");
+					else
+						vty_out(vty, "%*s", len, " ");
+				}
+			} else {
+				if (nexthop_hostname)
+					len = vty_out(vty, "%pI6(%s)%s",
+						      &attr->mp_nexthop_global,
+						      nexthop_hostname,
+						      vrf_id_str);
+				else
+					len = vty_out(vty, "%pI6%s",
+						      &attr->mp_nexthop_global,
+						      vrf_id_str);
+
+				len = wide ? (41 - len) : (16 - len);
+
+				if (len < 1)
+					vty_out(vty, "\n%*s", 36, " ");
+				else
+					vty_out(vty, "%*s", len, " ");
+			}
+		}
+	}
+
+	/* MED/Metric */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
+		if (json_paths)
+			json_object_int_add(json_path, "metric", attr->med);
+		else if (wide)
+			vty_out(vty, "%7u", attr->med);
+		else
+			vty_out(vty, "%10u", attr->med);
+	else if (!json_paths) {
+		if (wide)
+			vty_out(vty, "%*s", 7, " ");
+		else
+			vty_out(vty, "%*s", 10, " ");
+	}
+
+	/* Local Pref */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
+		if (json_paths)
+			json_object_int_add(json_path, "locPrf",
+					    attr->local_pref);
+		else
+			vty_out(vty, "%7u", attr->local_pref);
+	else if (!json_paths)
+		vty_out(vty, "       ");
+
+	if (json_paths)
+		json_object_int_add(json_path, "weight", attr->weight);
+	else
+		vty_out(vty, "%7u ", attr->weight);
+
+	if (json_paths)
+		json_object_string_addf(json_path, "peerId", "%pSU",
+					&path->peer->connection->su);
+
+	/* Print aspath */
+	if (attr->aspath) {
+		if (json_paths)
+			json_object_string_add(json_path, "path",
+					       attr->aspath->str);
+		else
+			aspath_print_vty(vty, attr->aspath);
+	}
+
+	/* Print origin */
+	if (json_paths)
+		json_object_string_add(json_path, "origin",
+				       bgp_origin_long_str[attr->origin]);
+	else
+		vty_out(vty, "%s", bgp_origin_str[attr->origin]);
+
+	if (json_paths) {
+		if (bgp_evpn_is_esi_valid(&attr->esi)) {
+			json_object_string_add(json_path, "esi",
+					esi_to_str(&attr->esi,
+					esi_buf, sizeof(esi_buf)));
+		}
+		if (safi == SAFI_EVPN &&
+		    attr->flag & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) {
+			json_ext_community = json_object_new_object();
+			json_object_string_add(
+				json_ext_community, "string",
+				bgp_attr_get_ecommunity(attr)->str);
+			json_object_object_add(json_path,
+					       "extendedCommunity",
+					       json_ext_community);
+		}
+
+		if (nexthop_self)
+			json_object_boolean_true_add(json_path,
+				"announceNexthopSelf");
+		if (nexthop_othervrf) {
+			json_object_string_add(json_path, "nhVrfName",
+				nexthop_vrfname);
+
+			json_object_int_add(json_path, "nhVrfId",
+				((nexthop_vrfid == VRF_UNKNOWN)
+					? -1
+					: (int)nexthop_vrfid));
+		}
+	}
+
+	if (json_paths) {
+		if (json_nexthop_global || json_nexthop_ll) {
+			json_nexthops = json_object_new_array();
+
+			if (json_nexthop_global)
+				json_object_array_add(json_nexthops,
+						      json_nexthop_global);
+
+			if (json_nexthop_ll)
+				json_object_array_add(json_nexthops,
+						      json_nexthop_ll);
+
+			json_object_object_add(json_path, "nexthops",
+					       json_nexthops);
+		}
+
+		json_object_array_add(json_paths, json_path);
+	} else {
+		vty_out(vty, "\n");
+
+		if (safi == SAFI_EVPN) {
+			if (bgp_evpn_is_esi_valid(&attr->esi)) {
+				/* XXX - add these params to the json out */
+				vty_out(vty, "%*s", 20, " ");
+				vty_out(vty, "ESI:%s",
+					esi_to_str(&attr->esi, esi_buf,
+						   sizeof(esi_buf)));
+
+				vty_out(vty, "\n");
+			}
+			if (attr->flag &
+				ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) {
+				vty_out(vty, "%*s", 20, " ");
+				vty_out(vty, "%s\n",
+					bgp_attr_get_ecommunity(attr)->str);
+			}
+		}
+
+#ifdef ENABLE_BGP_VNC
+		/* prints an additional line, indented, with VNC info, if
+		 * present */
+		if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP))
+			rfapi_vty_out_vncinfo(vty, p, path, safi);
+#endif
+	}
+}
+
+/* called from terminal list command */
+void route_vty_out_tmp(struct vty *vty, struct bgp_dest *dest,
+		       const struct prefix *p, struct attr *attr, safi_t safi,
+		       bool use_json, json_object *json_ar, bool wide)
+{
+	json_object *json_status = NULL;
+	json_object *json_net = NULL;
+	int len;
+	char buff[BUFSIZ];
+
+	/* Route status display. */
+	if (use_json) {
+		json_status = json_object_new_object();
+		json_net = json_object_new_object();
+	} else {
+		vty_out(vty, " *");
+		vty_out(vty, ">");
+		vty_out(vty, " ");
+	}
+
+	/* print prefix and mask */
+	if (use_json) {
+		if (safi == SAFI_EVPN)
+			bgp_evpn_route2json((struct prefix_evpn *)p, json_net);
+		else if (p->family == AF_INET || p->family == AF_INET6) {
+			json_object_string_add(
+				json_net, "addrPrefix",
+				inet_ntop(p->family, &p->u.prefix, buff,
+				BUFSIZ));
+			json_object_int_add(json_net, "prefixLen",
+				p->prefixlen);
+			json_object_string_addf(json_net, "network", "%pFX", p);
+		}
+	} else
+		route_vty_out_route(dest, p, vty, NULL, wide);
+
+	/* Print attribute */
+	if (attr) {
+		if (use_json) {
+			if (p->family == AF_INET &&
+			    (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP ||
+			     !BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+				if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP)
+					json_object_string_addf(
+						json_net, "nextHop", "%pI4",
+						&attr->mp_nexthop_global_in);
+				else
+					json_object_string_addf(
+						json_net, "nextHop", "%pI4",
+						&attr->nexthop);
+			} else if (p->family == AF_INET6 ||
+				   BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr)) {
+				json_object_string_addf(
+					json_net, "nextHopGlobal", "%pI6",
+					&attr->mp_nexthop_global);
+			} else if (p->family == AF_EVPN &&
+				   !BGP_ATTR_NEXTHOP_AFI_IP6(attr)) {
+				json_object_string_addf(
+					json_net, "nextHop", "%pI4",
+					&attr->mp_nexthop_global_in);
+			}
+
+			if (attr->flag
+			    & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
+				json_object_int_add(json_net, "metric",
+						    attr->med);
+
+			if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
+				json_object_int_add(json_net, "locPrf",
+						    attr->local_pref);
+
+			json_object_int_add(json_net, "weight", attr->weight);
+
+			/* Print aspath */
+			if (attr->aspath)
+				json_object_string_add(json_net, "path",
+						       attr->aspath->str);
+
+			/* Print origin */
+#if CONFDATE > 20231208
+CPP_NOTICE("Drop `bgpOriginCodes` from JSON outputs")
+#endif
+			json_object_string_add(json_net, "bgpOriginCode",
+					       bgp_origin_str[attr->origin]);
+			json_object_string_add(
+				json_net, "origin",
+				bgp_origin_long_str[attr->origin]);
+		} else {
+			if (p->family == AF_INET &&
+			    (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP ||
+			     safi == SAFI_EVPN ||
+			     !BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+				if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP
+				    || safi == SAFI_EVPN)
+					vty_out(vty, "%-16pI4",
+						&attr->mp_nexthop_global_in);
+				else if (wide)
+					vty_out(vty, "%-41pI4", &attr->nexthop);
+				else
+					vty_out(vty, "%-16pI4", &attr->nexthop);
+			} else if (p->family == AF_INET6 ||
+				   BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr)) {
+				len = vty_out(vty, "%pI6",
+					      &attr->mp_nexthop_global);
+				len = wide ? (41 - len) : (16 - len);
+				if (len < 1)
+					vty_out(vty, "\n%*s", 36, " ");
+				else
+					vty_out(vty, "%*s", len, " ");
+			}
+			if (attr->flag
+			    & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))
+				if (wide)
+					vty_out(vty, "%7u", attr->med);
+				else
+					vty_out(vty, "%10u", attr->med);
+			else if (wide)
+				vty_out(vty, "       ");
+			else
+				vty_out(vty, "          ");
+
+			if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))
+				vty_out(vty, "%7u", attr->local_pref);
+			else
+				vty_out(vty, "       ");
+
+			vty_out(vty, "%7u ", attr->weight);
+
+			/* Print aspath */
+			if (attr->aspath)
+				aspath_print_vty(vty, attr->aspath);
+
+			/* Print origin */
+			vty_out(vty, "%s", bgp_origin_str[attr->origin]);
+		}
+	}
+	if (use_json) {
+		struct bgp_path_info *bpi = bgp_dest_get_bgp_path_info(dest);
+
+#if CONFDATE > 20231208
+CPP_NOTICE("Drop `bgpStatusCodes` from JSON outputs")
+#endif
+		json_object_boolean_true_add(json_status, "*");
+		json_object_boolean_true_add(json_status, ">");
+		json_object_boolean_true_add(json_net, "valid");
+		json_object_boolean_true_add(json_net, "best");
+
+		if (bpi && CHECK_FLAG(bpi->flags, BGP_PATH_MULTIPATH)) {
+			json_object_boolean_true_add(json_status, "=");
+			json_object_boolean_true_add(json_net, "multipath");
+		}
+		json_object_object_add(json_net, "appliedStatusSymbols",
+				       json_status);
+		json_object_object_addf(json_ar, json_net, "%pFX", p);
+	} else
+		vty_out(vty, "\n");
+}
+
+void route_vty_out_tag(struct vty *vty, const struct prefix *p,
+		       struct bgp_path_info *path, int display, safi_t safi,
+		       json_object *json)
+{
+	json_object *json_out = NULL;
+	struct attr *attr;
+	mpls_label_t label = MPLS_INVALID_LABEL;
+
+	if (!path->extra)
+		return;
+
+	if (json)
+		json_out = json_object_new_object();
+
+	/* short status lead text */
+	route_vty_short_status_out(vty, path, p, json_out);
+
+	/* print prefix and mask */
+	if (json == NULL) {
+		if (!display)
+			route_vty_out_route(path->net, p, vty, NULL, false);
+		else
+			vty_out(vty, "%*s", 17, " ");
+	}
+
+	/* Print attribute */
+	attr = path->attr;
+	if (((p->family == AF_INET) &&
+	     ((safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP))) ||
+	    (safi == SAFI_EVPN && !BGP_ATTR_NEXTHOP_AFI_IP6(attr)) ||
+	    (!BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+		if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP
+		    || safi == SAFI_EVPN) {
+			if (json)
+				json_object_string_addf(
+					json_out, "mpNexthopGlobalIn", "%pI4",
+					&attr->mp_nexthop_global_in);
+			else
+				vty_out(vty, "%-16pI4",
+					&attr->mp_nexthop_global_in);
+		} else {
+			if (json)
+				json_object_string_addf(json_out, "nexthop",
+							"%pI4", &attr->nexthop);
+			else
+				vty_out(vty, "%-16pI4", &attr->nexthop);
+		}
+	} else if (((p->family == AF_INET6) &&
+		    ((safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP))) ||
+		   (safi == SAFI_EVPN && BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr)) ||
+		   (BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+		char buf_a[512];
+
+		if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) {
+			if (json)
+				json_object_string_addf(
+					json_out, "mpNexthopGlobalIn", "%pI6",
+					&attr->mp_nexthop_global);
+			else
+				vty_out(vty, "%s",
+					inet_ntop(AF_INET6,
+						  &attr->mp_nexthop_global,
+						  buf_a, sizeof(buf_a)));
+		} else if (attr->mp_nexthop_len
+			   == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
+			snprintfrr(buf_a, sizeof(buf_a), "%pI6(%pI6)",
+				   &attr->mp_nexthop_global,
+				   &attr->mp_nexthop_local);
+			if (json)
+				json_object_string_add(json_out,
+						       "mpNexthopGlobalLocal",
+						       buf_a);
+			else
+				vty_out(vty, "%s", buf_a);
+		}
+	}
+
+	if (bgp_is_valid_label(&path->extra->label[0])) {
+		label = decode_label(&path->extra->label[0]);
+		if (json) {
+			json_object_int_add(json_out, "notag", label);
+			json_object_array_add(json, json_out);
+		} else {
+			vty_out(vty, "notag/%d", label);
+			vty_out(vty, "\n");
+		}
+	} else if (!json)
+		vty_out(vty, "\n");
+}
+
+void route_vty_out_overlay(struct vty *vty, const struct prefix *p,
+			   struct bgp_path_info *path, int display,
+			   json_object *json_paths)
+{
+	struct attr *attr;
+	json_object *json_path = NULL;
+	json_object *json_nexthop = NULL;
+	json_object *json_overlay = NULL;
+
+	if (!path->extra)
+		return;
+
+	if (json_paths) {
+		json_path = json_object_new_object();
+		json_overlay = json_object_new_object();
+		json_nexthop = json_object_new_object();
+	}
+
+	/* short status lead text */
+	route_vty_short_status_out(vty, path, p, json_path);
+
+	/* print prefix and mask */
+	if (!display)
+		route_vty_out_route(path->net, p, vty, json_path, false);
+	else
+		vty_out(vty, "%*s", 17, " ");
+
+	/* Print attribute */
+	attr = path->attr;
+	int af = NEXTHOP_FAMILY(attr->mp_nexthop_len);
+
+	switch (af) {
+	case AF_INET:
+		if (!json_path) {
+			vty_out(vty, "%-16pI4", &attr->mp_nexthop_global_in);
+		} else {
+			json_object_string_addf(json_nexthop, "ip", "%pI4",
+						&attr->mp_nexthop_global_in);
+
+			json_object_string_add(json_nexthop, "afi", "ipv4");
+
+			json_object_object_add(json_path, "nexthop",
+					       json_nexthop);
+		}
+		break;
+	case AF_INET6:
+		if (!json_path) {
+			vty_out(vty, "%pI6(%pI6)", &attr->mp_nexthop_global,
+				&attr->mp_nexthop_local);
+		} else {
+			json_object_string_addf(json_nexthop, "ipv6Global",
+						"%pI6",
+						&attr->mp_nexthop_global);
+
+			json_object_string_addf(json_nexthop, "ipv6LinkLocal",
+						"%pI6",
+						&attr->mp_nexthop_local);
+
+			json_object_string_add(json_nexthop, "afi", "ipv6");
+
+			json_object_object_add(json_path, "nexthop",
+					       json_nexthop);
+		}
+		break;
+	default:
+		if (!json_path) {
+			vty_out(vty, "?");
+		} else {
+			json_object_string_add(json_nexthop, "error",
+					       "Unsupported address-family");
+		}
+	}
+
+	const struct bgp_route_evpn *eo = bgp_attr_get_evpn_overlay(attr);
+
+	if (!json_path)
+		vty_out(vty, "/%pIA", &eo->gw_ip);
+	else
+		json_object_string_addf(json_overlay, "gw", "%pIA", &eo->gw_ip);
+
+	if (bgp_attr_get_ecommunity(attr)) {
+		char *mac = NULL;
+		struct ecommunity_val *routermac = ecommunity_lookup(
+			bgp_attr_get_ecommunity(attr), ECOMMUNITY_ENCODE_EVPN,
+			ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC);
+
+		if (routermac)
+			mac = ecom_mac2str((char *)routermac->val);
+		if (mac) {
+			if (!json_path) {
+				vty_out(vty, "/%s", mac);
+			} else {
+				json_object_string_add(json_overlay, "rmac",
+						       mac);
+			}
+			XFREE(MTYPE_TMP, mac);
+		}
+	}
+
+	if (!json_path) {
+		vty_out(vty, "\n");
+	} else {
+		json_object_object_add(json_path, "overlay", json_overlay);
+
+		json_object_array_add(json_paths, json_path);
+	}
+}
+
+/* dampening route */
+static void damp_route_vty_out(struct vty *vty, const struct prefix *p,
+			       struct bgp_path_info *path, int display,
+			       afi_t afi, safi_t safi, bool use_json,
+			       json_object *json_paths)
+{
+	struct attr *attr = path->attr;
+	int len;
+	char timebuf[BGP_UPTIME_LEN] = {};
+	json_object *json_path = NULL;
+
+	if (use_json)
+		json_path = json_object_new_object();
+
+	/* short status lead text */
+	route_vty_short_status_out(vty, path, p, json_path);
+
+	/* print prefix and mask */
+	if (!use_json) {
+		if (!display)
+			route_vty_out_route(path->net, p, vty, NULL, false);
+		else
+			vty_out(vty, "%*s", 17, " ");
+
+		len = vty_out(vty, "%s", path->peer->host);
+		len = 17 - len;
+
+		if (len < 1)
+			vty_out(vty, "\n%*s", 34, " ");
+		else
+			vty_out(vty, "%*s", len, " ");
+
+		vty_out(vty, "%s ",
+			bgp_damp_reuse_time_vty(vty, path, timebuf,
+						BGP_UPTIME_LEN, afi, safi,
+						use_json, NULL));
+
+		if (attr->aspath)
+			aspath_print_vty(vty, attr->aspath);
+
+		vty_out(vty, "%s", bgp_origin_str[attr->origin]);
+
+		vty_out(vty, "\n");
+	} else {
+		bgp_damp_reuse_time_vty(vty, path, timebuf, BGP_UPTIME_LEN, afi,
+					safi, use_json, json_path);
+
+		if (attr->aspath)
+			json_object_string_add(json_path, "asPath",
+					       attr->aspath->str);
+
+		json_object_string_add(json_path, "origin",
+				       bgp_origin_str[attr->origin]);
+		json_object_string_add(json_path, "peerHost", path->peer->host);
+
+		json_object_array_add(json_paths, json_path);
+	}
+}
+
+/* flap route */
+static void flap_route_vty_out(struct vty *vty, const struct prefix *p,
+			       struct bgp_path_info *path, int display,
+			       afi_t afi, safi_t safi, bool use_json,
+			       json_object *json_paths)
+{
+	struct attr *attr = path->attr;
+	struct bgp_damp_info *bdi;
+	char timebuf[BGP_UPTIME_LEN] = {};
+	int len;
+	json_object *json_path = NULL;
+
+	if (!path->extra)
+		return;
+
+	if (use_json)
+		json_path = json_object_new_object();
+
+	bdi = path->extra->damp_info;
+
+	/* short status lead text */
+	route_vty_short_status_out(vty, path, p, json_path);
+
+	if (!use_json) {
+		if (!display)
+			route_vty_out_route(path->net, p, vty, NULL, false);
+		else
+			vty_out(vty, "%*s", 17, " ");
+
+		len = vty_out(vty, "%s", path->peer->host);
+		len = 16 - len;
+		if (len < 1)
+			vty_out(vty, "\n%*s", 33, " ");
+		else
+			vty_out(vty, "%*s", len, " ");
+
+		len = vty_out(vty, "%d", bdi->flap);
+		len = 5 - len;
+		if (len < 1)
+			vty_out(vty, " ");
+		else
+			vty_out(vty, "%*s", len, " ");
+
+		vty_out(vty, "%s ", peer_uptime(bdi->start_time, timebuf,
+						BGP_UPTIME_LEN, 0, NULL));
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_DAMPED)
+		    && !CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+			vty_out(vty, "%s ",
+				bgp_damp_reuse_time_vty(vty, path, timebuf,
+							BGP_UPTIME_LEN, afi,
+							safi, use_json, NULL));
+		else
+			vty_out(vty, "%*s ", 8, " ");
+
+		if (attr->aspath)
+			aspath_print_vty(vty, attr->aspath);
+
+		vty_out(vty, "%s", bgp_origin_str[attr->origin]);
+
+		vty_out(vty, "\n");
+	} else {
+		json_object_string_add(json_path, "peerHost", path->peer->host);
+		json_object_int_add(json_path, "bdiFlap", bdi->flap);
+
+		peer_uptime(bdi->start_time, timebuf, BGP_UPTIME_LEN, use_json,
+			    json_path);
+
+		if (CHECK_FLAG(path->flags, BGP_PATH_DAMPED)
+		    && !CHECK_FLAG(path->flags, BGP_PATH_HISTORY))
+			bgp_damp_reuse_time_vty(vty, path, timebuf,
+						BGP_UPTIME_LEN, afi, safi,
+						use_json, json_path);
+
+		if (attr->aspath)
+			json_object_string_add(json_path, "asPath",
+					       attr->aspath->str);
+
+		json_object_string_add(json_path, "origin",
+				       bgp_origin_str[attr->origin]);
+
+		json_object_array_add(json_paths, json_path);
+	}
+}
+
+static void route_vty_out_advertised_to(struct vty *vty, struct peer *peer,
+					int *first, const char *header,
+					json_object *json_adv_to)
+{
+	json_object *json_peer = NULL;
+
+	if (json_adv_to) {
+		/* 'advertised-to' is a dictionary of peers we have advertised
+		 * this
+		 * prefix too.  The key is the peer's IP or swpX, the value is
+		 * the
+		 * hostname if we know it and "" if not.
+		 */
+		json_peer = json_object_new_object();
+
+		if (peer->hostname)
+			json_object_string_add(json_peer, "hostname",
+					       peer->hostname);
+
+		if (peer->conf_if)
+			json_object_object_add(json_adv_to, peer->conf_if,
+					       json_peer);
+		else
+			json_object_object_addf(json_adv_to, json_peer, "%pSU",
+						&peer->connection->su);
+	} else {
+		if (*first) {
+			vty_out(vty, "%s", header);
+			*first = 0;
+		}
+
+		if (peer->hostname
+		    && CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHOW_HOSTNAME)) {
+			if (peer->conf_if)
+				vty_out(vty, " %s(%s)", peer->hostname,
+					peer->conf_if);
+			else
+				vty_out(vty, " %s(%pSU)", peer->hostname,
+					&peer->connection->su);
+		} else {
+			if (peer->conf_if)
+				vty_out(vty, " %s", peer->conf_if);
+			else
+				vty_out(vty, " %pSU", &peer->connection->su);
+		}
+	}
+}
+
+static void route_vty_out_tx_ids(struct vty *vty,
+				 struct bgp_addpath_info_data *d)
+{
+	int i;
+
+	for (i = 0; i < BGP_ADDPATH_MAX; i++) {
+		vty_out(vty, "TX-%s %u%s", bgp_addpath_names(i)->human_name,
+			d->addpath_tx_id[i],
+			i < BGP_ADDPATH_MAX - 1 ? " " : "\n");
+	}
+}
+
+static void route_vty_out_detail_es_info(struct vty *vty,
+					 struct bgp_path_info *pi,
+					 struct attr *attr,
+					 json_object *json_path)
+{
+	char esi_buf[ESI_STR_LEN];
+	bool es_local = !!CHECK_FLAG(attr->es_flags, ATTR_ES_IS_LOCAL);
+	bool peer_router = !!CHECK_FLAG(attr->es_flags,
+			ATTR_ES_PEER_ROUTER);
+	bool peer_active = !!CHECK_FLAG(attr->es_flags,
+			ATTR_ES_PEER_ACTIVE);
+	bool peer_proxy = !!CHECK_FLAG(attr->es_flags,
+			ATTR_ES_PEER_PROXY);
+	esi_to_str(&attr->esi, esi_buf, sizeof(esi_buf));
+	if (json_path) {
+		json_object *json_es_info = NULL;
+
+		json_object_string_add(
+				json_path, "esi",
+				esi_buf);
+		if (es_local || bgp_evpn_attr_is_sync(attr)) {
+			json_es_info = json_object_new_object();
+			if (es_local)
+				json_object_boolean_true_add(
+						json_es_info, "localEs");
+			if (peer_active)
+				json_object_boolean_true_add(
+						json_es_info, "peerActive");
+			if (peer_proxy)
+				json_object_boolean_true_add(
+						json_es_info, "peerProxy");
+			if (peer_router)
+				json_object_boolean_true_add(
+						json_es_info, "peerRouter");
+			if (attr->mm_sync_seqnum)
+				json_object_int_add(
+						json_es_info, "peerSeq",
+						attr->mm_sync_seqnum);
+			json_object_object_add(
+					json_path, "es_info",
+					json_es_info);
+		}
+	} else {
+		if (bgp_evpn_attr_is_sync(attr))
+			vty_out(vty,
+					"      ESI %s %s peer-info: (%s%s%sMM: %d)\n",
+					esi_buf,
+					es_local ? "local-es":"",
+					peer_proxy ? "proxy " : "",
+					peer_active ? "active ":"",
+					peer_router ? "router ":"",
+					attr->mm_sync_seqnum);
+		else
+			vty_out(vty, "      ESI %s %s\n",
+					esi_buf,
+					es_local ? "local-es":"");
+	}
+}
+
+void route_vty_out_detail(struct vty *vty, struct bgp *bgp, struct bgp_dest *bn,
+			  const struct prefix *p, struct bgp_path_info *path,
+			  afi_t afi, safi_t safi,
+			  enum rpki_states rpki_curr_state,
+			  json_object *json_paths)
+{
+	char buf[INET6_ADDRSTRLEN];
+	char tag_buf[30];
+	struct attr *attr = path->attr;
+	time_t tbuf;
+	char timebuf[32];
+	json_object *json_bestpath = NULL;
+	json_object *json_cluster_list = NULL;
+	json_object *json_cluster_list_list = NULL;
+	json_object *json_ext_community = NULL;
+	json_object *json_last_update = NULL;
+	json_object *json_pmsi = NULL;
+	json_object *json_nexthop_global = NULL;
+	json_object *json_nexthop_ll = NULL;
+	json_object *json_nexthops = NULL;
+	json_object *json_path = NULL;
+	json_object *json_peer = NULL;
+	json_object *json_string = NULL;
+	json_object *json_adv_to = NULL;
+	int first = 0;
+	struct listnode *node, *nnode;
+	struct peer *peer;
+	bool addpath_capable;
+	int has_adj;
+	unsigned int first_as;
+	bool nexthop_self =
+		CHECK_FLAG(path->flags, BGP_PATH_ANNC_NH_SELF) ? true : false;
+	int i;
+	char *nexthop_hostname =
+		bgp_nexthop_hostname(path->peer, path->nexthop);
+	uint32_t ttl = 0;
+	uint32_t bos = 0;
+	uint32_t exp = 0;
+	mpls_label_t label = MPLS_INVALID_LABEL;
+	tag_buf[0] = '\0';
+	struct bgp_path_info *bpi_ultimate =
+		bgp_get_imported_bpi_ultimate(path);
+
+	if (json_paths) {
+		json_path = json_object_new_object();
+		json_peer = json_object_new_object();
+		json_nexthop_global = json_object_new_object();
+	}
+
+	if (safi == SAFI_EVPN) {
+		if (!json_paths)
+			vty_out(vty, "  Route %pFX", p);
+	}
+
+	if (path->extra) {
+		if (path->extra && path->extra->num_labels) {
+			bgp_evpn_label2str(path->extra->label,
+					   path->extra->num_labels, tag_buf,
+					   sizeof(tag_buf));
+		}
+		if (safi == SAFI_EVPN) {
+			if (!json_paths) {
+				if (tag_buf[0] != '\0')
+					vty_out(vty, " VNI %s", tag_buf);
+			} else {
+				if (tag_buf[0])
+					json_object_string_add(json_path, "vni",
+							       tag_buf);
+			}
+		}
+	}
+
+	if (safi == SAFI_EVPN
+	    && attr->evpn_overlay.type == OVERLAY_INDEX_GATEWAY_IP) {
+		char gwip_buf[INET6_ADDRSTRLEN];
+
+		ipaddr2str(&attr->evpn_overlay.gw_ip, gwip_buf,
+			   sizeof(gwip_buf));
+
+		if (json_paths)
+			json_object_string_add(json_path, "gatewayIP",
+					       gwip_buf);
+		else
+			vty_out(vty, " Gateway IP %s", gwip_buf);
+	}
+
+	if (safi == SAFI_EVPN && !json_path)
+		vty_out(vty, "\n");
+
+
+	if (path->extra && path->extra->vrfleak &&
+	    path->extra->vrfleak->parent && !json_paths) {
+		struct bgp_path_info *parent_ri;
+		struct bgp_dest *dest, *pdest;
+
+		parent_ri =
+			(struct bgp_path_info *)path->extra->vrfleak->parent;
+		dest = parent_ri->net;
+		if (dest && dest->pdest) {
+			pdest = dest->pdest;
+			if (is_pi_family_evpn(parent_ri)) {
+				vty_out(vty, "  Imported from ");
+				vty_out(vty, BGP_RD_AS_FORMAT(bgp->asnotation),
+					(struct prefix_rd *)bgp_dest_get_prefix(
+						pdest));
+				vty_out(vty, ":%pFX, VNI %s",
+					(struct prefix_evpn *)
+						bgp_dest_get_prefix(dest),
+					tag_buf);
+				if (CHECK_FLAG(attr->es_flags, ATTR_ES_L3_NHG))
+					vty_out(vty, ", L3NHG %s",
+						CHECK_FLAG(
+							attr->es_flags,
+							ATTR_ES_L3_NHG_ACTIVE)
+							? "active"
+							: "inactive");
+				vty_out(vty, "\n");
+
+			} else {
+				vty_out(vty, "  Imported from ");
+				vty_out(vty, BGP_RD_AS_FORMAT(bgp->asnotation),
+					(struct prefix_rd *)bgp_dest_get_prefix(
+						pdest));
+				vty_out(vty, ":%pFX\n",
+					(struct prefix_evpn *)
+						bgp_dest_get_prefix(dest));
+			}
+		}
+	}
+
+	/* Line1 display AS-path, Aggregator */
+	if (attr->aspath) {
+		if (json_paths) {
+			if (!attr->aspath->json)
+				aspath_str_update(attr->aspath, true);
+			json_object_lock(attr->aspath->json);
+			json_object_object_add(json_path, "aspath",
+					       attr->aspath->json);
+		} else {
+			if (attr->aspath->segments)
+				vty_out(vty, "  %s", attr->aspath->str);
+			else
+				vty_out(vty, "  Local");
+		}
+	}
+
+	if (CHECK_FLAG(path->flags, BGP_PATH_REMOVED)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path, "removed");
+		else
+			vty_out(vty, ", (removed)");
+	}
+
+	if (CHECK_FLAG(path->flags, BGP_PATH_STALE)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path, "stale");
+		else
+			vty_out(vty, ", (stale)");
+	}
+
+	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR))) {
+		if (json_paths) {
+			json_object_int_add(json_path, "aggregatorAs",
+					    attr->aggregator_as);
+			json_object_string_addf(json_path, "aggregatorId",
+						"%pI4", &attr->aggregator_addr);
+		} else {
+			vty_out(vty, ", (aggregated by %u %pI4)",
+				attr->aggregator_as, &attr->aggregator_addr);
+		}
+	}
+
+	if (CHECK_FLAG(path->peer->af_flags[afi][safi],
+		       PEER_FLAG_REFLECTOR_CLIENT)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path,
+						     "rxedFromRrClient");
+		else
+			vty_out(vty, ", (Received from a RR-client)");
+	}
+
+	if (CHECK_FLAG(path->peer->af_flags[afi][safi],
+		       PEER_FLAG_RSERVER_CLIENT)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path,
+						     "rxedFromRsClient");
+		else
+			vty_out(vty, ", (Received from a RS-client)");
+	}
+
+	if (CHECK_FLAG(path->flags, BGP_PATH_HISTORY)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path,
+						     "dampeningHistoryEntry");
+		else
+			vty_out(vty, ", (history entry)");
+	} else if (CHECK_FLAG(path->flags, BGP_PATH_DAMPED)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path,
+						     "dampeningSuppressed");
+		else
+			vty_out(vty, ", (suppressed due to dampening)");
+	}
+
+	if (!json_paths)
+		vty_out(vty, "\n");
+
+	/* Line2 display Next-hop, Neighbor, Router-id */
+	/* Display the nexthop */
+
+	if ((p->family == AF_INET || p->family == AF_ETHERNET ||
+	     p->family == AF_EVPN) &&
+	    (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN ||
+	     !BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+		if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP
+		    || safi == SAFI_EVPN) {
+			if (json_paths) {
+				json_object_string_addf(
+					json_nexthop_global, "ip", "%pI4",
+					&attr->mp_nexthop_global_in);
+
+				if (path->peer->hostname)
+					json_object_string_add(
+						json_nexthop_global, "hostname",
+						path->peer->hostname);
+			} else {
+				if (nexthop_hostname)
+					vty_out(vty, "    %pI4(%s)",
+						&attr->mp_nexthop_global_in,
+						nexthop_hostname);
+				else
+					vty_out(vty, "    %pI4",
+						&attr->mp_nexthop_global_in);
+			}
+		} else {
+			if (json_paths) {
+				json_object_string_addf(json_nexthop_global,
+							"ip", "%pI4",
+							&attr->nexthop);
+
+				if (path->peer->hostname)
+					json_object_string_add(
+						json_nexthop_global, "hostname",
+						path->peer->hostname);
+			} else {
+				if (nexthop_hostname)
+					vty_out(vty, "    %pI4(%s)",
+						&attr->nexthop,
+						nexthop_hostname);
+				else
+					vty_out(vty, "    %pI4",
+						&attr->nexthop);
+			}
+		}
+
+		if (json_paths)
+			json_object_string_add(json_nexthop_global, "afi",
+					       "ipv4");
+	} else {
+		if (json_paths) {
+			json_object_string_addf(json_nexthop_global, "ip",
+						"%pI6",
+						&attr->mp_nexthop_global);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_global,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_global, "afi",
+					       "ipv6");
+			json_object_string_add(json_nexthop_global, "scope",
+					       "global");
+		} else {
+			if (nexthop_hostname)
+				vty_out(vty, "    %pI6(%s)",
+					&attr->mp_nexthop_global,
+					nexthop_hostname);
+			else
+				vty_out(vty, "    %pI6",
+					&attr->mp_nexthop_global);
+		}
+	}
+
+	/* Display the IGP cost or 'inaccessible' */
+	if (!CHECK_FLAG(bpi_ultimate->flags, BGP_PATH_VALID)) {
+		bool import = CHECK_FLAG(bgp->flags, BGP_FLAG_IMPORT_CHECK);
+
+		if (json_paths) {
+			json_object_boolean_false_add(json_nexthop_global,
+						      "accessible");
+			json_object_boolean_add(json_nexthop_global,
+						"importCheckEnabled", import);
+		} else {
+			vty_out(vty, " (inaccessible%s)",
+				import ? ", import-check enabled" : "");
+		}
+	} else {
+		if (bpi_ultimate->extra && bpi_ultimate->extra->igpmetric) {
+			if (json_paths)
+				json_object_int_add(
+					json_nexthop_global, "metric",
+					bpi_ultimate->extra->igpmetric);
+			else
+				vty_out(vty, " (metric %u)",
+					bpi_ultimate->extra->igpmetric);
+		}
+
+		/* IGP cost is 0, display this only for json */
+		else {
+			if (json_paths)
+				json_object_int_add(json_nexthop_global,
+						    "metric", 0);
+		}
+
+		if (json_paths)
+			json_object_boolean_true_add(json_nexthop_global,
+						     "accessible");
+	}
+
+	/* Display peer "from" output */
+	/* This path was originated locally */
+	if (path->peer == bgp->peer_self) {
+
+		if (safi == SAFI_EVPN || (p->family == AF_INET &&
+					  !BGP_ATTR_MP_NEXTHOP_LEN_IP6(attr))) {
+			if (json_paths)
+				json_object_string_add(json_peer, "peerId",
+						       "0.0.0.0");
+			else
+				vty_out(vty, " from 0.0.0.0 ");
+		} else {
+			if (json_paths)
+				json_object_string_add(json_peer, "peerId",
+						       "::");
+			else
+				vty_out(vty, " from :: ");
+		}
+
+		if (json_paths)
+			json_object_string_addf(json_peer, "routerId", "%pI4",
+						&bgp->router_id);
+		else
+			vty_out(vty, "(%pI4)", &bgp->router_id);
+	}
+
+	/* We RXed this path from one of our peers */
+	else {
+
+		if (json_paths) {
+			json_object_string_addf(json_peer, "peerId", "%pSU",
+						&path->peer->connection->su);
+			json_object_string_addf(json_peer, "routerId", "%pI4",
+						&path->peer->remote_id);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_peer, "hostname",
+						       path->peer->hostname);
+
+			if (path->peer->domainname)
+				json_object_string_add(json_peer, "domainname",
+						       path->peer->domainname);
+
+			if (path->peer->conf_if)
+				json_object_string_add(json_peer, "interface",
+						       path->peer->conf_if);
+		} else {
+			if (path->peer->conf_if) {
+				if (path->peer->hostname
+				    && CHECK_FLAG(path->peer->bgp->flags,
+						  BGP_FLAG_SHOW_HOSTNAME))
+					vty_out(vty, " from %s(%s)",
+						path->peer->hostname,
+						path->peer->conf_if);
+				else
+					vty_out(vty, " from %s",
+						path->peer->conf_if);
+			} else {
+				if (path->peer->hostname
+				    && CHECK_FLAG(path->peer->bgp->flags,
+						  BGP_FLAG_SHOW_HOSTNAME))
+					vty_out(vty, " from %s(%s)",
+						path->peer->hostname,
+						path->peer->host);
+				else
+					vty_out(vty, " from %pSU",
+						&path->peer->connection->su);
+			}
+
+			if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
+				vty_out(vty, " (%pI4)", &attr->originator_id);
+			else
+				vty_out(vty, " (%pI4)", &path->peer->remote_id);
+		}
+	}
+
+	/*
+	 * Note when vrfid of nexthop is different from that of prefix
+	 */
+	if (path->extra && path->extra->vrfleak &&
+	    path->extra->vrfleak->bgp_orig) {
+		vrf_id_t nexthop_vrfid = path->extra->vrfleak->bgp_orig->vrf_id;
+
+		if (json_paths) {
+			const char *vn;
+
+			if (path->extra->vrfleak->bgp_orig->inst_type ==
+			    BGP_INSTANCE_TYPE_DEFAULT)
+				vn = VRF_DEFAULT_NAME;
+			else
+				vn = path->extra->vrfleak->bgp_orig->name;
+
+			json_object_string_add(json_path, "nhVrfName", vn);
+
+			if (nexthop_vrfid == VRF_UNKNOWN) {
+				json_object_int_add(json_path, "nhVrfId", -1);
+			} else {
+				json_object_int_add(json_path, "nhVrfId",
+						    (int)nexthop_vrfid);
+			}
+		} else {
+			if (nexthop_vrfid == VRF_UNKNOWN)
+				vty_out(vty, " vrf ?");
+			else {
+				struct vrf *vrf;
+
+				vrf = vrf_lookup_by_id(nexthop_vrfid);
+				vty_out(vty, " vrf %s(%u)",
+					VRF_LOGNAME(vrf), nexthop_vrfid);
+			}
+		}
+	}
+
+	if (nexthop_self) {
+		if (json_paths) {
+			json_object_boolean_true_add(json_path,
+						     "announceNexthopSelf");
+		} else {
+			vty_out(vty, " announce-nh-self");
+		}
+	}
+
+	if (!json_paths)
+		vty_out(vty, "\n");
+
+	/* display the link-local nexthop */
+	if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) {
+		if (json_paths) {
+			json_nexthop_ll = json_object_new_object();
+			json_object_string_addf(json_nexthop_ll, "ip", "%pI6",
+						&attr->mp_nexthop_local);
+
+			if (path->peer->hostname)
+				json_object_string_add(json_nexthop_ll,
+						       "hostname",
+						       path->peer->hostname);
+
+			json_object_string_add(json_nexthop_ll, "afi", "ipv6");
+			json_object_string_add(json_nexthop_ll, "scope",
+					       "link-local");
+
+			json_object_boolean_true_add(json_nexthop_ll,
+						     "accessible");
+
+			if (!attr->mp_nexthop_prefer_global)
+				json_object_boolean_true_add(json_nexthop_ll,
+							     "used");
+			else
+				json_object_boolean_true_add(
+					json_nexthop_global, "used");
+		} else {
+			vty_out(vty, "    (%s) %s\n",
+				inet_ntop(AF_INET6, &attr->mp_nexthop_local,
+					  buf, INET6_ADDRSTRLEN),
+				attr->mp_nexthop_prefer_global
+					? "(prefer-global)"
+					: "(used)");
+		}
+	}
+	/* If we do not have a link-local nexthop then we must flag the
+	   global as "used" */
+	else {
+		if (json_paths)
+			json_object_boolean_true_add(json_nexthop_global,
+						     "used");
+	}
+
+	if (safi == SAFI_EVPN &&
+			bgp_evpn_is_esi_valid(&attr->esi)) {
+		route_vty_out_detail_es_info(vty, path, attr, json_path);
+	}
+
+	/* Line 3 display Origin, Med, Locpref, Weight, Tag, valid,
+	 * Int/Ext/Local, Atomic, best */
+	if (json_paths)
+		json_object_string_add(json_path, "origin",
+				       bgp_origin_long_str[attr->origin]);
+	else
+		vty_out(vty, "      Origin %s",
+			bgp_origin_long_str[attr->origin]);
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)) {
+		if (json_paths)
+			json_object_int_add(json_path, "metric", attr->med);
+		else
+			vty_out(vty, ", metric %u", attr->med);
+	}
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)) {
+		if (json_paths)
+			json_object_int_add(json_path, "locPrf",
+					    attr->local_pref);
+		else
+			vty_out(vty, ", localpref %u", attr->local_pref);
+	}
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_AIGP)) {
+		if (json_paths)
+			json_object_int_add(json_path, "aigpMetric",
+					    bgp_attr_get_aigp_metric(attr));
+		else
+			vty_out(vty, ", aigp-metric %" PRIu64,
+				bgp_attr_get_aigp_metric(attr));
+	}
+
+	if (attr->weight != 0) {
+		if (json_paths)
+			json_object_int_add(json_path, "weight", attr->weight);
+		else
+			vty_out(vty, ", weight %u", attr->weight);
+	}
+
+	if (attr->tag != 0) {
+		if (json_paths)
+			json_object_int_add(json_path, "tag", attr->tag);
+		else
+			vty_out(vty, ", tag %" ROUTE_TAG_PRI, attr->tag);
+	}
+
+	if (!CHECK_FLAG(path->flags, BGP_PATH_VALID)) {
+		if (json_paths)
+			json_object_boolean_false_add(json_path, "valid");
+		else
+			vty_out(vty, ", invalid");
+	} else if (!CHECK_FLAG(path->flags, BGP_PATH_HISTORY)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path, "valid");
+		else
+			vty_out(vty, ", valid");
+	}
+
+	if (json_paths)
+		json_object_int_add(json_path, "version", bn->version);
+
+	if (path->peer != bgp->peer_self) {
+		if (path->peer->as == path->peer->local_as) {
+			if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION)) {
+				if (json_paths)
+					json_object_string_add(
+						json_peer, "type",
+						"confed-internal");
+				else
+					vty_out(vty, ", confed-internal");
+			} else {
+				if (json_paths)
+					json_object_string_add(
+						json_peer, "type", "internal");
+				else
+					vty_out(vty, ", internal");
+			}
+		} else {
+			if (bgp_confederation_peers_check(bgp,
+							  path->peer->as)) {
+				if (json_paths)
+					json_object_string_add(
+						json_peer, "type",
+						"confed-external");
+				else
+					vty_out(vty, ", confed-external");
+			} else {
+				if (json_paths)
+					json_object_string_add(
+						json_peer, "type", "external");
+				else
+					vty_out(vty, ", external");
+			}
+		}
+	} else if (path->sub_type == BGP_ROUTE_AGGREGATE) {
+		if (json_paths) {
+			json_object_boolean_true_add(json_path, "aggregated");
+			json_object_boolean_true_add(json_path, "local");
+		} else {
+			vty_out(vty, ", aggregated, local");
+		}
+	} else if (path->type != ZEBRA_ROUTE_BGP) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path, "sourced");
+		else
+			vty_out(vty, ", sourced");
+	} else {
+		if (json_paths) {
+			json_object_boolean_true_add(json_path, "sourced");
+			json_object_boolean_true_add(json_path, "local");
+		} else {
+			vty_out(vty, ", sourced, local");
+		}
+	}
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path,
+						     "atomicAggregate");
+		else
+			vty_out(vty, ", atomic-aggregate");
+	}
+
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_OTC)) {
+		if (json_paths)
+			json_object_int_add(json_path, "otc", attr->otc);
+		else
+			vty_out(vty, ", otc %u", attr->otc);
+	}
+
+	if (CHECK_FLAG(path->flags, BGP_PATH_MULTIPATH)
+	    || (CHECK_FLAG(path->flags, BGP_PATH_SELECTED)
+		&& bgp_path_info_mpath_count(path))) {
+		if (json_paths)
+			json_object_boolean_true_add(json_path, "multipath");
+		else
+			vty_out(vty, ", multipath");
+	}
+
+	// Mark the bestpath(s)
+	if (CHECK_FLAG(path->flags, BGP_PATH_DMED_SELECTED)) {
+		first_as = aspath_get_first_as(attr->aspath);
+
+		if (json_paths) {
+			if (!json_bestpath)
+				json_bestpath = json_object_new_object();
+			json_object_int_add(json_bestpath, "bestpathFromAs",
+					    first_as);
+		} else {
+			if (first_as)
+				vty_out(vty, ", bestpath-from-AS %u", first_as);
+			else
+				vty_out(vty, ", bestpath-from-AS Local");
+		}
+	}
+
+	if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED)) {
+		if (json_paths) {
+			if (!json_bestpath)
+				json_bestpath = json_object_new_object();
+			json_object_boolean_true_add(json_bestpath, "overall");
+			json_object_string_add(
+				json_bestpath, "selectionReason",
+				bgp_path_selection_reason2str(bn->reason));
+		} else {
+			vty_out(vty, ", best");
+			vty_out(vty, " (%s)",
+				bgp_path_selection_reason2str(bn->reason));
+		}
+	}
+
+	if (rpki_curr_state != RPKI_NOT_BEING_USED) {
+		if (json_paths)
+			json_object_string_add(
+				json_path, "rpkiValidationState",
+				bgp_rpki_validation2str(rpki_curr_state));
+		else
+			vty_out(vty, ", rpki validation-state: %s",
+				bgp_rpki_validation2str(rpki_curr_state));
+	}
+
+	if (json_bestpath)
+		json_object_object_add(json_path, "bestpath", json_bestpath);
+
+	if (!json_paths)
+		vty_out(vty, "\n");
+
+	/* Line 4 display Community */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)) {
+		if (json_paths) {
+			if (!bgp_attr_get_community(attr)->json)
+				community_str(bgp_attr_get_community(attr),
+					      true, true);
+			json_object_lock(bgp_attr_get_community(attr)->json);
+			json_object_object_add(
+				json_path, "community",
+				bgp_attr_get_community(attr)->json);
+		} else {
+			vty_out(vty, "      Community: %s\n",
+				bgp_attr_get_community(attr)->str);
+		}
+	}
+
+	/* Line 5 display Extended-community */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) {
+		if (json_paths) {
+			json_ext_community = json_object_new_object();
+			json_object_string_add(
+				json_ext_community, "string",
+				bgp_attr_get_ecommunity(attr)->str);
+			json_object_object_add(json_path, "extendedCommunity",
+					       json_ext_community);
+		} else {
+			vty_out(vty, "      Extended Community: %s\n",
+				bgp_attr_get_ecommunity(attr)->str);
+		}
+	}
+
+	/* Line 6 display Large community */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES)) {
+		if (json_paths) {
+			if (!bgp_attr_get_lcommunity(attr)->json)
+				lcommunity_str(bgp_attr_get_lcommunity(attr),
+					       true, true);
+			json_object_lock(bgp_attr_get_lcommunity(attr)->json);
+			json_object_object_add(
+				json_path, "largeCommunity",
+				bgp_attr_get_lcommunity(attr)->json);
+		} else {
+			vty_out(vty, "      Large Community: %s\n",
+				bgp_attr_get_lcommunity(attr)->str);
+		}
+	}
+
+	/* Line 7 display Originator, Cluster-id */
+	if ((attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
+	    || (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST))) {
+		char buf[BUFSIZ] = {0};
+
+		if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) {
+			if (json_paths)
+				json_object_string_addf(json_path,
+							"originatorId", "%pI4",
+							&attr->originator_id);
+			else
+				vty_out(vty, "      Originator: %pI4",
+					&attr->originator_id);
+		}
+
+		if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST)) {
+			struct cluster_list *cluster =
+				bgp_attr_get_cluster(attr);
+			int i;
+
+			if (json_paths) {
+				json_cluster_list = json_object_new_object();
+				json_cluster_list_list =
+					json_object_new_array();
+
+				for (i = 0; i < cluster->length / 4; i++) {
+					json_string = json_object_new_string(
+						inet_ntop(AF_INET,
+							  &cluster->list[i],
+							  buf, sizeof(buf)));
+					json_object_array_add(
+						json_cluster_list_list,
+						json_string);
+				}
+
+				/*
+				 * struct cluster_list does not have
+				 * "str" variable like aspath and community
+				 * do.  Add this someday if someone asks
+				 * for it.
+				 * json_object_string_add(json_cluster_list,
+				 * "string", cluster->str);
+				 */
+				json_object_object_add(json_cluster_list,
+						       "list",
+						       json_cluster_list_list);
+				json_object_object_add(json_path, "clusterList",
+						       json_cluster_list);
+			} else {
+				vty_out(vty, ", Cluster list: ");
+
+				for (i = 0; i < cluster->length / 4; i++) {
+					vty_out(vty, "%pI4 ",
+						&cluster->list[i]);
+				}
+			}
+		}
+
+		if (!json_paths)
+			vty_out(vty, "\n");
+	}
+
+	if (path->extra && path->extra->damp_info)
+		bgp_damp_info_vty(vty, path, afi, safi, json_path);
+
+	/* Remote Label */
+	if (path->extra && bgp_is_valid_label(&path->extra->label[0])
+	    && (safi != SAFI_EVPN && !is_route_parent_evpn(path))) {
+		mpls_lse_decode(path->extra->label[0], &label, &ttl, &exp,
+				&bos);
+
+		if (json_paths)
+			json_object_int_add(json_path, "remoteLabel", label);
+		else
+			vty_out(vty, "      Remote label: %d\n", label);
+	}
+
+	/* Remote SID */
+	if ((path->attr->srv6_l3vpn || path->attr->srv6_vpn) &&
+	    safi != SAFI_EVPN) {
+		struct in6_addr *sid_tmp =
+			path->attr->srv6_l3vpn ? (&path->attr->srv6_l3vpn->sid)
+					       : (&path->attr->srv6_vpn->sid);
+		if (json_paths)
+			json_object_string_addf(json_path, "remoteSid", "%pI6",
+						sid_tmp);
+		else
+			vty_out(vty, "      Remote SID: %pI6\n", sid_tmp);
+	}
+
+	/* Label Index */
+	if (attr->label_index != BGP_INVALID_LABEL_INDEX) {
+		if (json_paths)
+			json_object_int_add(json_path, "labelIndex",
+					    attr->label_index);
+		else
+			vty_out(vty, "      Label Index: %d\n",
+				attr->label_index);
+	}
+
+	/* Line 8 display Addpath IDs */
+	if (path->addpath_rx_id
+	    || bgp_addpath_info_has_ids(&path->tx_addpath)) {
+		if (json_paths) {
+			json_object_int_add(json_path, "addpathRxId",
+					    path->addpath_rx_id);
+
+			/* Keep backwards compatibility with the old API
+			 * by putting TX All's ID in the old field
+			 */
+			json_object_int_add(
+				json_path, "addpathTxId",
+				path->tx_addpath
+					.addpath_tx_id[BGP_ADDPATH_ALL]);
+
+			/* ... but create a specific field for each
+			 * strategy
+			 */
+			for (i = 0; i < BGP_ADDPATH_MAX; i++) {
+				json_object_int_add(
+					json_path,
+					bgp_addpath_names(i)->id_json_name,
+					path->tx_addpath.addpath_tx_id[i]);
+			}
+		} else {
+			vty_out(vty, "      AddPath ID: RX %u, ",
+				path->addpath_rx_id);
+
+			route_vty_out_tx_ids(vty, &path->tx_addpath);
+		}
+	}
+
+	/* If we used addpath to TX a non-bestpath we need to display
+	 * "Advertised to" on a path-by-path basis
+	 */
+	if (bgp_addpath_is_addpath_used(&bgp->tx_addpath, afi, safi)) {
+		first = 1;
+
+		for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
+			addpath_capable =
+				bgp_addpath_encode_tx(peer, afi, safi);
+			has_adj = bgp_adj_out_lookup(
+				peer, path->net,
+				bgp_addpath_id_for_peer(peer, afi, safi,
+							&path->tx_addpath));
+
+			if ((addpath_capable && has_adj)
+			    || (!addpath_capable && has_adj
+				&& CHECK_FLAG(path->flags,
+					      BGP_PATH_SELECTED))) {
+				if (json_path && !json_adv_to)
+					json_adv_to = json_object_new_object();
+
+				route_vty_out_advertised_to(
+					vty, peer, &first,
+					"      Advertised to:", json_adv_to);
+			}
+		}
+
+		if (json_path) {
+			if (json_adv_to) {
+				json_object_object_add(
+					json_path, "advertisedTo", json_adv_to);
+			}
+		} else {
+			if (!first) {
+				vty_out(vty, "\n");
+			}
+		}
+	}
+
+	/* Line 9 display Uptime */
+	tbuf = time(NULL) - (monotime(NULL) - path->uptime);
+	if (json_paths) {
+		json_last_update = json_object_new_object();
+		json_object_int_add(json_last_update, "epoch", tbuf);
+		json_object_string_add(json_last_update, "string",
+				       ctime_r(&tbuf, timebuf));
+		json_object_object_add(json_path, "lastUpdate",
+				       json_last_update);
+	} else
+		vty_out(vty, "      Last update: %s", ctime_r(&tbuf, timebuf));
+
+	/* Line 10 display PMSI tunnel attribute, if present */
+	if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL)) {
+		const char *str = lookup_msg(bgp_pmsi_tnltype_str,
+					     bgp_attr_get_pmsi_tnl_type(attr),
+					     PMSI_TNLTYPE_STR_DEFAULT);
+
+		if (json_paths) {
+			json_pmsi = json_object_new_object();
+			json_object_string_add(json_pmsi, "tunnelType", str);
+			json_object_int_add(json_pmsi, "label",
+					    label2vni(&attr->label));
+			json_object_object_add(json_path, "pmsi", json_pmsi);
+		} else
+			vty_out(vty, "      PMSI Tunnel Type: %s, label: %d\n",
+				str, label2vni(&attr->label));
+	}
+
+	if (path->peer->connection->t_gr_restart &&
+	    CHECK_FLAG(path->flags, BGP_PATH_STALE)) {
+		unsigned long gr_remaining = event_timer_remain_second(
+			path->peer->connection->t_gr_restart);
+
+		if (json_paths) {
+			json_object_int_add(json_path,
+					    "gracefulRestartSecondsRemaining",
+					    gr_remaining);
+		} else
+			vty_out(vty,
+				"      Time until Graceful Restart stale route deleted: %lu\n",
+				gr_remaining);
+	}
+
+	if (path->peer->t_llgr_stale[afi][safi] &&
+	    bgp_attr_get_community(attr) &&
+	    community_include(bgp_attr_get_community(attr),
+			      COMMUNITY_LLGR_STALE)) {
+		unsigned long llgr_remaining = event_timer_remain_second(
+			path->peer->t_llgr_stale[afi][safi]);
+
+		if (json_paths) {
+			json_object_int_add(json_path, "llgrSecondsRemaining",
+					    llgr_remaining);
+		} else
+			vty_out(vty,
+				"      Time until Long-lived stale route deleted: %lu\n",
+				llgr_remaining);
+	}
+
+	/* Output some debug about internal state of the dest flags */
+	if (json_paths) {
+		if (CHECK_FLAG(bn->flags, BGP_NODE_PROCESS_SCHEDULED))
+			json_object_boolean_true_add(json_path, "processScheduled");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_USER_CLEAR))
+			json_object_boolean_true_add(json_path, "userCleared");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_LABEL_CHANGED))
+			json_object_boolean_true_add(json_path, "labelChanged");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_REGISTERED_FOR_LABEL))
+			json_object_boolean_true_add(json_path, "registeredForLabel");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_SELECT_DEFER))
+			json_object_boolean_true_add(json_path, "selectDefered");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_FIB_INSTALLED))
+			json_object_boolean_true_add(json_path, "fibInstalled");
+		if (CHECK_FLAG(bn->flags, BGP_NODE_FIB_INSTALL_PENDING))
+			json_object_boolean_true_add(json_path, "fibPending");
+
+		if (json_nexthop_global || json_nexthop_ll) {
+			json_nexthops = json_object_new_array();
+
+			if (json_nexthop_global)
+				json_object_array_add(json_nexthops,
+						      json_nexthop_global);
+
+			if (json_nexthop_ll)
+				json_object_array_add(json_nexthops,
+						      json_nexthop_ll);
+
+			json_object_object_add(json_path, "nexthops",
+					       json_nexthops);
+		}
+
+		json_object_object_add(json_path, "peer", json_peer);
+		json_object_array_add(json_paths, json_path);
+	}
+}
+
+#define BGP_SHOW_HEADER_CSV "Flags, Network, Next Hop, Metric, LocPrf, Weight, Path"
+#define BGP_SHOW_DAMP_HEADER "   Network          From             Reuse    Path\n"
+#define BGP_SHOW_FLAP_HEADER "   Network          From            Flaps Duration Reuse    Path\n"
+
+static int bgp_show_regexp(struct vty *vty, struct bgp *bgp, const char *regstr,
+			   afi_t afi, safi_t safi, enum bgp_show_type type,
+			   bool use_json);
+static int bgp_show_community(struct vty *vty, struct bgp *bgp,
+			      const char *comstr, int exact, afi_t afi,
+			      safi_t safi, uint16_t show_flags);
+
+static int bgp_show_table(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
+			  struct bgp_table *table, enum bgp_show_type type,
+			  void *output_arg, const char *rd, int is_last,
+			  unsigned long *output_cum, unsigned long *total_cum,
+			  unsigned long *json_header_depth, uint16_t show_flags,
+			  enum rpki_states rpki_target_state)
+{
+	struct bgp_path_info *pi;
+	struct bgp_dest *dest;
+	bool header = true;
+	bool json_detail_header = false;
+	int display;
+	unsigned long output_count = 0;
+	unsigned long total_count = 0;
+	struct prefix *p;
+	json_object *json_paths = NULL;
+	int first = 1;
+	bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	bool wide = CHECK_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+	bool all = CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_ALL);
+	bool detail_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON_DETAIL);
+	bool detail_routes = CHECK_FLAG(show_flags, BGP_SHOW_OPT_ROUTES_DETAIL);
+
+	if (output_cum && *output_cum != 0)
+		header = false;
+
+	if (use_json && !*json_header_depth) {
+		if (all)
+			*json_header_depth = 1;
+		else {
+			vty_out(vty, "{\n");
+			*json_header_depth = 2;
+		}
+		vty_out(vty,
+			" \"vrfId\": %d,\n \"vrfName\": \"%s\",\n \"tableVersion\": %" PRId64
+			",\n \"routerId\": \"%pI4\",\n \"defaultLocPrf\": %u,\n"
+			" \"localAS\": ",
+			bgp->vrf_id == VRF_UNKNOWN ? -1 : (int)bgp->vrf_id,
+			bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT
+				? VRF_DEFAULT_NAME
+				: bgp->name,
+			table->version, &bgp->router_id,
+			bgp->default_local_pref);
+		if ((bgp->asnotation == ASNOTATION_PLAIN) ||
+		    ((bgp->asnotation == ASNOTATION_DOT) &&
+		     (bgp->as < UINT16_MAX)))
+			vty_out(vty, "%u", bgp->as);
+		else {
+			vty_out(vty, "\"");
+			vty_out(vty, ASN_FORMAT(bgp->asnotation), &bgp->as);
+			vty_out(vty, "\"");
+		}
+		vty_out(vty, ",\n \"routes\": { ");
+		if (rd) {
+			vty_out(vty, " \"routeDistinguishers\" : {");
+			++*json_header_depth;
+		}
+	}
+
+	if (use_json && rd) {
+		vty_out(vty, " \"%s\" : { ", rd);
+	}
+
+	/* Check for 'json detail', where we need header output once per dest */
+	if (use_json && detail_json && type != bgp_show_type_dampend_paths &&
+	    type != bgp_show_type_damp_neighbor &&
+	    type != bgp_show_type_flap_statistics &&
+	    type != bgp_show_type_flap_neighbor)
+		json_detail_header = true;
+
+	/* Start processing of routes. */
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+		enum rpki_states rpki_curr_state = RPKI_NOT_BEING_USED;
+		bool json_detail_header_used = false;
+
+		pi = bgp_dest_get_bgp_path_info(dest);
+		if (pi == NULL)
+			continue;
+
+		display = 0;
+		if (use_json)
+			json_paths = json_object_new_array();
+		else
+			json_paths = NULL;
+
+		for (; pi; pi = pi->next) {
+			struct community *picomm = NULL;
+
+			picomm = bgp_attr_get_community(pi->attr);
+
+			total_count++;
+
+			if (type == bgp_show_type_prefix_version) {
+				uint32_t version =
+					strtoul(output_arg, NULL, 10);
+				if (dest->version < version)
+					continue;
+			}
+
+			if (type == bgp_show_type_community_alias) {
+				char *alias = output_arg;
+				char **communities;
+				int num;
+				bool found = false;
+
+				if (picomm) {
+					frrstr_split(picomm->str, " ",
+						     &communities, &num);
+					for (int i = 0; i < num; i++) {
+						const char *com2alias =
+							bgp_community2alias(
+								communities[i]);
+						if (!found
+						    && strcmp(alias, com2alias)
+							       == 0)
+							found = true;
+						XFREE(MTYPE_TMP,
+						      communities[i]);
+					}
+					XFREE(MTYPE_TMP, communities);
+				}
+
+				if (!found &&
+				    bgp_attr_get_lcommunity(pi->attr)) {
+					frrstr_split(bgp_attr_get_lcommunity(
+							     pi->attr)
+							     ->str,
+						     " ", &communities, &num);
+					for (int i = 0; i < num; i++) {
+						const char *com2alias =
+							bgp_community2alias(
+								communities[i]);
+						if (!found
+						    && strcmp(alias, com2alias)
+							       == 0)
+							found = true;
+						XFREE(MTYPE_TMP,
+						      communities[i]);
+					}
+					XFREE(MTYPE_TMP, communities);
+				}
+
+				if (!found)
+					continue;
+			}
+
+			if (type == bgp_show_type_rpki) {
+				if (dest_p->family == AF_INET
+				    || dest_p->family == AF_INET6)
+					rpki_curr_state = hook_call(
+						bgp_rpki_prefix_status,
+						pi->peer, pi->attr, dest_p);
+				if (rpki_target_state != RPKI_NOT_BEING_USED
+				    && rpki_curr_state != rpki_target_state)
+					continue;
+			}
+
+			if (type == bgp_show_type_flap_statistics
+			    || type == bgp_show_type_flap_neighbor
+			    || type == bgp_show_type_dampend_paths
+			    || type == bgp_show_type_damp_neighbor) {
+				if (!(pi->extra && pi->extra->damp_info))
+					continue;
+			}
+			if (type == bgp_show_type_regexp) {
+				regex_t *regex = output_arg;
+
+				if (bgp_regexec(regex, pi->attr->aspath)
+				    == REG_NOMATCH)
+					continue;
+			}
+			if (type == bgp_show_type_prefix_list) {
+				struct prefix_list *plist = output_arg;
+
+				if (prefix_list_apply(plist, dest_p)
+				    != PREFIX_PERMIT)
+					continue;
+			}
+			if (type == bgp_show_type_access_list) {
+				struct access_list *alist = output_arg;
+
+				if (access_list_apply(alist, dest_p) !=
+				    FILTER_PERMIT)
+					continue;
+			}
+			if (type == bgp_show_type_filter_list) {
+				struct as_list *as_list = output_arg;
+
+				if (as_list_apply(as_list, pi->attr->aspath)
+				    != AS_FILTER_PERMIT)
+					continue;
+			}
+			if (type == bgp_show_type_route_map) {
+				struct route_map *rmap = output_arg;
+				struct bgp_path_info path;
+				struct bgp_path_info_extra extra;
+				struct attr dummy_attr = {};
+				route_map_result_t ret;
+
+				dummy_attr = *pi->attr;
+
+				prep_for_rmap_apply(&path, &extra, dest, pi,
+						    pi->peer, &dummy_attr);
+
+				ret = route_map_apply(rmap, dest_p, &path);
+				bgp_attr_flush(&dummy_attr);
+				if (ret == RMAP_DENYMATCH)
+					continue;
+			}
+			if (type == bgp_show_type_neighbor
+			    || type == bgp_show_type_flap_neighbor
+			    || type == bgp_show_type_damp_neighbor) {
+				union sockunion *su = output_arg;
+
+				if (pi->peer == NULL
+				    || pi->peer->su_remote == NULL
+				    || !sockunion_same(pi->peer->su_remote, su))
+					continue;
+			}
+			if (type == bgp_show_type_cidr_only) {
+				uint32_t destination;
+
+				destination = ntohl(dest_p->u.prefix4.s_addr);
+				if (IN_CLASSC(destination)
+				    && dest_p->prefixlen == 24)
+					continue;
+				if (IN_CLASSB(destination)
+				    && dest_p->prefixlen == 16)
+					continue;
+				if (IN_CLASSA(destination)
+				    && dest_p->prefixlen == 8)
+					continue;
+			}
+			if (type == bgp_show_type_prefix_longer) {
+				p = output_arg;
+				if (!prefix_match(p, dest_p))
+					continue;
+			}
+			if (type == bgp_show_type_community_all) {
+				if (!picomm)
+					continue;
+			}
+			if (type == bgp_show_type_community) {
+				struct community *com = output_arg;
+
+				if (!picomm || !community_match(picomm, com))
+					continue;
+			}
+			if (type == bgp_show_type_community_exact) {
+				struct community *com = output_arg;
+
+				if (!picomm || !community_cmp(picomm, com))
+					continue;
+			}
+			if (type == bgp_show_type_community_list) {
+				struct community_list *list = output_arg;
+
+				if (!community_list_match(picomm, list))
+					continue;
+			}
+			if (type == bgp_show_type_community_list_exact) {
+				struct community_list *list = output_arg;
+
+				if (!community_list_exact_match(picomm, list))
+					continue;
+			}
+			if (type == bgp_show_type_lcommunity) {
+				struct lcommunity *lcom = output_arg;
+
+				if (!bgp_attr_get_lcommunity(pi->attr) ||
+				    !lcommunity_match(
+					    bgp_attr_get_lcommunity(pi->attr),
+					    lcom))
+					continue;
+			}
+
+			if (type == bgp_show_type_lcommunity_exact) {
+				struct lcommunity *lcom = output_arg;
+
+				if (!bgp_attr_get_lcommunity(pi->attr) ||
+				    !lcommunity_cmp(
+					    bgp_attr_get_lcommunity(pi->attr),
+					    lcom))
+					continue;
+			}
+			if (type == bgp_show_type_lcommunity_list) {
+				struct community_list *list = output_arg;
+
+				if (!lcommunity_list_match(
+					    bgp_attr_get_lcommunity(pi->attr),
+					    list))
+					continue;
+			}
+			if (type
+			    == bgp_show_type_lcommunity_list_exact) {
+				struct community_list *list = output_arg;
+
+				if (!lcommunity_list_exact_match(
+					    bgp_attr_get_lcommunity(pi->attr),
+					    list))
+					continue;
+			}
+			if (type == bgp_show_type_lcommunity_all) {
+				if (!bgp_attr_get_lcommunity(pi->attr))
+					continue;
+			}
+			if (type == bgp_show_type_dampend_paths
+			    || type == bgp_show_type_damp_neighbor) {
+				if (!CHECK_FLAG(pi->flags, BGP_PATH_DAMPED)
+				    || CHECK_FLAG(pi->flags, BGP_PATH_HISTORY))
+					continue;
+			}
+			if (type == bgp_show_type_self_originated) {
+				if (pi->peer != bgp->peer_self)
+					continue;
+			}
+
+			if (!use_json && header) {
+				vty_out(vty,
+					"BGP table version is %" PRIu64
+					", local router ID is %pI4, vrf id ",
+					table->version, &bgp->router_id);
+				if (bgp->vrf_id == VRF_UNKNOWN)
+					vty_out(vty, "%s", VRFID_NONE_STR);
+				else
+					vty_out(vty, "%u", bgp->vrf_id);
+				vty_out(vty, "\n");
+				vty_out(vty, "Default local pref %u, ",
+					bgp->default_local_pref);
+				vty_out(vty, "local AS ");
+				vty_out(vty, ASN_FORMAT(bgp->asnotation),
+					&bgp->as);
+				vty_out(vty, "\n");
+				if (!detail_routes) {
+					vty_out(vty, BGP_SHOW_SCODE_HEADER);
+					vty_out(vty, BGP_SHOW_NCODE_HEADER);
+					vty_out(vty, BGP_SHOW_OCODE_HEADER);
+					vty_out(vty, BGP_SHOW_RPKI_HEADER);
+				}
+				if (type == bgp_show_type_dampend_paths
+				    || type == bgp_show_type_damp_neighbor)
+					vty_out(vty, BGP_SHOW_DAMP_HEADER);
+				else if (type == bgp_show_type_flap_statistics
+					 || type == bgp_show_type_flap_neighbor)
+					vty_out(vty, BGP_SHOW_FLAP_HEADER);
+				else if (!detail_routes)
+					vty_out(vty, (wide ? BGP_SHOW_HEADER_WIDE
+							   : BGP_SHOW_HEADER));
+				header = false;
+
+			}
+			if (rd != NULL && !display && !output_count) {
+				if (!use_json)
+					vty_out(vty,
+						"Route Distinguisher: %s\n",
+						rd);
+			}
+			if (type == bgp_show_type_dampend_paths
+			    || type == bgp_show_type_damp_neighbor)
+				damp_route_vty_out(vty, dest_p, pi, display,
+						   afi, safi, use_json,
+						   json_paths);
+			else if (type == bgp_show_type_flap_statistics
+				 || type == bgp_show_type_flap_neighbor)
+				flap_route_vty_out(vty, dest_p, pi, display,
+						   afi, safi, use_json,
+						   json_paths);
+			else {
+				if (detail_routes || detail_json) {
+					const struct prefix_rd *prd = NULL;
+
+					if (dest->pdest)
+						prd = bgp_rd_from_dest(
+							dest->pdest, safi);
+
+					if (!use_json)
+						route_vty_out_detail_header(
+							vty, bgp, dest,
+							bgp_dest_get_prefix(
+								dest),
+							prd, table->afi, safi,
+							NULL, false);
+
+					route_vty_out_detail(
+						vty, bgp, dest, dest_p, pi,
+						family2afi(dest_p->family),
+						safi, RPKI_NOT_BEING_USED,
+						json_paths);
+				} else {
+					route_vty_out(vty, dest_p, pi, display,
+						      safi, json_paths, wide);
+				}
+			}
+			display++;
+		}
+
+		if (display) {
+			output_count++;
+			if (!use_json)
+				continue;
+
+			/* encode prefix */
+			if (dest_p->family == AF_FLOWSPEC) {
+				char retstr[BGP_FLOWSPEC_STRING_DISPLAY_MAX];
+
+
+				bgp_fs_nlri_get_string(
+					(unsigned char *)
+						dest_p->u.prefix_flowspec.ptr,
+					dest_p->u.prefix_flowspec.prefixlen,
+					retstr, NLRI_STRING_FORMAT_MIN, NULL,
+					family2afi(dest_p->u
+						   .prefix_flowspec.family));
+				if (first)
+					vty_out(vty, "\"%s/%d\": ", retstr,
+						dest_p->u.prefix_flowspec
+							.prefixlen);
+				else
+					vty_out(vty, ",\"%s/%d\": ", retstr,
+						dest_p->u.prefix_flowspec
+							.prefixlen);
+			} else {
+				if (first)
+					vty_out(vty, "\"%pFX\": ", dest_p);
+				else
+					vty_out(vty, ",\"%pFX\": ", dest_p);
+			}
+
+			/* This is used for 'json detail' vty keywords.
+			 *
+			 * In plain 'json' the per-prefix header is encoded
+			 * as a standalone dictionary in the first json_paths
+			 * array element:
+			 * "<prefix>": [{header}, {path-1}, {path-N}]
+			 * (which is confusing and borderline broken)
+			 *
+			 * For 'json detail' this changes the value
+			 * of each prefix-key to be a dictionary where each
+			 * header item has its own key, and json_paths is
+			 * tucked under the "paths" key:
+			 * "<prefix>": {
+			 *   "<header-key-1>": <header-val-1>,
+			 *   "<header-key-N>": <header-val-N>,
+			 *   "paths": [{path-1}, {path-N}]
+			 * }
+			 */
+			if (json_detail_header && json_paths != NULL) {
+				const struct prefix_rd *prd;
+
+				/* Start per-prefix dictionary */
+				vty_out(vty, "{\n");
+
+				prd = bgp_rd_from_dest(dest, safi);
+
+				route_vty_out_detail_header(
+					vty, bgp, dest,
+					bgp_dest_get_prefix(dest), prd,
+					table->afi, safi, json_paths, true);
+
+				vty_out(vty, "\"paths\": ");
+				json_detail_header_used = true;
+			}
+
+			/*
+			 * We are using no_pretty here because under
+			 * extremely high settings( say lots and lots of
+			 * routes with lots and lots of ways to reach
+			 * that route via different paths ) this can
+			 * save several minutes of output when FRR
+			 * is run on older cpu's or more underperforming
+			 * routers out there
+			 */
+			vty_json_no_pretty(vty, json_paths);
+
+			/* End per-prefix dictionary */
+			if (json_detail_header_used)
+				vty_out(vty, "} ");
+
+			json_paths = NULL;
+			first = 0;
+		} else
+			json_object_free(json_paths);
+	}
+
+	if (output_cum) {
+		output_count += *output_cum;
+		*output_cum = output_count;
+	}
+	if (total_cum) {
+		total_count += *total_cum;
+		*total_cum = total_count;
+	}
+	if (use_json) {
+		if (rd) {
+			vty_out(vty, " }%s ", (is_last ? "" : ","));
+		}
+		if (is_last) {
+			unsigned long i;
+			for (i = 0; i < *json_header_depth; ++i)
+				vty_out(vty, " } ");
+			if (!all)
+				vty_out(vty, "\n");
+		}
+	} else {
+		if (is_last) {
+			/* No route is displayed */
+			if (output_count == 0) {
+				if (type == bgp_show_type_normal)
+					vty_out(vty,
+						"No BGP prefixes displayed, %ld exist\n",
+						total_count);
+			} else
+				vty_out(vty,
+					"\nDisplayed  %ld routes and %ld total paths\n",
+					output_count, total_count);
+		}
+	}
+
+	return CMD_SUCCESS;
+}
+
+int bgp_show_table_rd(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
+		      struct bgp_table *table, struct prefix_rd *prd_match,
+		      enum bgp_show_type type, void *output_arg,
+		      uint16_t show_flags)
+{
+	struct bgp_dest *dest, *next;
+	unsigned long output_cum = 0;
+	unsigned long total_cum = 0;
+	unsigned long json_header_depth = 0;
+	struct bgp_table *itable;
+	bool show_msg;
+	bool use_json = !!CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	show_msg = (!use_json && type == bgp_show_type_normal);
+
+	for (dest = bgp_table_top(table); dest; dest = next) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		next = bgp_route_next(dest);
+		if (prd_match && memcmp(dest_p->u.val, prd_match->val, 8) != 0)
+			continue;
+
+		itable = bgp_dest_get_bgp_table_info(dest);
+		if (itable != NULL) {
+			struct prefix_rd prd;
+			char rd[RD_ADDRSTRLEN];
+
+			memcpy(&prd, dest_p, sizeof(struct prefix_rd));
+			prefix_rd2str(&prd, rd, sizeof(rd), bgp->asnotation);
+			bgp_show_table(vty, bgp, afi, safi, itable, type, output_arg,
+				       rd, next == NULL, &output_cum,
+				       &total_cum, &json_header_depth,
+				       show_flags, RPKI_NOT_BEING_USED);
+			if (next == NULL)
+				show_msg = false;
+		}
+	}
+	if (show_msg) {
+		if (output_cum == 0)
+			vty_out(vty, "No BGP prefixes displayed, %ld exist\n",
+				total_cum);
+		else
+			vty_out(vty,
+				"\nDisplayed  %ld routes and %ld total paths\n",
+				output_cum, total_cum);
+	} else {
+		if (use_json && output_cum == 0 && json_header_depth == 0)
+			vty_out(vty, "{}\n");
+	}
+	return CMD_SUCCESS;
+}
+
+static int bgp_show(struct vty *vty, struct bgp *bgp, afi_t afi, safi_t safi,
+		    enum bgp_show_type type, void *output_arg,
+		    uint16_t show_flags, enum rpki_states rpki_target_state)
+{
+	struct bgp_table *table;
+	unsigned long json_header_depth = 0;
+	bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	if (bgp == NULL) {
+		bgp = bgp_get_default();
+	}
+
+	if (bgp == NULL) {
+		if (!use_json)
+			vty_out(vty, "No BGP process is configured\n");
+		else
+			vty_out(vty, "{}\n");
+		return CMD_WARNING;
+	}
+
+	/* Labeled-unicast routes live in the unicast table. */
+	if (safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	table = bgp->rib[afi][safi];
+	/* use MPLS and ENCAP specific shows until they are merged */
+	if (safi == SAFI_MPLS_VPN) {
+		return bgp_show_table_rd(vty, bgp, afi, safi, table, NULL, type,
+					 output_arg, show_flags);
+	}
+
+	if (safi == SAFI_FLOWSPEC && type == bgp_show_type_detail) {
+		return bgp_show_table_flowspec(vty, bgp, afi, table, type,
+					       output_arg, use_json,
+					       1, NULL, NULL);
+	}
+
+	if (safi == SAFI_EVPN)
+		return bgp_evpn_show_all_routes(vty, bgp, type, use_json, 0);
+
+	return bgp_show_table(vty, bgp, afi, safi, table, type, output_arg, NULL, 1,
+			      NULL, NULL, &json_header_depth, show_flags,
+			      rpki_target_state);
+}
+
+static void bgp_show_all_instances_routes_vty(struct vty *vty, afi_t afi,
+					      safi_t safi, uint16_t show_flags)
+{
+	struct listnode *node, *nnode;
+	struct bgp *bgp;
+	int is_first = 1;
+	bool route_output = false;
+	bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	if (use_json)
+		vty_out(vty, "{\n");
+
+	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
+		route_output = true;
+		if (use_json) {
+			if (!is_first)
+				vty_out(vty, ",\n");
+			else
+				is_first = 0;
+
+			vty_out(vty, "\"%s\":",
+				(bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
+					? VRF_DEFAULT_NAME
+					: bgp->name);
+		} else {
+			vty_out(vty, "\nInstance %s:\n",
+				(bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
+					? VRF_DEFAULT_NAME
+					: bgp->name);
+		}
+		bgp_show(vty, bgp, afi, safi, bgp_show_type_normal, NULL,
+			 show_flags, RPKI_NOT_BEING_USED);
+	}
+
+	if (use_json)
+		vty_out(vty, "}\n");
+	else if (!route_output)
+		vty_out(vty, "%% BGP instance not found\n");
+}
+
+/* Header of detailed BGP route information */
+void route_vty_out_detail_header(struct vty *vty, struct bgp *bgp,
+				 struct bgp_dest *dest, const struct prefix *p,
+				 const struct prefix_rd *prd, afi_t afi,
+				 safi_t safi, json_object *json,
+				 bool incremental_print)
+{
+	struct bgp_path_info *pi;
+	struct peer *peer;
+	struct listnode *node, *nnode;
+	char buf1[RD_ADDRSTRLEN];
+	int count = 0;
+	int best = 0;
+	int suppress = 0;
+	int accept_own = 0;
+	int route_filter_translated_v4 = 0;
+	int route_filter_v4 = 0;
+	int route_filter_translated_v6 = 0;
+	int route_filter_v6 = 0;
+	int llgr_stale = 0;
+	int no_llgr = 0;
+	int accept_own_nexthop = 0;
+	int blackhole = 0;
+	int no_export = 0;
+	int no_advertise = 0;
+	int local_as = 0;
+	int no_peer = 0;
+	int first = 1;
+	int has_valid_label = 0;
+	mpls_label_t label = 0;
+	json_object *json_adv_to = NULL;
+	uint32_t ttl = 0;
+	uint32_t bos = 0;
+	uint32_t exp = 0;
+
+	mpls_lse_decode(dest->local_label, &label, &ttl, &exp, &bos);
+
+	has_valid_label = bgp_is_valid_label(&label);
+
+	if (safi == SAFI_EVPN) {
+		if (!json) {
+			vty_out(vty, "BGP routing table entry for %s%s%pFX\n",
+				prd ? prefix_rd2str(prd, buf1, sizeof(buf1),
+						    bgp->asnotation)
+				    : "",
+				prd ? ":" : "", (struct prefix_evpn *)p);
+		} else {
+			json_object_string_add(
+				json, "rd",
+				prd ? prefix_rd2str(prd, buf1, sizeof(buf1),
+						    bgp->asnotation)
+				    : "");
+			bgp_evpn_route2json((struct prefix_evpn *)p, json);
+		}
+	} else {
+		if (!json) {
+			vty_out(vty,
+				"BGP routing table entry for %s%s%pFX, version %" PRIu64
+				"\n",
+				(((safi == SAFI_MPLS_VPN ||
+				   safi == SAFI_ENCAP) &&
+				  prd)
+					 ? prefix_rd2str(prd, buf1,
+							 sizeof(buf1),
+							 bgp->asnotation)
+					 : ""),
+				safi == SAFI_MPLS_VPN && prd ? ":" : "", p,
+				dest->version);
+
+		} else {
+			if (incremental_print) {
+				vty_out(vty, "\"prefix\": \"%pFX\",\n", p);
+				vty_out(vty, "\"version\": \"%" PRIu64 "\",\n",
+					dest->version);
+			} else {
+				json_object_string_addf(json, "prefix", "%pFX",
+							p);
+				json_object_int_add(json, "version",
+						    dest->version);
+			}
+		}
+	}
+
+	if (has_valid_label) {
+		if (json) {
+			if (incremental_print)
+				vty_out(vty, "\"localLabel\": \"%u\",\n",
+					label);
+			else
+				json_object_int_add(json, "localLabel", label);
+		} else
+			vty_out(vty, "Local label: %d\n", label);
+	}
+
+	if (!json)
+		if (bgp_labeled_safi(safi) && safi != SAFI_EVPN)
+			vty_out(vty, "not allocated\n");
+
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+		struct community *picomm = NULL;
+
+		picomm = bgp_attr_get_community(pi->attr);
+
+		count++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED)) {
+			best = count;
+			if (bgp_path_suppressed(pi))
+				suppress = 1;
+
+			if (!picomm)
+				continue;
+
+			no_advertise += community_include(
+				picomm, COMMUNITY_NO_ADVERTISE);
+			no_export +=
+				community_include(picomm, COMMUNITY_NO_EXPORT);
+			local_as +=
+				community_include(picomm, COMMUNITY_LOCAL_AS);
+			accept_own +=
+				community_include(picomm, COMMUNITY_ACCEPT_OWN);
+			route_filter_translated_v4 += community_include(
+				picomm, COMMUNITY_ROUTE_FILTER_TRANSLATED_v4);
+			route_filter_translated_v6 += community_include(
+				picomm, COMMUNITY_ROUTE_FILTER_TRANSLATED_v6);
+			route_filter_v4 += community_include(
+				picomm, COMMUNITY_ROUTE_FILTER_v4);
+			route_filter_v6 += community_include(
+				picomm, COMMUNITY_ROUTE_FILTER_v6);
+			llgr_stale +=
+				community_include(picomm, COMMUNITY_LLGR_STALE);
+			no_llgr += community_include(picomm, COMMUNITY_NO_LLGR);
+			accept_own_nexthop += community_include(
+				picomm, COMMUNITY_ACCEPT_OWN_NEXTHOP);
+			blackhole +=
+				community_include(picomm, COMMUNITY_BLACKHOLE);
+			no_peer += community_include(picomm, COMMUNITY_NO_PEER);
+		}
+	}
+
+	if (!json) {
+		vty_out(vty, "Paths: (%d available", count);
+		if (best) {
+			vty_out(vty, ", best #%d", best);
+			if (safi == SAFI_UNICAST) {
+				if (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
+					vty_out(vty, ", table %s",
+						VRF_DEFAULT_NAME);
+				else
+					vty_out(vty, ", vrf %s",
+						bgp->name);
+			}
+		} else
+			vty_out(vty, ", no best path");
+
+		if (accept_own)
+			vty_out(vty,
+			", accept own local route exported and imported in different VRF");
+		else if (route_filter_translated_v4)
+			vty_out(vty,
+			", mark translated RTs for VPNv4 route filtering");
+		else if (route_filter_v4)
+			vty_out(vty,
+			", attach RT as-is for VPNv4 route filtering");
+		else if (route_filter_translated_v6)
+			vty_out(vty,
+			", mark translated RTs for VPNv6 route filtering");
+		else if (route_filter_v6)
+			vty_out(vty,
+			", attach RT as-is for VPNv6 route filtering");
+		else if (llgr_stale)
+			vty_out(vty,
+				", mark routes to be retained for a longer time. Requires support for Long-lived BGP Graceful Restart");
+		else if (no_llgr)
+			vty_out(vty,
+			", mark routes to not be treated according to Long-lived BGP Graceful Restart operations");
+		else if (accept_own_nexthop)
+			vty_out(vty,
+			", accept local nexthop");
+		else if (blackhole)
+			vty_out(vty, ", inform peer to blackhole prefix");
+		else if (no_export)
+			vty_out(vty, ", not advertised to EBGP peer");
+		else if (no_advertise)
+			vty_out(vty, ", not advertised to any peer");
+		else if (local_as)
+			vty_out(vty, ", not advertised outside local AS");
+		else if (no_peer)
+			vty_out(vty,
+			", inform EBGP peer not to advertise to their EBGP peers");
+
+		if (suppress)
+			vty_out(vty,
+				", Advertisements suppressed by an aggregate.");
+		vty_out(vty, ")\n");
+	}
+
+	/* If we are not using addpath then we can display Advertised to and
+	 * that will
+	 * show what peers we advertised the bestpath to.  If we are using
+	 * addpath
+	 * though then we must display Advertised to on a path-by-path basis. */
+	if (!bgp_addpath_is_addpath_used(&bgp->tx_addpath, afi, safi)) {
+		for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
+			if (bgp_adj_out_lookup(peer, dest, 0)) {
+				if (json && !json_adv_to)
+					json_adv_to = json_object_new_object();
+
+				route_vty_out_advertised_to(
+					vty, peer, &first,
+					"  Advertised to non peer-group peers:\n ",
+					json_adv_to);
+			}
+		}
+
+		if (json && json_adv_to) {
+			if (incremental_print) {
+				vty_out(vty, "\"advertisedTo\": ");
+				vty_json(vty, json_adv_to);
+				vty_out(vty, ",");
+			} else
+				json_object_object_add(json, "advertisedTo",
+						       json_adv_to);
+		} else {
+			if (!json && first)
+				vty_out(vty, "  Not advertised to any peer");
+			vty_out(vty, "\n");
+		}
+	}
+}
+
+static void bgp_show_path_info(const struct prefix_rd *pfx_rd,
+			       struct bgp_dest *bgp_node, struct vty *vty,
+			       struct bgp *bgp, afi_t afi, safi_t safi,
+			       json_object *json, enum bgp_path_type pathtype,
+			       int *display, enum rpki_states rpki_target_state)
+{
+	struct bgp_path_info *pi;
+	int header = 1;
+	json_object *json_header = NULL;
+	json_object *json_paths = NULL;
+	const struct prefix *p = bgp_dest_get_prefix(bgp_node);
+
+	for (pi = bgp_dest_get_bgp_path_info(bgp_node); pi; pi = pi->next) {
+		enum rpki_states rpki_curr_state = RPKI_NOT_BEING_USED;
+
+		if (p->family == AF_INET || p->family == AF_INET6)
+			rpki_curr_state = hook_call(bgp_rpki_prefix_status,
+						    pi->peer, pi->attr, p);
+
+		if (rpki_target_state != RPKI_NOT_BEING_USED
+		    && rpki_curr_state != rpki_target_state)
+			continue;
+
+		if (json && !json_paths) {
+			/* Instantiate json_paths only if path is valid */
+			json_paths = json_object_new_array();
+			if (pfx_rd)
+				json_header = json_object_new_object();
+			else
+				json_header = json;
+		}
+
+		if (header) {
+			route_vty_out_detail_header(
+				vty, bgp, bgp_node,
+				bgp_dest_get_prefix(bgp_node), pfx_rd, AFI_IP,
+				safi, json_header, false);
+			header = 0;
+		}
+		(*display)++;
+
+		if (pathtype == BGP_PATH_SHOW_ALL
+		    || (pathtype == BGP_PATH_SHOW_BESTPATH
+			&& CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+		    || (pathtype == BGP_PATH_SHOW_MULTIPATH
+			&& (CHECK_FLAG(pi->flags, BGP_PATH_MULTIPATH)
+			    || CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))))
+			route_vty_out_detail(vty, bgp, bgp_node,
+					     bgp_dest_get_prefix(bgp_node), pi,
+					     afi, safi, rpki_curr_state,
+					     json_paths);
+	}
+
+	if (json && json_paths) {
+		json_object_object_add(json_header, "paths", json_paths);
+
+		if (pfx_rd)
+			json_object_object_addf(
+				json, json_header,
+				BGP_RD_AS_FORMAT(bgp->asnotation), pfx_rd);
+	}
+}
+
+/*
+ * Return rd based on safi
+ */
+const struct prefix_rd *bgp_rd_from_dest(const struct bgp_dest *dest,
+					 safi_t safi)
+{
+	switch (safi) {
+	case SAFI_MPLS_VPN:
+	case SAFI_ENCAP:
+	case SAFI_EVPN:
+		return (struct prefix_rd *)(bgp_dest_get_prefix(dest));
+	case SAFI_UNSPEC:
+	case SAFI_UNICAST:
+	case SAFI_MULTICAST:
+	case SAFI_LABELED_UNICAST:
+	case SAFI_FLOWSPEC:
+	case SAFI_MAX:
+		return NULL;
+	}
+
+	assert(!"Reached end of function when we were not expecting it");
+}
+
+/* Display specified route of BGP table. */
+static int bgp_show_route_in_table(struct vty *vty, struct bgp *bgp,
+				   struct bgp_table *rib, const char *ip_str,
+				   afi_t afi, safi_t safi,
+				   enum rpki_states rpki_target_state,
+				   struct prefix_rd *prd, int prefix_check,
+				   enum bgp_path_type pathtype, bool use_json)
+{
+	int ret;
+	int display = 0;
+	struct prefix match;
+	struct bgp_dest *dest;
+	struct bgp_dest *rm;
+	struct bgp_table *table;
+	json_object *json = NULL;
+	json_object *json_paths = NULL;
+
+	/* Check IP address argument. */
+	ret = str2prefix(ip_str, &match);
+	if (!ret) {
+		vty_out(vty, "address is malformed\n");
+		return CMD_WARNING;
+	}
+
+	match.family = afi2family(afi);
+
+	if (use_json)
+		json = json_object_new_object();
+
+	if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP) {
+		for (dest = bgp_table_top(rib); dest;
+		     dest = bgp_route_next(dest)) {
+			const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+			if (prd && memcmp(dest_p->u.val, prd->val, 8) != 0)
+				continue;
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			rm = bgp_node_match(table, &match);
+			if (rm == NULL)
+				continue;
+
+			const struct prefix *rm_p = bgp_dest_get_prefix(rm);
+			if (prefix_check
+			    && rm_p->prefixlen != match.prefixlen) {
+				bgp_dest_unlock_node(rm);
+				continue;
+			}
+
+			bgp_show_path_info((struct prefix_rd *)dest_p, rm, vty,
+					   bgp, afi, safi, json, pathtype,
+					   &display, rpki_target_state);
+
+			bgp_dest_unlock_node(rm);
+		}
+	} else if (safi == SAFI_EVPN) {
+		struct bgp_dest *longest_pfx;
+		bool is_exact_pfxlen_match = false;
+
+		for (dest = bgp_table_top(rib); dest;
+		     dest = bgp_route_next(dest)) {
+			const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+			if (prd && memcmp(&dest_p->u.val, prd->val, 8) != 0)
+				continue;
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			longest_pfx = NULL;
+			is_exact_pfxlen_match = false;
+			/*
+			 * Search through all the prefixes for a match.  The
+			 * pfx's are enumerated in ascending order of pfxlens.
+			 * So, the last pfx match is the longest match.  Set
+			 * is_exact_pfxlen_match when we get exact pfxlen match
+			 */
+			for (rm = bgp_table_top(table); rm;
+				rm = bgp_route_next(rm)) {
+				const struct prefix *rm_p =
+					bgp_dest_get_prefix(rm);
+				/*
+				 * Get prefixlen of the ip-prefix within type5
+				 * evpn route
+				 */
+				if (evpn_type5_prefix_match(rm_p, &match)
+				    && rm->info) {
+					longest_pfx = rm;
+					int type5_pfxlen =
+						bgp_evpn_get_type5_prefixlen(
+							rm_p);
+					if (type5_pfxlen == match.prefixlen) {
+						is_exact_pfxlen_match = true;
+						rm = bgp_dest_unlock_node(rm);
+
+						assert(rm);
+						break;
+					}
+				}
+			}
+
+			if (!longest_pfx)
+				continue;
+
+			if (prefix_check && !is_exact_pfxlen_match)
+				continue;
+
+			rm = longest_pfx;
+			bgp_dest_lock_node(rm);
+
+			bgp_show_path_info((struct prefix_rd *)dest_p, rm, vty,
+					   bgp, afi, safi, json, pathtype,
+					   &display, rpki_target_state);
+
+			bgp_dest_unlock_node(rm);
+		}
+	} else if (safi == SAFI_FLOWSPEC) {
+		if (use_json)
+			json_paths = json_object_new_array();
+
+		display = bgp_flowspec_display_match_per_ip(afi, rib,
+					   &match, prefix_check,
+					   vty,
+					   use_json,
+					   json_paths);
+		if (use_json) {
+			if (display)
+				json_object_object_add(json, "paths",
+						       json_paths);
+			else
+				json_object_free(json_paths);
+		}
+	} else {
+		dest = bgp_node_match(rib, &match);
+		if (dest != NULL) {
+			const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+			if (!prefix_check
+			    || dest_p->prefixlen == match.prefixlen) {
+				bgp_show_path_info(NULL, dest, vty, bgp, afi,
+						   safi, json, pathtype,
+						   &display, rpki_target_state);
+			}
+
+			bgp_dest_unlock_node(dest);
+		}
+	}
+
+	if (use_json) {
+		vty_json(vty, json);
+	} else {
+		if (!display) {
+			vty_out(vty, "%% Network not in table\n");
+			return CMD_WARNING;
+		}
+	}
+
+	return CMD_SUCCESS;
+}
+
+/* Display specified route of Main RIB */
+static int bgp_show_route(struct vty *vty, struct bgp *bgp, const char *ip_str,
+			  afi_t afi, safi_t safi, struct prefix_rd *prd,
+			  int prefix_check, enum bgp_path_type pathtype,
+			  enum rpki_states rpki_target_state, bool use_json)
+{
+	if (!bgp) {
+		bgp = bgp_get_default();
+		if (!bgp) {
+			if (!use_json)
+				vty_out(vty, "No BGP process is configured\n");
+			else
+				vty_out(vty, "{}\n");
+			return CMD_WARNING;
+		}
+	}
+
+	/* labeled-unicast routes live in the unicast table */
+	if (safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	return bgp_show_route_in_table(vty, bgp, bgp->rib[afi][safi], ip_str,
+				       afi, safi, rpki_target_state, prd,
+				       prefix_check, pathtype, use_json);
+}
+
+static int bgp_show_lcommunity(struct vty *vty, struct bgp *bgp, int argc,
+			       struct cmd_token **argv, bool exact, afi_t afi,
+			       safi_t safi, bool uj)
+{
+	struct lcommunity *lcom;
+	struct buffer *b;
+	int i;
+	char *str;
+	int first = 0;
+	uint16_t show_flags = 0;
+	int ret;
+
+	if (uj)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	b = buffer_new(1024);
+	for (i = 0; i < argc; i++) {
+		if (first)
+			buffer_putc(b, ' ');
+		else {
+			if (strmatch(argv[i]->text, "AA:BB:CC")) {
+				first = 1;
+				buffer_putstr(b, argv[i]->arg);
+			}
+		}
+	}
+	buffer_putc(b, '\0');
+
+	str = buffer_getstr(b);
+	buffer_free(b);
+
+	lcom = lcommunity_str2com(str);
+	XFREE(MTYPE_TMP, str);
+	if (!lcom) {
+		vty_out(vty, "%% Large-community malformed\n");
+		return CMD_WARNING;
+	}
+
+	ret = bgp_show(vty, bgp, afi, safi,
+		       (exact ? bgp_show_type_lcommunity_exact
+			      : bgp_show_type_lcommunity),
+		       lcom, show_flags, RPKI_NOT_BEING_USED);
+
+	lcommunity_free(&lcom);
+	return ret;
+}
+
+static int bgp_show_lcommunity_list(struct vty *vty, struct bgp *bgp,
+				    const char *lcom, bool exact, afi_t afi,
+				    safi_t safi, bool uj)
+{
+	struct community_list *list;
+	uint16_t show_flags = 0;
+
+	if (uj)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+
+	list = community_list_lookup(bgp_clist, lcom, 0,
+				     LARGE_COMMUNITY_LIST_MASTER);
+	if (list == NULL) {
+		vty_out(vty, "%% %s is not a valid large-community-list name\n",
+			lcom);
+		return CMD_WARNING;
+	}
+
+	return bgp_show(vty, bgp, afi, safi,
+			(exact ? bgp_show_type_lcommunity_list_exact
+			       : bgp_show_type_lcommunity_list),
+			list, show_flags, RPKI_NOT_BEING_USED);
+}
+
+DEFUN (show_ip_bgp_large_community_list,
+       show_ip_bgp_large_community_list_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] large-community-list <(1-500)|LCOMMUNITY_LIST_NAME> [exact-match] [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Display routes matching the large-community-list\n"
+       "large-community-list number\n"
+       "large-community-list name\n"
+       "Exact match of the large-communities\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	int idx = 0;
+	bool exact_match = 0;
+	struct bgp *bgp = NULL;
+	bool uj = use_json(argc, argv);
+
+	if (uj)
+		argc--;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	argv_find(argv, argc, "large-community-list", &idx);
+
+	const char *clist_number_or_name = argv[++idx]->arg;
+
+	if (++idx < argc && strmatch(argv[idx]->text, "exact-match"))
+		exact_match = 1;
+
+	return bgp_show_lcommunity_list(vty, bgp, clist_number_or_name,
+					exact_match, afi, safi, uj);
+}
+DEFUN (show_ip_bgp_large_community,
+       show_ip_bgp_large_community_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] large-community [<AA:BB:CC> [exact-match]] [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Display routes matching the large-communities\n"
+       "List of large-community numbers\n"
+       "Exact match of the large-communities\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	int idx = 0;
+	bool exact_match = 0;
+	struct bgp *bgp = NULL;
+	bool uj = use_json(argc, argv);
+	uint16_t show_flags = 0;
+
+	if (uj) {
+		argc--;
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	}
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (argv_find(argv, argc, "AA:BB:CC", &idx)) {
+		if (argv_find(argv, argc, "exact-match", &idx)) {
+			argc--;
+			exact_match = 1;
+		}
+		return bgp_show_lcommunity(vty, bgp, argc, argv,
+					exact_match, afi, safi, uj);
+	} else
+		return bgp_show(vty, bgp, afi, safi,
+				bgp_show_type_lcommunity_all, NULL, show_flags,
+				RPKI_NOT_BEING_USED);
+}
+
+static int bgp_table_stats_single(struct vty *vty, struct bgp *bgp, afi_t afi,
+				  safi_t safi, struct json_object *json_array);
+static int bgp_table_stats(struct vty *vty, struct bgp *bgp, afi_t afi,
+			   safi_t safi, struct json_object *json);
+
+
+DEFUN(show_ip_bgp_statistics_all, show_ip_bgp_statistics_all_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME] statistics-all [json]",
+      SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR
+      "Display number of prefixes for all afi/safi\n" JSON_STR)
+{
+	bool uj = use_json(argc, argv);
+	struct bgp *bgp = NULL;
+	safi_t safi = SAFI_UNICAST;
+	afi_t afi = AFI_IP6;
+	int idx = 0;
+	struct json_object *json_all = NULL;
+	struct json_object *json_afi_safi = NULL;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, false);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (uj)
+		json_all = json_object_new_object();
+
+	FOREACH_AFI_SAFI (afi, safi) {
+		/*
+		 * So limit output to those afi/safi pairs that
+		 * actually have something interesting in them
+		 */
+		if (strmatch(get_afi_safi_str(afi, safi, true),
+			     "Unknown")) {
+			continue;
+		}
+		if (uj) {
+			json_afi_safi = json_object_new_array();
+			json_object_object_add(
+					       json_all,
+					       get_afi_safi_str(afi, safi, true),
+					       json_afi_safi);
+		} else {
+			json_afi_safi = NULL;
+		}
+
+		bgp_table_stats(vty, bgp, afi, safi, json_afi_safi);
+	}
+
+	if (uj)
+		vty_json(vty, json_all);
+
+	return CMD_SUCCESS;
+}
+
+/* BGP route print out function without JSON */
+DEFUN (show_ip_bgp_l2vpn_evpn_statistics,
+       show_ip_bgp_l2vpn_evpn_statistics_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] l2vpn evpn statistics [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       L2VPN_HELP_STR
+       EVPN_HELP_STR
+       "BGP RIB advertisement statistics\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	int idx = 0, ret;
+	bool uj = use_json(argc, argv);
+	struct json_object *json_afi_safi = NULL, *json = NULL;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, false);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (uj)
+		json_afi_safi = json_object_new_array();
+	else
+		json_afi_safi = NULL;
+
+	ret = bgp_table_stats(vty, bgp, afi, safi, json_afi_safi);
+
+	if (uj) {
+		json = json_object_new_object();
+		json_object_object_add(json, get_afi_safi_str(afi, safi, true),
+				       json_afi_safi);
+		vty_json(vty, json);
+	}
+	return ret;
+}
+
+/* BGP route print out function without JSON */
+DEFUN(show_ip_bgp_afi_safi_statistics, show_ip_bgp_afi_safi_statistics_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR
+      " [" BGP_SAFI_WITH_LABEL_CMD_STR
+      "]]\
+         statistics [json]",
+      SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
+	      BGP_SAFI_WITH_LABEL_HELP_STR
+      "BGP RIB advertisement statistics\n" JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	int idx = 0, ret;
+	bool uj = use_json(argc, argv);
+	struct json_object *json_afi_safi = NULL, *json = NULL;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, false);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (uj)
+		json_afi_safi = json_object_new_array();
+	else
+		json_afi_safi = NULL;
+
+	ret = bgp_table_stats(vty, bgp, afi, safi, json_afi_safi);
+
+	if (uj) {
+		json = json_object_new_object();
+		json_object_object_add(json, get_afi_safi_str(afi, safi, true),
+				       json_afi_safi);
+		vty_json(vty, json);
+	}
+	return ret;
+}
+
+DEFPY(show_ip_bgp_dampening_params, show_ip_bgp_dampening_params_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR
+      " [" BGP_SAFI_WITH_LABEL_CMD_STR
+      "]] [all$all] dampening parameters [json]",
+      SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
+	      BGP_SAFI_WITH_LABEL_HELP_STR
+      "Display the entries for all address families\n"
+      "Display detailed information about dampening\n"
+      "Display detail of configured dampening parameters\n"
+      JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	int idx = 0;
+	uint16_t show_flags = 0;
+	bool uj = use_json(argc, argv);
+
+	if (uj) {
+		argc--;
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	}
+
+	/* [<ipv4|ipv6> [all]] */
+	if (all) {
+		SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_ALL);
+		if (argv_find(argv, argc, "ipv4", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP);
+
+		if (argv_find(argv, argc, "ipv6", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP6);
+	}
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, false);
+	if (!idx)
+		return CMD_WARNING;
+
+	return bgp_show_dampening_parameters(vty, afi, safi, show_flags);
+}
+
+/* BGP route print out function */
+DEFPY(show_ip_bgp, show_ip_bgp_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR
+      " [" BGP_SAFI_WITH_LABEL_CMD_STR
+      "]]\
+          [all$all]\
+          [cidr-only\
+          |dampening <flap-statistics|dampened-paths>\
+          |community [AA:NN|local-AS|no-advertise|no-export\
+                     |graceful-shutdown|no-peer|blackhole|llgr-stale|no-llgr\
+                     |accept-own|accept-own-nexthop|route-filter-v6\
+                     |route-filter-v4|route-filter-translated-v6\
+                     |route-filter-translated-v4] [exact-match]\
+          |community-list <(1-500)|COMMUNITY_LIST_NAME> [exact-match]\
+          |filter-list AS_PATH_FILTER_NAME\
+          |prefix-list WORD\
+          |access-list ACCESSLIST_NAME\
+          |route-map RMAP_NAME\
+          |rpki <invalid|valid|notfound>\
+          |version (1-4294967295)\
+          |alias ALIAS_NAME\
+          |A.B.C.D/M longer-prefixes\
+          |X:X::X:X/M longer-prefixes\
+          |"BGP_SELF_ORIG_CMD_STR"\
+          |detail-routes$detail_routes\
+          ] [json$uj [detail$detail_json] | wide$wide]",
+      SHOW_STR IP_STR BGP_STR BGP_INSTANCE_HELP_STR BGP_AFI_HELP_STR
+	      BGP_SAFI_WITH_LABEL_HELP_STR
+      "Display the entries for all address families\n"
+      "Display only routes with non-natural netmasks\n"
+      "Display detailed information about dampening\n"
+      "Display flap statistics of routes\n"
+      "Display paths suppressed due to dampening\n"
+      "Display routes matching the communities\n" COMMUNITY_AANN_STR
+      "Do not send outside local AS (well-known community)\n"
+      "Do not advertise to any peer (well-known community)\n"
+      "Do not export to next AS (well-known community)\n"
+      "Graceful shutdown (well-known community)\n"
+      "Do not export to any peer (well-known community)\n"
+      "Inform EBGP peers to blackhole traffic to prefix (well-known community)\n"
+      "Staled Long-lived Graceful Restart VPN route (well-known community)\n"
+      "Removed because Long-lived Graceful Restart was not enabled for VPN route (well-known community)\n"
+      "Should accept local VPN route if exported and imported into different VRF (well-known community)\n"
+      "Should accept VPN route with local nexthop (well-known community)\n"
+      "RT VPNv6 route filtering (well-known community)\n"
+      "RT VPNv4 route filtering (well-known community)\n"
+      "RT translated VPNv6 route filtering (well-known community)\n"
+      "RT translated VPNv4 route filtering (well-known community)\n"
+      "Exact match of the communities\n"
+      "Community-list number\n"
+      "Community-list name\n"
+      "Display routes matching the community-list\n"
+      "Exact match of the communities\n"
+      "Display routes conforming to the filter-list\n"
+      "Regular expression access list name\n"
+      "Display routes conforming to the prefix-list\n"
+      "Prefix-list name\n"
+      "Display routes conforming to the access-list\n"
+      "Access-list name\n"
+      "Display routes matching the route-map\n"
+      "A route-map to match on\n"
+      "RPKI route types\n"
+      "A valid path as determined by rpki\n"
+      "A invalid path as determined by rpki\n"
+      "A path that has no rpki data\n"
+      "Display prefixes with matching version numbers\n"
+      "Version number and above\n"
+      "Display prefixes with matching BGP community alias\n"
+      "BGP community alias\n"
+      "IPv4 prefix\n"
+      "Display route and more specific routes\n"
+      "IPv6 prefix\n"
+      "Display route and more specific routes\n"
+      BGP_SELF_ORIG_HELP_STR
+      "Display detailed version of all routes\n"
+      JSON_STR
+      "Display detailed version of JSON output\n"
+      "Increase table width for longer prefixes\n")
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	enum bgp_show_type sh_type = bgp_show_type_normal;
+	void *output_arg = NULL;
+	struct bgp *bgp = NULL;
+	int idx = 0;
+	int exact_match = 0;
+	char *community = NULL;
+	bool first = true;
+	uint16_t show_flags = 0;
+	enum rpki_states rpki_target_state = RPKI_NOT_BEING_USED;
+	struct prefix p;
+
+	if (uj) {
+		argc--;
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	}
+
+	if (detail_json)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON_DETAIL);
+
+	if (detail_routes)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_ROUTES_DETAIL);
+
+	/* [<ipv4|ipv6> [all]] */
+	if (all) {
+		SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_ALL);
+
+		if (argv_find(argv, argc, "ipv4", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP);
+
+		if (argv_find(argv, argc, "ipv6", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP6);
+	}
+
+	if (wide)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (argv_find(argv, argc, "cidr-only", &idx))
+		sh_type = bgp_show_type_cidr_only;
+
+	if (argv_find(argv, argc, "dampening", &idx)) {
+		if (argv_find(argv, argc, "dampened-paths", &idx))
+			sh_type = bgp_show_type_dampend_paths;
+		else if (argv_find(argv, argc, "flap-statistics", &idx))
+			sh_type = bgp_show_type_flap_statistics;
+	}
+
+	if (argv_find(argv, argc, "community", &idx)) {
+		char *maybecomm = NULL;
+
+		if (idx + 1 < argc) {
+			if (argv[idx + 1]->type == VARIABLE_TKN)
+				maybecomm = argv[idx + 1]->arg;
+			else
+				maybecomm = argv[idx + 1]->text;
+		}
+
+		if (maybecomm && !strmatch(maybecomm, "json")
+		    && !strmatch(maybecomm, "exact-match"))
+			community = maybecomm;
+
+		if (argv_find(argv, argc, "exact-match", &idx))
+			exact_match = 1;
+
+		if (!community)
+			sh_type = bgp_show_type_community_all;
+	}
+
+	if (argv_find(argv, argc, "community-list", &idx)) {
+		const char *clist_number_or_name = argv[++idx]->arg;
+		struct community_list *list;
+
+		if (argv_find(argv, argc, "exact-match", &idx))
+			exact_match = 1;
+
+		list = community_list_lookup(bgp_clist, clist_number_or_name, 0,
+					     COMMUNITY_LIST_MASTER);
+		if (list == NULL) {
+			vty_out(vty, "%% %s community-list not found\n",
+				clist_number_or_name);
+			return CMD_WARNING;
+		}
+
+		if (exact_match)
+			sh_type = bgp_show_type_community_list_exact;
+		else
+			sh_type = bgp_show_type_community_list;
+		output_arg = list;
+	}
+
+	if (argv_find(argv, argc, "filter-list", &idx)) {
+		const char *filter = argv[++idx]->arg;
+		struct as_list *as_list;
+
+		as_list = as_list_lookup(filter);
+		if (as_list == NULL) {
+			vty_out(vty, "%% %s AS-path access-list not found\n",
+				filter);
+			return CMD_WARNING;
+		}
+
+		sh_type = bgp_show_type_filter_list;
+		output_arg = as_list;
+	}
+
+	if (argv_find(argv, argc, "prefix-list", &idx)) {
+		const char *prefix_list_str = argv[++idx]->arg;
+		struct prefix_list *plist;
+
+		plist = prefix_list_lookup(afi, prefix_list_str);
+		if (plist == NULL) {
+			vty_out(vty, "%% %s prefix-list not found\n",
+				prefix_list_str);
+			return CMD_WARNING;
+		}
+
+		sh_type = bgp_show_type_prefix_list;
+		output_arg = plist;
+	}
+
+	if (argv_find(argv, argc, "access-list", &idx)) {
+		const char *access_list_str = argv[++idx]->arg;
+		struct access_list *alist;
+
+		alist = access_list_lookup(afi, access_list_str);
+		if (!alist) {
+			vty_out(vty, "%% %s access-list not found\n",
+				access_list_str);
+			return CMD_WARNING;
+		}
+
+		sh_type = bgp_show_type_access_list;
+		output_arg = alist;
+	}
+
+	if (argv_find(argv, argc, "route-map", &idx)) {
+		const char *rmap_str = argv[++idx]->arg;
+		struct route_map *rmap;
+
+		rmap = route_map_lookup_by_name(rmap_str);
+		if (!rmap) {
+			vty_out(vty, "%% %s route-map not found\n", rmap_str);
+			return CMD_WARNING;
+		}
+
+		sh_type = bgp_show_type_route_map;
+		output_arg = rmap;
+	}
+
+	if (argv_find(argv, argc, "rpki", &idx)) {
+		sh_type = bgp_show_type_rpki;
+		if (argv_find(argv, argc, "valid", &idx))
+			rpki_target_state = RPKI_VALID;
+		else if (argv_find(argv, argc, "invalid", &idx))
+			rpki_target_state = RPKI_INVALID;
+		else if (argv_find(argv, argc, "notfound", &idx))
+			rpki_target_state = RPKI_NOTFOUND;
+	}
+
+	/* Display prefixes with matching version numbers */
+	if (argv_find(argv, argc, "version", &idx)) {
+		sh_type = bgp_show_type_prefix_version;
+		output_arg = argv[idx + 1]->arg;
+	}
+
+	/* Display prefixes with matching BGP community alias */
+	if (argv_find(argv, argc, "alias", &idx)) {
+		sh_type = bgp_show_type_community_alias;
+		output_arg = argv[idx + 1]->arg;
+	}
+
+	/* prefix-longer */
+	if (argv_find(argv, argc, "A.B.C.D/M", &idx)
+	    || argv_find(argv, argc, "X:X::X:X/M", &idx)) {
+		const char *prefix_str = argv[idx]->arg;
+
+		if (!str2prefix(prefix_str, &p)) {
+			vty_out(vty, "%% Malformed Prefix\n");
+			return CMD_WARNING;
+		}
+
+		sh_type = bgp_show_type_prefix_longer;
+		output_arg = &p;
+	}
+
+	/* self originated only */
+	if (argv_find(argv, argc, BGP_SELF_ORIG_CMD_STR, &idx))
+		sh_type = bgp_show_type_self_originated;
+
+	if (!all) {
+		/* show bgp: AFI_IP6, show ip bgp: AFI_IP */
+		if (community)
+			return bgp_show_community(vty, bgp, community,
+						  exact_match, afi, safi,
+						  show_flags);
+		else
+			return bgp_show(vty, bgp, afi, safi, sh_type,
+					output_arg, show_flags,
+					rpki_target_state);
+	} else {
+		struct listnode *node;
+		struct bgp *abgp;
+		/* show <ip> bgp ipv4 all: AFI_IP, show <ip> bgp ipv6 all:
+		 * AFI_IP6 */
+
+		if (uj)
+			vty_out(vty, "{\n");
+
+		if (CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP)
+		    || CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP6)) {
+			afi = CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP)
+				      ? AFI_IP
+				      : AFI_IP6;
+			for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, abgp)) {
+				FOREACH_SAFI (safi) {
+					if (!bgp_afi_safi_peer_exists(abgp, afi,
+								      safi))
+						continue;
+
+					if (uj) {
+						if (first)
+							first = false;
+						else
+							vty_out(vty, ",\n");
+						vty_out(vty, "\"%s\":{\n",
+							get_afi_safi_str(afi,
+									 safi,
+									 true));
+					} else
+						vty_out(vty,
+							"\nFor address family: %s\n",
+							get_afi_safi_str(
+								afi, safi,
+								false));
+
+					if (community)
+						bgp_show_community(
+							vty, abgp, community,
+							exact_match, afi, safi,
+							show_flags);
+					else
+						bgp_show(vty, abgp, afi, safi,
+							 sh_type, output_arg,
+							 show_flags,
+							 rpki_target_state);
+					if (uj)
+						vty_out(vty, "}\n");
+				}
+			}
+		} else {
+			/* show <ip> bgp all: for each AFI and SAFI*/
+			for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, abgp)) {
+				FOREACH_AFI_SAFI (afi, safi) {
+					if (!bgp_afi_safi_peer_exists(abgp, afi,
+								      safi))
+						continue;
+
+					if (uj) {
+						if (first)
+							first = false;
+						else
+							vty_out(vty, ",\n");
+
+						vty_out(vty, "\"%s\":{\n",
+							get_afi_safi_str(afi,
+									 safi,
+									 true));
+
+						/* Adding 'routes' key to make
+						 * the json output format valid
+						 * for evpn
+						 */
+						if (safi == SAFI_EVPN)
+							vty_out(vty,
+								"\"routes\":");
+
+					} else
+						vty_out(vty,
+							"\nFor address family: %s\n",
+							get_afi_safi_str(
+								afi, safi,
+								false));
+
+					if (community)
+						bgp_show_community(
+							vty, abgp, community,
+							exact_match, afi, safi,
+							show_flags);
+					else
+						bgp_show(vty, abgp, afi, safi,
+							 sh_type, output_arg,
+							 show_flags,
+							 rpki_target_state);
+					if (uj)
+						vty_out(vty, "}\n");
+				}
+			}
+		}
+		if (uj)
+			vty_out(vty, "}\n");
+	}
+	return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_bgp_route,
+       show_ip_bgp_route_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]]<A.B.C.D|A.B.C.D/M|X:X::X:X|X:X::X:X/M> [<bestpath|multipath>] [rpki <valid|invalid|notfound>] [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Network in the BGP routing table to display\n"
+       "IPv4 prefix\n"
+       "Network in the BGP routing table to display\n"
+       "IPv6 prefix\n"
+       "Display only the bestpath\n"
+       "Display only multipaths\n"
+       "Display only paths that match the specified rpki state\n"
+       "A valid path as determined by rpki\n"
+       "A invalid path as determined by rpki\n"
+       "A path that has no rpki data\n"
+       JSON_STR)
+{
+	int prefix_check = 0;
+
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	char *prefix = NULL;
+	struct bgp *bgp = NULL;
+	enum bgp_path_type path_type;
+	bool uj = use_json(argc, argv);
+
+	int idx = 0;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	if (!bgp) {
+		vty_out(vty,
+			"Specified 'all' vrf's but this command currently only works per view/vrf\n");
+		return CMD_WARNING;
+	}
+
+	/* <A.B.C.D|A.B.C.D/M|X:X::X:X|X:X::X:X/M> */
+	if (argv_find(argv, argc, "A.B.C.D", &idx)
+	    || argv_find(argv, argc, "X:X::X:X", &idx))
+		prefix_check = 0;
+	else if (argv_find(argv, argc, "A.B.C.D/M", &idx)
+		 || argv_find(argv, argc, "X:X::X:X/M", &idx))
+		prefix_check = 1;
+
+	if ((argv[idx]->type == IPV6_TKN || argv[idx]->type == IPV6_PREFIX_TKN)
+	    && afi != AFI_IP6) {
+		vty_out(vty,
+			"%% Cannot specify IPv6 address or prefix with IPv4 AFI\n");
+		return CMD_WARNING;
+	}
+	if ((argv[idx]->type == IPV4_TKN || argv[idx]->type == IPV4_PREFIX_TKN)
+	    && afi != AFI_IP) {
+		vty_out(vty,
+			"%% Cannot specify IPv4 address or prefix with IPv6 AFI\n");
+		return CMD_WARNING;
+	}
+
+	prefix = argv[idx]->arg;
+
+	/* [<bestpath|multipath>] */
+	if (argv_find(argv, argc, "bestpath", &idx))
+		path_type = BGP_PATH_SHOW_BESTPATH;
+	else if (argv_find(argv, argc, "multipath", &idx))
+		path_type = BGP_PATH_SHOW_MULTIPATH;
+	else
+		path_type = BGP_PATH_SHOW_ALL;
+
+	return bgp_show_route(vty, bgp, prefix, afi, safi, NULL, prefix_check,
+			      path_type, RPKI_NOT_BEING_USED, uj);
+}
+
+DEFUN (show_ip_bgp_regexp,
+       show_ip_bgp_regexp_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] regexp REGEX [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Display routes matching the AS path regular expression\n"
+       "A regular-expression (1234567890_^|[,{}() ]$*+.?-\\) to match the BGP AS paths\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	bool uj = use_json(argc, argv);
+	char *regstr = NULL;
+
+	int idx = 0;
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, false);
+	if (!idx)
+		return CMD_WARNING;
+
+	// get index of regex
+	if (argv_find(argv, argc, "REGEX", &idx))
+		regstr = argv[idx]->arg;
+
+	assert(regstr);
+	return bgp_show_regexp(vty, bgp, (const char *)regstr, afi, safi,
+				 bgp_show_type_regexp, uj);
+}
+
+DEFPY (show_ip_bgp_instance_all,
+       show_ip_bgp_instance_all_cmd,
+       "show [ip] bgp <view|vrf> all ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] [json$uj | wide$wide]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_ALL_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       JSON_STR
+      "Increase table width for longer prefixes\n")
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	int idx = 0;
+	uint16_t show_flags = 0;
+
+	if (uj) {
+		argc--;
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	}
+
+	if (wide)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	bgp_show_all_instances_routes_vty(vty, afi, safi, show_flags);
+	return CMD_SUCCESS;
+}
+
+static int bgp_show_regexp(struct vty *vty, struct bgp *bgp, const char *regstr,
+			   afi_t afi, safi_t safi, enum bgp_show_type type,
+			   bool use_json)
+{
+	regex_t *regex;
+	int rc;
+	uint16_t show_flags = 0;
+
+	if (use_json)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	if (!config_bgp_aspath_validate(regstr)) {
+		vty_out(vty, "Invalid character in REGEX %s\n",
+			regstr);
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	regex = bgp_regcomp(regstr);
+	if (!regex) {
+		vty_out(vty, "Can't compile regexp %s\n", regstr);
+		return CMD_WARNING;
+	}
+
+	rc = bgp_show(vty, bgp, afi, safi, type, regex, show_flags,
+		      RPKI_NOT_BEING_USED);
+	bgp_regex_free(regex);
+	return rc;
+}
+
+static int bgp_show_community(struct vty *vty, struct bgp *bgp,
+			      const char *comstr, int exact, afi_t afi,
+			      safi_t safi, uint16_t show_flags)
+{
+	struct community *com;
+	int ret = 0;
+
+	com = community_str2com(comstr);
+	if (!com) {
+		vty_out(vty, "%% Community malformed: %s\n", comstr);
+		return CMD_WARNING;
+	}
+
+	ret = bgp_show(vty, bgp, afi, safi,
+		       (exact ? bgp_show_type_community_exact
+			      : bgp_show_type_community),
+		       com, show_flags, RPKI_NOT_BEING_USED);
+	community_free(&com);
+
+	return ret;
+}
+
+enum bgp_stats {
+	BGP_STATS_MAXBITLEN = 0,
+	BGP_STATS_RIB,
+	BGP_STATS_PREFIXES,
+	BGP_STATS_TOTPLEN,
+	BGP_STATS_UNAGGREGATEABLE,
+	BGP_STATS_MAX_AGGREGATEABLE,
+	BGP_STATS_AGGREGATES,
+	BGP_STATS_SPACE,
+	BGP_STATS_ASPATH_COUNT,
+	BGP_STATS_ASPATH_MAXHOPS,
+	BGP_STATS_ASPATH_TOTHOPS,
+	BGP_STATS_ASPATH_MAXSIZE,
+	BGP_STATS_ASPATH_TOTSIZE,
+	BGP_STATS_ASN_HIGHEST,
+	BGP_STATS_MAX,
+};
+
+#define TABLE_STATS_IDX_VTY 0
+#define TABLE_STATS_IDX_JSON 1
+
+static const char *table_stats_strs[][2] = {
+	[BGP_STATS_PREFIXES] = {"Total Prefixes", "totalPrefixes"},
+	[BGP_STATS_TOTPLEN] = {"Average prefix length", "averagePrefixLength"},
+	[BGP_STATS_RIB] = {"Total Advertisements", "totalAdvertisements"},
+	[BGP_STATS_UNAGGREGATEABLE] = {"Unaggregateable prefixes",
+				       "unaggregateablePrefixes"},
+	[BGP_STATS_MAX_AGGREGATEABLE] = {"Maximum aggregateable prefixes",
+					 "maximumAggregateablePrefixes"},
+	[BGP_STATS_AGGREGATES] = {"BGP Aggregate advertisements",
+				  "bgpAggregateAdvertisements"},
+	[BGP_STATS_SPACE] = {"Address space advertised",
+			     "addressSpaceAdvertised"},
+	[BGP_STATS_ASPATH_COUNT] = {"Advertisements with paths",
+				    "advertisementsWithPaths"},
+	[BGP_STATS_ASPATH_MAXHOPS] = {"Longest AS-Path (hops)",
+				      "longestAsPath"},
+	[BGP_STATS_ASPATH_MAXSIZE] = {"Largest AS-Path (bytes)",
+				      "largestAsPath"},
+	[BGP_STATS_ASPATH_TOTHOPS] = {"Average AS-Path length (hops)",
+				      "averageAsPathLengthHops"},
+	[BGP_STATS_ASPATH_TOTSIZE] = {"Average AS-Path size (bytes)",
+				      "averageAsPathSizeBytes"},
+	[BGP_STATS_ASN_HIGHEST] = {"Highest public ASN", "highestPublicAsn"},
+	[BGP_STATS_MAX] = {NULL, NULL}
+};
+
+struct bgp_table_stats {
+	struct bgp_table *table;
+	unsigned long long counts[BGP_STATS_MAX];
+
+	unsigned long long
+		prefix_len_count[MAX(EVPN_ROUTE_PREFIXLEN, IPV6_MAX_BITLEN) +
+				 1];
+
+	double total_space;
+};
+
+static void bgp_table_stats_rn(struct bgp_dest *dest, struct bgp_dest *top,
+			       struct bgp_table_stats *ts, unsigned int space)
+{
+	struct bgp_dest *pdest = bgp_dest_parent_nolock(dest);
+	struct bgp_path_info *pi;
+	const struct prefix *rn_p;
+
+	if (!bgp_dest_has_bgp_path_info_data(dest))
+		return;
+
+	rn_p = bgp_dest_get_prefix(dest);
+	ts->counts[BGP_STATS_PREFIXES]++;
+	ts->counts[BGP_STATS_TOTPLEN] += rn_p->prefixlen;
+
+	ts->prefix_len_count[rn_p->prefixlen]++;
+	/* check if the prefix is included by any other announcements */
+	while (pdest && !bgp_dest_has_bgp_path_info_data(pdest))
+		pdest = bgp_dest_parent_nolock(pdest);
+
+	if (pdest == NULL || pdest == top) {
+		ts->counts[BGP_STATS_UNAGGREGATEABLE]++;
+		/* announced address space */
+		if (space)
+			ts->total_space += pow(2.0, space - rn_p->prefixlen);
+	} else if (bgp_dest_has_bgp_path_info_data(pdest))
+		ts->counts[BGP_STATS_MAX_AGGREGATEABLE]++;
+
+
+	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
+		ts->counts[BGP_STATS_RIB]++;
+
+		if (CHECK_FLAG(pi->attr->flag,
+			       ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+			ts->counts[BGP_STATS_AGGREGATES]++;
+
+		/* as-path stats */
+		if (pi->attr->aspath) {
+			unsigned int hops = aspath_count_hops(pi->attr->aspath);
+			unsigned int size = aspath_size(pi->attr->aspath);
+			as_t highest = aspath_highest(pi->attr->aspath);
+
+			ts->counts[BGP_STATS_ASPATH_COUNT]++;
+
+			if (hops > ts->counts[BGP_STATS_ASPATH_MAXHOPS])
+				ts->counts[BGP_STATS_ASPATH_MAXHOPS] = hops;
+
+			if (size > ts->counts[BGP_STATS_ASPATH_MAXSIZE])
+				ts->counts[BGP_STATS_ASPATH_MAXSIZE] = size;
+
+			ts->counts[BGP_STATS_ASPATH_TOTHOPS] += hops;
+			ts->counts[BGP_STATS_ASPATH_TOTSIZE] += size;
+			if (highest > ts->counts[BGP_STATS_ASN_HIGHEST])
+				ts->counts[BGP_STATS_ASN_HIGHEST] = highest;
+		}
+	}
+}
+
+static void bgp_table_stats_walker(struct event *t)
+{
+	struct bgp_dest *dest, *ndest;
+	struct bgp_dest *top;
+	struct bgp_table_stats *ts = EVENT_ARG(t);
+	unsigned int space = 0;
+
+	if (!(top = bgp_table_top(ts->table)))
+		return;
+
+	switch (ts->table->afi) {
+	case AFI_IP:
+		space = IPV4_MAX_BITLEN;
+		break;
+	case AFI_IP6:
+		space = IPV6_MAX_BITLEN;
+		break;
+	case AFI_L2VPN:
+		space = EVPN_ROUTE_PREFIXLEN;
+		break;
+	case AFI_UNSPEC:
+	case AFI_MAX:
+		return;
+	}
+
+	ts->counts[BGP_STATS_MAXBITLEN] = space;
+
+	for (dest = top; dest; dest = bgp_route_next(dest)) {
+		if (ts->table->safi == SAFI_MPLS_VPN
+		    || ts->table->safi == SAFI_ENCAP
+		    || ts->table->safi == SAFI_EVPN) {
+			struct bgp_table *table;
+
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			top = bgp_table_top(table);
+			for (ndest = bgp_table_top(table); ndest;
+			     ndest = bgp_route_next(ndest))
+				bgp_table_stats_rn(ndest, top, ts, space);
+		} else {
+			bgp_table_stats_rn(dest, top, ts, space);
+		}
+	}
+}
+
+static void bgp_table_stats_all(struct vty *vty, afi_t afi, safi_t safi,
+				struct json_object *json_array)
+{
+	struct listnode *node, *nnode;
+	struct bgp *bgp;
+
+	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp))
+		bgp_table_stats_single(vty, bgp, afi, safi, json_array);
+}
+
+static int bgp_table_stats_single(struct vty *vty, struct bgp *bgp, afi_t afi,
+				  safi_t safi, struct json_object *json_array)
+{
+	struct bgp_table_stats ts;
+	unsigned int i;
+	int ret = CMD_SUCCESS;
+	char temp_buf[20];
+	struct json_object *json = NULL;
+	uint32_t bitlen = 0;
+	struct json_object *json_bitlen;
+
+	if (json_array)
+		json = json_object_new_object();
+
+	if (!bgp->rib[afi][safi]) {
+		char warning_msg[50];
+
+		snprintf(warning_msg, sizeof(warning_msg),
+			 "%% No RIB exist's for the AFI(%d)/SAFI(%d)", afi,
+			 safi);
+
+		if (!json)
+			vty_out(vty, "%s\n", warning_msg);
+		else
+			json_object_string_add(json, "warning", warning_msg);
+
+		ret = CMD_WARNING;
+		goto end_table_stats;
+	}
+
+	if (!json)
+		vty_out(vty, "BGP %s RIB statistics (%s)\n",
+			get_afi_safi_str(afi, safi, false), bgp->name_pretty);
+	else
+		json_object_string_add(json, "instance", bgp->name_pretty);
+
+	/* labeled-unicast routes live in the unicast table */
+	if (safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	memset(&ts, 0, sizeof(ts));
+	ts.table = bgp->rib[afi][safi];
+	event_execute(bm->master, bgp_table_stats_walker, &ts, 0, NULL);
+
+	for (i = 0; i < BGP_STATS_MAX; i++) {
+		if ((!json && !table_stats_strs[i][TABLE_STATS_IDX_VTY])
+		    || (json && !table_stats_strs[i][TABLE_STATS_IDX_JSON]))
+			continue;
+
+		switch (i) {
+		case BGP_STATS_ASPATH_TOTHOPS:
+		case BGP_STATS_ASPATH_TOTSIZE:
+			if (!json) {
+				snprintf(
+					temp_buf, sizeof(temp_buf), "%12.2f",
+					ts.counts[i]
+						? (float)ts.counts[i]
+							  / (float)ts.counts
+								    [BGP_STATS_ASPATH_COUNT]
+						: 0);
+				vty_out(vty, "%-30s: %s",
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_VTY],
+					temp_buf);
+			} else {
+				json_object_double_add(
+					json,
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_JSON],
+					ts.counts[i]
+						? (double)ts.counts[i]
+							  / (double)ts.counts
+							    [BGP_STATS_ASPATH_COUNT]
+						: 0);
+			}
+			break;
+		case BGP_STATS_TOTPLEN:
+			if (!json) {
+				snprintf(
+					temp_buf, sizeof(temp_buf), "%12.2f",
+					ts.counts[i]
+						? (float)ts.counts[i]
+							  / (float)ts.counts
+							    [BGP_STATS_PREFIXES]
+						: 0);
+				vty_out(vty, "%-30s: %s",
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_VTY],
+					temp_buf);
+			} else {
+				json_object_double_add(
+					json,
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_JSON],
+					ts.counts[i]
+						? (double)ts.counts[i]
+							  / (double)ts.counts
+							    [BGP_STATS_PREFIXES]
+						: 0);
+			}
+			break;
+		case BGP_STATS_SPACE:
+			if (!json) {
+				snprintf(temp_buf, sizeof(temp_buf), "%12g",
+					 ts.total_space);
+				vty_out(vty, "%-30s: %s\n",
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_VTY],
+					temp_buf);
+			} else {
+				json_object_double_add(
+					json,
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_JSON],
+					(double)ts.total_space);
+			}
+			if (afi == AFI_IP6) {
+				if (!json) {
+					snprintf(temp_buf, sizeof(temp_buf),
+						 "%12g",
+						 ts.total_space
+							 * pow(2.0, -128 + 32));
+					vty_out(vty, "%30s: %s\n",
+						"/32 equivalent %s\n",
+						temp_buf);
+				} else {
+					json_object_double_add(
+						json, "/32equivalent",
+						(double)(ts.total_space
+							 * pow(2.0,
+							       -128 + 32)));
+				}
+				if (!json) {
+					snprintf(temp_buf, sizeof(temp_buf),
+						 "%12g",
+						 ts.total_space
+							 * pow(2.0, -128 + 48));
+					vty_out(vty, "%30s: %s\n",
+						"/48 equivalent %s\n",
+						temp_buf);
+				} else {
+					json_object_double_add(
+						json, "/48equivalent",
+						(double)(ts.total_space
+							 * pow(2.0,
+							       -128 + 48)));
+				}
+			} else {
+				if (!json) {
+					snprintf(temp_buf, sizeof(temp_buf),
+						 "%12.2f",
+						 ts.total_space * 100.
+							 * pow(2.0, -32));
+					vty_out(vty, "%30s: %s\n",
+						"% announced ", temp_buf);
+				} else {
+					json_object_double_add(
+						json, "%announced",
+						(double)(ts.total_space * 100.
+							 * pow(2.0, -32)));
+				}
+				if (!json) {
+					snprintf(temp_buf, sizeof(temp_buf),
+						 "%12.2f",
+						 ts.total_space
+							 * pow(2.0, -32 + 8));
+					vty_out(vty, "%30s: %s\n",
+						"/8 equivalent ", temp_buf);
+				} else {
+					json_object_double_add(
+						json, "/8equivalent",
+						(double)(ts.total_space
+							 * pow(2.0, -32 + 8)));
+				}
+				if (!json) {
+					snprintf(temp_buf, sizeof(temp_buf),
+						 "%12.2f",
+						 ts.total_space
+							 * pow(2.0, -32 + 24));
+					vty_out(vty, "%30s: %s\n",
+						"/24 equivalent ", temp_buf);
+				} else {
+					json_object_double_add(
+						json, "/24equivalent",
+						(double)(ts.total_space
+							 * pow(2.0, -32 + 24)));
+				}
+			}
+			break;
+		default:
+			if (!json) {
+				snprintf(temp_buf, sizeof(temp_buf), "%12llu",
+					 ts.counts[i]);
+				vty_out(vty, "%-30s: %s",
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_VTY],
+					temp_buf);
+			} else {
+				json_object_int_add(
+					json,
+					table_stats_strs[i]
+							[TABLE_STATS_IDX_JSON],
+					ts.counts[i]);
+			}
+		}
+		if (!json)
+			vty_out(vty, "\n");
+	}
+
+	switch (afi) {
+	case AFI_IP:
+		bitlen = IPV4_MAX_BITLEN;
+		break;
+	case AFI_IP6:
+		bitlen = IPV6_MAX_BITLEN;
+		break;
+	case AFI_L2VPN:
+		bitlen = EVPN_ROUTE_PREFIXLEN;
+		break;
+	case AFI_UNSPEC:
+	case AFI_MAX:
+		break;
+	}
+
+	if (json) {
+		json_bitlen = json_object_new_array();
+
+		for (i = 0; i <= bitlen; i++) {
+			if (!ts.prefix_len_count[i])
+				continue;
+
+			struct json_object *ind_bit = json_object_new_object();
+
+			snprintf(temp_buf, sizeof(temp_buf), "%u", i);
+			json_object_int_add(ind_bit, temp_buf,
+					    ts.prefix_len_count[i]);
+			json_object_array_add(json_bitlen, ind_bit);
+		}
+		json_object_object_add(json, "prefixLength", json_bitlen);
+	}
+
+end_table_stats:
+	if (json)
+		json_object_array_add(json_array, json);
+	return ret;
+}
+
+static int bgp_table_stats(struct vty *vty, struct bgp *bgp, afi_t afi,
+			   safi_t safi, struct json_object *json_array)
+{
+	if (!bgp) {
+		bgp_table_stats_all(vty, afi, safi, json_array);
+		return CMD_SUCCESS;
+	}
+
+	return bgp_table_stats_single(vty, bgp, afi, safi, json_array);
+}
+
+enum bgp_pcounts {
+	PCOUNT_ADJ_IN = 0,
+	PCOUNT_DAMPED,
+	PCOUNT_REMOVED,
+	PCOUNT_HISTORY,
+	PCOUNT_STALE,
+	PCOUNT_VALID,
+	PCOUNT_ALL,
+	PCOUNT_COUNTED,
+	PCOUNT_BPATH_SELECTED,
+	PCOUNT_PFCNT, /* the figure we display to users */
+	PCOUNT_MAX,
+};
+
+static const char *const pcount_strs[] = {
+		[PCOUNT_ADJ_IN] = "Adj-in",
+		[PCOUNT_DAMPED] = "Damped",
+		[PCOUNT_REMOVED] = "Removed",
+		[PCOUNT_HISTORY] = "History",
+		[PCOUNT_STALE] = "Stale",
+		[PCOUNT_VALID] = "Valid",
+		[PCOUNT_ALL] = "All RIB",
+		[PCOUNT_COUNTED] = "PfxCt counted",
+		[PCOUNT_BPATH_SELECTED] = "PfxCt Best Selected",
+		[PCOUNT_PFCNT] = "Useable",
+		[PCOUNT_MAX] = NULL,
+};
+
+struct peer_pcounts {
+	unsigned int count[PCOUNT_MAX];
+	const struct peer *peer;
+	const struct bgp_table *table;
+	safi_t safi;
+};
+
+static void bgp_peer_count_proc(struct bgp_dest *rn, struct peer_pcounts *pc)
+{
+	const struct bgp_adj_in *ain;
+	const struct bgp_path_info *pi;
+	const struct peer *peer = pc->peer;
+
+	for (ain = rn->adj_in; ain; ain = ain->next)
+		if (ain->peer == peer)
+			pc->count[PCOUNT_ADJ_IN]++;
+
+	for (pi = bgp_dest_get_bgp_path_info(rn); pi; pi = pi->next) {
+
+		if (pi->peer != peer)
+			continue;
+
+		pc->count[PCOUNT_ALL]++;
+
+		if (CHECK_FLAG(pi->flags, BGP_PATH_DAMPED))
+			pc->count[PCOUNT_DAMPED]++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_HISTORY))
+			pc->count[PCOUNT_HISTORY]++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_REMOVED))
+			pc->count[PCOUNT_REMOVED]++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_STALE))
+			pc->count[PCOUNT_STALE]++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_VALID))
+			pc->count[PCOUNT_VALID]++;
+		if (!CHECK_FLAG(pi->flags, BGP_PATH_UNUSEABLE))
+			pc->count[PCOUNT_PFCNT]++;
+		if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+			pc->count[PCOUNT_BPATH_SELECTED]++;
+
+		if (CHECK_FLAG(pi->flags, BGP_PATH_COUNTED)) {
+			pc->count[PCOUNT_COUNTED]++;
+			if (CHECK_FLAG(pi->flags, BGP_PATH_UNUSEABLE))
+				flog_err(
+					EC_LIB_DEVELOPMENT,
+					"Attempting to count but flags say it is unusable");
+		} else {
+			if (!CHECK_FLAG(pi->flags, BGP_PATH_UNUSEABLE))
+				flog_err(
+					EC_LIB_DEVELOPMENT,
+					"Not counted but flags say we should");
+		}
+	}
+}
+
+static void bgp_peer_count_walker(struct event *t)
+{
+	struct bgp_dest *rn, *rm;
+	const struct bgp_table *table;
+	struct peer_pcounts *pc = EVENT_ARG(t);
+
+	if (pc->safi == SAFI_MPLS_VPN || pc->safi == SAFI_ENCAP
+	    || pc->safi == SAFI_EVPN) {
+		/* Special handling for 2-level routing tables. */
+		for (rn = bgp_table_top(pc->table); rn;
+		     rn = bgp_route_next(rn)) {
+			table = bgp_dest_get_bgp_table_info(rn);
+			if (table != NULL)
+				for (rm = bgp_table_top(table); rm;
+				     rm = bgp_route_next(rm))
+					bgp_peer_count_proc(rm, pc);
+		}
+	} else
+		for (rn = bgp_table_top(pc->table); rn; rn = bgp_route_next(rn))
+			bgp_peer_count_proc(rn, pc);
+}
+
+static int bgp_peer_counts(struct vty *vty, struct peer *peer, afi_t afi,
+			   safi_t safi, bool use_json)
+{
+	struct peer_pcounts pcounts = {.peer = peer};
+	unsigned int i;
+	json_object *json = NULL;
+	json_object *json_loop = NULL;
+
+	if (use_json) {
+		json = json_object_new_object();
+		json_loop = json_object_new_object();
+	}
+
+	if (!peer || !peer->bgp || !peer->afc[afi][safi]
+	    || !peer->bgp->rib[afi][safi]) {
+		if (use_json) {
+			json_object_string_add(
+				json, "warning",
+				"No such neighbor or address family");
+			vty_out(vty, "%s\n", json_object_to_json_string(json));
+			json_object_free(json);
+			json_object_free(json_loop);
+		} else
+			vty_out(vty, "%% No such neighbor or address family\n");
+
+		return CMD_WARNING;
+	}
+
+	memset(&pcounts, 0, sizeof(pcounts));
+	pcounts.peer = peer;
+	pcounts.table = peer->bgp->rib[afi][safi];
+	pcounts.safi = safi;
+
+	/* in-place call via thread subsystem so as to record execution time
+	 * stats for the thread-walk (i.e. ensure this can't be blamed on
+	 * on just vty_read()).
+	 */
+	event_execute(bm->master, bgp_peer_count_walker, &pcounts, 0, NULL);
+
+	if (use_json) {
+		json_object_string_add(json, "prefixCountsFor", peer->host);
+		json_object_string_add(json, "multiProtocol",
+				       get_afi_safi_str(afi, safi, true));
+		json_object_int_add(json, "pfxCounter",
+				    peer->pcount[afi][safi]);
+
+		for (i = 0; i < PCOUNT_MAX; i++)
+			json_object_int_add(json_loop, pcount_strs[i],
+					    pcounts.count[i]);
+
+		json_object_object_add(json, "ribTableWalkCounters", json_loop);
+
+		if (pcounts.count[PCOUNT_PFCNT] != peer->pcount[afi][safi]) {
+			json_object_string_add(json, "pfxctDriftFor",
+					       peer->host);
+			json_object_string_add(
+				json, "recommended",
+				"Please report this bug, with the above command output");
+		}
+		vty_json(vty, json);
+	} else {
+
+		if (peer->hostname
+		    && CHECK_FLAG(peer->bgp->flags, BGP_FLAG_SHOW_HOSTNAME)) {
+			vty_out(vty, "Prefix counts for %s/%s, %s\n",
+				peer->hostname, peer->host,
+				get_afi_safi_str(afi, safi, false));
+		} else {
+			vty_out(vty, "Prefix counts for %s, %s\n", peer->host,
+				get_afi_safi_str(afi, safi, false));
+		}
+
+		vty_out(vty, "PfxCt: %u\n", peer->pcount[afi][safi]);
+		vty_out(vty, "\nCounts from RIB table walk:\n\n");
+
+		for (i = 0; i < PCOUNT_MAX; i++)
+			vty_out(vty, "%20s: %-10d\n", pcount_strs[i],
+				pcounts.count[i]);
+
+		if (pcounts.count[PCOUNT_PFCNT] != peer->pcount[afi][safi]) {
+			vty_out(vty, "%s [pcount] PfxCt drift!\n", peer->host);
+			vty_out(vty,
+				"Please report this bug, with the above command output\n");
+		}
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_bgp_instance_neighbor_prefix_counts,
+       show_ip_bgp_instance_neighbor_prefix_counts_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_CMD_STR"]] neighbors <A.B.C.D|X:X::X:X|WORD> prefix-counts [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_HELP_STR
+       "Detailed information on TCP and BGP neighbor connections\n"
+       "Neighbor to display information about\n"
+       "Neighbor to display information about\n"
+       "Neighbor on BGP configured interface\n"
+       "Display detailed prefix count information\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct peer *peer;
+	int idx = 0;
+	struct bgp *bgp = NULL;
+	bool uj = use_json(argc, argv);
+
+	if (uj)
+		argc--;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	argv_find(argv, argc, "neighbors", &idx);
+	peer = peer_lookup_in_view(vty, bgp, argv[idx + 1]->arg, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	return bgp_peer_counts(vty, peer, afi, safi, uj);
+}
+
+#ifdef KEEP_OLD_VPN_COMMANDS
+DEFUN (show_ip_bgp_vpn_neighbor_prefix_counts,
+       show_ip_bgp_vpn_neighbor_prefix_counts_cmd,
+       "show [ip] bgp <vpnv4|vpnv6> all neighbors <A.B.C.D|X:X::X:X|WORD> prefix-counts [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_VPNVX_HELP_STR
+       "Display information about all VPNv4 NLRIs\n"
+       "Detailed information on TCP and BGP neighbor connections\n"
+       "Neighbor to display information about\n"
+       "Neighbor to display information about\n"
+       "Neighbor on BGP configured interface\n"
+       "Display detailed prefix count information\n"
+       JSON_STR)
+{
+	int idx_peer = 6;
+	struct peer *peer;
+	bool uj = use_json(argc, argv);
+
+	peer = peer_lookup_in_view(vty, NULL, argv[idx_peer]->arg, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	return bgp_peer_counts(vty, peer, AFI_IP, SAFI_MPLS_VPN, uj);
+}
+
+DEFUN (show_ip_bgp_vpn_all_route_prefix,
+       show_ip_bgp_vpn_all_route_prefix_cmd,
+       "show [ip] bgp <vpnv4|vpnv6> all <A.B.C.D|A.B.C.D/M> [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_VPNVX_HELP_STR
+       "Display information about all VPNv4 NLRIs\n"
+       "Network in the BGP routing table to display\n"
+       "Network in the BGP routing table to display\n"
+       JSON_STR)
+{
+	int idx = 0;
+	char *network = NULL;
+	struct bgp *bgp = bgp_get_default();
+	if (!bgp) {
+		vty_out(vty, "Can't find default instance\n");
+		return CMD_WARNING;
+	}
+
+	if (argv_find(argv, argc, "A.B.C.D", &idx))
+		network = argv[idx]->arg;
+	else if (argv_find(argv, argc, "A.B.C.D/M", &idx))
+		network = argv[idx]->arg;
+	else {
+		vty_out(vty, "Unable to figure out Network\n");
+		return CMD_WARNING;
+	}
+
+	return bgp_show_route(vty, bgp, network, AFI_IP, SAFI_MPLS_VPN, NULL, 0,
+			      BGP_PATH_SHOW_ALL, RPKI_NOT_BEING_USED,
+			      use_json(argc, argv));
+}
+#endif /* KEEP_OLD_VPN_COMMANDS */
+
+DEFUN (show_bgp_l2vpn_evpn_route_prefix,
+       show_bgp_l2vpn_evpn_route_prefix_cmd,
+       "show bgp l2vpn evpn <A.B.C.D|A.B.C.D/M|X:X::X:X|X:X::X:X/M> [json]",
+       SHOW_STR
+       BGP_STR
+       L2VPN_HELP_STR
+       EVPN_HELP_STR
+       "Network in the BGP routing table to display\n"
+       "Network in the BGP routing table to display\n"
+       "Network in the BGP routing table to display\n"
+       "Network in the BGP routing table to display\n"
+       JSON_STR)
+{
+	int idx = 0;
+	char *network = NULL;
+	int prefix_check = 0;
+
+	if (argv_find(argv, argc, "A.B.C.D", &idx) ||
+		argv_find(argv, argc, "X:X::X:X", &idx))
+		network = argv[idx]->arg;
+	else if (argv_find(argv, argc, "A.B.C.D/M", &idx) ||
+		argv_find(argv, argc, "X:X::X:X/M", &idx)) {
+		network = argv[idx]->arg;
+		prefix_check = 1;
+	} else {
+		vty_out(vty, "Unable to figure out Network\n");
+		return CMD_WARNING;
+	}
+	return bgp_show_route(vty, NULL, network, AFI_L2VPN, SAFI_EVPN, NULL,
+			      prefix_check, BGP_PATH_SHOW_ALL,
+			      RPKI_NOT_BEING_USED, use_json(argc, argv));
+}
+
+static void show_adj_route_header(struct vty *vty, struct peer *peer,
+				  struct bgp_table *table, int *header1,
+				  int *header2, json_object *json,
+				  json_object *json_scode,
+				  json_object *json_ocode, bool wide,
+				  bool detail)
+{
+	uint64_t version = table ? table->version : 0;
+
+	if (*header1) {
+		if (json) {
+			json_object_int_add(json, "bgpTableVersion", version);
+			json_object_string_addf(json, "bgpLocalRouterId",
+						"%pI4", &peer->bgp->router_id);
+			json_object_int_add(json, "defaultLocPrf",
+					    peer->bgp->default_local_pref);
+			json_object_int_add(json, "localAS",
+					    peer->change_local_as
+						    ? peer->change_local_as
+						    : peer->local_as);
+			json_object_object_add(json, "bgpStatusCodes",
+					       json_scode);
+			json_object_object_add(json, "bgpOriginCodes",
+					       json_ocode);
+		} else {
+			vty_out(vty,
+				"BGP table version is %" PRIu64
+				", local router ID is %pI4, vrf id ",
+				version, &peer->bgp->router_id);
+			if (peer->bgp->vrf_id == VRF_UNKNOWN)
+				vty_out(vty, "%s", VRFID_NONE_STR);
+			else
+				vty_out(vty, "%u", peer->bgp->vrf_id);
+			vty_out(vty, "\n");
+			vty_out(vty, "Default local pref %u, ",
+				peer->bgp->default_local_pref);
+			vty_out(vty, "local AS %u\n",
+				peer->change_local_as ? peer->change_local_as
+						      : peer->local_as);
+			if (!detail) {
+				vty_out(vty, BGP_SHOW_SCODE_HEADER);
+				vty_out(vty, BGP_SHOW_NCODE_HEADER);
+				vty_out(vty, BGP_SHOW_OCODE_HEADER);
+				vty_out(vty, BGP_SHOW_RPKI_HEADER);
+			}
+		}
+		*header1 = 0;
+	}
+	if (*header2) {
+		if (!json && !detail)
+			vty_out(vty, (wide ? BGP_SHOW_HEADER_WIDE
+					   : BGP_SHOW_HEADER));
+		*header2 = 0;
+	}
+}
+
+static void
+show_adj_route(struct vty *vty, struct peer *peer, struct bgp_table *table,
+	       afi_t afi, safi_t safi, enum bgp_show_adj_route_type type,
+	       const char *rmap_name, json_object *json, json_object *json_ar,
+	       json_object *json_scode, json_object *json_ocode,
+	       uint16_t show_flags, int *header1, int *header2, char *rd_str,
+	       const struct prefix *match, unsigned long *output_count,
+	       unsigned long *filtered_count)
+{
+	struct bgp_adj_in *ain = NULL;
+	struct bgp_adj_out *adj = NULL;
+	struct bgp_dest *dest;
+	struct bgp *bgp;
+	struct attr attr;
+	int ret;
+	struct update_subgroup *subgrp;
+	struct peer_af *paf = NULL;
+	bool route_filtered;
+	bool detail = CHECK_FLAG(show_flags, BGP_SHOW_OPT_ROUTES_DETAIL);
+	bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	bool wide = CHECK_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+	bool show_rd = ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+			|| (safi == SAFI_EVPN))
+			       ? true
+			       : false;
+	int display = 0;
+	json_object *json_net = NULL;
+
+	bgp = peer->bgp;
+
+	/* If the user supplied a prefix, look for a matching route instead
+	 * of walking the whole table.
+	 */
+	if (match) {
+		dest = bgp_node_match(table, match);
+		if (!dest) {
+			if (!use_json)
+				vty_out(vty, "Network not in table\n");
+			return;
+		}
+
+		const struct prefix *rn_p = bgp_dest_get_prefix(dest);
+
+		if (rn_p->prefixlen != match->prefixlen) {
+			if (!use_json)
+				vty_out(vty, "Network not in table\n");
+			bgp_dest_unlock_node(dest);
+			return;
+		}
+
+		if (type == bgp_show_adj_route_received ||
+		    type == bgp_show_adj_route_filtered) {
+			for (ain = dest->adj_in; ain; ain = ain->next) {
+				if (ain->peer == peer) {
+					attr = *ain->attr;
+					break;
+				}
+			}
+			/* bail out if if adj_out is empty, or
+			 * if the prefix isn't in this peer's
+			 * adj_in
+			 */
+			if (!ain || ain->peer != peer) {
+				if (!use_json)
+					vty_out(vty, "Network not in table\n");
+				bgp_dest_unlock_node(dest);
+				return;
+			}
+		} else if (type == bgp_show_adj_route_advertised) {
+			bool peer_found = false;
+
+			RB_FOREACH (adj, bgp_adj_out_rb, &dest->adj_out) {
+				SUBGRP_FOREACH_PEER (adj->subgroup, paf) {
+					if (paf->peer == peer && adj->attr) {
+						attr = *adj->attr;
+						peer_found = true;
+						break;
+					}
+				}
+				if (peer_found)
+					break;
+			}
+			/* bail out if if adj_out is empty, or
+			 * if the prefix isn't in this peer's
+			 * adj_out
+			 */
+			if (!paf || !peer_found) {
+				if (!use_json)
+					vty_out(vty, "Network not in table\n");
+				bgp_dest_unlock_node(dest);
+				return;
+			}
+		}
+
+		ret = bgp_output_modifier(peer, rn_p, &attr, afi, safi,
+					  rmap_name);
+
+		if (ret != RMAP_DENY) {
+			show_adj_route_header(vty, peer, table, header1,
+					      header2, json, json_scode,
+					      json_ocode, wide, detail);
+
+			if (use_json)
+				json_net = json_object_new_object();
+
+			bgp_show_path_info(NULL /* prefix_rd */, dest, vty, bgp,
+					   afi, safi, json_net,
+					   BGP_PATH_SHOW_ALL, &display,
+					   RPKI_NOT_BEING_USED);
+			if (use_json)
+				json_object_object_addf(json_ar, json_net,
+							"%pFX", rn_p);
+			(*output_count)++;
+		} else
+			(*filtered_count)++;
+
+		bgp_attr_flush(&attr);
+		bgp_dest_unlock_node(dest);
+		return;
+	}
+
+
+	subgrp = peer_subgroup(peer, afi, safi);
+
+	if (type == bgp_show_adj_route_advertised && subgrp
+	    && CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE)) {
+		if (use_json) {
+			json_object_int_add(json, "bgpTableVersion",
+					    table->version);
+			json_object_string_addf(json, "bgpLocalRouterId",
+						"%pI4", &bgp->router_id);
+			json_object_int_add(json, "defaultLocPrf",
+						bgp->default_local_pref);
+			json_object_int_add(json, "localAS",
+					    peer->change_local_as
+						    ? peer->change_local_as
+						    : peer->local_as);
+			json_object_object_add(json, "bgpStatusCodes",
+					       json_scode);
+			json_object_object_add(json, "bgpOriginCodes",
+					       json_ocode);
+			json_object_string_add(
+				json, "bgpOriginatingDefaultNetwork",
+				(afi == AFI_IP) ? "0.0.0.0/0" : "::/0");
+		} else {
+			vty_out(vty,
+				"BGP table version is %" PRIu64
+				", local router ID is %pI4, vrf id ",
+				table->version, &bgp->router_id);
+			if (bgp->vrf_id == VRF_UNKNOWN)
+				vty_out(vty, "%s", VRFID_NONE_STR);
+			else
+				vty_out(vty, "%u", bgp->vrf_id);
+			vty_out(vty, "\n");
+			vty_out(vty, "Default local pref %u, ",
+				bgp->default_local_pref);
+			vty_out(vty, "local AS %u\n",
+				peer->change_local_as ? peer->change_local_as
+						      : peer->local_as);
+			if (!detail) {
+				vty_out(vty, BGP_SHOW_SCODE_HEADER);
+				vty_out(vty, BGP_SHOW_NCODE_HEADER);
+				vty_out(vty, BGP_SHOW_OCODE_HEADER);
+				vty_out(vty, BGP_SHOW_RPKI_HEADER);
+			}
+
+			vty_out(vty, "Originating default network %s\n\n",
+				(afi == AFI_IP) ? "0.0.0.0/0" : "::/0");
+		}
+		(*output_count)++;
+		*header1 = 0;
+	}
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		if (type == bgp_show_adj_route_received
+		    || type == bgp_show_adj_route_filtered) {
+			for (ain = dest->adj_in; ain; ain = ain->next) {
+				if (ain->peer != peer)
+					continue;
+				show_adj_route_header(vty, peer, table, header1,
+						      header2, json, json_scode,
+						      json_ocode, wide, detail);
+
+				if ((safi == SAFI_MPLS_VPN)
+				    || (safi == SAFI_ENCAP)
+				    || (safi == SAFI_EVPN)) {
+					if (use_json)
+						json_object_string_add(
+							json_ar, "rd", rd_str);
+					else if (show_rd && rd_str) {
+						vty_out(vty,
+							"Route Distinguisher: %s\n",
+							rd_str);
+						show_rd = false;
+					}
+				}
+
+				attr = *ain->attr;
+				route_filtered = false;
+
+				/* Filter prefix using distribute list,
+				 * filter list or prefix list
+				 */
+				const struct prefix *rn_p =
+					bgp_dest_get_prefix(dest);
+				if ((bgp_input_filter(peer, rn_p, &attr, afi,
+						      safi))
+				    == FILTER_DENY)
+					route_filtered = true;
+
+				/* Filter prefix using route-map */
+				ret = bgp_input_modifier(peer, rn_p, &attr, afi,
+							 safi, rmap_name, NULL,
+							 0, NULL);
+
+				if (type == bgp_show_adj_route_filtered &&
+					!route_filtered && ret != RMAP_DENY) {
+					bgp_attr_flush(&attr);
+					continue;
+				}
+
+				if (type == bgp_show_adj_route_received
+				    && (route_filtered || ret == RMAP_DENY))
+					(*filtered_count)++;
+
+				if (detail) {
+					if (use_json)
+						json_net =
+							json_object_new_object();
+
+					struct bgp_path_info bpi;
+					struct bgp_dest buildit = *dest;
+					struct bgp_dest *pass_in;
+
+					if (route_filtered ||
+					    ret == RMAP_DENY) {
+						bpi.attr = &attr;
+						bpi.peer = peer;
+						buildit.info = &bpi;
+
+						pass_in = &buildit;
+					} else
+						pass_in = dest;
+					bgp_show_path_info(
+						NULL, pass_in, vty, bgp, afi,
+						safi, json_net,
+						BGP_PATH_SHOW_ALL, &display,
+						RPKI_NOT_BEING_USED);
+					if (use_json)
+						json_object_object_addf(
+							json_ar, json_net,
+							"%pFX", rn_p);
+				} else
+					route_vty_out_tmp(vty, dest, rn_p,
+							  &attr, safi, use_json,
+							  json_ar, wide);
+				bgp_attr_flush(&attr);
+				(*output_count)++;
+			}
+		} else if (type == bgp_show_adj_route_advertised) {
+			RB_FOREACH (adj, bgp_adj_out_rb, &dest->adj_out)
+				SUBGRP_FOREACH_PEER (adj->subgroup, paf) {
+					if (paf->peer != peer || !adj->attr)
+						continue;
+
+					show_adj_route_header(
+						vty, peer, table, header1,
+						header2, json, json_scode,
+						json_ocode, wide, detail);
+
+					const struct prefix *rn_p =
+						bgp_dest_get_prefix(dest);
+
+					attr = *adj->attr;
+					ret = bgp_output_modifier(
+						peer, rn_p, &attr, afi, safi,
+						rmap_name);
+
+					if (ret != RMAP_DENY) {
+						if ((safi == SAFI_MPLS_VPN)
+						    || (safi == SAFI_ENCAP)
+						    || (safi == SAFI_EVPN)) {
+							if (use_json)
+								json_object_string_add(
+									json_ar,
+									"rd",
+									rd_str);
+							else if (show_rd
+								 && rd_str) {
+								vty_out(vty,
+									"Route Distinguisher: %s\n",
+									rd_str);
+								show_rd = false;
+							}
+						}
+						if (detail) {
+							if (use_json)
+								json_net =
+									json_object_new_object();
+							bgp_show_path_info(
+								NULL /* prefix_rd
+								      */
+								,
+								dest, vty, bgp,
+								afi, safi,
+								json_net,
+								BGP_PATH_SHOW_ALL,
+								&display,
+								RPKI_NOT_BEING_USED);
+							if (use_json)
+								json_object_object_addf(
+									json_ar,
+									json_net,
+									"%pFX",
+									rn_p);
+						} else
+							route_vty_out_tmp(
+								vty, dest, rn_p,
+								&attr, safi,
+								use_json,
+								json_ar, wide);
+						(*output_count)++;
+					} else {
+						(*filtered_count)++;
+					}
+
+					bgp_attr_flush(&attr);
+				}
+		} else if (type == bgp_show_adj_route_bestpath) {
+			struct bgp_path_info *pi;
+
+			show_adj_route_header(vty, peer, table, header1,
+					      header2, json, json_scode,
+					      json_ocode, wide, detail);
+
+			const struct prefix *rn_p = bgp_dest_get_prefix(dest);
+
+			for (pi = bgp_dest_get_bgp_path_info(dest); pi;
+			     pi = pi->next) {
+				if (pi->peer != peer)
+					continue;
+
+				if (!CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+					continue;
+
+				if (detail) {
+					if (use_json)
+						json_net =
+							json_object_new_object();
+					bgp_show_path_info(
+						NULL /* prefix_rd */, dest, vty,
+						bgp, afi, safi, json_net,
+						BGP_PATH_SHOW_BESTPATH,
+						&display, RPKI_NOT_BEING_USED);
+					if (use_json)
+						json_object_object_addf(
+							json_ar, json_net,
+							"%pFX", rn_p);
+				} else
+					route_vty_out_tmp(
+						vty, dest, rn_p, pi->attr, safi,
+						use_json, json_ar, wide);
+				(*output_count)++;
+			}
+		}
+	}
+}
+
+static int peer_adj_routes(struct vty *vty, struct peer *peer, afi_t afi,
+			   safi_t safi, enum bgp_show_adj_route_type type,
+			   const char *rmap_name, const struct prefix *match,
+			   uint16_t show_flags)
+{
+	struct bgp *bgp;
+	struct bgp_table *table;
+	json_object *json = NULL;
+	json_object *json_scode = NULL;
+	json_object *json_ocode = NULL;
+	json_object *json_ar = NULL;
+	bool use_json = CHECK_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	/* Init BGP headers here so they're only displayed once
+	 * even if 'table' is 2-tier (MPLS_VPN, ENCAP, EVPN).
+	 */
+	int header1 = 1;
+	int header2 = 1;
+
+	/*
+	 * Initialize variables for each RD
+	 * All prefixes under an RD is aggregated within "json_routes"
+	 */
+	char rd_str[BUFSIZ] = {0};
+	json_object *json_routes = NULL;
+
+
+	/* For 2-tier tables, prefix counts need to be
+	 * maintained across multiple runs of show_adj_route()
+	 */
+	unsigned long output_count_per_rd;
+	unsigned long filtered_count_per_rd;
+	unsigned long output_count = 0;
+	unsigned long filtered_count = 0;
+
+	if (use_json) {
+		json = json_object_new_object();
+		json_ar = json_object_new_object();
+		json_scode = json_object_new_object();
+		json_ocode = json_object_new_object();
+#if CONFDATE > 20231208
+CPP_NOTICE("Drop `bgpStatusCodes` from JSON outputs")
+#endif
+		json_object_string_add(json_scode, "suppressed", "s");
+		json_object_string_add(json_scode, "damped", "d");
+		json_object_string_add(json_scode, "history", "h");
+		json_object_string_add(json_scode, "valid", "*");
+		json_object_string_add(json_scode, "best", ">");
+		json_object_string_add(json_scode, "multipath", "=");
+		json_object_string_add(json_scode, "internal", "i");
+		json_object_string_add(json_scode, "ribFailure", "r");
+		json_object_string_add(json_scode, "stale", "S");
+		json_object_string_add(json_scode, "removed", "R");
+
+#if CONFDATE > 20231208
+CPP_NOTICE("Drop `bgpOriginCodes` from JSON outputs")
+#endif
+		json_object_string_add(json_ocode, "igp", "i");
+		json_object_string_add(json_ocode, "egp", "e");
+		json_object_string_add(json_ocode, "incomplete", "?");
+	}
+
+	if (!peer || !peer->afc[afi][safi]) {
+		if (use_json) {
+			json_object_string_add(
+				json, "warning",
+				"No such neighbor or address family");
+			vty_out(vty, "%s\n", json_object_to_json_string(json));
+			json_object_free(json);
+			json_object_free(json_ar);
+			json_object_free(json_scode);
+			json_object_free(json_ocode);
+		} else
+			vty_out(vty, "%% No such neighbor or address family\n");
+
+		return CMD_WARNING;
+	}
+
+	if ((type == bgp_show_adj_route_received
+	     || type == bgp_show_adj_route_filtered)
+	    && !CHECK_FLAG(peer->af_flags[afi][safi],
+			   PEER_FLAG_SOFT_RECONFIG)) {
+		if (use_json) {
+			json_object_string_add(
+				json, "warning",
+				"Inbound soft reconfiguration not enabled");
+			vty_out(vty, "%s\n", json_object_to_json_string(json));
+			json_object_free(json);
+			json_object_free(json_ar);
+			json_object_free(json_scode);
+			json_object_free(json_ocode);
+		} else
+			vty_out(vty,
+				"%% Inbound soft reconfiguration not enabled\n");
+
+		return CMD_WARNING;
+	}
+
+	bgp = peer->bgp;
+
+	/* labeled-unicast routes live in the unicast table */
+	if (safi == SAFI_LABELED_UNICAST)
+		table = bgp->rib[afi][SAFI_UNICAST];
+	else
+		table = bgp->rib[afi][safi];
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+	    || (safi == SAFI_EVPN)) {
+
+		struct bgp_dest *dest;
+
+		for (dest = bgp_table_top(table); dest;
+		     dest = bgp_route_next(dest)) {
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+
+			output_count_per_rd = 0;
+			filtered_count_per_rd = 0;
+
+			if (use_json)
+				json_routes = json_object_new_object();
+
+			const struct prefix_rd *prd;
+			prd = (const struct prefix_rd *)bgp_dest_get_prefix(
+				dest);
+
+			prefix_rd2str(prd, rd_str, sizeof(rd_str),
+				      bgp->asnotation);
+
+			show_adj_route(
+				vty, peer, table, afi, safi, type, rmap_name,
+				json, json_routes, json_scode, json_ocode,
+				show_flags, &header1, &header2, rd_str, match,
+				&output_count_per_rd, &filtered_count_per_rd);
+
+			/* Don't include an empty RD in the output! */
+			if (json_routes && (output_count_per_rd > 0))
+				json_object_object_add(json_ar, rd_str,
+						       json_routes);
+
+			output_count += output_count_per_rd;
+			filtered_count += filtered_count_per_rd;
+		}
+	} else
+		show_adj_route(vty, peer, table, afi, safi, type, rmap_name,
+			       json, json_ar, json_scode, json_ocode,
+			       show_flags, &header1, &header2, rd_str, match,
+			       &output_count, &filtered_count);
+
+	if (use_json) {
+		if (type == bgp_show_adj_route_advertised)
+			json_object_object_add(json, "advertisedRoutes",
+					       json_ar);
+		else
+			json_object_object_add(json, "receivedRoutes", json_ar);
+		json_object_int_add(json, "totalPrefixCounter", output_count);
+		json_object_int_add(json, "filteredPrefixCounter",
+				    filtered_count);
+
+		/*
+		 * These fields only give up ownership to `json` when `header1`
+		 * is used (set to zero). See code in `show_adj_route` and
+		 * `show_adj_route_header`.
+		 */
+		if (header1 == 1) {
+			json_object_free(json_scode);
+			json_object_free(json_ocode);
+		}
+
+                /*
+                 * This is an extremely expensive operation at scale
+                 * and non-pretty reduces memory footprint significantly.
+                 */
+                vty_json_no_pretty(vty, json);
+        } else if (output_count > 0) {
+		if (!match && filtered_count > 0)
+			vty_out(vty,
+				"\nTotal number of prefixes %ld (%ld filtered)\n",
+				output_count, filtered_count);
+		else
+			vty_out(vty, "\nTotal number of prefixes %ld\n",
+				output_count);
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFPY (show_ip_bgp_instance_neighbor_bestpath_route,
+       show_ip_bgp_instance_neighbor_bestpath_route_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR " [" BGP_SAFI_WITH_LABEL_CMD_STR "]] neighbors <A.B.C.D|X:X::X:X|WORD> bestpath-routes [detail$detail] [json$uj | wide$wide]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Detailed information on TCP and BGP neighbor connections\n"
+       "Neighbor to display information about\n"
+       "Neighbor to display information about\n"
+       "Neighbor on BGP configured interface\n"
+       "Display the routes selected by best path\n"
+       "Display detailed version of routes\n"
+       JSON_STR
+       "Increase table width for longer prefixes\n")
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	char *rmap_name = NULL;
+	char *peerstr = NULL;
+	struct bgp *bgp = NULL;
+	struct peer *peer;
+	enum bgp_show_adj_route_type type = bgp_show_adj_route_bestpath;
+	int idx = 0;
+	uint16_t show_flags = 0;
+
+	if (detail)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_ROUTES_DETAIL);
+
+	if (uj)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	if (wide)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+
+	if (!idx)
+		return CMD_WARNING;
+
+	argv_find(argv, argc, "neighbors", &idx);
+	peerstr = argv[++idx]->arg;
+
+	peer = peer_lookup_in_view(vty, bgp, peerstr, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	return peer_adj_routes(vty, peer, afi, safi, type, rmap_name, NULL,
+			       show_flags);
+}
+
+DEFPY(show_ip_bgp_instance_neighbor_advertised_route,
+      show_ip_bgp_instance_neighbor_advertised_route_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME] [" BGP_AFI_CMD_STR " [" BGP_SAFI_WITH_LABEL_CMD_STR "]] [all$all] neighbors <A.B.C.D|X:X::X:X|WORD> <advertised-routes|received-routes|filtered-routes> [route-map RMAP_NAME$route_map] [<A.B.C.D/M|X:X::X:X/M>$prefix | detail$detail] [json$uj | wide$wide]",
+      SHOW_STR
+      IP_STR
+      BGP_STR
+      BGP_INSTANCE_HELP_STR
+      BGP_AFI_HELP_STR
+      BGP_SAFI_WITH_LABEL_HELP_STR
+      "Display the entries for all address families\n"
+      "Detailed information on TCP and BGP neighbor connections\n"
+      "Neighbor to display information about\n"
+      "Neighbor to display information about\n"
+      "Neighbor on BGP configured interface\n"
+      "Display the routes advertised to a BGP neighbor\n"
+      "Display the received routes from neighbor\n"
+      "Display the filtered routes received from neighbor\n"
+      "Route-map to modify the attributes\n"
+      "Name of the route map\n"
+      "IPv4 prefix\n"
+      "IPv6 prefix\n"
+      "Display detailed version of routes\n"
+      JSON_STR
+      "Increase table width for longer prefixes\n")
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	char *peerstr = NULL;
+	struct bgp *bgp = NULL;
+	struct peer *peer;
+	enum bgp_show_adj_route_type type = bgp_show_adj_route_advertised;
+	int idx = 0;
+	bool first = true;
+	uint16_t show_flags = 0;
+	struct listnode *node;
+	struct bgp *abgp;
+
+	if (detail || prefix_str)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_ROUTES_DETAIL);
+
+	if (uj) {
+		argc--;
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+	}
+
+	if (all) {
+		SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_ALL);
+		if (argv_find(argv, argc, "ipv4", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP);
+
+		if (argv_find(argv, argc, "ipv6", &idx))
+			SET_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP6);
+	}
+
+	if (wide)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_WIDE);
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	/* neighbors <A.B.C.D|X:X::X:X|WORD> */
+	argv_find(argv, argc, "neighbors", &idx);
+	peerstr = argv[++idx]->arg;
+
+	peer = peer_lookup_in_view(vty, bgp, peerstr, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	if (argv_find(argv, argc, "advertised-routes", &idx))
+		type = bgp_show_adj_route_advertised;
+	else if (argv_find(argv, argc, "received-routes", &idx))
+		type = bgp_show_adj_route_received;
+	else if (argv_find(argv, argc, "filtered-routes", &idx))
+		type = bgp_show_adj_route_filtered;
+
+	if (!all)
+		return peer_adj_routes(vty, peer, afi, safi, type, route_map,
+				       prefix_str ? prefix : NULL, show_flags);
+	if (uj)
+		vty_out(vty, "{\n");
+
+	if (CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP)
+	    || CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP6)) {
+		afi = CHECK_FLAG(show_flags, BGP_SHOW_OPT_AFI_IP) ? AFI_IP
+								  : AFI_IP6;
+		for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, abgp)) {
+			FOREACH_SAFI (safi) {
+				if (!bgp_afi_safi_peer_exists(abgp, afi, safi))
+					continue;
+
+				if (uj) {
+					if (first)
+						first = false;
+					else
+						vty_out(vty, ",\n");
+					vty_out(vty, "\"%s\":",
+						get_afi_safi_str(afi, safi,
+								 true));
+				} else
+					vty_out(vty,
+						"\nFor address family: %s\n",
+						get_afi_safi_str(afi, safi,
+								 false));
+
+				peer_adj_routes(vty, peer, afi, safi, type,
+						route_map, prefix, show_flags);
+			}
+		}
+	} else {
+		for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, abgp)) {
+			FOREACH_AFI_SAFI (afi, safi) {
+				if (!bgp_afi_safi_peer_exists(abgp, afi, safi))
+					continue;
+
+				if (uj) {
+					if (first)
+						first = false;
+					else
+						vty_out(vty, ",\n");
+					vty_out(vty, "\"%s\":",
+						get_afi_safi_str(afi, safi,
+								 true));
+				} else
+					vty_out(vty,
+						"\nFor address family: %s\n",
+						get_afi_safi_str(afi, safi,
+								 false));
+
+				peer_adj_routes(vty, peer, afi, safi, type,
+						route_map, prefix, show_flags);
+			}
+		}
+	}
+	if (uj)
+		vty_out(vty, "}\n");
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (show_ip_bgp_neighbor_received_prefix_filter,
+       show_ip_bgp_neighbor_received_prefix_filter_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] [<ipv4|ipv6> [unicast]] neighbors <A.B.C.D|X:X::X:X|WORD> received prefix-filter [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AF_STR
+       BGP_AF_STR
+       BGP_AF_MODIFIER_STR
+       "Detailed information on TCP and BGP neighbor connections\n"
+       "Neighbor to display information about\n"
+       "Neighbor to display information about\n"
+       "Neighbor on BGP configured interface\n"
+       "Display information received from a BGP neighbor\n"
+       "Display the prefixlist filter\n"
+       JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	char *peerstr = NULL;
+	char name[BUFSIZ];
+	struct peer *peer;
+	int count;
+	int idx = 0;
+	struct bgp *bgp = NULL;
+	bool uj = use_json(argc, argv);
+
+	if (uj)
+		argc--;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	/* neighbors <A.B.C.D|X:X::X:X|WORD> */
+	argv_find(argv, argc, "neighbors", &idx);
+	peerstr = argv[++idx]->arg;
+
+	peer = peer_lookup_in_view(vty, bgp, peerstr, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	snprintf(name, sizeof(name), "%s.%d.%d", peer->host, afi, safi);
+	count = prefix_bgp_show_prefix_list(NULL, afi, name, uj);
+	if (count) {
+		if (!uj)
+			vty_out(vty, "Address Family: %s\n",
+				get_afi_safi_str(afi, safi, false));
+		prefix_bgp_show_prefix_list(vty, afi, name, uj);
+	} else {
+		if (uj)
+			vty_out(vty, "{}\n");
+		else
+			vty_out(vty, "No functional output\n");
+	}
+
+	return CMD_SUCCESS;
+}
+
+static int bgp_show_neighbor_route(struct vty *vty, struct peer *peer,
+				   afi_t afi, safi_t safi,
+				   enum bgp_show_type type, bool use_json)
+{
+	uint16_t show_flags = 0;
+
+	if (use_json)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	if (!peer || !peer->afc[afi][safi]) {
+		if (use_json) {
+			json_object *json_no = NULL;
+			json_no = json_object_new_object();
+			json_object_string_add(
+				json_no, "warning",
+				"No such neighbor or address family");
+			vty_out(vty, "%s\n",
+				json_object_to_json_string(json_no));
+			json_object_free(json_no);
+		} else
+			vty_out(vty, "%% No such neighbor or address family\n");
+		return CMD_WARNING;
+	}
+
+	/* labeled-unicast routes live in the unicast table */
+	if (safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	return bgp_show(vty, peer->bgp, afi, safi, type, &peer->connection->su,
+			show_flags, RPKI_NOT_BEING_USED);
+}
+
+/*
+ * Used for "detailed" output for cmds like show bgp <afi> <safi> (or)
+ * show bgp <vrf> (or) show bgp <vrf> <afi> <safi>
+ */
+DEFPY(show_ip_bgp_vrf_afi_safi_routes_detailed,
+      show_ip_bgp_vrf_afi_safi_routes_detailed_cmd,
+      "show [ip] bgp [<view|vrf> VIEWVRFNAME$vrf_name] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] detail [json$uj]",
+      SHOW_STR
+      IP_STR
+      BGP_STR
+      BGP_INSTANCE_HELP_STR
+      BGP_AFI_HELP_STR
+      BGP_SAFI_WITH_LABEL_HELP_STR
+      "Detailed information\n"
+      JSON_STR)
+{
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct bgp *bgp = NULL;
+	int idx = 0;
+	uint16_t show_flags = BGP_SHOW_OPT_ROUTES_DETAIL;
+
+	if (uj)
+		SET_FLAG(show_flags, BGP_SHOW_OPT_JSON);
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+	/* 'vrf all' case to iterate all vrfs & show output per vrf instance */
+	if (vrf_name && strmatch(vrf_name, "all")) {
+		bgp_show_all_instances_routes_vty(vty, afi, safi, show_flags);
+		return CMD_SUCCESS;
+	}
+
+	/* All other cases except vrf all */
+	return bgp_show(vty, bgp, afi, safi, bgp_show_type_detail, NULL,
+			show_flags, RPKI_NOT_BEING_USED);
+}
+
+DEFUN (show_ip_bgp_neighbor_routes,
+       show_ip_bgp_neighbor_routes_cmd,
+       "show [ip] bgp [<view|vrf> VIEWVRFNAME] ["BGP_AFI_CMD_STR" ["BGP_SAFI_WITH_LABEL_CMD_STR"]] neighbors <A.B.C.D|X:X::X:X|WORD> <flap-statistics|dampened-routes|routes> [json]",
+       SHOW_STR
+       IP_STR
+       BGP_STR
+       BGP_INSTANCE_HELP_STR
+       BGP_AFI_HELP_STR
+       BGP_SAFI_WITH_LABEL_HELP_STR
+       "Detailed information on TCP and BGP neighbor connections\n"
+       "Neighbor to display information about\n"
+       "Neighbor to display information about\n"
+       "Neighbor on BGP configured interface\n"
+       "Display flap statistics of the routes learned from neighbor\n"
+       "Display the dampened routes received from neighbor\n"
+       "Display routes learned from neighbor\n"
+       JSON_STR)
+{
+	char *peerstr = NULL;
+	struct bgp *bgp = NULL;
+	afi_t afi = AFI_IP6;
+	safi_t safi = SAFI_UNICAST;
+	struct peer *peer;
+	enum bgp_show_type sh_type = bgp_show_type_neighbor;
+	int idx = 0;
+	bool uj = use_json(argc, argv);
+
+	if (uj)
+		argc--;
+
+	bgp_vty_find_and_parse_afi_safi_bgp(vty, argv, argc, &idx, &afi, &safi,
+					    &bgp, uj);
+	if (!idx)
+		return CMD_WARNING;
+
+	/* neighbors <A.B.C.D|X:X::X:X|WORD> */
+	argv_find(argv, argc, "neighbors", &idx);
+	peerstr = argv[++idx]->arg;
+
+	peer = peer_lookup_in_view(vty, bgp, peerstr, uj);
+	if (!peer)
+		return CMD_WARNING;
+
+	if (argv_find(argv, argc, "flap-statistics", &idx))
+		sh_type = bgp_show_type_flap_neighbor;
+	else if (argv_find(argv, argc, "dampened-routes", &idx))
+		sh_type = bgp_show_type_damp_neighbor;
+	else if (argv_find(argv, argc, "routes", &idx))
+		sh_type = bgp_show_type_neighbor;
+
+	return bgp_show_neighbor_route(vty, peer, afi, safi, sh_type, uj);
+}
+
+struct bgp_table *bgp_distance_table[AFI_MAX][SAFI_MAX];
+
+struct bgp_distance {
+	/* Distance value for the IP source prefix. */
+	uint8_t distance;
+
+	/* Name of the access-list to be matched. */
+	char *access_list;
+};
+
+DEFUN (show_bgp_afi_vpn_rd_route,
+       show_bgp_afi_vpn_rd_route_cmd,
+       "show bgp "BGP_AFI_CMD_STR" vpn rd <ASN:NN_OR_IP-ADDRESS:NN|all> <A.B.C.D/M|X:X::X:X/M> [json]",
+       SHOW_STR
+       BGP_STR
+       BGP_AFI_HELP_STR
+       BGP_AF_MODIFIER_STR
+       "Display information for a route distinguisher\n"
+       "Route Distinguisher\n"
+       "All Route Distinguishers\n"
+       "Network in the BGP routing table to display\n"
+       "Network in the BGP routing table to display\n"
+       JSON_STR)
+{
+	int ret;
+	struct prefix_rd prd;
+	afi_t afi = AFI_MAX;
+	int idx = 0;
+
+	if (!argv_find_and_parse_afi(argv, argc, &idx, &afi)) {
+		vty_out(vty, "%% Malformed Address Family\n");
+		return CMD_WARNING;
+	}
+
+	if (!strcmp(argv[5]->arg, "all"))
+		return bgp_show_route(vty, NULL, argv[6]->arg, afi,
+				      SAFI_MPLS_VPN, NULL, 0, BGP_PATH_SHOW_ALL,
+				      RPKI_NOT_BEING_USED,
+				      use_json(argc, argv));
+
+	ret = str2prefix_rd(argv[5]->arg, &prd);
+	if (!ret) {
+		vty_out(vty, "%% Malformed Route Distinguisher\n");
+		return CMD_WARNING;
+	}
+
+	return bgp_show_route(vty, NULL, argv[6]->arg, afi, SAFI_MPLS_VPN, &prd,
+			      0, BGP_PATH_SHOW_ALL, RPKI_NOT_BEING_USED,
+			      use_json(argc, argv));
+}
+
+static struct bgp_distance *bgp_distance_new(void)
+{
+	return XCALLOC(MTYPE_BGP_DISTANCE, sizeof(struct bgp_distance));
+}
+
+static void bgp_distance_free(struct bgp_distance *bdistance)
+{
+	XFREE(MTYPE_BGP_DISTANCE, bdistance);
+}
+
+static int bgp_distance_set(struct vty *vty, const char *distance_str,
+			    const char *ip_str, const char *access_list_str)
+{
+	int ret;
+	afi_t afi;
+	safi_t safi;
+	struct prefix p;
+	uint8_t distance;
+	struct bgp_dest *dest;
+	struct bgp_distance *bdistance;
+
+	afi = bgp_node_afi(vty);
+	safi = bgp_node_safi(vty);
+
+	ret = str2prefix(ip_str, &p);
+	if (ret == 0) {
+		vty_out(vty, "Malformed prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	distance = atoi(distance_str);
+
+	/* Get BGP distance node. */
+	dest = bgp_node_get(bgp_distance_table[afi][safi], &p);
+	bdistance = bgp_dest_get_bgp_distance_info(dest);
+	if (bdistance)
+		bgp_dest_unlock_node(dest);
+	else {
+		bdistance = bgp_distance_new();
+		bgp_dest_set_bgp_distance_info(dest, bdistance);
+	}
+
+	/* Set distance value. */
+	bdistance->distance = distance;
+
+	/* Reset access-list configuration. */
+	XFREE(MTYPE_AS_LIST, bdistance->access_list);
+	if (access_list_str)
+		bdistance->access_list =
+			XSTRDUP(MTYPE_AS_LIST, access_list_str);
+
+	return CMD_SUCCESS;
+}
+
+static int bgp_distance_unset(struct vty *vty, const char *distance_str,
+			      const char *ip_str, const char *access_list_str)
+{
+	int ret;
+	afi_t afi;
+	safi_t safi;
+	struct prefix p;
+	int distance;
+	struct bgp_dest *dest;
+	struct bgp_distance *bdistance;
+
+	afi = bgp_node_afi(vty);
+	safi = bgp_node_safi(vty);
+
+	ret = str2prefix(ip_str, &p);
+	if (ret == 0) {
+		vty_out(vty, "Malformed prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	dest = bgp_node_lookup(bgp_distance_table[afi][safi], &p);
+	if (!dest) {
+		vty_out(vty, "Can't find specified prefix\n");
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	bdistance = bgp_dest_get_bgp_distance_info(dest);
+	distance = atoi(distance_str);
+
+	if (bdistance->distance != distance) {
+		vty_out(vty, "Distance does not match configured\n");
+		bgp_dest_unlock_node(dest);
+		return CMD_WARNING_CONFIG_FAILED;
+	}
+
+	XFREE(MTYPE_AS_LIST, bdistance->access_list);
+	bgp_distance_free(bdistance);
+
+	bgp_dest_set_bgp_path_info(dest, NULL);
+	dest = bgp_dest_unlock_node(dest);
+	assert(dest);
+	bgp_dest_unlock_node(dest);
+
+	return CMD_SUCCESS;
+}
+
+/* Apply BGP information to distance method. */
+uint8_t bgp_distance_apply(const struct prefix *p, struct bgp_path_info *pinfo,
+			   afi_t afi, safi_t safi, struct bgp *bgp)
+{
+	struct bgp_dest *dest;
+	struct prefix q = {0};
+	struct peer *peer;
+	struct bgp_distance *bdistance;
+	struct access_list *alist;
+	struct bgp_static *bgp_static;
+	struct bgp_path_info *bpi_ultimate;
+
+	if (!bgp)
+		return 0;
+
+	peer = pinfo->peer;
+
+	if (pinfo->attr->distance)
+		return pinfo->attr->distance;
+
+	/* get peer origin to calculate appropriate distance */
+	if (pinfo->sub_type == BGP_ROUTE_IMPORTED) {
+		bpi_ultimate = bgp_get_imported_bpi_ultimate(pinfo);
+		peer = bpi_ultimate->peer;
+	}
+
+	/* Check source address.
+	 * Note: for aggregate route, peer can have unspec af type.
+	 */
+	if (pinfo->sub_type != BGP_ROUTE_AGGREGATE &&
+	    !sockunion2hostprefix(&peer->connection->su, &q))
+		return 0;
+
+	dest = bgp_node_match(bgp_distance_table[afi][safi], &q);
+	if (dest) {
+		bdistance = bgp_dest_get_bgp_distance_info(dest);
+		bgp_dest_unlock_node(dest);
+
+		if (bdistance->access_list) {
+			alist = access_list_lookup(afi, bdistance->access_list);
+			if (alist
+			    && access_list_apply(alist, p) == FILTER_PERMIT)
+				return bdistance->distance;
+		} else
+			return bdistance->distance;
+	}
+
+	/* Backdoor check. */
+	dest = bgp_node_lookup(bgp->route[afi][safi], p);
+	if (dest) {
+		bgp_static = bgp_dest_get_bgp_static_info(dest);
+		bgp_dest_unlock_node(dest);
+
+		if (bgp_static->backdoor) {
+			if (bgp->distance_local[afi][safi])
+				return bgp->distance_local[afi][safi];
+			else
+				return ZEBRA_IBGP_DISTANCE_DEFAULT;
+		}
+	}
+
+	if (peer->sort == BGP_PEER_EBGP) {
+		if (bgp->distance_ebgp[afi][safi])
+			return bgp->distance_ebgp[afi][safi];
+		return ZEBRA_EBGP_DISTANCE_DEFAULT;
+	} else if (peer->sort == BGP_PEER_IBGP) {
+		if (bgp->distance_ibgp[afi][safi])
+			return bgp->distance_ibgp[afi][safi];
+		return ZEBRA_IBGP_DISTANCE_DEFAULT;
+	} else {
+		if (bgp->distance_local[afi][safi])
+			return bgp->distance_local[afi][safi];
+		return ZEBRA_IBGP_DISTANCE_DEFAULT;
+	}
+}
+
+/* If we enter `distance bgp (1-255) (1-255) (1-255)`,
+ * we should tell ZEBRA update the routes for a specific
+ * AFI/SAFI to reflect changes in RIB.
+ */
+static void bgp_announce_routes_distance_update(struct bgp *bgp,
+						afi_t update_afi,
+						safi_t update_safi)
+{
+	afi_t afi;
+	safi_t safi;
+
+	FOREACH_AFI_SAFI (afi, safi) {
+		if (!bgp_fibupd_safi(safi))
+			continue;
+
+		if (afi != update_afi && safi != update_safi)
+			continue;
+
+		if (BGP_DEBUG(zebra, ZEBRA))
+			zlog_debug(
+				"%s: Announcing routes due to distance change afi/safi (%d/%d)",
+				__func__, afi, safi);
+		bgp_zebra_announce_table(bgp, afi, safi);
+	}
+}
+
+DEFUN (bgp_distance,
+       bgp_distance_cmd,
+       "distance bgp (1-255) (1-255) (1-255)",
+       "Define an administrative distance\n"
+       "BGP distance\n"
+       "Distance for routes external to the AS\n"
+       "Distance for routes internal to the AS\n"
+       "Distance for local routes\n")
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	int idx_number = 2;
+	int idx_number_2 = 3;
+	int idx_number_3 = 4;
+	int distance_ebgp = atoi(argv[idx_number]->arg);
+	int distance_ibgp = atoi(argv[idx_number_2]->arg);
+	int distance_local = atoi(argv[idx_number_3]->arg);
+	afi_t afi;
+	safi_t safi;
+
+	afi = bgp_node_afi(vty);
+	safi = bgp_node_safi(vty);
+
+	if (bgp->distance_ebgp[afi][safi] != distance_ebgp
+	    || bgp->distance_ibgp[afi][safi] != distance_ibgp
+	    || bgp->distance_local[afi][safi] != distance_local) {
+		bgp->distance_ebgp[afi][safi] = distance_ebgp;
+		bgp->distance_ibgp[afi][safi] = distance_ibgp;
+		bgp->distance_local[afi][safi] = distance_local;
+		bgp_announce_routes_distance_update(bgp, afi, safi);
+	}
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_bgp_distance,
+       no_bgp_distance_cmd,
+       "no distance bgp [(1-255) (1-255) (1-255)]",
+       NO_STR
+       "Define an administrative distance\n"
+       "BGP distance\n"
+       "Distance for routes external to the AS\n"
+       "Distance for routes internal to the AS\n"
+       "Distance for local routes\n")
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	afi_t afi;
+	safi_t safi;
+
+	afi = bgp_node_afi(vty);
+	safi = bgp_node_safi(vty);
+
+	if (bgp->distance_ebgp[afi][safi] != 0
+	    || bgp->distance_ibgp[afi][safi] != 0
+	    || bgp->distance_local[afi][safi] != 0) {
+		bgp->distance_ebgp[afi][safi] = 0;
+		bgp->distance_ibgp[afi][safi] = 0;
+		bgp->distance_local[afi][safi] = 0;
+		bgp_announce_routes_distance_update(bgp, afi, safi);
+	}
+	return CMD_SUCCESS;
+}
+
+
+DEFUN (bgp_distance_source,
+       bgp_distance_source_cmd,
+       "distance (1-255) A.B.C.D/M",
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n")
+{
+	int idx_number = 1;
+	int idx_ipv4_prefixlen = 2;
+	bgp_distance_set(vty, argv[idx_number]->arg,
+			 argv[idx_ipv4_prefixlen]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_bgp_distance_source,
+       no_bgp_distance_source_cmd,
+       "no distance (1-255) A.B.C.D/M",
+       NO_STR
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n")
+{
+	int idx_number = 2;
+	int idx_ipv4_prefixlen = 3;
+	bgp_distance_unset(vty, argv[idx_number]->arg,
+			   argv[idx_ipv4_prefixlen]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (bgp_distance_source_access_list,
+       bgp_distance_source_access_list_cmd,
+       "distance (1-255) A.B.C.D/M WORD",
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n"
+       "Access list name\n")
+{
+	int idx_number = 1;
+	int idx_ipv4_prefixlen = 2;
+	int idx_word = 3;
+	bgp_distance_set(vty, argv[idx_number]->arg,
+			 argv[idx_ipv4_prefixlen]->arg, argv[idx_word]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_bgp_distance_source_access_list,
+       no_bgp_distance_source_access_list_cmd,
+       "no distance (1-255) A.B.C.D/M WORD",
+       NO_STR
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n"
+       "Access list name\n")
+{
+	int idx_number = 2;
+	int idx_ipv4_prefixlen = 3;
+	int idx_word = 4;
+	bgp_distance_unset(vty, argv[idx_number]->arg,
+			   argv[idx_ipv4_prefixlen]->arg, argv[idx_word]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (ipv6_bgp_distance_source,
+       ipv6_bgp_distance_source_cmd,
+       "distance (1-255) X:X::X:X/M",
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n")
+{
+	bgp_distance_set(vty, argv[1]->arg, argv[2]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_ipv6_bgp_distance_source,
+       no_ipv6_bgp_distance_source_cmd,
+       "no distance (1-255) X:X::X:X/M",
+       NO_STR
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n")
+{
+	bgp_distance_unset(vty, argv[2]->arg, argv[3]->arg, NULL);
+	return CMD_SUCCESS;
+}
+
+DEFUN (ipv6_bgp_distance_source_access_list,
+       ipv6_bgp_distance_source_access_list_cmd,
+       "distance (1-255) X:X::X:X/M WORD",
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n"
+       "Access list name\n")
+{
+	bgp_distance_set(vty, argv[1]->arg, argv[2]->arg, argv[3]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_ipv6_bgp_distance_source_access_list,
+       no_ipv6_bgp_distance_source_access_list_cmd,
+       "no distance (1-255) X:X::X:X/M WORD",
+       NO_STR
+       "Define an administrative distance\n"
+       "Administrative distance\n"
+       "IP source prefix\n"
+       "Access list name\n")
+{
+	bgp_distance_unset(vty, argv[2]->arg, argv[3]->arg, argv[4]->arg);
+	return CMD_SUCCESS;
+}
+
+DEFUN (bgp_damp_set,
+       bgp_damp_set_cmd,
+       "bgp dampening [(1-45) [(1-20000) (1-50000) (1-255)]]",
+       "BGP Specific commands\n"
+       "Enable route-flap dampening\n"
+       "Half-life time for the penalty\n"
+       "Value to start reusing a route\n"
+       "Value to start suppressing a route\n"
+       "Maximum duration to suppress a stable route\n")
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	int idx_half_life = 2;
+	int idx_reuse = 3;
+	int idx_suppress = 4;
+	int idx_max_suppress = 5;
+	int half = DEFAULT_HALF_LIFE * 60;
+	int reuse = DEFAULT_REUSE;
+	int suppress = DEFAULT_SUPPRESS;
+	int max = 4 * half;
+
+	if (argc == 6) {
+		half = atoi(argv[idx_half_life]->arg) * 60;
+		reuse = atoi(argv[idx_reuse]->arg);
+		suppress = atoi(argv[idx_suppress]->arg);
+		max = atoi(argv[idx_max_suppress]->arg) * 60;
+	} else if (argc == 3) {
+		half = atoi(argv[idx_half_life]->arg) * 60;
+		max = 4 * half;
+	}
+
+	/*
+	 * These can't be 0 but our SA doesn't understand the
+	 * way our cli is constructed
+	 */
+	assert(reuse);
+	assert(half);
+	if (suppress < reuse) {
+		vty_out(vty,
+			"Suppress value cannot be less than reuse value \n");
+		return 0;
+	}
+
+	return bgp_damp_enable(bgp, bgp_node_afi(vty), bgp_node_safi(vty), half,
+			       reuse, suppress, max);
+}
+
+DEFUN (bgp_damp_unset,
+       bgp_damp_unset_cmd,
+       "no bgp dampening [(1-45) [(1-20000) (1-50000) (1-255)]]",
+       NO_STR
+       "BGP Specific commands\n"
+       "Enable route-flap dampening\n"
+       "Half-life time for the penalty\n"
+       "Value to start reusing a route\n"
+       "Value to start suppressing a route\n"
+       "Maximum duration to suppress a stable route\n")
+{
+	VTY_DECLVAR_CONTEXT(bgp, bgp);
+	return bgp_damp_disable(bgp, bgp_node_afi(vty), bgp_node_safi(vty));
+}
+
+/* Display specified route of BGP table. */
+static int bgp_clear_damp_route(struct vty *vty, const char *view_name,
+				const char *ip_str, afi_t afi, safi_t safi,
+				struct prefix_rd *prd, int prefix_check)
+{
+	int ret;
+	struct prefix match;
+	struct bgp_dest *dest;
+	struct bgp_dest *rm;
+	struct bgp_path_info *pi;
+	struct bgp_path_info *pi_temp;
+	struct bgp *bgp;
+	struct bgp_table *table;
+
+	/* BGP structure lookup. */
+	if (view_name) {
+		bgp = bgp_lookup_by_name(view_name);
+		if (bgp == NULL) {
+			vty_out(vty, "%% Can't find BGP instance %s\n",
+				view_name);
+			return CMD_WARNING;
+		}
+	} else {
+		bgp = bgp_get_default();
+		if (bgp == NULL) {
+			vty_out(vty, "%% No BGP process is configured\n");
+			return CMD_WARNING;
+		}
+	}
+
+	/* Check IP address argument. */
+	ret = str2prefix(ip_str, &match);
+	if (!ret) {
+		vty_out(vty, "%% address is malformed\n");
+		return CMD_WARNING;
+	}
+
+	match.family = afi2family(afi);
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)
+	    || (safi == SAFI_EVPN)) {
+		for (dest = bgp_table_top(bgp->rib[AFI_IP][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+			if (prd && memcmp(dest_p->u.val, prd->val, 8) != 0)
+				continue;
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+			rm = bgp_node_match(table, &match);
+			if (rm == NULL)
+				continue;
+
+			const struct prefix *rm_p = bgp_dest_get_prefix(dest);
+
+			if (!prefix_check
+			    || rm_p->prefixlen == match.prefixlen) {
+				pi = bgp_dest_get_bgp_path_info(rm);
+				while (pi) {
+					if (pi->extra && pi->extra->damp_info) {
+						pi_temp = pi->next;
+						bgp_damp_info_free(
+							pi->extra->damp_info,
+							1, afi, safi);
+						pi = pi_temp;
+					} else
+						pi = pi->next;
+				}
+			}
+
+			bgp_dest_unlock_node(rm);
+		}
+	} else {
+		dest = bgp_node_match(bgp->rib[afi][safi], &match);
+		if (dest != NULL) {
+			const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+			if (!prefix_check
+			    || dest_p->prefixlen == match.prefixlen) {
+				pi = bgp_dest_get_bgp_path_info(dest);
+				while (pi) {
+					if (pi->extra && pi->extra->damp_info) {
+						pi_temp = pi->next;
+						bgp_damp_info_free(
+							pi->extra->damp_info,
+							1, afi, safi);
+						pi = pi_temp;
+					} else
+						pi = pi->next;
+				}
+			}
+
+			bgp_dest_unlock_node(dest);
+		}
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (clear_ip_bgp_dampening,
+       clear_ip_bgp_dampening_cmd,
+       "clear ip bgp dampening",
+       CLEAR_STR
+       IP_STR
+       BGP_STR
+       "Clear route flap dampening information\n")
+{
+	bgp_damp_info_clean(AFI_IP, SAFI_UNICAST);
+	return CMD_SUCCESS;
+}
+
+DEFUN (clear_ip_bgp_dampening_prefix,
+       clear_ip_bgp_dampening_prefix_cmd,
+       "clear ip bgp dampening A.B.C.D/M",
+       CLEAR_STR
+       IP_STR
+       BGP_STR
+       "Clear route flap dampening information\n"
+       "IPv4 prefix\n")
+{
+	int idx_ipv4_prefixlen = 4;
+	return bgp_clear_damp_route(vty, NULL, argv[idx_ipv4_prefixlen]->arg,
+				    AFI_IP, SAFI_UNICAST, NULL, 1);
+}
+
+DEFUN (clear_ip_bgp_dampening_address,
+       clear_ip_bgp_dampening_address_cmd,
+       "clear ip bgp dampening A.B.C.D",
+       CLEAR_STR
+       IP_STR
+       BGP_STR
+       "Clear route flap dampening information\n"
+       "Network to clear damping information\n")
+{
+	int idx_ipv4 = 4;
+	return bgp_clear_damp_route(vty, NULL, argv[idx_ipv4]->arg, AFI_IP,
+				    SAFI_UNICAST, NULL, 0);
+}
+
+DEFUN (clear_ip_bgp_dampening_address_mask,
+       clear_ip_bgp_dampening_address_mask_cmd,
+       "clear ip bgp dampening A.B.C.D A.B.C.D",
+       CLEAR_STR
+       IP_STR
+       BGP_STR
+       "Clear route flap dampening information\n"
+       "Network to clear damping information\n"
+       "Network mask\n")
+{
+	int idx_ipv4 = 4;
+	int idx_ipv4_2 = 5;
+	int ret;
+	char prefix_str[BUFSIZ];
+
+	ret = netmask_str2prefix_str(argv[idx_ipv4]->arg, argv[idx_ipv4_2]->arg,
+				     prefix_str, sizeof(prefix_str));
+	if (!ret) {
+		vty_out(vty, "%% Inconsistent address and mask\n");
+		return CMD_WARNING;
+	}
+
+	return bgp_clear_damp_route(vty, NULL, prefix_str, AFI_IP, SAFI_UNICAST,
+				    NULL, 0);
+}
+
+static void show_bgp_peerhash_entry(struct hash_bucket *bucket, void *arg)
+{
+       struct vty *vty = arg;
+       struct peer *peer = bucket->data;
+
+       vty_out(vty, "\tPeer: %s %pSU\n", peer->host, &peer->connection->su);
+}
+
+DEFUN (show_bgp_listeners,
+       show_bgp_listeners_cmd,
+       "show bgp listeners",
+       SHOW_STR
+       BGP_STR
+       "Display Listen Sockets and who created them\n")
+{
+	bgp_dump_listener_info(vty);
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (show_bgp_peerhash,
+       show_bgp_peerhash_cmd,
+       "show bgp peerhash",
+       SHOW_STR
+       BGP_STR
+       "Display information about the BGP peerhash\n")
+{
+       struct list *instances = bm->bgp;
+       struct listnode *node;
+       struct bgp *bgp;
+
+       for (ALL_LIST_ELEMENTS_RO(instances, node, bgp)) {
+	       vty_out(vty, "BGP: %s\n", bgp->name_pretty);
+	       hash_iterate(bgp->peerhash, show_bgp_peerhash_entry,
+                            vty);
+       }
+
+       return CMD_SUCCESS;
+}
+
+/* also used for encap safi */
+static void bgp_config_write_network_vpn(struct vty *vty, struct bgp *bgp,
+					 afi_t afi, safi_t safi)
+{
+	struct bgp_dest *pdest;
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	const struct prefix *p;
+	struct bgp_static *bgp_static;
+	mpls_label_t label;
+
+	/* Network configuration. */
+	for (pdest = bgp_table_top(bgp->route[afi][safi]); pdest;
+	     pdest = bgp_route_next(pdest)) {
+		table = bgp_dest_get_bgp_table_info(pdest);
+		if (!table)
+			continue;
+
+		for (dest = bgp_table_top(table); dest;
+		     dest = bgp_route_next(dest)) {
+			bgp_static = bgp_dest_get_bgp_static_info(dest);
+			if (bgp_static == NULL)
+				continue;
+
+			p = bgp_dest_get_prefix(dest);
+
+			/* "network" configuration display.  */
+			label = decode_label(&bgp_static->label);
+
+			vty_out(vty, "  network %pFX rd %s", p,
+				bgp_static->prd_pretty);
+			if (safi == SAFI_MPLS_VPN)
+				vty_out(vty, " label %u", label);
+
+			if (bgp_static->rmap.name)
+				vty_out(vty, " route-map %s",
+					bgp_static->rmap.name);
+
+			if (bgp_static->backdoor)
+				vty_out(vty, " backdoor");
+
+			vty_out(vty, "\n");
+		}
+	}
+}
+
+static void bgp_config_write_network_evpn(struct vty *vty, struct bgp *bgp,
+					  afi_t afi, safi_t safi)
+{
+	struct bgp_dest *pdest;
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	const struct prefix *p;
+	struct bgp_static *bgp_static;
+	char buf[PREFIX_STRLEN * 2];
+	char buf2[SU_ADDRSTRLEN];
+	char esi_buf[ESI_STR_LEN];
+
+	/* Network configuration. */
+	for (pdest = bgp_table_top(bgp->route[afi][safi]); pdest;
+	     pdest = bgp_route_next(pdest)) {
+		table = bgp_dest_get_bgp_table_info(pdest);
+		if (!table)
+			continue;
+
+		for (dest = bgp_table_top(table); dest;
+		     dest = bgp_route_next(dest)) {
+			bgp_static = bgp_dest_get_bgp_static_info(dest);
+			if (bgp_static == NULL)
+				continue;
+
+			char *macrouter = NULL;
+
+			if (bgp_static->router_mac)
+				macrouter = prefix_mac2str(
+					bgp_static->router_mac, NULL, 0);
+			if (bgp_static->eth_s_id)
+				esi_to_str(bgp_static->eth_s_id,
+						esi_buf, sizeof(esi_buf));
+			p = bgp_dest_get_prefix(dest);
+
+			/* "network" configuration display.  */
+			if (p->u.prefix_evpn.route_type == 5) {
+				char local_buf[PREFIX_STRLEN];
+
+				uint8_t family = is_evpn_prefix_ipaddr_v4((
+							 struct prefix_evpn *)p)
+							 ? AF_INET
+							 : AF_INET6;
+				inet_ntop(family,
+					  &p->u.prefix_evpn.prefix_addr.ip.ip
+						   .addr,
+					  local_buf, sizeof(local_buf));
+				snprintf(buf, sizeof(buf), "%s/%u", local_buf,
+					 p->u.prefix_evpn.prefix_addr
+						 .ip_prefix_length);
+			} else {
+				prefix2str(p, buf, sizeof(buf));
+			}
+
+			if (bgp_static->gatewayIp.family == AF_INET
+			    || bgp_static->gatewayIp.family == AF_INET6)
+				inet_ntop(bgp_static->gatewayIp.family,
+					  &bgp_static->gatewayIp.u.prefix, buf2,
+					  sizeof(buf2));
+			vty_out(vty,
+				"  network %s rd %s ethtag %u label %u esi %s gwip %s routermac %s\n",
+				buf, bgp_static->prd_pretty,
+				p->u.prefix_evpn.prefix_addr.eth_tag,
+				decode_label(&bgp_static->label), esi_buf, buf2,
+				macrouter);
+
+			XFREE(MTYPE_TMP, macrouter);
+		}
+	}
+}
+
+/* Configuration of static route announcement and aggregate
+   information. */
+void bgp_config_write_network(struct vty *vty, struct bgp *bgp, afi_t afi,
+			      safi_t safi)
+{
+	struct bgp_dest *dest;
+	const struct prefix *p;
+	struct bgp_static *bgp_static;
+	struct bgp_aggregate *bgp_aggregate;
+
+	if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_ENCAP)) {
+		bgp_config_write_network_vpn(vty, bgp, afi, safi);
+		return;
+	}
+
+	if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
+		bgp_config_write_network_evpn(vty, bgp, afi, safi);
+		return;
+	}
+
+	/* Network configuration. */
+	for (dest = bgp_table_top(bgp->route[afi][safi]); dest;
+	     dest = bgp_route_next(dest)) {
+		bgp_static = bgp_dest_get_bgp_static_info(dest);
+		if (bgp_static == NULL)
+			continue;
+
+		p = bgp_dest_get_prefix(dest);
+
+		vty_out(vty, "  network %pFX", p);
+
+		if (bgp_static->label_index != BGP_INVALID_LABEL_INDEX)
+			vty_out(vty, " label-index %u",
+				bgp_static->label_index);
+
+		if (bgp_static->rmap.name)
+			vty_out(vty, " route-map %s", bgp_static->rmap.name);
+
+		if (bgp_static->backdoor)
+			vty_out(vty, " backdoor");
+
+		vty_out(vty, "\n");
+	}
+
+	/* Aggregate-address configuration. */
+	for (dest = bgp_table_top(bgp->aggregate[afi][safi]); dest;
+	     dest = bgp_route_next(dest)) {
+		bgp_aggregate = bgp_dest_get_bgp_aggregate_info(dest);
+		if (bgp_aggregate == NULL)
+			continue;
+
+		p = bgp_dest_get_prefix(dest);
+
+		vty_out(vty, "  aggregate-address %pFX", p);
+
+		if (bgp_aggregate->as_set)
+			vty_out(vty, " as-set");
+
+		if (bgp_aggregate->summary_only)
+			vty_out(vty, " summary-only");
+
+		if (bgp_aggregate->rmap.name)
+			vty_out(vty, " route-map %s", bgp_aggregate->rmap.name);
+
+		if (bgp_aggregate->origin != BGP_ORIGIN_UNSPECIFIED)
+			vty_out(vty, " origin %s",
+				bgp_origin2str(bgp_aggregate->origin));
+
+		if (bgp_aggregate->match_med)
+			vty_out(vty, " matching-MED-only");
+
+		if (bgp_aggregate->suppress_map_name)
+			vty_out(vty, " suppress-map %s",
+				bgp_aggregate->suppress_map_name);
+
+		vty_out(vty, "\n");
+	}
+}
+
+void bgp_config_write_distance(struct vty *vty, struct bgp *bgp, afi_t afi,
+			       safi_t safi)
+{
+	struct bgp_dest *dest;
+	struct bgp_distance *bdistance;
+
+	/* Distance configuration. */
+	if (bgp->distance_ebgp[afi][safi] && bgp->distance_ibgp[afi][safi]
+	    && bgp->distance_local[afi][safi]
+	    && (bgp->distance_ebgp[afi][safi] != ZEBRA_EBGP_DISTANCE_DEFAULT
+		|| bgp->distance_ibgp[afi][safi] != ZEBRA_IBGP_DISTANCE_DEFAULT
+		|| bgp->distance_local[afi][safi]
+			   != ZEBRA_IBGP_DISTANCE_DEFAULT)) {
+		vty_out(vty, "  distance bgp %d %d %d\n",
+			bgp->distance_ebgp[afi][safi],
+			bgp->distance_ibgp[afi][safi],
+			bgp->distance_local[afi][safi]);
+	}
+
+	for (dest = bgp_table_top(bgp_distance_table[afi][safi]); dest;
+	     dest = bgp_route_next(dest)) {
+		bdistance = bgp_dest_get_bgp_distance_info(dest);
+		if (bdistance != NULL)
+			vty_out(vty, "  distance %d %pBD %s\n",
+				bdistance->distance, dest,
+				bdistance->access_list ? bdistance->access_list
+						       : "");
+	}
+}
+
+/* Allocate routing table structure and install commands. */
+void bgp_route_init(void)
+{
+	afi_t afi;
+	safi_t safi;
+
+	/* Init BGP distance table. */
+	FOREACH_AFI_SAFI (afi, safi)
+		bgp_distance_table[afi][safi] = bgp_table_init(NULL, afi, safi);
+
+	/* IPv4 BGP commands. */
+	install_element(BGP_NODE, &bgp_table_map_cmd);
+	install_element(BGP_NODE, &bgp_network_cmd);
+	install_element(BGP_NODE, &no_bgp_table_map_cmd);
+
+	install_element(BGP_NODE, &aggregate_addressv4_cmd);
+
+	/* IPv4 unicast configuration.  */
+	install_element(BGP_IPV4_NODE, &bgp_table_map_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_network_cmd);
+	install_element(BGP_IPV4_NODE, &no_bgp_table_map_cmd);
+
+	install_element(BGP_IPV4_NODE, &aggregate_addressv4_cmd);
+
+	/* IPv4 multicast configuration.  */
+	install_element(BGP_IPV4M_NODE, &bgp_table_map_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_network_cmd);
+	install_element(BGP_IPV4M_NODE, &no_bgp_table_map_cmd);
+	install_element(BGP_IPV4M_NODE, &aggregate_addressv4_cmd);
+
+	/* IPv4 labeled-unicast configuration.  */
+	install_element(BGP_IPV4L_NODE, &bgp_network_cmd);
+	install_element(BGP_IPV4L_NODE, &aggregate_addressv4_cmd);
+
+	install_element(VIEW_NODE, &show_ip_bgp_instance_all_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_afi_safi_statistics_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_l2vpn_evpn_statistics_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_dampening_params_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_route_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_regexp_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_statistics_all_cmd);
+
+	install_element(VIEW_NODE,
+			&show_ip_bgp_instance_neighbor_advertised_route_cmd);
+	install_element(VIEW_NODE,
+			&show_ip_bgp_instance_neighbor_bestpath_route_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_neighbor_routes_cmd);
+	install_element(VIEW_NODE,
+			&show_ip_bgp_neighbor_received_prefix_filter_cmd);
+#ifdef KEEP_OLD_VPN_COMMANDS
+	install_element(VIEW_NODE, &show_ip_bgp_vpn_all_route_prefix_cmd);
+#endif /* KEEP_OLD_VPN_COMMANDS */
+	install_element(VIEW_NODE, &show_bgp_afi_vpn_rd_route_cmd);
+	install_element(VIEW_NODE,
+			&show_bgp_l2vpn_evpn_route_prefix_cmd);
+
+	/* BGP dampening clear commands */
+	install_element(ENABLE_NODE, &clear_ip_bgp_dampening_cmd);
+	install_element(ENABLE_NODE, &clear_ip_bgp_dampening_prefix_cmd);
+
+	install_element(ENABLE_NODE, &clear_ip_bgp_dampening_address_cmd);
+	install_element(ENABLE_NODE, &clear_ip_bgp_dampening_address_mask_cmd);
+
+	/* prefix count */
+	install_element(ENABLE_NODE,
+			&show_ip_bgp_instance_neighbor_prefix_counts_cmd);
+#ifdef KEEP_OLD_VPN_COMMANDS
+	install_element(ENABLE_NODE,
+			&show_ip_bgp_vpn_neighbor_prefix_counts_cmd);
+#endif /* KEEP_OLD_VPN_COMMANDS */
+
+	/* New config IPv6 BGP commands.  */
+	install_element(BGP_IPV6_NODE, &bgp_table_map_cmd);
+	install_element(BGP_IPV6_NODE, &ipv6_bgp_network_cmd);
+	install_element(BGP_IPV6_NODE, &no_bgp_table_map_cmd);
+
+	install_element(BGP_IPV6_NODE, &aggregate_addressv6_cmd);
+
+	install_element(BGP_IPV6M_NODE, &ipv6_bgp_network_cmd);
+
+	/* IPv6 labeled unicast address family. */
+	install_element(BGP_IPV6L_NODE, &ipv6_bgp_network_cmd);
+	install_element(BGP_IPV6L_NODE, &aggregate_addressv6_cmd);
+
+	install_element(BGP_NODE, &bgp_distance_cmd);
+	install_element(BGP_NODE, &no_bgp_distance_cmd);
+	install_element(BGP_NODE, &bgp_distance_source_cmd);
+	install_element(BGP_NODE, &no_bgp_distance_source_cmd);
+	install_element(BGP_NODE, &bgp_distance_source_access_list_cmd);
+	install_element(BGP_NODE, &no_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_distance_cmd);
+	install_element(BGP_IPV4_NODE, &no_bgp_distance_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_distance_source_cmd);
+	install_element(BGP_IPV4_NODE, &no_bgp_distance_source_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV4_NODE, &no_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_distance_cmd);
+	install_element(BGP_IPV4M_NODE, &no_bgp_distance_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_distance_source_cmd);
+	install_element(BGP_IPV4M_NODE, &no_bgp_distance_source_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV4M_NODE,
+			&no_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV6_NODE, &bgp_distance_cmd);
+	install_element(BGP_IPV6_NODE, &no_bgp_distance_cmd);
+	install_element(BGP_IPV6_NODE, &ipv6_bgp_distance_source_cmd);
+	install_element(BGP_IPV6_NODE, &no_ipv6_bgp_distance_source_cmd);
+	install_element(BGP_IPV6_NODE,
+			&ipv6_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV6_NODE,
+			&no_ipv6_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV6M_NODE, &bgp_distance_cmd);
+	install_element(BGP_IPV6M_NODE, &no_bgp_distance_cmd);
+	install_element(BGP_IPV6M_NODE, &ipv6_bgp_distance_source_cmd);
+	install_element(BGP_IPV6M_NODE, &no_ipv6_bgp_distance_source_cmd);
+	install_element(BGP_IPV6M_NODE,
+			&ipv6_bgp_distance_source_access_list_cmd);
+	install_element(BGP_IPV6M_NODE,
+			&no_ipv6_bgp_distance_source_access_list_cmd);
+
+	/* BGP dampening */
+	install_element(BGP_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV4_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV4M_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV4L_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV4L_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV6_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV6_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV6M_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV6M_NODE, &bgp_damp_unset_cmd);
+	install_element(BGP_IPV6L_NODE, &bgp_damp_set_cmd);
+	install_element(BGP_IPV6L_NODE, &bgp_damp_unset_cmd);
+
+	/* Large Communities */
+	install_element(VIEW_NODE, &show_ip_bgp_large_community_list_cmd);
+	install_element(VIEW_NODE, &show_ip_bgp_large_community_cmd);
+
+	/* show bgp vrf <afi> <safi> detailed */
+	install_element(VIEW_NODE,
+			&show_ip_bgp_vrf_afi_safi_routes_detailed_cmd);
+
+	install_element(VIEW_NODE, &show_bgp_listeners_cmd);
+	install_element(VIEW_NODE, &show_bgp_peerhash_cmd);
+}
+
+void bgp_route_finish(void)
+{
+	afi_t afi;
+	safi_t safi;
+
+	FOREACH_AFI_SAFI (afi, safi) {
+		bgp_table_unlock(bgp_distance_table[afi][safi]);
+		bgp_distance_table[afi][safi] = NULL;
+	}
+}