1 files changed, 294 insertions, 108 deletions

diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c
index f1c181438e..aabe533ee6 100644
--- a/zebra/zapi_msg.c
+++ b/zebra/zapi_msg.c
@@ -383,9 +383,14 @@ static void zebra_interface_nbr_address_add_update(struct interface *ifp,
 			p->prefixlen, ifc->ifp->name);
 	}
 
-	for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+	for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+		/* Do not send unsolicited messages to synchronous clients. */
+		if (client->synchronous)
+			continue;
+
 		zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_ADD,
 					    client, ifp, ifc);
+	}
 }
 
 /* Interface address deletion. */
@@ -407,9 +412,14 @@ static void zebra_interface_nbr_address_delete_update(struct interface *ifp,
 			p->prefixlen, ifc->ifp->name);
 	}
 
-	for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+	for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+		/* Do not send unsolicited messages to synchronous clients. */
+		if (client->synchronous)
+			continue;
+
 		zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_DELETE,
 					    client, ifp, ifc);
+	}
 }
 
 /* Send addresses on interface to client */
@@ -1063,7 +1073,7 @@ static void zread_rnh_register(ZAPI_HANDLER_ARGS)
 
 	if (IS_ZEBRA_DEBUG_NHT)
 		zlog_debug(
-			"rnh_register msg from client %s: hdr->length=%d, type=%s vrf=%u\n",
+			"rnh_register msg from client %s: hdr->length=%d, type=%s vrf=%u",
 			zebra_route_string(client->proto), hdr->length,
 			(type == RNH_NEXTHOP_TYPE) ? "nexthop" : "route",
 			zvrf->vrf->vrf_id);
@@ -1152,7 +1162,7 @@ static void zread_rnh_unregister(ZAPI_HANDLER_ARGS)
 
 	if (IS_ZEBRA_DEBUG_NHT)
 		zlog_debug(
-			"rnh_unregister msg from client %s: hdr->length=%d vrf: %u\n",
+			"rnh_unregister msg from client %s: hdr->length=%d vrf: %u",
 			zebra_route_string(client->proto), hdr->length,
 			zvrf->vrf->vrf_id);
 
@@ -1403,6 +1413,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;
@@ -1411,12 +1547,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) {
@@ -1430,8 +1569,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. */
@@ -1459,6 +1598,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();
 
@@ -1469,130 +1617,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);
+			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);
 			}
-			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);
-			}
-			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))
@@ -1610,6 +1766,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;
 	}
@@ -1621,10 +1778,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) {
@@ -1740,6 +1915,10 @@ void zsend_capabilities_all_clients(void)
 
 	zvrf = vrf_info_lookup(VRF_DEFAULT);
 	for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+		/* Do not send unsolicited messages to synchronous clients. */
+		if (client->synchronous)
+			continue;
+
 		zsend_capabilities(client, zvrf);
 	}
 }
@@ -1751,13 +1930,18 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
 	uint8_t proto;
 	unsigned short instance;
 	uint8_t notify;
+	uint8_t synchronous;
 
 	STREAM_GETC(msg, proto);
 	STREAM_GETW(msg, instance);
 	STREAM_GETC(msg, notify);
+	STREAM_GETC(msg, synchronous);
 	if (notify)
 		client->notify_owner = true;
 
+	if (synchronous)
+		client->synchronous = true;
+
 	/* accept only dynamic routing protocols */
 	if ((proto < ZEBRA_ROUTE_MAX) && (proto > ZEBRA_ROUTE_CONNECT)) {
 		zlog_notice(
@@ -1774,8 +1958,10 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
 		zebra_gr_client_reconnect(client);
 	}
 
-	zsend_capabilities(client, zvrf);
-	zebra_vrf_update_all(client);
+	if (!client->synchronous) {
+		zsend_capabilities(client, zvrf);
+		zebra_vrf_update_all(client);
+	}
 stream_failure:
 	return;
 }