1 files changed, 245 insertions, 47 deletions

diff --git a/pbrd/pbr_nht.c b/pbrd/pbr_nht.c
index 31da656793..3fb3759049 100644
--- a/pbrd/pbr_nht.c
+++ b/pbrd/pbr_nht.c
@@ -37,7 +37,7 @@
 
 DEFINE_MTYPE_STATIC(PBRD, PBR_NHG, "PBR Nexthop Groups")
 
-static struct hash *pbr_nhg_hash;
+struct hash *pbr_nhg_hash;
 static struct hash *pbr_nhrc_hash;
 
 static uint32_t pbr_nhg_low_table;
@@ -91,15 +91,15 @@ static void *pbr_nh_alloc(void *p)
 	struct nhrc *nhrc;
 
 	new = XCALLOC(MTYPE_PBR_NHG, sizeof(*new));
-	nhrc = hash_get(pbr_nhrc_hash, pnhc->nexthop, pbr_nhrc_hash_alloc);
-	new->nexthop = &nhrc->nexthop;
+	nhrc = hash_get(pbr_nhrc_hash, &pnhc->nexthop, pbr_nhrc_hash_alloc);
+	new->nexthop = nhrc->nexthop;
 
 	/* Decremented again in pbr_nh_delete */
 	++nhrc->refcount;
 
 	DEBUGD(&pbr_dbg_nht, "%s: Sending nexthop to Zebra", __func__);
 
-	pbr_send_rnh(new->nexthop, true);
+	pbr_send_rnh(&new->nexthop, true);
 
 	new->valid = false;
 	return new;
@@ -109,14 +109,14 @@ static void pbr_nh_delete(struct pbr_nexthop_cache **pnhc)
 {
 	struct nhrc *nhrc;
 
-	nhrc = hash_lookup(pbr_nhrc_hash, (*pnhc)->nexthop);
+	nhrc = hash_lookup(pbr_nhrc_hash, &((*pnhc)->nexthop));
 
 	if (nhrc)
 		--nhrc->refcount;
 	if (!nhrc || nhrc->refcount == 0) {
 		DEBUGD(&pbr_dbg_nht, "%s: Removing nexthop from Zebra",
 		       __func__);
-		pbr_send_rnh((*pnhc)->nexthop, false);
+		pbr_send_rnh(&((*pnhc)->nexthop), false);
 	}
 	if (nhrc && nhrc->refcount == 0) {
 		hash_release(pbr_nhrc_hash, nhrc);
@@ -136,7 +136,7 @@ static uint32_t pbr_nh_hash_key(const void *arg)
 	uint32_t key;
 	const struct pbr_nexthop_cache *pbrnc = arg;
 
-	key = nexthop_hash(pbrnc->nexthop);
+	key = nexthop_hash(&pbrnc->nexthop);
 
 	return key;
 }
@@ -148,28 +148,28 @@ static bool pbr_nh_hash_equal(const void *arg1, const void *arg2)
 	const struct pbr_nexthop_cache *pbrnc2 =
 		(const struct pbr_nexthop_cache *)arg2;
 
-	if (pbrnc1->nexthop->vrf_id != pbrnc2->nexthop->vrf_id)
+	if (pbrnc1->nexthop.vrf_id != pbrnc2->nexthop.vrf_id)
 		return false;
 
-	if (pbrnc1->nexthop->ifindex != pbrnc2->nexthop->ifindex)
+	if (pbrnc1->nexthop.ifindex != pbrnc2->nexthop.ifindex)
 		return false;
 
-	if (pbrnc1->nexthop->type != pbrnc2->nexthop->type)
+	if (pbrnc1->nexthop.type != pbrnc2->nexthop.type)
 		return false;
 
-	switch (pbrnc1->nexthop->type) {
+	switch (pbrnc1->nexthop.type) {
 	case NEXTHOP_TYPE_IFINDEX:
-		return pbrnc1->nexthop->ifindex == pbrnc2->nexthop->ifindex;
+		return pbrnc1->nexthop.ifindex == pbrnc2->nexthop.ifindex;
 	case NEXTHOP_TYPE_IPV4_IFINDEX:
 	case NEXTHOP_TYPE_IPV4:
-		return pbrnc1->nexthop->gate.ipv4.s_addr
-		       == pbrnc2->nexthop->gate.ipv4.s_addr;
+		return pbrnc1->nexthop.gate.ipv4.s_addr
+		       == pbrnc2->nexthop.gate.ipv4.s_addr;
 	case NEXTHOP_TYPE_IPV6_IFINDEX:
 	case NEXTHOP_TYPE_IPV6:
-		return !memcmp(&pbrnc1->nexthop->gate.ipv6,
-			       &pbrnc2->nexthop->gate.ipv6, 16);
+		return !memcmp(&pbrnc1->nexthop.gate.ipv6,
+			       &pbrnc2->nexthop.gate.ipv6, 16);
 	case NEXTHOP_TYPE_BLACKHOLE:
-		return pbrnc1->nexthop->bh_type == pbrnc2->nexthop->bh_type;
+		return pbrnc1->nexthop.bh_type == pbrnc2->nexthop.bh_type;
 	}
 
 	/*
@@ -249,9 +249,8 @@ void pbr_nhgroup_add_nexthop_cb(const struct nexthop_group_cmd *nhgc,
 	pnhgc = hash_get(pbr_nhg_hash, &pnhgc_find, pbr_nhgc_alloc);
 
 	/* create & insert new pnhc into pnhgc->nhh */
-	pnhc_find.nexthop = (struct nexthop *)nhop;
+	pnhc_find.nexthop = *nhop;
 	pnhc = hash_get(pnhgc->nhh, &pnhc_find, pbr_nh_alloc);
-	pnhc_find.nexthop = NULL;
 
 	/* set parent pnhgc */
 	pnhc->parent = pnhgc;
@@ -291,7 +290,7 @@ void pbr_nhgroup_del_nexthop_cb(const struct nexthop_group_cmd *nhgc,
 	pnhgc = hash_lookup(pbr_nhg_hash, &pnhgc_find);
 
 	/* delete pnhc from pnhgc->nhh */
-	pnhc_find.nexthop = (struct nexthop *)nhop;
+	pnhc_find.nexthop = *nhop;
 	pnhc = hash_release(pnhgc->nhh, &pnhc_find);
 
 	/* delete pnhc */
@@ -499,7 +498,7 @@ void pbr_nht_change_group(const char *name)
 		struct pbr_nexthop_cache lookup;
 		struct pbr_nexthop_cache *pnhc;
 
-		lookup.nexthop = nhop;
+		lookup.nexthop = *nhop;
 		pnhc = hash_lookup(pnhgc->nhh, &lookup);
 		if (!pnhc) {
 			pnhc = hash_get(pnhgc->nhh, &lookup, pbr_nh_alloc);
@@ -553,9 +552,25 @@ void pbr_nht_add_individual_nexthop(struct pbr_map_sequence *pbrms,
 
 	pnhgc = hash_get(pbr_nhg_hash, &find, pbr_nhgc_alloc);
 
-	lookup.nexthop = pbrms->nhg->nexthop;
+	lookup.nexthop = *pbrms->nhg->nexthop;
 	pnhc = hash_get(pnhgc->nhh, &lookup, pbr_nh_alloc);
 	pnhc->parent = pnhgc;
+	if (nhop->vrf_id != VRF_DEFAULT) {
+		struct vrf *vrf = vrf_lookup_by_id(nhop->vrf_id);
+
+		if (vrf)
+			strlcpy(pnhc->vrf_name, vrf->name,
+				sizeof(pnhc->vrf_name));
+	}
+
+	if (nhop->ifindex != 0) {
+		struct interface *ifp =
+			if_lookup_by_index(nhop->ifindex, nhop->vrf_id);
+
+		if (ifp)
+			strlcpy(pnhc->intf_name, ifp->name,
+				sizeof(pnhc->intf_name));
+	}
 	pbr_nht_install_nexthop_group(pnhgc, *pbrms->nhg);
 }
 
@@ -574,7 +589,7 @@ static void pbr_nht_release_individual_nexthop(struct pbr_map_sequence *pbrms)
 
 	nh = pbrms->nhg->nexthop;
 	nh_type = nh->type;
-	lup.nexthop = nh;
+	lup.nexthop = *nh;
 	pnhc = hash_lookup(pnhgc->nhh, &lup);
 	pnhc->parent = NULL;
 	hash_release(pnhgc->nhh, pnhc);
@@ -625,7 +640,7 @@ struct pbr_nexthop_group_cache *pbr_nht_add_group(const char *name)
 		struct pbr_nexthop_cache lookupc;
 		struct pbr_nexthop_cache *pnhc;
 
-		lookupc.nexthop = nhop;
+		lookupc.nexthop = *nhop;
 		pnhc = hash_lookup(pnhgc->nhh, &lookupc);
 		if (!pnhc) {
 			pnhc = hash_get(pnhgc->nhh, &lookupc, pbr_nh_alloc);
@@ -689,13 +704,18 @@ bool pbr_nht_nexthop_group_valid(const char *name)
 struct pbr_nht_individual {
 	struct zapi_route *nhr;
 	struct interface *ifp;
+	struct pbr_vrf *pbr_vrf;
+	struct pbr_nexthop_cache *pnhc;
+	vrf_id_t old_vrf_id;
 
-	uint32_t valid;
+	bool valid;
+
+	bool nhr_matched;
 };
 
 static bool
 pbr_nht_individual_nexthop_gw_update(struct pbr_nexthop_cache *pnhc,
-				     const struct pbr_nht_individual *pnhi)
+				     struct pbr_nht_individual *pnhi)
 {
 	bool is_valid = pnhc->valid;
 
@@ -704,25 +724,26 @@ pbr_nht_individual_nexthop_gw_update(struct pbr_nexthop_cache *pnhc,
 
 	switch (pnhi->nhr->prefix.family) {
 	case AF_INET:
-		if (pnhc->nexthop->gate.ipv4.s_addr
+		if (pnhc->nexthop.gate.ipv4.s_addr
 		    != pnhi->nhr->prefix.u.prefix4.s_addr)
 			goto done; /* Unrelated change */
 		break;
 	case AF_INET6:
-		if (memcmp(&pnhc->nexthop->gate.ipv6,
+		if (memcmp(&pnhc->nexthop.gate.ipv6,
 			   &pnhi->nhr->prefix.u.prefix6, 16)
 		    != 0)
 			goto done; /* Unrelated change */
 		break;
 	}
 
+	pnhi->nhr_matched = true;
 	if (!pnhi->nhr->nexthop_num) {
 		is_valid = false;
 		goto done;
 	}
 
-	if (pnhc->nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX
-	    || pnhc->nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
+	if (pnhc->nexthop.type == NEXTHOP_TYPE_IPV4_IFINDEX
+	    || pnhc->nexthop.type == NEXTHOP_TYPE_IPV6_IFINDEX) {
 
 		/* GATEWAY_IFINDEX type shouldn't resolve to group */
 		if (pnhi->nhr->nexthop_num > 1) {
@@ -733,7 +754,7 @@ pbr_nht_individual_nexthop_gw_update(struct pbr_nexthop_cache *pnhc,
 		/* If whatever we resolved to wasn't on the interface we
 		 * specified. (i.e. not a connected route), its invalid.
 		 */
-		if (pnhi->nhr->nexthops[0].ifindex != pnhc->nexthop->ifindex) {
+		if (pnhi->nhr->nexthops[0].ifindex != pnhc->nexthop.ifindex) {
 			is_valid = false;
 			goto done;
 		}
@@ -747,18 +768,20 @@ done:
 	return pnhc->valid;
 }
 
-static bool pbr_nht_individual_nexthop_interface_update(
-	struct pbr_nexthop_cache *pnhc, const struct pbr_nht_individual *pnhi)
+static bool
+pbr_nht_individual_nexthop_interface_update(struct pbr_nexthop_cache *pnhc,
+					    struct pbr_nht_individual *pnhi)
 {
 	bool is_valid = pnhc->valid;
 
 	if (!pnhi->ifp) /* It doesn't care about non-interface updates */
 		goto done;
 
-	if (pnhc->nexthop->ifindex
+	if (pnhc->nexthop.ifindex
 	    != pnhi->ifp->ifindex) /* Un-related interface */
 		goto done;
 
+	pnhi->nhr_matched = true;
 	is_valid = !!if_is_up(pnhi->ifp);
 
 done:
@@ -773,18 +796,17 @@ done:
  * If the update is un-related, the subroutines shoud just return their cached
  * valid state.
  */
-static void
-pbr_nht_individual_nexthop_update(struct pbr_nexthop_cache *pnhc,
-				  const struct pbr_nht_individual *pnhi)
+static void pbr_nht_individual_nexthop_update(struct pbr_nexthop_cache *pnhc,
+					      struct pbr_nht_individual *pnhi)
 {
 	assert(pnhi->nhr || pnhi->ifp); /* Either nexthop or interface update */
 
-	switch (pnhc->nexthop->type) {
+	switch (pnhc->nexthop.type) {
 	case NEXTHOP_TYPE_IFINDEX:
 		pbr_nht_individual_nexthop_interface_update(pnhc, pnhi);
 		break;
 	case NEXTHOP_TYPE_IPV6_IFINDEX:
-		if (IN6_IS_ADDR_LINKLOCAL(&pnhc->nexthop->gate.ipv6)) {
+		if (IN6_IS_ADDR_LINKLOCAL(&pnhc->nexthop.gate.ipv6)) {
 			pbr_nht_individual_nexthop_interface_update(pnhc, pnhi);
 			break;
 		}
@@ -817,7 +839,7 @@ static void pbr_nht_individual_nexthop_update_lookup(struct hash_bucket *b,
 	       pnhc->valid);
 
 	if (pnhc->valid)
-		pnhi->valid += 1;
+		pnhi->valid = true;
 }
 
 static void pbr_nexthop_group_cache_iterate_to_group(struct hash_bucket *b,
@@ -827,7 +849,7 @@ static void pbr_nexthop_group_cache_iterate_to_group(struct hash_bucket *b,
 	struct nexthop_group *nhg = data;
 	struct nexthop *nh = NULL;
 
-	copy_nexthops(&nh, pnhc->nexthop, NULL);
+	copy_nexthops(&nh, &pnhc->nexthop, NULL);
 
 	_nexthop_add(&nhg->nexthop, nh);
 }
@@ -849,10 +871,14 @@ static void pbr_nht_nexthop_update_lookup(struct hash_bucket *b, void *data)
 	old_valid = pnhgc->valid;
 
 	pnhi.nhr = (struct zapi_route *)data;
-	pnhi.valid = 0;
+	pnhi.valid = false;
+	pnhi.nhr_matched = false;
 	hash_iterate(pnhgc->nhh, pbr_nht_individual_nexthop_update_lookup,
 		     &pnhi);
 
+	if (!pnhi.nhr_matched)
+		return;
+
 	/*
 	 * If any of the specified nexthops are valid we are valid
 	 */
@@ -877,6 +903,178 @@ void pbr_nht_nexthop_update(struct zapi_route *nhr)
 	hash_iterate(pbr_nhg_hash, pbr_nht_nexthop_update_lookup, nhr);
 }
 
+struct nhrc_vrf_info {
+	struct pbr_vrf *pbr_vrf;
+	uint32_t old_vrf_id;
+	struct nhrc *nhrc;
+};
+
+static int pbr_nht_nhrc_vrf_change(struct hash_bucket *b, void *data)
+{
+	struct nhrc *nhrc = b->data;
+	struct nhrc_vrf_info *nhrcvi = data;
+
+	if (nhrc->nexthop.vrf_id == nhrcvi->old_vrf_id) {
+		nhrcvi->nhrc = nhrc;
+		return HASHWALK_ABORT;
+	}
+
+	return HASHWALK_CONTINUE;
+}
+
+static int pbr_nht_individual_nexthop_vrf_handle(struct hash_bucket *b,
+						 void *data)
+{
+	struct pbr_nexthop_cache *pnhc = b->data;
+	struct pbr_nht_individual *pnhi = data;
+
+	if (pnhc->looked_at == true)
+		return HASHWALK_CONTINUE;
+
+	if (pnhc->nexthop.vrf_id == VRF_DEFAULT)
+		return HASHWALK_CONTINUE;
+
+	if (strncmp(pnhc->vrf_name, pbr_vrf_name(pnhi->pbr_vrf),
+		    sizeof(pnhc->vrf_name))
+	    == 0) {
+		pnhi->pnhc = pnhc;
+
+		if (pnhc->nexthop.vrf_id != pbr_vrf_id(pnhi->pbr_vrf)) {
+			struct nhrc_vrf_info nhrcvi;
+
+			memset(&nhrcvi, 0, sizeof(nhrcvi));
+			nhrcvi.pbr_vrf = pnhi->pbr_vrf;
+			nhrcvi.old_vrf_id = pnhc->nexthop.vrf_id;
+
+			pnhi->nhr_matched = true;
+			pnhi->old_vrf_id = pnhc->nexthop.vrf_id;
+
+			do {
+				nhrcvi.nhrc = NULL;
+				hash_walk(pbr_nhrc_hash,
+					  pbr_nht_nhrc_vrf_change, &nhrcvi);
+				if (nhrcvi.nhrc) {
+					hash_release(pbr_nhrc_hash,
+						     nhrcvi.nhrc);
+					nhrcvi.nhrc->nexthop.vrf_id =
+						pbr_vrf_id(pnhi->pbr_vrf);
+					hash_get(pbr_nhrc_hash, nhrcvi.nhrc,
+						 hash_alloc_intern);
+					pbr_send_rnh(&nhrcvi.nhrc->nexthop, true);
+				}
+			} while (nhrcvi.nhrc);
+		}
+
+		pnhc->looked_at = true;
+		return HASHWALK_ABORT;
+	}
+
+	return HASHWALK_CONTINUE;
+}
+
+static void pbr_nht_clear_looked_at(struct hash_bucket *b, void *data)
+{
+	struct pbr_nexthop_cache *pnhc = b->data;
+
+	pnhc->looked_at = false;
+}
+
+static void pbr_nht_nexthop_vrf_handle(struct hash_bucket *b, void *data)
+{
+	struct pbr_nexthop_group_cache *pnhgc = b->data;
+	struct pbr_vrf *pbr_vrf = data;
+	struct pbr_nht_individual pnhi = {};
+
+	zlog_debug("pnhgc iterating");
+	hash_iterate(pnhgc->nhh, pbr_nht_clear_looked_at, NULL);
+	memset(&pnhi, 0, sizeof(pnhi));
+	pnhi.pbr_vrf = pbr_vrf;
+	do {
+		struct pbr_nexthop_cache *pnhc;
+
+		pnhi.pnhc = NULL;
+		hash_walk(pnhgc->nhh, pbr_nht_individual_nexthop_vrf_handle,
+			  &pnhi);
+
+		if (!pnhi.pnhc)
+			continue;
+
+		pnhc = pnhi.pnhc;
+		pnhc->nexthop.vrf_id = pnhi.old_vrf_id;
+		pnhi.pnhc = hash_release(pnhgc->nhh, pnhi.pnhc);
+		if (pnhi.pnhc) {
+			pnhi.pnhc->nexthop.vrf_id = pbr_vrf_id(pbr_vrf);
+
+			hash_get(pnhgc->nhh, pnhi.pnhc, hash_alloc_intern);
+		} else
+			pnhc->nexthop.vrf_id = pbr_vrf_id(pbr_vrf);
+
+		pbr_map_check_vrf_nh_group_change(pnhgc->name, pbr_vrf,
+						  pnhi.old_vrf_id);
+	} while (pnhi.pnhc);
+}
+
+void pbr_nht_vrf_update(struct pbr_vrf *pbr_vrf)
+{
+	hash_iterate(pbr_nhg_hash, pbr_nht_nexthop_vrf_handle, pbr_vrf);
+}
+
+static void pbr_nht_individual_nexthop_interface_handle(struct hash_bucket *b,
+							void *data)
+{
+	struct pbr_nexthop_cache *pnhc = b->data;
+	struct pbr_nht_individual *pnhi = data;
+
+	if (pnhc->nexthop.ifindex == 0)
+		return;
+
+	if ((strncmp(pnhc->intf_name, pnhi->ifp->name, sizeof(pnhc->intf_name))
+	     == 0)
+	    && pnhc->nexthop.ifindex != pnhi->ifp->ifindex)
+		pnhi->pnhc = pnhc;
+}
+
+static void pbr_nht_nexthop_interface_handle(struct hash_bucket *b, void *data)
+{
+	struct pbr_nexthop_group_cache *pnhgc = b->data;
+	struct interface *ifp = data;
+	struct pbr_nht_individual pnhi = {};
+	struct nhrc *nhrc;
+	uint32_t old_ifindex;
+
+	do {
+		memset(&pnhi, 0, sizeof(pnhi));
+		pnhi.ifp = ifp;
+		hash_iterate(pnhgc->nhh,
+			     pbr_nht_individual_nexthop_interface_handle,
+			     &pnhi);
+
+		if (!pnhi.pnhc)
+			continue;
+
+		pnhi.pnhc = hash_release(pnhgc->nhh, pnhi.pnhc);
+		old_ifindex = pnhi.pnhc->nexthop.ifindex;
+
+		nhrc = hash_lookup(pbr_nhrc_hash, &pnhi.pnhc->nexthop);
+		if (nhrc) {
+			hash_release(pbr_nhrc_hash, nhrc);
+			nhrc->nexthop.ifindex = ifp->ifindex;
+			hash_get(pbr_nhrc_hash, nhrc, hash_alloc_intern);
+		}
+		pnhi.pnhc->nexthop.ifindex = ifp->ifindex;
+
+		hash_get(pnhgc->nhh, pnhi.pnhc, hash_alloc_intern);
+
+		pbr_map_check_interface_nh_group_change(pnhgc->name, ifp,
+							old_ifindex);
+	} while (pnhi.pnhc);
+}
+
+void pbr_nht_interface_update(struct interface *ifp)
+{
+	hash_iterate(pbr_nhg_hash, pbr_nht_nexthop_interface_handle, ifp);
+}
+
 static void
 pbr_nht_individual_nexthop_interface_update_lookup(struct hash_bucket *b,
 						   void *data)
@@ -893,7 +1091,7 @@ pbr_nht_individual_nexthop_interface_update_lookup(struct hash_bucket *b,
 	       old_valid, pnhc->valid);
 
 	if (pnhc->valid)
-		pnhi->valid += 1;
+		pnhi->valid = true;
 }
 
 static void pbr_nht_nexthop_interface_update_lookup(struct hash_bucket *b,
@@ -906,14 +1104,14 @@ static void pbr_nht_nexthop_interface_update_lookup(struct hash_bucket *b,
 	old_valid = pnhgc->valid;
 
 	pnhi.ifp = data;
-	pnhi.valid = 0;
+	pnhi.valid = false;
 	hash_iterate(pnhgc->nhh,
 		     pbr_nht_individual_nexthop_interface_update_lookup, &pnhi);
 
 	/*
 	 * If any of the specified nexthops are valid we are valid
 	 */
-	pnhgc->valid = !!pnhi.valid;
+	pnhgc->valid = pnhi.valid;
 
 	if (old_valid != pnhgc->valid)
 		pbr_map_check_nh_group_change(pnhgc->name);
@@ -1036,7 +1234,7 @@ static void pbr_nht_show_nhg_nexthops(struct hash_bucket *b, void *data)
 	struct vty *vty = data;
 
 	vty_out(vty, "\tValid: %d ", pnhc->valid);
-	nexthop_group_write_nexthop(vty, pnhc->nexthop);
+	nexthop_group_write_nexthop(vty, &pnhc->nexthop);
 }
 
 static void pbr_nht_json_nhg_nexthops(struct hash_bucket *b, void *data)
@@ -1046,7 +1244,7 @@ static void pbr_nht_json_nhg_nexthops(struct hash_bucket *b, void *data)
 	json_object *this_hop;
 
 	this_hop = json_object_new_object();
-	nexthop_group_json_nexthop(this_hop, pnhc->nexthop);
+	nexthop_group_json_nexthop(this_hop, &pnhc->nexthop);
 	json_object_boolean_add(this_hop, "valid", pnhc->valid);
 
 	json_object_array_add(all_hops, this_hop);