[mirror_frr.git] / bgpd / bgp_nexthop.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* BGP nexthop scan
 * Copyright (C) 2000 Kunihiro Ishiguro
 */

#include <zebra.h>

#include "command.h"
#include "frrevent.h"
#include "prefix.h"
#include "lib/json.h"
#include "zclient.h"
#include "stream.h"
#include "network.h"
#include "log.h"
#include "memory.h"
#include "hash.h"
#include "jhash.h"
#include "nexthop.h"
#include "queue.h"
#include "filter.h"
#include "printfrr.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_nexthop.h"
#include "bgpd/bgp_nht.h"
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_damp.h"
#include "bgpd/bgp_fsm.h"
#include "bgpd/bgp_vty.h"
#include "bgpd/bgp_rd.h"
#include "bgpd/bgp_mplsvpn.h"

DEFINE_MTYPE_STATIC(BGPD, MARTIAN_STRING, "BGP Martian Addr Intf String");

int bgp_nexthop_cache_compare(const struct bgp_nexthop_cache *a,
			      const struct bgp_nexthop_cache *b)
{
	if (a->srte_color < b->srte_color)
		return -1;
	if (a->srte_color > b->srte_color)
		return 1;

	if (a->ifindex < b->ifindex)
		return -1;
	if (a->ifindex > b->ifindex)
		return 1;

	return prefix_cmp(&a->prefix, &b->prefix);
}

void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
{
	nexthops_free(bnc->nexthop);
}

struct bgp_nexthop_cache *bnc_new(struct bgp_nexthop_cache_head *tree,
				  struct prefix *prefix, uint32_t srte_color,
				  ifindex_t ifindex)
{
	struct bgp_nexthop_cache *bnc;

	bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
		      sizeof(struct bgp_nexthop_cache));
	bnc->prefix = *prefix;
	bnc->ifindex = ifindex;
	bnc->srte_color = srte_color;
	bnc->tree = tree;
	LIST_INIT(&(bnc->paths));
	bgp_nexthop_cache_add(tree, bnc);

	return bnc;
}

bool bnc_existing_for_prefix(struct bgp_nexthop_cache *bnc)
{
	struct bgp_nexthop_cache *bnc_tmp;

	frr_each (bgp_nexthop_cache, bnc->tree, bnc_tmp) {
		if (bnc_tmp == bnc)
			continue;
		if (prefix_cmp(&bnc->prefix, &bnc_tmp->prefix) == 0)
			return true;
	}
	return false;
}

void bnc_free(struct bgp_nexthop_cache *bnc)
{
	bnc_nexthop_free(bnc);
	bgp_nexthop_cache_del(bnc->tree, bnc);
	XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
}

struct bgp_nexthop_cache *bnc_find(struct bgp_nexthop_cache_head *tree,
				   struct prefix *prefix, uint32_t srte_color,
				   ifindex_t ifindex)
{
	struct bgp_nexthop_cache bnc = {};

	if (!tree)
		return NULL;

	bnc.prefix = *prefix;
	bnc.srte_color = srte_color;
	bnc.ifindex = ifindex;
	return bgp_nexthop_cache_find(tree, &bnc);
}

/* Reset and free all BGP nexthop cache. */
static void bgp_nexthop_cache_reset(struct bgp_nexthop_cache_head *tree)
{
	struct bgp_nexthop_cache *bnc;

	while (bgp_nexthop_cache_count(tree) > 0) {
		bnc = bgp_nexthop_cache_first(tree);

		while (!LIST_EMPTY(&(bnc->paths))) {
			struct bgp_path_info *path = LIST_FIRST(&(bnc->paths));

			bgp_mplsvpn_path_nh_label_unlink(path);

			path_nh_map(path, bnc, false);
		}

		bnc_free(bnc);
	}
}

static void *bgp_tip_hash_alloc(void *p)
{
	const struct in_addr *val = (const struct in_addr *)p;
	struct tip_addr *addr;

	addr = XMALLOC(MTYPE_TIP_ADDR, sizeof(struct tip_addr));
	addr->refcnt = 0;
	addr->addr.s_addr = val->s_addr;

	return addr;
}

static void bgp_tip_hash_free(void *addr)
{
	XFREE(MTYPE_TIP_ADDR, addr);
}

static unsigned int bgp_tip_hash_key_make(const void *p)
{
	const struct tip_addr *addr = p;

	return jhash_1word(addr->addr.s_addr, 0);
}

static bool bgp_tip_hash_cmp(const void *p1, const void *p2)
{
	const struct tip_addr *addr1 = p1;
	const struct tip_addr *addr2 = p2;

	return addr1->addr.s_addr == addr2->addr.s_addr;
}

void bgp_tip_hash_init(struct bgp *bgp)
{
	bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
				    "BGP TIP hash");
}

void bgp_tip_hash_destroy(struct bgp *bgp)
{
	hash_clean_and_free(&bgp->tip_hash, bgp_tip_hash_free);
}

/* Add/Update Tunnel-IP entry of bgp martian next-hop table.
 *
 * Returns true only if we add a _new_ TIP so the caller knows that an
 * actionable change has occurred. If we find an existing TIP then we
 * only need to update the refcnt, since the collection of known TIPs
 * has not changed.
 */
bool bgp_tip_add(struct bgp *bgp, struct in_addr *tip)
{
	struct tip_addr tmp;
	struct tip_addr *addr;
	bool tip_added = false;

	tmp.addr = *tip;

	addr = hash_lookup(bgp->tip_hash, &tmp);
	if (!addr) {
		addr = hash_get(bgp->tip_hash, &tmp, bgp_tip_hash_alloc);
		tip_added = true;
	}

	addr->refcnt++;

	return tip_added;
}

void bgp_tip_del(struct bgp *bgp, struct in_addr *tip)
{
	struct tip_addr tmp;
	struct tip_addr *addr;

	tmp.addr = *tip;

	addr = hash_lookup(bgp->tip_hash, &tmp);
	/* may have been deleted earlier by bgp_interface_down() */
	if (addr == NULL)
		return;

	addr->refcnt--;

	if (addr->refcnt == 0) {
		hash_release(bgp->tip_hash, addr);
		XFREE(MTYPE_TIP_ADDR, addr);
	}
}

/* BGP own address structure */
struct bgp_addr {
	struct prefix p;
	struct list *ifp_name_list;
};

static void show_address_entry(struct hash_bucket *bucket, void *args)
{
	struct vty *vty = (struct vty *)args;
	struct bgp_addr *addr = (struct bgp_addr *)bucket->data;
	char *name;
	struct listnode *node;
	char str[INET6_ADDRSTRLEN] = {0};

	vty_out(vty, "addr: %s, count: %d : ",
		inet_ntop(addr->p.family, &(addr->p.u.prefix),
			  str, INET6_ADDRSTRLEN),
		addr->ifp_name_list->count);

	for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
		vty_out(vty, " %s,", name);
	}

	vty_out(vty, "\n");
}

void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp)
{
	hash_iterate(bgp->address_hash,
		     (void (*)(struct hash_bucket *, void *))show_address_entry,
		     vty);
}

static void bgp_address_hash_string_del(void *val)
{
	char *data = val;

	XFREE(MTYPE_MARTIAN_STRING, data);
}

static void *bgp_address_hash_alloc(void *p)
{
	struct bgp_addr *copy_addr = p;
	struct bgp_addr *addr = NULL;

	addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
	prefix_copy(&addr->p, &copy_addr->p);

	addr->ifp_name_list = list_new();
	addr->ifp_name_list->del = bgp_address_hash_string_del;

	return addr;
}

static void bgp_address_hash_free(void *data)
{
	struct bgp_addr *addr = data;

	list_delete(&addr->ifp_name_list);
	XFREE(MTYPE_BGP_ADDR, addr);
}

static unsigned int bgp_address_hash_key_make(const void *p)
{
	const struct bgp_addr *addr = p;

	return prefix_hash_key(&addr->p);
}

static bool bgp_address_hash_cmp(const void *p1, const void *p2)
{
	const struct bgp_addr *addr1 = p1;
	const struct bgp_addr *addr2 = p2;

	return prefix_same(&addr1->p, &addr2->p);
}

void bgp_address_init(struct bgp *bgp)
{
	bgp->address_hash =
		hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
				"BGP Connected Address Hash");
}

void bgp_address_destroy(struct bgp *bgp)
{
	hash_clean_and_free(&bgp->address_hash, bgp_address_hash_free);
}

static void bgp_address_add(struct bgp *bgp, struct connected *ifc,
			    struct prefix *p)
{
	struct bgp_addr tmp;
	struct bgp_addr *addr;
	struct listnode *node;
	char *name;

	tmp.p = *p;

	if (tmp.p.family == AF_INET)
		tmp.p.prefixlen = IPV4_MAX_BITLEN;
	else if (tmp.p.family == AF_INET6)
		tmp.p.prefixlen = IPV6_MAX_BITLEN;

	addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);

	for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
		if (strcmp(ifc->ifp->name, name) == 0)
			break;
	}
	if (!node) {
		name = XSTRDUP(MTYPE_MARTIAN_STRING, ifc->ifp->name);
		listnode_add(addr->ifp_name_list, name);
	}
}

static void bgp_address_del(struct bgp *bgp, struct connected *ifc,
			    struct prefix *p)
{
	struct bgp_addr tmp;
	struct bgp_addr *addr;
	struct listnode *node;
	char *name;

	tmp.p = *p;

	if (tmp.p.family == AF_INET)
		tmp.p.prefixlen = IPV4_MAX_BITLEN;
	else if (tmp.p.family == AF_INET6)
		tmp.p.prefixlen = IPV6_MAX_BITLEN;

	addr = hash_lookup(bgp->address_hash, &tmp);
	/* may have been deleted earlier by bgp_interface_down() */
	if (addr == NULL)
		return;

	for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
		if (strcmp(ifc->ifp->name, name) == 0)
			break;
	}

	if (node) {
		list_delete_node(addr->ifp_name_list, node);
		XFREE(MTYPE_MARTIAN_STRING, name);
	}

	if (addr->ifp_name_list->count == 0) {
		hash_release(bgp->address_hash, addr);
		list_delete(&addr->ifp_name_list);
		XFREE(MTYPE_BGP_ADDR, addr);
	}
}


struct bgp_connected_ref {
	unsigned int refcnt;
};

void bgp_connected_add(struct bgp *bgp, struct connected *ifc)
{
	struct prefix p;
	struct prefix *addr;
	struct bgp_dest *dest;
	struct bgp_connected_ref *bc;
	struct listnode *node, *nnode;
	struct peer *peer;

	addr = ifc->address;

	p = *(CONNECTED_PREFIX(ifc));
	if (addr->family == AF_INET) {
		apply_mask_ipv4((struct prefix_ipv4 *)&p);

		if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
			return;

		bgp_address_add(bgp, ifc, addr);

		dest = bgp_node_get(bgp->connected_table[AFI_IP], &p);
		bc = bgp_dest_get_bgp_connected_ref_info(dest);
		if (bc)
			bc->refcnt++;
		else {
			bc = XCALLOC(MTYPE_BGP_CONN,
				     sizeof(struct bgp_connected_ref));
			bc->refcnt = 1;
			bgp_dest_set_bgp_connected_ref_info(dest, bc);
		}

		for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
			if (peer->conf_if
			    && (strcmp(peer->conf_if, ifc->ifp->name) == 0)
			    && !peer_established(peer)
			    && !CHECK_FLAG(peer->flags,
					   PEER_FLAG_IFPEER_V6ONLY)) {
				if (peer_active(peer))
					BGP_EVENT_ADD(peer, BGP_Stop);
				BGP_EVENT_ADD(peer, BGP_Start);
			}
		}
	} else if (addr->family == AF_INET6) {
		apply_mask_ipv6((struct prefix_ipv6 *)&p);

		if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
			return;

		if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
			return;

		bgp_address_add(bgp, ifc, addr);

		dest = bgp_node_get(bgp->connected_table[AFI_IP6], &p);

		bc = bgp_dest_get_bgp_connected_ref_info(dest);
		if (bc)
			bc->refcnt++;
		else {
			bc = XCALLOC(MTYPE_BGP_CONN,
				     sizeof(struct bgp_connected_ref));
			bc->refcnt = 1;
			bgp_dest_set_bgp_connected_ref_info(dest, bc);
		}
	}
}

void bgp_connected_delete(struct bgp *bgp, struct connected *ifc)
{
	struct prefix p;
	struct prefix *addr;
	struct bgp_dest *dest = NULL;
	struct bgp_connected_ref *bc;

	addr = ifc->address;

	p = *(CONNECTED_PREFIX(ifc));
	apply_mask(&p);
	if (addr->family == AF_INET) {
		if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
			return;

		bgp_address_del(bgp, ifc, addr);

		dest = bgp_node_lookup(bgp->connected_table[AFI_IP], &p);
	} else if (addr->family == AF_INET6) {
		if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
			return;

		if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
			return;

		bgp_address_del(bgp, ifc, addr);

		dest = bgp_node_lookup(bgp->connected_table[AFI_IP6], &p);
	}

	if (!dest)
		return;

	bc = bgp_dest_get_bgp_connected_ref_info(dest);
	bc->refcnt--;
	if (bc->refcnt == 0) {
		XFREE(MTYPE_BGP_CONN, bc);
		bgp_dest_set_bgp_connected_ref_info(dest, NULL);
	}
	bgp_dest_unlock_node(dest);
	bgp_dest_unlock_node(dest);
}

static void bgp_connected_cleanup(struct route_table *table,
				  struct route_node *rn)
{
	struct bgp_connected_ref *bc;
	struct bgp_dest *bn = bgp_dest_from_rnode(rn);

	bc = bgp_dest_get_bgp_connected_ref_info(bn);
	if (!bc)
		return;

	XFREE(MTYPE_BGP_CONN, bc);
	bgp_dest_set_bgp_connected_ref_info(bn, NULL);
}

bool bgp_nexthop_self(struct bgp *bgp, afi_t afi, uint8_t type,
		      uint8_t sub_type, struct attr *attr,
		      struct bgp_dest *dest)
{
	uint8_t new_afi = afi == AFI_IP ? AF_INET : AF_INET6;
	struct bgp_addr tmp_addr = {{0}}, *addr = NULL;
	struct tip_addr tmp_tip, *tip = NULL;
	const struct prefix *p = bgp_dest_get_prefix(dest);
	bool is_bgp_static_route =
		((type == ZEBRA_ROUTE_BGP) && (sub_type == BGP_ROUTE_STATIC))
			? true
			: false;

	if (!is_bgp_static_route)
		new_afi = BGP_ATTR_NEXTHOP_AFI_IP6(attr) ? AF_INET6 : AF_INET;

	tmp_addr.p.family = new_afi;
	switch (new_afi) {
	case AF_INET:
		if (is_bgp_static_route) {
			tmp_addr.p.u.prefix4 = p->u.prefix4;
			tmp_addr.p.prefixlen = p->prefixlen;
		} else {
			/* Here we need to find out which nexthop to be used*/
			if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) {
				tmp_addr.p.u.prefix4 = attr->nexthop;
				tmp_addr.p.prefixlen = IPV4_MAX_BITLEN;
			} else if ((attr->mp_nexthop_len)
				   && ((attr->mp_nexthop_len
					== BGP_ATTR_NHLEN_IPV4)
				       || (attr->mp_nexthop_len
					   == BGP_ATTR_NHLEN_VPNV4))) {
				tmp_addr.p.u.prefix4 =
					attr->mp_nexthop_global_in;
				tmp_addr.p.prefixlen = IPV4_MAX_BITLEN;
			} else
				return false;
		}
		break;
	case AF_INET6:
		if (is_bgp_static_route) {
			tmp_addr.p.u.prefix6 = p->u.prefix6;
			tmp_addr.p.prefixlen = p->prefixlen;
		} else {
			tmp_addr.p.u.prefix6 = attr->mp_nexthop_global;
			tmp_addr.p.prefixlen = IPV6_MAX_BITLEN;
		}
		break;
	default:
		break;
	}

	addr = hash_lookup(bgp->address_hash, &tmp_addr);
	if (addr)
		return true;

	if (new_afi == AF_INET && hashcount(bgp->tip_hash)) {
		memset(&tmp_tip, 0, sizeof(tmp_tip));
		tmp_tip.addr = attr->nexthop;

		if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) {
			tmp_tip.addr = attr->nexthop;
		} else if ((attr->mp_nexthop_len) &&
			   ((attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4)
			    || (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV4))) {
			tmp_tip.addr = attr->mp_nexthop_global_in;
		}

		tip = hash_lookup(bgp->tip_hash, &tmp_tip);
		if (tip)
			return true;
	}

	return false;
}

bool bgp_multiaccess_check_v4(struct in_addr nexthop, struct peer *peer)
{
	struct bgp_dest *dest1;
	struct bgp_dest *dest2;
	struct prefix p;
	int ret;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;
	p.u.prefix4 = nexthop;

	dest1 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	if (!dest1)
		return false;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;
	p.u.prefix4 = peer->su.sin.sin_addr;

	dest2 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	if (!dest2) {
		bgp_dest_unlock_node(dest1);
		return false;
	}

	ret = (dest1 == dest2);

	bgp_dest_unlock_node(dest1);
	bgp_dest_unlock_node(dest2);

	return ret;
}

bool bgp_multiaccess_check_v6(struct in6_addr nexthop, struct peer *peer)
{
	struct bgp_dest *dest1;
	struct bgp_dest *dest2;
	struct prefix p;
	int ret;

	p.family = AF_INET6;
	p.prefixlen = IPV6_MAX_BITLEN;
	p.u.prefix6 = nexthop;

	dest1 = bgp_node_match(peer->bgp->connected_table[AFI_IP6], &p);
	if (!dest1)
		return false;

	p.family = AF_INET6;
	p.prefixlen = IPV6_MAX_BITLEN;
	p.u.prefix6 = peer->su.sin6.sin6_addr;

	dest2 = bgp_node_match(peer->bgp->connected_table[AFI_IP6], &p);
	if (!dest2) {
		bgp_dest_unlock_node(dest1);
		return false;
	}

	ret = (dest1 == dest2);

	bgp_dest_unlock_node(dest1);
	bgp_dest_unlock_node(dest2);

	return ret;
}

bool bgp_subgrp_multiaccess_check_v6(struct in6_addr nexthop,
				     struct update_subgroup *subgrp,
				     struct peer *exclude)
{
	struct bgp_dest *dest1 = NULL, *dest2 = NULL;
	struct peer_af *paf = NULL;
	struct prefix p = {0}, np = {0};
	struct bgp *bgp = NULL;

	np.family = AF_INET6;
	np.prefixlen = IPV6_MAX_BITLEN;
	np.u.prefix6 = nexthop;

	p.family = AF_INET;
	p.prefixlen = IPV6_MAX_BITLEN;

	bgp = SUBGRP_INST(subgrp);
	dest1 = bgp_node_match(bgp->connected_table[AFI_IP6], &np);
	if (!dest1)
		return false;

	SUBGRP_FOREACH_PEER (subgrp, paf) {
		/* Skip peer we're told to exclude - e.g., source of route. */
		if (paf->peer == exclude)
			continue;

		p.u.prefix6 = paf->peer->su.sin6.sin6_addr;
		dest2 = bgp_node_match(bgp->connected_table[AFI_IP6], &p);
		if (dest1 == dest2) {
			bgp_dest_unlock_node(dest1);
			bgp_dest_unlock_node(dest2);
			return true;
		}

		if (dest2)
			bgp_dest_unlock_node(dest2);
	}

	bgp_dest_unlock_node(dest1);
	return false;
}

bool bgp_subgrp_multiaccess_check_v4(struct in_addr nexthop,
				     struct update_subgroup *subgrp,
				     struct peer *exclude)
{
	struct bgp_dest *dest1, *dest2;
	struct peer_af *paf;
	struct prefix p, np;
	struct bgp *bgp;

	np.family = AF_INET;
	np.prefixlen = IPV4_MAX_BITLEN;
	np.u.prefix4 = nexthop;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;

	bgp = SUBGRP_INST(subgrp);
	dest1 = bgp_node_match(bgp->connected_table[AFI_IP], &np);
	if (!dest1)
		return false;

	SUBGRP_FOREACH_PEER (subgrp, paf) {
		/* Skip peer we're told to exclude - e.g., source of route. */
		if (paf->peer == exclude)
			continue;

		p.u.prefix4 = paf->peer->su.sin.sin_addr;

		dest2 = bgp_node_match(bgp->connected_table[AFI_IP], &p);
		if (dest1 == dest2) {
			bgp_dest_unlock_node(dest1);
			bgp_dest_unlock_node(dest2);
			return true;
		}

		if (dest2)
			bgp_dest_unlock_node(dest2);
	}

	bgp_dest_unlock_node(dest1);
	return false;
}

static void bgp_show_bgp_path_info_flags(uint32_t flags, json_object *json)
{
	json_object *json_flags = NULL;

	if (!json)
		return;

	json_flags = json_object_new_object();
	json_object_boolean_add(json_flags, "igpChanged",
				CHECK_FLAG(flags, BGP_PATH_IGP_CHANGED));
	json_object_boolean_add(json_flags, "damped",
				CHECK_FLAG(flags, BGP_PATH_DAMPED));
	json_object_boolean_add(json_flags, "history",
				CHECK_FLAG(flags, BGP_PATH_HISTORY));
	json_object_boolean_add(json_flags, "bestpath",
				CHECK_FLAG(flags, BGP_PATH_SELECTED));
	json_object_boolean_add(json_flags, "valid",
				CHECK_FLAG(flags, BGP_PATH_VALID));
	json_object_boolean_add(json_flags, "attrChanged",
				CHECK_FLAG(flags, BGP_PATH_ATTR_CHANGED));
	json_object_boolean_add(json_flags, "deterministicMedCheck",
				CHECK_FLAG(flags, BGP_PATH_DMED_CHECK));
	json_object_boolean_add(json_flags, "deterministicMedSelected",
				CHECK_FLAG(flags, BGP_PATH_DMED_SELECTED));
	json_object_boolean_add(json_flags, "stale",
				CHECK_FLAG(flags, BGP_PATH_STALE));
	json_object_boolean_add(json_flags, "removed",
				CHECK_FLAG(flags, BGP_PATH_REMOVED));
	json_object_boolean_add(json_flags, "counted",
				CHECK_FLAG(flags, BGP_PATH_COUNTED));
	json_object_boolean_add(json_flags, "multipath",
				CHECK_FLAG(flags, BGP_PATH_MULTIPATH));
	json_object_boolean_add(json_flags, "multipathChanged",
				CHECK_FLAG(flags, BGP_PATH_MULTIPATH_CHG));
	json_object_boolean_add(json_flags, "ribAttributeChanged",
				CHECK_FLAG(flags, BGP_PATH_RIB_ATTR_CHG));
	json_object_boolean_add(json_flags, "nexthopSelf",
				CHECK_FLAG(flags, BGP_PATH_ANNC_NH_SELF));
	json_object_boolean_add(json_flags, "linkBandwidthChanged",
				CHECK_FLAG(flags, BGP_PATH_LINK_BW_CHG));
	json_object_boolean_add(json_flags, "acceptOwn",
				CHECK_FLAG(flags, BGP_PATH_ACCEPT_OWN));
	json_object_object_add(json, "flags", json_flags);
}

static void bgp_show_nexthop_paths(struct vty *vty, struct bgp *bgp,
				   struct bgp_nexthop_cache *bnc,
				   json_object *json)
{
	struct bgp_dest *dest;
	struct bgp_path_info *path;
	afi_t afi;
	safi_t safi;
	struct bgp_table *table;
	struct bgp *bgp_path;
	json_object *paths = NULL;
	json_object *json_path = NULL;

	if (json)
		paths = json_object_new_array();
	else
		vty_out(vty, "  Paths:\n");
	LIST_FOREACH (path, &(bnc->paths), nh_thread) {
		dest = path->net;
		assert(dest && bgp_dest_table(dest));
		afi = family2afi(bgp_dest_get_prefix(dest)->family);
		table = bgp_dest_table(dest);
		safi = table->safi;
		bgp_path = table->bgp;


		if (json) {
			json_path = json_object_new_object();
			json_object_string_add(json_path, "afi", afi2str(afi));
			json_object_string_add(json_path, "safi",
					       safi2str(safi));
			json_object_string_addf(json_path, "prefix", "%pBD",
						dest);
			if (dest->pdest)
				json_object_string_addf(
					json_path, "rd",
					BGP_RD_AS_FORMAT(bgp->asnotation),
					(struct prefix_rd *)bgp_dest_get_prefix(
						dest->pdest));
			json_object_string_add(
				json_path, "vrf",
				vrf_id_to_name(bgp_path->vrf_id));
			bgp_show_bgp_path_info_flags(path->flags, json_path);
			json_object_array_add(paths, json_path);
			continue;
		}
		if (dest->pdest) {
			vty_out(vty, "    %d/%d %pBD RD ", afi, safi, dest);
			vty_out(vty, BGP_RD_AS_FORMAT(bgp->asnotation),
				(struct prefix_rd *)bgp_dest_get_prefix(
					dest->pdest));
			vty_out(vty, " %s flags 0x%x\n", bgp_path->name_pretty,
				path->flags);
		} else
			vty_out(vty, "    %d/%d %pBD %s flags 0x%x\n",
				afi, safi, dest, bgp_path->name_pretty, path->flags);
	}
	if (json)
		json_object_object_add(json, "paths", paths);
}

static void bgp_show_nexthops_detail(struct vty *vty, struct bgp *bgp,
				     struct bgp_nexthop_cache *bnc,
				     json_object *json)
{
	struct nexthop *nexthop;
	json_object *json_gates = NULL;
	json_object *json_gate = NULL;

	if (json)
		json_gates = json_object_new_array();
	for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next) {
		if (json) {
			json_gate = json_object_new_object();
			switch (nexthop->type) {
			case NEXTHOP_TYPE_IPV6:
				json_object_string_addf(json_gate, "ip", "%pI6",
							&nexthop->gate.ipv6);
				break;
			case NEXTHOP_TYPE_IPV6_IFINDEX:
				json_object_string_addf(json_gate, "ip", "%pI6",
							&nexthop->gate.ipv6);
				json_object_string_add(
					json_gate, "interfaceName",
					ifindex2ifname(
						bnc->ifindex ? bnc->ifindex
							     : nexthop->ifindex,
						bgp->vrf_id));
				break;
			case NEXTHOP_TYPE_IPV4:
				json_object_string_addf(json_gate, "ip", "%pI4",
							&nexthop->gate.ipv4);
				break;
			case NEXTHOP_TYPE_IFINDEX:
				json_object_string_add(
					json_gate, "interfaceName",
					ifindex2ifname(
						bnc->ifindex ? bnc->ifindex
							     : nexthop->ifindex,
						bgp->vrf_id));
				break;
			case NEXTHOP_TYPE_IPV4_IFINDEX:
				json_object_string_addf(json_gate, "ip", "%pI4",
							&nexthop->gate.ipv4);
				json_object_string_add(
					json_gate, "interfaceName",
					ifindex2ifname(
						bnc->ifindex ? bnc->ifindex
							     : nexthop->ifindex,
						bgp->vrf_id));
				break;
			case NEXTHOP_TYPE_BLACKHOLE:
				json_object_boolean_true_add(json_gate,
							     "unreachable");
				switch (nexthop->bh_type) {
				case BLACKHOLE_REJECT:
					json_object_boolean_true_add(json_gate,
								     "reject");
					break;
				case BLACKHOLE_ADMINPROHIB:
					json_object_boolean_true_add(
						json_gate, "adminProhibited");
					break;
				case BLACKHOLE_NULL:
					json_object_boolean_true_add(
						json_gate, "blackhole");
					break;
				case BLACKHOLE_UNSPEC:
					break;
				}
				break;
			default:
				break;
			}
			json_object_array_add(json_gates, json_gate);
			continue;
		}
		switch (nexthop->type) {
		case NEXTHOP_TYPE_IPV6:
		case NEXTHOP_TYPE_IPV6_IFINDEX:
			vty_out(vty, "  gate %pI6", &nexthop->gate.ipv6);
			if (nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX &&
			    bnc->ifindex)
				vty_out(vty, ", if %s\n",
					ifindex2ifname(bnc->ifindex,
						       bgp->vrf_id));
			else if (nexthop->ifindex)
				vty_out(vty, ", if %s\n",
					ifindex2ifname(nexthop->ifindex,
						       bgp->vrf_id));
			else
				vty_out(vty, "\n");
			break;
		case NEXTHOP_TYPE_IPV4:
		case NEXTHOP_TYPE_IPV4_IFINDEX:
			vty_out(vty, "  gate %pI4", &nexthop->gate.ipv4);
			if (nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX &&
			    bnc->ifindex)
				vty_out(vty, ", if %s\n",
					ifindex2ifname(bnc->ifindex,
						       bgp->vrf_id));
			else if (nexthop->ifindex)
				vty_out(vty, ", if %s\n",
					ifindex2ifname(nexthop->ifindex,
						       bgp->vrf_id));
			else
				vty_out(vty, "\n");
			break;
		case NEXTHOP_TYPE_IFINDEX:
			vty_out(vty, "  if %s\n",
				ifindex2ifname(bnc->ifindex ? bnc->ifindex
							    : nexthop->ifindex,
					       bgp->vrf_id));
			break;
		case NEXTHOP_TYPE_BLACKHOLE:
			vty_out(vty, "  blackhole\n");
			break;
		default:
			vty_out(vty, "  invalid nexthop type %u\n",
				nexthop->type);
		}
	}
	if (json)
		json_object_object_add(json, "nexthops", json_gates);
}

static void bgp_show_nexthop(struct vty *vty, struct bgp *bgp,
			     struct bgp_nexthop_cache *bnc, bool specific,
			     json_object *json)
{
	char buf[PREFIX2STR_BUFFER];
	time_t tbuf;
	struct peer *peer;
	json_object *json_last_update = NULL;
	json_object *json_nexthop = NULL;

	peer = (struct peer *)bnc->nht_info;

	if (json)
		json_nexthop = json_object_new_object();
	if (bnc->srte_color) {
		if (json)
			json_object_int_add(json_nexthop, "srteColor",
					    bnc->srte_color);
		else
			vty_out(vty, " SR-TE color %u -", bnc->srte_color);
	}
	inet_ntop(bnc->prefix.family, &bnc->prefix.u.prefix, buf, sizeof(buf));
	if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
		if (json) {
			json_object_boolean_true_add(json_nexthop, "valid");
			json_object_boolean_true_add(json_nexthop, "complete");
			json_object_int_add(json_nexthop, "igpMetric",
					    bnc->metric);
			json_object_int_add(json_nexthop, "pathCount",
					    bnc->path_count);
			if (peer)
				json_object_string_add(json_nexthop, "peer",
						       peer->host);
			if (bnc->is_evpn_gwip_nexthop)
				json_object_boolean_true_add(json_nexthop,
							     "isEvpnGatewayIp");
		} else {
			vty_out(vty, " %s valid [IGP metric %d], #paths %d",
				buf, bnc->metric, bnc->path_count);
			if (peer)
				vty_out(vty, ", peer %s", peer->host);
			if (bnc->is_evpn_gwip_nexthop)
				vty_out(vty, " EVPN Gateway IP");
			vty_out(vty, "\n");
		}
		bgp_show_nexthops_detail(vty, bgp, bnc, json_nexthop);
	} else if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_EVPN_INCOMPLETE)) {
		if (json) {
			json_object_boolean_true_add(json_nexthop, "valid");
			json_object_boolean_false_add(json_nexthop, "complete");
			json_object_int_add(json_nexthop, "igpMetric",
					    bnc->metric);
			json_object_int_add(json_nexthop, "pathCount",
					    bnc->path_count);
			if (bnc->is_evpn_gwip_nexthop)
				json_object_boolean_true_add(json_nexthop,
							     "isEvpnGatewayIp");
		} else {
			vty_out(vty,
				" %s overlay index unresolved [IGP metric %d], #paths %d",
				buf, bnc->metric, bnc->path_count);
			if (bnc->is_evpn_gwip_nexthop)
				vty_out(vty, " EVPN Gateway IP");
			vty_out(vty, "\n");
		}
		bgp_show_nexthops_detail(vty, bgp, bnc, json_nexthop);
	} else {
		if (json) {
			json_object_boolean_false_add(json_nexthop, "valid");
			json_object_boolean_false_add(json_nexthop, "complete");
			json_object_int_add(json_nexthop, "pathCount",
					    bnc->path_count);
			if (peer)
				json_object_string_add(json_nexthop, "peer",
						       peer->host);
			if (bnc->is_evpn_gwip_nexthop)
				json_object_boolean_true_add(json_nexthop,
							     "isEvpnGatewayIp");
			if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
				json_object_boolean_false_add(json_nexthop,
							      "isConnected");
			if (!CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED))
				json_object_boolean_false_add(json_nexthop,
							      "isRegistered");
		} else {
			vty_out(vty, " %s invalid, #paths %d", buf,
				bnc->path_count);
			if (peer)
				vty_out(vty, ", peer %s", peer->host);
			if (bnc->is_evpn_gwip_nexthop)
				vty_out(vty, " EVPN Gateway IP");
			vty_out(vty, "\n");
			if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED))
				vty_out(vty, "  Must be Connected\n");
			if (!CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED))
				vty_out(vty, "  Is not Registered\n");
		}
	}
	tbuf = time(NULL) - (monotime(NULL) - bnc->last_update);
	if (json) {
		if (!specific) {
			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(&tbuf));
			json_object_object_add(json_nexthop, "lastUpdate",
					       json_last_update);
		} else {
			json_object_int_add(json_nexthop, "lastUpdate", tbuf);
		}
	} else {
		vty_out(vty, "  Last update: %s", ctime(&tbuf));
	}

	/* show paths dependent on nexthop, if needed. */
	if (specific)
		bgp_show_nexthop_paths(vty, bgp, bnc, json_nexthop);
	if (json)
		json_object_object_add(json, buf, json_nexthop);
}

static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp,
			      bool import_table, json_object *json, afi_t afi,
			      bool detail)
{
	struct bgp_nexthop_cache *bnc;
	struct bgp_nexthop_cache_head(*tree)[AFI_MAX];
	json_object *json_afi = NULL;
	bool found = false;

	if (!json) {
		if (import_table)
			vty_out(vty, "Current BGP import check cache:\n");
		else
			vty_out(vty, "Current BGP nexthop cache:\n");
	}
	if (import_table)
		tree = &bgp->import_check_table;
	else
		tree = &bgp->nexthop_cache_table;

	if (afi == AFI_IP || afi == AFI_IP6) {
		if (json)
			json_afi = json_object_new_object();
		frr_each (bgp_nexthop_cache, &(*tree)[afi], bnc) {
			bgp_show_nexthop(vty, bgp, bnc, detail, json_afi);
			found = true;
		}
		if (found && json)
			json_object_object_add(
				json, (afi == AFI_IP) ? "ipv4" : "ipv6",
				json_afi);
		return;
	}

	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		if (json && (afi == AFI_IP || afi == AFI_IP6))
			json_afi = json_object_new_object();
		frr_each (bgp_nexthop_cache, &(*tree)[afi], bnc)
			bgp_show_nexthop(vty, bgp, bnc, detail, json_afi);
		if (json && (afi == AFI_IP || afi == AFI_IP6))
			json_object_object_add(
				json, (afi == AFI_IP) ? "ipv4" : "ipv6",
				json_afi);
	}
}

static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
				     const char *nhopip_str, bool import_table,
				     json_object *json, afi_t afi, bool detail)
{
	struct bgp *bgp;

	if (name && !strmatch(name, VRF_DEFAULT_NAME))
		bgp = bgp_lookup_by_name(name);
	else
		bgp = bgp_get_default();
	if (!bgp) {
		if (!json)
			vty_out(vty, "%% No such BGP instance exist\n");
		return CMD_WARNING;
	}

	if (nhopip_str) {
		struct prefix nhop;
		struct bgp_nexthop_cache_head (*tree)[AFI_MAX];
		struct bgp_nexthop_cache *bnc;
		bool found = false;
		json_object *json_afi = NULL;

		if (!str2prefix(nhopip_str, &nhop)) {
			if (!json)
				vty_out(vty, "nexthop address is malformed\n");
			return CMD_WARNING;
		}
		tree = import_table ? &bgp->import_check_table
				    : &bgp->nexthop_cache_table;
		if (json)
			json_afi = json_object_new_object();
		frr_each (bgp_nexthop_cache, &(*tree)[family2afi(nhop.family)],
			  bnc) {
			if (prefix_cmp(&bnc->prefix, &nhop))
				continue;
			bgp_show_nexthop(vty, bgp, bnc, true, json_afi);
			found = true;
		}
		if (json)
			json_object_object_add(
				json,
				(family2afi(nhop.family) == AFI_IP) ? "ipv4"
								    : "ipv6",
				json_afi);
		if (!found && !json)
			vty_out(vty, "nexthop %s does not have entry\n",
				nhopip_str);
	} else
		bgp_show_nexthops(vty, bgp, import_table, json, afi, detail);

	return CMD_SUCCESS;
}

static void bgp_show_all_instances_nexthops_vty(struct vty *vty,
						json_object *json, afi_t afi,
						bool detail)
{
	struct listnode *node, *nnode;
	struct bgp *bgp;
	const char *inst_name;
	json_object *json_instance = NULL;

	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
		inst_name = (bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
				    ? VRF_DEFAULT_NAME
				    : bgp->name;
		if (json)
			json_instance = json_object_new_object();
		else
			vty_out(vty, "\nInstance %s:\n", inst_name);

		bgp_show_nexthops(vty, bgp, false, json_instance, afi, detail);

		if (json)
			json_object_object_add(json, inst_name, json_instance);
	}
}

#include "bgpd/bgp_nexthop_clippy.c"

DEFPY (show_ip_bgp_nexthop,
       show_ip_bgp_nexthop_cmd,
       "show [ip] bgp [<view|vrf> VIEWVRFNAME$vrf] nexthop [<A.B.C.D|X:X::X:X>$nhop] [<ipv4$afi [A.B.C.D$nhop]|ipv6$afi [X:X::X:X$nhop]>] [detail$detail] [json$uj]",
       SHOW_STR
       IP_STR
       BGP_STR
       BGP_INSTANCE_HELP_STR
       "BGP nexthop table\n"
       "IPv4 nexthop address\n"
       "IPv6 nexthop address\n"
       "BGP nexthop IPv4 table\n"
       "IPv4 nexthop address\n"
       "BGP nexthop IPv6 table\n"
       "IPv6 nexthop address\n"
       "Show detailed information\n"
       JSON_STR)
{
	int rc = 0;
	json_object *json = NULL;
	afi_t afiz = AFI_UNSPEC;

	if (uj)
		json = json_object_new_object();

	if (afi)
		afiz = bgp_vty_afi_from_str(afi);

	rc = show_ip_bgp_nexthop_table(vty, vrf, nhop_str, false, json, afiz,
				       detail);

	if (uj)
		vty_json(vty, json);

	return rc;
}

DEFPY (show_ip_bgp_import_check,
       show_ip_bgp_import_check_cmd,
       "show [ip] bgp [<view|vrf> VIEWVRFNAME$vrf] import-check-table [detail$detail] [json$uj]",
       SHOW_STR
       IP_STR
       BGP_STR
       BGP_INSTANCE_HELP_STR
       "BGP import check table\n"
       "Show detailed information\n"
       JSON_STR)
{
	int rc = 0;
	json_object *json = NULL;

	if (uj)
		json = json_object_new_object();

	rc = show_ip_bgp_nexthop_table(vty, vrf, NULL, true, json, AFI_UNSPEC,
				       detail);

	if (uj)
		vty_json(vty, json);

	return rc;
}

DEFPY (show_ip_bgp_instance_all_nexthop,
       show_ip_bgp_instance_all_nexthop_cmd,
       "show [ip] bgp <view|vrf> all nexthop [<ipv4|ipv6>$afi] [detail$detail] [json$uj]",
       SHOW_STR
       IP_STR
       BGP_STR
       BGP_INSTANCE_ALL_HELP_STR
       "BGP nexthop table\n"
       "BGP IPv4 nexthop table\n"
       "BGP IPv6 nexthop table\n"
       "Show detailed information\n"
       JSON_STR)
{
	json_object *json = NULL;
	afi_t afiz = AFI_UNSPEC;

	if (uj)
		json = json_object_new_object();

	if (afi)
		afiz = bgp_vty_afi_from_str(afi);

	bgp_show_all_instances_nexthops_vty(vty, json, afiz, detail);

	if (uj)
		vty_json(vty, json);

	return CMD_SUCCESS;
}

void bgp_scan_init(struct bgp *bgp)
{
	afi_t afi;

	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		bgp_nexthop_cache_init(&bgp->nexthop_cache_table[afi]);
		bgp_nexthop_cache_init(&bgp->import_check_table[afi]);
		bgp->connected_table[afi] = bgp_table_init(bgp, afi,
			SAFI_UNICAST);
	}
}

void bgp_scan_vty_init(void)
{
	install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
	install_element(VIEW_NODE, &show_ip_bgp_import_check_cmd);
	install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
}

void bgp_scan_finish(struct bgp *bgp)
{
	afi_t afi;

	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		/* Only the current one needs to be reset. */
		bgp_nexthop_cache_reset(&bgp->nexthop_cache_table[afi]);
		bgp_nexthop_cache_reset(&bgp->import_check_table[afi]);

		bgp->connected_table[afi]->route_table->cleanup =
			bgp_connected_cleanup;
		bgp_table_unlock(bgp->connected_table[afi]);
		bgp->connected_table[afi] = NULL;
	}
}

char *bgp_nexthop_dump_bnc_flags(struct bgp_nexthop_cache *bnc, char *buf,
				 size_t len)
{
	if (bnc->flags == 0) {
		snprintfrr(buf, len, "None ");
		return buf;
	}

	snprintfrr(buf, len, "%s%s%s%s%s%s%s",
		   CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID) ? "Valid " : "",
		   CHECK_FLAG(bnc->flags, BGP_NEXTHOP_REGISTERED) ? "Reg " : "",
		   CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED) ? "Conn " : "",
		   CHECK_FLAG(bnc->flags, BGP_NEXTHOP_PEER_NOTIFIED) ? "Notify "
								     : "",
		   CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE) ? "Static " : "",
		   CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE_EXACT_MATCH)
			   ? "Static Exact "
			   : "",
		   CHECK_FLAG(bnc->flags, BGP_NEXTHOP_LABELED_VALID)
			   ? "Label Valid "
			   : "");

	return buf;
}

char *bgp_nexthop_dump_bnc_change_flags(struct bgp_nexthop_cache *bnc,
					char *buf, size_t len)
{
	if (bnc->flags == 0) {
		snprintfrr(buf, len, "None ");
		return buf;
	}

	snprintfrr(buf, len, "%s%s%s",
		   CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CHANGED)
			   ? "Changed "
			   : "",
		   CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_METRIC_CHANGED)
			   ? "Metric "
			   : "",
		   CHECK_FLAG(bnc->change_flags, BGP_NEXTHOP_CONNECTED_CHANGED)
			   ? "Connected "
			   : "");

	return buf;
}