From f8b81fed29e5ff0cbc189440774648169cc598d1 Mon Sep 17 00:00:00 2001
From: Donatas Abraitis <donatas@opensourcerouting.org>
Date: Sun, 2 Nov 2025 23:23:51 +0200
Subject: [PATCH] bgpd: Use bgp_attr_[exists/set/unset] helpers when doing attr
 stuff

This would help in the future to avoid passing bare int (constant) instead
of using ATTR_FLAG_BIT() macro.

Signed-off-by: Donatas Abraitis <donatas@opensourcerouting.org>
---
 bgpd/bgp_attr.c                      | 116 +++++++++++++--------------
 bgpd/bgp_attr.h                      |   4 +
 bgpd/bgp_debug.c                     |  34 ++++----
 bgpd/bgp_evpn.c                      |   8 +-
 bgpd/bgp_label.c                     |   5 +-
 bgpd/bgp_mpath.c                     |   2 +-
 bgpd/bgp_mplsvpn.c                   |  14 ++--
 bgpd/bgp_nexthop.c                   |  10 +--
 bgpd/bgp_route.c                     |  73 ++++++++---------
 bgpd/bgp_routemap.c                  |  21 +++--
 bgpd/bgp_snmp_bgp4v2.c               |  27 +++----
 bgpd/bgp_zebra.c                     |   2 +-
 bgpd/rfapi/vnc_export_bgp.c          |   4 +-
 tools/coccinelle/bgp_attr_flag.cocci |  14 ++++
 14 files changed, 163 insertions(+), 171 deletions(-)
 create mode 100644 tools/coccinelle/bgp_attr_flag.cocci

diff --git a/bgpd/bgp_attr.c b/bgpd/bgp_attr.c
index 15b2f15f3d5a..80ea744b0e25 100644
--- a/bgpd/bgp_attr.c
+++ b/bgpd/bgp_attr.c
@@ -1330,14 +1330,14 @@ struct attr *bgp_attr_default_set(struct attr *attr, struct bgp *bgp,
 	memset(attr, 0, sizeof(struct attr));
 
 	attr->origin = origin;
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN));
+	bgp_attr_set(attr, BGP_ATTR_ORIGIN);
 	attr->aspath = aspath_empty(bgp->asnotation);
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH));
+	bgp_attr_set(attr, BGP_ATTR_AS_PATH);
 	attr->weight = BGP_ATTR_DEFAULT_WEIGHT;
 	attr->tag = 0;
 	attr->label_index = BGP_INVALID_LABEL_INDEX;
 	attr->label = MPLS_INVALID_LABEL;
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP));
+	bgp_attr_set(attr, BGP_ATTR_NEXT_HOP);
 	attr->mp_nexthop_len = IPV6_MAX_BYTELEN;
 	attr->local_pref = bgp->default_local_pref;
 
@@ -1478,7 +1478,7 @@ void bgp_attr_unintern_sub(struct attr *attr)
 
 	/* aspath refcount shoud be decrement. */
 	aspath_unintern(&attr->aspath);
-	UNSET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH));
+	bgp_attr_unset(attr, BGP_ATTR_AS_PATH);
 
 	comm = bgp_attr_get_community(attr);
 	community_unintern(&comm);
@@ -1921,7 +1921,7 @@ bgp_attr_origin(struct bgp_attr_parser_args *args)
 	}
 
 	/* Set oring attribute flag. */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN));
+	bgp_attr_set(attr, BGP_ATTR_ORIGIN);
 
 	return 0;
 }
@@ -1973,7 +1973,7 @@ static int bgp_attr_aspath(struct bgp_attr_parser_args *args)
 	}
 
 	/* Set aspath attribute flag. */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH));
+	bgp_attr_set(attr, BGP_ATTR_AS_PATH);
 
 	return BGP_ATTR_PARSE_PROCEED;
 }
@@ -2081,7 +2081,7 @@ static int bgp_attr_as4_path(struct bgp_attr_parser_args *args,
 	}
 
 	/* Set aspath attribute flag. */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH));
+	bgp_attr_set(attr, BGP_ATTR_AS4_PATH);
 
 	return BGP_ATTR_PARSE_PROCEED;
 }
@@ -2131,7 +2131,7 @@ bgp_attr_nexthop(struct bgp_attr_parser_args *args)
 	}
 
 	attr->nexthop.s_addr = stream_get_ipv4(connection->curr);
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP));
+	bgp_attr_set(attr, BGP_ATTR_NEXT_HOP);
 
 	return BGP_ATTR_PARSE_PROCEED;
 }
@@ -2191,7 +2191,7 @@ bgp_attr_local_pref(struct bgp_attr_parser_args *args)
 	STREAM_GETL(connection->curr, attr->local_pref);
 
 	/* Set the local-pref flag. */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+	bgp_attr_set(attr, BGP_ATTR_LOCAL_PREF);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -2221,7 +2221,7 @@ static int bgp_attr_atomic(struct bgp_attr_parser_args *args)
 		goto atomic_ignore;
 
 	/* Set atomic aggregate flag. */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE));
+	bgp_attr_set(attr, BGP_ATTR_ATOMIC_AGGREGATE);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -2280,7 +2280,7 @@ static int bgp_attr_aggregator(struct bgp_attr_parser_args *args)
 			zlog_debug("%s: attributes: %s", __func__, str);
 		}
 	} else {
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR));
+		bgp_attr_set(attr, BGP_ATTR_AGGREGATOR);
 	}
 
 	return BGP_ATTR_PARSE_PROCEED;
@@ -2332,7 +2332,7 @@ bgp_attr_as4_aggregator(struct bgp_attr_parser_args *args,
 			zlog_debug("%s: attributes: %s", __func__, str);
 		}
 	} else {
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR));
+		bgp_attr_set(attr, BGP_ATTR_AS4_AGGREGATOR);
 	}
 
 	return BGP_ATTR_PARSE_PROCEED;
@@ -2524,7 +2524,7 @@ bgp_attr_originator_id(struct bgp_attr_parser_args *args)
 
 	attr->originator_id.s_addr = stream_get_ipv4(connection->curr);
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID));
+	bgp_attr_set(attr, BGP_ATTR_ORIGINATOR_ID);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -2783,7 +2783,7 @@ int bgp_mp_reach_parse(struct bgp_attr_parser_args *args,
 
 	stream_forward_getp(s, nlri_len);
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI));
+	bgp_attr_set(attr, BGP_ATTR_MP_REACH_NLRI);
 
 	return BGP_ATTR_PARSE_PROCEED;
 #undef LEN_LEFT
@@ -2836,7 +2836,7 @@ int bgp_mp_unreach_parse(struct bgp_attr_parser_args *args,
 
 	stream_forward_getp(s, withdraw_len);
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI));
+	bgp_attr_set(attr, BGP_ATTR_MP_UNREACH_NLRI);
 
 	return BGP_ATTR_PARSE_PROCEED;
 }
@@ -3123,7 +3123,7 @@ static int bgp_attr_encap(struct bgp_attr_parser_args *args)
 					  args->total);
 	}
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ENCAP));
+	bgp_attr_set(attr, BGP_ATTR_ENCAP);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -3561,7 +3561,7 @@ enum bgp_attr_parse_ret bgp_attr_prefix_sid(struct bgp_attr_parser_args *args)
 		}
 	}
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID));
+	bgp_attr_set(attr, BGP_ATTR_PREFIX_SID);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -3615,7 +3615,7 @@ bgp_attr_pmsi_tunnel(struct bgp_attr_parser_args *args)
 		}
 	}
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL));
+	bgp_attr_set(attr, BGP_ATTR_PMSI_TUNNEL);
 	bgp_attr_set_pmsi_tnl_type(attr, tnl_type);
 	stream_get(&attr->label, connection->curr, BGP_LABEL_BYTES);
 
@@ -3854,7 +3854,7 @@ static enum bgp_attr_parse_ret bgp_attr_otc(struct bgp_attr_parser_args *args)
 					  args->total);
 	}
 
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC));
+	bgp_attr_set(attr, BGP_ATTR_OTC);
 
 	return BGP_ATTR_PARSE_PROCEED;
 
@@ -3939,22 +3939,21 @@ static int bgp_attr_check(struct peer *peer, struct attr *attr,
 	    !length)
 		return BGP_ATTR_PARSE_WITHDRAW;
 
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_ORIGIN))
 		type = BGP_ATTR_ORIGIN;
 
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_AS_PATH))
 		type = BGP_ATTR_AS_PATH;
 
 	/* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present
 	 * and
 	 * NLRI is empty. We can't easily check NLRI empty here though.
 	 */
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP))
-	    && !CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP) &&
+	    !bgp_attr_exists(attr, BGP_ATTR_MP_REACH_NLRI))
 		type = BGP_ATTR_NEXT_HOP;
 
-	if (peer->sort == BGP_PEER_IBGP
-	    && !CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+	if (peer->sort == BGP_PEER_IBGP && !bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))
 		type = BGP_ATTR_LOCAL_PREF;
 
 	/* An UPDATE message that contains the MP_UNREACH_NLRI is not required
@@ -3962,8 +3961,8 @@ static int bgp_attr_check(struct peer *peer, struct attr *attr,
 	 * are present, it should. Check for any other attribute being present
 	 * instead.
 	 */
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI)) &&
-	    CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_MP_REACH_NLRI) &&
+	    bgp_attr_exists(attr, BGP_ATTR_MP_UNREACH_NLRI))
 		return type ? BGP_ATTR_PARSE_MISSING_MANDATORY
 			    : BGP_ATTR_PARSE_PROCEED;
 
@@ -4367,8 +4366,8 @@ enum bgp_attr_parse_ret bgp_attr_parse(struct peer *peer, struct attr *attr,
 	 * attribute. If such a message contains the NEXT_HOP attribute, the BGP
 	 * speaker that receives the message SHOULD ignore this attribute.
 	 */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP))
-	    && !CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP) &&
+	    !bgp_attr_exists(attr, BGP_ATTR_MP_REACH_NLRI)) {
 		if (bgp_attr_nexthop_valid(peer, attr) < 0) {
 			ret = BGP_ATTR_PARSE_ERROR;
 			goto done;
@@ -4396,9 +4395,8 @@ enum bgp_attr_parse_ret bgp_attr_parse(struct peer *peer, struct attr *attr,
 	 */
 	/* actually... this doesn't ever return failure currently, but
 	 * better safe than sorry */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH))
-	    && bgp_attr_munge_as4_attrs(peer, attr, as4_path, as4_aggregator,
-					&as4_aggregator_addr)) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AS_PATH) &&
+	    bgp_attr_munge_as4_attrs(peer, attr, as4_path, as4_aggregator, &as4_aggregator_addr)) {
 		bgp_notify_send(connection, BGP_NOTIFY_UPDATE_ERR, BGP_NOTIFY_UPDATE_MAL_ATTR);
 		ret = BGP_ATTR_PARSE_ERROR;
 		goto done;
@@ -5097,15 +5095,14 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	    && !peer_cap_enhe(peer, afi, safi)) {
 		afi_t nh_afi = BGP_NEXTHOP_AFI_FROM_NHLEN(attr->mp_nexthop_len);
 
-		if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP))) {
+		if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP)) {
 			stream_putc(s, BGP_ATTR_FLAG_TRANS);
 			stream_putc(s, BGP_ATTR_NEXT_HOP);
 			bpacket_attr_vec_arr_set_vec(vecarr, BGP_ATTR_VEC_NH, s,
 						     attr);
 			stream_putc(s, 4);
 			stream_put_ipv4(s, attr->nexthop.s_addr);
-		} else if (peer_cap_enhe(from, afi, safi) ||
-			   (nh_afi == AFI_IP6)) {
+		} else if (peer_cap_enhe(from, afi, safi) || (nh_afi == AFI_IP6)) {
 			/*
 			 * Likely this is the case when an IPv4 prefix was
 			 * received with Extended Next-hop capability in this
@@ -5127,8 +5124,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	}
 
 	/* MED attribute. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)) ||
-	    bgp->maxmed_active) {
+	if (bgp_attr_exists(attr, BGP_ATTR_MULTI_EXIT_DISC) || bgp->maxmed_active) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL);
 		stream_putc(s, BGP_ATTR_MULTI_EXIT_DISC);
 		stream_putc(s, 4);
@@ -5146,14 +5142,14 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	}
 
 	/* Atomic aggregate. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_ATOMIC_AGGREGATE)) {
 		stream_putc(s, BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_ATOMIC_AGGREGATE);
 		stream_putc(s, 0);
 	}
 
 	/* Aggregator. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AGGREGATOR)) {
 		/* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_AGGREGATOR);
@@ -5185,7 +5181,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 
 	/* Community attribute. */
 	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY) &&
-	    CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))) {
+	    bgp_attr_exists(attr, BGP_ATTR_COMMUNITIES)) {
 		struct community *comm = NULL;
 
 		comm = bgp_attr_get_community(attr);
@@ -5208,9 +5204,8 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	/*
 	 * Large Community attribute.
 	 */
-	if (CHECK_FLAG(peer->af_flags[afi][safi],
-		       PEER_FLAG_SEND_LARGE_COMMUNITY) &&
-	    CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES))) {
+	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY) &&
+	    bgp_attr_exists(attr, BGP_ATTR_LARGE_COMMUNITIES)) {
 		if (lcom_length(bgp_attr_get_lcommunity(attr)) > 255) {
 			stream_putc(s,
 				    BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
@@ -5240,8 +5235,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 		stream_putc(s, BGP_ATTR_ORIGINATOR_ID);
 		stream_putc(s, 4);
 
-		if (CHECK_FLAG(attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))
+		if (bgp_attr_exists(attr, BGP_ATTR_ORIGINATOR_ID))
 			stream_put_in_addr(s, &attr->originator_id);
 		else
 			stream_put_in_addr(s, &from->remote_id);
@@ -5272,15 +5266,13 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 
 	/* Extended IPv6/Communities attributes. */
 	if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY)) {
-		if (CHECK_FLAG(attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+		if (bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES)) {
 			struct ecommunity *ecomm = bgp_attr_get_ecommunity(attr);
 
 			bgp_packet_ecommunity_attribute(s, peer, ecomm, BGP_ATTR_EXT_COMMUNITIES);
 		}
 
-		if (CHECK_FLAG(attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES))) {
+		if (bgp_attr_exists(attr, BGP_ATTR_IPV6_EXT_COMMUNITIES)) {
 			struct ecommunity *ecomm =
 				bgp_attr_get_ipv6_ecommunity(attr);
 
@@ -5432,7 +5424,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	}
 
 	/* PMSI Tunnel */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_PMSI_TUNNEL)) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_PMSI_TUNNEL);
 		stream_putc(s, 9); // Length
@@ -5445,7 +5437,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	}
 
 	/* OTC */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_OTC)) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_OTC);
 		stream_putc(s, 4);
@@ -5453,7 +5445,7 @@ bgp_size_t bgp_packet_attribute(struct bgp *bgp, struct peer *peer, struct strea
 	}
 
 	/* AIGP */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) && AIGP_TRANSMIT_ALLOWED(peer)) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AIGP) && AIGP_TRANSMIT_ALLOWED(peer)) {
 		/* At the moment only AIGP Metric TLV exists for AIGP
 		 * attribute. If more comes in, do not forget to update
 		 * attr_len variable to include new ones.
@@ -5605,7 +5597,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* MED attribute. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_MULTI_EXIT_DISC)) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL);
 		stream_putc(s, BGP_ATTR_MULTI_EXIT_DISC);
 		stream_putc(s, 4);
@@ -5613,7 +5605,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* Local preference. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF)) {
 		stream_putc(s, BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_LOCAL_PREF);
 		stream_putc(s, 4);
@@ -5621,14 +5613,14 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* Atomic aggregate. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_ATOMIC_AGGREGATE)) {
 		stream_putc(s, BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_ATOMIC_AGGREGATE);
 		stream_putc(s, 0);
 	}
 
 	/* Aggregator. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AGGREGATOR)) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_AGGREGATOR);
 		stream_putc(s, 8);
@@ -5637,7 +5629,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* Community attribute. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_COMMUNITIES)) {
 		struct community *comm = NULL;
 
 		comm = bgp_attr_get_community(attr);
@@ -5657,7 +5649,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* Large Community attribute. */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_LARGE_COMMUNITIES)) {
 		if (lcom_length(bgp_attr_get_lcommunity(attr)) > 255) {
 			stream_putc(s,
 				    BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
@@ -5711,7 +5703,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* Prefix SID */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_PREFIX_SID)) {
 		if (attr->label_index != BGP_INVALID_LABEL_INDEX) {
 			stream_putc(s, BGP_ATTR_FLAG_OPTIONAL |
 					       BGP_ATTR_FLAG_TRANS);
@@ -5726,7 +5718,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* OTC */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_OTC)) {
 		stream_putc(s, BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS);
 		stream_putc(s, BGP_ATTR_OTC);
 		stream_putc(s, 4);
@@ -5734,7 +5726,7 @@ void bgp_dump_routes_attr(struct stream *s, struct bgp_path_info *bpi,
 	}
 
 	/* AIGP */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AIGP)) {
 		/* At the moment only AIGP Metric TLV exists for AIGP
 		 * attribute. If more comes in, do not forget to update
 		 * attr_len variable to include new ones.
@@ -5917,7 +5909,7 @@ bool route_matches_soo(struct bgp_path_info *pi, struct ecommunity *soo)
 	struct attr *attr = pi->attr;
 	struct ecommunity *ecom;
 
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES))
 		return false;
 
 	ecom = attr->ecommunity;
diff --git a/bgpd/bgp_attr.h b/bgpd/bgp_attr.h
index 85ac1de646d3..9fc7e8538484 100644
--- a/bgpd/bgp_attr.h
+++ b/bgpd/bgp_attr.h
@@ -348,6 +348,10 @@ struct transit {
 #define ATTR_FLAG_BIT(X)                                                       \
 	__builtin_choose_expr((X) >= 1 && (X) <= 64, 1ULL << ((X)-1), (void)0)
 
+#define bgp_attr_exists(attr, id) CHECK_FLAG((attr)->flag, ATTR_FLAG_BIT(id))
+#define bgp_attr_set(attr, id) SET_FLAG((attr)->flag, ATTR_FLAG_BIT(id))
+#define bgp_attr_unset(attr, id) UNSET_FLAG((attr)->flag, ATTR_FLAG_BIT(id))
+
 #define BGP_CLUSTER_LIST_LENGTH(attr)                                          \
 	(CHECK_FLAG((attr)->flag, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST))        \
 		 ? bgp_attr_get_cluster((attr))->length                        \
diff --git a/bgpd/bgp_debug.c b/bgpd/bgp_debug.c
index 5687e907bd37..c86cca6aaca4 100644
--- a/bgpd/bgp_debug.c
+++ b/bgpd/bgp_debug.c
@@ -406,10 +406,10 @@ bool bgp_dump_attr(struct attr *attr, char *buf, size_t size)
 
 	buf[0] = '\0';
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)))
+	if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP))
 		snprintfrr(buf, size, "nexthop %pI4", &attr->nexthop);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN)))
+	if (bgp_attr_exists(attr, BGP_ATTR_ORIGIN))
 		snprintf(buf + strlen(buf), size - strlen(buf), ", origin %s",
 			 bgp_origin_str[attr->origin]);
 
@@ -426,54 +426,54 @@ bool bgp_dump_attr(struct attr *attr, char *buf, size_t size)
 	if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4)
 		snprintfrr(buf, size, "nexthop %pI4", &attr->nexthop);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+	if (bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", localpref %u", attr->local_pref);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)))
+	if (bgp_attr_exists(attr, BGP_ATTR_AIGP))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", aigp-metric %" PRIu64,
 			 (unsigned long long)bgp_attr_get_aigp_metric(attr));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+	if (bgp_attr_exists(attr, BGP_ATTR_MULTI_EXIT_DISC))
 		snprintf(buf + strlen(buf), size - strlen(buf), ", metric %u",
 			 attr->med);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)))
+	if (bgp_attr_exists(attr, BGP_ATTR_COMMUNITIES))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", community %s",
 			 community_str(bgp_attr_get_community(attr), false,
 				       true));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES)))
+	if (bgp_attr_exists(attr, BGP_ATTR_LARGE_COMMUNITIES))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", large-community %s",
 			 lcommunity_str(bgp_attr_get_lcommunity(attr), false,
 					true));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
+	if (bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", extcommunity %s",
 			 ecommunity_str(bgp_attr_get_ecommunity(attr)));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES)))
+	if (bgp_attr_exists(attr, BGP_ATTR_IPV6_EXT_COMMUNITIES))
 		snprintf(buf + strlen(buf), size - strlen(buf), ", ipv6-extcommunity %s",
 			 ecommunity_str(bgp_attr_get_ipv6_ecommunity(attr)));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+	if (bgp_attr_exists(attr, BGP_ATTR_ATOMIC_AGGREGATE))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", atomic-aggregate");
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+	if (bgp_attr_exists(attr, BGP_ATTR_AGGREGATOR))
 		snprintfrr(buf + strlen(buf), size - strlen(buf),
 			   ", aggregated by %u %pI4", attr->aggregator_as,
 			   &attr->aggregator_addr);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))
+	if (bgp_attr_exists(attr, BGP_ATTR_ORIGINATOR_ID))
 		snprintfrr(buf + strlen(buf), size - strlen(buf),
 			   ", originator %pI4", &attr->originator_id);
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_CLUSTER_LIST)) {
 		struct cluster_list *cluster;
 		int i;
 
@@ -486,21 +486,21 @@ bool bgp_dump_attr(struct attr *attr, char *buf, size_t size)
 				   " %pI4", &cluster->list[i]);
 	}
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL)))
+	if (bgp_attr_exists(attr, BGP_ATTR_PMSI_TUNNEL))
 		snprintf(buf + strlen(buf), size - strlen(buf),
 			 ", pmsi tnltype %u", bgp_attr_get_pmsi_tnl_type(attr));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH)))
+	if (bgp_attr_exists(attr, BGP_ATTR_AS_PATH))
 		snprintf(buf + strlen(buf), size - strlen(buf), ", path %s",
 			 aspath_print(attr->aspath));
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_PREFIX_SID)) {
 		if (attr->label_index != BGP_INVALID_LABEL_INDEX)
 			snprintf(buf + strlen(buf), size - strlen(buf),
 				 ", label-index %u", attr->label_index);
 	}
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NHC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_NHC)) {
 		struct bgp_nhc_tlv *tlv;
 		struct bgp_nhc *nhc = bgp_attr_get_nhc(attr);
 
diff --git a/bgpd/bgp_evpn.c b/bgpd/bgp_evpn.c
index e15af2f34d58..dfe9d19a2d20 100644
--- a/bgpd/bgp_evpn.c
+++ b/bgpd/bgp_evpn.c
@@ -3779,7 +3779,7 @@ static int is_route_matching_for_vrf(struct bgp *bgp_vrf,
 
 	assert(attr);
 	/* Route should have valid RT to be even considered. */
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES))
 		return 0;
 
 	ecom = bgp_attr_get_ecommunity(attr);
@@ -3846,7 +3846,7 @@ static int is_route_matching_for_vni(struct bgp *bgp, struct bgpevpn *vpn,
 
 	assert(attr);
 	/* Route should have valid RT to be even considered. */
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES))
 		return 0;
 
 	ecom = bgp_attr_get_ecommunity(attr);
@@ -4415,7 +4415,7 @@ static int bgp_evpn_install_uninstall_table(struct bgp *bgp, afi_t afi,
 		return 0;
 
 	/* If we don't have Route Target, nothing much to do. */
-	if (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)))
+	if (!bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES))
 		return 0;
 
 	/* EAD prefix in the global table doesn't include the VTEP-IP so
@@ -5045,7 +5045,7 @@ static int process_type3_route(struct peer *peer, afi_t afi, safi_t safi,
 	 * Note: We just simply ignore the values as it is not clear if
 	 * doing anything else is better.
 	 */
-	if (attr && CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL))) {
+	if (attr && bgp_attr_exists(attr, BGP_ATTR_PMSI_TUNNEL)) {
 		enum pta_type pmsi_tnl_type = bgp_attr_get_pmsi_tnl_type(attr);
 
 		if (pmsi_tnl_type != PMSI_TNLTYPE_INGR_REPL
diff --git a/bgpd/bgp_label.c b/bgpd/bgp_label.c
index 0eef10f752f1..dd6cdcd5bee7 100644
--- a/bgpd/bgp_label.c
+++ b/bgpd/bgp_label.c
@@ -374,9 +374,8 @@ void bgp_reg_dereg_for_label(struct bgp_dest *dest, struct bgp_path_info *pi,
 		 * Determine if we will let zebra should derive label from
 		 * label index instead of bgpd requesting from label pool
 		 */
-		if (CHECK_FLAG(pi->attr->flag,
-			    ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID))
-			&& pi->attr->label_index != BGP_INVALID_LABEL_INDEX) {
+		if (bgp_attr_exists(pi->attr, BGP_ATTR_PREFIX_SID) &&
+		    pi->attr->label_index != BGP_INVALID_LABEL_INDEX) {
 			with_label_index = true;
 			UNSET_FLAG(dest->flags, BGP_NODE_LABEL_REQUESTED);
 		} else {
diff --git a/bgpd/bgp_mpath.c b/bgpd/bgp_mpath.c
index c54cfd59953c..ce431f1240fb 100644
--- a/bgpd/bgp_mpath.c
+++ b/bgpd/bgp_mpath.c
@@ -373,7 +373,7 @@ enum bgp_wecmp_behavior bgp_path_info_mpath_chkwtd(struct bgp *bgp, struct bgp_p
 	 * characteristic and do weighted ECMP based on that.
 	 */
 	if (bgp->lb_handling == BGP_LINK_BW_IGNORE_BW) {
-		if (CHECK_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NHC)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_NHC))
 			return BGP_WECMP_BEHAVIOR_NNHN_COUNT;
 	}
 
diff --git a/bgpd/bgp_mplsvpn.c b/bgpd/bgp_mplsvpn.c
index 550eb5d2acc8..3b277c188641 100644
--- a/bgpd/bgp_mplsvpn.c
+++ b/bgpd/bgp_mplsvpn.c
@@ -1297,10 +1297,8 @@ leak_update(struct bgp *to_bgp, struct bgp_dest *bn,
 		 * route-map test permit 10
 		 *   set extcommunity rt none
 		 */
-		if (CHECK_FLAG(bpi->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) &&
-		    CHECK_FLAG(new_attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+		if (bgp_attr_exists(bpi->attr, BGP_ATTR_EXT_COMMUNITIES) &&
+		    bgp_attr_exists(new_attr, BGP_ATTR_EXT_COMMUNITIES)) {
 			if (!ecommunity_cmp(
 				    bgp_attr_get_ecommunity(bpi->attr),
 				    bgp_attr_get_ecommunity(new_attr))) {
@@ -1618,9 +1616,8 @@ vpn_leak_from_vrf_get_per_nexthop_label(afi_t afi, struct bgp_path_info *pi,
 			      bpi_ultimate->type == ZEBRA_ROUTE_BGP;
 
 	if (is_bgp_static_route == false && afi == AFI_IP &&
-	    CHECK_FLAG(pi->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)) &&
-	    (pi->attr->nexthop.s_addr == INADDR_ANY ||
-	     !ipv4_unicast_valid(&pi->attr->nexthop))) {
+	    bgp_attr_exists(pi->attr, BGP_ATTR_NEXT_HOP) &&
+	    (pi->attr->nexthop.s_addr == INADDR_ANY || !ipv4_unicast_valid(&pi->attr->nexthop))) {
 		/* IPv4 nexthop in standard BGP encoding format.
 		 * Format of address is not valid (not any, not unicast).
 		 * Fallback to the per VRF label.
@@ -4398,8 +4395,7 @@ bool bgp_mplsvpn_path_uses_valid_mpls_label(struct bgp_path_info *pi)
 		/* srv6 sid */
 		return false;
 
-	if (pi->attr &&
-	    CHECK_FLAG(pi->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID)) &&
+	if (pi->attr && bgp_attr_exists(pi->attr, BGP_ATTR_PREFIX_SID) &&
 	    pi->attr->label_index != BGP_INVALID_LABEL_INDEX)
 		/* prefix_sid attribute */
 		return false;
diff --git a/bgpd/bgp_nexthop.c b/bgpd/bgp_nexthop.c
index 33a18d0e1246..e7e77ee7d56b 100644
--- a/bgpd/bgp_nexthop.c
+++ b/bgpd/bgp_nexthop.c
@@ -539,7 +539,7 @@ bool bgp_nexthop_self(struct bgp *bgp, afi_t afi, uint8_t type,
 			tmp_addr.p.prefixlen = p->prefixlen;
 		} else {
 			/* Here we need to find out which nexthop to be used*/
-			if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP))) {
+			if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP)) {
 				tmp_addr.p.u.prefix4 = attr->nexthop;
 				tmp_addr.p.prefixlen = IPV4_MAX_BITLEN;
 			} else if ((attr->mp_nexthop_len) &&
@@ -574,16 +574,16 @@ bool bgp_nexthop_self(struct bgp *bgp, afi_t afi, uint8_t type,
 		SET_IPADDR_V4(&tmp_tip.addr);
 		IPV4_ADDR_COPY(&tmp_tip.addr.ipaddr_v4, &attr->nexthop);
 
-		if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP))) {
+		if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP)) {
 			IPV4_ADDR_COPY(&tmp_tip.addr.ipaddr_v4, &attr->nexthop);
 		} else if ((attr->mp_nexthop_len) &&
 			   ((attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4) ||
 			    (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV4))) {
 			IPV4_ADDR_COPY(&tmp_tip.addr.ipaddr_v4, &attr->mp_nexthop_global_in);
 		} else if ((attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) ||
-					(attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) ||
-					(attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL) ||
-					(attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL)) {
+			   (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) ||
+			   (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL) ||
+			   (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL)) {
 			SET_IPADDR_V6(&tmp_tip.addr);
 			IPV6_ADDR_COPY(&tmp_tip.addr.ipaddr_v6, &attr->mp_nexthop_global);
 		}
diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c
index f4e3158f1d6e..68cae3e6273c 100644
--- a/bgpd/bgp_route.c
+++ b/bgpd/bgp_route.c
@@ -672,7 +672,7 @@ static bool use_bgp_med_value(struct attr *attr, struct bgp *bgp)
    missing-as-worst" is specified, treat it as the worst value. */
 uint32_t bgp_med_value(struct attr *attr, struct bgp *bgp)
 {
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+	if (bgp_attr_exists(attr, BGP_ATTR_MULTI_EXIT_DISC))
 		return attr->med;
 	else {
 		if (CHECK_FLAG(bgp->flags, BGP_FLAG_MED_MISSING_AS_WORST))
@@ -1022,9 +1022,9 @@ int bgp_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
 	/* 2. Local preference check. */
 	new_pref = exist_pref = bgp->default_local_pref;
 
-	if (CHECK_FLAG(newattr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+	if (bgp_attr_exists(newattr, BGP_ATTR_LOCAL_PREF))
 		new_pref = newattr->local_pref;
-	if (CHECK_FLAG(existattr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+	if (bgp_attr_exists(existattr, BGP_ATTR_LOCAL_PREF))
 		exist_pref = existattr->local_pref;
 
 	if (new_pref > exist_pref) {
@@ -1064,10 +1064,10 @@ int bgp_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
 		bool exist_accept_own = false;
 		uint32_t accept_own = COMMUNITY_ACCEPT_OWN;
 
-		if (CHECK_FLAG(newattr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)))
+		if (bgp_attr_exists(newattr, BGP_ATTR_COMMUNITIES))
 			new_accept_own = community_include(
 				bgp_attr_get_community(newattr), accept_own);
-		if (CHECK_FLAG(existattr->flag, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)))
+		if (bgp_attr_exists(existattr, BGP_ATTR_COMMUNITIES))
 			exist_accept_own = community_include(
 				bgp_attr_get_community(existattr), accept_own);
 
@@ -1116,8 +1116,7 @@ int bgp_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
 	}
 
 	/* 3.5. Tie-breaker - AIGP (Metric TLV) attribute */
-	if (CHECK_FLAG(newattr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) &&
-	    CHECK_FLAG(existattr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) &&
+	if (bgp_attr_exists(newattr, BGP_ATTR_AIGP) && bgp_attr_exists(existattr, BGP_ATTR_AIGP) &&
 	    CHECK_FLAG(bgp->flags, BGP_FLAG_COMPARE_AIGP)) {
 		uint64_t new_aigp = bgp_aigp_metric_total(new);
 		uint64_t exist_aigp = bgp_aigp_metric_total(exist);
@@ -1523,11 +1522,11 @@ int bgp_path_info_cmp(struct bgp *bgp, struct bgp_path_info *new,
 	 * be 0 and would always win over the other path. If originator id is
 	 * used for the comparison, it will decide which path is better.
 	 */
-	if (CHECK_FLAG(newattr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))
+	if (bgp_attr_exists(newattr, BGP_ATTR_ORIGINATOR_ID))
 		new_id.s_addr = newattr->originator_id.s_addr;
 	else
 		new_id.s_addr = peer_new->remote_id.s_addr;
-	if (CHECK_FLAG(existattr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))
+	if (bgp_attr_exists(existattr, BGP_ATTR_ORIGINATOR_ID))
 		exist_id.s_addr = existattr->originator_id.s_addr;
 	else
 		exist_id.s_addr = peer_exist->remote_id.s_addr;
@@ -1836,7 +1835,7 @@ static bool bgp_cluster_filter(struct peer *peer, struct attr *attr)
 
 static bool bgp_otc_filter(struct peer *peer, struct attr *attr)
 {
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_OTC)) {
 		if (peer->local_role == ROLE_PROVIDER ||
 		    peer->local_role == ROLE_RS_SERVER)
 			return true;
@@ -1847,7 +1846,7 @@ static bool bgp_otc_filter(struct peer *peer, struct attr *attr)
 	if (peer->local_role == ROLE_CUSTOMER ||
 	    peer->local_role == ROLE_PEER ||
 	    peer->local_role == ROLE_RS_CLIENT) {
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC));
+		bgp_attr_set(attr, BGP_ATTR_OTC);
 		attr->otc = peer->as;
 	}
 	return false;
@@ -1855,7 +1854,7 @@ static bool bgp_otc_filter(struct peer *peer, struct attr *attr)
 
 static bool bgp_otc_egress(struct peer *peer, struct attr *attr)
 {
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_OTC)) {
 		if (peer->local_role == ROLE_CUSTOMER ||
 		    peer->local_role == ROLE_RS_CLIENT ||
 		    peer->local_role == ROLE_PEER)
@@ -1865,7 +1864,7 @@ static bool bgp_otc_egress(struct peer *peer, struct attr *attr)
 	if (peer->local_role == ROLE_PROVIDER ||
 	    peer->local_role == ROLE_PEER ||
 	    peer->local_role == ROLE_RS_SERVER) {
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_OTC));
+		bgp_attr_set(attr, BGP_ATTR_OTC);
 		attr->otc = peer->bgp->as;
 	}
 	return false;
@@ -2117,7 +2116,7 @@ void bgp_attr_add_gshut_community(struct attr *attr)
 
 	/* When we add the graceful-shutdown community we must also
 	 * lower the local-preference */
-	SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+	bgp_attr_set(attr, BGP_ATTR_LOCAL_PREF);
 	attr->local_pref = BGP_GSHUT_LOCAL_PREF;
 }
 
@@ -2327,7 +2326,7 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 
 	/* If the attribute has originator-id and it is same as remote
 	   peer's id. */
-	if (onlypeer && (CHECK_FLAG(piattr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))) &&
+	if (onlypeer && (bgp_attr_exists(piattr, BGP_ATTR_ORIGINATOR_ID)) &&
 	    (IPV4_ADDR_SAME(&onlypeer->remote_id, &piattr->originator_id))) {
 		if (bgp_debug_update(NULL, p, subgrp->update_group, 0))
 			zlog_debug(
@@ -2447,22 +2446,22 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 
 	/* If local-preference is not set. */
 	if ((peer->sort == BGP_PEER_IBGP || peer->sort == BGP_PEER_CONFED) &&
-	    (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))) {
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+	    (!bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))) {
+		bgp_attr_set(attr, BGP_ATTR_LOCAL_PREF);
 		attr->local_pref = bgp->default_local_pref;
 	}
 
 	/* If originator-id is not set and the route is to be reflected,
 	   set the originator id */
-	if (ibgp_to_ibgp && (!CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))) {
+	if (ibgp_to_ibgp && (!bgp_attr_exists(attr, BGP_ATTR_ORIGINATOR_ID))) {
 		IPV4_ADDR_COPY(&(attr->originator_id), &(from->remote_id));
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID));
+		bgp_attr_set(attr, BGP_ATTR_ORIGINATOR_ID);
 	}
 
 	/* Remove MED if its an EBGP peer - will get overwritten by route-maps
 	 */
 	if (peer->sort == BGP_PEER_EBGP && peer->sub_sort != BGP_PEER_EBGP_OAD &&
-	    CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC))) {
+	    bgp_attr_exists(attr, BGP_ATTR_MULTI_EXIT_DISC)) {
 		if (from != bgp->peer_self && !transparent
 		    && !CHECK_FLAG(peer->af_flags[afi][safi],
 				   PEER_FLAG_MED_UNCHANGED))
@@ -2672,7 +2671,7 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 		 * The ATOMIC_AGGREGATE Path Attribute is subsequently attached
 		 * to the BGP route, if AS_SETs are dropped.
 		 */
-		SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE));
+		bgp_attr_set(attr, BGP_ATTR_ATOMIC_AGGREGATE);
 	}
 
 	/* If neighbor soo is configured, then check if the route has
@@ -2680,7 +2679,7 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 	 * one. If they match, do not announce, to prevent routing
 	 * loops.
 	 */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) && peer->soo[afi][safi]) {
+	if (bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES) && peer->soo[afi][safi]) {
 		struct ecommunity *ecomm_soo = peer->soo[afi][safi];
 		struct ecommunity *ecomm = bgp_attr_get_ecommunity(attr);
 
@@ -2707,7 +2706,7 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 		if (peer->sort == BGP_PEER_IBGP ||
 		    peer->sort == BGP_PEER_CONFED ||
 		    peer->sub_sort == BGP_PEER_EBGP_OAD) {
-			SET_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+			bgp_attr_set(attr, BGP_ATTR_LOCAL_PREF);
 			attr->local_pref = BGP_GSHUT_LOCAL_PREF;
 		} else {
 			bgp_attr_add_gshut_community(attr);
@@ -2889,7 +2888,7 @@ bool subgroup_announce_check(struct bgp_dest *dest, struct bgp_path_info *pi,
 	 * EBGP. Note in route reflection the nexthop is usually unmodified
 	 * and the AIGP should not be adjusted in that case.
 	 */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AIGP)) && AIGP_TRANSMIT_ALLOWED(peer)) {
+	if (bgp_attr_exists(attr, BGP_ATTR_AIGP) && AIGP_TRANSMIT_ALLOWED(peer)) {
 		if (nh_reset ||
 		    CHECK_FLAG(attr->rmap_change_flags, BATTR_RMAP_NEXTHOP_PEER_ADDRESS)) {
 			uint64_t aigp = bgp_aigp_metric_total(pi);
@@ -4907,7 +4906,7 @@ bool bgp_update_martian_nexthop(struct bgp *bgp, afi_t afi, safi_t safi,
 	 * and we MUST check if at least one of them is valid.
 	 * E.g.: IPv6 prefix can be with nexthop: 0.0.0.0, and mp_nexthop: fc00::1.
 	 */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP)))
+	if (bgp_attr_exists(attr, BGP_ATTR_NEXT_HOP))
 		nh_invalid = (attr->nexthop.s_addr == INADDR_ANY ||
 			      !ipv4_unicast_valid(&attr->nexthop) ||
 			      bgp_nexthop_self(bgp, afi, type, stype, attr, dest));
@@ -5280,7 +5279,7 @@ void bgp_update(struct peer *peer, const struct prefix *p, uint32_t addpath_id,
 	 */
 	bool accept_own = false;
 
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) &&
+	if (bgp_attr_exists(attr, BGP_ATTR_ORIGINATOR_ID) &&
 	    IPV4_ADDR_SAME(&bgp->router_id, &attr->originator_id)) {
 		accept_own =
 			bgp_accept_own(peer, afi, safi, attr, p, &sub_type);
@@ -5348,7 +5347,7 @@ void bgp_update(struct peer *peer, const struct prefix *p, uint32_t addpath_id,
 	/* If the route has Node Target Extended Communities, check
 	 * if it's allowed to be installed locally.
 	 */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+	if (bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES)) {
 		struct ecommunity *ecomm = bgp_attr_get_ecommunity(attr);
 
 		if (ecommunity_lookup(ecomm, ECOMMUNITY_ENCODE_IP,
@@ -5664,8 +5663,8 @@ void bgp_update(struct peer *peer, const struct prefix *p, uint32_t addpath_id,
 		 */
 		if (((safi == SAFI_EVPN) || (safi == SAFI_MPLS_VPN))
 		    && !same_attr) {
-			if (CHECK_FLAG(pi->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES)) &&
-			    CHECK_FLAG(attr_new->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+			if (bgp_attr_exists(pi->attr, BGP_ATTR_EXT_COMMUNITIES) &&
+			    bgp_attr_exists(attr_new, BGP_ATTR_EXT_COMMUNITIES)) {
 				int cmp;
 
 				cmp = ecommunity_cmp(
@@ -9023,7 +9022,7 @@ bool bgp_aggregate_route(struct bgp *bgp, const struct prefix *p, afi_t afi,
 			if (BGP_PATH_HOLDDOWN(pi))
 				continue;
 
-			if (CHECK_FLAG(pi->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+			if (bgp_attr_exists(pi->attr, BGP_ATTR_ATOMIC_AGGREGATE))
 				atomic_aggregate = 1;
 
 			if (pi->sub_type == BGP_ROUTE_AGGREGATE)
@@ -10881,7 +10880,7 @@ void route_vty_out(struct vty *vty, const struct prefix *p,
 	}
 
 	/* Local Pref */
-	if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+	if (bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))
 		if (json_paths)
 			json_object_int_add(json_path, "locPrf",
 					    attr->local_pref);
@@ -10921,8 +10920,7 @@ void route_vty_out(struct vty *vty, const struct prefix *p,
 					esi_to_str(&attr->esi,
 					esi_buf, sizeof(esi_buf)));
 		}
-		if (safi == SAFI_EVPN &&
-		    CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+		if (safi == SAFI_EVPN && bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES)) {
 			json_ext_community = json_object_new_object();
 			json_object_string_add(
 				json_ext_community, "string",
@@ -10976,7 +10974,7 @@ void route_vty_out(struct vty *vty, const struct prefix *p,
 
 				vty_out(vty, "\n");
 			}
-			if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES))) {
+			if (bgp_attr_exists(attr, BGP_ATTR_EXT_COMMUNITIES)) {
 				vty_out(vty, "%*s", 20, " ");
 				vty_out(vty, "%s\n",
 					bgp_attr_get_ecommunity(attr)->str);
@@ -11058,7 +11056,7 @@ void route_vty_out_tmp(struct vty *vty, struct bgp *bgp, struct bgp_dest *dest,
 				json_object_int_add(json_net, "metric", value);
 			}
 
-			if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+			if (bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))
 				json_object_int_add(json_net, "locPrf",
 						    attr->local_pref);
 
@@ -11109,7 +11107,7 @@ void route_vty_out_tmp(struct vty *vty, struct bgp *bgp, struct bgp_dest *dest,
 			else
 				vty_out(vty, "          ");
 
-			if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+			if (bgp_attr_exists(attr, BGP_ATTR_LOCAL_PREF))
 				vty_out(vty, "%7u", attr->local_pref);
 			else
 				vty_out(vty, "       ");
@@ -14994,8 +14992,7 @@ static void bgp_table_stats_rn(struct bgp_dest *dest, struct bgp_dest *top,
 	for (pi = bgp_dest_get_bgp_path_info(dest); pi; pi = pi->next) {
 		ts->counts[BGP_STATS_RIB]++;
 
-		if (CHECK_FLAG(pi->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+		if (bgp_attr_exists(pi->attr, BGP_ATTR_ATOMIC_AGGREGATE))
 			ts->counts[BGP_STATS_AGGREGATES]++;
 
 		if (pi->peer == ts->table->bgp->peer_self) {
diff --git a/bgpd/bgp_routemap.c b/bgpd/bgp_routemap.c
index 0747cfbb7ceb..35f8cf42e31b 100644
--- a/bgpd/bgp_routemap.c
+++ b/bgpd/bgp_routemap.c
@@ -470,11 +470,10 @@ route_match_script(void *rule, const struct prefix *prefix, void *object)
 
 		path->attr->med = newattr.med;
 
-		if (CHECK_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_LOCAL_PREF))
 			locpref = path->attr->local_pref;
 		if (locpref != newattr.local_pref) {
-			SET_FLAG(path->attr->flag,
-				 ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+			bgp_attr_set(path->attr, BGP_ATTR_LOCAL_PREF);
 			path->attr->local_pref = newattr.local_pref;
 		}
 		break;
@@ -2201,7 +2200,7 @@ route_set_ip_nexthop(void *rule, const struct prefix *prefix, void *object)
 		    peer->connection->su_remote &&
 		    sockunion_family(peer->connection->su_remote) == AF_INET) {
 			path->attr->nexthop.s_addr = sockunion2ip(peer->connection->su_remote);
-			SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP));
+			bgp_attr_set(path->attr, BGP_ATTR_NEXT_HOP);
 		} else if (CHECK_FLAG(peer->rmap_type, PEER_RMAP_TYPE_OUT)) {
 			/* The next hop value will be set as part of
 			 * packet rewrite.  Set the flags here to indicate
@@ -2214,7 +2213,7 @@ route_set_ip_nexthop(void *rule, const struct prefix *prefix, void *object)
 		}
 	} else {
 		/* Set next hop value. */
-		SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP));
+		bgp_attr_set(path->attr, BGP_ATTR_NEXT_HOP);
 		path->attr->nexthop = *rins->address;
 		SET_FLAG(path->attr->rmap_change_flags,
 			 BATTR_RMAP_IPV4_NHOP_CHANGED);
@@ -2348,7 +2347,7 @@ route_set_local_pref(void *rule, const struct prefix *prefix, void *object)
 	if (path->attr->local_pref)
 		locpref = path->attr->local_pref;
 
-	SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF));
+	bgp_attr_set(path->attr, BGP_ATTR_LOCAL_PREF);
 	path->attr->local_pref = route_value_adjust(rv, locpref, path);
 
 	return RMAP_OKAY;
@@ -2423,7 +2422,7 @@ route_set_metric(void *rule, const struct prefix *prefix, void *object)
 	rv = rule;
 	path = object;
 
-	if (CHECK_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+	if (bgp_attr_exists(path->attr, BGP_ATTR_MULTI_EXIT_DISC))
 		med = path->attr->med;
 
 	bgp_attr_set_med(path->attr, route_value_adjust(rv, med, path));
@@ -3625,7 +3624,7 @@ route_set_atomic_aggregate(void *rule, const struct prefix *pfx, void *object)
 	struct bgp_path_info *path;
 
 	path = object;
-	SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE));
+	bgp_attr_set(path->attr, BGP_ATTR_ATOMIC_AGGREGATE);
 
 	return RMAP_OKAY;
 }
@@ -3703,7 +3702,7 @@ route_set_aggregator_as(void *rule, const struct prefix *prefix, void *object)
 
 	path->attr->aggregator_as = aggregator->as;
 	path->attr->aggregator_addr = aggregator->address;
-	SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR));
+	bgp_attr_set(path->attr, BGP_ATTR_AGGREGATOR);
 
 	return RMAP_OKAY;
 }
@@ -3783,7 +3782,7 @@ route_set_label_index(void *rule, const struct prefix *prefix, void *object)
 	label_index = rv->value;
 	if (label_index) {
 		path->attr->label_index = label_index;
-		SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID));
+		bgp_attr_set(path->attr, BGP_ATTR_PREFIX_SID);
 	}
 
 	return RMAP_OKAY;
@@ -4450,7 +4449,7 @@ route_set_originator_id(void *rule, const struct prefix *prefix, void *object)
 	address = rule;
 	path = object;
 
-	SET_FLAG(path->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID));
+	bgp_attr_set(path->attr, BGP_ATTR_ORIGINATOR_ID);
 	path->attr->originator_id = *address;
 
 	return RMAP_OKAY;
diff --git a/bgpd/bgp_snmp_bgp4v2.c b/bgpd/bgp_snmp_bgp4v2.c
index 724eefe60108..399d660db167 100644
--- a/bgpd/bgp_snmp_bgp4v2.c
+++ b/bgpd/bgp_snmp_bgp4v2.c
@@ -824,8 +824,7 @@ static uint8_t *bgp4v2PathAttrTable(struct variable *v, oid name[],
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_CALC_LOCAL_PREF:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_LOCAL_PREF))
 			return SNMP_INTEGER(path->attr->local_pref);
 		else
 			return SNMP_INTEGER(0);
@@ -878,50 +877,42 @@ static uint8_t *bgp4v2PathAttrTable(struct variable *v, oid name[],
 		/* Not properly defined in specification what should be here. */
 		break;
 	case BGP4V2_NLRI_LOCAL_PREF_PRESENT:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_LOCAL_PREF))
 			return SNMP_INTEGER(1);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_LOCAL_PREF:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_LOCAL_PREF))
 			return SNMP_INTEGER(path->attr->local_pref);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_MED_PRESENT:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_MULTI_EXIT_DISC))
 			return SNMP_INTEGER(1);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_MED:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_MULTI_EXIT_DISC))
 			return SNMP_INTEGER(path->attr->med);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_ATOMIC_AGGREGATE:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_ATOMIC_AGGREGATE))
 			return SNMP_INTEGER(1);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_AGGREGATOR_PRESENT:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_AGGREGATOR))
 			return SNMP_INTEGER(1);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_AGGREGATOR_AS:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_AGGREGATOR))
 			return SNMP_INTEGER(path->attr->aggregator_as);
 		else
 			return SNMP_INTEGER(0);
 	case BGP4V2_NLRI_AGGREGATOR_ADDR:
-		if (CHECK_FLAG(path->attr->flag,
-			       ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
+		if (bgp_attr_exists(path->attr, BGP_ATTR_AGGREGATOR))
 			return SNMP_IPADDRESS(path->attr->aggregator_addr);
 		else
 			return SNMP_IPADDRESS(bgp_empty_addr);
diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c
index 6869045a5806..b8fb4e8cafe2 100644
--- a/bgpd/bgp_zebra.c
+++ b/bgpd/bgp_zebra.c
@@ -1323,7 +1323,7 @@ static void bgp_zebra_announce_parse_nexthop(
 							 &nh_weight))
 				continue;
 		} else if (do_wt_ecmp == BGP_WECMP_BEHAVIOR_NNHN_COUNT) {
-			if (CHECK_FLAG(mpinfo->attr->flag, ATTR_FLAG_BIT(BGP_ATTR_NHC)))
+			if (bgp_attr_exists(mpinfo->attr, BGP_ATTR_NHC))
 				nh_weight = bgp_nhc_nnhn_count(bgp_attr_get_nhc(mpinfo->attr));
 		}
 		api_nh = &api->nexthops[*valid_nh_count];
diff --git a/bgpd/rfapi/vnc_export_bgp.c b/bgpd/rfapi/vnc_export_bgp.c
index 0fd1264ac80b..40c995c13653 100644
--- a/bgpd/rfapi/vnc_export_bgp.c
+++ b/bgpd/rfapi/vnc_export_bgp.c
@@ -98,7 +98,7 @@ static void encap_attr_export_ce(struct attr *new, struct attr *orig,
 	if (!CHECK_FLAG(new->flag, BGP_ATTR_MULTI_EXIT_DISC)) {
 		uint32_t med = 255;
 
-		if (CHECK_FLAG(new->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))) {
+		if (bgp_attr_exists(new, BGP_ATTR_LOCAL_PREF)) {
 			if (new->local_pref > 255)
 				med = 0;
 			else
@@ -645,7 +645,7 @@ encap_attr_export(struct attr *new, struct attr *orig,
 	if (!CHECK_FLAG(new->flag, BGP_ATTR_MULTI_EXIT_DISC)) {
 		uint32_t med = 255;
 
-		if (CHECK_FLAG(new->flag, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF))) {
+		if (bgp_attr_exists(new, BGP_ATTR_LOCAL_PREF)) {
 			if (new->local_pref > 255)
 				med = 0;
 			else
diff --git a/tools/coccinelle/bgp_attr_flag.cocci b/tools/coccinelle/bgp_attr_flag.cocci
new file mode 100644
index 000000000000..21c9c6b0f6e2
--- /dev/null
+++ b/tools/coccinelle/bgp_attr_flag.cocci
@@ -0,0 +1,14 @@
+@@
+expression e1, e2;
+@@
+
+(
+- CHECK_FLAG(e1->flag, ATTR_FLAG_BIT(e2))
++ bgp_attr_exists(e1, e2)
+|
+- SET_FLAG(e1->flag, ATTR_FLAG_BIT(e2))
++ bgp_attr_set(e1, e2)
+|
+- UNSET_FLAG(e1->flag, ATTR_FLAG_BIT(e2))
++ bgp_attr_unset(e1, e2)
+)