Adding upstream version 8.4.4.upstream/8.4.4upstream

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

1 files changed, 1066 insertions, 0 deletions

diff --git a/bgpd/bgp_updgrp_adv.c b/bgpd/bgp_updgrp_adv.c
new file mode 100644
index 0000000..b301899
--- /dev/null
+++ b/bgpd/bgp_updgrp_adv.c
@@ -0,0 +1,1066 @@
+/**
+ * bgp_updgrp_adv.c: BGP update group advertisement and adjacency
+ *                   maintenance
+ *
+ *
+ * @copyright Copyright (C) 2014 Cumulus Networks, Inc.
+ *
+ * @author Avneesh Sachdev <avneesh@sproute.net>
+ * @author Rajesh Varadarajan <rajesh@sproute.net>
+ * @author Pradosh Mohapatra <pradosh@sproute.net>
+ *
+ * This file is part of GNU Zebra.
+ *
+ * GNU Zebra is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * GNU Zebra is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#include "command.h"
+#include "memory.h"
+#include "prefix.h"
+#include "hash.h"
+#include "thread.h"
+#include "queue.h"
+#include "routemap.h"
+#include "filter.h"
+
+#include "bgpd/bgpd.h"
+#include "bgpd/bgp_table.h"
+#include "bgpd/bgp_debug.h"
+#include "bgpd/bgp_route.h"
+#include "bgpd/bgp_advertise.h"
+#include "bgpd/bgp_attr.h"
+#include "bgpd/bgp_aspath.h"
+#include "bgpd/bgp_packet.h"
+#include "bgpd/bgp_fsm.h"
+#include "bgpd/bgp_mplsvpn.h"
+#include "bgpd/bgp_updgrp.h"
+#include "bgpd/bgp_advertise.h"
+#include "bgpd/bgp_addpath.h"
+
+
+/********************
+ * PRIVATE FUNCTIONS
+ ********************/
+static int bgp_adj_out_compare(const struct bgp_adj_out *o1,
+			       const struct bgp_adj_out *o2)
+{
+	if (o1->subgroup < o2->subgroup)
+		return -1;
+
+	if (o1->subgroup > o2->subgroup)
+		return 1;
+
+	if (o1->addpath_tx_id < o2->addpath_tx_id)
+		return -1;
+
+	if (o1->addpath_tx_id > o2->addpath_tx_id)
+		return 1;
+
+	return 0;
+}
+RB_GENERATE(bgp_adj_out_rb, bgp_adj_out, adj_entry, bgp_adj_out_compare);
+
+static inline struct bgp_adj_out *adj_lookup(struct bgp_dest *dest,
+					     struct update_subgroup *subgrp,
+					     uint32_t addpath_tx_id)
+{
+	struct bgp_adj_out lookup;
+
+	if (!dest || !subgrp)
+		return NULL;
+
+	/* update-groups that do not support addpath will pass 0 for
+	 * addpath_tx_id. */
+	lookup.subgroup = subgrp;
+	lookup.addpath_tx_id = addpath_tx_id;
+
+	return RB_FIND(bgp_adj_out_rb, &dest->adj_out, &lookup);
+}
+
+static void adj_free(struct bgp_adj_out *adj)
+{
+	TAILQ_REMOVE(&(adj->subgroup->adjq), adj, subgrp_adj_train);
+	SUBGRP_DECR_STAT(adj->subgroup, adj_count);
+
+	RB_REMOVE(bgp_adj_out_rb, &adj->dest->adj_out, adj);
+	bgp_dest_unlock_node(adj->dest);
+
+	XFREE(MTYPE_BGP_ADJ_OUT, adj);
+}
+
+static void subgrp_withdraw_stale_addpath(struct updwalk_context *ctx,
+					  struct update_subgroup *subgrp)
+{
+	struct bgp_adj_out *adj, *adj_next;
+	uint32_t id;
+	struct bgp_path_info *pi;
+	afi_t afi = SUBGRP_AFI(subgrp);
+	safi_t safi = SUBGRP_SAFI(subgrp);
+	struct peer *peer = SUBGRP_PEER(subgrp);
+
+	/* Look through all of the paths we have advertised for this rn and send
+	 * a withdraw for the ones that are no longer present */
+	RB_FOREACH_SAFE (adj, bgp_adj_out_rb, &ctx->dest->adj_out, adj_next) {
+		if (adj->subgroup != subgrp)
+			continue;
+
+		for (pi = bgp_dest_get_bgp_path_info(ctx->dest); pi;
+		     pi = pi->next) {
+			id = bgp_addpath_id_for_peer(peer, afi, safi,
+						     &pi->tx_addpath);
+
+			if (id == adj->addpath_tx_id) {
+				break;
+			}
+		}
+
+		if (!pi) {
+			subgroup_process_announce_selected(
+				subgrp, NULL, ctx->dest, adj->addpath_tx_id);
+		}
+	}
+}
+
+static int group_announce_route_walkcb(struct update_group *updgrp, void *arg)
+{
+	struct updwalk_context *ctx = arg;
+	struct update_subgroup *subgrp;
+	struct bgp_path_info *pi;
+	afi_t afi;
+	safi_t safi;
+	struct peer *peer;
+	struct bgp_adj_out *adj, *adj_next;
+	bool addpath_capable;
+
+	afi = UPDGRP_AFI(updgrp);
+	safi = UPDGRP_SAFI(updgrp);
+	peer = UPDGRP_PEER(updgrp);
+	addpath_capable = bgp_addpath_encode_tx(peer, afi, safi);
+
+	if (BGP_DEBUG(update, UPDATE_OUT))
+		zlog_debug("%s: afi=%s, safi=%s, p=%pRN", __func__,
+			   afi2str(afi), safi2str(safi),
+			   bgp_dest_to_rnode(ctx->dest));
+
+	UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) {
+
+		/*
+		 * Skip the subgroups that have coalesce timer running. We will
+		 * walk the entire prefix table for those subgroups when the
+		 * coalesce timer fires.
+		 */
+		if (!subgrp->t_coalesce) {
+
+			/* An update-group that uses addpath */
+			if (addpath_capable) {
+				subgrp_withdraw_stale_addpath(ctx, subgrp);
+
+				for (pi = bgp_dest_get_bgp_path_info(ctx->dest);
+				     pi; pi = pi->next) {
+					/* Skip the bestpath for now */
+					if (pi == ctx->pi)
+						continue;
+
+					subgroup_process_announce_selected(
+						subgrp, pi, ctx->dest,
+						bgp_addpath_id_for_peer(
+							peer, afi, safi,
+							&pi->tx_addpath));
+				}
+
+				/* Process the bestpath last so the "show [ip]
+				 * bgp neighbor x.x.x.x advertised"
+				 * output shows the attributes from the bestpath
+				 */
+				if (ctx->pi)
+					subgroup_process_announce_selected(
+						subgrp, ctx->pi, ctx->dest,
+						bgp_addpath_id_for_peer(
+							peer, afi, safi,
+							&ctx->pi->tx_addpath));
+			}
+			/* An update-group that does not use addpath */
+			else {
+				if (ctx->pi) {
+					subgroup_process_announce_selected(
+						subgrp, ctx->pi, ctx->dest,
+						bgp_addpath_id_for_peer(
+							peer, afi, safi,
+							&ctx->pi->tx_addpath));
+				} else {
+					/* Find the addpath_tx_id of the path we
+					 * had advertised and
+					 * send a withdraw */
+					RB_FOREACH_SAFE (adj, bgp_adj_out_rb,
+							 &ctx->dest->adj_out,
+							 adj_next) {
+						if (adj->subgroup == subgrp) {
+							subgroup_process_announce_selected(
+								subgrp, NULL,
+								ctx->dest,
+								adj->addpath_tx_id);
+						}
+					}
+				}
+			}
+		}
+
+		/* Notify BGP Conditional advertisement */
+		bgp_notify_conditional_adv_scanner(subgrp);
+	}
+
+	return UPDWALK_CONTINUE;
+}
+
+static void subgrp_show_adjq_vty(struct update_subgroup *subgrp,
+				 struct vty *vty, uint8_t flags)
+{
+	struct bgp_table *table;
+	struct bgp_adj_out *adj;
+	unsigned long output_count;
+	struct bgp_dest *dest;
+	int header1 = 1;
+	struct bgp *bgp;
+	int header2 = 1;
+
+	bgp = SUBGRP_INST(subgrp);
+	if (!bgp)
+		return;
+
+	table = bgp->rib[SUBGRP_AFI(subgrp)][SUBGRP_SAFI(subgrp)];
+
+	output_count = 0;
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		RB_FOREACH (adj, bgp_adj_out_rb, &dest->adj_out) {
+			if (adj->subgroup != subgrp)
+				continue;
+
+			if (header1) {
+				vty_out(vty,
+					"BGP table version is %" PRIu64
+					", local router ID is %pI4\n",
+					table->version, &bgp->router_id);
+				vty_out(vty, BGP_SHOW_SCODE_HEADER);
+				vty_out(vty, BGP_SHOW_OCODE_HEADER);
+				header1 = 0;
+			}
+			if (header2) {
+				vty_out(vty, BGP_SHOW_HEADER);
+				header2 = 0;
+			}
+			if ((flags & UPDWALK_FLAGS_ADVQUEUE) && adj->adv &&
+			    adj->adv->baa) {
+				route_vty_out_tmp(
+					vty, dest, dest_p, adj->adv->baa->attr,
+					SUBGRP_SAFI(subgrp), 0, NULL, false);
+				output_count++;
+			}
+			if ((flags & UPDWALK_FLAGS_ADVERTISED) && adj->attr) {
+				route_vty_out_tmp(vty, dest, dest_p, adj->attr,
+						  SUBGRP_SAFI(subgrp), 0, NULL,
+						  false);
+				output_count++;
+			}
+		}
+	}
+	if (output_count != 0)
+		vty_out(vty, "\nTotal number of prefixes %ld\n", output_count);
+}
+
+static int updgrp_show_adj_walkcb(struct update_group *updgrp, void *arg)
+{
+	struct updwalk_context *ctx = arg;
+	struct update_subgroup *subgrp;
+	struct vty *vty;
+
+	vty = ctx->vty;
+	UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) {
+		if (ctx->subgrp_id && (ctx->subgrp_id != subgrp->id))
+			continue;
+		vty_out(vty, "update group %" PRIu64 ", subgroup %" PRIu64 "\n",
+			updgrp->id, subgrp->id);
+		subgrp_show_adjq_vty(subgrp, vty, ctx->flags);
+	}
+	return UPDWALK_CONTINUE;
+}
+
+static void updgrp_show_adj(struct bgp *bgp, afi_t afi, safi_t safi,
+			    struct vty *vty, uint64_t id, uint8_t flags)
+{
+	struct updwalk_context ctx;
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.vty = vty;
+	ctx.subgrp_id = id;
+	ctx.flags = flags;
+
+	update_group_af_walk(bgp, afi, safi, updgrp_show_adj_walkcb, &ctx);
+}
+
+static void subgroup_coalesce_timer(struct thread *thread)
+{
+	struct update_subgroup *subgrp;
+	struct bgp *bgp;
+
+	subgrp = THREAD_ARG(thread);
+	if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
+		zlog_debug("u%" PRIu64 ":s%" PRIu64" announcing routes upon coalesce timer expiry(%u ms)",
+			   (SUBGRP_UPDGRP(subgrp))->id, subgrp->id,
+			   subgrp->v_coalesce);
+	subgrp->t_coalesce = NULL;
+	subgrp->v_coalesce = 0;
+	bgp = SUBGRP_INST(subgrp);
+	subgroup_announce_route(subgrp);
+
+
+	/* While the announce_route() may kick off the route advertisement timer
+	 * for
+	 * the members of the subgroup, we'd like to send the initial updates
+	 * much
+	 * faster (i.e., without enforcing MRAI). Also, if there were no routes
+	 * to
+	 * announce, this is the method currently employed to trigger the EOR.
+	 */
+	if (!bgp_update_delay_active(SUBGRP_INST(subgrp)) &&
+	    !(BGP_SUPPRESS_FIB_ENABLED(bgp))) {
+		struct peer_af *paf;
+		struct peer *peer;
+
+		SUBGRP_FOREACH_PEER (subgrp, paf) {
+			peer = PAF_PEER(paf);
+			THREAD_OFF(peer->t_routeadv);
+			BGP_TIMER_ON(peer->t_routeadv, bgp_routeadv_timer, 0);
+		}
+	}
+}
+
+static int update_group_announce_walkcb(struct update_group *updgrp, void *arg)
+{
+	struct update_subgroup *subgrp;
+
+	UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) {
+		subgroup_announce_all(subgrp);
+	}
+
+	return UPDWALK_CONTINUE;
+}
+
+static int update_group_announce_rrc_walkcb(struct update_group *updgrp,
+					    void *arg)
+{
+	struct update_subgroup *subgrp;
+	afi_t afi;
+	safi_t safi;
+	struct peer *peer;
+
+	afi = UPDGRP_AFI(updgrp);
+	safi = UPDGRP_SAFI(updgrp);
+	peer = UPDGRP_PEER(updgrp);
+
+	/* Only announce if this is a group of route-reflector-clients */
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_REFLECTOR_CLIENT)) {
+		UPDGRP_FOREACH_SUBGRP (updgrp, subgrp) {
+			subgroup_announce_all(subgrp);
+		}
+	}
+
+	return UPDWALK_CONTINUE;
+}
+
+/********************
+ * PUBLIC FUNCTIONS
+ ********************/
+
+/**
+ * Allocate an adj-out object. Do proper initialization of its fields,
+ * primarily its association with the subgroup and the prefix.
+ */
+struct bgp_adj_out *bgp_adj_out_alloc(struct update_subgroup *subgrp,
+				      struct bgp_dest *dest,
+				      uint32_t addpath_tx_id)
+{
+	struct bgp_adj_out *adj;
+
+	adj = XCALLOC(MTYPE_BGP_ADJ_OUT, sizeof(struct bgp_adj_out));
+	adj->subgroup = subgrp;
+	adj->addpath_tx_id = addpath_tx_id;
+
+	RB_INSERT(bgp_adj_out_rb, &dest->adj_out, adj);
+	bgp_dest_lock_node(dest);
+	adj->dest = dest;
+
+	TAILQ_INSERT_TAIL(&(subgrp->adjq), adj, subgrp_adj_train);
+	SUBGRP_INCR_STAT(subgrp, adj_count);
+	return adj;
+}
+
+
+struct bgp_advertise *
+bgp_advertise_clean_subgroup(struct update_subgroup *subgrp,
+			     struct bgp_adj_out *adj)
+{
+	struct bgp_advertise *adv;
+	struct bgp_advertise_attr *baa;
+	struct bgp_advertise *next;
+	struct bgp_adv_fifo_head *fhead;
+
+	adv = adj->adv;
+	baa = adv->baa;
+	next = NULL;
+
+	if (baa) {
+		fhead = &subgrp->sync->update;
+
+		/* Unlink myself from advertise attribute FIFO.  */
+		bgp_advertise_delete(baa, adv);
+
+		/* Fetch next advertise candidate. */
+		next = baa->adv;
+
+		/* Unintern BGP advertise attribute.  */
+		bgp_advertise_attr_unintern(subgrp->hash, baa);
+	} else
+		fhead = &subgrp->sync->withdraw;
+
+
+	/* Unlink myself from advertisement FIFO.  */
+	bgp_adv_fifo_del(fhead, adv);
+
+	/* Free memory.  */
+	bgp_advertise_free(adj->adv);
+	adj->adv = NULL;
+
+	return next;
+}
+
+void bgp_adj_out_set_subgroup(struct bgp_dest *dest,
+			      struct update_subgroup *subgrp, struct attr *attr,
+			      struct bgp_path_info *path)
+{
+	struct bgp_adj_out *adj = NULL;
+	struct bgp_advertise *adv;
+	struct peer *peer;
+	afi_t afi;
+	safi_t safi;
+	struct peer *adv_peer;
+	struct peer_af *paf;
+	struct bgp *bgp;
+	uint32_t attr_hash = attrhash_key_make(attr);
+
+	peer = SUBGRP_PEER(subgrp);
+	afi = SUBGRP_AFI(subgrp);
+	safi = SUBGRP_SAFI(subgrp);
+	bgp = SUBGRP_INST(subgrp);
+
+	if (DISABLE_BGP_ANNOUNCE)
+		return;
+
+	/* Look for adjacency information. */
+	adj = adj_lookup(
+		dest, subgrp,
+		bgp_addpath_id_for_peer(peer, afi, safi, &path->tx_addpath));
+
+	if (adj) {
+		if (CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_TABLE_REPARSING))
+			subgrp->pscount++;
+	} else {
+		adj = bgp_adj_out_alloc(
+			subgrp, dest,
+			bgp_addpath_id_for_peer(peer, afi, safi,
+						&path->tx_addpath));
+		if (!adj)
+			return;
+
+		subgrp->pscount++;
+	}
+
+	/* Check if we are sending the same route. This is needed to
+	 * avoid duplicate UPDATES. For instance, filtering communities
+	 * at egress, neighbors will see duplicate UPDATES despite
+	 * the route wasn't changed actually.
+	 * Do not suppress BGP UPDATES for route-refresh.
+	 */
+	if (CHECK_FLAG(bgp->flags, BGP_FLAG_SUPPRESS_DUPLICATES)
+	    && !CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_FORCE_UPDATES)
+	    && adj->attr_hash == attr_hash) {
+		if (BGP_DEBUG(update, UPDATE_OUT)) {
+			char attr_str[BUFSIZ] = {0};
+
+			bgp_dump_attr(attr, attr_str, sizeof(attr_str));
+
+			zlog_debug("%s suppress UPDATE w/ attr: %s", peer->host,
+				   attr_str);
+		}
+
+		/*
+		 * If BGP is skipping sending this value to it's peers
+		 * the version number should be updated just like it
+		 * would if it sent the data.  Why?  Because update
+		 * groups will not be coalesced until such time that
+		 * the version numbers are the same.
+		 *
+		 * Imagine a scenario with say 2 peers and they come
+		 * up and are placed in the same update group.  Then
+		 * a new peer comes up a bit later.  Then a prefix is
+		 * flapped that we decide for the first 2 peers are
+		 * mapped to and we decide not to send the data to
+		 * it.  Then unless more network changes happen we
+		 * will never be able to coalesce the 3rd peer down
+		 */
+		subgrp->version = MAX(subgrp->version, dest->version);
+		return;
+	}
+
+	if (adj->adv)
+		bgp_advertise_clean_subgroup(subgrp, adj);
+	adj->adv = bgp_advertise_new();
+
+	adv = adj->adv;
+	adv->dest = dest;
+	assert(adv->pathi == NULL);
+	/* bgp_path_info adj_out reference */
+	adv->pathi = bgp_path_info_lock(path);
+
+	adv->baa = bgp_advertise_attr_intern(subgrp->hash, attr);
+	adv->adj = adj;
+	adj->attr_hash = attr_hash;
+
+	/* Add new advertisement to advertisement attribute list. */
+	bgp_advertise_add(adv->baa, adv);
+
+	/*
+	 * If the update adv list is empty, trigger the member peers'
+	 * mrai timers so the socket writes can happen.
+	 */
+	if (!bgp_adv_fifo_count(&subgrp->sync->update)) {
+		SUBGRP_FOREACH_PEER (subgrp, paf) {
+			/* If there are no routes in the withdraw list, set
+			 * the flag PEER_STATUS_ADV_DELAY which will allow
+			 * more routes to be sent in the update message
+			 */
+			if (BGP_SUPPRESS_FIB_ENABLED(bgp)) {
+				adv_peer = PAF_PEER(paf);
+				if (!bgp_adv_fifo_count(
+						&subgrp->sync->withdraw))
+					SET_FLAG(adv_peer->thread_flags,
+						 PEER_THREAD_SUBGRP_ADV_DELAY);
+				else
+					UNSET_FLAG(adv_peer->thread_flags,
+						PEER_THREAD_SUBGRP_ADV_DELAY);
+			}
+			bgp_adjust_routeadv(PAF_PEER(paf));
+		}
+	}
+
+	bgp_adv_fifo_add_tail(&subgrp->sync->update, adv);
+
+	subgrp->version = MAX(subgrp->version, dest->version);
+}
+
+/* The only time 'withdraw' will be false is if we are sending
+ * the "neighbor x.x.x.x default-originate" default and need to clear
+ * bgp_adj_out for the 0.0.0.0/0 route in the BGP table.
+ */
+void bgp_adj_out_unset_subgroup(struct bgp_dest *dest,
+				struct update_subgroup *subgrp, char withdraw,
+				uint32_t addpath_tx_id)
+{
+	struct bgp_adj_out *adj;
+	struct bgp_advertise *adv;
+	bool trigger_write;
+
+	if (DISABLE_BGP_ANNOUNCE)
+		return;
+
+	/* Lookup existing adjacency */
+	adj = adj_lookup(dest, subgrp, addpath_tx_id);
+	if (adj != NULL) {
+		/* Clean up previous advertisement.  */
+		if (adj->adv)
+			bgp_advertise_clean_subgroup(subgrp, adj);
+
+		/* If default originate is enabled and the route is default
+		 * route, do not send withdraw. This will prevent deletion of
+		 * the default route at the peer.
+		 */
+		if (CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE)
+		    && is_default_prefix(bgp_dest_get_prefix(dest)))
+			return;
+
+		if (adj->attr && withdraw) {
+			/* We need advertisement structure.  */
+			adj->adv = bgp_advertise_new();
+			adv = adj->adv;
+			adv->dest = dest;
+			adv->adj = adj;
+
+			/* Note if we need to trigger a packet write */
+			trigger_write =
+				!bgp_adv_fifo_count(&subgrp->sync->withdraw);
+
+			/* Add to synchronization entry for withdraw
+			 * announcement.  */
+			bgp_adv_fifo_add_tail(&subgrp->sync->withdraw, adv);
+
+			if (trigger_write)
+				subgroup_trigger_write(subgrp);
+		} else {
+			/* Free allocated information.  */
+			adj_free(adj);
+		}
+		if (!CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_TABLE_REPARSING))
+			subgrp->pscount--;
+	}
+
+	subgrp->version = MAX(subgrp->version, dest->version);
+}
+
+void bgp_adj_out_remove_subgroup(struct bgp_dest *dest, struct bgp_adj_out *adj,
+				 struct update_subgroup *subgrp)
+{
+	if (adj->attr)
+		bgp_attr_unintern(&adj->attr);
+
+	if (adj->adv)
+		bgp_advertise_clean_subgroup(subgrp, adj);
+
+	adj_free(adj);
+}
+
+/*
+ * Go through all the routes and clean up the adj/adv structures corresponding
+ * to the subgroup.
+ */
+void subgroup_clear_table(struct update_subgroup *subgrp)
+{
+	struct bgp_adj_out *aout, *taout;
+
+	SUBGRP_FOREACH_ADJ_SAFE (subgrp, aout, taout)
+		bgp_adj_out_remove_subgroup(aout->dest, aout, subgrp);
+}
+
+/*
+ * subgroup_announce_table
+ */
+void subgroup_announce_table(struct update_subgroup *subgrp,
+			     struct bgp_table *table)
+{
+	struct bgp_dest *dest;
+	struct bgp_path_info *ri;
+	struct attr attr;
+	struct peer *peer;
+	afi_t afi;
+	safi_t safi;
+	bool addpath_capable;
+	struct bgp *bgp;
+	bool advertise;
+
+	peer = SUBGRP_PEER(subgrp);
+	afi = SUBGRP_AFI(subgrp);
+	safi = SUBGRP_SAFI(subgrp);
+	bgp = SUBGRP_INST(subgrp);
+	addpath_capable = bgp_addpath_encode_tx(peer, afi, safi);
+
+	if (safi == SAFI_LABELED_UNICAST)
+		safi = SAFI_UNICAST;
+
+	if (!table)
+		table = peer->bgp->rib[afi][safi];
+
+	if (safi != SAFI_MPLS_VPN && safi != SAFI_ENCAP && safi != SAFI_EVPN
+	    && CHECK_FLAG(peer->af_flags[afi][safi],
+			  PEER_FLAG_DEFAULT_ORIGINATE))
+		subgroup_default_originate(subgrp, 0);
+
+	subgrp->pscount = 0;
+	SET_FLAG(subgrp->sflags, SUBGRP_STATUS_TABLE_REPARSING);
+
+	for (dest = bgp_table_top(table); dest; dest = bgp_route_next(dest)) {
+		const struct prefix *dest_p = bgp_dest_get_prefix(dest);
+
+		/* Check if the route can be advertised */
+		advertise = bgp_check_advertise(bgp, dest);
+
+		for (ri = bgp_dest_get_bgp_path_info(dest); ri; ri = ri->next) {
+
+			if (!bgp_check_selected(ri, peer, addpath_capable, afi,
+						safi))
+				continue;
+
+			if (subgroup_announce_check(dest, ri, subgrp, dest_p,
+						    &attr, NULL)) {
+				/* Check if route can be advertised */
+				if (advertise) {
+					if (!bgp_check_withdrawal(bgp, dest))
+						bgp_adj_out_set_subgroup(
+							dest, subgrp, &attr,
+							ri);
+					else
+						bgp_adj_out_unset_subgroup(
+							dest, subgrp, 1,
+							bgp_addpath_id_for_peer(
+								peer, afi, safi,
+								&ri->tx_addpath));
+				}
+			} else {
+				/* If default originate is enabled for
+				 * the peer, do not send explicit
+				 * withdraw. This will prevent deletion
+				 * of default route advertised through
+				 * default originate
+				 */
+				if (CHECK_FLAG(peer->af_flags[afi][safi],
+					       PEER_FLAG_DEFAULT_ORIGINATE) &&
+				    is_default_prefix(
+					    bgp_dest_get_prefix(dest)))
+					break;
+
+				bgp_adj_out_unset_subgroup(
+					dest, subgrp, 1,
+					bgp_addpath_id_for_peer(
+						peer, afi, safi,
+						&ri->tx_addpath));
+			}
+		}
+	}
+	UNSET_FLAG(subgrp->sflags, SUBGRP_STATUS_TABLE_REPARSING);
+
+	/*
+	 * We walked through the whole table -- make sure our version number
+	 * is consistent with the one on the table. This should allow
+	 * subgroups to merge sooner if a peer comes up when the route node
+	 * with the largest version is no longer in the table. This also
+	 * covers the pathological case where all routes in the table have
+	 * now been deleted.
+	 */
+	subgrp->version = MAX(subgrp->version, table->version);
+
+	/*
+	 * Start a task to merge the subgroup if necessary.
+	 */
+	update_subgroup_trigger_merge_check(subgrp, 0);
+}
+
+/*
+ * subgroup_announce_route
+ *
+ * Refresh all routes out to a subgroup.
+ */
+void subgroup_announce_route(struct update_subgroup *subgrp)
+{
+	struct bgp_dest *dest;
+	struct bgp_table *table;
+	struct peer *onlypeer;
+
+	if (update_subgroup_needs_refresh(subgrp)) {
+		update_subgroup_set_needs_refresh(subgrp, 0);
+	}
+
+	/*
+	 * First update is deferred until ORF or ROUTE-REFRESH is received
+	 */
+	onlypeer = ((SUBGRP_PCOUNT(subgrp) == 1) ? (SUBGRP_PFIRST(subgrp))->peer
+						 : NULL);
+	if (onlypeer && CHECK_FLAG(onlypeer->af_sflags[SUBGRP_AFI(subgrp)]
+						      [SUBGRP_SAFI(subgrp)],
+				   PEER_STATUS_ORF_WAIT_REFRESH))
+		return;
+
+	if (SUBGRP_SAFI(subgrp) != SAFI_MPLS_VPN
+	    && SUBGRP_SAFI(subgrp) != SAFI_ENCAP
+	    && SUBGRP_SAFI(subgrp) != SAFI_EVPN)
+		subgroup_announce_table(subgrp, NULL);
+	else
+		for (dest = bgp_table_top(update_subgroup_rib(subgrp)); dest;
+		     dest = bgp_route_next(dest)) {
+			table = bgp_dest_get_bgp_table_info(dest);
+			if (!table)
+				continue;
+			subgroup_announce_table(subgrp, table);
+		}
+}
+
+void subgroup_default_originate(struct update_subgroup *subgrp, int withdraw)
+{
+	struct bgp *bgp;
+	struct attr attr;
+	struct attr *new_attr = &attr;
+	struct prefix p;
+	struct peer *from;
+	struct bgp_dest *dest;
+	struct bgp_path_info *pi;
+	struct peer *peer;
+	struct bgp_adj_out *adj;
+	route_map_result_t ret = RMAP_DENYMATCH;
+	route_map_result_t new_ret = RMAP_DENYMATCH;
+	afi_t afi;
+	safi_t safi;
+	int pref = 65536;
+	int new_pref = 0;
+
+	if (!subgrp)
+		return;
+
+	peer = SUBGRP_PEER(subgrp);
+	afi = SUBGRP_AFI(subgrp);
+	safi = SUBGRP_SAFI(subgrp);
+
+	if (!(afi == AFI_IP || afi == AFI_IP6))
+		return;
+
+	bgp = peer->bgp;
+	from = bgp->peer_self;
+
+	bgp_attr_default_set(&attr, bgp, BGP_ORIGIN_IGP);
+
+	/* make coverity happy */
+	assert(attr.aspath);
+
+	attr.med = 0;
+	attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC);
+
+	if ((afi == AFI_IP6) || peer_cap_enhe(peer, afi, safi)) {
+		/* IPv6 global nexthop must be included. */
+		attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL;
+
+		/* If the peer is on shared nextwork and we have link-local
+		   nexthop set it. */
+		if (peer->shared_network
+		    && !IN6_IS_ADDR_UNSPECIFIED(&peer->nexthop.v6_local))
+			attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL;
+	}
+
+	if (peer->default_rmap[afi][safi].name) {
+		struct bgp_path_info tmp_pi = {0};
+
+		tmp_pi.peer = bgp->peer_self;
+
+		SET_FLAG(bgp->peer_self->rmap_type, PEER_RMAP_TYPE_DEFAULT);
+
+		/* Iterate over the RIB to see if we can announce
+		 * the default route. We announce the default
+		 * route only if route-map has a match.
+		 */
+		for (dest = bgp_table_top(bgp->rib[afi][safi]); dest;
+		     dest = bgp_route_next(dest)) {
+			if (!bgp_dest_has_bgp_path_info_data(dest))
+				continue;
+
+			for (pi = bgp_dest_get_bgp_path_info(dest); pi;
+			     pi = pi->next) {
+				struct attr tmp_attr = attr;
+
+				tmp_pi.attr = &tmp_attr;
+
+				new_ret = route_map_apply_ext(
+					peer->default_rmap[afi][safi].map,
+					bgp_dest_get_prefix(dest), pi, &tmp_pi,
+					&new_pref);
+
+				if (new_ret == RMAP_PERMITMATCH) {
+					if (new_pref < pref) {
+						pref = new_pref;
+						bgp_attr_flush(new_attr);
+						new_attr = bgp_attr_intern(
+							tmp_pi.attr);
+						bgp_attr_flush(tmp_pi.attr);
+					}
+					subgroup_announce_reset_nhop(
+						(peer_cap_enhe(peer, afi, safi)
+							 ? AF_INET6
+							 : AF_INET),
+						new_attr);
+					ret = new_ret;
+				} else
+					bgp_attr_flush(&tmp_attr);
+			}
+		}
+		bgp->peer_self->rmap_type = 0;
+
+		if (ret == RMAP_DENYMATCH) {
+			/*
+			 * If its a implicit withdraw due to routemap
+			 * deny operation need to set the flag back.
+			 * This is a convertion of update flow to
+			 * withdraw flow.
+			 */
+			if (!withdraw &&
+			    (!CHECK_FLAG(subgrp->sflags,
+					 SUBGRP_STATUS_DEFAULT_ORIGINATE)))
+				SET_FLAG(subgrp->sflags,
+					 SUBGRP_STATUS_DEFAULT_ORIGINATE);
+			withdraw = 1;
+		}
+	}
+
+	/* Check if the default route is in local BGP RIB which is
+	 * installed through redistribute or network command
+	 */
+	memset(&p, 0, sizeof(p));
+	p.family = afi2family(afi);
+	p.prefixlen = 0;
+	dest = bgp_afi_node_lookup(bgp->rib[afi][safi], afi, safi, &p, NULL);
+
+	if (withdraw) {
+		/* Withdraw the default route advertised using default
+		 * originate
+		 */
+		if (CHECK_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE))
+			subgroup_default_withdraw_packet(subgrp);
+		UNSET_FLAG(subgrp->sflags, SUBGRP_STATUS_DEFAULT_ORIGINATE);
+
+		/* If default route is present in the local RIB, advertise the
+		 * route
+		 */
+		if (dest) {
+			for (pi = bgp_dest_get_bgp_path_info(dest); pi;
+			     pi = pi->next) {
+				if (CHECK_FLAG(pi->flags, BGP_PATH_SELECTED))
+					if (subgroup_announce_check(
+						    dest, pi, subgrp,
+						    bgp_dest_get_prefix(dest),
+						    &attr, NULL)) {
+						struct attr *default_attr =
+							bgp_attr_intern(&attr);
+
+						bgp_adj_out_set_subgroup(
+							dest, subgrp,
+							default_attr, pi);
+					}
+			}
+			bgp_dest_unlock_node(dest);
+		}
+	} else {
+		if (!CHECK_FLAG(subgrp->sflags,
+				SUBGRP_STATUS_DEFAULT_ORIGINATE)) {
+
+			/* The 'neighbor x.x.x.x default-originate' default will
+			 * act as an
+			 * implicit withdraw for any previous UPDATEs sent for
+			 * 0.0.0.0/0 so
+			 * clear adj_out for the 0.0.0.0/0 prefix in the BGP
+			 * table.
+			 */
+			if (dest) {
+				/* Remove the adjacency for the previously
+				 * advertised default route
+				 */
+				adj = adj_lookup(
+				       dest, subgrp,
+				       BGP_ADDPATH_TX_ID_FOR_DEFAULT_ORIGINATE);
+				if (adj != NULL) {
+					/* Clean up previous advertisement.  */
+					if (adj->adv)
+						bgp_advertise_clean_subgroup(
+							subgrp, adj);
+
+					/* Free allocated information.  */
+					adj_free(adj);
+				}
+				bgp_dest_unlock_node(dest);
+			}
+
+			/* Advertise the default route */
+			if (bgp_in_graceful_shutdown(bgp))
+				bgp_attr_add_gshut_community(new_attr);
+
+			SET_FLAG(subgrp->sflags,
+				 SUBGRP_STATUS_DEFAULT_ORIGINATE);
+			subgroup_default_update_packet(subgrp, new_attr, from);
+		}
+	}
+
+	aspath_unintern(&attr.aspath);
+}
+
+/*
+ * Announce the BGP table to a subgroup.
+ *
+ * At startup, we try to optimize route announcement by coalescing the
+ * peer-up events. This is done only the first time - from then on,
+ * subgrp->v_coalesce will be set to zero and the normal logic
+ * prevails.
+ */
+void subgroup_announce_all(struct update_subgroup *subgrp)
+{
+	if (!subgrp)
+		return;
+
+	/*
+	 * If coalesce timer value is not set, announce routes immediately.
+	 */
+	if (!subgrp->v_coalesce) {
+		if (bgp_debug_update(NULL, NULL, subgrp->update_group, 0))
+			zlog_debug("u%" PRIu64 ":s%" PRIu64" announcing all routes",
+				   subgrp->update_group->id, subgrp->id);
+		subgroup_announce_route(subgrp);
+		return;
+	}
+
+	/*
+	 * We should wait for the coalesce timer. Arm the timer if not done.
+	 */
+	if (!subgrp->t_coalesce) {
+		thread_add_timer_msec(bm->master, subgroup_coalesce_timer,
+				      subgrp, subgrp->v_coalesce,
+				      &subgrp->t_coalesce);
+	}
+}
+
+/*
+ * Go through all update subgroups and set up the adv queue for the
+ * input route.
+ */
+void group_announce_route(struct bgp *bgp, afi_t afi, safi_t safi,
+			  struct bgp_dest *dest, struct bgp_path_info *pi)
+{
+	struct updwalk_context ctx;
+	ctx.pi = pi;
+	ctx.dest = dest;
+
+	/* If suppress fib is enabled, the route will be advertised when
+	 * FIB status is received
+	 */
+	if (!bgp_check_advertise(bgp, dest))
+		return;
+
+	update_group_af_walk(bgp, afi, safi, group_announce_route_walkcb, &ctx);
+}
+
+void update_group_show_adj_queue(struct bgp *bgp, afi_t afi, safi_t safi,
+				 struct vty *vty, uint64_t id)
+{
+	updgrp_show_adj(bgp, afi, safi, vty, id, UPDWALK_FLAGS_ADVQUEUE);
+}
+
+void update_group_show_advertised(struct bgp *bgp, afi_t afi, safi_t safi,
+				  struct vty *vty, uint64_t id)
+{
+	updgrp_show_adj(bgp, afi, safi, vty, id, UPDWALK_FLAGS_ADVERTISED);
+}
+
+void update_group_announce(struct bgp *bgp)
+{
+	update_group_walk(bgp, update_group_announce_walkcb, NULL);
+}
+
+void update_group_announce_rrclients(struct bgp *bgp)
+{
+	update_group_walk(bgp, update_group_announce_rrc_walkcb, NULL);
+}