Commit 4695b7a1d8 for frr

commit 4695b7a1d83cfa08b018af3d74526da131608f19
Author: Donald Sharp <sharpd@nvidia.com>
Date:   Thu Nov 12 10:41:15 2026 -0500

    bgpd: add accessors for EVPN ES flags

    Add bgp_attr_get_es_flags() and bgp_attr_set_es_flags() and use them
    for every read and write of the Ethernet Segment flags. Callers that
    change individual bits still apply SET_FLAG and UNSET_FLAG to the
    value from the getter.

    Signed-off-by: Donald Sharp <sharpd@nvidia.com>

diff --git a/bgpd/bgp_attr.c b/bgpd/bgp_attr.c
index c59c430cf1..b96763c206 100644
--- a/bgpd/bgp_attr.c
+++ b/bgpd/bgp_attr.c
@@ -1460,7 +1460,8 @@ bool attrhash_cmp(const void *p1, const void *p2)
 		    IPV4_ADDR_SAME(&attr1->originator_id, &attr2->originator_id) &&
 		    overlay_index_same(attr1, attr2) &&
 		    !memcmp(&attr1->esi, &attr2->esi, sizeof(esi_t)) &&
-		    attr1->es_flags == attr2->es_flags && attr1->mm_seqnum == attr2->mm_seqnum &&
+		    bgp_attr_get_es_flags(attr1) == bgp_attr_get_es_flags(attr2) &&
+		    attr1->mm_seqnum == attr2->mm_seqnum &&
 		    attr1->mm_sync_seqnum == attr2->mm_sync_seqnum &&
 		    attr1->df_pref == attr2->df_pref && attr1->df_alg == attr2->df_alg &&
 		    attr1->nh_ifindex == attr2->nh_ifindex &&
@@ -3540,7 +3541,7 @@ bgp_attr_ext_communities(struct bgp_attr_parser_args *args)
 	/* Check EVPN Neighbor advertisement flags, R-bit */
 	bgp_attr_evpn_na_flag(attr, &proxy);
 	if (proxy)
-		SET_FLAG(attr->es_flags, ATTR_ES_PROXY_ADVERT);
+		bgp_attr_set_es_flags(attr, bgp_attr_get_es_flags(attr) | ATTR_ES_PROXY_ADVERT);

 	/* Extract the Rmac, if any */
 	if (bgp_attr_rmac(attr, &attr->rmac)) {
diff --git a/bgpd/bgp_attr.h b/bgpd/bgp_attr.h
index 0eca481bc9..326e04cdbd 100644
--- a/bgpd/bgp_attr.h
+++ b/bgpd/bgp_attr.h
@@ -840,6 +840,16 @@ static inline void bgp_attr_set_originator_id(struct attr *attr, struct in_addr
 		bgp_attr_unset(attr, BGP_ATTR_ORIGINATOR_ID);
 }

+static inline uint8_t bgp_attr_get_es_flags(const struct attr *attr)
+{
+	return attr->es_flags;
+}
+
+static inline void bgp_attr_set_es_flags(struct attr *attr, uint8_t es_flags)
+{
+	attr->es_flags = es_flags;
+}
+
 static inline struct bgp_route_evpn *
 bgp_attr_get_evpn_overlay(const struct attr *attr)
 {
diff --git a/bgpd/bgp_evpn.c b/bgpd/bgp_evpn.c
index c26b14d9ed..72f0e43476 100644
--- a/bgpd/bgp_evpn.c
+++ b/bgpd/bgp_evpn.c
@@ -1459,7 +1459,7 @@ static void build_evpn_route_extcomm(struct bgpevpn *vpn, struct attr *attr, int
 		ecommunity_append_val_unchecked(ecom, &eval_tmp);
 	}

-	proxy = !!(attr->es_flags & ATTR_ES_PROXY_ADVERT);
+	proxy = !!(bgp_attr_get_es_flags(attr) & ATTR_ES_PROXY_ADVERT);
 	if (CHECK_FLAG(attr->evpn_flags, ATTR_EVPN_FLAG_ROUTER) || proxy) {
 		encode_na_flag_extcomm(&eval_tmp,
 				       CHECK_FLAG(attr->evpn_flags, ATTR_EVPN_FLAG_ROUTER), proxy);
@@ -1592,10 +1592,12 @@ enum zclient_send_status evpn_zebra_install(struct bgp *bgp, struct bgpevpn *vpn
 				 * router entry
 				 */
 				if (is_evpn_prefix_ipaddr_v6(p) &&
-				    CHECK_FLAG(pi->attr->es_flags, ATTR_ES_PEER_ROUTER))
+				    CHECK_FLAG(bgp_attr_get_es_flags(pi->attr),
+					       ATTR_ES_PEER_ROUTER))
 					SET_FLAG(flags, ZEBRA_MACIP_TYPE_ROUTER_FLAG);

-				if (!CHECK_FLAG(pi->attr->es_flags, ATTR_ES_PEER_ACTIVE))
+				if (!CHECK_FLAG(bgp_attr_get_es_flags(pi->attr),
+						ATTR_ES_PEER_ACTIVE))
 					SET_FLAG(flags, ZEBRA_MACIP_TYPE_PROXY_ADVERT);
 			} else
 				seq = mac_mobility_seqnum(pi->attr);
@@ -2196,12 +2198,10 @@ static void bgp_evpn_get_sync_info(struct bgp *bgp, esi_t *esi,
 			return;

 		/* we have a non-proxy path from the ES peer.  */
-		if (second_best_path->attr->es_flags &
-					ATTR_ES_PROXY_ADVERT) {
+		if (bgp_attr_get_es_flags(second_best_path->attr) & ATTR_ES_PROXY_ADVERT)
 			*proxy_from_peer = true;
-		} else {
+		else
 			*active_on_peer = true;
-		}

 		if (CHECK_FLAG(second_best_path->attr->evpn_flags,
 			       ATTR_EVPN_FLAG_ROUTER))
@@ -2227,6 +2227,7 @@ static void update_evpn_route_entry_sync_info(struct bgp *bgp,
 					      const struct ethaddr *mac)
 {
 	esi_t *esi;
+	uint8_t es_flags;
 	struct prefix_evpn *evp =
 		(struct prefix_evpn *)bgp_dest_get_prefix(dest);

@@ -2246,45 +2247,47 @@ static void update_evpn_route_entry_sync_info(struct bgp *bgp,
 					       &peer_router, &proxy_from_peer,
 					       mac);
 			attr->mm_sync_seqnum = max_sync_seq;
+			es_flags = bgp_attr_get_es_flags(attr);
 			if (active_on_peer)
-				SET_FLAG(attr->es_flags, ATTR_ES_PEER_ACTIVE);
+				SET_FLAG(es_flags, ATTR_ES_PEER_ACTIVE);
 			else
-				UNSET_FLAG(attr->es_flags, ATTR_ES_PEER_ACTIVE);
+				UNSET_FLAG(es_flags, ATTR_ES_PEER_ACTIVE);
 			if (proxy_from_peer)
-				SET_FLAG(attr->es_flags, ATTR_ES_PEER_PROXY);
+				SET_FLAG(es_flags, ATTR_ES_PEER_PROXY);
 			else
-				UNSET_FLAG(attr->es_flags, ATTR_ES_PEER_PROXY);
+				UNSET_FLAG(es_flags, ATTR_ES_PEER_PROXY);
 			if (peer_router)
-				SET_FLAG(attr->es_flags, ATTR_ES_PEER_ROUTER);
+				SET_FLAG(es_flags, ATTR_ES_PEER_ROUTER);
 			else
-				UNSET_FLAG(attr->es_flags, ATTR_ES_PEER_ROUTER);
+				UNSET_FLAG(es_flags, ATTR_ES_PEER_ROUTER);
+			bgp_attr_set_es_flags(attr, es_flags);

 			if (BGP_DEBUG(evpn_mh, EVPN_MH_RT)) {
 				char esi_buf[ESI_STR_LEN];

-				zlog_debug("setup sync info for %pFX es %s max_seq %d %s%s%s",
-					   evp,
-					   esi_to_str(esi, esi_buf,
-						      sizeof(esi_buf)),
-					   max_sync_seq,
-					   CHECK_FLAG(attr->es_flags,
+				zlog_debug("setup sync info for %pFX es %s max_seq %d %s%s%s", evp,
+					   esi_to_str(esi, esi_buf, sizeof(esi_buf)), max_sync_seq,
+					   CHECK_FLAG(bgp_attr_get_es_flags(attr),
 						      ATTR_ES_PEER_ACTIVE)
 						   ? "peer-active "
 						   : "",
-					   CHECK_FLAG(attr->es_flags,
+					   CHECK_FLAG(bgp_attr_get_es_flags(attr),
 						      ATTR_ES_PEER_PROXY)
 						   ? "peer-proxy "
 						   : "",
-					   CHECK_FLAG(attr->es_flags,
+					   CHECK_FLAG(bgp_attr_get_es_flags(attr),
 						      ATTR_ES_PEER_ROUTER)
 						   ? "peer-router "
 						   : "");
 			}
 		}
 	} else {
+		es_flags = bgp_attr_get_es_flags(attr);
+
 		attr->mm_sync_seqnum = 0;
-		UNSET_FLAG(attr->es_flags, ATTR_ES_PEER_ACTIVE);
-		UNSET_FLAG(attr->es_flags, ATTR_ES_PEER_PROXY);
+		UNSET_FLAG(es_flags, ATTR_ES_PEER_ACTIVE);
+		UNSET_FLAG(es_flags, ATTR_ES_PEER_PROXY);
+		bgp_attr_set_es_flags(attr, es_flags);
 	}
 }

@@ -2563,6 +2566,7 @@ static int update_evpn_route(struct bgp *bgp, struct bgpevpn *vpn,
 	bool old_is_sync = false;
 	bool mac_only = false;
 	struct ecommunity *macvrf_soo = NULL;
+	uint8_t es_flags;

 	memset(&attr, 0, sizeof(attr));

@@ -2573,19 +2577,22 @@ static int update_evpn_route(struct bgp *bgp, struct bgpevpn *vpn,
 		SET_FLAG(attr.evpn_flags, ATTR_EVPN_FLAG_STICKY);
 	if (CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW))
 		SET_FLAG(attr.evpn_flags, ATTR_EVPN_FLAG_DEFAULT_GW);
+	es_flags = bgp_attr_get_es_flags(&attr);
+
 	if (CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_ROUTER_FLAG))
 		SET_FLAG(attr.evpn_flags, ATTR_EVPN_FLAG_ROUTER);
 	if (CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_PROXY_ADVERT))
-		SET_FLAG(attr.es_flags, ATTR_ES_PROXY_ADVERT);
+		SET_FLAG(es_flags, ATTR_ES_PROXY_ADVERT);

 	if (esi && bgp_evpn_is_esi_valid(esi)) {
 		memcpy(&attr.esi, esi, sizeof(esi_t));
 		/* ES should not be marked local if ESI is in bypass */
 		if (bgp_evpn_is_esi_local_and_non_bypass(esi))
-			SET_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL);
+			SET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
 		else
-			UNSET_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL);
+			UNSET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
 	}
+	bgp_attr_set_es_flags(&attr, es_flags);

 	/* PMSI is only needed for type-3 routes */
 	if (p->prefix.route_type == BGP_EVPN_IMET_ROUTE) {
@@ -2629,7 +2636,8 @@ static int update_evpn_route(struct bgp *bgp, struct bgpevpn *vpn,
 	 * we're advertising L3VNI with these routes.
 	 */
 	add_l3_attrs = bgp_evpn_route_add_l3_attrs_ok(vpn, p,
-						      CHECK_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL)
+						      CHECK_FLAG(bgp_attr_get_es_flags(&attr),
+								 ATTR_ES_IS_LOCAL)
 							      ? &attr.esi
 							      : NULL);

@@ -2879,6 +2887,7 @@ void bgp_evpn_update_type2_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
 	int route_change;
 	bool old_is_sync = false;
 	struct ecommunity *macvrf_soo = NULL;
+	uint8_t es_flags;

 	if (CHECK_FLAG(local_pi->flags, BGP_PATH_REMOVED))
 		return;
@@ -2906,8 +2915,9 @@ void bgp_evpn_update_type2_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
 	 */
 	bgp_attr_default_set(&attr, bgp, BGP_ORIGIN_IGP);
 	bgp_evpn_vtep_ip_to_attr_nh(&vpn->originator_ip, &attr);
+	es_flags = bgp_attr_get_es_flags(local_pi->attr);
+
 	attr.evpn_flags = local_pi->attr->evpn_flags;
-	attr.es_flags = local_pi->attr->es_flags;
 	if (CHECK_FLAG(local_pi->attr->evpn_flags, ATTR_EVPN_FLAG_DEFAULT_GW)) {
 		SET_FLAG(attr.evpn_flags, ATTR_EVPN_FLAG_DEFAULT_GW);
 		if (is_evpn_prefix_ipaddr_v6(&evp))
@@ -2919,9 +2929,10 @@ void bgp_evpn_update_type2_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
 	 * The es_flags need to align with the local ES status
 	 */
 	if (bgp_evpn_is_esi_local_and_non_bypass(&attr.esi))
-		SET_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL);
+		SET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
 	else
-		UNSET_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL);
+		UNSET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
+	bgp_attr_set_es_flags(&attr, es_flags);

 	bgp_evpn_get_rmac_nexthop(vpn, &evp, &attr, local_pi->extra->evpn->af_flags);
 	vni2label(vpn->vni, &(attr.label));
@@ -2929,7 +2940,8 @@ void bgp_evpn_update_type2_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
 	 * using L3 VNI for type-2 routes also.
 	 */
 	add_l3_attrs = bgp_evpn_route_add_l3_attrs_ok(vpn, &evp,
-						      CHECK_FLAG(attr.es_flags, ATTR_ES_IS_LOCAL)
+						      CHECK_FLAG(bgp_attr_get_es_flags(&attr),
+								 ATTR_ES_IS_LOCAL)
 							      ? &attr.esi
 							      : NULL);

@@ -2943,13 +2955,11 @@ void bgp_evpn_update_type2_route_entry(struct bgp *bgp, struct bgpevpn *vpn,
 	if (bgp_debug_zebra(NULL)) {
 		char buf3[ESI_STR_LEN];

-		zlog_debug(
-			"VRF %s vni %u evp %pFX RMAC %pEA nexthop %pI4 esi %s esf 0x%x from %s",
-			vpn->bgp_vrf ? vrf_id_to_name(vpn->bgp_vrf->vrf_id)
-				     : " ",
-			vpn->vni, &evp, &attr.rmac, &attr.mp_nexthop_global_in,
-			esi_to_str(&attr.esi, buf3, sizeof(buf3)),
-			attr.es_flags, caller);
+		zlog_debug("VRF %s vni %u evp %pFX RMAC %pEA nexthop %pI4 esi %s esf 0x%x from %s",
+			   vpn->bgp_vrf ? vrf_id_to_name(vpn->bgp_vrf->vrf_id) : " ", vpn->vni,
+			   &evp, &attr.rmac, &attr.mp_nexthop_global_in,
+			   esi_to_str(&attr.esi, buf3, sizeof(buf3)), bgp_attr_get_es_flags(&attr),
+			   caller);
 	}

 	/* Update the route entry. */
@@ -3488,6 +3498,7 @@ static int install_evpn_route_entry_in_vrf(struct bgp *bgp_vrf,
 	char buf1[INET6_ADDRSTRLEN];
 	struct bgp_route_evpn *bre;
 	struct ecommunity *ecom;
+	uint8_t es_flags;

 	memset(pp, 0, sizeof(struct prefix));
 	ip_prefix_from_evpn_prefix(evp, pp);
@@ -3554,12 +3565,15 @@ static int install_evpn_route_entry_in_vrf(struct bgp *bgp_vrf,
 		}
 	}

+	es_flags = bgp_attr_get_es_flags(&attr);
+
 	bgp_evpn_es_vrf_use_nhg(bgp_vrf, &parent_pi->attr->esi, &use_l3nhg,
 				&is_l3nhg_active, NULL);
 	if (use_l3nhg)
-		SET_FLAG(attr.es_flags, ATTR_ES_L3_NHG_USE);
+		SET_FLAG(es_flags, ATTR_ES_L3_NHG_USE);
 	if (is_l3nhg_active)
-		SET_FLAG(attr.es_flags, ATTR_ES_L3_NHG_ACTIVE);
+		SET_FLAG(es_flags, ATTR_ES_L3_NHG_ACTIVE);
+	bgp_attr_set_es_flags(&attr, es_flags);

 	ecom = ecommunity_filter(bgp_attr_get_ecommunity(&attr), bgp_evpn_filter_ecommunity, NULL);
 	bgp_attr_set_ecommunity(&attr, ecom);
@@ -5438,6 +5452,7 @@ static int process_type2_route(struct peer *peer, afi_t afi, safi_t safi,
 	uint8_t num_labels = 0;
 	uint32_t eth_tag;
 	int ret = 0;
+	uint8_t es_flags;

 	/* Type-2 route should be either 33, 37 or 49 bytes or an
 	 * additional 3 bytes if there is a second label (VNI):
@@ -5471,10 +5486,12 @@ static int process_type2_route(struct peer *peer, afi_t afi, safi_t safi,
 	if (attr) {
 		STREAM_GET(&attr->esi, pkt, sizeof(esi_t));

+		es_flags = bgp_attr_get_es_flags(attr);
 		if (bgp_evpn_is_esi_local_and_non_bypass(&attr->esi))
-			SET_FLAG(attr->es_flags, ATTR_ES_IS_LOCAL);
+			SET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
 		else
-			UNSET_FLAG(attr->es_flags, ATTR_ES_IS_LOCAL);
+			UNSET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
+		bgp_attr_set_es_flags(attr, es_flags);
 	} else {
 		STREAM_FORWARD_GETP(pkt, sizeof(esi_t));
 	}
diff --git a/bgpd/bgp_evpn_mh.c b/bgpd/bgp_evpn_mh.c
index 4d89a88a4e..078c129555 100644
--- a/bgpd/bgp_evpn_mh.c
+++ b/bgpd/bgp_evpn_mh.c
@@ -2284,6 +2284,7 @@ static void bgp_evpn_mac_update_on_es_local_chg(struct bgp_evpn_es *es,
 	bool tmp_local;
 	struct attr *attr_new;
 	struct attr attr_tmp;
+	uint8_t es_flags;

 	if (BGP_DEBUG(evpn_mh, EVPN_MH_ES))
 		zlog_debug("update paths linked to es %s on chg to %s",
@@ -2299,7 +2300,7 @@ static void bgp_evpn_mac_update_on_es_local_chg(struct bgp_evpn_es *es,
 		if (!pi->attr)
 			continue;

-		tmp_local = !!(pi->attr->es_flags & ATTR_ES_IS_LOCAL);
+		tmp_local = !!(bgp_attr_get_es_flags(pi->attr) & ATTR_ES_IS_LOCAL);
 		if (tmp_local == is_local)
 			continue;

@@ -2310,10 +2311,12 @@ static void bgp_evpn_mac_update_on_es_local_chg(struct bgp_evpn_es *es,
 				is_local ? "local" : "non-local");

 		bgp_attr_dup_into(&attr_tmp, pi->attr);
+		es_flags = bgp_attr_get_es_flags(&attr_tmp);
 		if (is_local)
-			SET_FLAG(attr_tmp.es_flags, ATTR_ES_IS_LOCAL);
+			SET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
 		else
-			UNSET_FLAG(attr_tmp.es_flags, ATTR_ES_IS_LOCAL);
+			UNSET_FLAG(es_flags, ATTR_ES_IS_LOCAL);
+		bgp_attr_set_es_flags(&attr_tmp, es_flags);
 		attr_new = bgp_attr_intern(&attr_tmp);
 		bgp_attr_unintern(&pi->attr);
 		pi->attr = attr_new;
@@ -5030,7 +5033,7 @@ static void bgp_evpn_path_nh_link(struct bgp *bgp_vrf, struct bgp_path_info *pi)
 	/* if NHG is not being used for this path we don't need to manage the
 	 * nexthops in bgp (they are managed by zebra instead)
 	 */
-	if (!CHECK_FLAG(pi->attr->es_flags, ATTR_ES_L3_NHG_USE)) {
+	if (!CHECK_FLAG(bgp_attr_get_es_flags(pi->attr), ATTR_ES_L3_NHG_USE)) {
 		if (nh_info)
 			bgp_evpn_path_nh_unlink(nh_info);
 		return;
diff --git a/bgpd/bgp_evpn_mh.h b/bgpd/bgp_evpn_mh.h
index 8da9d584b5..4b363a1c0a 100644
--- a/bgpd/bgp_evpn_mh.h
+++ b/bgpd/bgp_evpn_mh.h
@@ -13,6 +13,7 @@
 #include "bgpd.h"
 #include "bgp_evpn.h"
 #include "bgp_evpn_private.h"
+#include "bgp_attr.h"

 #define BGP_EVPN_AD_ES_ETH_TAG 0xffffffff
 #define BGP_EVPN_AD_EVI_ETH_TAG 0
@@ -359,8 +360,8 @@ static inline esi_t *bgp_evpn_attr_get_esi(struct attr *attr)

 static inline bool bgp_evpn_attr_is_sync(struct attr *attr)
 {
-	return attr ? !!(attr->es_flags &
-		(ATTR_ES_PEER_PROXY | ATTR_ES_PEER_ACTIVE)) : false;
+	return attr ? !!(bgp_attr_get_es_flags(attr) & (ATTR_ES_PEER_PROXY | ATTR_ES_PEER_ACTIVE))
+		    : false;
 }

 static inline uint32_t bgp_evpn_attr_get_sync_seq(struct attr *attr)
@@ -370,24 +371,22 @@ static inline uint32_t bgp_evpn_attr_get_sync_seq(struct attr *attr)

 static inline bool bgp_evpn_attr_is_active_on_peer(struct attr *attr)
 {
-	return attr ?
-		!!(attr->es_flags & ATTR_ES_PEER_ACTIVE) : false;
+	return attr ? !!(bgp_attr_get_es_flags(attr) & ATTR_ES_PEER_ACTIVE) : false;
 }

 static inline bool bgp_evpn_attr_is_router_on_peer(struct attr *attr)
 {
-	return attr ?
-		!!(attr->es_flags & ATTR_ES_PEER_ROUTER) : false;
+	return attr ? !!(bgp_attr_get_es_flags(attr) & ATTR_ES_PEER_ROUTER) : false;
 }

 static inline bool bgp_evpn_attr_is_proxy(struct attr *attr)
 {
-	return attr ? !!(attr->es_flags & ATTR_ES_PROXY_ADVERT) : false;
+	return attr ? !!(bgp_attr_get_es_flags(attr) & ATTR_ES_PROXY_ADVERT) : false;
 }

 static inline bool bgp_evpn_attr_is_local_es(struct attr *attr)
 {
-	return attr ? !!(attr->es_flags & ATTR_ES_IS_LOCAL) : false;
+	return attr ? !!(bgp_attr_get_es_flags(attr) & ATTR_ES_IS_LOCAL) : false;
 }

 static inline bool bgp_evpn_local_es_is_active(struct bgp_evpn_es *es)
diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c
index ac72133821..a18a540786 100644
--- a/bgpd/bgp_route.c
+++ b/bgpd/bgp_route.c
@@ -13735,13 +13735,11 @@ static void route_vty_out_detail_es_info(struct vty *vty,
 					 json_object *json_path)
 {
 	char esi_buf[ESI_STR_LEN];
-	bool es_local = !!CHECK_FLAG(attr->es_flags, ATTR_ES_IS_LOCAL);
-	bool peer_router = !!CHECK_FLAG(attr->es_flags,
-			ATTR_ES_PEER_ROUTER);
-	bool peer_active = !!CHECK_FLAG(attr->es_flags,
-			ATTR_ES_PEER_ACTIVE);
-	bool peer_proxy = !!CHECK_FLAG(attr->es_flags,
-			ATTR_ES_PEER_PROXY);
+	bool es_local = !!CHECK_FLAG(bgp_attr_get_es_flags(attr), ATTR_ES_IS_LOCAL);
+	bool peer_router = !!CHECK_FLAG(bgp_attr_get_es_flags(attr), ATTR_ES_PEER_ROUTER);
+	bool peer_active = !!CHECK_FLAG(bgp_attr_get_es_flags(attr), ATTR_ES_PEER_ACTIVE);
+	bool peer_proxy = !!CHECK_FLAG(bgp_attr_get_es_flags(attr), ATTR_ES_PEER_PROXY);
+
 	esi_to_str(&attr->esi, esi_buf, sizeof(esi_buf));
 	if (json_path) {
 		json_object *json_es_info = NULL;
@@ -14026,24 +14024,23 @@ void route_vty_out_detail(struct vty *vty, struct bgp *bgp, struct bgp_dest *bn,
 						(struct prefix_evpn *)bgp_dest_get_prefix(dest),
 						has_srv6_service ? "Label" : "VNI", evpn_label_buf);
 				}
-				if (CHECK_FLAG(attr->es_flags, ATTR_ES_L3_NHG) &&
+				if (CHECK_FLAG(bgp_attr_get_es_flags(attr), ATTR_ES_L3_NHG) &&
 				    !json_paths) {
 					vty_out(vty, ", L3NHG %s",
-						CHECK_FLAG(
-							attr->es_flags,
-							ATTR_ES_L3_NHG_ACTIVE)
+						CHECK_FLAG(bgp_attr_get_es_flags(attr),
+							   ATTR_ES_L3_NHG_ACTIVE)
 							? "active"
 							: "inactive");
 					vty_out(vty, "\n");
 				} else if (json_paths) {
-					json_object_boolean_add(
-						json_path, "l3nhg",
-						CHECK_FLAG(attr->es_flags,
-							   ATTR_ES_L3_NHG));
-					json_object_boolean_add(
-						json_path, "l3nhgActive",
-						CHECK_FLAG(attr->es_flags,
-							   ATTR_ES_L3_NHG_ACTIVE));
+					json_object_boolean_add(json_path, "l3nhg",
+								CHECK_FLAG(bgp_attr_get_es_flags(
+										   attr),
+									   ATTR_ES_L3_NHG));
+					json_object_boolean_add(json_path, "l3nhgActive",
+								CHECK_FLAG(bgp_attr_get_es_flags(
+										   attr),
+									   ATTR_ES_L3_NHG_ACTIVE));
 				}
 			} else {
 				if (json_paths) {