1 files changed, 890 insertions, 1 deletions

diff --git a/ospfd/ospf_asbr.c b/ospfd/ospf_asbr.c
index fd9b166433..94fa1b5b44 100644
--- a/ospfd/ospf_asbr.c
+++ b/ospfd/ospf_asbr.c
@@ -42,7 +42,7 @@
 #include "ospfd/ospf_route.h"
 #include "ospfd/ospf_zebra.h"
 #include "ospfd/ospf_dump.h"
-
+#include "ospfd/ospf_errors.h"
 
 /* Remove external route. */
 void ospf_external_route_remove(struct ospf *ospf, struct prefix_ipv4 *p)
@@ -80,6 +80,7 @@ struct external_info *ospf_external_info_new(uint8_t type,
 	new = XCALLOC(MTYPE_OSPF_EXTERNAL_INFO, sizeof(struct external_info));
 	new->type = type;
 	new->instance = instance;
+	new->to_be_processed = 0;
 
 	ospf_reset_route_map_set_values(&new->route_map_set);
 	return new;
@@ -147,6 +148,7 @@ ospf_external_info_add(struct ospf *ospf, uint8_t type, unsigned short instance,
 	new->nexthop = nexthop;
 	new->tag = tag;
 	new->orig_tag = tag;
+	new->aggr_route = NULL;
 
 	/* we don't unlock rn from the get() because we're attaching the info */
 	if (rn)
@@ -327,3 +329,890 @@ void ospf_redistribute_withdraw(struct ospf *ospf, uint8_t type,
 					rn->info = NULL;
 				}
 }
+
+/* External Route Aggregator Handlers */
+bool is_valid_summary_addr(struct prefix_ipv4 *p)
+{
+	/* Default prefix validation*/
+	if (p->prefix.s_addr == INADDR_ANY)
+		return false;
+
+	/*Host route shouldn't be configured as summary addres*/
+	if (p->prefixlen == IPV4_MAX_PREFIXLEN)
+		return false;
+
+	return true;
+}
+void ospf_asbr_external_aggregator_init(struct ospf *instance)
+{
+	instance->rt_aggr_tbl = route_table_init();
+
+	instance->t_external_aggr = NULL;
+
+	instance->aggr_action = 0;
+
+	instance->aggr_delay_interval = OSPF_EXTL_AGGR_DEFAULT_DELAY;
+}
+
+static unsigned int ospf_external_rt_hash_key(const void *data)
+{
+	const struct external_info *ei = data;
+	unsigned int key = 0;
+
+	key = prefix_hash_key(&ei->p);
+	return key;
+}
+
+static bool ospf_external_rt_hash_cmp(const void *d1, const void *d2)
+{
+	const struct external_info *ei1 = d1;
+	const struct external_info *ei2 = d2;
+
+	return prefix_same((struct prefix *)&ei1->p, (struct prefix *)&ei2->p);
+}
+
+static struct ospf_external_aggr_rt *
+ospf_external_aggregator_new(struct prefix_ipv4 *p)
+{
+	struct ospf_external_aggr_rt *aggr;
+
+	aggr = (struct ospf_external_aggr_rt *)XCALLOC(
+		MTYPE_OSPF_EXTERNAL_RT_AGGR,
+		sizeof(struct ospf_external_aggr_rt));
+
+	if (!aggr)
+		return NULL;
+
+	aggr->p.family = p->family;
+	aggr->p.prefix = p->prefix;
+	aggr->p.prefixlen = p->prefixlen;
+	aggr->match_extnl_hash = hash_create(ospf_external_rt_hash_key,
+					     ospf_external_rt_hash_cmp,
+					     "Ospf external route hash");
+	return aggr;
+}
+
+static void ospf_aggr_handle_external_info(void *data)
+{
+	struct external_info *ei = (struct external_info *)data;
+	struct ospf_external_aggr_rt *aggr = NULL;
+	struct ospf *ospf = NULL;
+	struct ospf_lsa *lsa = NULL;
+
+	ei->aggr_route = NULL;
+
+	ei->to_be_processed = true;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Handle extrenal route(%pI4/%d)", __func__,
+			   &ei->p.prefix, ei->p.prefixlen);
+
+	ospf = ospf_lookup_instance(ei->instance);
+
+	assert(ospf);
+
+	if (!ospf_redistribute_check(ospf, ei, NULL))
+		return;
+
+	aggr = ospf_external_aggr_match(ospf, &ei->p);
+	if (aggr) {
+		(void)ospf_originate_summary_lsa(ospf, aggr, ei);
+		return;
+	}
+
+	lsa = ospf_external_info_find_lsa(ospf, &ei->p);
+	if (lsa)
+		ospf_external_lsa_refresh(ospf, lsa, ei, LSA_REFRESH_FORCE, 1);
+	else
+		(void)ospf_external_lsa_originate(ospf, ei);
+}
+
+static void ospf_aggr_unlink_external_info(void *data)
+{
+	struct external_info *ei = (struct external_info *)data;
+
+	ei->aggr_route = NULL;
+
+	ei->to_be_processed = true;
+}
+
+void ospf_external_aggregator_free(struct ospf_external_aggr_rt *aggr)
+{
+	if (OSPF_EXTERNAL_RT_COUNT(aggr))
+		hash_clean(aggr->match_extnl_hash,
+			   (void *)ospf_aggr_unlink_external_info);
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Release the aggregator Address(%pI4/%d)",
+			   __func__, &aggr->p.prefix, aggr->p.prefixlen);
+	hash_free(aggr->match_extnl_hash);
+	aggr->match_extnl_hash = NULL;
+
+	XFREE(MTYPE_OSPF_EXTERNAL_RT_AGGR, aggr);
+}
+
+static void ospf_external_aggr_add(struct ospf *ospf,
+				   struct ospf_external_aggr_rt *aggr)
+{
+	struct route_node *rn;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Adding Aggregate route to Aggr table (%pI4/%d)",
+			   __func__, &aggr->p.prefix, aggr->p.prefixlen);
+	rn = route_node_get(ospf->rt_aggr_tbl, (struct prefix *)&aggr->p);
+	if (rn->info)
+		route_unlock_node(rn);
+	else
+		rn->info = aggr;
+}
+
+static void ospf_external_aggr_delete(struct ospf *ospf, struct route_node *rn)
+{
+	struct ospf_external_aggr_rt *aggr = rn->info;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Deleting Aggregate route (%pI4/%d)", __func__,
+			   &aggr->p.prefix, aggr->p.prefixlen);
+
+	/* Sent a Max age LSA if it is already originated. */
+	if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug("%s: Flushing Aggregate route (%pI4/%d)",
+				   __func__, &aggr->p.prefix,
+				   aggr->p.prefixlen);
+		ospf_external_lsa_flush(ospf, 0, &aggr->p, 0);
+	}
+
+	rn->info = NULL;
+	route_unlock_node(rn);
+	route_unlock_node(rn);
+}
+
+struct ospf_external_aggr_rt *
+ospf_extrenal_aggregator_lookup(struct ospf *ospf, struct prefix_ipv4 *p)
+{
+	struct route_node *rn;
+	struct ospf_external_aggr_rt *summary_rt = NULL;
+
+	rn = route_node_lookup(ospf->rt_aggr_tbl, (struct prefix *)p);
+	if (rn) {
+		summary_rt = rn->info;
+		route_unlock_node(rn);
+		return summary_rt;
+	}
+	return NULL;
+}
+
+struct ospf_external_aggr_rt *ospf_external_aggr_match(struct ospf *ospf,
+						       struct prefix_ipv4 *p)
+{
+	struct route_node *node;
+	struct ospf_external_aggr_rt *summary_rt = NULL;
+
+	node = route_node_match(ospf->rt_aggr_tbl, (struct prefix *)p);
+	if (node) {
+
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			if (node->info) {
+				struct ospf_external_aggr_rt *ag = node->info;
+
+				zlog_debug(
+					"%s: Matching aggregator found.prefix:%pI4/%d Aggregator %pI4/%d\n",
+					__func__, &p->prefix, p->prefixlen,
+					&ag->p.prefix, ag->p.prefixlen);
+			}
+
+		summary_rt = node->info;
+		route_unlock_node(node);
+		return summary_rt;
+	}
+	return NULL;
+}
+
+void ospf_unlink_ei_from_aggr(struct ospf *ospf,
+			      struct ospf_external_aggr_rt *aggr,
+			      struct external_info *ei)
+{
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug(
+			"%s: Unlinking extrenal route(%pI4/%d) from aggregator(%pI4/%d), external route count:%ld",
+			__func__, &ei->p.prefix, ei->p.prefixlen,
+			&aggr->p.prefix, aggr->p.prefixlen,
+			OSPF_EXTERNAL_RT_COUNT(aggr));
+	hash_release(aggr->match_extnl_hash, ei);
+	ei->aggr_route = NULL;
+
+	/* Flush the aggreagte route if matching
+	 * external route count becomes zero.
+	 */
+	if (!OSPF_EXTERNAL_RT_COUNT(aggr)
+	    && CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug("%s: Flushing the aggreagte route (%pI4/%d)",
+				   __func__, &aggr->p.prefix,
+				   aggr->p.prefixlen);
+
+		/* Flush the aggregate LSA */
+		ospf_external_lsa_flush(ospf, 0, &aggr->p, 0);
+
+		/* Unset the Origination flag */
+		UNSET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+	}
+}
+
+static void ospf_link_ei_to_aggr(struct ospf_external_aggr_rt *aggr,
+				 struct external_info *ei)
+{
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug(
+			"%s: Linking extrenal route(%pI4/%d) to aggregator(%pI4/%d)",
+			__func__, &ei->p.prefix, ei->p.prefixlen,
+			&aggr->p.prefix, aggr->p.prefixlen);
+	hash_get(aggr->match_extnl_hash, ei, hash_alloc_intern);
+	ei->aggr_route = aggr;
+}
+
+struct ospf_lsa *ospf_originate_summary_lsa(struct ospf *ospf,
+					    struct ospf_external_aggr_rt *aggr,
+					    struct external_info *ei)
+{
+	struct ospf_lsa *lsa;
+	struct external_info ei_aggr;
+	struct as_external_lsa *asel;
+	struct ospf_external_aggr_rt *old_aggr;
+	route_tag_t tag = 0;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Prepare to originate Summary route(%pI4/%d)",
+			   __func__, &aggr->p.prefix, aggr->p.prefixlen);
+
+	/* This case to handle when the overlapping aggregator address
+	 * is availbe.Best match will be considered.So need to delink
+	 * from old aggregator and link to the new aggr.
+	 */
+	if (ei->aggr_route) {
+		if (ei->aggr_route != aggr) {
+			old_aggr = ei->aggr_route;
+			ospf_unlink_ei_from_aggr(ospf, old_aggr, ei);
+		}
+	}
+
+	/* Add the external route to hash table */
+	ospf_link_ei_to_aggr(aggr, ei);
+
+	lsa = ospf_external_info_find_lsa(ospf, &aggr->p);
+	/* Dont originate external LSA,
+	 * If it is configured not to advertise.
+	 */
+	if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE)) {
+		/* If it is already originated as external LSA,
+		 * But, it is configured not to advertise then
+		 * flush the originated external lsa.
+		 */
+		if (lsa)
+			ospf_external_lsa_flush(ospf, 0, &aggr->p, 0);
+		UNSET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug(
+				"%s: Don't originate the summary address,It is configured to not-advertise.",
+				__func__);
+		return NULL;
+	}
+
+	/* Prepare the extrenal_info for aggregator */
+	memset(&ei_aggr, 0, sizeof(struct external_info));
+	ei_aggr.p = aggr->p;
+	ei_aggr.tag = aggr->tag;
+	ei_aggr.type = 0;
+	ei_aggr.instance = ospf->instance;
+	ei_aggr.route_map_set.metric = -1;
+	ei_aggr.route_map_set.metric_type = -1;
+
+	/* Summary route already originated,
+	 * So, Do nothing.
+	 */
+	if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+		if (!lsa) {
+			flog_warn(EC_OSPF_LSA_MISSING,
+				  "%s: Could not refresh/originate %pI4/%d",
+				  __func__, &aggr->p.prefix, aggr->p.prefixlen);
+			return NULL;
+		}
+
+		asel = (struct as_external_lsa *)lsa->data;
+		tag = (unsigned long)ntohl(asel->e[0].route_tag);
+
+		/* If tag modified , then re-originate the route
+		 * with modified tag details.
+		 */
+		if (tag != ei_aggr.tag) {
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s: Route tag changed(old:%d new:%d,So refresh the summary route.(%pI4/%d)",
+					__func__, tag, ei_aggr.tag,
+					&aggr->p.prefix, aggr->p.prefixlen);
+
+			ospf_external_lsa_refresh(ospf, lsa, &ei_aggr,
+						  LSA_REFRESH_FORCE, 1);
+		}
+		return lsa;
+	}
+
+	if (lsa && IS_LSA_MAXAGE(lsa)) {
+		/* This is special case.
+		 * If a summary route need to be originated but where
+		 * summary route already exist in lsdb with maxage, then
+		 * it need to be refreshed.
+		 */
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug(
+				"%s: LSA is in MAX-AGE so refreshing LSA(%pI4/%d)",
+				__PRETTY_FUNCTION__, &aggr->p.prefix,
+				aggr->p.prefixlen);
+
+		ospf_external_lsa_refresh(ospf, lsa, &ei_aggr,
+					  LSA_REFRESH_FORCE, 1);
+		SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+		return lsa;
+	}
+
+	/* If the external route prefix same as aggregate route
+	 * and if external route is already originated as TYPE-5
+	 * then it need to be refreshed and originate bit should
+	 * be set.
+	 */
+	if (lsa && prefix_same((struct prefix *)&ei_aggr.p,
+			       (struct prefix *)&ei->p)) {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug(
+				"%s: External route prefix is same as aggr so refreshing LSA(%pI4/%d)",
+				__PRETTY_FUNCTION__, &aggr->p.prefix,
+				aggr->p.prefixlen);
+		ospf_external_lsa_refresh(ospf, lsa, &ei_aggr,
+					  LSA_REFRESH_FORCE, 1);
+		SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+		return lsa;
+	}
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Originate Summary route(%pI4/%d)", __func__,
+			   &aggr->p.prefix, aggr->p.prefixlen);
+
+	/* Originate summary LSA */
+	lsa = ospf_external_lsa_originate(ospf, &ei_aggr);
+	if (lsa) {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug("%s: Set the origination bit for aggregator",
+				   __func__);
+		SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+	}
+
+	return lsa;
+}
+void ospf_unset_all_aggr_flag(struct ospf *ospf)
+{
+	struct route_node *rn = NULL;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("Unset the origination bit for all aggregator");
+
+	for (rn = route_top(ospf->rt_aggr_tbl); rn; rn = route_next(rn)) {
+		if (!rn->info)
+			continue;
+
+		struct ospf_external_aggr_rt *aggr = rn->info;
+
+		UNSET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+	}
+}
+
+static void ospf_delete_all_marked_aggregators(struct ospf *ospf)
+{
+	struct route_node *rn = NULL;
+
+	/* Loop through all the aggregators, Delete all aggregators
+	 * which are marked as DELETE. Set action to NONE for remaining
+	 * aggregators
+	 */
+	for (rn = route_top(ospf->rt_aggr_tbl); rn; rn = route_next(rn)) {
+		if (!rn->info)
+			continue;
+
+		struct ospf_external_aggr_rt *aggr = rn->info;
+
+		if (aggr->action != OSPF_ROUTE_AGGR_DEL) {
+			aggr->action = OSPF_ROUTE_AGGR_NONE;
+			continue;
+		}
+		ospf_external_aggr_delete(ospf, rn);
+		ospf_external_aggregator_free(aggr);
+	}
+}
+
+static void ospf_handle_aggregated_exnl_rt(struct ospf *ospf,
+					   struct ospf_external_aggr_rt *aggr,
+					   struct external_info *ei)
+{
+	struct ospf_lsa *lsa;
+	struct as_external_lsa *al;
+	struct in_addr mask;
+
+	/* Handling the case where the external route prefix
+	 * and aggregate prefix is same
+	 * If same dont flush the originated external LSA.
+	 */
+	if (prefix_same((struct prefix *)&aggr->p, (struct prefix *)&ei->p)) {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug(
+				"%s: External Route prefix same as Aggregator(%pI4/%d), so dont flush.",
+				__func__, &ei->p.prefix, ei->p.prefixlen);
+		return;
+	}
+
+	lsa = ospf_external_info_find_lsa(ospf, &ei->p);
+	if (lsa) {
+		al = (struct as_external_lsa *)lsa->data;
+		masklen2ip(ei->p.prefixlen, &mask);
+
+		if (mask.s_addr != al->mask.s_addr)
+			return;
+
+		ospf_external_lsa_flush(ospf, ei->type, &ei->p, 0);
+	}
+}
+
+static void ospf_handle_exnl_rt_after_aggr_del(struct ospf *ospf,
+					       struct external_info *ei)
+{
+	struct ospf_lsa *lsa;
+
+	/* Process only marked external routes.
+	 * These routes were part of a deleted
+	 * aggregator.So, originate now.
+	 */
+	if (!ei->to_be_processed)
+		return;
+
+	ei->to_be_processed = false;
+
+	lsa = ospf_external_info_find_lsa(ospf, &ei->p);
+
+	if (lsa)
+		ospf_external_lsa_refresh(ospf, lsa, ei, LSA_REFRESH_FORCE, 0);
+	else {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug("%s: Originate external route(%pI4/%d)",
+				   __func__, &ei->p.prefix, ei->p.prefixlen);
+
+		ospf_external_lsa_originate(ospf, ei);
+	}
+}
+
+static void ospf_handle_external_aggr_add(struct ospf *ospf)
+{
+	struct external_info *ei;
+	struct route_node *rn = NULL;
+	struct route_table *rt = NULL;
+	int type = 0;
+
+	/* Delete all the aggregators which are marked as
+	 * OSPF_ROUTE_AGGR_DEL.
+	 */
+	ospf_delete_all_marked_aggregators(ospf);
+
+	for (type = 0; type <= ZEBRA_ROUTE_MAX; type++) {
+		struct list *ext_list;
+		struct listnode *node;
+		struct ospf_external *ext;
+		struct ospf_external_aggr_rt *aggr;
+
+		ext_list = ospf->external[type];
+		if (!ext_list)
+			continue;
+
+		for (ALL_LIST_ELEMENTS_RO(ext_list, node, ext)) {
+			rt = ext->external_info;
+			if (!rt)
+				continue;
+
+			for (rn = route_top(rt); rn; rn = route_next(rn)) {
+				if (!rn->info)
+					continue;
+
+				ei = rn->info;
+				if (is_prefix_default(&ei->p))
+					continue;
+
+				/* Check the AS-external-LSA
+				 * should be originated.
+				 */
+				if (!ospf_redistribute_check(ospf, ei, NULL))
+					continue;
+
+				aggr = ospf_external_aggr_match(ospf, &ei->p);
+
+				/* If matching aggregator found, Add
+				 * the external route reference to the
+				 * aggregator and originate the aggr
+				 * route if it is advertisable.
+				 * flush the external LSA if it is
+				 * already originated for this external
+				 * prefix.
+				 */
+				if (aggr) {
+					ospf_originate_summary_lsa(ospf, aggr,
+								   ei);
+
+					/* All aggregated external rts
+					 * are handled here.
+					 */
+					ospf_handle_aggregated_exnl_rt(
+						ospf, aggr, ei);
+					continue;
+				}
+
+				/* External routes which are only out
+				 * of aggregation will be handled here.
+				 */
+				ospf_handle_exnl_rt_after_aggr_del(ospf, ei);
+			}
+		}
+	}
+}
+
+static void
+ospf_aggr_handle_advertise_change(struct ospf *ospf,
+				  struct ospf_external_aggr_rt *aggr,
+				  struct external_info *ei_aggr)
+{
+	struct ospf_lsa *lsa;
+
+	/* Check if advertise option modified. */
+	if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE)) {
+
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug(
+				"%s: Don't originate the summary address,It is configured to not-advertise.",
+				__func__);
+
+		if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s: No-advertise,So Flush the Aggregate route(%pI4/%d)",
+					__func__, &aggr->p.prefix,
+					aggr->p.prefixlen);
+
+			ospf_external_lsa_flush(ospf, 0, &aggr->p, 0);
+
+			UNSET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+		}
+		return;
+	}
+
+	if (!CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+		if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+			zlog_debug("%s: Now it is advatisable", __func__);
+
+		lsa = ospf_external_info_find_lsa(ospf, &ei_aggr->p);
+		if (lsa && IS_LSA_MAXAGE(lsa)) {
+			/* This is special case.
+			 * If a summary route need to be originated but where
+			 * summary route already exist in lsdb with maxage, then
+			 * it need to be refreshed.
+			 */
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s: It is already with Maxage, So refresh it (%pI4/%d)",
+					__func__, &aggr->p.prefix,
+					aggr->p.prefixlen);
+
+			ospf_external_lsa_refresh(ospf, lsa, ei_aggr,
+						  LSA_REFRESH_FORCE, 1);
+
+			SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_ORIGINATED);
+
+		} else {
+
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s: Originate Aggregate LSA (%pI4/%d)",
+					__func__, &aggr->p.prefix,
+					aggr->p.prefixlen);
+
+			/* Originate summary LSA */
+			lsa = ospf_external_lsa_originate(ospf, ei_aggr);
+			if (lsa)
+				SET_FLAG(aggr->flags,
+					 OSPF_EXTERNAL_AGGRT_ORIGINATED);
+		}
+	}
+}
+
+static void ospf_handle_external_aggr_update(struct ospf *ospf)
+{
+	struct route_node *rn = NULL;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Process modified aggregators.\n", __func__);
+
+	for (rn = route_top(ospf->rt_aggr_tbl); rn; rn = route_next(rn)) {
+		struct ospf_external_aggr_rt *aggr;
+		struct ospf_lsa *lsa = NULL;
+		struct as_external_lsa *asel = NULL;
+		struct external_info ei_aggr;
+		route_tag_t tag = 0;
+
+		if (!rn->info)
+			continue;
+
+		aggr = rn->info;
+
+		if (aggr->action == OSPF_ROUTE_AGGR_DEL) {
+			aggr->action = OSPF_ROUTE_AGGR_NONE;
+			ospf_external_aggr_delete(ospf, rn);
+
+			if (OSPF_EXTERNAL_RT_COUNT(aggr))
+				hash_clean(
+					aggr->match_extnl_hash,
+					(void *)ospf_aggr_handle_external_info);
+
+			hash_free(aggr->match_extnl_hash);
+			XFREE(MTYPE_OSPF_EXTERNAL_RT_AGGR, aggr);
+
+		} else if (aggr->action == OSPF_ROUTE_AGGR_MODIFY) {
+
+			aggr->action = OSPF_ROUTE_AGGR_NONE;
+
+			/* Prepare the extrenal_info for aggregator */
+			memset(&ei_aggr, 0, sizeof(struct external_info));
+			ei_aggr.p = aggr->p;
+			ei_aggr.tag = aggr->tag;
+			ei_aggr.type = 0;
+			ei_aggr.instance = ospf->instance;
+			ei_aggr.route_map_set.metric = -1;
+			ei_aggr.route_map_set.metric_type = -1;
+
+			/* Check if tag modified */
+			if (CHECK_FLAG(aggr->flags,
+				       OSPF_EXTERNAL_AGGRT_ORIGINATED)) {
+				lsa = ospf_external_info_find_lsa(ospf,
+								  &ei_aggr.p);
+				if (!lsa) {
+					flog_warn(EC_OSPF_LSA_MISSING,
+						  "%s: Could not refresh/originate %pI4/%d",
+						  __func__, &aggr->p.prefix,
+						  aggr->p.prefixlen);
+					continue;
+				}
+
+				asel = (struct as_external_lsa *)lsa->data;
+				tag = (unsigned long)ntohl(
+					asel->e[0].route_tag);
+
+				/* If tag modified , then re-originate the
+				 * route with modified tag details.
+				 */
+				if (tag != ei_aggr.tag) {
+					if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+						zlog_debug(
+							"%s: Route tag changed(old:%d new:%d,So refresh the summary route.(%pI4/%d)",
+							__func__, tag,
+							ei_aggr.tag,
+							&aggr->p.prefix,
+							aggr->p.prefixlen);
+
+					ospf_external_lsa_refresh(
+						ospf, lsa, &ei_aggr,
+						LSA_REFRESH_FORCE, 1);
+				}
+			}
+
+			/* Advertise option modified ?
+			 * If so, handled it here.
+			 */
+			ospf_aggr_handle_advertise_change(ospf, aggr, &ei_aggr);
+		}
+	}
+}
+
+static int ospf_asbr_external_aggr_process(struct thread *thread)
+{
+	struct ospf *ospf = THREAD_ARG(thread);
+	int operation = 0;
+
+	ospf->t_external_aggr = NULL;
+	operation = ospf->aggr_action;
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: operation:%d\n", __func__, operation);
+
+	switch (operation) {
+	case OSPF_ROUTE_AGGR_ADD:
+		ospf_handle_external_aggr_add(ospf);
+		break;
+	case OSPF_ROUTE_AGGR_DEL:
+	case OSPF_ROUTE_AGGR_MODIFY:
+		ospf_handle_external_aggr_update(ospf);
+		break;
+	default:
+		break;
+	}
+
+	return OSPF_SUCCESS;
+}
+static void ospf_external_aggr_timer(struct ospf *ospf,
+				     struct ospf_external_aggr_rt *aggr,
+				     enum ospf_aggr_action_t operation)
+{
+	aggr->action = operation;
+
+	if (ospf->t_external_aggr) {
+		if (ospf->aggr_action == OSPF_ROUTE_AGGR_ADD) {
+
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s: Not required to retsart timer,set is already added.",
+					__func__);
+			return;
+		}
+
+		if (operation == OSPF_ROUTE_AGGR_ADD) {
+			if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+				zlog_debug(
+					"%s, Restarting Aggregator delay timer.",
+					__func__);
+			THREAD_OFF(ospf->t_external_aggr);
+		}
+	}
+
+	if (IS_DEBUG_OSPF(lsa, EXTNL_LSA_AGGR))
+		zlog_debug("%s: Start Aggregator delay timer %d(in seconds).",
+			   __func__, ospf->aggr_delay_interval);
+
+	ospf->aggr_action = operation;
+	thread_add_timer(master, ospf_asbr_external_aggr_process, ospf,
+			 ospf->aggr_delay_interval, &ospf->t_external_aggr);
+}
+
+int ospf_asbr_external_aggregator_set(struct ospf *ospf, struct prefix_ipv4 *p,
+				      route_tag_t tag)
+{
+	struct ospf_external_aggr_rt *aggregator;
+
+	aggregator = ospf_extrenal_aggregator_lookup(ospf, p);
+
+	if (aggregator) {
+		if (CHECK_FLAG(aggregator->flags,
+			       OSPF_EXTERNAL_AGGRT_NO_ADVERTISE))
+			UNSET_FLAG(aggregator->flags,
+				   OSPF_EXTERNAL_AGGRT_NO_ADVERTISE);
+		else if (aggregator->tag == tag)
+			return OSPF_SUCCESS;
+
+		aggregator->tag = tag;
+
+		ospf_external_aggr_timer(ospf, aggregator,
+					 OSPF_ROUTE_AGGR_MODIFY);
+	} else {
+		aggregator = ospf_external_aggregator_new(p);
+		if (!aggregator)
+			return OSPF_FAILURE;
+
+		aggregator->tag = tag;
+
+		ospf_external_aggr_add(ospf, aggregator);
+		ospf_external_aggr_timer(ospf, aggregator, OSPF_ROUTE_AGGR_ADD);
+	}
+
+	return OSPF_SUCCESS;
+}
+
+int ospf_asbr_external_aggregator_unset(struct ospf *ospf,
+					struct prefix_ipv4 *p, route_tag_t tag)
+{
+	struct route_node *rn;
+	struct ospf_external_aggr_rt *aggr;
+
+	rn = route_node_lookup(ospf->rt_aggr_tbl, (struct prefix *)p);
+	if (!rn)
+		return OSPF_INVALID;
+
+	aggr = rn->info;
+
+	if (tag && (tag != aggr->tag))
+		return OSPF_INVALID;
+
+	if (!OSPF_EXTERNAL_RT_COUNT(aggr)) {
+		ospf_external_aggr_delete(ospf, rn);
+		ospf_external_aggregator_free(aggr);
+		return OSPF_SUCCESS;
+	}
+
+	ospf_external_aggr_timer(ospf, aggr, OSPF_ROUTE_AGGR_DEL);
+
+	return OSPF_SUCCESS;
+}
+
+int ospf_asbr_external_rt_no_advertise(struct ospf *ospf, struct prefix_ipv4 *p)
+{
+	struct ospf_external_aggr_rt *aggr;
+	route_tag_t tag = 0;
+
+	aggr = ospf_extrenal_aggregator_lookup(ospf, p);
+	if (aggr) {
+		if (CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE))
+			return OSPF_SUCCESS;
+
+		SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE);
+
+		aggr->tag = tag;
+
+		if (!OSPF_EXTERNAL_RT_COUNT(aggr))
+			return OSPF_SUCCESS;
+
+		ospf_external_aggr_timer(ospf, aggr, OSPF_ROUTE_AGGR_MODIFY);
+	} else {
+		aggr = ospf_external_aggregator_new(p);
+
+		if (!aggr)
+			return OSPF_FAILURE;
+
+		SET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE);
+		ospf_external_aggr_add(ospf, aggr);
+		ospf_external_aggr_timer(ospf, aggr, OSPF_ROUTE_AGGR_ADD);
+	}
+
+	return OSPF_SUCCESS;
+}
+
+int ospf_asbr_external_rt_advertise(struct ospf *ospf, struct prefix_ipv4 *p)
+{
+	struct route_node *rn;
+	struct ospf_external_aggr_rt *aggr;
+
+	rn = route_node_lookup(ospf->rt_aggr_tbl, (struct prefix *)p);
+	if (!rn)
+		return OSPF_INVALID;
+
+	aggr = rn->info;
+
+	if (!CHECK_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE))
+		return OSPF_INVALID;
+
+	UNSET_FLAG(aggr->flags, OSPF_EXTERNAL_AGGRT_NO_ADVERTISE);
+
+	if (!OSPF_EXTERNAL_RT_COUNT(aggr))
+		return OSPF_SUCCESS;
+
+	ospf_external_aggr_timer(ospf, aggr, OSPF_ROUTE_AGGR_MODIFY);
+	return OSPF_SUCCESS;
+}
+
+int ospf_external_aggregator_timer_set(struct ospf *ospf, unsigned int interval)
+{
+	ospf->aggr_delay_interval = interval;
+	return OSPF_SUCCESS;
+}