// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 * Copyright 2009-2016, LabN Consulting, L.L.C.
 *
 */

/*
 * File:	rfapi_rib.c
 * Purpose:	maintain per-nve ribs and generate change lists
 */

#include "lib/zebra.h"
#include "lib/prefix.h"
#include "lib/agg_table.h"
#include "lib/vty.h"
#include "lib/memory.h"
#include "lib/log.h"
#include "lib/skiplist.h"
#include "lib/workqueue.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_ecommunity.h"
#include "bgpd/bgp_mplsvpn.h"
#include "bgpd/bgp_vnc_types.h"

#include "bgpd/rfapi/rfapi.h"
#include "bgpd/rfapi/bgp_rfapi_cfg.h"
#include "bgpd/rfapi/rfapi_import.h"
#include "bgpd/rfapi/rfapi_private.h"
#include "bgpd/rfapi/rfapi_vty.h"
#include "bgpd/rfapi/vnc_import_bgp.h"
#include "bgpd/rfapi/rfapi_rib.h"
#include "bgpd/rfapi/rfapi_monitor.h"
#include "bgpd/rfapi/rfapi_encap_tlv.h"
#include "bgpd/rfapi/vnc_debug.h"

#define DEBUG_PROCESS_PENDING_NODE	0
#define DEBUG_PENDING_DELETE_ROUTE	0
#define DEBUG_NHL			0
#define DEBUG_RIB_SL_RD                 0
#define DEBUG_CLEANUP 0

/* forward decl */
#if DEBUG_NHL
static void rfapiRibShowRibSl(void *stream, struct prefix *pfx,
			      struct skiplist *sl);
#endif

/*
 * RIB
 * ---
 * Model of the set of routes currently in the NVE's RIB.
 *
 * node->info		ptr to "struct skiplist".
 *			MUST be NULL if there are no routes.
 *			key = ptr to struct prefix {vn}
 *			val = ptr to struct rfapi_info
 *			skiplist.del = NULL
 *			skiplist.cmp = vnc_prefix_cmp
 *
 * node->aggregate	ptr to "struct skiplist".
 *			key = ptr to struct prefix {vn}
 *			val = ptr to struct rfapi_info
 *			skiplist.del = rfapi_info_free
 *			skiplist.cmp = vnc_prefix_cmp
 *
 *			This skiplist at "aggregate"
 *			contains the routes recently
 *			deleted
 *
 *
 * Pending RIB
 * -----------
 * Sparse list of prefixes that need to be updated. Each node
 * will have the complete set of routes for the prefix.
 *
 * node->info		ptr to "struct list" (lib/linklist.h)
 *			"Cost List"
 *			List of routes sorted lowest cost first.
 *			This list is how the new complete set
 *			of routes should look.
 *			Set if there are updates to the prefix;
 *			MUST be NULL if there are no updates.
 *
 *			.data = ptr to struct rfapi_info
 *			list.cmp = NULL (sorted manually)
 *			list.del = rfapi_info_free
 *
 *			Special case: if node->info is 1, it means
 *			"delete all routes at this prefix".
 *
 * node->aggregate	ptr to struct skiplist
 *			key = ptr to struct prefix {vn} (part of ri)
 *			val =  struct rfapi_info
 *			skiplist.cmp = vnc_prefix_cmp
 *			skiplist.del = NULL
 *
 *			ptlist is rewritten anew each time
 *			rfapiRibUpdatePendingNode() is called
 *
 *			THE ptlist VALUES ARE REFERENCES TO THE
 *			rfapi_info STRUCTS IN THE node->info LIST.
 */

/*
 * iterate over RIB to count responses, compare with running counters
 */
void rfapiRibCheckCounts(
	int checkstats,      /* validate rfd & global counts */
	unsigned int offset) /* number of ri's held separately */
{
	struct rfapi_descriptor *rfd;
	struct listnode *node;

	struct bgp *bgp = bgp_get_default();

	uint32_t t_pfx_active = 0;

	uint32_t t_ri_active = 0;
	uint32_t t_ri_deleted = 0;
	uint32_t t_ri_pend = 0;

	unsigned int alloc_count;

	/*
	 * loop over NVEs
	 */
	for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, node, rfd)) {

		afi_t afi;
		uint32_t pfx_active = 0;

		for (afi = AFI_IP; afi < AFI_MAX; ++afi) {

			struct agg_node *rn;

			for (rn = agg_route_top(rfd->rib[afi]); rn;
			     rn = agg_route_next(rn)) {

				struct skiplist *sl = rn->info;
				struct skiplist *dsl = rn->aggregate;
				uint32_t ri_active = 0;
				uint32_t ri_deleted = 0;

				if (sl) {
					ri_active = skiplist_count(sl);
					assert(ri_active);
					t_ri_active += ri_active;
					++pfx_active;
					++t_pfx_active;
				}

				if (dsl) {
					ri_deleted = skiplist_count(dsl);
					t_ri_deleted += ri_deleted;
				}
			}
			for (rn = agg_route_top(rfd->rib_pending[afi]); rn;
			     rn = agg_route_next(rn)) {

				struct list *l = rn->info; /* sorted by cost */
				struct skiplist *sl = rn->aggregate;
				uint32_t ri_pend_cost = 0;
				uint32_t ri_pend_uniq = 0;

				if (sl) {
					ri_pend_uniq = skiplist_count(sl);
				}

				if (l && (l != (void *)1)) {
					ri_pend_cost = l->count;
					t_ri_pend += l->count;
				}

				assert(ri_pend_uniq == ri_pend_cost);
			}
		}

		if (checkstats) {
			if (pfx_active != rfd->rib_prefix_count) {
				vnc_zlog_debug_verbose(
					"%s: rfd %p actual pfx count %u != running %u",
					__func__, rfd, pfx_active,
					rfd->rib_prefix_count);
				assert(0);
			}
		}
	}

	if (checkstats && bgp->rfapi) {
		if (t_pfx_active != bgp->rfapi->rib_prefix_count_total) {
			vnc_zlog_debug_verbose(
				"%s: actual total pfx count %u != running %u",
				__func__, t_pfx_active,
				bgp->rfapi->rib_prefix_count_total);
			assert(0);
		}
	}

	/*
	 * Check against memory allocation count
	 */
	alloc_count = mtype_stats_alloc(MTYPE_RFAPI_INFO);
	assert(t_ri_active + t_ri_deleted + t_ri_pend + offset == alloc_count);
}

static struct rfapi_info *rfapi_info_new(void)
{
	return XCALLOC(MTYPE_RFAPI_INFO, sizeof(struct rfapi_info));
}

void rfapiFreeRfapiUnOptionChain(struct rfapi_un_option *p)
{
	while (p) {
		struct rfapi_un_option *next;

		next = p->next;
		XFREE(MTYPE_RFAPI_UN_OPTION, p);
		p = next;
	}
}

void rfapiFreeRfapiVnOptionChain(struct rfapi_vn_option *p)
{
	while (p) {
		struct rfapi_vn_option *next;

		next = p->next;
		XFREE(MTYPE_RFAPI_VN_OPTION, p);
		p = next;
	}
}


static void rfapi_info_free(struct rfapi_info *goner)
{
	if (goner) {
		if (goner->tea_options) {
			rfapiFreeBgpTeaOptionChain(goner->tea_options);
			goner->tea_options = NULL;
		}
		if (goner->un_options) {
			rfapiFreeRfapiUnOptionChain(goner->un_options);
			goner->un_options = NULL;
		}
		if (goner->vn_options) {
			rfapiFreeRfapiVnOptionChain(goner->vn_options);
			goner->vn_options = NULL;
		}
		if (goner->timer) {
			struct rfapi_rib_tcb *tcb;

			tcb = EVENT_ARG(goner->timer);
			EVENT_OFF(goner->timer);
			XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
		}
		XFREE(MTYPE_RFAPI_INFO, goner);
	}
}

/*
 * Timer control block for recently-deleted and expired routes
 */
struct rfapi_rib_tcb {
	struct rfapi_descriptor *rfd;
	struct skiplist *sl;
	struct rfapi_info *ri;
	struct agg_node *rn;
	int flags;
#define RFAPI_RIB_TCB_FLAG_DELETED	0x00000001
};

/*
 * remove route from rib
 */
static void rfapiRibExpireTimer(struct event *t)
{
	struct rfapi_rib_tcb *tcb = EVENT_ARG(t);

	RFAPI_RIB_CHECK_COUNTS(1, 0);

	/*
	 * Forget reference to thread. Otherwise rfapi_info_free() will
	 * attempt to free thread pointer as an option chain
	 */
	tcb->ri->timer = NULL;

	/* "deleted" skiplist frees ri, "active" doesn't */
	assert(!skiplist_delete(tcb->sl, &tcb->ri->rk, NULL));
	if (!tcb->sl->del) {
		/*
		 * XXX in this case, skiplist has no delete function: we must
		 * therefore delete rfapi_info explicitly.
		 */
		rfapi_info_free(tcb->ri);
	}

	if (skiplist_empty(tcb->sl)) {
		if (CHECK_FLAG(tcb->flags, RFAPI_RIB_TCB_FLAG_DELETED))
			tcb->rn->aggregate = NULL;
		else {
			struct bgp *bgp = bgp_get_default();
			tcb->rn->info = NULL;
			RFAPI_RIB_PREFIX_COUNT_DECR(tcb->rfd, bgp->rfapi);
		}
		skiplist_free(tcb->sl);
		agg_unlock_node(tcb->rn);
	}

	XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);

	RFAPI_RIB_CHECK_COUNTS(1, 0);
}

static void rfapiRibStartTimer(struct rfapi_descriptor *rfd,
			       struct rfapi_info *ri,
			       struct agg_node *rn, /* route node attached to */
			       int deleted)
{
	struct rfapi_rib_tcb *tcb = NULL;

	if (ri->timer) {
		tcb = EVENT_ARG(ri->timer);
		EVENT_OFF(ri->timer);
	} else {
		tcb = XCALLOC(MTYPE_RFAPI_RECENT_DELETE,
			      sizeof(struct rfapi_rib_tcb));
	}
#if DEBUG_CLEANUP
	zlog_debug("%s: rfd %p, rn %p, ri %p, tcb %p", __func__, rfd, rn, ri,
		   tcb);
#endif

	tcb->rfd = rfd;
	tcb->ri = ri;
	tcb->rn = rn;
	if (deleted) {
		tcb->sl = (struct skiplist *)rn->aggregate;
		SET_FLAG(tcb->flags, RFAPI_RIB_TCB_FLAG_DELETED);
	} else {
		tcb->sl = (struct skiplist *)rn->info;
		UNSET_FLAG(tcb->flags, RFAPI_RIB_TCB_FLAG_DELETED);
	}

	vnc_zlog_debug_verbose("%s: rfd %p pfx %pRN life %u", __func__, rfd, rn,
			       ri->lifetime);

	event_add_timer(bm->master, rfapiRibExpireTimer, tcb, ri->lifetime,
			&ri->timer);
}

extern void rfapi_rib_key_init(struct prefix *prefix, /* may be NULL */
			       struct prefix_rd *rd,  /* may be NULL */
			       struct prefix *aux,    /* may be NULL */
			       struct rfapi_rib_key *rk)

{
	memset((void *)rk, 0, sizeof(struct rfapi_rib_key));
	if (prefix)
		rk->vn = *prefix;
	if (rd)
		rk->rd = *rd;
	if (aux)
		rk->aux_prefix = *aux;
}

/*
 * Compares two <struct rfapi_rib_key>s
 */
int rfapi_rib_key_cmp(const void *k1, const void *k2)
{
	const struct rfapi_rib_key *a = (struct rfapi_rib_key *)k1;
	const struct rfapi_rib_key *b = (struct rfapi_rib_key *)k2;
	int ret;

	if (!a || !b)
		return (a - b);

	ret = vnc_prefix_cmp(&a->vn, &b->vn);
	if (ret)
		return ret;

	ret = vnc_prefix_cmp(&a->rd, &b->rd);
	if (ret)
		return ret;

	ret = vnc_prefix_cmp(&a->aux_prefix, &b->aux_prefix);

	return ret;
}


/*
 * Note: this function will claim that two option chains are
 * different unless their option items are in identical order.
 * The consequence is that RFP updated responses can be sent
 * unnecessarily, or that they might contain nexthop items
 * that are not strictly needed.
 *
 * This function could be modified to compare option chains more
 * thoroughly, but it's not clear that the extra compuation would
 * be worth it.
 */
static int bgp_tea_options_cmp(struct bgp_tea_options *a,
			       struct bgp_tea_options *b)
{
	int rc;

	if (!a || !b) {
		return (a - b);
	}

	if (a->type != b->type)
		return (a->type - b->type);
	if (a->length != b->length)
		return (a->length = b->length);
	if ((rc = memcmp(a->value, b->value, a->length)))
		return rc;
	if (!a->next != !b->next) { /* logical xor */
		return (a->next - b->next);
	}
	if (a->next)
		return bgp_tea_options_cmp(a->next, b->next);
	return 0;
}

static int rfapi_info_cmp(struct rfapi_info *a, struct rfapi_info *b)
{
	int rc;

	if (!a || !b)
		return (a - b);

	if ((rc = rfapi_rib_key_cmp(&a->rk, &b->rk)))
		return rc;

	if ((rc = vnc_prefix_cmp(&a->un, &b->un)))
		return rc;

	if (a->cost != b->cost)
		return (a->cost - b->cost);

	if (a->lifetime != b->lifetime)
		return (a->lifetime - b->lifetime);

	if ((rc = bgp_tea_options_cmp(a->tea_options, b->tea_options)))
		return rc;

	return 0;
}

void rfapiRibClear(struct rfapi_descriptor *rfd)
{
	struct bgp *bgp;
	afi_t afi;

	if (rfd->bgp)
		bgp = rfd->bgp;
	else
		bgp = bgp_get_default();
#ifdef DEBUG_L2_EXTRA
	vnc_zlog_debug_verbose("%s: rfd=%p", __func__, rfd);
#endif

	for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
		struct agg_node *pn;
		struct agg_node *rn;

		if (rfd->rib_pending[afi]) {
			for (pn = agg_route_top(rfd->rib_pending[afi]); pn;
			     pn = agg_route_next(pn)) {
				if (pn->aggregate) {
					/*
					 * free references into the rfapi_info
					 * structures before
					 * freeing the structures themselves
					 */
					skiplist_free(
						(struct skiplist
							 *)(pn->aggregate));
					pn->aggregate = NULL;
					agg_unlock_node(
						pn); /* skiplist deleted */
				}
				/*
				 * free the rfapi_info structures
				 */
				if (pn->info) {
					if (pn->info != (void *)1) {
						list_delete(
							(struct list *
								 *)(&pn->info));
					}
					pn->info = NULL;
					/* linklist or 1 deleted */
					agg_unlock_node(pn);
				}
			}
		}
		if (rfd->rib[afi]) {
			for (rn = agg_route_top(rfd->rib[afi]); rn;
			     rn = agg_route_next(rn)) {
				if (rn->info) {

					struct rfapi_info *ri;

					while (0 == skiplist_first(
							    (struct skiplist *)
								    rn->info,
							    NULL,
							    (void **)&ri)) {

						if (ri->timer) {
							struct rfapi_rib_tcb
								*tcb;

							tcb = EVENT_ARG(
								ri->timer);
							EVENT_OFF(ri->timer);
							XFREE(MTYPE_RFAPI_RECENT_DELETE,
							      tcb);
						}
						rfapi_info_free(ri);
						skiplist_delete_first(
							(struct skiplist *)
								rn->info);
					}
					skiplist_free(
						(struct skiplist *)rn->info);
					rn->info = NULL;
					agg_unlock_node(rn);
					RFAPI_RIB_PREFIX_COUNT_DECR(rfd,
								    bgp->rfapi);
				}
				if (rn->aggregate) {

					struct rfapi_info *ri_del;

					/* delete skiplist & contents */
					while (!skiplist_first(
						(struct skiplist
							 *)(rn->aggregate),
						NULL, (void **)&ri_del)) {

						/* sl->del takes care of ri_del
						 */
						skiplist_delete_first((
							struct skiplist
								*)(rn->aggregate));
					}
					skiplist_free(
						(struct skiplist
							 *)(rn->aggregate));

					rn->aggregate = NULL;
					agg_unlock_node(rn);
				}
			}
		}
	}
	if (rfd->updated_responses_queue)
		work_queue_free_and_null(&rfd->updated_responses_queue);
}

/*
 * Release all dynamically-allocated memory that is part of an HD's RIB
 */
void rfapiRibFree(struct rfapi_descriptor *rfd)
{
	afi_t afi;

#if DEBUG_CLEANUP
	zlog_debug("%s: rfd %p", __func__, rfd);
#endif

	/*
	 * NB rfd is typically detached from master list, so is not included
	 * in the count performed by RFAPI_RIB_CHECK_COUNTS
	 */

	/*
	 * Free routes attached to radix trees
	 */
	rfapiRibClear(rfd);

	/* Now the uncounted rfapi_info's are freed, so the check should succeed
	 */
	RFAPI_RIB_CHECK_COUNTS(1, 0);

	/*
	 * Free radix trees
	 */
	for (afi = AFI_IP; afi < AFI_MAX; ++afi) {
		if (rfd->rib_pending[afi])
			agg_table_finish(rfd->rib_pending[afi]);
		rfd->rib_pending[afi] = NULL;

		if (rfd->rib[afi])
			agg_table_finish(rfd->rib[afi]);
		rfd->rib[afi] = NULL;

		/* NB agg_table_finish frees only prefix nodes, not chained
		 * info */
		if (rfd->rsp_times[afi])
			agg_table_finish(rfd->rsp_times[afi]);
		rfd->rib[afi] = NULL;
	}
}

/*
 * Copies struct bgp_path_info to struct rfapi_info, except for rk fields and un
 */
static void rfapiRibBi2Ri(struct bgp_path_info *bpi, struct rfapi_info *ri,
			  uint32_t lifetime)
{
	struct bgp_attr_encap_subtlv *pEncap;

	ri->cost = rfapiRfpCost(bpi->attr);
	ri->lifetime = lifetime;

	/* This loop based on rfapiRouteInfo2NextHopEntry() */
	for (pEncap = bgp_attr_get_vnc_subtlvs(bpi->attr); pEncap;
	     pEncap = pEncap->next) {
		struct bgp_tea_options *hop;

		switch (pEncap->type) {
		case BGP_VNC_SUBTLV_TYPE_LIFETIME:
			/* use configured lifetime, not attr lifetime */
			break;

		case BGP_VNC_SUBTLV_TYPE_RFPOPTION:
			hop = XCALLOC(MTYPE_BGP_TEA_OPTIONS,
				      sizeof(struct bgp_tea_options));
			assert(hop);
			hop->type = pEncap->value[0];
			hop->length = pEncap->value[1];
			hop->value = XCALLOC(MTYPE_BGP_TEA_OPTIONS_VALUE,
					     pEncap->length - 2);
			assert(hop->value);
			memcpy(hop->value, pEncap->value + 2,
			       pEncap->length - 2);
			if (hop->length > pEncap->length - 2) {
				zlog_warn(
					"%s: VNC subtlv length mismatch: RFP option says %d, attr says %d (shrinking)",
					__func__, hop->length,
					pEncap->length - 2);
				hop->length = pEncap->length - 2;
			}
			hop->next = ri->tea_options;
			ri->tea_options = hop;
			break;

		default:
			break;
		}
	}

	rfapi_un_options_free(ri->un_options); /* maybe free old version */
	ri->un_options = rfapi_encap_tlv_to_un_option(bpi->attr);

	/*
	 * VN options
	 */
	if (bpi->extra && decode_rd_type(bpi->extra->vnc->vnc.import.rd.val) ==
				  RD_TYPE_VNC_ETH) {
		/* ethernet route */

		struct rfapi_vn_option *vo;

		vo = XCALLOC(MTYPE_RFAPI_VN_OPTION,
			     sizeof(struct rfapi_vn_option));
		assert(vo);

		vo->type = RFAPI_VN_OPTION_TYPE_L2ADDR;

		/* copy from RD already stored in bpi, so we don't need it_node
		 */
		memcpy(&vo->v.l2addr.macaddr,
		       bpi->extra->vnc->vnc.import.rd.val + 2, ETH_ALEN);

		(void)rfapiEcommunityGetLNI(bgp_attr_get_ecommunity(bpi->attr),
					    &vo->v.l2addr.logical_net_id);
		(void)rfapiEcommunityGetEthernetTag(
			bgp_attr_get_ecommunity(bpi->attr),
			&vo->v.l2addr.tag_id);

		/* local_nve_id comes from RD */
		vo->v.l2addr.local_nve_id =
			bpi->extra->vnc->vnc.import.rd.val[1];

		/* label comes from MP_REACH_NLRI label */
		vo->v.l2addr.label =
			BGP_PATH_INFO_NUM_LABELS(bpi)
				? decode_label(&bpi->extra->labels->label[0])
				: MPLS_INVALID_LABEL;

		rfapi_vn_options_free(
			ri->vn_options); /* maybe free old version */
		ri->vn_options = vo;
	}

	/*
	 * If there is an auxiliary IP address (L2 can have it), copy it
	 */
	if (bpi->extra && bpi->extra->vnc->vnc.import.aux_prefix.family) {
		ri->rk.aux_prefix = bpi->extra->vnc->vnc.import.aux_prefix;
	}
}

/*
 * rfapiRibPreloadBi
 *
 *	Install route into NVE RIB model so as to be consistent with
 *	caller's response to rfapi_query().
 *
 *	Also: return indication to caller whether this specific route
 *	should be included in the response to the NVE according to
 *	the following tests:
 *
 *	1. If there were prior duplicates of this route in this same
 *	   query response, don't include the route.
 *
 * RETURN VALUE:
 *
 *	0	OK to include route in response
 *	!0	do not include route in response
 */
int rfapiRibPreloadBi(
	struct agg_node *rfd_rib_node, /* NULL = don't preload or filter */
	struct prefix *pfx_vn, struct prefix *pfx_un, uint32_t lifetime,
	struct bgp_path_info *bpi)
{
	struct rfapi_descriptor *rfd;
	struct skiplist *slRibPt = NULL;
	struct rfapi_info *ori = NULL;
	struct rfapi_rib_key rk;
	struct agg_node *trn;
	afi_t afi;
	const struct prefix *p = agg_node_get_prefix(rfd_rib_node);

	if (!rfd_rib_node)
		return 0;

	afi = family2afi(p->family);

	rfd = agg_get_table_info(agg_get_table(rfd_rib_node));

	memset((void *)&rk, 0, sizeof(rk));
	rk.vn = *pfx_vn;
	rk.rd = bpi->extra->vnc->vnc.import.rd;

	/*
	 * If there is an auxiliary IP address (L2 can have it), copy it
	 */
	if (bpi->extra->vnc->vnc.import.aux_prefix.family) {
		rk.aux_prefix = bpi->extra->vnc->vnc.import.aux_prefix;
	}

	/*
	 * is this route already in NVE's RIB?
	 */
	slRibPt = (struct skiplist *)rfd_rib_node->info;

	if (slRibPt && !skiplist_search(slRibPt, &rk, (void **)&ori)) {

		if ((ori->rsp_counter == rfd->rsp_counter)
		    && (ori->last_sent_time == rfd->rsp_time)) {
			return -1; /* duplicate in this response */
		}

		/* found: update contents of existing route in RIB */
		ori->un = *pfx_un;
		rfapiRibBi2Ri(bpi, ori, lifetime);
	} else {
		/* not found: add new route to RIB */
		ori = rfapi_info_new();
		ori->rk = rk;
		ori->un = *pfx_un;
		rfapiRibBi2Ri(bpi, ori, lifetime);

		if (!slRibPt) {
			slRibPt = skiplist_new(0, rfapi_rib_key_cmp, NULL);
			rfd_rib_node->info = slRibPt;
			agg_lock_node(rfd_rib_node);
			RFAPI_RIB_PREFIX_COUNT_INCR(rfd, rfd->bgp->rfapi);
		}
		skiplist_insert(slRibPt, &ori->rk, ori);
	}

	ori->last_sent_time = monotime(NULL);

	/*
	 * poke timer
	 */
	RFAPI_RIB_CHECK_COUNTS(0, 0);
	rfapiRibStartTimer(rfd, ori, rfd_rib_node, 0);
	RFAPI_RIB_CHECK_COUNTS(0, 0);

	/*
	 * Update last sent time for prefix
	 */
	trn = agg_node_get(rfd->rsp_times[afi], p); /* locks trn */
	trn->info = (void *)(uintptr_t)monotime(NULL);
	if (agg_node_get_lock_count(trn) > 1)
		agg_unlock_node(trn);

	return 0;
}

/*
 * Frees rfapi_info items at node
 *
 * Adjust 'rib' and 'rib_pending' as follows:
 *
 * If rib_pending node->info is 1 (magic value):
 *	callback: NHL = RIB NHL with lifetime = withdraw_lifetime_value
 *	RIB = remove all routes at the node
 *	DONE
 *
 * For each item at rib node:
 *  if not present in pending node, move RIB item to "delete list"
 *
 * For each item at pending rib node:
 *  if present (same vn/un) in rib node with same lifetime & options, drop
 *	matching item from pending node
 *
 * For each remaining item at pending rib node, add or replace item
 * at rib node.
 *
 * Construct NHL as concatenation of pending list + delete list
 *
 * Clear pending node
 */
static void process_pending_node(struct bgp *bgp, struct rfapi_descriptor *rfd,
				 afi_t afi,
				 struct agg_node *pn, /* pending node */
				 struct rfapi_next_hop_entry **head,
				 struct rfapi_next_hop_entry **tail)
{
	struct listnode *node = NULL;
	struct listnode *nnode = NULL;
	struct rfapi_info *ri = NULL;    /* happy valgrind */
	struct rfapi_ip_prefix hp = {0}; /* pfx to put in NHE */
	struct agg_node *rn = NULL;
	struct skiplist *slRibPt = NULL; /* rib list */
	struct skiplist *slPendPt = NULL;
	struct list *lPendCost = NULL;
	struct list *delete_list = NULL;
	int printedprefix = 0;
	int rib_node_started_nonempty = 0;
	int sendingsomeroutes = 0;
	const struct prefix *p;
#if DEBUG_PROCESS_PENDING_NODE
	unsigned int count_rib_initial = 0;
	unsigned int count_pend_vn_initial = 0;
	unsigned int count_pend_cost_initial = 0;
#endif

	assert(pn);
	p = agg_node_get_prefix(pn);
	vnc_zlog_debug_verbose("%s: afi=%d, %pRN pn->info=%p", __func__, afi,
			       pn, pn->info);

	if (AFI_L2VPN != afi) {
		rfapiQprefix2Rprefix(p, &hp);
	}

	RFAPI_RIB_CHECK_COUNTS(1, 0);

	/*
	 * Find corresponding RIB node
	 */
	rn = agg_node_get(rfd->rib[afi], p); /* locks rn */

	/*
	 * RIB skiplist has key=rfapi_addr={vn,un}, val = rfapi_info,
	 * skiplist.del = NULL
	 */
	slRibPt = (struct skiplist *)rn->info;
	if (slRibPt)
		rib_node_started_nonempty = 1;

	slPendPt = (struct skiplist *)(pn->aggregate);
	lPendCost = (struct list *)(pn->info);

#if DEBUG_PROCESS_PENDING_NODE
	/* debugging */
	if (slRibPt)
		count_rib_initial = skiplist_count(slRibPt);

	if (slPendPt)
		count_pend_vn_initial = skiplist_count(slPendPt);

	if (lPendCost && lPendCost != (struct list *)1)
		count_pend_cost_initial = lPendCost->count;
#endif


	/*
	 * Handle special case: delete all routes at prefix
	 */
	if (lPendCost == (struct list *)1) {
		vnc_zlog_debug_verbose("%s: lPendCost=1 => delete all",
				       __func__);
		if (slRibPt && !skiplist_empty(slRibPt)) {
			delete_list = list_new();
			while (0
			       == skiplist_first(slRibPt, NULL, (void **)&ri)) {
				listnode_add(delete_list, ri);
				vnc_zlog_debug_verbose(
					"%s: after listnode_add, delete_list->count=%d",
					__func__, delete_list->count);
				rfapiFreeBgpTeaOptionChain(ri->tea_options);
				ri->tea_options = NULL;

				if (ri->timer) {
					struct rfapi_rib_tcb *tcb;

					tcb = EVENT_ARG(ri->timer);
					EVENT_OFF(ri->timer);
					XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
				}

				vnc_zlog_debug_verbose(
					"%s:   put dl pfx=%pRN vn=%pFX un=%pFX cost=%d life=%d vn_options=%p",
					__func__, pn, &ri->rk.vn, &ri->un,
					ri->cost, ri->lifetime, ri->vn_options);

				skiplist_delete_first(slRibPt);
			}

			assert(skiplist_empty(slRibPt));

			skiplist_free(slRibPt);
			rn->info = slRibPt = NULL;
			agg_unlock_node(rn);

			lPendCost = pn->info = NULL;
			agg_unlock_node(pn);

			goto callback;
		}
		if (slRibPt) {
			skiplist_free(slRibPt);
			rn->info = NULL;
			agg_unlock_node(rn);
		}

		assert(!slPendPt);
		if (slPendPt) { /* TBD I think we can toss this block */
			skiplist_free(slPendPt);
			pn->aggregate = NULL;
			agg_unlock_node(pn);
		}

		pn->info = NULL;
		agg_unlock_node(pn);

		agg_unlock_node(rn); /* agg_node_get() */

		if (rib_node_started_nonempty) {
			RFAPI_RIB_PREFIX_COUNT_DECR(rfd, bgp->rfapi);
		}

		RFAPI_RIB_CHECK_COUNTS(1, 0);

		return;
	}

	vnc_zlog_debug_verbose("%s:   lPendCost->count=%d, slRibPt->count=%d",
			       __func__,
			       (lPendCost ? (int)lPendCost->count : -1),
			       (slRibPt ? (int)slRibPt->count : -1));

	/*
	 * Iterate over routes at RIB Node.
	 * If not found at Pending Node, delete from RIB Node and add to
	 * deletelist
	 * If found at Pending Node
	 *      If identical rfapi_info, delete from Pending Node
	 */
	if (slRibPt) {
		void *cursor = NULL;
		struct rfapi_info *ori;

		/*
		 * Iterate over RIB List
		 *
		 */
		while (!skiplist_next(slRibPt, NULL, (void **)&ori, &cursor)) {

			if (skiplist_search(slPendPt, &ori->rk, (void **)&ri)) {
				/*
				 * Not in Pending list, so it should be deleted
				 */
				if (!delete_list)
					delete_list = list_new();
				listnode_add(delete_list, ori);
				rfapiFreeBgpTeaOptionChain(ori->tea_options);
				ori->tea_options = NULL;
				if (ori->timer) {
					struct rfapi_rib_tcb *tcb;

					tcb = EVENT_ARG(ori->timer);
					EVENT_OFF(ori->timer);
					XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
				}

#if DEBUG_PROCESS_PENDING_NODE
				/* deleted from slRibPt below, after we're done
				 * iterating */
				vnc_zlog_debug_verbose(
					"%s:   slRibPt ri %p not matched in pending list, delete",
					__func__, ori);
#endif

			} else {
				/*
				 * Found in pending list. If same lifetime,
				 * cost, options,
				 * then remove from pending list because the
				 * route
				 * hasn't changed.
				 */
				if (!rfapi_info_cmp(ori, ri)) {
					skiplist_delete(slPendPt, &ri->rk,
							NULL);
					assert(lPendCost);
					if (lPendCost) {
						/* linear walk: might need
						 * optimization */
						listnode_delete(lPendCost,
								ri); /* XXX
									doesn't
									free
									data!
									bug? */
						rfapi_info_free(
							ri); /* grr... */
					}
				}
#if DEBUG_PROCESS_PENDING_NODE
				vnc_zlog_debug_verbose(
					"%s:   slRibPt ri %p matched in pending list, %s",
					__func__, ori,
					(same ? "same info"
					      : "different info"));
#endif
			}
		}
		/*
		 * Go back and delete items from RIB
		 */
		if (delete_list) {
			for (ALL_LIST_ELEMENTS_RO(delete_list, node, ri)) {
				vnc_zlog_debug_verbose(
					"%s:   deleting ri %p from slRibPt",
					__func__, ri);
				assert(!skiplist_delete(slRibPt, &ri->rk,
							NULL));
			}
			if (skiplist_empty(slRibPt)) {
				skiplist_free(slRibPt);
				slRibPt = rn->info = NULL;
				agg_unlock_node(rn);
			}
		}
	}

	RFAPI_RIB_CHECK_COUNTS(0, (delete_list ? delete_list->count : 0));

	/*
	 * Iterate over routes at Pending Node
	 *
	 * If {vn} found at RIB Node, update RIB Node route contents to match PN
	 * If {vn} NOT found at RIB Node, add copy to RIB Node
	 */
	if (lPendCost) {
		for (ALL_LIST_ELEMENTS_RO(lPendCost, node, ri)) {

			struct rfapi_info *ori;

			if (slRibPt
			    && !skiplist_search(slRibPt, &ri->rk,
						(void **)&ori)) {

				/* found: update contents of existing route in
				 * RIB */
				ori->un = ri->un;
				ori->cost = ri->cost;
				ori->lifetime = ri->lifetime;
				rfapiFreeBgpTeaOptionChain(ori->tea_options);
				ori->tea_options =
					rfapiOptionsDup(ri->tea_options);
				ori->last_sent_time = monotime(NULL);

				rfapiFreeRfapiVnOptionChain(ori->vn_options);
				ori->vn_options =
					rfapiVnOptionsDup(ri->vn_options);

				rfapiFreeRfapiUnOptionChain(ori->un_options);
				ori->un_options =
					rfapiUnOptionsDup(ri->un_options);

				vnc_zlog_debug_verbose(
					"%s:   matched lPendCost item %p in slRibPt, rewrote",
					__func__, ri);

			} else {
				/* not found: add new route to RIB */
				ori = rfapi_info_new();
				ori->rk = ri->rk;
				ori->un = ri->un;
				ori->cost = ri->cost;
				ori->lifetime = ri->lifetime;
				ori->tea_options =
					rfapiOptionsDup(ri->tea_options);
				ori->last_sent_time = monotime(NULL);
				ori->vn_options =
					rfapiVnOptionsDup(ri->vn_options);
				ori->un_options =
					rfapiUnOptionsDup(ri->un_options);

				if (!slRibPt) {
					slRibPt = skiplist_new(
						0, rfapi_rib_key_cmp, NULL);
					rn->info = slRibPt;
					agg_lock_node(rn);
				}
				skiplist_insert(slRibPt, &ori->rk, ori);

				vnc_zlog_debug_verbose(
					"%s:   nomatch lPendCost item %p in slRibPt, added (rd=%pRDP)",
					__func__, ri, &ori->rk.rd);
			}

			/*
			 * poke timer
			 */
			RFAPI_RIB_CHECK_COUNTS(
				0, (delete_list ? delete_list->count : 0));
			rfapiRibStartTimer(rfd, ori, rn, 0);
			RFAPI_RIB_CHECK_COUNTS(
				0, (delete_list ? delete_list->count : 0));
		}
	}


callback:
	/*
	 * Construct NHL as concatenation of pending list + delete list
	 */


	RFAPI_RIB_CHECK_COUNTS(0, (delete_list ? delete_list->count : 0));

	if (lPendCost) {

		char buf[BUFSIZ];
		char buf2[BUFSIZ];

		vnc_zlog_debug_verbose("%s: lPendCost->count now %d", __func__,
				       lPendCost->count);
		vnc_zlog_debug_verbose("%s: For prefix %pRN (a)", __func__, pn);
		printedprefix = 1;

		for (ALL_LIST_ELEMENTS(lPendCost, node, nnode, ri)) {

			struct rfapi_next_hop_entry *new;
			struct agg_node *trn;

			new = XCALLOC(MTYPE_RFAPI_NEXTHOP,
				      sizeof(struct rfapi_next_hop_entry));

			if (ri->rk.aux_prefix.family) {
				rfapiQprefix2Rprefix(&ri->rk.aux_prefix,
						     &new->prefix);
			} else {
				new->prefix = hp;
				if (AFI_L2VPN == afi) {
					/* hp is 0; need to set length to match
					 * AF of vn */
					new->prefix.length =
						(ri->rk.vn.family == AF_INET)
							? 32
							: 128;
				}
			}
			new->prefix.cost = ri->cost;
			new->lifetime = ri->lifetime;
			rfapiQprefix2Raddr(&ri->rk.vn, &new->vn_address);
			rfapiQprefix2Raddr(&ri->un, &new->un_address);
			/* free option chain from ri */
			rfapiFreeBgpTeaOptionChain(ri->tea_options);

			ri->tea_options =
				NULL; /* option chain was transferred to NHL */

			new->vn_options = ri->vn_options;
			ri->vn_options =
				NULL; /* option chain was transferred to NHL */

			new->un_options = ri->un_options;
			ri->un_options =
				NULL; /* option chain was transferred to NHL */

			if (*tail)
				(*tail)->next = new;
			*tail = new;
			if (!*head) {
				*head = new;
			}
			sendingsomeroutes = 1;

			++rfd->stat_count_nh_reachable;
			++bgp->rfapi->stat.count_updated_response_updates;

			/*
			 * update this NVE's timestamp for this prefix
			 */
			trn = agg_node_get(rfd->rsp_times[afi],
					   p); /* locks trn */
			trn->info = (void *)(uintptr_t)monotime(NULL);
			if (agg_node_get_lock_count(trn) > 1)
				agg_unlock_node(trn);

			rfapiRfapiIpAddr2Str(&new->vn_address, buf, BUFSIZ);
			rfapiRfapiIpAddr2Str(&new->un_address, buf2, BUFSIZ);
			vnc_zlog_debug_verbose(
				"%s:   add vn=%s un=%s cost=%d life=%d",
				__func__, buf, buf2, new->prefix.cost,
				new->lifetime);
		}
	}

	RFAPI_RIB_CHECK_COUNTS(0, (delete_list ? delete_list->count : 0));

	if (delete_list) {

		char buf[BUFSIZ];
		char buf2[BUFSIZ];

		if (!printedprefix) {
			vnc_zlog_debug_verbose("%s: For prefix %pRN (d)",
					       __func__, pn);
		}
		vnc_zlog_debug_verbose("%s: delete_list has %d elements",
				       __func__, delete_list->count);

		RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
		if (!CHECK_FLAG(bgp->rfapi_cfg->flags,
				BGP_VNC_CONFIG_RESPONSE_REMOVAL_DISABLE)) {

			for (ALL_LIST_ELEMENTS(delete_list, node, nnode, ri)) {

				struct rfapi_next_hop_entry *new;
				struct rfapi_info *ri_del;

				RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
				new = XCALLOC(
					MTYPE_RFAPI_NEXTHOP,
					sizeof(struct rfapi_next_hop_entry));

				if (ri->rk.aux_prefix.family) {
					rfapiQprefix2Rprefix(&ri->rk.aux_prefix,
							     &new->prefix);
				} else {
					new->prefix = hp;
					if (AFI_L2VPN == afi) {
						/* hp is 0; need to set length
						 * to match AF of vn */
						new->prefix.length =
							(ri->rk.vn.family
							 == AF_INET)
								? 32
								: 128;
					}
				}

				new->prefix.cost = ri->cost;
				new->lifetime = RFAPI_REMOVE_RESPONSE_LIFETIME;
				rfapiQprefix2Raddr(&ri->rk.vn,
						   &new->vn_address);
				rfapiQprefix2Raddr(&ri->un, &new->un_address);

				new->vn_options = ri->vn_options;
				ri->vn_options = NULL; /* option chain was
							  transferred to NHL */

				new->un_options = ri->un_options;
				ri->un_options = NULL; /* option chain was
							  transferred to NHL */

				if (*tail)
					(*tail)->next = new;
				*tail = new;
				if (!*head) {
					*head = new;
				}
				++rfd->stat_count_nh_removal;
				++bgp->rfapi->stat
					  .count_updated_response_deletes;

				rfapiRfapiIpAddr2Str(&new->vn_address, buf,
						     BUFSIZ);
				rfapiRfapiIpAddr2Str(&new->un_address, buf2,
						     BUFSIZ);
				vnc_zlog_debug_verbose(
					"%s:   DEL vn=%s un=%s cost=%d life=%d",
					__func__, buf, buf2, new->prefix.cost,
					new->lifetime);

				RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
				/*
				 * Update/add to list of recent deletions at
				 * this prefix
				 */
				if (!rn->aggregate) {
					rn->aggregate = skiplist_new(
						0, rfapi_rib_key_cmp,
						(void (*)(void *))
							rfapi_info_free);
					agg_lock_node(rn);
				}
				RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);

				/* sanity check lifetime */
				if (ri->lifetime
				    > RFAPI_LIFETIME_INFINITE_WITHDRAW_DELAY)
					ri->lifetime =
						RFAPI_LIFETIME_INFINITE_WITHDRAW_DELAY;

				RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);
				/* cancel normal expire timer */
				if (ri->timer) {
					struct rfapi_rib_tcb *tcb;

					tcb = EVENT_ARG(ri->timer);
					EVENT_OFF(ri->timer);
					XFREE(MTYPE_RFAPI_RECENT_DELETE, tcb);
				}
				RFAPI_RIB_CHECK_COUNTS(0, delete_list->count);

				/*
				 * Look in "recently-deleted" list
				 */
				if (skiplist_search(
					    (struct skiplist *)(rn->aggregate),
					    &ri->rk, (void **)&ri_del)) {

					int rc;

					RFAPI_RIB_CHECK_COUNTS(
						0, delete_list->count);
					/*
					 * NOT in "recently-deleted" list
					 */
					list_delete_node(
						delete_list,
						node); /* does not free ri */
					rc = skiplist_insert(
						(struct skiplist
							 *)(rn->aggregate),
						&ri->rk, ri);
					assert(!rc);

					RFAPI_RIB_CHECK_COUNTS(
						0, delete_list->count);
					rfapiRibStartTimer(rfd, ri, rn, 1);
					RFAPI_RIB_CHECK_COUNTS(
						0, delete_list->count);
					ri->last_sent_time = monotime(NULL);
#if DEBUG_RIB_SL_RD
					vnc_zlog_debug_verbose(
						"%s: move route to recently deleted list, rd=%pRDP",
						__func__, &ri->rk.rd);
#endif

				} else {
					/*
					 * IN "recently-deleted" list
					 */
					RFAPI_RIB_CHECK_COUNTS(
						0, delete_list->count);
					rfapiRibStartTimer(rfd, ri_del, rn, 1);
					RFAPI_RIB_CHECK_COUNTS(
						0, delete_list->count);
					ri->last_sent_time = monotime(NULL);
				}
			}
		} else {
			vnc_zlog_debug_verbose(
				"%s: response removal disabled, omitting removals",
				__func__);
		}

		delete_list->del = (void (*)(void *))rfapi_info_free;
		list_delete(&delete_list);
	}

	RFAPI_RIB_CHECK_COUNTS(0, 0);

	/*
	 * Reset pending lists. The final agg_unlock_node() will probably
	 * cause the pending node to be released.
	 */
	if (slPendPt) {
		skiplist_free(slPendPt);
		pn->aggregate = NULL;
		agg_unlock_node(pn);
	}
	if (lPendCost) {
		list_delete(&lPendCost);
		pn->info = NULL;
		agg_unlock_node(pn);
	}
	RFAPI_RIB_CHECK_COUNTS(0, 0);

	if (rib_node_started_nonempty) {
		if (!rn->info) {
			RFAPI_RIB_PREFIX_COUNT_DECR(rfd, bgp->rfapi);
		}
	} else {
		if (rn->info) {
			RFAPI_RIB_PREFIX_COUNT_INCR(rfd, bgp->rfapi);
		}
	}

	if (sendingsomeroutes)
		rfapiMonitorTimersRestart(rfd, p);

	agg_unlock_node(rn); /* agg_node_get() */

	RFAPI_RIB_CHECK_COUNTS(1, 0);
}

/*
 * regardless of targets, construct a single callback by doing
 * only one traversal of the pending RIB
 *
 *
 * Do callback
 *
 */
static void rib_do_callback_onepass(struct rfapi_descriptor *rfd, afi_t afi)
{
	struct bgp *bgp = bgp_get_default();
	struct rfapi_next_hop_entry *head = NULL;
	struct rfapi_next_hop_entry *tail = NULL;
	struct agg_node *rn;

#ifdef DEBUG_L2_EXTRA
	vnc_zlog_debug_verbose("%s: rfd=%p, afi=%d", __func__, rfd, afi);
#endif

	if (!rfd->rib_pending[afi])
		return;

	assert(bgp->rfapi);

	for (rn = agg_route_top(rfd->rib_pending[afi]); rn;
	     rn = agg_route_next(rn)) {
		process_pending_node(bgp, rfd, afi, rn, &head, &tail);
	}

	if (head) {
		rfapi_response_cb_t *f;

#if DEBUG_NHL
		vnc_zlog_debug_verbose("%s: response callback NHL follows:",
				       __func__);
		rfapiPrintNhl(NULL, head);
#endif

		if (rfd->response_cb)
			f = rfd->response_cb;
		else
			f = bgp->rfapi->rfp_methods.response_cb;

		bgp->rfapi->flags |= RFAPI_INCALLBACK;
		vnc_zlog_debug_verbose("%s: invoking updated response callback",
				       __func__);
		(*f)(head, rfd->cookie);
		bgp->rfapi->flags &= ~RFAPI_INCALLBACK;
		++bgp->rfapi->response_updated_count;
	}
}

static wq_item_status rfapiRibDoQueuedCallback(struct work_queue *wq,
					       void *data)
{
	struct rfapi_descriptor *rfd;
	afi_t afi;
	uint32_t queued_flag;

	RFAPI_RIB_CHECK_COUNTS(1, 0);

	rfd = ((struct rfapi_updated_responses_queue *)data)->rfd;
	afi = ((struct rfapi_updated_responses_queue *)data)->afi;

	/* Make sure the HD wasn't closed after the work item was scheduled */
	if (rfapi_check(rfd))
		return WQ_SUCCESS;

	rib_do_callback_onepass(rfd, afi);

	queued_flag = RFAPI_QUEUED_FLAG(afi);

	UNSET_FLAG(rfd->flags, queued_flag);

	RFAPI_RIB_CHECK_COUNTS(1, 0);

	return WQ_SUCCESS;
}

static void rfapiRibQueueItemDelete(struct work_queue *wq, void *data)
{
	XFREE(MTYPE_RFAPI_UPDATED_RESPONSE_QUEUE, data);
}

static void updated_responses_queue_init(struct rfapi_descriptor *rfd)
{
	if (rfd->updated_responses_queue)
		return;

	rfd->updated_responses_queue =
		work_queue_new(bm->master, "rfapi updated responses");
	assert(rfd->updated_responses_queue);

	rfd->updated_responses_queue->spec.workfunc = rfapiRibDoQueuedCallback;
	rfd->updated_responses_queue->spec.del_item_data =
		rfapiRibQueueItemDelete;
	rfd->updated_responses_queue->spec.max_retries = 0;
	rfd->updated_responses_queue->spec.hold = 1;
}

/*
 * Called when an import table node is modified. Construct a
 * new complete nexthop list, sorted by cost (lowest first),
 * based on the import table node.
 *
 * Filter out duplicate nexthops (vn address). There should be
 * only one UN address per VN address from the point of view of
 * a given import table, so we can probably ignore UN addresses
 * while filtering.
 *
 * Based on rfapiNhlAddNodeRoutes()
 */
void rfapiRibUpdatePendingNode(
	struct bgp *bgp, struct rfapi_descriptor *rfd,
	struct rfapi_import_table *it, /* needed for L2 */
	struct agg_node *it_node, uint32_t lifetime)
{
	const struct prefix *prefix;
	struct bgp_path_info *bpi;
	struct agg_node *pn;
	afi_t afi;
	uint32_t queued_flag;
	int count = 0;

	vnc_zlog_debug_verbose("%s: entry", __func__);

	if (CHECK_FLAG(bgp->rfapi_cfg->flags, BGP_VNC_CONFIG_CALLBACK_DISABLE))
		return;

	vnc_zlog_debug_verbose("%s: callbacks are not disabled", __func__);

	RFAPI_RIB_CHECK_COUNTS(1, 0);

	prefix = agg_node_get_prefix(it_node);
	afi = family2afi(prefix->family);
	vnc_zlog_debug_verbose("%s: prefix=%pFX", __func__, prefix);

	pn = agg_node_get(rfd->rib_pending[afi], prefix);
	assert(pn);

	vnc_zlog_debug_verbose("%s: pn->info=%p, pn->aggregate=%p", __func__,
			       pn->info, pn->aggregate);

	if (pn->aggregate) {
		/*
		 * free references into the rfapi_info structures before
		 * freeing the structures themselves
		 */
		skiplist_free((struct skiplist *)(pn->aggregate));
		pn->aggregate = NULL;
		agg_unlock_node(pn); /* skiplist deleted */
	}


	/*
	 * free the rfapi_info structures
	 */
	if (pn->info) {
		if (pn->info != (void *)1) {
			list_delete((struct list **)(&pn->info));
		}
		pn->info = NULL;
		agg_unlock_node(pn); /* linklist or 1 deleted */
	}

	/*
	 * The BPIs in the import table are already sorted by cost
	 */
	for (bpi = it_node->info; bpi; bpi = bpi->next) {

		struct rfapi_info *ri;
		struct prefix pfx_nh;

		if (!bpi->extra) {
			/* shouldn't happen */
			/* TBD increment error stats counter */
			continue;
		}

		rfapiNexthop2Prefix(bpi->attr, &pfx_nh);

		/*
		 * Omit route if nexthop is self
		 */
		if (CHECK_FLAG(bgp->rfapi_cfg->flags,
			       BGP_VNC_CONFIG_FILTER_SELF_FROM_RSP)) {

			struct prefix pfx_vn;

			assert(!rfapiRaddr2Qprefix(&rfd->vn_addr, &pfx_vn));
			if (prefix_same(&pfx_vn, &pfx_nh))
				continue;
		}

		ri = rfapi_info_new();
		ri->rk.vn = pfx_nh;
		ri->rk.rd = bpi->extra->vnc->vnc.import.rd;
		/*
		 * If there is an auxiliary IP address (L2 can have it), copy it
		 */
		if (bpi->extra->vnc->vnc.import.aux_prefix.family) {
			ri->rk.aux_prefix =
				bpi->extra->vnc->vnc.import.aux_prefix;
		}

		if (rfapiGetUnAddrOfVpnBi(bpi, &ri->un)) {
			rfapi_info_free(ri);
			continue;
		}

		if (!pn->aggregate) {
			pn->aggregate =
				skiplist_new(0, rfapi_rib_key_cmp, NULL);
			agg_lock_node(pn);
		}

		/*
		 * If we have already added this nexthop, the insert will fail.
		 * Note that the skiplist key is a pointer INTO the rfapi_info
		 * structure which will be added to the "info" list.
		 * The skiplist entry VALUE is not used for anything but
		 * might be useful during debugging.
		 */
		if (skiplist_insert((struct skiplist *)pn->aggregate, &ri->rk,
				    ri)) {

			/*
			 * duplicate
			 */
			rfapi_info_free(ri);
			continue;
		}

		rfapiRibBi2Ri(bpi, ri, lifetime);

		if (!pn->info) {
			pn->info = list_new();
			((struct list *)(pn->info))->del =
				(void (*)(void *))rfapi_info_free;
			agg_lock_node(pn);
		}

		listnode_add((struct list *)(pn->info), ri);
	}

	if (pn->info) {
		count = ((struct list *)(pn->info))->count;
	}

	if (!count) {
		assert(!pn->info);
		assert(!pn->aggregate);
		pn->info = (void *)1; /* magic value means this node has no
					 routes */
		agg_lock_node(pn);
	}

	agg_unlock_node(pn); /* agg_node_get */

	queued_flag = RFAPI_QUEUED_FLAG(afi);

	if (!CHECK_FLAG(rfd->flags, queued_flag)) {

		struct rfapi_updated_responses_queue *urq;

		urq = XCALLOC(MTYPE_RFAPI_UPDATED_RESPONSE_QUEUE,
			      sizeof(struct rfapi_updated_responses_queue));
		if (!rfd->updated_responses_queue)
			updated_responses_queue_init(rfd);

		SET_FLAG(rfd->flags, queued_flag);
		urq->rfd = rfd;
		urq->afi = afi;
		work_queue_add(rfd->updated_responses_queue, urq);
	}
	RFAPI_RIB_CHECK_COUNTS(1, 0);
}

void rfapiRibUpdatePendingNodeSubtree(
	struct bgp *bgp, struct rfapi_descriptor *rfd,
	struct rfapi_import_table *it, struct agg_node *it_node,
	struct agg_node *omit_subtree, /* may be NULL */
	uint32_t lifetime)
{
	/* FIXME: need to find a better way here to work without sticking our
	 * hands in node->link */
	if (agg_node_left(it_node)
	    && (agg_node_left(it_node) != omit_subtree)) {
		if (agg_node_left(it_node)->info)
			rfapiRibUpdatePendingNode(
				bgp, rfd, it, agg_node_left(it_node), lifetime);
		rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it,
						 agg_node_left(it_node),
						 omit_subtree, lifetime);
	}

	if (agg_node_right(it_node)
	    && (agg_node_right(it_node) != omit_subtree)) {
		if (agg_node_right(it_node)->info)
			rfapiRibUpdatePendingNode(bgp, rfd, it,
						  agg_node_right(it_node),
						  lifetime);
		rfapiRibUpdatePendingNodeSubtree(bgp, rfd, it,
						 agg_node_right(it_node),
						 omit_subtree, lifetime);
	}
}

/*
 * RETURN VALUE
 *
 *	0	allow prefix to be included in response
 *	!0	don't allow prefix to be included in response
 */
int rfapiRibFTDFilterRecentPrefix(
	struct rfapi_descriptor *rfd,
	struct agg_node *it_rn,		    /* import table node */
	struct prefix *pfx_target_original) /* query target */
{
	struct bgp *bgp = rfd->bgp;
	const struct prefix *p = agg_node_get_prefix(it_rn);
	afi_t afi = family2afi(p->family);
	time_t prefix_time;
	struct agg_node *trn;

	/*
	 * Not in FTD mode, so allow prefix
	 */
	if (bgp->rfapi_cfg->rfp_cfg.download_type != RFAPI_RFP_DOWNLOAD_FULL)
		return 0;

	/*
	 * TBD
	 * This matches behavior of now-obsolete rfapiRibFTDFilterRecent(),
	 * but we need to decide if that is correct.
	 */
	if (p->family == AF_ETHERNET)
		return 0;

#ifdef DEBUG_FTD_FILTER_RECENT
	{
		vnc_zlog_debug_verbose("%s: prefix %pFX", __func__,
				       agg_node_get_prefix(it_rn));
	}
#endif

	/*
	 * prefix covers target address, so allow prefix
	 */
	if (prefix_match(p, pfx_target_original)) {
#ifdef DEBUG_FTD_FILTER_RECENT
		vnc_zlog_debug_verbose("%s: prefix covers target, allowed",
				       __func__);
#endif
		return 0;
	}

	/*
	 * check this NVE's timestamp for this prefix
	 */
	trn = agg_node_get(rfd->rsp_times[afi], p); /* locks trn */
	prefix_time = (time_t)trn->info;
	if (agg_node_get_lock_count(trn) > 1)
		agg_unlock_node(trn);

#ifdef DEBUG_FTD_FILTER_RECENT
	vnc_zlog_debug_verbose("%s: last sent time %lu, last allowed time %lu",
			       __func__, prefix_time,
			       rfd->ftd_last_allowed_time);
#endif

	/*
	 * haven't sent this prefix, which doesn't cover target address,
	 * to NVE since ftd_advertisement_interval, so OK to send now.
	 */
	if (prefix_time <= rfd->ftd_last_allowed_time)
		return 0;

	return 1;
}

/*
 * Call when rfapi returns from rfapi_query() so the RIB reflects
 * the routes sent to the NVE before the first updated response
 *
 * Also: remove duplicates from response. Caller should use returned
 * value of nexthop chain.
 */
struct rfapi_next_hop_entry *
rfapiRibPreload(struct bgp *bgp, struct rfapi_descriptor *rfd,
		struct rfapi_next_hop_entry *response, int use_eth_resolution)
{
	struct rfapi_next_hop_entry *nhp;
	struct rfapi_next_hop_entry *nhp_next;
	struct rfapi_next_hop_entry *head = NULL;
	struct rfapi_next_hop_entry *tail = NULL;
	time_t new_last_sent_time;

	vnc_zlog_debug_verbose("%s: loading response=%p, use_eth_resolution=%d",
			       __func__, response, use_eth_resolution);

	new_last_sent_time = monotime(NULL);

	for (nhp = response; nhp; nhp = nhp_next) {

		struct prefix pfx;
		struct rfapi_rib_key rk;
		afi_t afi;
		struct rfapi_info *ri;
		int need_insert;
		struct agg_node *rn;
		int rib_node_started_nonempty = 0;
		struct agg_node *trn;
		int allowed = 0;

		/* save in case we delete nhp */
		nhp_next = nhp->next;

		if (nhp->lifetime == RFAPI_REMOVE_RESPONSE_LIFETIME) {
			/*
			 * weird, shouldn't happen
			 */
			vnc_zlog_debug_verbose(
				"%s: got nhp->lifetime == RFAPI_REMOVE_RESPONSE_LIFETIME",
				__func__);
			continue;
		}


		if (use_eth_resolution) {
			/* get the prefix of the ethernet address in the L2
			 * option */
			struct rfapi_l2address_option *pL2o;
			struct rfapi_vn_option *vo;

			/*
			 * Look for VN option of type
			 * RFAPI_VN_OPTION_TYPE_L2ADDR
			 */
			for (pL2o = NULL, vo = nhp->vn_options; vo;
			     vo = vo->next) {
				if (RFAPI_VN_OPTION_TYPE_L2ADDR == vo->type) {
					pL2o = &vo->v.l2addr;
					break;
				}
			}

			if (!pL2o) {
				/*
				 * not supposed to happen
				 */
				vnc_zlog_debug_verbose("%s: missing L2 info",
						       __func__);
				continue;
			}

			afi = AFI_L2VPN;
			rfapiL2o2Qprefix(pL2o, &pfx);
		} else {
			rfapiRprefix2Qprefix(&nhp->prefix, &pfx);
			afi = family2afi(pfx.family);
		}

		/*
		 * TBD for ethernet, rib must know the right way to distinguish
		 * duplicate routes
		 *
		 * Current approach: prefix is key to radix tree; then
		 * each prefix has a set of routes with unique VN addrs
		 */

		/*
		 * Look up prefix in RIB
		 */
		rn = agg_node_get(rfd->rib[afi], &pfx); /* locks rn */

		if (rn->info) {
			rib_node_started_nonempty = 1;
		} else {
			rn->info = skiplist_new(0, rfapi_rib_key_cmp, NULL);
			agg_lock_node(rn);
		}

		/*
		 * Look up route at prefix
		 */
		need_insert = 0;
		memset((void *)&rk, 0, sizeof(rk));
		assert(!rfapiRaddr2Qprefix(&nhp->vn_address, &rk.vn));

		if (use_eth_resolution) {
			/* copy what came from aux_prefix to rk.aux_prefix */
			rfapiRprefix2Qprefix(&nhp->prefix, &rk.aux_prefix);
			if (RFAPI_0_PREFIX(&rk.aux_prefix)
			    && RFAPI_HOST_PREFIX(&rk.aux_prefix)) {
				/* mark as "none" if nhp->prefix is 0/32 or
				 * 0/128 */
				rk.aux_prefix.family = AF_UNSPEC;
			}
		}

#if DEBUG_NHL
		{
			char str_aux_prefix[PREFIX_STRLEN];

			str_aux_prefix[0] = 0;

			prefix2str(&rk.aux_prefix, str_aux_prefix,
				   sizeof(str_aux_prefix));

			if (!rk.aux_prefix.family) {
			}
			vnc_zlog_debug_verbose(
				"%s:   rk.vn=%pFX rk.aux_prefix=%s", __func__,
				&rk.vn,
				(rk.aux_prefix.family ? str_aux_prefix : "-"));
		}
		vnc_zlog_debug_verbose(
			"%s: RIB skiplist for this prefix follows", __func__);
		rfapiRibShowRibSl(NULL, agg_node_get_prefix(rn),
				  (struct skiplist *)rn->info);
#endif


		if (!skiplist_search((struct skiplist *)rn->info, &rk,
				     (void **)&ri)) {
			/*
			 * Already have this route; make values match
			 */
			rfapiFreeRfapiUnOptionChain(ri->un_options);
			ri->un_options = NULL;
			rfapiFreeRfapiVnOptionChain(ri->vn_options);
			ri->vn_options = NULL;

#if DEBUG_NHL
			vnc_zlog_debug_verbose("%s: found in RIB", __func__);
#endif

			/*
			 * Filter duplicate routes from initial response.
			 * Check timestamps to avoid wraparound problems
			 */
			if ((ri->rsp_counter != rfd->rsp_counter)
			    || (ri->last_sent_time != new_last_sent_time)) {

#if DEBUG_NHL
				vnc_zlog_debug_verbose(
					"%s: allowed due to counter/timestamp diff",
					__func__);
#endif
				allowed = 1;
			}

		} else {

#if DEBUG_NHL
			vnc_zlog_debug_verbose(
				"%s: allowed due to not yet in RIB", __func__);
#endif
			/* not found: add new route to RIB */
			ri = rfapi_info_new();
			need_insert = 1;
			allowed = 1;
		}

		ri->rk = rk;
		assert(!rfapiRaddr2Qprefix(&nhp->un_address, &ri->un));
		ri->cost = nhp->prefix.cost;
		ri->lifetime = nhp->lifetime;
		ri->vn_options = rfapiVnOptionsDup(nhp->vn_options);
		ri->rsp_counter = rfd->rsp_counter;
		ri->last_sent_time = monotime(NULL);

		if (need_insert) {
			int rc;
			rc = skiplist_insert((struct skiplist *)rn->info,
					     &ri->rk, ri);
			assert(!rc);
		}

		if (!rib_node_started_nonempty) {
			RFAPI_RIB_PREFIX_COUNT_INCR(rfd, bgp->rfapi);
		}

		RFAPI_RIB_CHECK_COUNTS(0, 0);
		rfapiRibStartTimer(rfd, ri, rn, 0);
		RFAPI_RIB_CHECK_COUNTS(0, 0);

		agg_unlock_node(rn);

		/*
		 * update this NVE's timestamp for this prefix
		 */
		trn = agg_node_get(rfd->rsp_times[afi], &pfx); /* locks trn */
		trn->info = (void *)(uintptr_t)monotime(NULL);
		if (agg_node_get_lock_count(trn) > 1)
			agg_unlock_node(trn);

		vnc_zlog_debug_verbose(
			"%s:   added pfx=%pFX nh[vn]=%pFX, cost=%u, lifetime=%u, allowed=%d",
			__func__, &pfx, &rk.vn, nhp->prefix.cost, nhp->lifetime,
			allowed);

		if (allowed) {
			if (tail)
				(tail)->next = nhp;
			tail = nhp;
			if (!head) {
				head = nhp;
			}
		} else {
			rfapi_un_options_free(nhp->un_options);
			nhp->un_options = NULL;
			rfapi_vn_options_free(nhp->vn_options);
			nhp->vn_options = NULL;

			XFREE(MTYPE_RFAPI_NEXTHOP, nhp);
		}
	}

	if (tail)
		tail->next = NULL;
	return head;
}

void rfapiRibPendingDeleteRoute(struct bgp *bgp, struct rfapi_import_table *it,
				afi_t afi, struct agg_node *it_node)
{
	struct rfapi_descriptor *rfd;
	struct listnode *node;
	const struct prefix *p = agg_node_get_prefix(it_node);

	vnc_zlog_debug_verbose("%s: entry, it=%p, afi=%d, it_node=%p, pfx=%pRN",
			       __func__, it, afi, it_node, it_node);

	if (AFI_L2VPN == afi) {
		/*
		 * ethernet import tables are per-LNI and each ethernet monitor
		 * identifies the rfd that owns it.
		 */
		struct rfapi_monitor_eth *m;
		struct agg_node *rn;
		struct skiplist *sl;
		void *cursor;
		int rc;

		/*
		 * route-specific monitors
		 */
		if ((sl = RFAPI_MONITOR_ETH(it_node))) {

			vnc_zlog_debug_verbose(
				"%s: route-specific skiplist: %p", __func__,
				sl);

			for (cursor = NULL,
			    rc = skiplist_next(sl, NULL, (void **)&m, &cursor);
			     !rc; rc = skiplist_next(sl, NULL, (void **)&m,
						     &cursor)) {

#if DEBUG_PENDING_DELETE_ROUTE
				vnc_zlog_debug_verbose("%s: eth monitor rfd=%p",
						       __func__, m->rfd);
#endif
				/*
				 * If we have already sent a route with this
				 * prefix to this
				 * NVE, it's OK to send an update with the
				 * delete
				 */
				if ((rn = agg_node_lookup(m->rfd->rib[afi],
							  p))) {
					rfapiRibUpdatePendingNode(
						bgp, m->rfd, it, it_node,
						m->rfd->response_lifetime);
					agg_unlock_node(rn);
				}
			}
		}

		/*
		 * all-routes/FTD monitors
		 */
		for (m = it->eth0_queries; m; m = m->next) {
#if DEBUG_PENDING_DELETE_ROUTE
			vnc_zlog_debug_verbose("%s: eth0 monitor rfd=%p",
					       __func__, m->rfd);
#endif
			/*
			 * If we have already sent a route with this prefix to
			 * this
			 * NVE, it's OK to send an update with the delete
			 */
			if ((rn = agg_node_lookup(m->rfd->rib[afi], p))) {
				rfapiRibUpdatePendingNode(
					bgp, m->rfd, it, it_node,
					m->rfd->response_lifetime);
				agg_unlock_node(rn);
			}
		}

	} else {
		/*
		 * Find RFDs that reference this import table
		 */
		for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, node,
					  rfd)) {

			struct agg_node *rn;

			vnc_zlog_debug_verbose(
				"%s: comparing rfd(%p)->import_table=%p to it=%p",
				__func__, rfd, rfd->import_table, it);

			if (rfd->import_table != it)
				continue;

			vnc_zlog_debug_verbose("%s: matched rfd %p", __func__,
					       rfd);

			/*
			 * If we have sent a response to this NVE with this
			 * prefix
			 * previously, we should send an updated response.
			 */
			if ((rn = agg_node_lookup(rfd->rib[afi], p))) {
				rfapiRibUpdatePendingNode(
					bgp, rfd, it, it_node,
					rfd->response_lifetime);
				agg_unlock_node(rn);
			}
		}
	}
}

void rfapiRibShowResponsesSummary(void *stream)
{
	int (*fp)(void *, const char *, ...);
	struct vty *vty;
	void *out;
	const char *vty_newline;
	struct bgp *bgp = bgp_get_default();

	int nves = 0;
	int nves_with_nonempty_ribs = 0;
	struct rfapi_descriptor *rfd;
	struct listnode *node;

	if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
		return;
	if (!bgp) {
		fp(out, "Unable to find default BGP instance\n");
		return;
	}

	fp(out, "%-24s ", "Responses: (Prefixes)");
	fp(out, "%-8s %-8u ", "Active:", bgp->rfapi->rib_prefix_count_total);
	fp(out, "%-8s %-8u",
	   "Maximum:", bgp->rfapi->rib_prefix_count_total_max);
	fp(out, "\n");

	fp(out, "%-24s ", "           (Updated)");
	fp(out, "%-8s %-8u ",
	   "Update:", bgp->rfapi->stat.count_updated_response_updates);
	fp(out, "%-8s %-8u",
	   "Remove:", bgp->rfapi->stat.count_updated_response_deletes);
	fp(out, "%-8s %-8u", "Total:",
	   bgp->rfapi->stat.count_updated_response_updates
		   + bgp->rfapi->stat.count_updated_response_deletes);
	fp(out, "\n");

	fp(out, "%-24s ", "           (NVEs)");
	for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, node, rfd)) {
		++nves;
		if (rfd->rib_prefix_count)
			++nves_with_nonempty_ribs;
	}
	fp(out, "%-8s %-8u ", "Active:", nves_with_nonempty_ribs);
	fp(out, "%-8s %-8u", "Total:", nves);
	fp(out, "\n");
}

void rfapiRibShowResponsesSummaryClear(void)
{
	struct bgp *bgp = bgp_get_default();

	bgp->rfapi->rib_prefix_count_total_max =
		bgp->rfapi->rib_prefix_count_total;
}

static int print_rib_sl(int (*fp)(void *, const char *, ...), struct vty *vty,
			void *out, struct skiplist *sl, int deleted,
			char *str_pfx, int *printedprefix)
{
	struct rfapi_info *ri;
	int rc;
	void *cursor;
	int routes_displayed = 0;

	cursor = NULL;
	for (rc = skiplist_next(sl, NULL, (void **)&ri, &cursor); !rc;
	     rc = skiplist_next(sl, NULL, (void **)&ri, &cursor)) {

		char str_vn[PREFIX_STRLEN];
		char str_un[PREFIX_STRLEN];
		char str_lifetime[BUFSIZ];
		char str_age[BUFSIZ];
		char *p;

		++routes_displayed;

		prefix2str(&ri->rk.vn, str_vn, sizeof(str_vn));
		p = index(str_vn, '/');
		if (p)
			*p = 0;

		prefix2str(&ri->un, str_un, sizeof(str_un));
		p = index(str_un, '/');
		if (p)
			*p = 0;

		rfapiFormatSeconds(ri->lifetime, str_lifetime, BUFSIZ);
#ifdef RFAPI_REGISTRATIONS_REPORT_AGE
		rfapiFormatAge(ri->last_sent_time, str_age, BUFSIZ);
#else
		{
			time_t now = monotime(NULL);
			time_t expire =
				ri->last_sent_time + (time_t)ri->lifetime;
			/* allow for delayed/async removal */
			rfapiFormatSeconds((expire > now ? expire - now : 1),
					   str_age, BUFSIZ);
		}
#endif

		fp(out, " %c %-20s %-15s %-15s %-4u %-8s %-8s %pRDP\n",
		   deleted ? 'r' : ' ', *printedprefix ? "" : str_pfx, str_vn,
		   str_un, ri->cost, str_lifetime, str_age, &ri->rk.rd);

		if (!*printedprefix)
			*printedprefix = 1;
	}
	return routes_displayed;
}

#if DEBUG_NHL
/*
 * This one is for debugging (set stream to NULL to send output to log)
 */
static void rfapiRibShowRibSl(void *stream, struct prefix *pfx,
			      struct skiplist *sl)
{
	int (*fp)(void *, const char *, ...);
	struct vty *vty;
	void *out;
	const char *vty_newline;

	int nhs_displayed = 0;
	char str_pfx[PREFIX_STRLEN];
	int printedprefix = 0;

	if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
		return;

	prefix2str(pfx, str_pfx, sizeof(str_pfx));

	nhs_displayed +=
		print_rib_sl(fp, vty, out, sl, 0, str_pfx, &printedprefix);
}
#endif

void rfapiRibShowResponses(void *stream, struct prefix *pfx_match,
			   int show_removed)
{
	int (*fp)(void *, const char *, ...);
	struct vty *vty;
	void *out;
	const char *vty_newline;

	struct rfapi_descriptor *rfd;
	struct listnode *node;

	struct bgp *bgp = bgp_get_default();
	int printedheader = 0;
	int routes_total = 0;
	int nhs_total = 0;
	int nves_displayed = 0;
	int routes_displayed = 0;
	int nhs_displayed = 0;

	if (rfapiStream2Vty(stream, &fp, &vty, &out, &vty_newline) == 0)
		return;
	if (!bgp) {
		fp(out, "Unable to find default BGP instance\n");
		return;
	}

	/*
	 * loop over NVEs
	 */
	for (ALL_LIST_ELEMENTS_RO(&bgp->rfapi->descriptors, node, rfd)) {

		int printednve = 0;
		afi_t afi;

		for (afi = AFI_IP; afi < AFI_MAX; ++afi) {

			struct agg_node *rn;

			if (!rfd->rib[afi])
				continue;

			for (rn = agg_route_top(rfd->rib[afi]); rn;
			     rn = agg_route_next(rn)) {
				const struct prefix *p =
					agg_node_get_prefix(rn);
				struct skiplist *sl;
				char str_pfx[PREFIX_STRLEN];
				int printedprefix = 0;

				if (!show_removed)
					sl = rn->info;
				else
					sl = rn->aggregate;

				if (!sl)
					continue;

				routes_total++;
				nhs_total += skiplist_count(sl);

				if (pfx_match && !prefix_match(pfx_match, p)
				    && !prefix_match(p, pfx_match))
					continue;

				if (!printedheader) {
					++printedheader;

					fp(out, "\n[%s]\n",
					   show_removed ? "Removed" : "Active");
					fp(out, "%-15s %-15s\n", "Querying VN",
					   "Querying UN");
					fp(out,
					   "   %-20s %-15s %-15s %4s %-8s %-8s\n",
					   "Prefix", "Registered VN",
					   "Registered UN", "Cost", "Lifetime",
#ifdef RFAPI_REGISTRATIONS_REPORT_AGE
					   "Age"
#else
					   "Remaining"
#endif
					);
				}
				if (!printednve) {
					char str_vn[BUFSIZ];
					char str_un[BUFSIZ];

					++printednve;
					++nves_displayed;

					fp(out, "%-15s %-15s\n",
					   rfapiRfapiIpAddr2Str(&rfd->vn_addr,
								str_vn, BUFSIZ),
					   rfapiRfapiIpAddr2Str(&rfd->un_addr,
								str_un,
								BUFSIZ));
				}
				prefix2str(p, str_pfx, sizeof(str_pfx));
				// fp(out, "  %s\n", buf);  /* prefix */

				routes_displayed++;
				nhs_displayed += print_rib_sl(
					fp, vty, out, sl, show_removed, str_pfx,
					&printedprefix);
			}
		}
	}

	if (routes_total) {
		fp(out, "\n");
		fp(out, "Displayed %u NVEs, and %u out of %u %s prefixes",
		   nves_displayed, routes_displayed, routes_total,
		   show_removed ? "removed" : "active");
		if (nhs_displayed != routes_displayed
		    || nhs_total != routes_total)
			fp(out, " with %u out of %u next hops", nhs_displayed,
			   nhs_total);
		fp(out, "\n");
	}
}
