bgpd: Convert attr->vnc_subtlvs to use accessor functions

Add a get/set accessor functions and use them.

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

diff --git a/bgpd/bgp_attr.c b/bgpd/bgp_attr.c
index 0eb73089b6cecf26b854898c2814f03c12a20e71..fb9f3a1b382f94e925119d3d6802a8728c81ce77 100644 (file)
--- a/bgpd/bgp_attr.c
+++ b/bgpd/bgp_attr.c
@@ -257,9 +257,12 @@ void bgp_attr_flush_encap(struct attr *attr)
                attr->encap_subtlvs = NULL;
        }
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs) {
-               encap_free(attr->vnc_subtlvs);
-               attr->vnc_subtlvs = NULL;
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+
+       if (vnc_subtlvs) {
+               encap_free(vnc_subtlvs);
+               bgp_attr_set_vnc_subtlvs(attr, NULL);
        }
 #endif
 }
@@ -674,8 +677,10 @@ unsigned int attrhash_key_make(const void *p)
        if (attr->encap_subtlvs)
                MIX(encap_hash_key_make(attr->encap_subtlvs));
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs)
-               MIX(encap_hash_key_make(attr->vnc_subtlvs));
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+       if (vnc_subtlvs)
+               MIX(encap_hash_key_make(vnc_subtlvs));
 #endif
        MIX(attr->mp_nexthop_len);
        key = jhash(attr->mp_nexthop_global.s6_addr, IPV6_MAX_BYTELEN, key);
@@ -716,7 +721,8 @@ bool attrhash_cmp(const void *p1, const void *p2)
                    && (attr1->encap_tunneltype == attr2->encap_tunneltype)
                    && encap_same(attr1->encap_subtlvs, attr2->encap_subtlvs)
 #ifdef ENABLE_BGP_VNC
-                   && encap_same(attr1->vnc_subtlvs, attr2->vnc_subtlvs)
+                   && encap_same(bgp_attr_get_vnc_subtlvs(attr1),
+                                 bgp_attr_get_vnc_subtlvs(attr2))
 #endif
                    && IPV6_ADDR_SAME(&attr1->mp_nexthop_global,
                                      &attr2->mp_nexthop_global)
@@ -802,9 +808,11 @@ static void *bgp_attr_hash_alloc(void *p)
                val->encap_subtlvs = NULL;
        }
 #ifdef ENABLE_BGP_VNC
-       if (val->vnc_subtlvs) {
-               val->vnc_subtlvs = NULL;
-       }
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(val);
+
+       if (vnc_subtlvs)
+               bgp_attr_set_vnc_subtlvs(val, NULL);
 #endif
        if (val->srv6_l3vpn)
                val->srv6_l3vpn = NULL;
@@ -895,12 +903,16 @@ struct attr *bgp_attr_intern(struct attr *attr)
                        attr->srv6_vpn->refcnt++;
        }
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs) {
-               if (!attr->vnc_subtlvs->refcnt)
-                       attr->vnc_subtlvs = encap_intern(attr->vnc_subtlvs,
-                                                        VNC_SUBTLV_TYPE);
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+
+       if (vnc_subtlvs) {
+               if (!vnc_subtlvs->refcnt)
+                       bgp_attr_set_vnc_subtlvs(
+                               attr,
+                               encap_intern(vnc_subtlvs, VNC_SUBTLV_TYPE));
                else
-                       attr->vnc_subtlvs->refcnt++;
+                       vnc_subtlvs->refcnt++;
        }
 #endif
 
@@ -1091,8 +1103,13 @@ void bgp_attr_unintern_sub(struct attr *attr)
                encap_unintern(&attr->encap_subtlvs, ENCAP_SUBTLV_TYPE);
 
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs)
-               encap_unintern(&attr->vnc_subtlvs, VNC_SUBTLV_TYPE);
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+
+       if (vnc_subtlvs) {
+               encap_unintern(&vnc_subtlvs, VNC_SUBTLV_TYPE);
+               bgp_attr_set_vnc_subtlvs(attr, vnc_subtlvs);
+       }
 #endif
 
        if (attr->srv6_l3vpn)
@@ -1187,9 +1204,12 @@ void bgp_attr_flush(struct attr *attr)
                attr->encap_subtlvs = NULL;
        }
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs && !attr->vnc_subtlvs->refcnt) {
-               encap_free(attr->vnc_subtlvs);
-               attr->vnc_subtlvs = NULL;
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+
+       if (vnc_subtlvs && !vnc_subtlvs->refcnt) {
+               encap_free(vnc_subtlvs);
+               bgp_attr_set_vnc_subtlvs(attr, NULL);
        }
 #endif
 }
@@ -2455,15 +2475,17 @@ static int bgp_attr_encap(uint8_t type, struct peer *peer, /* IN */
 #ifdef ENABLE_BGP_VNC
                } else {
                        struct bgp_attr_encap_subtlv *stlv_last;
-                       for (stlv_last = attr->vnc_subtlvs;
+                       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+                               bgp_attr_get_vnc_subtlvs(attr);
+
+                       for (stlv_last = vnc_subtlvs;
                             stlv_last && stlv_last->next;
                             stlv_last = stlv_last->next)
                                ;
-                       if (stlv_last) {
+                       if (stlv_last)
                                stlv_last->next = tlv;
-                       } else {
-                               attr->vnc_subtlvs = tlv;
-                       }
+                       else
+                               bgp_attr_set_vnc_subtlvs(attr, tlv);
 #endif
                }
        }
@@ -3333,9 +3355,13 @@ done:
                        attr->encap_subtlvs = encap_intern(attr->encap_subtlvs,
                                                           ENCAP_SUBTLV_TYPE);
 #ifdef ENABLE_BGP_VNC
-               if (attr->vnc_subtlvs)
-                       attr->vnc_subtlvs = encap_intern(attr->vnc_subtlvs,
-                                                        VNC_SUBTLV_TYPE);
+               struct bgp_attr_encap_subtlv *vnc_subtlvs =
+                       bgp_attr_get_vnc_subtlvs(attr);
+
+               if (vnc_subtlvs)
+                       bgp_attr_set_vnc_subtlvs(
+                               attr,
+                               encap_intern(vnc_subtlvs, VNC_SUBTLV_TYPE));
 #endif
        } else {
                if (transit) {
@@ -3353,8 +3379,11 @@ done:
        if (attr->encap_subtlvs)
                assert(attr->encap_subtlvs->refcnt > 0);
 #ifdef ENABLE_BGP_VNC
-       if (attr->vnc_subtlvs)
-               assert(attr->vnc_subtlvs->refcnt > 0);
+       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+               bgp_attr_get_vnc_subtlvs(attr);
+
+       if (vnc_subtlvs)
+               assert(vnc_subtlvs->refcnt > 0);
 #endif
 
        return ret;
@@ -3606,7 +3635,7 @@ static void bgp_packet_mpattr_tea(struct bgp *bgp, struct peer *peer,
 #ifdef ENABLE_BGP_VNC_ATTR
        case BGP_ATTR_VNC:
                attrname = "VNC";
-               subtlvs = attr->vnc_subtlvs;
+               subtlvs = bgp_attr_get_vnc_subtlvs(attr);
                if (subtlvs == NULL) /* nothing to do */
                        return;
                attrlenfield = 0;   /* no outer T + L */

diff --git a/bgpd/bgp_attr.h b/bgpd/bgp_attr.h
index e154b9eefd61c50a73fbfbb7ba5dcb19c5a1e0f4..1b176f87164de2c55d408242a6fd1db5e2866216 100644 (file)
--- a/bgpd/bgp_attr.h
+++ b/bgpd/bgp_attr.h
@@ -515,4 +515,23 @@ static inline void bgp_attr_set_evpn_overlay(struct attr *attr,
        memcpy(&attr->evpn_overlay, eo, sizeof(struct bgp_route_evpn));
 }
 
+static inline struct bgp_attr_encap_subtlv *
+bgp_attr_get_vnc_subtlvs(const struct attr *attr)
+{
+#ifdef ENABLE_BGP_VNC
+       return attr->vnc_subtlvs;
+#else
+       return NULL;
+#endif
+}
+
+static inline void
+bgp_attr_set_vnc_subtlvs(struct attr *attr,
+                        struct bgp_attr_encap_subtlv *vnc_subtlvs)
+{
+#ifdef ENABLE_BGP_VNC
+       attr->vnc_subtlvs = vnc_subtlvs;
+#endif
+}
+
 #endif /* _QUAGGA_BGP_ATTR_H */

diff --git a/bgpd/rfapi/rfapi.c b/bgpd/rfapi/rfapi.c
index 297c353c8fa1cfe2ebf483c78e24e66aa5191850..f7bbd44512b724c56051f31e6cfd9e8ca303e039 100644 (file)
--- a/bgpd/rfapi/rfapi.c
+++ b/bgpd/rfapi/rfapi.c
@@ -744,7 +744,7 @@ void add_vnc_route(struct rfapi_descriptor *rfd, /* cookie, VPN UN addr, peer */
                encaptlv->length = 4;
                lt = htonl(*lifetime);
                memcpy(encaptlv->value, &lt, 4);
-               attr.vnc_subtlvs = encaptlv;
+               bgp_attr_set_vnc_subtlvs(&attr, encaptlv);
                vnc_zlog_debug_verbose(
                        "%s: set Encap Attr Prefix Lifetime to %d", __func__,
                        *lifetime);
@@ -754,7 +754,8 @@ void add_vnc_route(struct rfapi_descriptor *rfd, /* cookie, VPN UN addr, peer */
        if (rfp_options) {
 
                if (flags & RFAPI_AHR_RFPOPT_IS_VNCTLV) {
-
+                       struct bgp_attr_encap_subtlv *vnc_subtlvs =
+                               bgp_attr_get_vnc_subtlvs(&attr);
                        /*
                         * this flag means we're passing a pointer to an
                         * existing encap tlv chain which we should copy.
@@ -763,16 +764,15 @@ void add_vnc_route(struct rfapi_descriptor *rfd, /* cookie, VPN UN addr, peer */
                         */
                        encaptlv = encap_tlv_dup(
                                (struct bgp_attr_encap_subtlv *)rfp_options);
-                       if (attr.vnc_subtlvs) {
-                               attr.vnc_subtlvs->next = encaptlv;
-                       } else {
-                               attr.vnc_subtlvs = encaptlv;
-                       }
-
+                       if (vnc_subtlvs)
+                               vnc_subtlvs->next = encaptlv;
+                       else
+                               bgp_attr_set_vnc_subtlvs(&attr, encaptlv);
                } else {
                        struct bgp_tea_options *hop;
                        /* XXX max of one tlv present so far from above code */
-                       struct bgp_attr_encap_subtlv *tail = attr.vnc_subtlvs;
+                       struct bgp_attr_encap_subtlv *tail =
+                               bgp_attr_get_vnc_subtlvs(&attr);
 
                        for (hop = rfp_options; hop; hop = hop->next) {
 
@@ -798,11 +798,11 @@ void add_vnc_route(struct rfapi_descriptor *rfd, /* cookie, VPN UN addr, peer */
                                /*
                                 * add to end of subtlv chain
                                 */
-                               if (tail) {
+                               if (tail)
                                        tail->next = encaptlv;
-                               } else {
-                                       attr.vnc_subtlvs = encaptlv;
-                               }
+                               else
+                                       bgp_attr_set_vnc_subtlvs(&attr,
+                                                                encaptlv);
                                tail = encaptlv;
                        }
                }

diff --git a/bgpd/rfapi/rfapi_import.c b/bgpd/rfapi/rfapi_import.c
index e3581addee13909e146b04e0e72c68d021d4643a..3d87b6354238aee121cb18a00eef15f80ca3ee14 100644 (file)
--- a/bgpd/rfapi/rfapi_import.c
+++ b/bgpd/rfapi/rfapi_import.c
@@ -298,10 +298,9 @@ static wq_item_status rfapi_deferred_close_workfunc(struct work_queue *q,
 int rfapiGetL2o(struct attr *attr, struct rfapi_l2address_option *l2o)
 {
        if (attr) {
-
                struct bgp_attr_encap_subtlv *pEncap;
 
-               for (pEncap = attr->vnc_subtlvs; pEncap;
+               for (pEncap = bgp_attr_get_vnc_subtlvs(attr); pEncap;
                     pEncap = pEncap->next) {
 
                        if (pEncap->type == BGP_VNC_SUBTLV_TYPE_RFPOPTION) {
@@ -358,7 +357,7 @@ int rfapiGetVncLifetime(struct attr *attr, uint32_t *lifetime)
 
        if (attr) {
 
-               for (pEncap = attr->vnc_subtlvs; pEncap;
+               for (pEncap = bgp_attr_get_vnc_subtlvs(attr); pEncap;
                     pEncap = pEncap->next) {
 
                        if (pEncap->type
@@ -1337,7 +1336,8 @@ rfapiRouteInfo2NextHopEntry(struct rfapi_ip_prefix *rprefix,
                return NULL;
        }
 
-       for (pEncap = bpi->attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) {
+       for (pEncap = bgp_attr_get_vnc_subtlvs(bpi->attr); pEncap;
+            pEncap = pEncap->next) {
                switch (pEncap->type) {
                case BGP_VNC_SUBTLV_TYPE_LIFETIME:
                        /* use configured lifetime, not attr lifetime */

diff --git a/bgpd/rfapi/rfapi_rib.c b/bgpd/rfapi/rfapi_rib.c
index 630a379ec2163e1a5f8af12faca97867fbb0bc36..d1f335f54946306d39b32d4653748355d41d32a0 100644 (file)
--- a/bgpd/rfapi/rfapi_rib.c
+++ b/bgpd/rfapi/rfapi_rib.c
@@ -622,7 +622,8 @@ static void rfapiRibBi2Ri(struct bgp_path_info *bpi, struct rfapi_info *ri,
        ri->lifetime = lifetime;
 
        /* This loop based on rfapiRouteInfo2NextHopEntry() */
-       for (pEncap = bpi->attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) {
+       for (pEncap = bgp_attr_get_vnc_subtlvs(bpi->attr); pEncap;
+            pEncap = pEncap->next) {
                struct bgp_tea_options *hop;
 
                switch (pEncap->type) {

diff --git a/bgpd/rfapi/rfapi_vty.c b/bgpd/rfapi/rfapi_vty.c
index 7daaa01d902f974d45eea15f21c4351e46704cf3..40d5111e8c75a1a51fb0f1c51228a5b0f46d9774 100644 (file)
--- a/bgpd/rfapi/rfapi_vty.c
+++ b/bgpd/rfapi/rfapi_vty.c
@@ -596,7 +596,8 @@ void rfapiPrintBi(void *stream, struct bgp_path_info *bpi)
        }
 
        /* RFP option lengths */
-       for (pEncap = bpi->attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) {
+       for (pEncap = bgp_attr_get_vnc_subtlvs(bpi->attr); pEncap;
+            pEncap = pEncap->next) {
 
                if (pEncap->type == BGP_VNC_SUBTLV_TYPE_RFPOPTION) {
                        if (printed_1st_gol) {

diff --git a/bgpd/rfapi/vnc_import_bgp.c b/bgpd/rfapi/vnc_import_bgp.c
index 0b6b39b966f740026ee9088f5fb9d95d78f6e6b3..5a65eef4668c8527e0ff952cd61694298adc33f1 100644 (file)
--- a/bgpd/rfapi/vnc_import_bgp.c
+++ b/bgpd/rfapi/vnc_import_bgp.c
@@ -468,7 +468,7 @@ static void vnc_import_bgp_add_route_mode_resolve_nve_one_bi(
                plifetime = &lifetime;
        }
 
-       encaptlvs = bpi->attr->vnc_subtlvs;
+       encaptlvs = bgp_attr_get_vnc_subtlvs(bpi->attr);
        if (bpi->attr->encap_tunneltype != BGP_ENCAP_TYPE_RESERVED
            && bpi->attr->encap_tunneltype != BGP_ENCAP_TYPE_MPLS) {
                opt = &optary[cur_opt++];