1 files changed, 279 insertions, 119 deletions

diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c
index 2190bfab4f..092b5dd3c2 100644
--- a/zebra/zapi_msg.c
+++ b/zebra/zapi_msg.c
@@ -957,7 +957,6 @@ int zsend_pw_update(struct zserv *client, struct zebra_pw *pw)
 
 /* Send response to a get label chunk request to client */
 int zsend_assign_label_chunk_response(struct zserv *client, vrf_id_t vrf_id,
-				      uint8_t proto, uint16_t instance,
 				      struct label_manager_chunk *lmc)
 {
 	int ret;
@@ -965,9 +964,9 @@ int zsend_assign_label_chunk_response(struct zserv *client, vrf_id_t vrf_id,
 
 	zclient_create_header(s, ZEBRA_GET_LABEL_CHUNK, vrf_id);
 	/* proto */
-	stream_putc(s, proto);
+	stream_putc(s, client->proto);
 	/* instance */
-	stream_putw(s, instance);
+	stream_putw(s, client->instance);
 
 	if (lmc) {
 		/* keep */
@@ -1413,6 +1412,132 @@ void zserv_nexthop_num_warn(const char *caller, const struct prefix *p,
 	}
 }
 
+/*
+ * Create a new nexthop based on a zapi nexthop.
+ */
+static struct nexthop *nexthop_from_zapi(struct route_entry *re,
+					 const struct zapi_nexthop *api_nh,
+					 const struct zapi_route *api)
+{
+	struct nexthop *nexthop = NULL;
+	struct ipaddr vtep_ip;
+	struct interface *ifp;
+	char nhbuf[INET6_ADDRSTRLEN] = "";
+
+	switch (api_nh->type) {
+	case NEXTHOP_TYPE_IFINDEX:
+		nexthop = nexthop_from_ifindex(api_nh->ifindex, api_nh->vrf_id);
+		break;
+	case NEXTHOP_TYPE_IPV4:
+		if (IS_ZEBRA_DEBUG_RECV) {
+			inet_ntop(AF_INET, &api_nh->gate.ipv4, nhbuf,
+				  sizeof(nhbuf));
+			zlog_debug("%s: nh=%s, vrf_id=%d", __func__,
+				   nhbuf, api_nh->vrf_id);
+		}
+		nexthop = nexthop_from_ipv4(&api_nh->gate.ipv4, NULL,
+					    api_nh->vrf_id);
+		break;
+	case NEXTHOP_TYPE_IPV4_IFINDEX:
+		if (IS_ZEBRA_DEBUG_RECV) {
+			inet_ntop(AF_INET, &api_nh->gate.ipv4, nhbuf,
+				  sizeof(nhbuf));
+			zlog_debug("%s: nh=%s, vrf_id=%d, ifindex=%d",
+				   __func__, nhbuf, api_nh->vrf_id,
+				   api_nh->ifindex);
+		}
+
+		nexthop = nexthop_from_ipv4_ifindex(
+			&api_nh->gate.ipv4, NULL, api_nh->ifindex,
+			api_nh->vrf_id);
+
+		ifp = if_lookup_by_index(api_nh->ifindex, api_nh->vrf_id);
+		if (ifp && connected_is_unnumbered(ifp))
+			SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
+
+		/* Special handling for IPv4 routes sourced from EVPN:
+		 * the nexthop and associated MAC need to be installed.
+		 */
+		if (CHECK_FLAG(api->flags, ZEBRA_FLAG_EVPN_ROUTE)) {
+			memset(&vtep_ip, 0, sizeof(struct ipaddr));
+			vtep_ip.ipa_type = IPADDR_V4;
+			memcpy(&(vtep_ip.ipaddr_v4), &(api_nh->gate.ipv4),
+			       sizeof(struct in_addr));
+			zebra_vxlan_evpn_vrf_route_add(
+				api_nh->vrf_id, &api_nh->rmac,
+				&vtep_ip, &api->prefix);
+		}
+		break;
+	case NEXTHOP_TYPE_IPV6:
+		if (IS_ZEBRA_DEBUG_RECV) {
+			inet_ntop(AF_INET6, &api_nh->gate.ipv6, nhbuf,
+				  sizeof(nhbuf));
+			zlog_debug("%s: nh=%s, vrf_id=%d", __func__,
+				   nhbuf, api_nh->vrf_id);
+		}
+		nexthop = nexthop_from_ipv6(&api_nh->gate.ipv6, api_nh->vrf_id);
+		break;
+	case NEXTHOP_TYPE_IPV6_IFINDEX:
+		if (IS_ZEBRA_DEBUG_RECV) {
+			inet_ntop(AF_INET6, &api_nh->gate.ipv6, nhbuf,
+				  sizeof(nhbuf));
+			zlog_debug("%s: nh=%s, vrf_id=%d, ifindex=%d",
+				   __func__, nhbuf, api_nh->vrf_id,
+				   api_nh->ifindex);
+		}
+		nexthop = nexthop_from_ipv6_ifindex(&api_nh->gate.ipv6,
+						    api_nh->ifindex,
+						    api_nh->vrf_id);
+
+		/* Special handling for IPv6 routes sourced from EVPN:
+		 * the nexthop and associated MAC need to be installed.
+		 */
+		if (CHECK_FLAG(api->flags, ZEBRA_FLAG_EVPN_ROUTE)) {
+			memset(&vtep_ip, 0, sizeof(struct ipaddr));
+			vtep_ip.ipa_type = IPADDR_V6;
+			memcpy(&vtep_ip.ipaddr_v6, &(api_nh->gate.ipv6),
+			       sizeof(struct in6_addr));
+			zebra_vxlan_evpn_vrf_route_add(
+				api_nh->vrf_id, &api_nh->rmac,
+				&vtep_ip, &api->prefix);
+		}
+		break;
+	case NEXTHOP_TYPE_BLACKHOLE:
+		if (IS_ZEBRA_DEBUG_RECV)
+			zlog_debug("%s: nh blackhole %d",
+				   __func__, api_nh->bh_type);
+
+		nexthop = nexthop_from_blackhole(api_nh->bh_type);
+		break;
+	}
+
+	/* Return early if we couldn't process the zapi nexthop */
+	if (nexthop == NULL) {
+		goto done;
+	}
+
+	if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_ONLINK))
+		SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
+
+	if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_WEIGHT))
+		nexthop->weight = api_nh->weight;
+
+	if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_HAS_BACKUP)) {
+		if (api_nh->backup_idx < api->backup_nexthop_num) {
+			/* Capture backup info */
+			SET_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP);
+			nexthop->backup_idx = api_nh->backup_idx;
+		} else {
+			/* Warn about invalid backup index */
+			if (IS_ZEBRA_DEBUG_RECV || IS_ZEBRA_DEBUG_EVENT)
+				zlog_debug("%s: invalid backup nh idx %d",
+					   __func__, api_nh->backup_idx);
+		}
+	}
+done:
+	return nexthop;
+}
+
 static void zread_route_add(ZAPI_HANDLER_ARGS)
 {
 	struct stream *s;
@@ -1421,12 +1546,15 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 	afi_t afi;
 	struct prefix_ipv6 *src_p = NULL;
 	struct route_entry *re;
-	struct nexthop *nexthop = NULL;
+	struct nexthop *nexthop = NULL, *last_nh;
 	struct nexthop_group *ng = NULL;
+	struct nhg_backup_info *bnhg = NULL;
 	int i, ret;
 	vrf_id_t vrf_id;
-	struct ipaddr vtep_ip;
-	struct interface *ifp;
+	struct nhg_hash_entry nhe;
+	enum lsp_types_t label_type;
+	char nhbuf[NEXTHOP_STRLEN];
+	char labelbuf[MPLS_LABEL_STRLEN];
 
 	s = msg;
 	if (zapi_route_decode(s, &api) < 0) {
@@ -1440,8 +1568,8 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 		char buf_prefix[PREFIX_STRLEN];
 
 		prefix2str(&api.prefix, buf_prefix, sizeof(buf_prefix));
-		zlog_debug("%s: p=%s, flags=0x%x",
-			   __func__, buf_prefix, api.flags);
+		zlog_debug("%s: p=%s, msg flags=0x%x, flags=0x%x",
+			   __func__, buf_prefix, (int)api.message, api.flags);
 	}
 
 	/* Allocate new route. */
@@ -1469,6 +1597,15 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 		return;
 	}
 
+	/* Report misuse of the backup flag */
+	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_BACKUP_NEXTHOPS) &&
+	    api.backup_nexthop_num == 0) {
+		if (IS_ZEBRA_DEBUG_RECV || IS_ZEBRA_DEBUG_EVENT)
+			zlog_debug("%s: client %s: BACKUP flag set but no backup nexthops, prefix %pFX",
+				__func__,
+				zebra_route_string(client->proto), &api.prefix);
+	}
+
 	/* Use temporary list of nexthops */
 	ng = nexthop_group_new();
 
@@ -1479,130 +1616,138 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 	 */
 	for (i = 0; i < api.nexthop_num; i++) {
 		api_nh = &api.nexthops[i];
-		ifindex_t ifindex = 0;
 
-		nexthop = NULL;
+		/* Convert zapi nexthop */
+		nexthop = nexthop_from_zapi(re, api_nh, &api);
+		if (!nexthop) {
+			flog_warn(
+				EC_ZEBRA_NEXTHOP_CREATION_FAILED,
+				"%s: Nexthops Specified: %d but we failed to properly create one",
+				__func__, api.nexthop_num);
+			nexthop_group_delete(&ng);
+			XFREE(MTYPE_RE, re);
+			return;
+		}
 
-		if (IS_ZEBRA_DEBUG_RECV)
-			zlog_debug("nh type %d", api_nh->type);
+		/* MPLS labels for BGP-LU or Segment Routing */
+		if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_LABEL)
+		    && api_nh->type != NEXTHOP_TYPE_IFINDEX
+		    && api_nh->type != NEXTHOP_TYPE_BLACKHOLE
+		    && api_nh->label_num > 0) {
 
-		switch (api_nh->type) {
-		case NEXTHOP_TYPE_IFINDEX:
-			nexthop = nexthop_from_ifindex(api_nh->ifindex,
-						       api_nh->vrf_id);
-			break;
-		case NEXTHOP_TYPE_IPV4:
-			if (IS_ZEBRA_DEBUG_RECV) {
-				char nhbuf[INET6_ADDRSTRLEN] = {0};
+			label_type = lsp_type_from_re_type(client->proto);
+			nexthop_add_labels(nexthop, label_type,
+					   api_nh->label_num,
+					   &api_nh->labels[0]);
+		}
 
-				inet_ntop(AF_INET, &api_nh->gate.ipv4, nhbuf,
-					  INET6_ADDRSTRLEN);
-				zlog_debug("%s: nh=%s, vrf_id=%d", __func__,
-					   nhbuf, api_nh->vrf_id);
-			}
-			nexthop = nexthop_from_ipv4(&api_nh->gate.ipv4,
-						    NULL, api_nh->vrf_id);
-			break;
-		case NEXTHOP_TYPE_IPV4_IFINDEX:
+		if (IS_ZEBRA_DEBUG_RECV) {
+			labelbuf[0] = '\0';
+			nhbuf[0] = '\0';
 
-			memset(&vtep_ip, 0, sizeof(struct ipaddr));
-			ifindex = api_nh->ifindex;
-			if (IS_ZEBRA_DEBUG_RECV) {
-				char nhbuf[INET6_ADDRSTRLEN] = {0};
+			nexthop2str(nexthop, nhbuf, sizeof(nhbuf));
 
-				inet_ntop(AF_INET, &api_nh->gate.ipv4, nhbuf,
-					  INET6_ADDRSTRLEN);
-				zlog_debug(
-					"%s: nh=%s, vrf_id=%d (re->vrf_id=%d), ifindex=%d",
-					__func__, nhbuf, api_nh->vrf_id,
-					re->vrf_id, ifindex);
-			}
-			nexthop = nexthop_from_ipv4_ifindex(
-				&api_nh->gate.ipv4, NULL, ifindex,
-				api_nh->vrf_id);
-
-			ifp = if_lookup_by_index(ifindex, api_nh->vrf_id);
-			if (ifp && connected_is_unnumbered(ifp))
-				SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
-			/* Special handling for IPv4 routes sourced from EVPN:
-			 * the nexthop and associated MAC need to be installed.
-			 */
-			if (CHECK_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE)) {
-				vtep_ip.ipa_type = IPADDR_V4;
-				memcpy(&(vtep_ip.ipaddr_v4),
-				       &(api_nh->gate.ipv4),
-				       sizeof(struct in_addr));
-				zebra_vxlan_evpn_vrf_route_add(
-					api_nh->vrf_id, &api_nh->rmac,
-					&vtep_ip, &api.prefix);
-			}
-			break;
-		case NEXTHOP_TYPE_IPV6:
-			nexthop = nexthop_from_ipv6(&api_nh->gate.ipv6,
-						    api_nh->vrf_id);
-			break;
-		case NEXTHOP_TYPE_IPV6_IFINDEX:
-			memset(&vtep_ip, 0, sizeof(struct ipaddr));
-			ifindex = api_nh->ifindex;
-			nexthop = nexthop_from_ipv6_ifindex(&api_nh->gate.ipv6,
-							    ifindex,
-							    api_nh->vrf_id);
-
-			/* Special handling for IPv6 routes sourced from EVPN:
-			 * the nexthop and associated MAC need to be installed.
-			 */
-			if (CHECK_FLAG(api.flags, ZEBRA_FLAG_EVPN_ROUTE)) {
-				vtep_ip.ipa_type = IPADDR_V6;
-				memcpy(&vtep_ip.ipaddr_v6, &(api_nh->gate.ipv6),
-				       sizeof(struct in6_addr));
-				zebra_vxlan_evpn_vrf_route_add(
-					api_nh->vrf_id, &api_nh->rmac,
-					&vtep_ip, &api.prefix);
+			if (nexthop->nh_label &&
+			    nexthop->nh_label->num_labels > 0) {
+				mpls_label2str(nexthop->nh_label->num_labels,
+					       nexthop->nh_label->label,
+					       labelbuf, sizeof(labelbuf),
+					       false);
 			}
-			break;
-		case NEXTHOP_TYPE_BLACKHOLE:
-			nexthop = nexthop_from_blackhole(api_nh->bh_type);
-			break;
+
+			zlog_debug("%s: nh=%s, vrf_id=%d %s",
+				   __func__, nhbuf, api_nh->vrf_id, labelbuf);
 		}
 
+		/* Add new nexthop to temporary list. This list is
+		 * canonicalized - sorted - so that it can be hashed later
+		 * in route processing. We expect that the sender has sent
+		 * the list sorted, and the zapi client api attempts to enforce
+		 * that, so this should be inexpensive - but it is necessary
+		 * to support shared nexthop-groups.
+		 */
+		nexthop_group_add_sorted(ng, nexthop);
+	}
+
+	/* Allocate temporary list of backup nexthops, if necessary */
+	if (api.backup_nexthop_num > 0) {
+		if (IS_ZEBRA_DEBUG_RECV)
+			zlog_debug("%s: adding %d backup nexthops",
+				   __func__, api.backup_nexthop_num);
+
+		bnhg = zebra_nhg_backup_alloc();
+		nexthop = NULL;
+		last_nh = NULL;
+	}
+
+	/* Copy backup nexthops also, if present */
+	for (i = 0; i < api.backup_nexthop_num; i++) {
+		api_nh = &api.backup_nexthops[i];
+
+		/* Convert zapi backup nexthop */
+		nexthop = nexthop_from_zapi(re, api_nh, &api);
 		if (!nexthop) {
 			flog_warn(
 				EC_ZEBRA_NEXTHOP_CREATION_FAILED,
-				"%s: Nexthops Specified: %d but we failed to properly create one",
-				__func__, api.nexthop_num);
+				"%s: Backup Nexthops Specified: %d but we failed to properly create one",
+				__func__, api.backup_nexthop_num);
 			nexthop_group_delete(&ng);
+			zebra_nhg_backup_free(&bnhg);
 			XFREE(MTYPE_RE, re);
 			return;
 		}
 
-		if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_ONLINK))
-			SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
-
-		if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_WEIGHT))
-			nexthop->weight = api_nh->weight;
+		/* Backup nexthops can't have backups; that's not valid. */
+		if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP)) {
+			if (IS_ZEBRA_DEBUG_RECV) {
+				nexthop2str(nexthop, nhbuf, sizeof(nhbuf));
+				zlog_debug("%s: backup nh %s with BACKUP flag!",
+					   __func__, nhbuf);
+			}
+			UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_HAS_BACKUP);
+			nexthop->backup_idx = 0;
+		}
 
 		/* MPLS labels for BGP-LU or Segment Routing */
 		if (CHECK_FLAG(api_nh->flags, ZAPI_NEXTHOP_FLAG_LABEL)
 		    && api_nh->type != NEXTHOP_TYPE_IFINDEX
-		    && api_nh->type != NEXTHOP_TYPE_BLACKHOLE) {
-			enum lsp_types_t label_type;
+		    && api_nh->type != NEXTHOP_TYPE_BLACKHOLE
+		    && api_nh->label_num > 0) {
 
 			label_type = lsp_type_from_re_type(client->proto);
-
-			if (IS_ZEBRA_DEBUG_RECV) {
-				zlog_debug(
-					"%s: adding %d labels of type %d (1st=%u)",
-					__func__, api_nh->label_num, label_type,
-					api_nh->labels[0]);
-			}
-
 			nexthop_add_labels(nexthop, label_type,
 					   api_nh->label_num,
 					   &api_nh->labels[0]);
 		}
 
-		/* Add new nexthop to temporary list */
-		nexthop_group_add_sorted(ng, nexthop);
+		if (IS_ZEBRA_DEBUG_RECV) {
+			labelbuf[0] = '\0';
+			nhbuf[0] = '\0';
+
+			nexthop2str(nexthop, nhbuf, sizeof(nhbuf));
+
+			if (nexthop->nh_label &&
+			    nexthop->nh_label->num_labels > 0) {
+				mpls_label2str(nexthop->nh_label->num_labels,
+					       nexthop->nh_label->label,
+					       labelbuf, sizeof(labelbuf),
+					       false);
+			}
+
+			zlog_debug("%s: backup nh=%s, vrf_id=%d %s",
+				   __func__, nhbuf, api_nh->vrf_id, labelbuf);
+		}
+
+		/* Note that the order of the backup nexthops is significant,
+		 * so we don't sort this list as we do the primary nexthops,
+		 * we just append.
+		 */
+		if (last_nh)
+			NEXTHOP_APPEND(last_nh, nexthop);
+		else
+			bnhg->nhe->nhg.nexthop = nexthop;
+
+		last_nh = nexthop;
 	}
 
 	if (CHECK_FLAG(api.message, ZAPI_MESSAGE_DISTANCE))
@@ -1620,6 +1765,7 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 			  "%s: Received SRC Prefix but afi is not v6",
 			  __func__);
 		nexthop_group_delete(&ng);
+		zebra_nhg_backup_free(&bnhg);
 		XFREE(MTYPE_RE, re);
 		return;
 	}
@@ -1631,10 +1777,28 @@ static void zread_route_add(ZAPI_HANDLER_ARGS)
 			  "%s: Received safi: %d but we can only accept UNICAST or MULTICAST",
 			  __func__, api.safi);
 		nexthop_group_delete(&ng);
+		zebra_nhg_backup_free(&bnhg);
 		XFREE(MTYPE_RE, re);
 		return;
 	}
-	ret = rib_add_multipath(afi, api.safi, &api.prefix, src_p, re, ng);
+
+	/* Include backup info with the route. We use a temporary nhe here;
+	 * if this is a new/unknown nhe, a new copy will be allocated
+	 * and stored.
+	 */
+	zebra_nhe_init(&nhe, afi, ng->nexthop);
+	nhe.nhg.nexthop = ng->nexthop;
+	nhe.backup_info = bnhg;
+	ret = rib_add_multipath_nhe(afi, api.safi, &api.prefix, src_p,
+				    re, &nhe);
+
+	/* At this point, these allocations are not needed: 're' has been
+	 * retained or freed, and if 're' still exists, it is using
+	 * a reference to a shared group object.
+	 */
+	nexthop_group_delete(&ng);
+	if (bnhg)
+		zebra_nhg_backup_free(&bnhg);
 
 	/* Stats */
 	switch (api.prefix.family) {
@@ -1766,9 +1930,11 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
 	unsigned short instance;
 	uint8_t notify;
 	uint8_t synchronous;
+	uint32_t session_id;
 
 	STREAM_GETC(msg, proto);
 	STREAM_GETW(msg, instance);
+	STREAM_GETL(msg, session_id);
 	STREAM_GETC(msg, notify);
 	STREAM_GETC(msg, synchronous);
 	if (notify)
@@ -1788,6 +1954,7 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
 
 		client->proto = proto;
 		client->instance = instance;
+		client->session_id = session_id;
 
 		/* Graceful restart processing for client connect */
 		zebra_gr_client_reconnect(client);
@@ -2031,7 +2198,7 @@ static void zread_label_manager_connect(struct zserv *client,
 	client->instance = instance;
 
 	/* call hook for connection using wrapper */
-	lm_client_connect_call(proto, instance, vrf_id);
+	lm_client_connect_call(client, vrf_id);
 
 stream_failure:
 	return;
@@ -2057,19 +2224,10 @@ static void zread_get_label_chunk(struct zserv *client, struct stream *msg,
 	STREAM_GETL(s, size);
 	STREAM_GETL(s, base);
 
-	/* call hook to get a chunk using wrapper */
-	lm_get_chunk_call(&lmc, proto, instance, keep, size, base, vrf_id);
+	assert(proto == client->proto && instance == client->instance);
 
-	if (!lmc)
-		flog_err(
-			EC_ZEBRA_LM_CANNOT_ASSIGN_CHUNK,
-			"Unable to assign Label Chunk of size %u to %s instance %u",
-			size, zebra_route_string(proto), instance);
-	else
-		if (IS_ZEBRA_DEBUG_PACKET)
-			zlog_debug("Assigned Label Chunk %u - %u to %s instance %u",
-				   lmc->start, lmc->end,
-				   zebra_route_string(proto), instance);
+	/* call hook to get a chunk using wrapper */
+	lm_get_chunk_call(&lmc, client, keep, size, base, vrf_id);
 
 stream_failure:
 	return;
@@ -2091,8 +2249,10 @@ static void zread_release_label_chunk(struct zserv *client, struct stream *msg)
 	STREAM_GETL(s, start);
 	STREAM_GETL(s, end);
 
+	assert(proto == client->proto && instance == client->instance);
+
 	/* call hook to release a chunk using wrapper */
-	lm_release_chunk_call(proto, instance, start, end);
+	lm_release_chunk_call(client, start, end);
 
 stream_failure:
 	return;