From aadc0905054edac0fe88b35ae29236875d586cd8 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Tue, 6 Jun 2017 13:20:38 -0400 Subject: [PATCH] bgpd: Refactor 'struct attr_extra' into 'struct attr' Most of the attributes in 'struct attr_extra' allow for the more interesting cases of using bgp. The extra overhead of managing it will induce errors as we add more attributes and the extra memory overhead is negligible on anything but full bgp feeds. Additionally this greatly simplifies the code for the handling of data. Signed-off-by: Donald Sharp bgpd: Fix missing label set Signed-off-by: Donald Sharp --- bgpd/bgp_attr.c | 799 ++++++++++++++--------------------- bgpd/bgp_attr.h | 72 ++-- bgpd/bgp_attr_evpn.c | 21 +- bgpd/bgp_debug.c | 53 ++- bgpd/bgp_encap_tlv.c | 65 ++- bgpd/bgp_evpn.c | 67 ++- bgpd/bgp_label.c | 6 +- bgpd/bgp_memory.c | 1 - bgpd/bgp_memory.h | 1 - bgpd/bgp_mpath.c | 62 ++- bgpd/bgp_nht.c | 6 +- bgpd/bgp_packet.c | 7 +- bgpd/bgp_route.c | 410 ++++++++---------- bgpd/bgp_route.h | 4 +- bgpd/bgp_routemap.c | 100 ++--- bgpd/bgp_snmp.c | 10 +- bgpd/bgp_updgrp_adv.c | 13 +- bgpd/bgp_vty.c | 5 - bgpd/bgp_zebra.c | 42 +- bgpd/rfapi/rfapi.c | 47 +-- bgpd/rfapi/rfapi_encap_tlv.c | 14 +- bgpd/rfapi/rfapi_import.c | 288 ++++++------- bgpd/rfapi/rfapi_rib.c | 8 +- bgpd/rfapi/rfapi_vty.c | 38 +- bgpd/rfapi/vnc_export_bgp.c | 62 +-- bgpd/rfapi/vnc_import_bgp.c | 37 +- 26 files changed, 923 insertions(+), 1315 deletions(-) diff --git a/bgpd/bgp_attr.c b/bgpd/bgp_attr.c index e62d1bb0aa..4d828d2822 100644 --- a/bgpd/bgp_attr.c +++ b/bgpd/bgp_attr.c @@ -270,17 +270,17 @@ encap_free(struct bgp_attr_encap_subtlv *p) void bgp_attr_flush_encap(struct attr *attr) { - if (!attr || !attr->extra) + if (!attr) return; - if (attr->extra->encap_subtlvs) { - encap_free(attr->extra->encap_subtlvs); - attr->extra->encap_subtlvs = NULL; + if (attr->encap_subtlvs) { + encap_free(attr->encap_subtlvs); + attr->encap_subtlvs = NULL; } #if ENABLE_BGP_VNC - if (attr->extra->vnc_subtlvs) { - encap_free(attr->extra->vnc_subtlvs); - attr->extra->vnc_subtlvs = NULL; + if (attr->vnc_subtlvs) { + encap_free(attr->vnc_subtlvs); + attr->vnc_subtlvs = NULL; } #endif } @@ -424,15 +424,15 @@ encap_finish (void) } static bool -overlay_index_same(const struct attr_extra *ae1, const struct attr_extra *ae2) +overlay_index_same(const struct attr *a1, const struct attr *a2) { - if(!ae1 && ae2) + if(!a1 && a2) return false; - if(!ae2 && ae1) + if(!a2 && a1) return false; - if(!ae1 && !ae2) + if(!a1 && !a2) return true; - return !memcmp(&(ae1->evpn_overlay), &(ae2->evpn_overlay), sizeof(struct overlay_index)); + return !memcmp(&(a1->evpn_overlay), &(a2->evpn_overlay), sizeof(struct overlay_index)); } /* Unknown transit attribute. */ @@ -532,34 +532,6 @@ transit_finish (void) /* Attribute hash routines. */ static struct hash *attrhash; -static struct attr_extra * -bgp_attr_extra_new (void) -{ - struct attr_extra *extra; - extra = XCALLOC (MTYPE_ATTR_EXTRA, sizeof (struct attr_extra)); - extra->label_index = BGP_INVALID_LABEL_INDEX; - extra->label = MPLS_INVALID_LABEL; - return extra; -} - -void -bgp_attr_extra_free (struct attr *attr) -{ - if (attr->extra) - { - XFREE (MTYPE_ATTR_EXTRA, attr->extra); - attr->extra = NULL; - } -} - -struct attr_extra * -bgp_attr_extra_get (struct attr *attr) -{ - if (!attr->extra) - attr->extra = bgp_attr_extra_new(); - return attr->extra; -} - /* Shallow copy of an attribute * Though, not so shallow that it doesn't copy the contents * of the attr_extra pointed to by 'extra' @@ -567,33 +539,7 @@ bgp_attr_extra_get (struct attr *attr) void bgp_attr_dup (struct attr *new, struct attr *orig) { - struct attr_extra *extra = new->extra; - *new = *orig; - /* if caller provided attr_extra space, use it in any case. - * - * This is neccesary even if orig->extra equals NULL, because otherwise - * memory may be later allocated on the heap by bgp_attr_extra_get. - * - * That memory would eventually be leaked, because the caller must not - * call bgp_attr_extra_free if he provided attr_extra on the stack. - */ - if (extra) - { - new->extra = extra; - memset(new->extra, 0, sizeof(struct attr_extra)); - new->extra->label_index = BGP_INVALID_LABEL_INDEX; - new->extra->label = MPLS_INVALID_LABEL; - - if (orig->extra) { - *new->extra = *orig->extra; - } - } - else if (orig->extra) - { - new->extra = bgp_attr_extra_new(); - *new->extra = *orig->extra; - } } void @@ -605,21 +551,18 @@ bgp_attr_deep_dup (struct attr *new, struct attr *orig) if (orig->community) new->community = community_dup(orig->community); - if (orig->extra) - { - if (orig->extra->ecommunity) - new->extra->ecommunity = ecommunity_dup(orig->extra->ecommunity); - if (orig->extra->cluster) - new->extra->cluster = cluster_dup(orig->extra->cluster); - if (orig->extra->transit) - new->extra->transit = transit_dup(orig->extra->transit); - if (orig->extra->encap_subtlvs) - new->extra->encap_subtlvs = encap_tlv_dup(orig->extra->encap_subtlvs); + if (orig->ecommunity) + new->ecommunity = ecommunity_dup(orig->ecommunity); + if (orig->cluster) + new->cluster = cluster_dup(orig->cluster); + if (orig->transit) + new->transit = transit_dup(orig->transit); + if (orig->encap_subtlvs) + new->encap_subtlvs = encap_tlv_dup(orig->encap_subtlvs); #if ENABLE_BGP_VNC - if (orig->extra->vnc_subtlvs) - new->extra->vnc_subtlvs = encap_tlv_dup(orig->extra->vnc_subtlvs); + if (orig->vnc_subtlvs) + new->vnc_subtlvs = encap_tlv_dup(orig->vnc_subtlvs); #endif - } } void @@ -631,21 +574,18 @@ bgp_attr_deep_free (struct attr *attr) if (attr->community) community_free(attr->community); - if (attr->extra) - { - if (attr->extra->ecommunity) - ecommunity_free(&attr->extra->ecommunity); - if (attr->extra->cluster) - cluster_free(attr->extra->cluster); - if (attr->extra->transit) - transit_free(attr->extra->transit); - if (attr->extra->encap_subtlvs) - encap_free(attr->extra->encap_subtlvs); + if (attr->ecommunity) + ecommunity_free(&attr->ecommunity); + if (attr->cluster) + cluster_free(attr->cluster); + if (attr->transit) + transit_free(attr->transit); + if (attr->encap_subtlvs) + encap_free(attr->encap_subtlvs); #if ENABLE_BGP_VNC - if (attr->extra->vnc_subtlvs) - encap_free(attr->extra->vnc_subtlvs); + if (attr->vnc_subtlvs) + encap_free(attr->vnc_subtlvs); #endif - } } unsigned long int @@ -664,7 +604,6 @@ unsigned int attrhash_key_make (void *p) { const struct attr *attr = (struct attr *) p; - const struct attr_extra *extra = attr->extra; uint32_t key = 0; #define MIX(val) key = jhash_1word(val, key) @@ -678,43 +617,37 @@ attrhash_key_make (void *p) key += attr->med; key += attr->local_pref; - if (extra) - { - MIX(extra->aggregator_as); - MIX(extra->aggregator_addr.s_addr); - MIX(extra->weight); - MIX(extra->mp_nexthop_global_in.s_addr); - MIX(extra->originator_id.s_addr); - MIX(extra->tag); - MIX(extra->label); - MIX(extra->label_index); - } - + MIX(attr->aggregator_as); + MIX(attr->aggregator_addr.s_addr); + MIX(attr->weight); + MIX(attr->mp_nexthop_global_in.s_addr); + MIX(attr->originator_id.s_addr); + MIX(attr->tag); + MIX(attr->label); + MIX(attr->label_index); + if (attr->aspath) MIX(aspath_key_make (attr->aspath)); if (attr->community) MIX(community_hash_make (attr->community)); - - if (extra) - { - if (extra->lcommunity) - MIX(lcommunity_hash_make (extra->lcommunity)); - if (extra->ecommunity) - MIX(ecommunity_hash_make (extra->ecommunity)); - if (extra->cluster) - MIX(cluster_hash_key_make (extra->cluster)); - if (extra->transit) - MIX(transit_hash_key_make (extra->transit)); - if (extra->encap_subtlvs) - MIX(encap_hash_key_make (extra->encap_subtlvs)); + + if (attr->lcommunity) + MIX(lcommunity_hash_make (attr->lcommunity)); + if (attr->ecommunity) + MIX(ecommunity_hash_make (attr->ecommunity)); + if (attr->cluster) + MIX(cluster_hash_key_make (attr->cluster)); + if (attr->transit) + MIX(transit_hash_key_make (attr->transit)); + if (attr->encap_subtlvs) + MIX(encap_hash_key_make (attr->encap_subtlvs)); #if ENABLE_BGP_VNC - if (extra->vnc_subtlvs) - MIX(encap_hash_key_make (extra->vnc_subtlvs)); + if (attr->vnc_subtlvs) + MIX(encap_hash_key_make (attr->vnc_subtlvs)); #endif - MIX(extra->mp_nexthop_len); - key = jhash(extra->mp_nexthop_global.s6_addr, IPV6_MAX_BYTELEN, key); - key = jhash(extra->mp_nexthop_local.s6_addr, IPV6_MAX_BYTELEN, key); - } + MIX(attr->mp_nexthop_len); + key = jhash(attr->mp_nexthop_global.s6_addr, IPV6_MAX_BYTELEN, key); + key = jhash(attr->mp_nexthop_local.s6_addr, IPV6_MAX_BYTELEN, key); return key; } @@ -734,38 +667,30 @@ attrhash_cmp (const void *p1, const void *p2) && attr1->local_pref == attr2->local_pref && attr1->rmap_change_flags == attr2->rmap_change_flags) { - const struct attr_extra *ae1 = attr1->extra; - const struct attr_extra *ae2 = attr2->extra; - - if (ae1 && ae2 - && ae1->aggregator_as == ae2->aggregator_as - && ae1->aggregator_addr.s_addr == ae2->aggregator_addr.s_addr - && ae1->weight == ae2->weight - && ae1->tag == ae2->tag - && ae1->label_index == ae2->label_index - && ae1->mp_nexthop_len == ae2->mp_nexthop_len - && IPV6_ADDR_SAME (&ae1->mp_nexthop_global, &ae2->mp_nexthop_global) - && IPV6_ADDR_SAME (&ae1->mp_nexthop_local, &ae2->mp_nexthop_local) - && IPV4_ADDR_SAME (&ae1->mp_nexthop_global_in, &ae2->mp_nexthop_global_in) - && ae1->ecommunity == ae2->ecommunity - && ae1->lcommunity == ae2->lcommunity - && ae1->cluster == ae2->cluster - && ae1->transit == ae2->transit - && (ae1->encap_tunneltype == ae2->encap_tunneltype) - && encap_same(ae1->encap_subtlvs, ae2->encap_subtlvs) + if (attr1->aggregator_as == attr2->aggregator_as + && attr1->aggregator_addr.s_addr == attr2->aggregator_addr.s_addr + && attr1->weight == attr2->weight + && attr1->tag == attr2->tag + && attr1->label_index == attr2->label_index + && attr1->mp_nexthop_len == attr2->mp_nexthop_len + && IPV6_ADDR_SAME (&attr1->mp_nexthop_global, &attr2->mp_nexthop_global) + && IPV6_ADDR_SAME (&attr1->mp_nexthop_local, &attr2->mp_nexthop_local) + && IPV4_ADDR_SAME (&attr1->mp_nexthop_global_in, &attr2->mp_nexthop_global_in) + && attr1->ecommunity == attr2->ecommunity + && attr1->lcommunity == attr2->lcommunity + && attr1->cluster == attr2->cluster + && attr1->transit == attr2->transit + && (attr1->encap_tunneltype == attr2->encap_tunneltype) + && encap_same(attr1->encap_subtlvs, attr2->encap_subtlvs) #if ENABLE_BGP_VNC - && encap_same(ae1->vnc_subtlvs, ae2->vnc_subtlvs) + && encap_same(attr1->vnc_subtlvs, attr2->vnc_subtlvs) #endif - && IPV4_ADDR_SAME (&ae1->originator_id, &ae2->originator_id) - && overlay_index_same(ae1, ae2)) + && IPV4_ADDR_SAME (&attr1->originator_id, &attr2->originator_id) + && overlay_index_same(attr1, attr2)) return 1; - else if (ae1 || ae2) - return 0; - /* neither attribute has extra attributes, so they're same */ - return 1; } - else - return 0; + + return 0; } static void @@ -780,7 +705,6 @@ attrhash_init (void) static void attr_vfree (void *attr) { - bgp_attr_extra_free ((struct attr *)attr); XFREE (MTYPE_ATTR, attr); } @@ -813,24 +737,19 @@ attr_show_all (struct vty *vty) static void * bgp_attr_hash_alloc (void *p) { - const struct attr * val = (const struct attr *) p; + struct attr * val = (struct attr *) p; struct attr *attr; attr = XMALLOC (MTYPE_ATTR, sizeof (struct attr)); *attr = *val; - if (val->extra) - { - attr->extra = bgp_attr_extra_new (); - *attr->extra = *val->extra; - if (val->extra->encap_subtlvs) { - val->extra->encap_subtlvs = NULL; - } + if (val->encap_subtlvs) { + val->encap_subtlvs = NULL; + } #if ENABLE_BGP_VNC - if (val->extra->vnc_subtlvs) { - val->extra->vnc_subtlvs = NULL; - } + if (val->vnc_subtlvs) { + val->vnc_subtlvs = NULL; + } #endif - } attr->refcnt = 0; return attr; } @@ -856,56 +775,51 @@ bgp_attr_intern (struct attr *attr) else attr->community->refcnt++; } - if (attr->extra) + + if (attr->ecommunity) { - struct attr_extra *attre = attr->extra; - - if (attre->ecommunity) - { - if (! attre->ecommunity->refcnt) - attre->ecommunity = ecommunity_intern (attre->ecommunity); - else - attre->ecommunity->refcnt++; - - } - if (attre->lcommunity) - { - if (! attre->lcommunity->refcnt) - attre->lcommunity = lcommunity_intern (attre->lcommunity); - else - attre->lcommunity->refcnt++; - } - if (attre->cluster) - { - if (! attre->cluster->refcnt) - attre->cluster = cluster_intern (attre->cluster); - else - attre->cluster->refcnt++; - } - if (attre->transit) - { - if (! attre->transit->refcnt) - attre->transit = transit_intern (attre->transit); - else - attre->transit->refcnt++; - } - if (attre->encap_subtlvs) - { - if (! attre->encap_subtlvs->refcnt) - attre->encap_subtlvs = encap_intern (attre->encap_subtlvs, ENCAP_SUBTLV_TYPE); - else - attre->encap_subtlvs->refcnt++; - } -#if ENABLE_BGP_VNC - if (attre->vnc_subtlvs) - { - if (! attre->vnc_subtlvs->refcnt) - attre->vnc_subtlvs = encap_intern (attre->vnc_subtlvs, VNC_SUBTLV_TYPE); - else - attre->vnc_subtlvs->refcnt++; - } -#endif + if (! attr->ecommunity->refcnt) + attr->ecommunity = ecommunity_intern (attr->ecommunity); + else + attr->ecommunity->refcnt++; } + if (attr->lcommunity) + { + if (! attr->lcommunity->refcnt) + attr->lcommunity = lcommunity_intern (attr->lcommunity); + else + attr->lcommunity->refcnt++; + } + if (attr->cluster) + { + if (! attr->cluster->refcnt) + attr->cluster = cluster_intern (attr->cluster); + else + attr->cluster->refcnt++; + } + if (attr->transit) + { + if (! attr->transit->refcnt) + attr->transit = transit_intern (attr->transit); + else + attr->transit->refcnt++; + } + if (attr->encap_subtlvs) + { + if (! attr->encap_subtlvs->refcnt) + attr->encap_subtlvs = encap_intern (attr->encap_subtlvs, ENCAP_SUBTLV_TYPE); + else + attr->encap_subtlvs->refcnt++; + } +#if ENABLE_BGP_VNC + if (attr->vnc_subtlvs) + { + if (! attr->vnc_subtlvs->refcnt) + attr->vnc_subtlvs = encap_intern (attr->vnc_subtlvs, VNC_SUBTLV_TYPE); + else + attr->vnc_subtlvs->refcnt++; + } +#endif find = (struct attr *) hash_get (attrhash, attr, bgp_attr_hash_alloc); find->refcnt++; @@ -932,26 +846,23 @@ bgp_attr_refcount (struct attr *attr) if (attr->community) attr->community->refcnt++; - if (attr->extra) - { - struct attr_extra *attre = attr->extra; - if (attre->ecommunity) - attre->ecommunity->refcnt++; + if (attr->ecommunity) + attr->ecommunity->refcnt++; - if (attre->cluster) - attre->cluster->refcnt++; + if (attr->cluster) + attr->cluster->refcnt++; - if (attre->transit) - attre->transit->refcnt++; + if (attr->transit) + attr->transit->refcnt++; - if (attre->encap_subtlvs) - attre->encap_subtlvs->refcnt++; + if (attr->encap_subtlvs) + attr->encap_subtlvs->refcnt++; #if ENABLE_BGP_VNC - if (attre->vnc_subtlvs) - attre->vnc_subtlvs->refcnt++; + if (attr->vnc_subtlvs) + attr->vnc_subtlvs->refcnt++; #endif - } + attr->refcnt++; return attr; } @@ -961,18 +872,17 @@ struct attr * bgp_attr_default_set (struct attr *attr, u_char origin) { memset (attr, 0, sizeof (struct attr)); - bgp_attr_extra_get (attr); attr->origin = origin; attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN); attr->aspath = aspath_empty (); attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH); - attr->extra->weight = BGP_ATTR_DEFAULT_WEIGHT; - attr->extra->tag = 0; - attr->extra->label_index = BGP_INVALID_LABEL_INDEX; - attr->extra->label = MPLS_INVALID_LABEL; + attr->weight = BGP_ATTR_DEFAULT_WEIGHT; + attr->tag = 0; + attr->label_index = BGP_INVALID_LABEL_INDEX; + attr->label = MPLS_INVALID_LABEL; attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP); - attr->extra->mp_nexthop_len = IPV6_MAX_BYTELEN; + attr->mp_nexthop_len = IPV6_MAX_BYTELEN; return attr; } @@ -986,11 +896,8 @@ bgp_attr_aggregate_intern (struct bgp *bgp, u_char origin, { struct attr attr; struct attr *new; - struct attr_extra attre; memset (&attr, 0, sizeof (struct attr)); - memset (&attre, 0, sizeof (struct attr_extra)); - attr.extra = &attre; /* Origin attribute. */ attr.origin = origin; @@ -1012,18 +919,20 @@ bgp_attr_aggregate_intern (struct bgp *bgp, u_char origin, attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES); } - attre.label_index = BGP_INVALID_LABEL_INDEX; - attre.label = MPLS_INVALID_LABEL; - attre.weight = BGP_ATTR_DEFAULT_WEIGHT; - attre.mp_nexthop_len = IPV6_MAX_BYTELEN; + attr.label_index = BGP_INVALID_LABEL_INDEX; + attr.label = MPLS_INVALID_LABEL; + attr.weight = BGP_ATTR_DEFAULT_WEIGHT; + attr.mp_nexthop_len = IPV6_MAX_BYTELEN; if (! as_set || atomic_aggregate) attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE); attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR); if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION)) - attre.aggregator_as = bgp->confed_id; + attr.aggregator_as = bgp->confed_id; else - attre.aggregator_as = bgp->as; - attre.aggregator_addr = bgp->router_id; + attr.aggregator_as = bgp->as; + attr.aggregator_addr = bgp->router_id; + attr.label_index = BGP_INVALID_LABEL_INDEX; + attr.label = MPLS_INVALID_LABEL; new = bgp_attr_intern (&attr); @@ -1044,31 +953,28 @@ bgp_attr_unintern_sub (struct attr *attr) community_unintern (&attr->community); UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES)); - if (attr->extra) - { - if (attr->extra->ecommunity) - ecommunity_unintern (&attr->extra->ecommunity); - UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES)); + if (attr->ecommunity) + ecommunity_unintern (&attr->ecommunity); + UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES)); - if (attr->extra->lcommunity) - lcommunity_unintern (&attr->extra->lcommunity); - UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES)); + if (attr->lcommunity) + lcommunity_unintern (&attr->lcommunity); + UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES)); - if (attr->extra->cluster) - cluster_unintern (attr->extra->cluster); - UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST)); - - if (attr->extra->transit) - transit_unintern (attr->extra->transit); + if (attr->cluster) + cluster_unintern (attr->cluster); + UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST)); - if (attr->extra->encap_subtlvs) - encap_unintern (&attr->extra->encap_subtlvs, ENCAP_SUBTLV_TYPE); + if (attr->transit) + transit_unintern (attr->transit); + + if (attr->encap_subtlvs) + encap_unintern (&attr->encap_subtlvs, ENCAP_SUBTLV_TYPE); #if ENABLE_BGP_VNC - if (attr->extra->vnc_subtlvs) - encap_unintern (&attr->extra->vnc_subtlvs, VNC_SUBTLV_TYPE); + if (attr->vnc_subtlvs) + encap_unintern (&attr->vnc_subtlvs, VNC_SUBTLV_TYPE); #endif - } } /* Free bgp attribute and aspath. */ @@ -1078,25 +984,17 @@ bgp_attr_unintern (struct attr **pattr) struct attr *attr = *pattr; struct attr *ret; struct attr tmp; - struct attr_extra tmp_extra; - + /* Decrement attribute reference. */ attr->refcnt--; - + tmp = *attr; - if (attr->extra) - { - tmp.extra = &tmp_extra; - memcpy (tmp.extra, attr->extra, sizeof (struct attr_extra)); - } - /* If reference becomes zero then free attribute object. */ if (attr->refcnt == 0) { ret = hash_release (attrhash, attr); assert (ret != NULL); - bgp_attr_extra_free (attr); XFREE (MTYPE_ATTR, attr); *pattr = NULL; } @@ -1117,37 +1015,33 @@ bgp_attr_flush (struct attr *attr) community_free (attr->community); attr->community = NULL; } - if (attr->extra) - { - struct attr_extra *attre = attr->extra; - if (attre->ecommunity && ! attre->ecommunity->refcnt) - ecommunity_free (&attre->ecommunity); - if (attre->lcommunity && ! attre->lcommunity->refcnt) - lcommunity_free (&attre->lcommunity); - if (attre->cluster && ! attre->cluster->refcnt) - { - cluster_free (attre->cluster); - attre->cluster = NULL; - } - if (attre->transit && ! attre->transit->refcnt) - { - transit_free (attre->transit); - attre->transit = NULL; - } - if (attre->encap_subtlvs && ! attre->encap_subtlvs->refcnt) - { - encap_free(attre->encap_subtlvs); - attre->encap_subtlvs = NULL; - } -#if ENABLE_BGP_VNC - if (attre->vnc_subtlvs && ! attre->vnc_subtlvs->refcnt) - { - encap_free(attre->vnc_subtlvs); - attre->vnc_subtlvs = NULL; - } -#endif + if (attr->ecommunity && ! attr->ecommunity->refcnt) + ecommunity_free (&attr->ecommunity); + if (attr->lcommunity && ! attr->lcommunity->refcnt) + lcommunity_free (&attr->lcommunity); + if (attr->cluster && ! attr->cluster->refcnt) + { + cluster_free (attr->cluster); + attr->cluster = NULL; } + if (attr->transit && ! attr->transit->refcnt) + { + transit_free (attr->transit); + attr->transit = NULL; + } + if (attr->encap_subtlvs && ! attr->encap_subtlvs->refcnt) + { + encap_free(attr->encap_subtlvs); + attr->encap_subtlvs = NULL; + } +#if ENABLE_BGP_VNC + if (attr->vnc_subtlvs && ! attr->vnc_subtlvs->refcnt) + { + encap_free(attr->vnc_subtlvs); + attr->vnc_subtlvs = NULL; + } +#endif } /* Implement draft-scudder-idr-optional-transitive behaviour and @@ -1630,7 +1524,6 @@ bgp_attr_aggregator (struct bgp_attr_parser_args *args) const bgp_size_t length = args->length; int wantedlen = 6; - struct attr_extra *attre = bgp_attr_extra_get (attr); /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */ if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)) @@ -1645,10 +1538,10 @@ bgp_attr_aggregator (struct bgp_attr_parser_args *args) } if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV ) ) - attre->aggregator_as = stream_getl (peer->ibuf); + attr->aggregator_as = stream_getl (peer->ibuf); else - attre->aggregator_as = stream_getw (peer->ibuf); - attre->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf); + attr->aggregator_as = stream_getw (peer->ibuf); + attr->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf); /* Set atomic aggregate flag. */ attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR); @@ -1692,7 +1585,6 @@ bgp_attr_munge_as4_attrs (struct peer *const peer, { int ignore_as4_path = 0; struct aspath *newpath; - struct attr_extra *attre = attr->extra; if (!attr->aspath) { @@ -1732,8 +1624,6 @@ bgp_attr_munge_as4_attrs (struct peer *const peer, { if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR) ) ) { - assert (attre); - /* received both. * if the as_number in aggregator is not AS_TRANS, * then AS4_AGGREGATOR and AS4_PATH shall be ignored @@ -1746,7 +1636,7 @@ bgp_attr_munge_as4_attrs (struct peer *const peer, * Aggregating node and the AS_PATH is to be * constructed "as in all other cases" */ - if (attre->aggregator_as != BGP_AS_TRANS) + if (attr->aggregator_as != BGP_AS_TRANS) { /* ignore */ if ( BGP_DEBUG(as4, AS4)) @@ -1759,8 +1649,8 @@ bgp_attr_munge_as4_attrs (struct peer *const peer, else { /* "New_aggregator shall be taken as aggregator" */ - attre->aggregator_as = as4_aggregator; - attre->aggregator_addr.s_addr = as4_aggregator_addr->s_addr; + attr->aggregator_as = as4_aggregator; + attr->aggregator_addr.s_addr = as4_aggregator_addr->s_addr; } } else @@ -1774,7 +1664,7 @@ bgp_attr_munge_as4_attrs (struct peer *const peer, zlog_debug ("[AS4] %s BGP not AS4 capable peer send" " AS4_AGGREGATOR but no AGGREGATOR, will take" " it as if AGGREGATOR with AS_TRANS had been there", peer->host); - (attre = bgp_attr_extra_get (attr))->aggregator_as = as4_aggregator; + attr->aggregator_as = as4_aggregator; /* sweep it under the carpet and simulate a "good" AGGREGATOR */ attr->flag |= (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR)); } @@ -1838,8 +1728,7 @@ bgp_attr_originator_id (struct bgp_attr_parser_args *args) args->total); } - (bgp_attr_extra_get (attr))->originator_id.s_addr - = stream_get_ipv4 (peer->ibuf); + attr->originator_id.s_addr = stream_get_ipv4 (peer->ibuf); attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID); @@ -1863,8 +1752,7 @@ bgp_attr_cluster_list (struct bgp_attr_parser_args *args) args->total); } - (bgp_attr_extra_get (attr))->cluster - = cluster_parse ((struct in_addr *)stream_pnt (peer->ibuf), length); + attr->cluster = cluster_parse ((struct in_addr *)stream_pnt (peer->ibuf), length); /* XXX: Fix cluster_parse to use stream API and then remove this */ stream_forward_getp (peer->ibuf, length); @@ -1888,7 +1776,6 @@ bgp_mp_reach_parse (struct bgp_attr_parser_args *args, struct peer *const peer = args->peer; struct attr *const attr = args->attr; const bgp_size_t length = args->length; - struct attr_extra *attre = bgp_attr_extra_get(attr); /* Set end of packet. */ s = BGP_INPUT(peer); @@ -1921,53 +1808,53 @@ bgp_mp_reach_parse (struct bgp_attr_parser_args *args, } /* Get nexthop length. */ - attre->mp_nexthop_len = stream_getc (s); + attr->mp_nexthop_len = stream_getc (s); - if (LEN_LEFT < attre->mp_nexthop_len) + if (LEN_LEFT < attr->mp_nexthop_len) { zlog_info ("%s: %s, MP nexthop length, %u, goes past end of attribute", - __func__, peer->host, attre->mp_nexthop_len); + __func__, peer->host, attr->mp_nexthop_len); return BGP_ATTR_PARSE_ERROR_NOTIFYPLS; } /* Nexthop length check. */ - switch (attre->mp_nexthop_len) + switch (attr->mp_nexthop_len) { case BGP_ATTR_NHLEN_IPV4: - stream_get (&attre->mp_nexthop_global_in, s, IPV4_MAX_BYTELEN); + stream_get (&attr->mp_nexthop_global_in, s, IPV4_MAX_BYTELEN); /* Probably needed for RFC 2283 */ if (attr->nexthop.s_addr == 0) - memcpy(&attr->nexthop.s_addr, &attre->mp_nexthop_global_in, IPV4_MAX_BYTELEN); + memcpy(&attr->nexthop.s_addr, &attr->mp_nexthop_global_in, IPV4_MAX_BYTELEN); break; case BGP_ATTR_NHLEN_VPNV4: stream_getl (s); /* RD high */ stream_getl (s); /* RD low */ - stream_get (&attre->mp_nexthop_global_in, s, IPV4_MAX_BYTELEN); + stream_get (&attr->mp_nexthop_global_in, s, IPV4_MAX_BYTELEN); break; case BGP_ATTR_NHLEN_IPV6_GLOBAL: case BGP_ATTR_NHLEN_VPNV6_GLOBAL: - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL) + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL) { stream_getl (s); /* RD high */ stream_getl (s); /* RD low */ } - stream_get (&attre->mp_nexthop_global, s, IPV6_MAX_BYTELEN); + stream_get (&attr->mp_nexthop_global, s, IPV6_MAX_BYTELEN); break; case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL: case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL: - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) { stream_getl (s); /* RD high */ stream_getl (s); /* RD low */ } - stream_get (&attre->mp_nexthop_global, s, IPV6_MAX_BYTELEN); - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) + stream_get (&attr->mp_nexthop_global, s, IPV6_MAX_BYTELEN); + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL) { stream_getl (s); /* RD high */ stream_getl (s); /* RD low */ } - stream_get (&attre->mp_nexthop_local, s, IPV6_MAX_BYTELEN); - if (! IN6_IS_ADDR_LINKLOCAL (&attre->mp_nexthop_local)) + stream_get (&attr->mp_nexthop_local, s, IPV6_MAX_BYTELEN); + if (! IN6_IS_ADDR_LINKLOCAL (&attr->mp_nexthop_local)) { char buf1[INET6_ADDRSTRLEN]; char buf2[INET6_ADDRSTRLEN]; @@ -1975,17 +1862,17 @@ bgp_mp_reach_parse (struct bgp_attr_parser_args *args, if (bgp_debug_update(peer, NULL, NULL, 1)) zlog_debug ("%s rcvd nexthops %s, %s -- ignoring non-LL value", peer->host, - inet_ntop (AF_INET6, &attre->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf1, INET6_ADDRSTRLEN), - inet_ntop (AF_INET6, &attre->mp_nexthop_local, + inet_ntop (AF_INET6, &attr->mp_nexthop_local, buf2, INET6_ADDRSTRLEN)); - attre->mp_nexthop_len = IPV6_MAX_BYTELEN; + attr->mp_nexthop_len = IPV6_MAX_BYTELEN; } break; default: zlog_info ("%s: (%s) Wrong multiprotocol next hop length: %d", - __func__, peer->host, attre->mp_nexthop_len); + __func__, peer->host, attr->mp_nexthop_len); return BGP_ATTR_PARSE_ERROR_NOTIFYPLS; } @@ -2087,18 +1974,16 @@ bgp_attr_large_community (struct bgp_attr_parser_args *args) */ if (length == 0) { - if (attr->extra) - attr->extra->lcommunity = NULL; + attr->lcommunity = NULL; /* Empty extcomm doesn't seem to be invalid per se */ return BGP_ATTR_PARSE_PROCEED; } - (bgp_attr_extra_get (attr))->lcommunity = - lcommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length); + attr->lcommunity = lcommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length); /* XXX: fix ecommunity_parse to use stream API */ stream_forward_getp (peer->ibuf, length); - if (attr->extra && !attr->extra->lcommunity) + if (!attr->lcommunity) return bgp_attr_malformed (args, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR, args->total); @@ -2119,18 +2004,16 @@ bgp_attr_ext_communities (struct bgp_attr_parser_args *args) if (length == 0) { - if (attr->extra) - attr->extra->ecommunity = NULL; + attr->ecommunity = NULL; /* Empty extcomm doesn't seem to be invalid per se */ return BGP_ATTR_PARSE_PROCEED; } - (bgp_attr_extra_get (attr))->ecommunity = - ecommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length); + attr->ecommunity = ecommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length); /* XXX: fix ecommunity_parse to use stream API */ stream_forward_getp (peer->ibuf, length); - if (attr->extra && !attr->extra->ecommunity) + if (!attr->ecommunity) return bgp_attr_malformed (args, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR, args->total); @@ -2138,8 +2021,8 @@ bgp_attr_ext_communities (struct bgp_attr_parser_args *args) attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); /* Extract MAC mobility sequence number, if any. */ - attr->extra->mm_seqnum = bgp_attr_mac_mobility_seqnum (attr, &sticky); - attr->extra->sticky = sticky; + attr->mm_seqnum = bgp_attr_mac_mobility_seqnum (attr, &sticky); + attr->sticky = sticky; return BGP_ATTR_PARSE_PROCEED; } @@ -2155,7 +2038,6 @@ bgp_attr_encap( u_char *startp) { bgp_size_t total; - struct attr_extra *attre = NULL; struct bgp_attr_encap_subtlv *stlv_last = NULL; uint16_t tunneltype = 0; @@ -2230,37 +2112,30 @@ bgp_attr_encap( length -= sublength; /* attach tlv to encap chain */ - if (!attre) { - attre = bgp_attr_extra_get(attr); - if (BGP_ATTR_ENCAP == type) { - for (stlv_last = attre->encap_subtlvs; stlv_last && stlv_last->next; - stlv_last = stlv_last->next); - if (stlv_last) { - stlv_last->next = tlv; - } else { - attre->encap_subtlvs = tlv; - } + if (BGP_ATTR_ENCAP == type) { + for (stlv_last = attr->encap_subtlvs; stlv_last && stlv_last->next; + stlv_last = stlv_last->next); + if (stlv_last) { + stlv_last->next = tlv; + } else { + attr->encap_subtlvs = tlv; + } #if ENABLE_BGP_VNC - } else { - for (stlv_last = attre->vnc_subtlvs; stlv_last && stlv_last->next; - stlv_last = stlv_last->next); - if (stlv_last) { - stlv_last->next = tlv; - } else { - attre->vnc_subtlvs = tlv; - } -#endif - } } else { - stlv_last->next = tlv; + for (stlv_last = attr->vnc_subtlvs; stlv_last && stlv_last->next; + stlv_last = stlv_last->next); + if (stlv_last) { + stlv_last->next = tlv; + } else { + attr->vnc_subtlvs = tlv; + } +#endif } - stlv_last = tlv; + stlv_last->next = tlv; } if (BGP_ATTR_ENCAP == type) { - if (!attre) - attre = bgp_attr_extra_get(attr); - attre->encap_tunneltype = tunneltype; + attr->encap_tunneltype = tunneltype; } if (length) { @@ -2319,14 +2194,14 @@ bgp_attr_prefix_sid (struct bgp_attr_parser_args *args, struct bgp_nlri *mp_upda args->total); /* Store label index; subsequently, we'll check on address-family */ - (bgp_attr_extra_get (attr))->label_index = label_index; + attr->label_index = label_index; /* * Ignore the Label index attribute unless received for labeled-unicast * SAFI. */ if (!mp_update->length || mp_update->safi != SAFI_LABELED_UNICAST) - attr->extra->label_index = BGP_INVALID_LABEL_INDEX; + attr->label_index = BGP_INVALID_LABEL_INDEX; } /* Placeholder code for the IPv6 SID type */ @@ -2382,7 +2257,6 @@ bgp_attr_unknown (struct bgp_attr_parser_args *args) { bgp_size_t total = args->total; struct transit *transit; - struct attr_extra *attre; struct peer *const peer = args->peer; struct attr *const attr = args->attr; u_char *const startp = args->startp; @@ -2420,10 +2294,10 @@ bgp_attr_unknown (struct bgp_attr_parser_args *args) SET_FLAG (*startp, BGP_ATTR_FLAG_PARTIAL); /* Store transitive attribute to the end of attr->transit. */ - if (! ((attre = bgp_attr_extra_get(attr))->transit) ) - attre->transit = XCALLOC (MTYPE_TRANSIT, sizeof (struct transit)); + if (!attr->transit) + attr->transit = XCALLOC (MTYPE_TRANSIT, sizeof (struct transit)); - transit = attre->transit; + transit = attr->transit; if (transit->val) transit->val = XREALLOC (MTYPE_TRANSIT_VAL, transit->val, @@ -2805,18 +2679,15 @@ bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size, if (ret != BGP_ATTR_PARSE_PROCEED) return ret; } - if (attr->extra) - { - /* Finally intern unknown attribute. */ - if (attr->extra->transit) - attr->extra->transit = transit_intern (attr->extra->transit); - if (attr->extra->encap_subtlvs) - attr->extra->encap_subtlvs = encap_intern (attr->extra->encap_subtlvs, ENCAP_SUBTLV_TYPE); + /* Finally intern unknown attribute. */ + if (attr->transit) + attr->transit = transit_intern (attr->transit); + if (attr->encap_subtlvs) + attr->encap_subtlvs = encap_intern (attr->encap_subtlvs, ENCAP_SUBTLV_TYPE); #if ENABLE_BGP_VNC - if (attr->extra->vnc_subtlvs) - attr->extra->vnc_subtlvs = encap_intern (attr->extra->vnc_subtlvs, VNC_SUBTLV_TYPE); + if (attr->vnc_subtlvs) + attr->vnc_subtlvs = encap_intern (attr->vnc_subtlvs, VNC_SUBTLV_TYPE); #endif - } return BGP_ATTR_PARSE_PROCEED; } @@ -2853,7 +2724,7 @@ bgp_packet_mpattr_start (struct stream *s, struct peer *peer, else if (safi == SAFI_LABELED_UNICAST) nh_afi = afi; else - nh_afi = BGP_NEXTHOP_AFI_FROM_NHLEN(attr->extra->mp_nexthop_len); + nh_afi = BGP_NEXTHOP_AFI_FROM_NHLEN(attr->mp_nexthop_len); /* Nexthop */ bpacket_attr_vec_arr_set_vec (vecarr, BGP_ATTR_VEC_NH, s, attr); @@ -2872,12 +2743,12 @@ bgp_packet_mpattr_start (struct stream *s, struct peer *peer, stream_putc (s, 12); stream_putl (s, 0); /* RD = 0, per RFC */ stream_putl (s, 0); - stream_put (s, &attr->extra->mp_nexthop_global_in, 4); + stream_put (s, &attr->mp_nexthop_global_in, 4); break; case SAFI_ENCAP: case SAFI_EVPN: stream_putc (s, 4); - stream_put (s, &attr->extra->mp_nexthop_global_in, 4); + stream_put (s, &attr->mp_nexthop_global_in, 4); break; default: break; @@ -2891,45 +2762,37 @@ bgp_packet_mpattr_start (struct stream *s, struct peer *peer, case SAFI_LABELED_UNICAST: case SAFI_EVPN: { - struct attr_extra *attre = attr->extra; - - assert (attr->extra); - - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { stream_putc (s, BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL); - stream_put (s, &attre->mp_nexthop_global, IPV6_MAX_BYTELEN); - stream_put (s, &attre->mp_nexthop_local, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_local, IPV6_MAX_BYTELEN); } else { stream_putc (s, IPV6_MAX_BYTELEN); - stream_put (s, &attre->mp_nexthop_global, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); } } break; case SAFI_MPLS_VPN: { - struct attr_extra *attre = attr->extra; - - assert (attr->extra); - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) { + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) { stream_putc (s, 24); stream_putl (s, 0); /* RD = 0, per RFC */ stream_putl (s, 0); - stream_put (s, &attre->mp_nexthop_global, IPV6_MAX_BYTELEN); - } else if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { + stream_put (s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); + } else if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { stream_putc (s, 48); stream_putl (s, 0); /* RD = 0, per RFC */ stream_putl (s, 0); - stream_put (s, &attre->mp_nexthop_global, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); stream_putl (s, 0); /* RD = 0, per RFC */ stream_putl (s, 0); - stream_put (s, &attre->mp_nexthop_local, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_local, IPV6_MAX_BYTELEN); } } break; case SAFI_ENCAP: - assert (attr->extra); stream_putc (s, IPV6_MAX_BYTELEN); - stream_put (s, &attr->extra->mp_nexthop_global, IPV6_MAX_BYTELEN); + stream_put (s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); break; default: break; @@ -2937,7 +2800,7 @@ bgp_packet_mpattr_start (struct stream *s, struct peer *peer, break; default: zlog_err ("Bad nexthop when sening to %s, AFI %u SAFI %u nhlen %d", - peer->host, afi, safi, attr->extra->mp_nexthop_len); + peer->host, afi, safi, attr->mp_nexthop_len); break; } @@ -3007,16 +2870,16 @@ bgp_packet_mpattr_tea( struct bgp_attr_encap_subtlv *st; const char *attrname; - if (!attr || !attr->extra || + if (!attr || (attrtype == BGP_ATTR_ENCAP && - (!attr->extra->encap_tunneltype || - attr->extra->encap_tunneltype == BGP_ENCAP_TYPE_MPLS))) + (!attr->encap_tunneltype || + attr->encap_tunneltype == BGP_ENCAP_TYPE_MPLS))) return; switch (attrtype) { case BGP_ATTR_ENCAP: attrname = "Tunnel Encap"; - subtlvs = attr->extra->encap_subtlvs; + subtlvs = attr->encap_subtlvs; if (subtlvs == NULL) /* nothing to do */ return; /* @@ -3032,7 +2895,7 @@ bgp_packet_mpattr_tea( #if ENABLE_BGP_VNC case BGP_ATTR_VNC: attrname = "VNC"; - subtlvs = attr->extra->vnc_subtlvs; + subtlvs = attr->vnc_subtlvs; if (subtlvs == NULL) /* nothing to do */ return; attrlenfield = 0; /* no outer T + L */ @@ -3071,7 +2934,7 @@ bgp_packet_mpattr_tea( if (attrtype == BGP_ATTR_ENCAP) { /* write outer T+L */ - stream_putw(s, attr->extra->encap_tunneltype); + stream_putw(s, attr->encap_tunneltype); stream_putw(s, attrlenfield - 4); } @@ -3260,8 +3123,6 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, /* Aggregator. */ if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR)) { - assert (attr->extra); - /* 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); @@ -3270,7 +3131,7 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, { /* AS4 capable peer */ stream_putc (s, 8); - stream_putl (s, attr->extra->aggregator_as); + stream_putl (s, attr->aggregator_as); } else { @@ -3278,7 +3139,7 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, stream_putc (s, 6); /* Is ASN representable in 2-bytes? Or must AS_TRANS be used? */ - if ( attr->extra->aggregator_as > 65535 ) + if ( attr->aggregator_as > 65535 ) { stream_putw (s, BGP_AS_TRANS); @@ -3289,9 +3150,9 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, send_as4_aggregator = 1; } else - stream_putw (s, (u_int16_t) attr->extra->aggregator_as); + stream_putw (s, (u_int16_t) attr->aggregator_as); } - stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr); + stream_put_ipv4 (s, attr->aggregator_addr.s_addr); } /* Community attribute. */ @@ -3316,23 +3177,22 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, /* * Large Community attribute. */ - if (attr->extra && - CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY) + if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_LARGE_COMMUNITY) && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES))) { - if (attr->extra->lcommunity->size * 12 > 255) + if (attr->lcommunity->size * 12 > 255) { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN); stream_putc (s, BGP_ATTR_LARGE_COMMUNITIES); - stream_putw (s, attr->extra->lcommunity->size * 12); + stream_putw (s, attr->lcommunity->size * 12); } else { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_LARGE_COMMUNITIES); - stream_putc (s, attr->extra->lcommunity->size * 12); + stream_putc (s, attr->lcommunity->size * 12); } - stream_put (s, attr->extra->lcommunity->val, attr->extra->lcommunity->size * 12); + stream_put (s, attr->lcommunity->val, attr->lcommunity->size * 12); } /* Route Reflector. */ @@ -3346,7 +3206,7 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, stream_putc (s, 4); if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) - stream_put_in_addr (s, &attr->extra->originator_id); + stream_put_in_addr (s, &attr->originator_id); else stream_put_in_addr (s, &from->remote_id); @@ -3354,16 +3214,16 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, stream_putc (s, BGP_ATTR_FLAG_OPTIONAL); stream_putc (s, BGP_ATTR_CLUSTER_LIST); - if (attr->extra && attr->extra->cluster) + if (attr->cluster) { - stream_putc (s, attr->extra->cluster->length + 4); + stream_putc (s, attr->cluster->length + 4); /* If this peer configuration's parent BGP has cluster_id. */ if (bgp->config & BGP_CONFIG_CLUSTER_ID) stream_put_in_addr (s, &bgp->cluster_id); else stream_put_in_addr (s, &bgp->router_id); - stream_put (s, attr->extra->cluster->list, - attr->extra->cluster->length); + stream_put (s, attr->cluster->list, + attr->cluster->length); } else { @@ -3380,26 +3240,22 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY) && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) { - struct attr_extra *attre = attr->extra; - - assert (attre); - if (peer->sort == BGP_PEER_IBGP || peer->sort == BGP_PEER_CONFED) { - if (attre->ecommunity->size * 8 > 255) + if (attr->ecommunity->size * 8 > 255) { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN); stream_putc (s, BGP_ATTR_EXT_COMMUNITIES); - stream_putw (s, attre->ecommunity->size * 8); + stream_putw (s, attr->ecommunity->size * 8); } else { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_EXT_COMMUNITIES); - stream_putc (s, attre->ecommunity->size * 8); + stream_putc (s, attr->ecommunity->size * 8); } - stream_put (s, attre->ecommunity->val, attre->ecommunity->size * 8); + stream_put (s, attr->ecommunity->val, attr->ecommunity->size * 8); } else { @@ -3408,9 +3264,9 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, int ecom_tr_size = 0; int i; - for (i = 0; i < attre->ecommunity->size; i++) + for (i = 0; i < attr->ecommunity->size; i++) { - pnt = attre->ecommunity->val + (i * 8); + pnt = attr->ecommunity->val + (i * 8); tbit = *pnt; if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE)) @@ -3434,9 +3290,9 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, stream_putc (s, ecom_tr_size * 8); } - for (i = 0; i < attre->ecommunity->size; i++) + for (i = 0; i < attr->ecommunity->size; i++) { - pnt = attre->ecommunity->val + (i * 8); + pnt = attr->ecommunity->val + (i * 8); tbit = *pnt; if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE)) @@ -3455,8 +3311,7 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, { u_int32_t label_index; - assert (attr->extra); - label_index = attr->extra->label_index; + label_index = attr->label_index; if (label_index != BGP_INVALID_LABEL_INDEX) { @@ -3500,8 +3355,6 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, if ( send_as4_aggregator ) { - assert (attr->extra); - /* send AS4_AGGREGATOR, at this place */ /* this section of code moved here in order to ensure the correct * *ascending* order of attributes @@ -3509,8 +3362,8 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_AS4_AGGREGATOR); stream_putc (s, 8); - stream_putl (s, attr->extra->aggregator_as); - stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr); + stream_putl (s, attr->aggregator_as); + stream_put_ipv4 (s, attr->aggregator_addr.s_addr); } if (((afi == AFI_IP || afi == AFI_IP6) && @@ -3527,8 +3380,8 @@ bgp_packet_attribute (struct bgp *bgp, struct peer *peer, } /* Unknown transit attribute. */ - if (attr->extra && attr->extra->transit) - stream_put (s, attr->extra->transit->val, attr->extra->transit->length); + if (attr->transit) + stream_put (s, attr->transit->val, attr->transit->length); /* Return total size of attribute. */ return stream_get_endp (s) - cp; @@ -3678,12 +3531,11 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr, /* Aggregator. */ if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR)) { - assert (attr->extra); stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_AGGREGATOR); stream_putc (s, 8); - stream_putl (s, attr->extra->aggregator_as); - stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr); + stream_putl (s, attr->aggregator_as); + stream_put_ipv4 (s, attr->aggregator_addr.s_addr); } /* Community attribute. */ @@ -3705,32 +3557,31 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr, } /* Large Community attribute. */ - if (attr->extra && attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES)) + if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES)) { - if (attr->extra->lcommunity->size * 12 > 255) + if (attr->lcommunity->size * 12 > 255) { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN); stream_putc (s, BGP_ATTR_LARGE_COMMUNITIES); - stream_putw (s, attr->extra->lcommunity->size * 12); + stream_putw (s, attr->lcommunity->size * 12); } else { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_LARGE_COMMUNITIES); - stream_putc (s, attr->extra->lcommunity->size * 12); + stream_putc (s, attr->lcommunity->size * 12); } - stream_put (s, attr->extra->lcommunity->val, attr->extra->lcommunity->size * 12); + stream_put (s, attr->lcommunity->val, attr->lcommunity->size * 12); } /* Add a MP_NLRI attribute to dump the IPv6 next hop */ - if (prefix != NULL && prefix->family == AF_INET6 && attr->extra && - (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL || - attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) ) + if (prefix != NULL && prefix->family == AF_INET6 && + (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL || + attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) ) { int sizep; - struct attr_extra *attre = attr->extra; - + stream_putc(s, BGP_ATTR_FLAG_OPTIONAL); stream_putc(s, BGP_ATTR_MP_REACH_NLRI); sizep = stream_get_endp (s); @@ -3741,10 +3592,10 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr, stream_putc(s, SAFI_UNICAST); /* SAFI */ /* Next hop */ - stream_putc(s, attre->mp_nexthop_len); - stream_put(s, &attre->mp_nexthop_global, IPV6_MAX_BYTELEN); - if (attre->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) - stream_put(s, &attre->mp_nexthop_local, IPV6_MAX_BYTELEN); + stream_putc(s, attr->mp_nexthop_len); + stream_put(s, &attr->mp_nexthop_global, IPV6_MAX_BYTELEN); + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + stream_put(s, &attr->mp_nexthop_local, IPV6_MAX_BYTELEN); /* SNPA */ stream_putc(s, 0); @@ -3759,9 +3610,7 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr, /* Prefix SID */ if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID)) { - assert (attr->extra); - - if (attr->extra->label_index != BGP_INVALID_LABEL_INDEX) + if (attr->label_index != BGP_INVALID_LABEL_INDEX) { stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS); stream_putc (s, BGP_ATTR_PREFIX_SID); @@ -3770,7 +3619,7 @@ bgp_dump_routes_attr (struct stream *s, struct attr *attr, stream_putc (s, BGP_PREFIX_SID_LABEL_INDEX_LENGTH); stream_putc (s, 0); // reserved stream_putw (s, 0); // flags - stream_putl (s, attr->extra->label_index); + stream_putl (s, attr->label_index); } } diff --git a/bgpd/bgp_attr.h b/bgpd/bgp_attr.h index c7dca435ba..99c6a6b79f 100644 --- a/bgpd/bgp_attr.h +++ b/bgpd/bgp_attr.h @@ -98,13 +98,35 @@ struct overlay_index union gw_addr gw_ip; }; -/* Additional/uncommon BGP attributes. - * lazily allocated as and when a struct attr - * requires it. - */ -struct attr_extra +/* BGP core attribute structure. */ +struct attr { - /* Multi-Protocol Nexthop, AFI IPv6 */ + /* AS Path structure */ + struct aspath *aspath; + + /* Community structure */ + struct community *community; + + /* Reference count of this attribute. */ + unsigned long refcnt; + + /* Flag of attribute is set or not. */ + uint64_t flag; + + /* Apart from in6_addr, the remaining static attributes */ + struct in_addr nexthop; + u_int32_t med; + u_int32_t local_pref; + ifindex_t nh_ifindex; + + /* Path origin attribute */ + u_char origin; + + /* has the route-map changed any attribute? + Used on the peer outbound side. */ + u_int32_t rmap_change_flags; + + /* Multi-Protocol Nexthop, AFI IPv6 */ struct in6_addr mp_nexthop_global; struct in6_addr mp_nexthop_local; @@ -165,38 +187,6 @@ struct attr_extra u_int32_t mm_seqnum; }; -/* BGP core attribute structure. */ -struct attr -{ - /* AS Path structure */ - struct aspath *aspath; - - /* Community structure */ - struct community *community; - - /* Lazily allocated pointer to extra attributes */ - struct attr_extra *extra; - - /* Reference count of this attribute. */ - unsigned long refcnt; - - /* Flag of attribute is set or not. */ - uint64_t flag; - - /* Apart from in6_addr, the remaining static attributes */ - struct in_addr nexthop; - u_int32_t med; - u_int32_t local_pref; - ifindex_t nh_ifindex; - - /* Path origin attribute */ - u_char origin; - - /* has the route-map changed any attribute? - Used on the peer outbound side. */ - u_int32_t rmap_change_flags; -}; - /* rmap_change_flags definition */ #define BATTR_RMAP_IPV4_NHOP_CHANGED (1 << 0) #define BATTR_RMAP_NEXTHOP_PEER_ADDRESS (1 << 1) @@ -226,7 +216,7 @@ struct transit #define BGP_CLUSTER_LIST_LENGTH(attr) \ (((attr)->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST)) ? \ - (attr)->extra->cluster->length : 0) + (attr)->cluster->length : 0) typedef enum { BGP_ATTR_PARSE_PROCEED = 0, @@ -245,8 +235,6 @@ extern void bgp_attr_finish (void); extern bgp_attr_parse_ret_t bgp_attr_parse (struct peer *, struct attr *, bgp_size_t, struct bgp_nlri *, struct bgp_nlri *); -extern struct attr_extra *bgp_attr_extra_get (struct attr *); -extern void bgp_attr_extra_free (struct attr *); extern void bgp_attr_dup (struct attr *, struct attr *); extern void bgp_attr_deep_dup (struct attr *, struct attr *); extern void bgp_attr_deep_free (struct attr *); @@ -342,7 +330,7 @@ bgp_rmap_nhop_changed(u_int32_t out_rmap_flags, u_int32_t in_rmap_flags) static inline u_int32_t mac_mobility_seqnum (struct attr *attr) { - return (attr && attr->extra) ? attr->extra->mm_seqnum : 0; + return (attr) ? attr->mm_seqnum : 0; } #endif /* _QUAGGA_BGP_ATTR_H */ diff --git a/bgpd/bgp_attr_evpn.c b/bgpd/bgp_attr_evpn.c index e66fdde5f6..aa175bcf51 100644 --- a/bgpd/bgp_attr_evpn.c +++ b/bgpd/bgp_attr_evpn.c @@ -39,17 +39,14 @@ void bgp_add_routermac_ecom(struct attr *attr, struct ethaddr *routermac) { struct ecommunity_val routermac_ecom; - if (attr->extra) - { - memset(&routermac_ecom, 0, sizeof(struct ecommunity_val)); - routermac_ecom.val[0] = ECOMMUNITY_ENCODE_EVPN; - routermac_ecom.val[1] = ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC; - memcpy(&routermac_ecom.val[2], routermac->octet, ETHER_ADDR_LEN); - if (!attr->extra->ecommunity) - attr->extra->ecommunity = ecommunity_new(); - ecommunity_add_val(attr->extra->ecommunity, &routermac_ecom); - ecommunity_str (attr->extra->ecommunity); - } + memset(&routermac_ecom, 0, sizeof(struct ecommunity_val)); + routermac_ecom.val[0] = ECOMMUNITY_ENCODE_EVPN; + routermac_ecom.val[1] = ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC; + memcpy(&routermac_ecom.val[2], routermac->octet, ETHER_ADDR_LEN); + if (!attr->ecommunity) + attr->ecommunity = ecommunity_new(); + ecommunity_add_val(attr->ecommunity, &routermac_ecom); + ecommunity_str (attr->ecommunity); } /* converts to an esi @@ -119,7 +116,7 @@ bgp_attr_mac_mobility_seqnum (struct attr *attr, u_char *sticky) int i; u_char flags = 0; - ecom = attr->extra->ecommunity; + ecom = attr->ecommunity; if (!ecom || !ecom->size) return 0; diff --git a/bgpd/bgp_debug.c b/bgpd/bgp_debug.c index a48df5c0c8..e4495c488c 100644 --- a/bgpd/bgp_debug.c +++ b/bgpd/bgp_debug.c @@ -387,6 +387,8 @@ bgp_debug_peer_updout_enabled(char *host) int bgp_dump_attr (struct attr *attr, char *buf, size_t size) { + char addrbuf[BUFSIZ]; + if (! attr) return 0; @@ -397,73 +399,68 @@ bgp_dump_attr (struct attr *attr, char *buf, size_t size) snprintf (buf + strlen (buf), size - strlen (buf), ", origin %s", bgp_origin_str[attr->origin]); - if (attr->extra) - { - char addrbuf[BUFSIZ]; + /* Add MP case. */ + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL + || attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + snprintf (buf + strlen (buf), size - strlen (buf), ", mp_nexthop %s", + inet_ntop (AF_INET6, &attr->mp_nexthop_global, + addrbuf, BUFSIZ)); - /* Add MP case. */ - if (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL - || attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) - snprintf (buf + strlen (buf), size - strlen (buf), ", mp_nexthop %s", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, - addrbuf, BUFSIZ)); + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + snprintf (buf + strlen (buf), size - strlen (buf), "(%s)", + inet_ntop (AF_INET6, &attr->mp_nexthop_local, + addrbuf, BUFSIZ)); - if (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) - snprintf (buf + strlen (buf), size - strlen (buf), "(%s)", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, - addrbuf, BUFSIZ)); - - if (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4) - snprintf (buf, size, "nexthop %s", inet_ntoa (attr->nexthop)); - } + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV4) + snprintf (buf, size, "nexthop %s", inet_ntoa (attr->nexthop)); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (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_MULTI_EXIT_DISC))) + if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (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 (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES))) snprintf (buf + strlen (buf), size - strlen (buf), ", community %s", community_str (attr->community)); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) snprintf (buf + strlen (buf), size - strlen (buf), ", extcommunity %s", - ecommunity_str (attr->extra->ecommunity)); + ecommunity_str (attr->ecommunity)); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))) snprintf (buf + strlen (buf), size - strlen (buf), ", atomic-aggregate"); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))) snprintf (buf + strlen (buf), size - strlen (buf), ", aggregated by %u %s", - attr->extra->aggregator_as, - inet_ntoa (attr->extra->aggregator_addr)); + attr->aggregator_as, + inet_ntoa (attr->aggregator_addr)); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID))) snprintf (buf + strlen (buf), size - strlen (buf), ", originator %s", - inet_ntoa (attr->extra->originator_id)); + inet_ntoa (attr->originator_id)); if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST))) { int i; snprintf (buf + strlen (buf), size - strlen (buf), ", clusterlist"); - for (i = 0; i < attr->extra->cluster->length / 4; i++) + for (i = 0; i < attr->cluster->length / 4; i++) snprintf (buf + strlen (buf), size - strlen (buf), " %s", - inet_ntoa (attr->extra->cluster->list[i])); + inet_ntoa (attr->cluster->list[i])); } - if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH))) + if (CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (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 (attr->extra->label_index != BGP_INVALID_LABEL_INDEX) + if (attr->label_index != BGP_INVALID_LABEL_INDEX) snprintf (buf + strlen (buf), size - strlen (buf), ", label-index %u", - attr->extra->label_index); + attr->label_index); } if (strlen (buf) > 1) diff --git a/bgpd/bgp_encap_tlv.c b/bgpd/bgp_encap_tlv.c index eee2cb72c3..89194980d1 100644 --- a/bgpd/bgp_encap_tlv.c +++ b/bgpd/bgp_encap_tlv.c @@ -238,7 +238,7 @@ subtlv_encode_remote_endpoint( if (last) {\ last->next = new;\ } else {\ - extra->encap_subtlvs = new;\ + attr->encap_subtlvs = new;\ }\ last = new;\ }\ @@ -249,13 +249,12 @@ bgp_encap_type_l2tpv3overip_to_tlv( struct bgp_encap_type_l2tpv3_over_ip *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_L2TPV3_OVER_IP; + attr->encap_tunneltype = BGP_ENCAP_TYPE_L2TPV3_OVER_IP; assert(CHECK_FLAG(bet->valid_subtlvs, BGP_TEA_SUBTLV_ENCAP)); @@ -270,13 +269,12 @@ bgp_encap_type_gre_to_tlv( struct bgp_encap_type_gre *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_GRE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_GRE; ENC_SUBTLV(BGP_TEA_SUBTLV_ENCAP, subtlv_encode_encap_gre, st_encap); ENC_SUBTLV(BGP_TEA_SUBTLV_PROTO_TYPE, subtlv_encode_proto_type, st_proto); @@ -289,13 +287,12 @@ bgp_encap_type_ip_in_ip_to_tlv( struct bgp_encap_type_ip_in_ip *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP; + attr->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP; ENC_SUBTLV(BGP_TEA_SUBTLV_PROTO_TYPE, subtlv_encode_proto_type, st_proto); ENC_SUBTLV(BGP_TEA_SUBTLV_COLOR, subtlv_encode_color, st_color); @@ -307,13 +304,12 @@ bgp_encap_type_transmit_tunnel_endpoint( struct bgp_encap_type_transmit_tunnel_endpoint *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT; + attr->encap_tunneltype = BGP_ENCAP_TYPE_TRANSMIT_TUNNEL_ENDPOINT; /* no subtlvs for this type */ } @@ -323,13 +319,12 @@ bgp_encap_type_ipsec_in_tunnel_mode_to_tlv( struct bgp_encap_type_ipsec_in_tunnel_mode *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_IPSEC_IN_TUNNEL_MODE; ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta); } @@ -339,13 +334,12 @@ bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode_to_tlv( struct bgp_encap_type_ip_in_ip_tunnel_with_ipsec_transport_mode *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_IP_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE; ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta); } @@ -355,13 +349,12 @@ bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode_to_tlv( struct bgp_encap_type_mpls_in_ip_tunnel_with_ipsec_transport_mode *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_IP_TUNNEL_WITH_IPSEC_TRANSPORT_MODE; ENC_SUBTLV(BGP_TEA_SUBTLV_IPSEC_TA, subtlv_encode_ipsec_ta, st_ipsec_ta); } @@ -371,13 +364,12 @@ bgp_encap_type_pbb_to_tlv( struct bgp_encap_type_pbb *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *last; /* advance to last subtlv */ - for (last = extra->encap_subtlvs; last && last->next; last = last->next); + for (last = attr->encap_subtlvs; last && last->next; last = last->next); - extra->encap_tunneltype = BGP_ENCAP_TYPE_PBB; + attr->encap_tunneltype = BGP_ENCAP_TYPE_PBB; assert(CHECK_FLAG(bet->valid_subtlvs, BGP_TEA_SUBTLV_ENCAP)); ENC_SUBTLV(BGP_TEA_SUBTLV_ENCAP, subtlv_encode_encap_pbb, st_encap); @@ -388,16 +380,15 @@ bgp_encap_type_vxlan_to_tlv( struct bgp_encap_type_vxlan *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); struct bgp_attr_encap_subtlv *tlv; uint32_t vnid; - extra->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN; + attr->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN; if(bet == NULL ||!bet->vnid) return; - if(extra->encap_subtlvs) - XFREE(MTYPE_ENCAP_TLV, extra->encap_subtlvs); + if(attr->encap_subtlvs) + XFREE(MTYPE_ENCAP_TLV, attr->encap_subtlvs); tlv = XCALLOC (MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv)-1+12); tlv->type = 1; /* encapsulation type */ tlv->length = 12; @@ -411,7 +402,7 @@ bgp_encap_type_vxlan_to_tlv( char *ptr = (char *)&tlv->value + 4; memcpy( ptr, bet->mac_address, 6); } - extra->encap_subtlvs = tlv; + attr->encap_subtlvs = tlv; return; } @@ -420,9 +411,7 @@ bgp_encap_type_nvgre_to_tlv( struct bgp_encap_type_nvgre *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); - - extra->encap_tunneltype = BGP_ENCAP_TYPE_NVGRE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_NVGRE; } void @@ -438,9 +427,7 @@ bgp_encap_type_mpls_in_gre_to_tlv( struct bgp_encap_type_mpls_in_gre *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); - - extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_GRE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_GRE; } void @@ -448,9 +435,8 @@ bgp_encap_type_vxlan_gpe_to_tlv( struct bgp_encap_type_vxlan_gpe *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); - extra->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN_GPE; + attr->encap_tunneltype = BGP_ENCAP_TYPE_VXLAN_GPE; } void @@ -458,9 +444,8 @@ bgp_encap_type_mpls_in_udp_to_tlv( struct bgp_encap_type_mpls_in_udp *bet, /* input structure */ struct attr *attr) { - struct attr_extra *extra = bgp_attr_extra_get(attr); - extra->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_UDP; + attr->encap_tunneltype = BGP_ENCAP_TYPE_MPLS_IN_UDP; } diff --git a/bgpd/bgp_evpn.c b/bgpd/bgp_evpn.c index d012952784..46e97cc50d 100644 --- a/bgpd/bgp_evpn.c +++ b/bgpd/bgp_evpn.c @@ -450,7 +450,6 @@ bgp_zebra_send_remote_vtep (struct bgp *bgp, struct bgpevpn *vpn, static void build_evpn_route_extcomm (struct bgpevpn *vpn, struct attr *attr) { - struct attr_extra *attre; struct ecommunity ecom_encap; struct ecommunity ecom_sticky; struct ecommunity_val eval; @@ -460,8 +459,6 @@ build_evpn_route_extcomm (struct bgpevpn *vpn, struct attr *attr) struct ecommunity *ecom; u_int32_t seqnum; - attre = bgp_attr_extra_get (attr); - /* Encap */ tnl_type = BGP_ENCAP_TYPE_VXLAN; memset (&ecom_encap, 0, sizeof (ecom_encap)); @@ -470,20 +467,20 @@ build_evpn_route_extcomm (struct bgpevpn *vpn, struct attr *attr) ecom_encap.val = (u_int8_t *)eval.val; /* Add Encap */ - attre->ecommunity = ecommunity_dup (&ecom_encap); + attr->ecommunity = ecommunity_dup (&ecom_encap); /* Add the export RTs */ for (ALL_LIST_ELEMENTS (vpn->export_rtl, node, nnode, ecom)) - attre->ecommunity = ecommunity_merge (attre->ecommunity, ecom); + attr->ecommunity = ecommunity_merge (attr->ecommunity, ecom); - if (attre->sticky) + if (attr->sticky) { seqnum = 0; memset (&ecom_sticky, 0, sizeof (ecom_sticky)); encode_mac_mobility_extcomm(1, seqnum, &eval_sticky); ecom_sticky.size = 1; ecom_sticky.val = (u_int8_t *)eval_sticky.val; - attre->ecommunity = ecommunity_merge (attre->ecommunity, &ecom_sticky); + attr->ecommunity = ecommunity_merge (attr->ecommunity, &ecom_sticky); } attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); @@ -495,7 +492,6 @@ build_evpn_route_extcomm (struct bgpevpn *vpn, struct attr *attr) static void add_mac_mobility_to_attr (u_int32_t seq_num, struct attr *attr) { - struct attr_extra *attre; struct ecommunity ecom_tmp; struct ecommunity_val eval; struct ecommunity *ecom_mm; @@ -504,25 +500,23 @@ add_mac_mobility_to_attr (u_int32_t seq_num, struct attr *attr) int type = 0; int sub_type = 0; - attre = bgp_attr_extra_get (attr); - /* Build MM */ encode_mac_mobility_extcomm (0, seq_num, &eval); /* Find current MM ecommunity */ ecom_mm = NULL; - if (attre->ecommunity) + if (attr->ecommunity) { - for (i = 0; i < attre->ecommunity->size; i++) + for (i = 0; i < attr->ecommunity->size; i++) { - pnt = attre->ecommunity->val + (i * 8); + pnt = attr->ecommunity->val + (i * 8); type = *pnt++; sub_type = *pnt++; if (type == ECOMMUNITY_ENCODE_EVPN && sub_type == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY) { - ecom_mm = (struct ecommunity*) attre->ecommunity->val + (i * 8); + ecom_mm = (struct ecommunity*) attr->ecommunity->val + (i * 8); break; } } @@ -540,7 +534,7 @@ add_mac_mobility_to_attr (u_int32_t seq_num, struct attr *attr) ecom_tmp.size = 1; ecom_tmp.val = (u_int8_t *)eval.val; - attre->ecommunity = ecommunity_merge (attre->ecommunity, &ecom_tmp); + attr->ecommunity = ecommunity_merge (attr->ecommunity, &ecom_tmp); } } @@ -645,7 +639,7 @@ evpn_route_select_install (struct bgp *bgp, struct bgpevpn *vpn, if (bgp_zebra_has_route_changed (rn, old_select)) ret = evpn_zebra_install (bgp, vpn, (struct prefix_evpn *)&rn->p, old_select->attr->nexthop, - old_select->attr->extra->sticky); + old_select->attr->sticky); UNSET_FLAG (old_select->flags, BGP_INFO_MULTIPATH_CHG); bgp_zebra_clear_route_change_flags (rn); return ret; @@ -675,7 +669,7 @@ evpn_route_select_install (struct bgp *bgp, struct bgpevpn *vpn, { ret = evpn_zebra_install (bgp, vpn, (struct prefix_evpn *) &rn->p, new_select->attr->nexthop, - new_select->attr->extra->sticky); + new_select->attr->sticky); /* If an old best existed and it was a "local" route, the only reason * it would be supplanted is due to MAC mobility procedures. So, we * need to do an implicit delete and withdraw that route from peers. @@ -727,7 +721,7 @@ evpn_route_is_sticky (struct bgp *bgp, struct bgp_node *rn) if (!local_ri) return 0; - return local_ri->attr->extra->sticky; + return local_ri->attr->sticky; } /* @@ -801,8 +795,8 @@ update_evpn_route_entry (struct bgp *bgp, struct bgpevpn *vpn, afi_t afi, attr_new = bgp_attr_intern (attr); /* Extract MAC mobility sequence number, if any. */ - attr_new->extra->mm_seqnum = bgp_attr_mac_mobility_seqnum (attr_new, &sticky); - attr_new->extra->sticky = sticky; + attr_new->mm_seqnum = bgp_attr_mac_mobility_seqnum (attr_new, &sticky); + attr_new->sticky = sticky; /* Create new route with its attribute. */ tmp_ri = info_make (ZEBRA_ROUTE_BGP, BGP_ROUTE_STATIC, 0, @@ -866,9 +860,9 @@ update_evpn_route (struct bgp *bgp, struct bgpevpn *vpn, /* Build path-attribute for this route. */ bgp_attr_default_set (&attr, BGP_ORIGIN_IGP); attr.nexthop = vpn->originator_ip; - attr.extra->mp_nexthop_global_in = vpn->originator_ip; - attr.extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; - attr.extra->sticky = sticky; + attr.mp_nexthop_global_in = vpn->originator_ip; + attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; + attr.sticky = sticky; /* Set up RT and ENCAP extended community. */ build_evpn_route_extcomm (vpn, &attr); @@ -910,7 +904,6 @@ update_evpn_route (struct bgp *bgp, struct bgpevpn *vpn, /* Unintern temporary. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return 0; } @@ -1017,12 +1010,12 @@ update_all_type2_routes (struct bgp *bgp, struct bgpevpn *vpn) bgp_attr_default_set (&attr, BGP_ORIGIN_IGP); bgp_attr_default_set (&attr_sticky, BGP_ORIGIN_IGP); attr.nexthop = vpn->originator_ip; - attr.extra->mp_nexthop_global_in = vpn->originator_ip; - attr.extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; + attr.mp_nexthop_global_in = vpn->originator_ip; + attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; attr_sticky.nexthop = vpn->originator_ip; - attr_sticky.extra->mp_nexthop_global_in = vpn->originator_ip; - attr_sticky.extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; - attr_sticky.extra->sticky = 1; + attr_sticky.mp_nexthop_global_in = vpn->originator_ip; + attr_sticky.mp_nexthop_len = BGP_ATTR_NHLEN_IPV4; + attr_sticky.sticky = 1; /* Set up RT, ENCAP and sticky MAC extended community. */ build_evpn_route_extcomm (vpn, &attr); @@ -1073,8 +1066,6 @@ update_all_type2_routes (struct bgp *bgp, struct bgpevpn *vpn) /* Unintern temporary. */ aspath_unintern (&attr.aspath); aspath_unintern (&attr_sticky.aspath); - bgp_attr_extra_free (&attr); - bgp_attr_extra_free (&attr_sticky); return 0; } @@ -1376,7 +1367,7 @@ is_route_matching_for_vni (struct bgp *bgp, struct bgpevpn *vpn, if (!(attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) return 0; - ecom = attr->extra->ecommunity; + ecom = attr->ecommunity; if (!ecom || !ecom->size) return 0; @@ -1592,7 +1583,7 @@ install_uninstall_evpn_route (struct bgp *bgp, afi_t afi, safi_t safi, if (!(attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES))) return 0; - ecom = attr->extra->ecommunity; + ecom = attr->ecommunity; if (!ecom || !ecom->size) return -1; @@ -2095,8 +2086,8 @@ evpn_mpattr_encode_type5 (struct stream *s, struct prefix *p, /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */ stream_putc(s, 8 + 10 + 4 + 1 + len + 3); stream_put(s, prd->val, 8); - if (attr && attr->extra) - stream_put(s, &(attr->extra->evpn_overlay.eth_s_id), 10); + if (attr && attr) + stream_put(s, &(attr->evpn_overlay.eth_s_id), 10); else stream_put(s, &temp, 10); stream_putl(s, p_evpn_p->eth_tag); @@ -2105,12 +2096,12 @@ evpn_mpattr_encode_type5 (struct stream *s, struct prefix *p, stream_put_ipv4(s, p_evpn_p->ip.ipaddr_v4.s_addr); else stream_put(s, &p_evpn_p->ip.ipaddr_v6, 16); - if (attr && attr->extra) + if (attr && attr) { if (IS_IPADDR_V4(&p_evpn_p->ip)) - stream_put_ipv4(s, attr->extra->evpn_overlay.gw_ip.ipv4. s_addr); + stream_put_ipv4(s, attr->evpn_overlay.gw_ip.ipv4. s_addr); else - stream_put(s, &(attr->extra->evpn_overlay.gw_ip.ipv6), 16); + stream_put(s, &(attr->evpn_overlay.gw_ip.ipv6), 16); } else { diff --git a/bgpd/bgp_label.c b/bgpd/bgp_label.c index fc0654f186..27533a5815 100644 --- a/bgpd/bgp_label.c +++ b/bgpd/bgp_label.c @@ -151,12 +151,10 @@ bgp_reg_dereg_for_label (struct bgp_node *rn, struct bgp_info *ri, assert (ri); if (ri->attr->flag & ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID)) { - assert (ri->attr->extra); - - if (ri->attr->extra->label_index != BGP_INVALID_LABEL_INDEX) + if (ri->attr->label_index != BGP_INVALID_LABEL_INDEX) { flags |= ZEBRA_FEC_REGISTER_LABEL_INDEX; - stream_putl (s, ri->attr->extra->label_index); + stream_putl (s, ri->attr->label_index); } } SET_FLAG (rn->flags, BGP_NODE_REGISTERED_FOR_LABEL); diff --git a/bgpd/bgp_memory.c b/bgpd/bgp_memory.c index 1913706587..6da9ff8682 100644 --- a/bgpd/bgp_memory.c +++ b/bgpd/bgp_memory.c @@ -43,7 +43,6 @@ DEFINE_MTYPE(BGPD, BGP_UPDGRP, "BGP update group") DEFINE_MTYPE(BGPD, BGP_UPD_SUBGRP, "BGP update subgroup") DEFINE_MTYPE(BGPD, BGP_PACKET, "BGP packet") DEFINE_MTYPE(BGPD, ATTR, "BGP attribute") -DEFINE_MTYPE(BGPD, ATTR_EXTRA, "BGP extra attributes") DEFINE_MTYPE(BGPD, AS_PATH, "BGP aspath") DEFINE_MTYPE(BGPD, AS_SEG, "BGP aspath seg") DEFINE_MTYPE(BGPD, AS_SEG_DATA, "BGP aspath segment data") diff --git a/bgpd/bgp_memory.h b/bgpd/bgp_memory.h index 185369d230..152cfaeaf2 100644 --- a/bgpd/bgp_memory.h +++ b/bgpd/bgp_memory.h @@ -39,7 +39,6 @@ DECLARE_MTYPE(BGP_UPDGRP) DECLARE_MTYPE(BGP_UPD_SUBGRP) DECLARE_MTYPE(BGP_PACKET) DECLARE_MTYPE(ATTR) -DECLARE_MTYPE(ATTR_EXTRA) DECLARE_MTYPE(AS_PATH) DECLARE_MTYPE(AS_SEG) DECLARE_MTYPE(AS_SEG_DATA) diff --git a/bgpd/bgp_mpath.c b/bgpd/bgp_mpath.c index 34690ac776..7ea5c9e773 100644 --- a/bgpd/bgp_mpath.c +++ b/bgpd/bgp_mpath.c @@ -106,35 +106,31 @@ bgp_maximum_paths_unset (struct bgp *bgp, afi_t afi, safi_t safi, int bgp_info_nexthop_cmp (struct bgp_info *bi1, struct bgp_info *bi2) { - struct attr_extra *ae1, *ae2; int compare; - ae1 = bi1->attr->extra; - ae2 = bi2->attr->extra; - compare = IPV4_ADDR_CMP (&bi1->attr->nexthop, &bi2->attr->nexthop); - if (!compare && ae1 && ae2) + if (!compare) { - if (ae1->mp_nexthop_len == ae2->mp_nexthop_len) + if (bi1->attr->mp_nexthop_len == bi2->attr->mp_nexthop_len) { - switch (ae1->mp_nexthop_len) + switch (bi1->attr->mp_nexthop_len) { case BGP_ATTR_NHLEN_IPV4: case BGP_ATTR_NHLEN_VPNV4: - compare = IPV4_ADDR_CMP (&ae1->mp_nexthop_global_in, - &ae2->mp_nexthop_global_in); + compare = IPV4_ADDR_CMP (&bi1->attr->mp_nexthop_global_in, + &bi2->attr->mp_nexthop_global_in); break; case BGP_ATTR_NHLEN_IPV6_GLOBAL: case BGP_ATTR_NHLEN_VPNV6_GLOBAL: - compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_global, - &ae2->mp_nexthop_global); + compare = IPV6_ADDR_CMP (&bi1->attr->mp_nexthop_global, + &bi2->attr->mp_nexthop_global); break; case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL: - compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_global, - &ae2->mp_nexthop_global); + compare = IPV6_ADDR_CMP (&bi1->attr->mp_nexthop_global, + &bi2->attr->mp_nexthop_global); if (!compare) - compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_local, - &ae2->mp_nexthop_local); + compare = IPV6_ADDR_CMP (&bi1->attr->mp_nexthop_local, + &bi2->attr->mp_nexthop_local); break; } } @@ -142,14 +138,14 @@ bgp_info_nexthop_cmp (struct bgp_info *bi1, struct bgp_info *bi2) /* This can happen if one IPv6 peer sends you global and link-local * nexthops but another IPv6 peer only sends you global */ - else if (ae1->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL || - ae1->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + else if (bi1->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL || + bi1->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { - compare = IPV6_ADDR_CMP (&ae1->mp_nexthop_global, - &ae2->mp_nexthop_global); + compare = IPV6_ADDR_CMP (&bi1->attr->mp_nexthop_global, + &bi2->attr->mp_nexthop_global); if (!compare) { - if (ae1->mp_nexthop_len < ae2->mp_nexthop_len) + if (bi1->attr->mp_nexthop_len < bi2->attr->mp_nexthop_len) compare = -1; else compare = 1; @@ -663,7 +659,6 @@ bgp_info_mpath_aggregate_update (struct bgp_info *new_best, struct community *community, *commerge; struct ecommunity *ecomm, *ecommerge; struct lcommunity *lcomm, *lcommerge; - struct attr_extra *ae; struct attr attr = { 0 }; if (old_best && (old_best != new_best) && @@ -697,9 +692,8 @@ bgp_info_mpath_aggregate_update (struct bgp_info *new_best, aspath = aspath_dup (attr.aspath); origin = attr.origin; community = attr.community ? community_dup (attr.community) : NULL; - ae = attr.extra; - ecomm = (ae && ae->ecommunity) ? ecommunity_dup (ae->ecommunity) : NULL; - lcomm = (ae && ae->lcommunity) ? lcommunity_dup (ae->lcommunity) : NULL; + ecomm = (attr.ecommunity) ? ecommunity_dup (attr.ecommunity) : NULL; + lcomm = (attr.lcommunity) ? lcommunity_dup (attr.lcommunity) : NULL; for (mpinfo = bgp_info_mpath_first (new_best); mpinfo; mpinfo = bgp_info_mpath_next (mpinfo)) @@ -723,28 +717,27 @@ bgp_info_mpath_aggregate_update (struct bgp_info *new_best, community = community_dup (mpinfo->attr->community); } - ae = mpinfo->attr->extra; - if (ae && ae->ecommunity) + if (mpinfo->attr->ecommunity) { if (ecomm) { - ecommerge = ecommunity_merge (ecomm, ae->ecommunity); + ecommerge = ecommunity_merge (ecomm, mpinfo->attr->ecommunity); ecomm = ecommunity_uniq_sort (ecommerge); ecommunity_free (&ecommerge); } else - ecomm = ecommunity_dup (ae->ecommunity); + ecomm = ecommunity_dup (mpinfo->attr->ecommunity); } - if (ae && ae->lcommunity) + if (mpinfo->attr->lcommunity) { if (lcomm) { - lcommerge = lcommunity_merge (lcomm, ae->lcommunity); + lcommerge = lcommunity_merge (lcomm, mpinfo->attr->lcommunity); lcomm = lcommunity_uniq_sort (lcommerge); lcommunity_free (&lcommerge); } else - lcomm = lcommunity_dup (ae->lcommunity); + lcomm = lcommunity_dup (mpinfo->attr->lcommunity); } } @@ -757,21 +750,18 @@ bgp_info_mpath_aggregate_update (struct bgp_info *new_best, } if (ecomm) { - ae = bgp_attr_extra_get (&attr); - ae->ecommunity = ecomm; + attr.ecommunity = ecomm; attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); } /* Zap multipath attr nexthop so we set nexthop to self */ attr.nexthop.s_addr = 0; - if (attr.extra) - memset (&attr.extra->mp_nexthop_global, 0, sizeof (struct in6_addr)); + memset (&attr.mp_nexthop_global, 0, sizeof (struct in6_addr)); /* TODO: should we set ATOMIC_AGGREGATE and AGGREGATOR? */ } new_attr = bgp_attr_intern (&attr); - bgp_attr_extra_free (&attr); if (new_attr != bgp_info_mpath_attr (new_best)) { diff --git a/bgpd/bgp_nht.c b/bgpd/bgp_nht.c index 341bb0abb5..3feb42246d 100644 --- a/bgpd/bgp_nht.c +++ b/bgpd/bgp_nht.c @@ -532,8 +532,8 @@ make_prefix (int afi, struct bgp_info *ri, struct prefix *p) break; case AFI_IP6: /* We don't register link local NH */ - if (ri->attr->extra->mp_nexthop_len != BGP_ATTR_NHLEN_IPV6_GLOBAL - || IN6_IS_ADDR_LINKLOCAL (&ri->attr->extra->mp_nexthop_global)) + if (ri->attr->mp_nexthop_len != BGP_ATTR_NHLEN_IPV6_GLOBAL + || IN6_IS_ADDR_LINKLOCAL (&ri->attr->mp_nexthop_global)) return -1; p->family = AF_INET6; @@ -545,7 +545,7 @@ make_prefix (int afi, struct bgp_info *ri, struct prefix *p) } else { - p->u.prefix6 = ri->attr->extra->mp_nexthop_global; + p->u.prefix6 = ri->attr->mp_nexthop_global; p->prefixlen = IPV6_MAX_BITLEN; } break; diff --git a/bgpd/bgp_packet.c b/bgpd/bgp_packet.c index 0c31d6e9f3..2b48b34e13 100644 --- a/bgpd/bgp_packet.c +++ b/bgpd/bgp_packet.c @@ -1364,7 +1364,6 @@ bgp_update_receive (struct peer *peer, bgp_size_t size) u_char *end; struct stream *s; struct attr attr; - struct attr_extra extra; bgp_size_t attribute_len; bgp_size_t update_len; bgp_size_t withdraw_len; @@ -1389,11 +1388,9 @@ bgp_update_receive (struct peer *peer, bgp_size_t size) /* Set initial values. */ memset (&attr, 0, sizeof (struct attr)); - memset (&extra, 0, sizeof (struct attr_extra)); - extra.label_index = BGP_INVALID_LABEL_INDEX; - extra.label = MPLS_INVALID_LABEL; + attr.label_index = BGP_INVALID_LABEL_INDEX; + attr.label = MPLS_INVALID_LABEL; memset (&nlris, 0, sizeof (nlris)); - attr.extra = &extra; memset (peer->rcvd_attr_str, 0, BUFSIZ); peer->rcvd_attr_printed = 0; diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c index cd21c25c77..fabea1f113 100644 --- a/bgpd/bgp_route.c +++ b/bgpd/bgp_route.c @@ -330,7 +330,7 @@ bgp_pcount_adjust (struct bgp_node *rn, struct bgp_info *ri) static int bgp_label_index_differs (struct bgp_info *ri1, struct bgp_info *ri2) { - return (!(ri1->attr->extra->label_index == ri2->attr->extra->label_index)); + return (!(ri1->attr->label_index == ri2->attr->label_index)); } /* Set/unset bgp_info flags, adjusting any other state as needed. @@ -392,7 +392,6 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, char *pfx_buf, afi_t afi, safi_t safi) { struct attr *newattr, *existattr; - struct attr_extra *newattre, *existattre; bgp_peer_sort_t new_sort; bgp_peer_sort_t exist_sort; u_int32_t new_pref; @@ -443,8 +442,6 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, newattr = new->attr; existattr = exist->attr; - newattre = newattr->extra; - existattre = existattr->extra; /* For EVPN routes, we cannot just go by local vs remote, we have to * look at the MAC mobility sequence number, if present. @@ -457,7 +454,7 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, * consistency in this scenario we are going to prefer the path with the * sticky flag. */ - if (newattre->sticky != existattre->sticky) + if (newattr->sticky != existattr->sticky) { if (!debug) { @@ -466,14 +463,14 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, bgp_info_path_with_addpath_rx_str (exist, exist_buf); } - if (newattre->sticky && !existattre->sticky) + if (newattr->sticky && !existattr->sticky) { zlog_warn("%s: %s wins over %s due to sticky MAC flag", pfx_buf, new_buf, exist_buf); return 1; } - if (!newattre->sticky && existattre->sticky) + if (!newattr->sticky && existattr->sticky) { zlog_warn("%s: %s loses to %s due to sticky MAC flag", pfx_buf, new_buf, exist_buf); @@ -504,10 +501,8 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, /* 1. Weight check. */ new_weight = exist_weight = 0; - if (newattre) - new_weight = newattre->weight; - if (existattre) - exist_weight = existattre->weight; + new_weight = newattr->weight; + exist_weight = existattr->weight; if (new_weight > exist_weight) { @@ -877,11 +872,11 @@ bgp_info_cmp (struct bgp *bgp, struct bgp_info *new, struct bgp_info *exist, * used for the comparision, it will decide which path is better. */ if (newattr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) - new_id.s_addr = newattre->originator_id.s_addr; + new_id.s_addr = newattr->originator_id.s_addr; else new_id.s_addr = new->peer->remote_id.s_addr; if (existattr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) - exist_id.s_addr = existattre->originator_id.s_addr; + exist_id.s_addr = existattr->originator_id.s_addr; else exist_id.s_addr = exist->peer->remote_id.s_addr; @@ -1105,14 +1100,14 @@ bgp_cluster_filter (struct peer *peer, struct attr *attr) { struct in_addr cluster_id; - if (attr->extra && attr->extra->cluster) + if (attr->cluster) { if (peer->bgp->config & BGP_CONFIG_CLUSTER_ID) cluster_id = peer->bgp->cluster_id; else cluster_id = peer->bgp->router_id; - if (cluster_loop_check (attr->extra->cluster, cluster_id)) + if (cluster_loop_check (attr->cluster, cluster_id)) return 1; } return 0; @@ -1131,7 +1126,7 @@ bgp_input_modifier (struct peer *peer, struct prefix *p, struct attr *attr, /* Apply default weight value. */ if (peer->weight[afi][safi]) - (bgp_attr_extra_get (attr))->weight = peer->weight[afi][safi]; + attr->weight = peer->weight[afi][safi]; if (rmap_name) { @@ -1188,7 +1183,7 @@ bgp_output_modifier (struct peer *peer, struct prefix *p, struct attr *attr, /* Apply default weight value. */ if (peer->weight[afi][safi]) - (bgp_attr_extra_get (attr))->weight = peer->weight[afi][safi]; + attr->weight = peer->weight[afi][safi]; if (rmap_name) { @@ -1287,7 +1282,7 @@ subgroup_announce_reset_nhop (u_char family, struct attr *attr) if (family == AF_INET) attr->nexthop.s_addr = 0; if (family == AF_INET6) - memset (&attr->extra->mp_nexthop_global, 0, IPV6_MAX_BYTELEN); + memset (&attr->mp_nexthop_global, 0, IPV6_MAX_BYTELEN); } int @@ -1416,7 +1411,7 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, peer's id. */ if (onlypeer && riattr->flag & ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID) && - (IPV4_ADDR_SAME (&onlypeer->remote_id, &riattr->extra->originator_id))) + (IPV4_ADDR_SAME (&onlypeer->remote_id, &riattr->originator_id))) { if (bgp_debug_update(NULL, p, subgrp->update_group, 0)) zlog_debug ("%s [Update:SEND] %s originator-id is same as " @@ -1523,8 +1518,7 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, set the originator id */ if (reflect && (!(attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)))) { - attr->extra = bgp_attr_extra_get(attr); - IPV4_ADDR_COPY(&(attr->extra->originator_id), &(from->remote_id)); + IPV4_ADDR_COPY(&(attr->originator_id), &(from->remote_id)); SET_FLAG(attr->flag, BGP_ATTR_ORIGINATOR_ID); } @@ -1555,7 +1549,7 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, (safi != SAFI_ENCAP && safi != SAFI_MPLS_VPN &&\ (p->family == AF_INET6 || peer_cap_enhe(peer, afi, safi))) || \ ((safi == SAFI_ENCAP || safi == SAFI_MPLS_VPN) &&\ - attr->extra->mp_nexthop_len >= IPV6_MAX_BYTELEN)) + attr->mp_nexthop_len >= IPV6_MAX_BYTELEN)) /* IPv6/MP starts with 1 nexthop. The link-local address is passed only if * the peer (group) is configured to receive link-local nexthop unchanged @@ -1565,14 +1559,14 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, */ if (NEXTHOP_IS_V6) { - attr->extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; + attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; if ((CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED) && - IN6_IS_ADDR_LINKLOCAL (&attr->extra->mp_nexthop_local)) || + IN6_IS_ADDR_LINKLOCAL (&attr->mp_nexthop_local)) || (!reflect && peer->shared_network && (from == bgp->peer_self || peer->sort == BGP_PEER_EBGP))) { - attr->extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; + attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; } /* Clear off link-local nexthop in source, whenever it is not needed to @@ -1580,7 +1574,7 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, */ if (!(CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_NEXTHOP_LOCAL_UNCHANGED))) - memset (&attr->extra->mp_nexthop_local, 0, IPV6_MAX_BYTELEN); + memset (&attr->mp_nexthop_local, 0, IPV6_MAX_BYTELEN); } bgp_peer_remove_private_as(bgp, afi, safi, peer, attr); @@ -1592,9 +1586,6 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, { struct bgp_info info; struct attr dummy_attr; - struct attr_extra dummy_extra; - - dummy_attr.extra = &dummy_extra; info.peer = peer; info.attr = attr; @@ -1679,7 +1670,7 @@ subgroup_announce_check (struct bgp_node *rn, struct bgp_info *ri, */ if (p->family == AF_INET6 || peer_cap_enhe(peer, afi, safi)) { - if (IN6_IS_ADDR_LINKLOCAL (&attr->extra->mp_nexthop_global)) + if (IN6_IS_ADDR_LINKLOCAL (&attr->mp_nexthop_global)) subgroup_announce_reset_nhop (AF_INET6, attr); } } @@ -1899,7 +1890,6 @@ subgroup_process_announce_selected (struct update_subgroup *subgrp, struct prefix *p; struct peer *onlypeer; struct attr attr; - struct attr_extra extra; afi_t afi; safi_t safi; @@ -1914,9 +1904,8 @@ subgroup_process_announce_selected (struct update_subgroup *subgrp, PEER_STATUS_ORF_WAIT_REFRESH)) return 0; - memset(&extra, 0, sizeof(struct attr_extra)); + memset(&attr, 0, sizeof(struct attr)); /* It's initialized in bgp_announce_check() */ - attr.extra = &extra; /* Announcement to the subgroup. If the route is filtered withdraw it. */ if (selected) @@ -2047,7 +2036,7 @@ bgp_process_main (struct work_queue *wq, void *data) { if (new_select->sub_type == BGP_ROUTE_STATIC && new_select->attr->flag & ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID) && - new_select->attr->extra->label_index != BGP_INVALID_LABEL_INDEX) + new_select->attr->label_index != BGP_INVALID_LABEL_INDEX) { if (CHECK_FLAG (rn->flags, BGP_NODE_REGISTERED_FOR_LABEL)) bgp_unregister_for_label (rn); @@ -2459,27 +2448,24 @@ info_make (int type, int sub_type, u_short instance, struct peer *peer, static void overlay_index_update(struct attr *attr, struct eth_segment_id *eth_s_id, union gw_addr *gw_ip) { - struct attr_extra *extra; - if(!attr) return; - extra = bgp_attr_extra_get(attr); if(eth_s_id == NULL) { - memset(&(extra->evpn_overlay.eth_s_id),0, sizeof(struct eth_segment_id)); + memset(&(attr->evpn_overlay.eth_s_id),0, sizeof(struct eth_segment_id)); } else { - memcpy(&(extra->evpn_overlay.eth_s_id), eth_s_id, sizeof(struct eth_segment_id)); + memcpy(&(attr->evpn_overlay.eth_s_id), eth_s_id, sizeof(struct eth_segment_id)); } if(gw_ip == NULL) { - memset(&(extra->evpn_overlay.gw_ip), 0, sizeof(union gw_addr)); + memset(&(attr->evpn_overlay.gw_ip), 0, sizeof(union gw_addr)); } else { - memcpy(&(extra->evpn_overlay.gw_ip),gw_ip, sizeof(union gw_addr)); + memcpy(&(attr->evpn_overlay.gw_ip),gw_ip, sizeof(union gw_addr)); } } @@ -2492,7 +2478,7 @@ overlay_index_equal(afi_t afi, struct bgp_info *info, struct eth_segment_id *eth if(afi != AFI_L2VPN) return true; - if (!info->attr || !info->attr->extra) + if (!info->attr) { memset(&temp, 0, 16); info_eth_s_id = (struct eth_segment_id *)&temp; @@ -2502,8 +2488,8 @@ overlay_index_equal(afi_t afi, struct bgp_info *info, struct eth_segment_id *eth } else { - info_eth_s_id = &(info->attr->extra->evpn_overlay.eth_s_id); - info_gw_ip = &(info->attr->extra->evpn_overlay.gw_ip); + info_eth_s_id = &(info->attr->evpn_overlay.eth_s_id); + info_gw_ip = &(info->attr->evpn_overlay.gw_ip); } if(gw_ip == NULL) info_gw_ip_remote = (union gw_addr *)&temp; @@ -2522,7 +2508,6 @@ overlay_index_equal(afi_t afi, struct bgp_info *info, struct eth_segment_id *eth static int bgp_update_martian_nexthop (struct bgp *bgp, afi_t afi, safi_t safi, struct attr *attr) { - struct attr_extra *attre = attr->extra; int ret = 0; /* Only validated for unicast and multicast currently. */ @@ -2544,23 +2529,23 @@ bgp_update_martian_nexthop (struct bgp *bgp, afi_t afi, safi_t safi, struct attr * there is code in bgp_attr.c to ignore the link-local (2nd) nexthop if * it is not an IPv6 link-local address. */ - if (attre && attre->mp_nexthop_len) + if (attr->mp_nexthop_len) { - switch (attre->mp_nexthop_len) + switch (attr->mp_nexthop_len) { case BGP_ATTR_NHLEN_IPV4: case BGP_ATTR_NHLEN_VPNV4: - ret = (attre->mp_nexthop_global_in.s_addr == 0 || - IPV4_CLASS_DE (ntohl (attre->mp_nexthop_global_in.s_addr)) || - bgp_nexthop_self (bgp, attre->mp_nexthop_global_in)); + ret = (attr->mp_nexthop_global_in.s_addr == 0 || + IPV4_CLASS_DE (ntohl (attr->mp_nexthop_global_in.s_addr)) || + bgp_nexthop_self (bgp, attr->mp_nexthop_global_in)); break; case BGP_ATTR_NHLEN_IPV6_GLOBAL: case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL: case BGP_ATTR_NHLEN_VPNV6_GLOBAL: - ret = (IN6_IS_ADDR_UNSPECIFIED(&attre->mp_nexthop_global) || - IN6_IS_ADDR_LOOPBACK(&attre->mp_nexthop_global) || - IN6_IS_ADDR_MULTICAST(&attre->mp_nexthop_global)); + ret = (IN6_IS_ADDR_UNSPECIFIED(&attr->mp_nexthop_global) || + IN6_IS_ADDR_LOOPBACK(&attr->mp_nexthop_global) || + IN6_IS_ADDR_MULTICAST(&attr->mp_nexthop_global)); break; default: @@ -2583,7 +2568,6 @@ bgp_update (struct peer *peer, struct prefix *p, u_int32_t addpath_id, struct bgp_node *rn; struct bgp *bgp; struct attr new_attr; - struct attr_extra new_extra; struct attr *attr_new; struct bgp_info *ri; struct bgp_info *new; @@ -2599,9 +2583,8 @@ bgp_update (struct peer *peer, struct prefix *p, u_int32_t addpath_id, int same_attr=0; memset (&new_attr, 0, sizeof(struct attr)); - memset (&new_extra, 0, sizeof(struct attr_extra)); - new_extra.label_index = BGP_INVALID_LABEL_INDEX; - new_extra.label = MPLS_INVALID_LABEL; + new_attr.label_index = BGP_INVALID_LABEL_INDEX; + new_attr.label = MPLS_INVALID_LABEL; bgp = peer->bgp; rn = bgp_afi_node_get (bgp->rib[afi][safi], afi, safi, p, prd); @@ -2656,7 +2639,7 @@ bgp_update (struct peer *peer, struct prefix *p, u_int32_t addpath_id, /* Route reflector originator ID check. */ if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID) - && IPV4_ADDR_SAME (&bgp->router_id, &attr->extra->originator_id)) + && IPV4_ADDR_SAME (&bgp->router_id, &attr->originator_id)) { reason = "originator is us;"; goto filtered; @@ -2676,7 +2659,6 @@ bgp_update (struct peer *peer, struct prefix *p, u_int32_t addpath_id, goto filtered; } - new_attr.extra = &new_extra; bgp_attr_dup (&new_attr, attr); /* Apply incoming route-map. @@ -2850,14 +2832,14 @@ bgp_update (struct peer *peer, struct prefix *p, u_int32_t addpath_id, { int cmp; - cmp = ecommunity_cmp (ri->attr->extra->ecommunity, - attr_new->extra->ecommunity); + cmp = ecommunity_cmp (ri->attr->ecommunity, + attr_new->ecommunity); if (!cmp) { if (bgp_debug_update(peer, p, NULL, 1)) zlog_debug ("Change in EXT-COMM, existing %s new %s", - ecommunity_str (ri->attr->extra->ecommunity), - ecommunity_str (attr_new->extra->ecommunity)); + ecommunity_str (ri->attr->ecommunity), + ecommunity_str (attr_new->ecommunity)); bgp_evpn_unimport_route (bgp, afi, safi, p, ri); } } @@ -4000,7 +3982,7 @@ bgp_static_update (struct bgp *bgp, struct prefix *p, /* Store label index, if required. */ if (bgp_static->label_index != BGP_INVALID_LABEL_INDEX) { - (bgp_attr_extra_get (&attr))->label_index = bgp_static->label_index; + attr.label_index = bgp_static->label_index; attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID); } @@ -4024,7 +4006,6 @@ bgp_static_update (struct bgp *bgp, struct prefix *p, /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); bgp_static_withdraw (bgp, p, afi, safi); return; } @@ -4047,7 +4028,6 @@ bgp_static_update (struct bgp *bgp, struct prefix *p, bgp_unlock_node (rn); bgp_attr_unintern (&attr_new); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return; } else @@ -4122,7 +4102,6 @@ bgp_static_update (struct bgp *bgp, struct prefix *p, bgp_process (bgp, rn, afi, safi); bgp_unlock_node (rn); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return; } } @@ -4174,7 +4153,6 @@ bgp_static_update (struct bgp *bgp, struct prefix *p, /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } void @@ -4277,8 +4255,8 @@ bgp_static_update_safi (struct bgp *bgp, struct prefix *p, { if (afi == AFI_IP) { - bgp_attr_extra_get (&attr)->mp_nexthop_global_in = bgp_static->igpnexthop; - bgp_attr_extra_get (&attr)->mp_nexthop_len = IPV4_MAX_BYTELEN; + attr.mp_nexthop_global_in = bgp_static->igpnexthop; + attr.mp_nexthop_len = IPV4_MAX_BYTELEN; } } if(afi == AFI_L2VPN) @@ -4323,7 +4301,6 @@ bgp_static_update_safi (struct bgp *bgp, struct prefix *p, /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); bgp_static_withdraw_safi (bgp, p, afi, safi, &bgp_static->prd); return; } @@ -4351,7 +4328,6 @@ bgp_static_update_safi (struct bgp *bgp, struct prefix *p, bgp_unlock_node (rn); bgp_attr_unintern (&attr_new); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return; } else @@ -4382,7 +4358,6 @@ bgp_static_update_safi (struct bgp *bgp, struct prefix *p, #endif bgp_unlock_node (rn); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return; } } @@ -4417,7 +4392,6 @@ bgp_static_update_safi (struct bgp *bgp, struct prefix *p, /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } /* Configure static BGP network. When user don't run zebra, static @@ -6156,14 +6130,13 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n if (nexthop6) { - struct attr_extra *extra = bgp_attr_extra_get(&attr); - extra->mp_nexthop_global = *nexthop6; - extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; + attr.mp_nexthop_global = *nexthop6; + attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; } attr.med = metric; attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC); - attr.extra->tag = tag; + attr.tag = tag; afi = family2afi (p->family); @@ -6171,10 +6144,8 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n if (red) { struct attr attr_new; - struct attr_extra extra_new; /* Copy attribute for modification. */ - attr_new.extra = &extra_new; bgp_attr_dup (&attr_new, &attr); if (red->redist_metric_flag) @@ -6199,7 +6170,6 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); bgp_redistribute_delete (bgp, p, type, instance); return; } @@ -6224,7 +6194,6 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n { bgp_attr_unintern (&new_attr); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); bgp_unlock_node (bn); return; } @@ -6247,7 +6216,6 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n bgp_process (bgp, bn, afi, SAFI_UNICAST); bgp_unlock_node (bn); aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); return; } } @@ -6264,7 +6232,6 @@ bgp_redistribute_add (struct bgp *bgp, struct prefix *p, const struct in_addr *n /* Unintern original. */ aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } void @@ -6479,7 +6446,7 @@ route_vty_out (struct vty *vty, struct prefix *p, /* Print attribute */ attr = binfo->attr; - if (attr) + if (attr) { /* * For ENCAP and EVPN routes, nexthop address family is not @@ -6487,32 +6454,25 @@ route_vty_out (struct vty *vty, struct prefix *p, * Both SAFI_MPLS_VPN and SAFI_ENCAP use the MP nexthop field * EVPN routes are also exchanged with a MP nexthop. Currently, this * is only IPv4, the value will be present in either attr->nexthop or - * attr->extra->mp_nexthop_global_in + * attr->mp_nexthop_global_in */ if ((safi == SAFI_ENCAP) || (safi == SAFI_MPLS_VPN)) { - if (attr->extra) - { - char buf[BUFSIZ]; - int af = NEXTHOP_FAMILY(attr->extra->mp_nexthop_len); + char buf[BUFSIZ]; + int af = NEXTHOP_FAMILY(attr->mp_nexthop_len); - switch (af) - { - case AF_INET: - vty_out (vty, "%s", inet_ntop(af, - &attr->extra->mp_nexthop_global_in, buf, BUFSIZ)); - break; - case AF_INET6: - vty_out (vty, "%s", inet_ntop(af, - &attr->extra->mp_nexthop_global, buf, BUFSIZ)); - break; - default: - vty_out(vty, "?"); - break; - } + switch (af) + { + case AF_INET: + vty_out (vty, "%s", inet_ntop(af, &attr->mp_nexthop_global_in, buf, BUFSIZ)); + break; + case AF_INET6: + vty_out (vty, "%s", inet_ntop(af, &attr->mp_nexthop_global, buf, BUFSIZ)); + break; + default: + vty_out(vty, "?"); + break; } - else - vty_out(vty, "?"); } else if (safi == SAFI_EVPN) { @@ -6535,7 +6495,7 @@ route_vty_out (struct vty *vty, struct prefix *p, json_nexthop_global = json_object_new_object(); if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_EVPN)) - json_object_string_add(json_nexthop_global, "ip", inet_ntoa (attr->extra->mp_nexthop_global_in)); + json_object_string_add(json_nexthop_global, "ip", inet_ntoa (attr->mp_nexthop_global_in)); else json_object_string_add(json_nexthop_global, "ip", inet_ntoa (attr->nexthop)); @@ -6546,7 +6506,7 @@ route_vty_out (struct vty *vty, struct prefix *p, { if ((safi == SAFI_MPLS_VPN) || (safi == SAFI_EVPN)) vty_out (vty, "%-16s", - inet_ntoa (attr->extra->mp_nexthop_global_in)); + inet_ntoa (attr->mp_nexthop_global_in)); else vty_out (vty, "%-16s", inet_ntoa (attr->nexthop)); } @@ -6563,25 +6523,25 @@ route_vty_out (struct vty *vty, struct prefix *p, json_nexthop_global = json_object_new_object(); json_object_string_add(json_nexthop_global, "ip", inet_ntop (AF_INET6, - &attr->extra->mp_nexthop_global, + &attr->mp_nexthop_global, buf, BUFSIZ)); json_object_string_add(json_nexthop_global, "afi", "ipv6"); json_object_string_add(json_nexthop_global, "scope", "global"); /* We display both LL & GL if both have been received */ - if ((attr->extra->mp_nexthop_len == 32) || (binfo->peer->conf_if)) + if ((attr->mp_nexthop_len == 32) || (binfo->peer->conf_if)) { json_nexthop_ll = json_object_new_object(); json_object_string_add(json_nexthop_ll, "ip", inet_ntop (AF_INET6, - &attr->extra->mp_nexthop_local, + &attr->mp_nexthop_local, buf, BUFSIZ)); json_object_string_add(json_nexthop_ll, "afi", "ipv6"); json_object_string_add(json_nexthop_ll, "scope", "link-local"); - if ((IPV6_ADDR_CMP (&attr->extra->mp_nexthop_global, - &attr->extra->mp_nexthop_local) != 0) && - !attr->extra->mp_nexthop_prefer_global) + if ((IPV6_ADDR_CMP (&attr->mp_nexthop_global, + &attr->mp_nexthop_local) != 0) && + !attr->mp_nexthop_prefer_global) json_object_boolean_true_add(json_nexthop_ll, "used"); else json_object_boolean_true_add(json_nexthop_global, "used"); @@ -6592,8 +6552,8 @@ route_vty_out (struct vty *vty, struct prefix *p, else { /* Display LL if LL/Global both in table unless prefer-global is set */ - if (((attr->extra->mp_nexthop_len == 32) && - !attr->extra->mp_nexthop_prefer_global) || + if (((attr->mp_nexthop_len == 32) && + !attr->mp_nexthop_prefer_global) || (binfo->peer->conf_if)) { if (binfo->peer->conf_if) @@ -6611,7 +6571,7 @@ route_vty_out (struct vty *vty, struct prefix *p, { len = vty_out (vty, "%s", inet_ntop (AF_INET6, - &attr->extra->mp_nexthop_local, + &attr->mp_nexthop_local, buf, BUFSIZ)); len = 16 - len; @@ -6625,7 +6585,7 @@ route_vty_out (struct vty *vty, struct prefix *p, { len = vty_out (vty, "%s", inet_ntop (AF_INET6, - &attr->extra->mp_nexthop_global, + &attr->mp_nexthop_global, buf, BUFSIZ)); len = 16 - len; @@ -6658,14 +6618,9 @@ route_vty_out (struct vty *vty, struct prefix *p, vty_out (vty, " "); if (json_paths) - { - if (attr->extra) - json_object_int_add(json_path, "weight", attr->extra->weight); - else - json_object_int_add(json_path, "weight", 0); - } + json_object_int_add(json_path, "weight", attr->weight); else - vty_out (vty, "%7u ", (attr->extra ? attr->extra->weight : 0)); + vty_out (vty, "%7u ", attr->weight); if (json_paths) { char buf[BUFSIZ]; @@ -6762,7 +6717,7 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t !BGP_ATTR_NEXTHOP_AFI_IP6(attr))) { if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) - json_object_string_add(json_net, "nextHop", inet_ntoa (attr->extra->mp_nexthop_global_in)); + json_object_string_add(json_net, "nextHop", inet_ntoa (attr->mp_nexthop_global_in)); else json_object_string_add(json_net, "nextHop", inet_ntoa (attr->nexthop)); } @@ -6770,7 +6725,7 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t { char buf[BUFSIZ]; - json_object_string_add(json_net, "netHopGloabal", inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + json_object_string_add(json_net, "netHopGloabal", inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf, BUFSIZ)); } @@ -6780,10 +6735,7 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)) json_object_int_add(json_net, "localPref", attr->local_pref); - if (attr->extra) - json_object_int_add(json_net, "weight", attr->extra->weight); - else - json_object_int_add(json_net, "weight", 0); + json_object_int_add(json_net, "weight", attr->weight); /* Print aspath */ if (attr->aspath) @@ -6802,7 +6754,7 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t { if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) vty_out (vty, "%-16s", - inet_ntoa (attr->extra->mp_nexthop_global_in)); + inet_ntoa (attr->mp_nexthop_global_in)); else vty_out (vty, "%-16s", inet_ntoa (attr->nexthop)); } @@ -6811,10 +6763,8 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t int len; char buf[BUFSIZ]; - assert (attr->extra); - len = vty_out (vty, "%s", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf, BUFSIZ)); len = 16 - len; if (len < 1) @@ -6832,7 +6782,7 @@ route_vty_out_tmp (struct vty *vty, struct prefix *p, struct attr *attr, safi_t else vty_out (vty, " "); - vty_out (vty, "%7u ", (attr->extra ? attr->extra->weight : 0)); + vty_out (vty, "%7u ", attr->weight); /* Print aspath */ if (attr->aspath) @@ -6891,9 +6841,9 @@ route_vty_out_tag (struct vty *vty, struct prefix *p, if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) { if (json) - json_object_string_add(json_out, "mpNexthopGlobalIn", inet_ntoa (attr->extra->mp_nexthop_global_in)); + json_object_string_add(json_out, "mpNexthopGlobalIn", inet_ntoa (attr->mp_nexthop_global_in)); else - vty_out (vty, "%-16s", inet_ntoa (attr->extra->mp_nexthop_global_in)); + vty_out (vty, "%-16s", inet_ntoa (attr->mp_nexthop_global_in)); } else { @@ -6907,36 +6857,35 @@ route_vty_out_tag (struct vty *vty, struct prefix *p, || (safi == SAFI_EVPN && p->family == AF_ETHERNET && BGP_ATTR_NEXTHOP_AFI_IP6(attr)) || (BGP_ATTR_NEXTHOP_AFI_IP6(attr))) { - assert (attr->extra); char buf_a[BUFSIZ]; char buf_b[BUFSIZ]; char buf_c[BUFSIZ]; - if (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) { if (json) json_object_string_add(json_out, "mpNexthopGlobalIn", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, buf_a, BUFSIZ)); + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf_a, BUFSIZ)); else vty_out (vty, "%s", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf_a, BUFSIZ)); } - else if (attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + else if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { if (json) { - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf_a, BUFSIZ); - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, + inet_ntop (AF_INET6, &attr->mp_nexthop_local, buf_b, BUFSIZ); sprintf(buf_c, "%s(%s)", buf_a, buf_b); json_object_string_add(json_out, "mpNexthopGlobalLocal", buf_c); } else vty_out (vty, "%s(%s)", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf_a, BUFSIZ), - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, + inet_ntop (AF_INET6, &attr->mp_nexthop_local, buf_b, BUFSIZ)); } @@ -6987,60 +6936,52 @@ route_vty_out_overlay (struct vty *vty, struct prefix *p, attr = binfo->attr; if (attr) { - if (attr->extra) - { - char buf1[BUFSIZ]; - int af = NEXTHOP_FAMILY(attr->extra->mp_nexthop_len); + char buf1[BUFSIZ]; + int af = NEXTHOP_FAMILY(attr->mp_nexthop_len); - switch (af) { - case AF_INET: - vty_out (vty, "%-16s", inet_ntop(af, - &attr->extra->mp_nexthop_global_in, buf, BUFSIZ)); - break; - case AF_INET6: - vty_out (vty, "%s(%s)", - inet_ntop (af, - &attr->extra->mp_nexthop_global, buf, BUFSIZ), - inet_ntop (af, - &attr->extra->mp_nexthop_local, buf1, BUFSIZ)); - break; - default: - vty_out(vty, "?"); - } - } else { + switch (af) { + case AF_INET: + vty_out (vty, "%-16s", inet_ntop(af, + &attr->mp_nexthop_global_in, buf, BUFSIZ)); + break; + case AF_INET6: + vty_out (vty, "%s(%s)", + inet_ntop (af, + &attr->mp_nexthop_global, buf, BUFSIZ), + inet_ntop (af, + &attr->mp_nexthop_local, buf1, BUFSIZ)); + break; + default: vty_out(vty, "?"); } } - if(attr->extra) + struct eth_segment_id *id = &(attr->evpn_overlay.eth_s_id); + char *str = esi2str(id); + vty_out (vty, "%s", str); + XFREE (MTYPE_TMP, str); + if (IS_EVPN_PREFIX_IPADDR_V4((struct prefix_evpn *)p)) { - struct eth_segment_id *id = &(attr->extra->evpn_overlay.eth_s_id); - char *str = esi2str(id); - vty_out (vty, "%s", str); - XFREE (MTYPE_TMP, str); - if (IS_EVPN_PREFIX_IPADDR_V4((struct prefix_evpn *)p)) - { - vty_out (vty, "/%s", inet_ntoa (attr->extra->evpn_overlay.gw_ip.ipv4)); - } - else if (IS_EVPN_PREFIX_IPADDR_V6((struct prefix_evpn *)p)) - { - vty_out (vty, "/%s", - inet_ntop (AF_INET6, &(attr->extra->evpn_overlay.gw_ip.ipv6), - buf, BUFSIZ)); - } - if(attr->extra->ecommunity) + vty_out (vty, "/%s", inet_ntoa (attr->evpn_overlay.gw_ip.ipv4)); + } + else if (IS_EVPN_PREFIX_IPADDR_V6((struct prefix_evpn *)p)) + { + vty_out (vty, "/%s", + inet_ntop (AF_INET6, &(attr->evpn_overlay.gw_ip.ipv6), + buf, BUFSIZ)); + } + if(attr->ecommunity) + { + char *mac = NULL; + struct ecommunity_val *routermac = ecommunity_lookup (attr->ecommunity, + ECOMMUNITY_ENCODE_EVPN, + ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC); + if(routermac) + mac = ecom_mac2str((char *)routermac->val); + if(mac) { - char *mac = NULL; - struct ecommunity_val *routermac = ecommunity_lookup (attr->extra->ecommunity, - ECOMMUNITY_ENCODE_EVPN, - ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC); - if(routermac) - mac = ecom_mac2str((char *)routermac->val); - if(mac) - { - vty_out (vty, "/%s",(char *)mac); - XFREE(MTYPE_TMP, mac); - } + vty_out (vty, "/%s",(char *)mac); + XFREE(MTYPE_TMP, mac); } } vty_out (vty, VTYNL); @@ -7372,14 +7313,14 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, { if (json_paths) { - json_object_int_add(json_path, "aggregatorAs", attr->extra->aggregator_as); - json_object_string_add(json_path, "aggregatorId", inet_ntoa (attr->extra->aggregator_addr)); + json_object_int_add(json_path, "aggregatorAs", attr->aggregator_as); + json_object_string_add(json_path, "aggregatorId", inet_ntoa (attr->aggregator_addr)); } else { vty_out (vty, ", (aggregated by %u %s)", - attr->extra->aggregator_as, - inet_ntoa (attr->extra->aggregator_addr)); + attr->aggregator_as, + inet_ntoa (attr->aggregator_addr)); } } @@ -7429,9 +7370,9 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, if (safi == SAFI_MPLS_VPN || safi == SAFI_ENCAP || safi == SAFI_EVPN) { if (json_paths) - json_object_string_add(json_nexthop_global, "ip", inet_ntoa (attr->extra->mp_nexthop_global_in)); + json_object_string_add(json_nexthop_global, "ip", inet_ntoa (attr->mp_nexthop_global_in)); else - vty_out (vty, " %s", inet_ntoa (attr->extra->mp_nexthop_global_in)); + vty_out (vty, " %s", inet_ntoa (attr->mp_nexthop_global_in)); } else { @@ -7446,11 +7387,10 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, } else { - assert (attr->extra); if (json_paths) { json_object_string_add(json_nexthop_global, "ip", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf, INET6_ADDRSTRLEN)); json_object_string_add(json_nexthop_global, "afi", "ipv6"); json_object_string_add(json_nexthop_global, "scope", "global"); @@ -7458,7 +7398,7 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, else { vty_out (vty, " %s", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_global, + inet_ntop (AF_INET6, &attr->mp_nexthop_global, buf, INET6_ADDRSTRLEN)); } } @@ -7559,7 +7499,7 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, } if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) - vty_out (vty, " (%s)", inet_ntoa (attr->extra->originator_id)); + vty_out (vty, " (%s)", inet_ntoa (attr->originator_id)); else vty_out (vty, " (%s)", inet_ntop (AF_INET, &binfo->peer->remote_id, buf1, BUFSIZ)); } @@ -7569,20 +7509,20 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, vty_out (vty, VTYNL); /* display the link-local nexthop */ - if (attr->extra && attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + if (attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { if (json_paths) { json_nexthop_ll = json_object_new_object(); json_object_string_add(json_nexthop_ll, "ip", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, + inet_ntop (AF_INET6, &attr->mp_nexthop_local, buf, INET6_ADDRSTRLEN)); json_object_string_add(json_nexthop_ll, "afi", "ipv6"); json_object_string_add(json_nexthop_ll, "scope", "link-local"); json_object_boolean_true_add(json_nexthop_ll, "accessible"); - if (!attr->extra->mp_nexthop_prefer_global) + if (!attr->mp_nexthop_prefer_global) json_object_boolean_true_add(json_nexthop_ll, "used"); else json_object_boolean_true_add(json_nexthop_global, "used"); @@ -7590,9 +7530,9 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, else { vty_outln (vty, " (%s) %s", - inet_ntop (AF_INET6, &attr->extra->mp_nexthop_local, + inet_ntop (AF_INET6, &attr->mp_nexthop_local, buf, INET6_ADDRSTRLEN), - attr->extra->mp_nexthop_prefer_global ? "(prefer-global)" : "(used)"); + attr->mp_nexthop_prefer_global ? "(prefer-global)" : "(used)"); } } /* If we do not have a link-local nexthop then we must flag the global as "used" */ @@ -7631,20 +7571,20 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, vty_out (vty, ", localpref %u", bgp->default_local_pref); } - if (attr->extra && attr->extra->weight != 0) + if (attr->weight != 0) { if (json_paths) - json_object_int_add(json_path, "weight", attr->extra->weight); + json_object_int_add(json_path, "weight", attr->weight); else - vty_out (vty, ", weight %u", attr->extra->weight); + vty_out (vty, ", weight %u", attr->weight); } - if (attr->extra && attr->extra->tag != 0) + if (attr->tag != 0) { if (json_paths) - json_object_int_add(json_path, "tag", attr->extra->tag); + json_object_int_add(json_path, "tag", attr->tag); else - vty_out (vty, ", tag %"ROUTE_TAG_PRI, attr->extra->tag); + vty_out (vty, ", tag %"ROUTE_TAG_PRI, attr->tag); } if (! CHECK_FLAG (binfo->flags, BGP_INFO_VALID)) @@ -7807,33 +7747,32 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, if (json_paths) { json_ext_community = json_object_new_object(); - json_object_string_add(json_ext_community, "string", attr->extra->ecommunity->str); + json_object_string_add(json_ext_community, "string", attr->ecommunity->str); json_object_object_add(json_path, "extendedCommunity", json_ext_community); } else { vty_outln (vty, " Extended Community: %s", - attr->extra->ecommunity->str); + attr->ecommunity->str); } } /* Line 6 display Large community */ if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES)) vty_outln (vty, " Large Community: %s", - attr->extra->lcommunity->str); + attr->lcommunity->str); /* Line 7 display Originator, Cluster-id */ if ((attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) || (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST))) { - assert (attr->extra); if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID)) { if (json_paths) - json_object_string_add(json_path, "originatorId", inet_ntoa (attr->extra->originator_id)); + json_object_string_add(json_path, "originatorId", inet_ntoa (attr->originator_id)); else vty_out (vty, " Originator: %s", - inet_ntoa (attr->extra->originator_id)); + inet_ntoa (attr->originator_id)); } if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST)) @@ -7845,16 +7784,16 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, json_cluster_list = json_object_new_object(); json_cluster_list_list = json_object_new_array(); - for (i = 0; i < attr->extra->cluster->length / 4; i++) + for (i = 0; i < attr->cluster->length / 4; i++) { - json_string = json_object_new_string(inet_ntoa (attr->extra->cluster->list[i])); + json_string = json_object_new_string(inet_ntoa (attr->cluster->list[i])); json_object_array_add(json_cluster_list_list, json_string); } /* struct cluster_list does not have "str" variable like * aspath and community do. Add this someday if someone * asks for it. - json_object_string_add(json_cluster_list, "string", attr->extra->cluster->str); + json_object_string_add(json_cluster_list, "string", attr->cluster->str); */ json_object_object_add(json_cluster_list, "list", json_cluster_list_list); json_object_object_add(json_path, "clusterList", json_cluster_list); @@ -7863,10 +7802,10 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, { vty_out (vty, ", Cluster list: "); - for (i = 0; i < attr->extra->cluster->length / 4; i++) + for (i = 0; i < attr->cluster->length / 4; i++) { vty_out (vty, "%s ", - inet_ntoa (attr->extra->cluster->list[i])); + inet_ntoa (attr->cluster->list[i])); } } } @@ -7893,13 +7832,13 @@ route_vty_out_detail (struct vty *vty, struct bgp *bgp, struct prefix *p, } /* Label Index */ - if (attr->extra->label_index != BGP_INVALID_LABEL_INDEX) + if (attr->label_index != BGP_INVALID_LABEL_INDEX) { if (json_paths) - json_object_int_add(json_path, "labelIndex", attr->extra->label_index); + json_object_int_add(json_path, "labelIndex", attr->label_index); else vty_outln (vty, " Label Index: %d", - attr->extra->label_index); + attr->label_index); } /* Line 8 display Addpath IDs */ @@ -8105,10 +8044,8 @@ bgp_show_table (struct vty *vty, struct bgp *bgp, struct bgp_table *table, struct route_map *rmap = output_arg; struct bgp_info binfo; struct attr dummy_attr; - struct attr_extra dummy_extra; int ret; - dummy_attr.extra = &dummy_extra; bgp_attr_dup (&dummy_attr, ri->attr); binfo.peer = ri->peer; @@ -8186,21 +8123,20 @@ bgp_show_table (struct vty *vty, struct bgp *bgp, struct bgp_table *table, { struct lcommunity *lcom = output_arg; - if (! ri->attr->extra || ! ri->attr->extra->lcommunity || - ! lcommunity_match (ri->attr->extra->lcommunity, lcom)) + if (! ri->attr->lcommunity || + ! lcommunity_match (ri->attr->lcommunity, lcom)) continue; } if (type == bgp_show_type_lcommunity_list) { struct community_list *list = output_arg; - if (! ri->attr->extra || - ! lcommunity_list_match (ri->attr->extra->lcommunity, list)) + if (! lcommunity_list_match (ri->attr->lcommunity, list)) continue; } if (type == bgp_show_type_lcommunity_all) { - if (! ri->attr->extra || ! ri->attr->extra->lcommunity) + if (! ri->attr->lcommunity) continue; } if (type == bgp_show_type_dampend_paths @@ -9831,7 +9767,6 @@ show_adj_route (struct vty *vty, struct peer *peer, afi_t afi, safi_t safi, struct bgp *bgp; int header2 = 1; struct attr attr; - struct attr_extra extra; int ret; struct update_subgroup *subgrp; json_object *json_scode = NULL; @@ -9904,7 +9839,6 @@ show_adj_route (struct vty *vty, struct peer *peer, afi_t afi, safi_t safi, header1 = 0; } - attr.extra = &extra; for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn)) { if (in) diff --git a/bgpd/bgp_route.h b/bgpd/bgp_route.h index cb918718fe..4b82717569 100644 --- a/bgpd/bgp_route.h +++ b/bgpd/bgp_route.h @@ -232,8 +232,8 @@ struct bgp_static #define BGP_ATTR_NEXTHOP_AFI_IP6(attr) \ (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP)) && \ - (attr)->extra && ((attr)->extra->mp_nexthop_len == 16 || \ - (attr)->extra->mp_nexthop_len == 32)) + ((attr)->mp_nexthop_len == 16 || \ + (attr)->mp_nexthop_len == 32)) #define BGP_INFO_COUNTABLE(BI) \ (! CHECK_FLAG ((BI)->flags, BGP_INFO_HISTORY) \ && ! CHECK_FLAG ((BI)->flags, BGP_INFO_REMOVED)) diff --git a/bgpd/bgp_routemap.c b/bgpd/bgp_routemap.c index b0a3cc677d..7ce144f729 100644 --- a/bgpd/bgp_routemap.c +++ b/bgpd/bgp_routemap.c @@ -868,8 +868,7 @@ route_match_lcommunity (void *rule, struct prefix *prefix, if (! list) return RMAP_NOMATCH; - if (bgp_info->attr->extra && - lcommunity_list_match (bgp_info->attr->extra->lcommunity, list)) + if (lcommunity_list_match (bgp_info->attr->lcommunity, list)) return RMAP_MATCH; } @@ -933,15 +932,12 @@ route_match_ecommunity (void *rule, struct prefix *prefix, { bgp_info = object; - if (!bgp_info->attr->extra) - return RMAP_NOMATCH; - list = community_list_lookup (bgp_clist, (char *) rule, EXTCOMMUNITY_LIST_MASTER); if (! list) return RMAP_NOMATCH; - if (ecommunity_list_match (bgp_info->attr->extra->ecommunity, list)) + if (ecommunity_list_match (bgp_info->attr->ecommunity, list)) return RMAP_MATCH; } return RMAP_NOMATCH; @@ -1149,10 +1145,7 @@ route_match_tag (void *rule, struct prefix *prefix, tag = rule; bgp_info = object; - if (!bgp_info->attr->extra) - return RMAP_NOMATCH; - - return ((bgp_info->attr->extra->tag == *tag)? RMAP_MATCH : RMAP_NOMATCH); + return ((bgp_info->attr->tag == *tag)? RMAP_MATCH : RMAP_NOMATCH); } return RMAP_NOMATCH; @@ -1332,7 +1325,6 @@ route_set_weight (void *rule, struct prefix *prefix, route_map_object_t type, { struct rmap_value *rv; struct bgp_info *bgp_info; - u_int32_t weight; if (type == RMAP_BGP) { @@ -1341,11 +1333,7 @@ route_set_weight (void *rule, struct prefix *prefix, route_map_object_t type, bgp_info = object; /* Set weight value. */ - weight = route_value_adjust(rv, 0, bgp_info->peer); - if (weight) - (bgp_attr_extra_get (bgp_info->attr))->weight = weight; - else if (bgp_info->attr->extra) - bgp_info->attr->extra->weight = 0; + bgp_info->attr->weight = route_value_adjust(rv, 0, bgp_info->peer); } return RMAP_OKAY; @@ -1644,14 +1632,13 @@ route_set_lcommunity (void *rule, struct prefix *prefix, rcs = rule; binfo = object; attr = binfo->attr; - old = (attr->extra) ? attr->extra->lcommunity : NULL; + old = attr->lcommunity; /* "none" case. */ if (rcs->none) { attr->flag &= ~(ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES)); - if (attr->extra) - attr->extra->lcommunity = NULL; + attr->lcommunity = NULL; /* See the longer comment down below. */ if (old && old->refcnt == 0) @@ -1676,7 +1663,7 @@ route_set_lcommunity (void *rule, struct prefix *prefix, new = lcommunity_dup (rcs->lcom); /* will be intern()'d or attr_flush()'d by bgp_update_main() */ - (bgp_attr_extra_get (attr))->lcommunity = new; + attr->lcommunity = new; attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES); } @@ -1766,7 +1753,7 @@ route_set_lcommunity_delete (void *rule, struct prefix *prefix, binfo = object; list = community_list_lookup (bgp_clist, rule, LARGE_COMMUNITY_LIST_MASTER); - old = ((binfo->attr->extra) ? binfo->attr->extra->lcommunity : NULL); + old = binfo->attr->lcommunity; if (list && old) { @@ -1783,13 +1770,13 @@ route_set_lcommunity_delete (void *rule, struct prefix *prefix, if (new->size == 0) { - binfo->attr->extra->lcommunity = NULL; + binfo->attr->lcommunity = NULL; binfo->attr->flag &= ~ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES); lcommunity_free (&new); } else { - binfo->attr->extra->lcommunity = new; + binfo->attr->lcommunity = new; binfo->attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_LARGE_COMMUNITIES); } } @@ -1946,7 +1933,7 @@ route_set_ecommunity (void *rule, struct prefix *prefix, return RMAP_OKAY; /* We assume additive for Extended Community. */ - old_ecom = (bgp_attr_extra_get (bgp_info->attr))->ecommunity; + old_ecom = bgp_info->attr->ecommunity; if (old_ecom) { @@ -1961,7 +1948,7 @@ route_set_ecommunity (void *rule, struct prefix *prefix, new_ecom = ecommunity_dup (ecom); /* will be intern()'d or attr_flush()'d by bgp_update_main() */ - bgp_info->attr->extra->ecommunity = new_ecom; + bgp_info->attr->ecommunity = new_ecom; bgp_info->attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); } @@ -2129,16 +2116,14 @@ route_set_aggregator_as (void *rule, struct prefix *prefix, { struct bgp_info *bgp_info; struct aggregator *aggregator; - struct attr_extra *ae; if (type == RMAP_BGP) { bgp_info = object; aggregator = rule; - ae = bgp_attr_extra_get (bgp_info->attr); - ae->aggregator_as = aggregator->as; - ae->aggregator_addr = aggregator->address; + bgp_info->attr->aggregator_as = aggregator->as; + bgp_info->attr->aggregator_addr = aggregator->address; bgp_info->attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR); } @@ -2187,16 +2172,14 @@ route_set_tag (void *rule, struct prefix *prefix, { route_tag_t *tag; struct bgp_info *bgp_info; - struct attr_extra *ae; if (type == RMAP_BGP) { tag = rule; bgp_info = object; - ae = bgp_attr_extra_get (bgp_info->attr); /* Set tag value */ - ae->tag=*tag; + bgp_info->attr->tag=*tag; } @@ -2231,7 +2214,7 @@ route_set_label_index (void *rule, struct prefix *prefix, label_index = rv->value; if (label_index) { - (bgp_attr_extra_get (bgp_info->attr))->label_index = label_index; + bgp_info->attr->label_index = label_index; bgp_info->attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_PREFIX_SID); } } @@ -2302,14 +2285,11 @@ route_match_ipv6_next_hop (void *rule, struct prefix *prefix, { bgp_info = object; - if (!bgp_info->attr->extra) - return RMAP_NOMATCH; - - if (IPV6_ADDR_SAME (&bgp_info->attr->extra->mp_nexthop_global, addr)) + if (IPV6_ADDR_SAME (&bgp_info->attr->mp_nexthop_global, addr)) return RMAP_MATCH; - if (bgp_info->attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL && - IPV6_ADDR_SAME (&bgp_info->attr->extra->mp_nexthop_local, rule)) + if (bgp_info->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL && + IPV6_ADDR_SAME (&bgp_info->attr->mp_nexthop_local, rule)) return RMAP_MATCH; return RMAP_NOMATCH; @@ -2407,11 +2387,11 @@ route_set_ipv6_nexthop_global (void *rule, struct prefix *prefix, bgp_info = object; /* Set next hop value. */ - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_global = *address; + bgp_info->attr->mp_nexthop_global = *address; /* Set nexthop length. */ - if (bgp_info->attr->extra->mp_nexthop_len == 0) - bgp_info->attr->extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; + if (bgp_info->attr->mp_nexthop_len == 0) + bgp_info->attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; SET_FLAG(bgp_info->attr->rmap_change_flags, BATTR_RMAP_IPV6_GLOBAL_NHOP_CHANGED); @@ -2477,13 +2457,13 @@ route_set_ipv6_nexthop_prefer_global (void *rule, struct prefix *prefix, && sockunion_family (peer->su_remote) == AF_INET6) { /* Set next hop preference to global */ - bgp_info->attr->extra->mp_nexthop_prefer_global = TRUE; + bgp_info->attr->mp_nexthop_prefer_global = TRUE; SET_FLAG(bgp_info->attr->rmap_change_flags, BATTR_RMAP_IPV6_PREFER_GLOBAL_CHANGED); } else { - bgp_info->attr->extra->mp_nexthop_prefer_global = FALSE; + bgp_info->attr->mp_nexthop_prefer_global = FALSE; SET_FLAG(bgp_info->attr->rmap_change_flags, BATTR_RMAP_IPV6_PREFER_GLOBAL_CHANGED); } @@ -2535,11 +2515,11 @@ route_set_ipv6_nexthop_local (void *rule, struct prefix *prefix, bgp_info = object; /* Set next hop value. */ - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_local = *address; + bgp_info->attr->mp_nexthop_local = *address; /* Set nexthop length. */ - if (bgp_info->attr->extra->mp_nexthop_len != BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) - bgp_info->attr->extra->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; + if (bgp_info->attr->mp_nexthop_len != BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + bgp_info->attr->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; SET_FLAG(bgp_info->attr->rmap_change_flags, BATTR_RMAP_IPV6_LL_NHOP_CHANGED); @@ -2611,15 +2591,15 @@ route_set_ipv6_nexthop_peer (void *rule, struct prefix *prefix, /* Set next hop value and length in attribute. */ if (IN6_IS_ADDR_LINKLOCAL(&peer_address)) { - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_local = peer_address; - if (bgp_info->attr->extra->mp_nexthop_len != 32) - bgp_info->attr->extra->mp_nexthop_len = 32; + bgp_info->attr->mp_nexthop_local = peer_address; + if (bgp_info->attr->mp_nexthop_len != 32) + bgp_info->attr->mp_nexthop_len = 32; } else { - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_global = peer_address; - if (bgp_info->attr->extra->mp_nexthop_len == 0) - bgp_info->attr->extra->mp_nexthop_len = 16; + bgp_info->attr->mp_nexthop_global = peer_address; + if (bgp_info->attr->mp_nexthop_len == 0) + bgp_info->attr->mp_nexthop_len = 16; } } @@ -2633,9 +2613,9 @@ route_set_ipv6_nexthop_peer (void *rule, struct prefix *prefix, SET_FLAG(bgp_info->attr->rmap_change_flags, BATTR_RMAP_NEXTHOP_PEER_ADDRESS); /* clear next hop value. */ - memset (&((bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_global), + memset (&(bgp_info->attr->mp_nexthop_global), 0, sizeof (struct in6_addr)); - memset (&((bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_local), + memset (&(bgp_info->attr->mp_nexthop_local), 0, sizeof (struct in6_addr)); } } @@ -2688,8 +2668,8 @@ route_set_vpnv4_nexthop (void *rule, struct prefix *prefix, bgp_info = object; /* Set next hop value. */ - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_global_in = *address; - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_len = 4; + bgp_info->attr->mp_nexthop_global_in = *address; + bgp_info->attr->mp_nexthop_len = 4; } return RMAP_OKAY; @@ -2730,8 +2710,8 @@ route_set_vpnv6_nexthop (void *rule, struct prefix *prefix, bgp_info = object; /* Set next hop value. */ - memcpy (&(bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_global, address, sizeof(struct in6_addr)); - (bgp_attr_extra_get (bgp_info->attr))->mp_nexthop_len = BGP_ATTR_NHLEN_VPNV6_GLOBAL; + memcpy (&bgp_info->attr->mp_nexthop_global, address, sizeof(struct in6_addr)); + bgp_info->attr->mp_nexthop_len = BGP_ATTR_NHLEN_VPNV6_GLOBAL; } return RMAP_OKAY; @@ -2794,7 +2774,7 @@ route_set_originator_id (void *rule, struct prefix *prefix, route_map_object_t t bgp_info = object; bgp_info->attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID); - (bgp_attr_extra_get (bgp_info->attr))->originator_id = *address; + bgp_info->attr->originator_id = *address; } return RMAP_OKAY; diff --git a/bgpd/bgp_snmp.c b/bgpd/bgp_snmp.c index db69400a67..c1a6ad589d 100644 --- a/bgpd/bgp_snmp.c +++ b/bgpd/bgp_snmp.c @@ -802,16 +802,10 @@ bgp4PathAttrTable (struct variable *v, oid name[], size_t *length, return SNMP_INTEGER (1); break; case BGP4PATHATTRAGGREGATORAS: /* 10 */ - if (binfo->attr->extra) - return SNMP_INTEGER (binfo->attr->extra->aggregator_as); - else - return SNMP_INTEGER (0); + return SNMP_INTEGER (binfo->attr->aggregator_as); break; case BGP4PATHATTRAGGREGATORADDR: /* 11 */ - if (binfo->attr->extra) - return SNMP_IPADDRESS (binfo->attr->extra->aggregator_addr); - else - return SNMP_INTEGER (0); + return SNMP_IPADDRESS (binfo->attr->aggregator_addr); break; case BGP4PATHATTRCALCLOCALPREF: /* 12 */ return SNMP_INTEGER (-1); diff --git a/bgpd/bgp_updgrp_adv.c b/bgpd/bgp_updgrp_adv.c index c4cb8ae1b3..f81568976f 100644 --- a/bgpd/bgp_updgrp_adv.c +++ b/bgpd/bgp_updgrp_adv.c @@ -587,7 +587,6 @@ subgroup_announce_table (struct update_subgroup *subgrp, struct bgp_node *rn; struct bgp_info *ri; struct attr attr; - struct attr_extra extra; struct peer *peer; afi_t afi; safi_t safi; @@ -610,9 +609,6 @@ subgroup_announce_table (struct update_subgroup *subgrp, && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_DEFAULT_ORIGINATE)) subgroup_default_originate (subgrp, 0); - /* It's initialized in bgp_announce_check() */ - attr.extra = &extra; - for (rn = bgp_table_top (table); rn; rn = bgp_route_next (rn)) for (ri = rn->info; ri; ri = ri->next) @@ -716,18 +712,16 @@ subgroup_default_originate (struct update_subgroup *subgrp, int withdraw) str2prefix ("0.0.0.0/0", &p); else if (afi == AFI_IP6) { - struct attr_extra *ae = attr.extra; - str2prefix ("::/0", &p); /* IPv6 global nexthop must be included. */ - ae->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; + attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL; /* If the peer is on shared nextwork and we have link-local nexthop set it. */ if (peer->shared_network && !IN6_IS_ADDR_UNSPECIFIED (&peer->nexthop.v6_local)) - ae->mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; + attr.mp_nexthop_len = BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL; } if (peer->default_rmap[afi][safi].name) @@ -739,11 +733,9 @@ subgroup_default_originate (struct update_subgroup *subgrp, int withdraw) for (ri = rn->info; ri; ri = ri->next) { struct attr dummy_attr; - struct attr_extra dummy_extra; struct bgp_info info; /* Provide dummy so the route-map can't modify the attributes */ - dummy_attr.extra = &dummy_extra; bgp_attr_dup (&dummy_attr, ri->attr); info.peer = ri->peer; info.attr = &dummy_attr; @@ -794,7 +786,6 @@ subgroup_default_originate (struct update_subgroup *subgrp, int withdraw) } } - bgp_attr_extra_free (&attr); aspath_unintern (&aspath); } diff --git a/bgpd/bgp_vty.c b/bgpd/bgp_vty.c index b877d982c8..b58a3266a0 100644 --- a/bgpd/bgp_vty.c +++ b/bgpd/bgp_vty.c @@ -6724,11 +6724,6 @@ DEFUN (show_bgp_memory, mtype_memstr (memstrbuf, sizeof (memstrbuf), count * sizeof(struct attr)), VTYNL); - if ((count = mtype_stats_alloc (MTYPE_ATTR_EXTRA))) - vty_out (vty, "%ld BGP extra attributes, using %s of memory%s", count, - mtype_memstr (memstrbuf, sizeof (memstrbuf), - count * sizeof(struct attr_extra)), - VTYNL); if ((count = attr_unknown_count())) vty_out (vty, "%ld unknown attributes%s", count, VTYNL); diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c index 91c155b3fd..3a215dc476 100644 --- a/bgpd/bgp_zebra.c +++ b/bgpd/bgp_zebra.c @@ -73,14 +73,12 @@ struct stream *bgp_label_buf = NULL; 2. use an array to avoid number of mallocs. Number of supported next-hops are finite, use of arrays should be ok. */ struct attr attr_cp[MULTIPATH_NUM]; -struct attr_extra attr_extra_cp[MULTIPATH_NUM]; unsigned int attr_index = 0; /* Once per address-family initialization of the attribute array */ #define BGP_INFO_ATTR_BUF_INIT()\ do {\ memset(attr_cp, 0, MULTIPATH_NUM * sizeof(struct attr));\ - memset(attr_extra_cp, 0, MULTIPATH_NUM * sizeof(struct attr_extra));\ attr_index = 0;\ } while (0) @@ -88,7 +86,6 @@ do {\ do { \ *info_dst = *info_src; \ assert(attr_index != multipath_num);\ - attr_cp[attr_index].extra = &attr_extra_cp[attr_index]; \ bgp_attr_dup (&attr_cp[attr_index], info_src->attr); \ bgp_attr_deep_dup (&attr_cp[attr_index], info_src->attr); \ info_dst->attr = &attr_cp[attr_index]; \ @@ -1162,23 +1159,23 @@ bgp_info_to_ipv6_nexthop (struct bgp_info *info) struct in6_addr *nexthop = NULL; /* Only global address nexthop exists. */ - if (info->attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) - nexthop = &info->attr->extra->mp_nexthop_global; + if (info->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL) + nexthop = &info->attr->mp_nexthop_global; /* If both global and link-local address present. */ - if (info->attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + if (info->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) { /* Check if route-map is set to prefer global over link-local */ - if (info->attr->extra->mp_nexthop_prefer_global) - nexthop = &info->attr->extra->mp_nexthop_global; + if (info->attr->mp_nexthop_prefer_global) + nexthop = &info->attr->mp_nexthop_global; else { /* Workaround for Cisco's nexthop bug. */ - if (IN6_IS_ADDR_UNSPECIFIED (&info->attr->extra->mp_nexthop_global) + if (IN6_IS_ADDR_UNSPECIFIED (&info->attr->mp_nexthop_global) && info->peer->su_remote->sa.sa_family == AF_INET6) nexthop = &info->peer->su_remote->sin6.sin6_addr; else - nexthop = &info->attr->extra->mp_nexthop_local; + nexthop = &info->attr->mp_nexthop_local; } } @@ -1248,10 +1245,7 @@ bgp_zebra_announce (struct bgp_node *rn, struct prefix *p, struct bgp_info *info flags = 0; peer = info->peer; - if ((info->attr->extra) && (info->attr->extra->tag != 0)) - tag = info->attr->extra->tag; - else - tag = 0; + tag = info->attr->tag; /* When we create an aggregate route we must also install a Null0 route in * the RIB */ @@ -1305,7 +1299,7 @@ bgp_zebra_announce (struct bgp_node *rn, struct prefix *p, struct bgp_info *info { /* Metric is currently based on the best-path only */ metric = info_cp->attr->med; - tag = info_cp->attr->extra->tag; + tag = info_cp->attr->tag; } nexthop = &info_cp->attr->nexthop; } @@ -1420,8 +1414,6 @@ bgp_zebra_announce (struct bgp_node *rn, struct prefix *p, struct bgp_info *info ifindex = 0; nexthop = NULL; - assert (info->attr->extra); - if (bgp->table_map[afi][safi].name) BGP_INFO_ATTR_BUF_INIT(); @@ -1441,7 +1433,7 @@ bgp_zebra_announce (struct bgp_node *rn, struct prefix *p, struct bgp_info *info if (mpinfo == info) { metric = info_cp->attr->med; - tag = info_cp->attr->extra->tag; + tag = info_cp->attr->tag; } nexthop = bgp_info_to_ipv6_nexthop(info_cp); } @@ -1454,7 +1446,7 @@ bgp_zebra_announce (struct bgp_node *rn, struct prefix *p, struct bgp_info *info continue; if ((mpinfo == info) && - mpinfo->attr->extra->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) + mpinfo->attr->mp_nexthop_len == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL) if (mpinfo->peer->nexthop.ifp) ifindex = mpinfo->peer->nexthop.ifp->ifindex; @@ -1674,10 +1666,10 @@ bgp_zebra_withdraw (struct prefix *p, struct bgp_info *info, safi_t safi) api.metric = info->attr->med; api.tag = 0; - if ((info->attr->extra) && (info->attr->extra->tag != 0)) + if (info->attr->tag != 0) { SET_FLAG(api.message, ZAPI_MESSAGE_TAG); - api.tag = info->attr->extra->tag; + api.tag = info->attr->tag; } if (bgp_debug_zebra(p)) @@ -1696,8 +1688,6 @@ bgp_zebra_withdraw (struct prefix *p, struct bgp_info *info, safi_t safi) if (p->family == AF_INET6) { struct zapi_ipv6 api; - - assert (info->attr->extra); api.vrf_id = peer->bgp->vrf_id; api.flags = flags; @@ -1714,10 +1704,10 @@ bgp_zebra_withdraw (struct prefix *p, struct bgp_info *info, safi_t safi) api.metric = info->attr->med; api.tag = 0; - if ((info->attr->extra) && (info->attr->extra->tag != 0)) + if (info->attr->tag != 0) { SET_FLAG(api.message, ZAPI_MESSAGE_TAG); - api.tag = info->attr->extra->tag; + api.tag = info->attr->tag; } if (bgp_debug_zebra(p)) @@ -1903,9 +1893,7 @@ bgp_redistribute_metric_set (struct bgp *bgp, struct bgp_redist *red, afi_t afi, { struct attr *old_attr; struct attr new_attr; - struct attr_extra new_extra; - new_attr.extra = &new_extra; bgp_attr_dup (&new_attr, ri->attr); new_attr.med = red->redist_metric; old_attr = ri->attr; diff --git a/bgpd/rfapi/rfapi.c b/bgpd/rfapi/rfapi.c index ffd4e3e323..5a9544247c 100644 --- a/bgpd/rfapi/rfapi.c +++ b/bgpd/rfapi/rfapi.c @@ -715,7 +715,6 @@ add_vnc_route ( /* Cripes, the memory management of attributes is byzantine */ bgp_attr_default_set (&attr, BGP_ORIGIN_INCOMPLETE); - assert (attr.extra); /* * At this point: @@ -772,7 +771,6 @@ add_vnc_route ( /* Encap SAFI not used with MPLS */ vnc_zlog_debug_verbose ("%s: mpls tunnel type, encap safi omitted", __func__); aspath_unintern (&attr.aspath); /* Unintern original. */ - bgp_attr_extra_free (&attr); return; } } @@ -790,7 +788,7 @@ add_vnc_route ( } /* override default weight assigned by bgp_attr_default_set() */ - attr.extra->weight = rfd->peer ? rfd->peer->weight[afi][safi] : 0; + attr.weight = rfd->peer ? rfd->peer->weight[afi][safi] : 0; /* * NB: ticket 81: do not reset attr.aspath here because it would @@ -808,7 +806,7 @@ add_vnc_route ( if (type == ZEBRA_ROUTE_BGP_DIRECT || type == ZEBRA_ROUTE_BGP_DIRECT_EXT) { attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID); - attr.extra->originator_id = bgp->router_id; + attr.originator_id = bgp->router_id; } @@ -825,7 +823,7 @@ add_vnc_route ( encaptlv->length = 4; lt = htonl (*lifetime); memcpy (encaptlv->value, <, 4); - attr.extra->vnc_subtlvs = encaptlv; + attr.vnc_subtlvs = encaptlv; vnc_zlog_debug_verbose ("%s: set Encap Attr Prefix Lifetime to %d", __func__, *lifetime); } @@ -845,13 +843,13 @@ add_vnc_route ( */ encaptlv = encap_tlv_dup ((struct bgp_attr_encap_subtlv *) rfp_options); - if (attr.extra->vnc_subtlvs) + if (attr.vnc_subtlvs) { - attr.extra->vnc_subtlvs->next = encaptlv; + attr.vnc_subtlvs->next = encaptlv; } else { - attr.extra->vnc_subtlvs = encaptlv; + attr.vnc_subtlvs = encaptlv; } } @@ -859,7 +857,7 @@ add_vnc_route ( { struct bgp_tea_options *hop; /* XXX max of one tlv present so far from above code */ - struct bgp_attr_encap_subtlv *tail = attr.extra->vnc_subtlvs; + struct bgp_attr_encap_subtlv *tail = attr.vnc_subtlvs; for (hop = rfp_options; hop; hop = hop->next) { @@ -887,7 +885,7 @@ add_vnc_route ( } else { - attr.extra->vnc_subtlvs = encaptlv; + attr.vnc_subtlvs = encaptlv; } tail = encaptlv; } @@ -903,8 +901,8 @@ add_vnc_route ( */ - attr.extra->ecommunity = ecommunity_new (); - assert (attr.extra->ecommunity); + attr.ecommunity = ecommunity_new (); + assert (attr.ecommunity); if (TunnelType != BGP_ENCAP_TYPE_MPLS && TunnelType != BGP_ENCAP_TYPE_RESERVED) @@ -921,7 +919,7 @@ add_vnc_route ( beec.val[1] = ECOMMUNITY_OPAQUE_SUBTYPE_ENCAP; beec.val[6] = ((TunnelType) >> 8) & 0xff; beec.val[7] = (TunnelType) & 0xff; - ecommunity_add_val (attr.extra->ecommunity, &beec); + ecommunity_add_val (attr.ecommunity, &beec); } /* @@ -929,21 +927,21 @@ add_vnc_route ( */ if (rt_export_list) { - attr.extra->ecommunity = - ecommunity_merge (attr.extra->ecommunity, rt_export_list); + attr.ecommunity = + ecommunity_merge (attr.ecommunity, rt_export_list); } - if (attr.extra->ecommunity->size) + if (attr.ecommunity->size) { attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES); } else { - ecommunity_free (&attr.extra->ecommunity); - attr.extra->ecommunity = NULL; + ecommunity_free (&attr.ecommunity); + attr.ecommunity = NULL; } - vnc_zlog_debug_verbose ("%s: attr.extra->ecommunity=%p", __func__, - attr.extra->ecommunity); + vnc_zlog_debug_verbose ("%s: attr.ecommunity=%p", __func__, + attr.ecommunity); /* @@ -965,13 +963,13 @@ add_vnc_route ( */ attr.nexthop.s_addr = nexthop->addr.v4.s_addr; - attr.extra->mp_nexthop_global_in = nexthop->addr.v4; - attr.extra->mp_nexthop_len = 4; + attr.mp_nexthop_global_in = nexthop->addr.v4; + attr.mp_nexthop_len = 4; break; case AF_INET6: - attr.extra->mp_nexthop_global = nexthop->addr.v6; - attr.extra->mp_nexthop_len = 16; + attr.mp_nexthop_global = nexthop->addr.v6; + attr.mp_nexthop_len = 16; break; default: @@ -1016,7 +1014,6 @@ add_vnc_route ( new_attr = bgp_attr_intern (&attr); aspath_unintern (&attr.aspath); /* Unintern original. */ - bgp_attr_extra_free (&attr); /* * At this point: diff --git a/bgpd/rfapi/rfapi_encap_tlv.c b/bgpd/rfapi/rfapi_encap_tlv.c index 04f8b249f7..24bfb41bfa 100644 --- a/bgpd/rfapi/rfapi_encap_tlv.c +++ b/bgpd/rfapi/rfapi_encap_tlv.c @@ -162,28 +162,24 @@ rfapi_tunneltype_option_to_tlv ( struct rfapi_un_option * rfapi_encap_tlv_to_un_option (struct attr *attr) { - struct attr_extra *attre = attr->extra; struct rfapi_un_option *uo = NULL; struct rfapi_tunneltype_option *tto; int rc; struct bgp_attr_encap_subtlv *stlv; - if (!attre) - return NULL; - /* no tunnel encap attr stored */ - if (!attre->encap_tunneltype) + if (!attr->encap_tunneltype) return NULL; - stlv = attre->encap_subtlvs; + stlv = attr->encap_subtlvs; uo = XCALLOC (MTYPE_RFAPI_UN_OPTION, sizeof (struct rfapi_un_option)); assert (uo); uo->type = RFAPI_UN_OPTION_TYPE_TUNNELTYPE; - uo->v.tunnel.type = attre->encap_tunneltype; + uo->v.tunnel.type = attr->encap_tunneltype; tto = &uo->v.tunnel; - switch (attre->encap_tunneltype) + switch (attr->encap_tunneltype) { case BGP_ENCAP_TYPE_L2TPV3_OVER_IP: rc = tlv_to_bgp_encap_type_l2tpv3overip (stlv, &tto->bgpinfo.l2tpv3_ip); @@ -249,7 +245,7 @@ rfapi_encap_tlv_to_un_option (struct attr *attr) default: vnc_zlog_debug_verbose ("%s: unknown tunnel type %d", - __func__, attre->encap_tunneltype); + __func__, attr->encap_tunneltype); rc = -1; break; } diff --git a/bgpd/rfapi/rfapi_import.c b/bgpd/rfapi/rfapi_import.c index ec52b5742b..7b0ca0cbb9 100644 --- a/bgpd/rfapi/rfapi_import.c +++ b/bgpd/rfapi/rfapi_import.c @@ -1,4 +1,4 @@ -/* + /* * * Copyright 2009-2016, LabN Consulting, L.L.C. * @@ -308,12 +308,12 @@ rfapi_deferred_close_workfunc (struct work_queue *q, void *data) int rfapiGetL2o (struct attr *attr, struct rfapi_l2address_option *l2o) { - if (attr && attr->extra) + if (attr) { struct bgp_attr_encap_subtlv *pEncap; - for (pEncap = attr->extra->vnc_subtlvs; pEncap; pEncap = pEncap->next) + for (pEncap = attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) { if (pEncap->type == BGP_VNC_SUBTLV_TYPE_RFPOPTION) @@ -358,10 +358,10 @@ rfapiGetVncLifetime (struct attr *attr, uint32_t * lifetime) *lifetime = RFAPI_INFINITE_LIFETIME; /* default to infinite */ - if (attr && attr->extra) + if (attr) { - for (pEncap = attr->extra->vnc_subtlvs; pEncap; pEncap = pEncap->next) + for (pEncap = attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) { if (pEncap->type == BGP_VNC_SUBTLV_TYPE_LIFETIME) @@ -387,9 +387,9 @@ rfapiGetTunnelType (struct attr *attr, bgp_encap_types *type) { *type = BGP_ENCAP_TYPE_MPLS; /* default to MPLS */ - if (attr && attr->extra && attr->extra->ecommunity) + if (attr && attr->ecommunity) { - struct ecommunity *ecom = attr->extra->ecommunity; + struct ecommunity *ecom = attr->ecommunity; int i; for (i = 0; i < (ecom->size * ECOMMUNITY_SIZE); i += ECOMMUNITY_SIZE) @@ -431,9 +431,9 @@ rfapiGetVncTunnelUnAddr (struct attr *attr, struct prefix *p) return ENOENT; } - if (attr && attr->extra) + if (attr) { - for (pEncap = attr->extra->encap_subtlvs; pEncap; pEncap = pEncap->next) + for (pEncap = attr->encap_subtlvs; pEncap; pEncap = pEncap->next) { if (pEncap->type == BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT) @@ -1184,7 +1184,7 @@ rfapiVpnBiNhEqualsPt (struct bgp_info *bi, struct rfapi_ip_addr *hpt) if (!hpt || !bi) return 0; - family = BGP_MP_NEXTHOP_FAMILY (bi->attr->extra->mp_nexthop_len); + family = BGP_MP_NEXTHOP_FAMILY (bi->attr->mp_nexthop_len); if (hpt->addr_family != family) return 0; @@ -1192,12 +1192,12 @@ rfapiVpnBiNhEqualsPt (struct bgp_info *bi, struct rfapi_ip_addr *hpt) switch (family) { case AF_INET: - if (bi->attr->extra->mp_nexthop_global_in.s_addr != hpt->addr.v4.s_addr) + if (bi->attr->mp_nexthop_global_in.s_addr != hpt->addr.v4.s_addr) return 0; break; case AF_INET6: - if (IPV6_ADDR_CMP (&bi->attr->extra->mp_nexthop_global, &hpt->addr.v6)) + if (IPV6_ADDR_CMP (&bi->attr->mp_nexthop_global, &hpt->addr.v6)) return 0; break; @@ -1225,31 +1225,27 @@ rfapiVpnBiSamePtUn (struct bgp_info *bi1, struct bgp_info *bi2) if (!bi1->attr || !bi2->attr) return 0; - if (!bi1->attr->extra || !bi2->attr->extra) - return 0; - /* * VN address comparisons */ - if (BGP_MP_NEXTHOP_FAMILY (bi1->attr->extra->mp_nexthop_len) != - BGP_MP_NEXTHOP_FAMILY (bi2->attr->extra->mp_nexthop_len)) + if (BGP_MP_NEXTHOP_FAMILY (bi1->attr->mp_nexthop_len) != + BGP_MP_NEXTHOP_FAMILY (bi2->attr->mp_nexthop_len)) { return 0; } - switch (BGP_MP_NEXTHOP_FAMILY (bi1->attr->extra->mp_nexthop_len)) + switch (BGP_MP_NEXTHOP_FAMILY (bi1->attr->mp_nexthop_len)) { - case AF_INET: - if (bi1->attr->extra->mp_nexthop_global_in.s_addr != - bi2->attr->extra->mp_nexthop_global_in.s_addr) + if (bi1->attr->mp_nexthop_global_in.s_addr != + bi2->attr->mp_nexthop_global_in.s_addr) return 0; break; case AF_INET6: - if (IPV6_ADDR_CMP (&bi1->attr->extra->mp_nexthop_global, - &bi2->attr->extra->mp_nexthop_global)) + if (IPV6_ADDR_CMP (&bi1->attr->mp_nexthop_global, + &bi2->attr->mp_nexthop_global)) return 0; break; @@ -1419,11 +1415,11 @@ rfapiRouteInfo2NextHopEntry ( memcpy (&vo->v.l2addr.macaddr, &rn->p.u.prefix_eth.octet, ETHER_ADDR_LEN); /* only low 3 bytes of this are significant */ - if (bi->attr && bi->attr->extra) + if (bi->attr) { - (void) rfapiEcommunityGetLNI (bi->attr->extra->ecommunity, + (void) rfapiEcommunityGetLNI (bi->attr->ecommunity, &vo->v.l2addr.logical_net_id); - (void) rfapiEcommunityGetEthernetTag (bi->attr->extra->ecommunity, + (void) rfapiEcommunityGetEthernetTag (bi->attr->ecommunity, &vo->v.l2addr.tag_id); } @@ -1451,132 +1447,129 @@ rfapiRouteInfo2NextHopEntry ( bgp_encap_types tun_type; new->prefix.cost = rfapiRfpCost (bi->attr); - if (bi->attr->extra) + struct bgp_attr_encap_subtlv *pEncap; + + switch (BGP_MP_NEXTHOP_FAMILY (bi->attr->mp_nexthop_len)) { + case AF_INET: + new->vn_address.addr_family = AF_INET; + new->vn_address.addr.v4 = bi->attr->mp_nexthop_global_in; + break; - struct bgp_attr_encap_subtlv *pEncap; + case AF_INET6: + new->vn_address.addr_family = AF_INET6; + new->vn_address.addr.v6 = bi->attr->mp_nexthop_global; + break; - switch (BGP_MP_NEXTHOP_FAMILY (bi->attr->extra->mp_nexthop_len)) + default: + zlog_warn ("%s: invalid vpn nexthop length: %d", + __func__, bi->attr->mp_nexthop_len); + rfapi_free_next_hop_list (new); + return NULL; + } + + for (pEncap = bi->attr->vnc_subtlvs; pEncap; + pEncap = pEncap->next) + { + switch (pEncap->type) { - case AF_INET: - new->vn_address.addr_family = AF_INET; - new->vn_address.addr.v4 = bi->attr->extra->mp_nexthop_global_in; - break; - - case AF_INET6: - new->vn_address.addr_family = AF_INET6; - new->vn_address.addr.v6 = bi->attr->extra->mp_nexthop_global; + case BGP_VNC_SUBTLV_TYPE_LIFETIME: + /* use configured lifetime, not attr lifetime */ break; default: - zlog_warn ("%s: invalid vpn nexthop length: %d", - __func__, bi->attr->extra->mp_nexthop_len); - rfapi_free_next_hop_list (new); - return NULL; + zlog_warn ("%s: unknown VNC option type %d", + __func__, pEncap->type); + + + break; } + } - for (pEncap = bi->attr->extra->vnc_subtlvs; pEncap; - pEncap = pEncap->next) + rfapiGetTunnelType (bi->attr, &tun_type); + if (tun_type == BGP_ENCAP_TYPE_MPLS) + { + struct prefix p; + /* MPLS carries UN address in next hop */ + rfapiNexthop2Prefix (bi->attr, &p); + if (p.family != 0) { - switch (pEncap->type) - { - case BGP_VNC_SUBTLV_TYPE_LIFETIME: - /* use configured lifetime, not attr lifetime */ - break; - - default: - zlog_warn ("%s: unknown VNC option type %d", - __func__, pEncap->type); - - - break; - } + rfapiQprefix2Raddr(&p, &new->un_address); + have_vnc_tunnel_un = 1; } + } - rfapiGetTunnelType (bi->attr, &tun_type); - if (tun_type == BGP_ENCAP_TYPE_MPLS) + for (pEncap = bi->attr->encap_subtlvs; pEncap; + pEncap = pEncap->next) + { + switch (pEncap->type) { - struct prefix p; - /* MPLS carries UN address in next hop */ - rfapiNexthop2Prefix (bi->attr, &p); - if (p.family != 0) + case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT: + /* + * Overrides ENCAP UN address, if any + */ + switch (pEncap->length) { - rfapiQprefix2Raddr(&p, &new->un_address); + + case 8: + new->un_address.addr_family = AF_INET; + memcpy (&new->un_address.addr.v4, pEncap->value, 4); have_vnc_tunnel_un = 1; - } - } + break; - for (pEncap = bi->attr->extra->encap_subtlvs; pEncap; - pEncap = pEncap->next) - { - switch (pEncap->type) - { - case BGP_ENCAP_SUBTLV_TYPE_REMOTE_ENDPOINT: - /* - * Overrides ENCAP UN address, if any - */ - switch (pEncap->length) - { - - case 8: - new->un_address.addr_family = AF_INET; - memcpy (&new->un_address.addr.v4, pEncap->value, 4); - have_vnc_tunnel_un = 1; - break; - - case 20: - new->un_address.addr_family = AF_INET6; - memcpy (&new->un_address.addr.v6, pEncap->value, 16); - have_vnc_tunnel_un = 1; - break; - - default: - zlog_warn - ("%s: invalid tunnel subtlv UN addr length (%d) for bi %p", - __func__, pEncap->length, bi); - } + case 20: + new->un_address.addr_family = AF_INET6; + memcpy (&new->un_address.addr.v6, pEncap->value, 16); + have_vnc_tunnel_un = 1; break; default: - zlog_warn ("%s: unknown Encap Attribute option type %d", - __func__, pEncap->type); - - - break; + zlog_warn + ("%s: invalid tunnel subtlv UN addr length (%d) for bi %p", + __func__, pEncap->length, bi); } - } + break; - new->un_options = rfapi_encap_tlv_to_un_option (bi->attr); + default: + zlog_warn ("%s: unknown Encap Attribute option type %d", + __func__, pEncap->type); + + + break; + } + } + + new->un_options = rfapi_encap_tlv_to_un_option (bi->attr); #if DEBUG_ENCAP_MONITOR - vnc_zlog_debug_verbose ("%s: line %d: have_vnc_tunnel_un=%d", - __func__, __LINE__, have_vnc_tunnel_un); + vnc_zlog_debug_verbose ("%s: line %d: have_vnc_tunnel_un=%d", + __func__, __LINE__, have_vnc_tunnel_un); #endif - if (!have_vnc_tunnel_un && bi && bi->extra) + if (!have_vnc_tunnel_un && bi && bi->extra) + { + /* + * use cached UN address from ENCAP route + */ + new->un_address.addr_family = bi->extra->vnc.import.un_family; + switch (new->un_address.addr_family) { - /* - * use cached UN address from ENCAP route - */ - new->un_address.addr_family = bi->extra->vnc.import.un_family; - switch (new->un_address.addr_family) - { - case AF_INET: - new->un_address.addr.v4 = bi->extra->vnc.import.un.addr4; - break; - case AF_INET6: - new->un_address.addr.v6 = bi->extra->vnc.import.un.addr6; - break; - default: - zlog_warn ("%s: invalid UN addr family (%d) for bi %p", - __func__, new->un_address.addr_family, bi); - rfapi_free_next_hop_list (new); - return NULL; - break; - } + case AF_INET: + new->un_address.addr.v4 = bi->extra->vnc.import.un.addr4; + break; + case AF_INET6: + new->un_address.addr.v6 = bi->extra->vnc.import.un.addr6; + break; + default: + zlog_warn ("%s: invalid UN addr family (%d) for bi %p", + __func__, new->un_address.addr_family, bi); + rfapi_free_next_hop_list (new); + return NULL; + break; } } } + new->lifetime = lifetime; return new; } @@ -2702,19 +2695,18 @@ rfapiNexthop2Prefix (struct attr *attr, struct prefix *p) { assert (p); assert (attr); - assert (attr->extra); memset (p, 0, sizeof (struct prefix)); - switch (p->family = BGP_MP_NEXTHOP_FAMILY (attr->extra->mp_nexthop_len)) + switch (p->family = BGP_MP_NEXTHOP_FAMILY (attr->mp_nexthop_len)) { case AF_INET: - p->u.prefix4 = attr->extra->mp_nexthop_global_in; + p->u.prefix4 = attr->mp_nexthop_global_in; p->prefixlen = 32; break; case AF_INET6: - p->u.prefix6 = attr->extra->mp_nexthop_global; + p->u.prefix6 = attr->mp_nexthop_global; p->prefixlen = 128; break; @@ -2779,9 +2771,7 @@ rfapiAttrNexthopAddrDifferent (struct prefix *p1, struct prefix *p2) static void rfapiCopyUnEncap2VPN (struct bgp_info *encap_bi, struct bgp_info *vpn_bi) { - struct attr_extra *attre; - - if (!encap_bi->attr || !encap_bi->attr->extra) + if (!encap_bi->attr) { zlog_warn ("%s: no encap bi attr/extra, can't copy UN address", __func__); @@ -2795,9 +2785,7 @@ rfapiCopyUnEncap2VPN (struct bgp_info *encap_bi, struct bgp_info *vpn_bi) return; } - attre = encap_bi->attr->extra; - - switch (BGP_MP_NEXTHOP_FAMILY (attre->mp_nexthop_len)) + switch (BGP_MP_NEXTHOP_FAMILY (encap_bi->attr->mp_nexthop_len)) { case AF_INET: @@ -2811,17 +2799,17 @@ rfapiCopyUnEncap2VPN (struct bgp_info *encap_bi, struct bgp_info *vpn_bi) } vpn_bi->extra->vnc.import.un_family = AF_INET; - vpn_bi->extra->vnc.import.un.addr4 = attre->mp_nexthop_global_in; + vpn_bi->extra->vnc.import.un.addr4 = encap_bi->attr->mp_nexthop_global_in; break; case AF_INET6: vpn_bi->extra->vnc.import.un_family = AF_INET6; - vpn_bi->extra->vnc.import.un.addr6 = attre->mp_nexthop_global; + vpn_bi->extra->vnc.import.un.addr6 = encap_bi->attr->mp_nexthop_global; break; default: zlog_warn ("%s: invalid encap nexthop length: %d", - __func__, attre->mp_nexthop_len); + __func__, encap_bi->attr->mp_nexthop_len); vpn_bi->extra->vnc.import.un_family = 0; break; } @@ -3102,21 +3090,21 @@ rfapiExpireEncapNow ( static int rfapiGetNexthop (struct attr *attr, struct prefix *prefix) { - switch (BGP_MP_NEXTHOP_FAMILY (attr->extra->mp_nexthop_len)) + switch (BGP_MP_NEXTHOP_FAMILY (attr->mp_nexthop_len)) { case AF_INET: prefix->family = AF_INET; prefix->prefixlen = 32; - prefix->u.prefix4 = attr->extra->mp_nexthop_global_in; + prefix->u.prefix4 = attr->mp_nexthop_global_in; break; case AF_INET6: prefix->family = AF_INET6; prefix->prefixlen = 128; - prefix->u.prefix6 = attr->extra->mp_nexthop_global; + prefix->u.prefix6 = attr->mp_nexthop_global; break; default: - vnc_zlog_debug_verbose ("%s: unknown attr->extra->mp_nexthop_len %d", __func__, - attr->extra->mp_nexthop_len); + vnc_zlog_debug_verbose ("%s: unknown attr->mp_nexthop_len %d", __func__, + attr->mp_nexthop_len); return EINVAL; } return 0; @@ -3187,7 +3175,7 @@ rfapiBgpInfoFilteredImportEncap ( * On a withdraw, peer and RD are sufficient to determine if * we should act. */ - if (!attr || !attr->extra || !attr->extra->ecommunity) + if (!attr || !attr->ecommunity) { vnc_zlog_debug_verbose ("%s: attr, extra, or ecommunity missing, not importing", @@ -3195,7 +3183,7 @@ rfapiBgpInfoFilteredImportEncap ( return; } #if RFAPI_REQUIRE_ENCAP_BEEC - if (!rfapiEcommunitiesMatchBeec (attr->extra->ecommunity)) + if (!rfapiEcommunitiesMatchBeec (attr->ecommunity)) { vnc_zlog_debug_verbose ("%s: it=%p: no match for BGP Encapsulation ecommunity", __func__, import_table); @@ -3203,7 +3191,7 @@ rfapiBgpInfoFilteredImportEncap ( } #endif if (!rfapiEcommunitiesIntersect (import_table->rt_import_list, - attr->extra->ecommunity)) + attr->ecommunity)) { vnc_zlog_debug_verbose ("%s: it=%p: no ecommunity intersection", @@ -3669,7 +3657,7 @@ rfapiBgpInfoFilteredImportVPN ( */ if (action == FIF_ACTION_UPDATE) { - if (!attr || !attr->extra || !attr->extra->ecommunity) + if (!attr || !attr->ecommunity) { vnc_zlog_debug_verbose ("%s: attr, extra, or ecommunity missing, not importing", @@ -3678,7 +3666,7 @@ rfapiBgpInfoFilteredImportVPN ( } if ((import_table != bgp->rfapi->it_ce) && !rfapiEcommunitiesIntersect (import_table->rt_import_list, - attr->extra->ecommunity)) + attr->ecommunity)) { vnc_zlog_debug_verbose ("%s: it=%p: no ecommunity intersection", @@ -4162,12 +4150,12 @@ rfapiProcessUpdate ( * Find rt containing LNI (Logical Network ID), which * _should_ always be present when mac address is present */ - rc = rfapiEcommunityGetLNI (attr->extra->ecommunity, &lni); + rc = rfapiEcommunityGetLNI (attr->ecommunity, &lni); vnc_zlog_debug_verbose - ("%s: rfapiEcommunityGetLNI returned %d, lni=%d, attr=%p, attr->extra=%p", - __func__, rc, lni, attr, attr->extra); - if (attr && attr->extra && !rc) + ("%s: rfapiEcommunityGetLNI returned %d, lni=%d, attr=%p", + __func__, rc, lni, attr); + if (attr && !rc) { it = rfapiMacImportTableGet (bgp, lni); diff --git a/bgpd/rfapi/rfapi_rib.c b/bgpd/rfapi/rfapi_rib.c index 5c3976a0c1..563c862381 100644 --- a/bgpd/rfapi/rfapi_rib.c +++ b/bgpd/rfapi/rfapi_rib.c @@ -664,7 +664,7 @@ rfapiRibBi2Ri( ri->lifetime = lifetime; /* This loop based on rfapiRouteInfo2NextHopEntry() */ - for (pEncap = bi->attr->extra->vnc_subtlvs; pEncap; pEncap = pEncap->next) + for (pEncap = bi->attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) { struct bgp_tea_options *hop; @@ -723,11 +723,11 @@ rfapiRibBi2Ri( memcpy (&vo->v.l2addr.macaddr, bi->extra->vnc.import.rd.val+2, ETHER_ADDR_LEN); - if (bi->attr && bi->attr->extra) + if (bi->attr) { - (void) rfapiEcommunityGetLNI (bi->attr->extra->ecommunity, + (void) rfapiEcommunityGetLNI (bi->attr->ecommunity, &vo->v.l2addr.logical_net_id); - (void) rfapiEcommunityGetEthernetTag (bi->attr->extra->ecommunity, + (void) rfapiEcommunityGetEthernetTag (bi->attr->ecommunity, &vo->v.l2addr.tag_id); } diff --git a/bgpd/rfapi/rfapi_vty.c b/bgpd/rfapi/rfapi_vty.c index d12958a600..81e307d86f 100644 --- a/bgpd/rfapi/rfapi_vty.c +++ b/bgpd/rfapi/rfapi_vty.c @@ -469,9 +469,9 @@ rfapi_vty_out_vncinfo ( } } - if (bi->attr && bi->attr->extra && bi->attr->extra->ecommunity) + if (bi->attr && bi->attr->ecommunity) { - s = ecommunity_ecom2str (bi->attr->extra->ecommunity, + s = ecommunity_ecom2str (bi->attr->ecommunity, ECOMMUNITY_FORMAT_ROUTE_MAP, 0); vty_out (vty, " EC{%s}", s); XFREE (MTYPE_ECOMMUNITY_STR, s); @@ -499,7 +499,6 @@ rfapiPrintAttrPtrs (void *stream, struct attr *attr) void *out; const char *vty_newline; - struct attr_extra *ae; char buf[BUFSIZ]; if (rfapiStream2Vty (stream, &fp, &vty, &out, &vty_newline) == 0) @@ -518,15 +517,12 @@ rfapiPrintAttrPtrs (void *stream, struct attr *attr) fp (out, " community=%p, refcnt=%d%s", attr->community, (attr->community ? attr->community->refcnt : 0), HVTYNL); - if ((ae = attr->extra)) - { - fp (out, " ecommunity=%p, refcnt=%d%s", ae->ecommunity, - (ae->ecommunity ? ae->ecommunity->refcnt : 0), HVTYNL); - fp (out, " cluster=%p, refcnt=%d%s", ae->cluster, - (ae->cluster ? ae->cluster->refcnt : 0), HVTYNL); - fp (out, " transit=%p, refcnt=%d%s", ae->transit, - (ae->transit ? ae->transit->refcnt : 0), HVTYNL); - } + fp (out, " ecommunity=%p, refcnt=%d%s", attr->ecommunity, + (attr->ecommunity ? attr->ecommunity->refcnt : 0), HVTYNL); + fp (out, " cluster=%p, refcnt=%d%s", attr->cluster, + (attr->cluster ? attr->cluster->refcnt : 0), HVTYNL); + fp (out, " transit=%p, refcnt=%d%s", attr->transit, + (attr->transit ? attr->transit->refcnt : 0), HVTYNL); } /* @@ -593,26 +589,26 @@ rfapiPrintBi (void *stream, struct bgp_info *bi) * RFP option sizes (they are opaque values) * extended communities (RTs) */ - if (bi->attr && bi->attr->extra) + if (bi->attr) { uint32_t lifetime; int printed_1st_gol = 0; struct bgp_attr_encap_subtlv *pEncap; struct prefix pfx_un; - int af = BGP_MP_NEXTHOP_FAMILY (bi->attr->extra->mp_nexthop_len); + int af = BGP_MP_NEXTHOP_FAMILY (bi->attr->mp_nexthop_len); /* Nexthop */ if (af == AF_INET) { r = snprintf (p, REMAIN, "%s", inet_ntop (AF_INET, - &bi->attr->extra->mp_nexthop_global_in, + &bi->attr->mp_nexthop_global_in, buf, BUFSIZ)); INCP; } else if (af == AF_INET6) { r = snprintf (p, REMAIN, "%s", inet_ntop (AF_INET6, - &bi->attr->extra->mp_nexthop_global, + &bi->attr->mp_nexthop_global, buf, BUFSIZ)); INCP; } @@ -650,7 +646,7 @@ rfapiPrintBi (void *stream, struct bgp_info *bi) } /* RFP option lengths */ - for (pEncap = bi->attr->extra->vnc_subtlvs; pEncap; + for (pEncap = bi->attr->vnc_subtlvs; pEncap; pEncap = pEncap->next) { @@ -673,9 +669,9 @@ rfapiPrintBi (void *stream, struct bgp_info *bi) } /* RT list */ - if (bi->attr->extra->ecommunity) + if (bi->attr->ecommunity) { - s = ecommunity_ecom2str (bi->attr->extra->ecommunity, + s = ecommunity_ecom2str (bi->attr->ecommunity, ECOMMUNITY_FORMAT_ROUTE_MAP, 0); r = snprintf (p, REMAIN, " %s", s); INCP; @@ -704,9 +700,9 @@ rfapiPrintBi (void *stream, struct bgp_info *bi) if (bi->attr) { - if (bi->attr->extra) + if (bi->attr->weight) { - r = snprintf (p, REMAIN, " W=%d", bi->attr->extra->weight); + r = snprintf (p, REMAIN, " W=%d", bi->attr->weight); INCP; } diff --git a/bgpd/rfapi/vnc_export_bgp.c b/bgpd/rfapi/vnc_export_bgp.c index bca95e47c0..342dc6a193 100644 --- a/bgpd/rfapi/vnc_export_bgp.c +++ b/bgpd/rfapi/vnc_export_bgp.c @@ -74,7 +74,6 @@ encap_attr_export_ce ( */ memset (new, 0, sizeof (struct attr)); bgp_attr_dup (new, orig); - bgp_attr_extra_get (new); /* * Set nexthop @@ -83,17 +82,13 @@ encap_attr_export_ce ( { case AF_INET: new->nexthop = use_nexthop->u.prefix4; - new->extra->mp_nexthop_len = 4; /* bytes */ + new->mp_nexthop_len = 4; /* bytes */ new->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP); break; case AF_INET6: - if (!new->extra) - { - new->extra = XCALLOC (MTYPE_ATTR_EXTRA, sizeof (struct attr_extra)); - } - new->extra->mp_nexthop_global = use_nexthop->u.prefix6; - new->extra->mp_nexthop_len = 16; /* bytes */ + new->mp_nexthop_global = use_nexthop->u.prefix6; + new->mp_nexthop_len = 16; /* bytes */ break; default: @@ -133,7 +128,6 @@ encap_attr_export_ce ( * * Caller should, after using the attr, call: * - bgp_attr_flush() to free non-interned parts - * - call bgp_attr_extra_free() to free extra */ } @@ -144,8 +138,8 @@ getce (struct bgp *bgp, struct attr *attr, struct prefix *pfx_ce) int i; uint16_t localadmin = bgp->rfapi_cfg->resolve_nve_roo_local_admin; - for (ecp = attr->extra->ecommunity->val, i = 0; - i < attr->extra->ecommunity->size; ++i, ecp += ECOMMUNITY_SIZE) + for (ecp = attr->ecommunity->val, i = 0; + i < attr->ecommunity->size; ++i, ecp += ECOMMUNITY_SIZE) { if (VNC_DEBUG(EXPORT_BGP_GETCE)) @@ -309,14 +303,12 @@ vnc_direct_bgp_add_route_ce ( if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); return; } } iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* * Rule: disallow route-map alteration of next-hop, because it @@ -563,14 +555,14 @@ vnc_route_origin_ecom (struct route_node *rn) struct ecommunity_val roec; - switch (BGP_MP_NEXTHOP_FAMILY (bi->attr->extra->mp_nexthop_len)) + switch (BGP_MP_NEXTHOP_FAMILY (bi->attr->mp_nexthop_len)) { case AF_INET: memset (&roec, 0, sizeof (roec)); roec.val[0] = 0x01; roec.val[1] = 0x03; memcpy (roec.val + 2, - &bi->attr->extra->mp_nexthop_global_in.s_addr, 4); + &bi->attr->mp_nexthop_global_in.s_addr, 4); roec.val[6] = 0; roec.val[7] = 0; ecommunity_add_val (new, &roec); @@ -642,16 +634,16 @@ encap_attr_export ( { use_nexthop = &orig_nexthop; orig_nexthop.family = - BGP_MP_NEXTHOP_FAMILY (orig->extra->mp_nexthop_len); + BGP_MP_NEXTHOP_FAMILY (orig->mp_nexthop_len); if (orig_nexthop.family == AF_INET) { orig_nexthop.prefixlen = 32; - orig_nexthop.u.prefix4 = orig->extra->mp_nexthop_global_in; + orig_nexthop.u.prefix4 = orig->mp_nexthop_global_in; } else if (orig_nexthop.family == AF_INET6) { orig_nexthop.prefixlen = 128; - orig_nexthop.u.prefix6 = orig->extra->mp_nexthop_global; + orig_nexthop.u.prefix6 = orig->mp_nexthop_global; } else { @@ -673,17 +665,13 @@ encap_attr_export ( { case AF_INET: new->nexthop = use_nexthop->u.prefix4; - new->extra->mp_nexthop_len = 4; /* bytes */ + new->mp_nexthop_len = 4; /* bytes */ new->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP); break; case AF_INET6: - if (!new->extra) - { - new->extra = XCALLOC (MTYPE_ATTR_EXTRA, sizeof (struct attr_extra)); - } - new->extra->mp_nexthop_global = use_nexthop->u.prefix6; - new->extra->mp_nexthop_len = 16; /* bytes */ + new->mp_nexthop_global = use_nexthop->u.prefix6; + new->mp_nexthop_len = 16; /* bytes */ break; default: @@ -691,7 +679,6 @@ encap_attr_export ( break; } - bgp_attr_extra_get (new); if (rn) { ecom_ro = vnc_route_origin_ecom (rn); @@ -701,17 +688,14 @@ encap_attr_export ( /* TBD test/assert for IPv6 */ ecom_ro = vnc_route_origin_ecom_single (&use_nexthop->u.prefix4); } - if (new->extra->ecommunity) + if (new->ecommunity) { if (ecom_ro) - { - new->extra->ecommunity = - ecommunity_merge (ecom_ro, new->extra->ecommunity); - } + new->ecommunity = ecommunity_merge (ecom_ro, new->ecommunity); } else { - new->extra->ecommunity = ecom_ro; + new->ecommunity = ecom_ro; } if (ecom_ro) { @@ -750,7 +734,6 @@ encap_attr_export ( * * Caller should, after using the attr, call: * - bgp_attr_flush() to free non-interned parts - * - call bgp_attr_extra_free() to free extra */ return 0; @@ -887,7 +870,6 @@ vnc_direct_bgp_add_prefix ( if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); vnc_zlog_debug_verbose ("%s: route map says DENY, so not calling bgp_update", __func__); @@ -903,7 +885,6 @@ vnc_direct_bgp_add_prefix ( iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); bgp_update (irfd->peer, &rn->p, /* prefix */ 0, /* addpath_id */ @@ -917,7 +898,6 @@ vnc_direct_bgp_add_prefix ( } aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } /* @@ -1134,7 +1114,6 @@ vnc_direct_bgp_add_nve (struct bgp *bgp, struct rfapi_descriptor *rfd) if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); continue; } @@ -1142,7 +1121,6 @@ vnc_direct_bgp_add_nve (struct bgp *bgp, struct rfapi_descriptor *rfd) iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); bgp_update (irfd->peer, &rn->p, /* prefix */ 0, /* addpath_id */ @@ -1157,7 +1135,6 @@ vnc_direct_bgp_add_nve (struct bgp *bgp, struct rfapi_descriptor *rfd) } aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } } } @@ -1361,7 +1338,6 @@ vnc_direct_bgp_add_group_afi ( if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); continue; } @@ -1369,7 +1345,6 @@ vnc_direct_bgp_add_group_afi ( iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); bgp_update (irfd->peer, &rn->p, /* prefix */ 0, /* addpath_id */ @@ -1384,7 +1359,6 @@ vnc_direct_bgp_add_group_afi ( } aspath_unintern (&attr.aspath); - bgp_attr_extra_free (&attr); } @@ -1744,14 +1718,12 @@ vnc_direct_bgp_rh_add_route ( if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); return; } } iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* * record route information that we will need to expire @@ -1983,7 +1955,6 @@ vnc_direct_bgp_rh_vpn_enable (struct bgp *bgp, afi_t afi) if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); vnc_zlog_debug_verbose ("%s: route map says DENY", __func__); continue; } @@ -1991,7 +1962,6 @@ vnc_direct_bgp_rh_vpn_enable (struct bgp *bgp, afi_t afi) iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* * record route information that we will need to expire diff --git a/bgpd/rfapi/vnc_import_bgp.c b/bgpd/rfapi/vnc_import_bgp.c index 47203cd238..1daf02a6bf 100644 --- a/bgpd/rfapi/vnc_import_bgp.c +++ b/bgpd/rfapi/vnc_import_bgp.c @@ -393,7 +393,6 @@ process_unicast_route ( if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); vnc_zlog_debug_verbose ("%s: route map \"%s\" says DENY, returning", __func__, rmap->name); return -1; @@ -406,8 +405,8 @@ process_unicast_route ( */ rfapiUnicastNexthop2Prefix (afi, &hattr, unicast_nexthop); - if (hattr.extra && hattr.extra->ecommunity) - *ecom = ecommunity_dup (hattr.extra->ecommunity); + if (hattr.ecommunity) + *ecom = ecommunity_dup (hattr.ecommunity); else *ecom = ecommunity_new (); @@ -415,7 +414,6 @@ process_unicast_route ( * Done with hattr, clean up */ bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* * Add EC that carries original NH of iBGP route (2 bytes = magic @@ -510,18 +508,18 @@ vnc_import_bgp_add_route_mode_resolve_nve_one_bi ( plifetime = &lifetime; } - if (bi->attr && bi->attr->extra) + if (bi->attr) { - encaptlvs = bi->attr->extra->vnc_subtlvs; - if (bi->attr->extra->encap_tunneltype != BGP_ENCAP_TYPE_RESERVED && - bi->attr->extra->encap_tunneltype != BGP_ENCAP_TYPE_MPLS) + encaptlvs = bi->attr->vnc_subtlvs; + if (bi->attr->encap_tunneltype != BGP_ENCAP_TYPE_RESERVED && + bi->attr->encap_tunneltype != BGP_ENCAP_TYPE_MPLS) { if (opt != NULL) opt->next = &optary[cur_opt]; opt = &optary[cur_opt++]; memset (opt, 0, sizeof (struct rfapi_un_option)); opt->type = RFAPI_UN_OPTION_TYPE_TUNNELTYPE; - opt->v.tunnel.type = bi->attr->extra->encap_tunneltype; + opt->v.tunnel.type = bi->attr->encap_tunneltype; /* TBD parse bi->attr->extra->encap_subtlvs */ } } @@ -532,8 +530,8 @@ vnc_import_bgp_add_route_mode_resolve_nve_one_bi ( struct ecommunity *new_ecom = ecommunity_dup (ecom); - if (bi->attr && bi->attr->extra && bi->attr->extra->ecommunity) - ecommunity_merge (new_ecom, bi->attr->extra->ecommunity); + if (bi->attr && bi->attr->ecommunity) + ecommunity_merge (new_ecom, bi->attr->ecommunity); if (bi->extra) label = decode_label (&bi->extra->label); @@ -891,7 +889,6 @@ vnc_import_bgp_add_route_mode_plain (struct bgp *bgp, if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); vnc_zlog_debug_verbose ("%s: route map \"%s\" says DENY, returning", __func__, rmap->name); return; @@ -900,7 +897,6 @@ vnc_import_bgp_add_route_mode_plain (struct bgp *bgp, iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* Now iattr is an allocated interned attr */ @@ -925,8 +921,8 @@ vnc_import_bgp_add_route_mode_plain (struct bgp *bgp, memset (&prd, 0, sizeof (prd)); rfapi_set_autord_from_vn (&prd, &vnaddr); - if (iattr && iattr->extra && iattr->extra->ecommunity) - ecom = ecommunity_dup (iattr->extra->ecommunity); + if (iattr && iattr->ecommunity) + ecom = ecommunity_dup (iattr->ecommunity); } @@ -1103,7 +1099,6 @@ vnc_import_bgp_add_route_mode_nvegroup (struct bgp *bgp, if (ret == RMAP_DENYMATCH) { bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); vnc_zlog_debug_verbose ("%s: route map \"%s\" says DENY, returning", __func__, rmap->name); return; @@ -1112,7 +1107,6 @@ vnc_import_bgp_add_route_mode_nvegroup (struct bgp *bgp, iattr = bgp_attr_intern (&hattr); bgp_attr_flush (&hattr); - bgp_attr_extra_free (&hattr); /* Now iattr is an allocated interned attr */ @@ -1139,8 +1133,8 @@ vnc_import_bgp_add_route_mode_nvegroup (struct bgp *bgp, else ecom = ecommunity_new (); - if (iattr && iattr->extra && iattr->extra->ecommunity) - ecom = ecommunity_merge (ecom, iattr->extra->ecommunity); + if (iattr && iattr->ecommunity) + ecom = ecommunity_merge (ecom, iattr->ecommunity); } local_pref = calc_local_pref (iattr, peer); @@ -1942,7 +1936,6 @@ vnc_import_bgp_exterior_add_route_it ( ZEBRA_ROUTE_BGP_DIRECT_EXT, BGP_ROUTE_REDISTRIBUTE, &label); - bgp_attr_extra_free (&new_attr); } if (have_usable_route) @@ -2273,7 +2266,6 @@ vnc_import_bgp_exterior_add_route_interior ( ZEBRA_ROUTE_BGP_DIRECT_EXT, BGP_ROUTE_REDISTRIBUTE, &label); - bgp_attr_extra_free (&new_attr); } vnc_zlog_debug_verbose ("%s: finished constructing exteriors based on existing monitors", @@ -2412,7 +2404,6 @@ vnc_import_bgp_exterior_add_route_interior ( ZEBRA_ROUTE_BGP_DIRECT_EXT, BGP_ROUTE_REDISTRIBUTE, &label); - bgp_attr_extra_free (&new_attr); } } @@ -2536,7 +2527,6 @@ vnc_import_bgp_exterior_add_route_interior ( ZEBRA_ROUTE_BGP_DIRECT_EXT, BGP_ROUTE_REDISTRIBUTE, &label); - bgp_attr_extra_free (&new_attr); } } if (list_adopted) @@ -2740,7 +2730,6 @@ vnc_import_bgp_exterior_del_route_interior ( ZEBRA_ROUTE_BGP_DIRECT_EXT, BGP_ROUTE_REDISTRIBUTE, &label); - bgp_attr_extra_free (&new_attr); } }