Merge pull request #93 from CAIDA/addr

Addr

lib/bgpstream_bgpdump.c

@@ -125,8 +125,7 @@ char *bgpstream_record_elem_bgpdump_snprintf(char *buf, size_t len,
   case BGPSTREAM_ELEM_TYPE_RIB:
   case BGPSTREAM_ELEM_TYPE_ANNOUNCEMENT:
     /* PREFIX */
-    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN,
-                               (bgpstream_pfx_t *)&(elem->prefix)) == NULL) {
+    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN, &(elem->prefix)) == NULL) {
       bgpstream_log(BGPSTREAM_LOG_ERR, "Malformed prefix");
       return NULL;
     }
@@ -216,8 +215,7 @@ char *bgpstream_record_elem_bgpdump_snprintf(char *buf, size_t len,
     break;
   case BGPSTREAM_ELEM_TYPE_WITHDRAWAL:
     /* PREFIX */
-    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN,
-                               (bgpstream_pfx_t *)&(elem->prefix)) == NULL) {
+    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN, &(elem->prefix)) == NULL) {
       bgpstream_log(BGPSTREAM_LOG_ERR, "Malformed prefix");
       return NULL;
     }

lib/bgpstream_elem.c

@@ -285,8 +285,7 @@ char *bgpstream_elem_custom_snprintf(char *buf, size_t len,
   case BGPSTREAM_ELEM_TYPE_ANNOUNCEMENT:
 
     /* PREFIX */
-    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN,
-        (const bgpstream_pfx_t *)&(elem->prefix)) == NULL) {
+    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN, &(elem->prefix)) == NULL) {
       bgpstream_log(BGPSTREAM_LOG_ERR, "Malformed prefix (R/A)");
       return NULL;
     }
@@ -350,8 +349,7 @@ char *bgpstream_elem_custom_snprintf(char *buf, size_t len,
   case BGPSTREAM_ELEM_TYPE_WITHDRAWAL:
 
     /* PREFIX */
-    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN,
-        (const bgpstream_pfx_t *)&(elem->prefix)) == NULL) {
+    if (bgpstream_pfx_snprintf(buf_p, B_REMAIN, &(elem->prefix)) == NULL) {
       bgpstream_log(BGPSTREAM_LOG_ERR, "Malformed prefix (W)");
       return NULL;
     }

lib/bgpstream_elem.h

@@ -149,7 +149,7 @@ typedef struct bgpstream_elem_aggregator {
   uint32_t aggregator_asn;
 
   /** Aggregator IP */
-  bgpstream_addr_storage_t aggregator_addr;
+  bgpstream_ip_addr_t aggregator_addr;
 
 } bgpstream_elem_aggregator_t;
 
@@ -190,7 +190,7 @@ typedef struct bgpstream_elem {
    * This is the IP address that the peer used to connect to the collector (or
    * router in the case of BMP).
    */
-  bgpstream_addr_storage_t peer_ip;
+  bgpstream_ip_addr_t peer_ip;
 
   /** Peer AS number */
   uint32_t peer_asn;
@@ -201,13 +201,13 @@ typedef struct bgpstream_elem {
    *
    * Available only for RIB, Announcement and Withdrawal elem types
    */
-  bgpstream_pfx_storage_t prefix;
+  bgpstream_pfx_t prefix;
 
   /** Next hop
    *
    * Available only for RIB and Announcement elem types
    */
-  bgpstream_addr_storage_t nexthop;
+  bgpstream_ip_addr_t nexthop;
 
   /** AS path
    *

lib/bgpstream_filter.c

@@ -126,7 +126,7 @@ void bgpstream_filter_mgr_filter_add(bgpstream_filter_mgr_t *bs_filter_mgr,
   case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_LESS:
   case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_EXACT:
   case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_ANY: {
-    bgpstream_pfx_storage_t pfx;
+    bgpstream_pfx_t pfx;
     uint8_t matchtype;
 
     if (bs_filter_mgr->prefixes == NULL) {
@@ -151,8 +151,7 @@ void bgpstream_filter_mgr_filter_add(bgpstream_filter_mgr_t *bs_filter_mgr,
     }
 
     pfx.allowed_matches = matchtype;
-    if (bgpstream_patricia_tree_insert(bs_filter_mgr->prefixes,
-                                       (bgpstream_pfx_t *)&pfx) == NULL) {
+    if (bgpstream_patricia_tree_insert(bs_filter_mgr->prefixes, &pfx) == NULL) {
       bgpstream_log(BGPSTREAM_LOG_VFINE,
                     "\tBSF_MGR:: add_filter malloc failed");
       bgpstream_log(BGPSTREAM_LOG_ERR, "\tBSF_MGR: can't add prefix");

lib/bgpstream_record.c

@@ -201,17 +201,15 @@ static int elem_check_filters(bgpstream_record_t *record,
       return 0;
     }
 
-    bgpstream_ip_addr_t *addr = &(((bgpstream_pfx_t *)&elem->prefix)->address);
-    if (addr->version != filter_mgr->ipversion)
+    if (elem->prefix.address.version != filter_mgr->ipversion)
       return 0;
   }
 
   if (filter_mgr->prefixes) {
     if (elem->type == BGPSTREAM_ELEM_TYPE_PEERSTATE) {
       return 0;
     }
-    return bgpstream_elem_prefix_match(filter_mgr->prefixes,
-                                       (bgpstream_pfx_t *)&elem->prefix);
+    return bgpstream_elem_prefix_match(filter_mgr->prefixes, &elem->prefix);
   }
 
   /* Checking AS Path expressions */

lib/bgpstream_record.h

@@ -201,7 +201,7 @@ typedef struct bgpstream_record {
    * name is empty. In this case the router IP should be used to identify the
    * router.
    */
-  bgpstream_addr_storage_t router_ip;
+  bgpstream_ip_addr_t router_ip;
 
   /* ---------- DUMP-ONLY FIELDS: ---------- */
 

lib/formats/bgpstream_parsebgp_common.h

@@ -35,13 +35,11 @@
   do {                                                                         \
     switch (afi) {                                                             \
     case PARSEBGP_BGP_AFI_IPV4:                                                \
-      (dst)->version = BGPSTREAM_ADDR_VERSION_IPV4;                            \
-      memcpy(&(dst)->ipv4, src, 4);                                            \
+      bgpstream_ipv4_addr_init(dst, src);                                      \
       break;                                                                   \
                                                                                \
     case PARSEBGP_BGP_AFI_IPV6:                                                \
-      (dst)->version = BGPSTREAM_ADDR_VERSION_IPV6;                            \
-      memcpy(&(dst)->ipv6, src, 16);                                           \
+      bgpstream_ipv6_addr_init(dst, src);                                      \
       break;                                                                   \
                                                                                \
     default:                                                                   \

lib/formats/bs_format_bmp.c

@@ -283,11 +283,9 @@ static int populate_prep_cb(bgpstream_format_t *format, uint8_t *buf,
 
   // grab the router IP
   if (IS_ROUTER_IPV6) {
-    record->router_ip.version = BGPSTREAM_ADDR_VERSION_IPV6;
-    memcpy(&record->router_ip.ipv6, buf, 16);
+    bgpstream_ipv6_addr_init(&record->router_ip, buf);
   } else {
-    record->router_ip.version = BGPSTREAM_ADDR_VERSION_IPV4;
-    memcpy(&record->router_ip.ipv4, buf, 4);
+    bgpstream_ipv4_addr_init(&record->router_ip, buf);
   }
   nread += 16;
   buf += 16;

lib/formats/bs_format_mrt.c

@@ -44,7 +44,7 @@ typedef struct peer_index_entry {
   uint32_t peer_asn;
 
   /** Peer IP */
-  bgpstream_addr_storage_t peer_ip;
+  bgpstream_ip_addr_t peer_ip;
 
 } peer_index_entry_t;
 
@@ -132,8 +132,7 @@ static int handle_td2_rib_entry(rec_data_t *rd, khash_t(td2_peer) * peer_table,
     return -1;
   }
   bs_pie = &kh_val(peer_table, k);
-  bgpstream_addr_copy((bgpstream_ip_addr_t *)&rd->elem->peer_ip,
-                      (bgpstream_ip_addr_t *)&bs_pie->peer_ip);
+  bgpstream_addr_copy(&rd->elem->peer_ip, &bs_pie->peer_ip);
 
   rd->elem->peer_asn = bs_pie->peer_asn;
 

lib/utils/bgpstream_utils_addr.c

@@ -45,7 +45,7 @@ unsigned long
 #endif
 bgpstream_ipv4_addr_hash(const bgpstream_ipv4_addr_t *addr)
 {
-  return __ac_Wang_hash(addr->ipv4.s_addr);
+  return __ac_Wang_hash(addr->addr.s_addr);
 }
 
 #if ULONG_MAX == ULLONG_MAX
@@ -55,76 +55,63 @@ unsigned long long
 #endif
 bgpstream_ipv6_addr_hash(const bgpstream_ipv6_addr_t *addr)
 {
-  return __ac_Wang_hash(*((const khint64_t *)(&(addr->ipv6.s6_addr[0]))));
+  return __ac_Wang_hash(*((const khint64_t *)(&(addr->addr.s6_addr[0]))));
 }
 
 #if ULONG_MAX == ULLONG_MAX
 unsigned long
 #else
 unsigned long long
 #endif
-bgpstream_addr_storage_hash(bgpstream_addr_storage_t *addr)
+bgpstream_addr_hash(bgpstream_ip_addr_t *addr)
 {
   switch (addr->version) {
   case BGPSTREAM_ADDR_VERSION_IPV4:
-    return bgpstream_ipv4_addr_hash((bgpstream_ipv4_addr_t *)addr);
-    break;
+    return bgpstream_ipv4_addr_hash(&addr->bs_ipv4);
 
   case BGPSTREAM_ADDR_VERSION_IPV6:
-    return bgpstream_ipv6_addr_hash((bgpstream_ipv6_addr_t *)addr);
-    break;
+    return bgpstream_ipv6_addr_hash(&addr->bs_ipv6);
 
   default:
     return 0;
-    break;
   }
 }
 
 int bgpstream_addr_equal(const bgpstream_ip_addr_t *addr1,
     const bgpstream_ip_addr_t *addr2)
 {
-  if (addr1->version == BGPSTREAM_ADDR_VERSION_IPV4 &&
-      addr2->version == BGPSTREAM_ADDR_VERSION_IPV4) {
-    return bgpstream_ipv4_addr_equal((const bgpstream_ipv4_addr_t *)addr1,
-                                     (const bgpstream_ipv4_addr_t *)addr2);
-  }
-  if (addr1->version == BGPSTREAM_ADDR_VERSION_IPV6 &&
-      addr2->version == BGPSTREAM_ADDR_VERSION_IPV6) {
-    return bgpstream_ipv6_addr_equal((const bgpstream_ipv6_addr_t *)addr1,
-                                     (const bgpstream_ipv6_addr_t *)addr2);
-  }
-  return 0;
-}
-
-int bgpstream_addr_storage_equal(const bgpstream_addr_storage_t *addr1,
-                                 const bgpstream_addr_storage_t *addr2)
-{
-  return bgpstream_addr_equal((const bgpstream_ip_addr_t *)addr1,
-                              (const bgpstream_ip_addr_t *)addr2);
+  if (addr1->version != addr2->version)
+    return 0;
+  else if (addr1->version == BGPSTREAM_ADDR_VERSION_IPV4)
+    return bgpstream_ipv4_addr_equal(&addr1->bs_ipv4, &addr2->bs_ipv4);
+  else if (addr1->version == BGPSTREAM_ADDR_VERSION_IPV6)
+    return bgpstream_ipv6_addr_equal(&addr1->bs_ipv6, &addr2->bs_ipv6);
+  else
+    return 0;
 }
 
 int bgpstream_ipv4_addr_equal(const bgpstream_ipv4_addr_t *addr1,
                               const bgpstream_ipv4_addr_t *addr2)
 {
-  return addr1->ipv4.s_addr == addr2->ipv4.s_addr;
+  return addr1->addr.s_addr == addr2->addr.s_addr;
 }
 
 int bgpstream_ipv6_addr_equal(const bgpstream_ipv6_addr_t *addr1,
                               const bgpstream_ipv6_addr_t *addr2)
 {
-  return memcmp(&(addr1->ipv6.s6_addr[0]), &(addr2->ipv6.s6_addr[0]), 16) == 0;
+  return memcmp(&(addr1->addr.s6_addr[0]), &(addr2->addr.s6_addr[0]), 16) == 0;
 }
 
 bgpstream_ip_addr_t *bgpstream_addr_mask(bgpstream_ip_addr_t *addr,
                                          uint8_t mask_len)
 {
   if (addr->version == BGPSTREAM_ADDR_VERSION_IPV4) {
     return (bgpstream_ip_addr_t *)bgpstream_ipv4_addr_mask(
-      (bgpstream_ipv4_addr_t *)addr, mask_len);
+      &addr->bs_ipv4, mask_len);
   }
   if (addr->version == BGPSTREAM_ADDR_VERSION_IPV6) {
     return (bgpstream_ip_addr_t *)bgpstream_ipv6_addr_mask(
-      (bgpstream_ipv6_addr_t *)addr, mask_len);
+      &addr->bs_ipv6, mask_len);
   }
   return NULL;
 }
@@ -136,7 +123,7 @@ bgpstream_ipv4_addr_t *bgpstream_ipv4_addr_mask(bgpstream_ipv4_addr_t *addr,
     mask_len = 32;
   }
 
-  addr->ipv4.s_addr &= htonl(~(((uint64_t)1 << (32 - mask_len)) - 1));
+  addr->addr.s_addr &= htonl(~(((uint64_t)1 << (32 - mask_len)) - 1));
   return addr;
 }
 
@@ -151,14 +138,14 @@ bgpstream_ipv6_addr_t *bgpstream_ipv6_addr_mask(bgpstream_ipv6_addr_t *addr,
 
   if (mask_len <= 64) {
     /* mask the bottom 64bits and zero the top 64bits */
-    ptr = (uint64_t *)&(addr->ipv6.s6_addr[8]);
+    ptr = (uint64_t *)&(addr->addr.s6_addr[8]);
     *ptr = 0;
-    ptr = (uint64_t *)&(addr->ipv6.s6_addr[0]);
+    ptr = (uint64_t *)&(addr->addr.s6_addr[0]);
     *ptr &= htonll((uint64_t)(~0) << (64 - mask_len));
   } else {
     /* mask the top 64 bits */
     mask_len -= 64;
-    ptr = (uint64_t *)&(addr->ipv6.s6_addr[8]);
+    ptr = (uint64_t *)&(addr->addr.s6_addr[8]);
     *ptr &= htonll((uint64_t)(~0) << (64 - mask_len - 64));
   }
 
@@ -170,38 +157,29 @@ void bgpstream_addr_copy(bgpstream_ip_addr_t *dst,
 {
   if (src->version == BGPSTREAM_ADDR_VERSION_IPV4) {
     memcpy(dst, src, sizeof(bgpstream_ipv4_addr_t));
-  }
-  if (src->version == BGPSTREAM_ADDR_VERSION_IPV6) {
+  } else if (src->version == BGPSTREAM_ADDR_VERSION_IPV6) {
     memcpy(dst, src, sizeof(bgpstream_ipv6_addr_t));
   }
 }
 
-bgpstream_addr_storage_t *bgpstream_str2addr(const char *addr_str,
-                                             bgpstream_addr_storage_t *addr)
+bgpstream_ip_addr_t *bgpstream_str2addr(const char *addr_str,
+                                        bgpstream_ip_addr_t *addr)
 {
   if (addr_str == NULL || addr == NULL) {
     return NULL;
   }
 
-  if (strchr(addr_str, ':') != NULL) {
-    /* this looks like it will be an IPv6 address */
-    if (inet_pton(AF_INET6, addr_str, &addr->ipv6) != 1) {
-      bgpstream_log(BGPSTREAM_LOG_ERR, "Could not parse address string %s",
-                    addr_str);
-      return NULL;
-    }
+  if (inet_pton(AF_INET, addr_str, &addr->bs_ipv4.addr) == 1) {
+    addr->version = BGPSTREAM_ADDR_VERSION_IPV4;
+    return addr;
+  } else if (inet_pton(AF_INET6, addr_str, &addr->bs_ipv6.addr) == 1) {
     addr->version = BGPSTREAM_ADDR_VERSION_IPV6;
+    return addr;
   } else {
-    /* probably a v4 address */
-    if (inet_pton(AF_INET, addr_str, &addr->ipv4) != 1) {
-      bgpstream_log(BGPSTREAM_LOG_ERR, "Could not parse address string %s",
-                    addr_str);
-      return NULL;
-    }
-    addr->version = BGPSTREAM_ADDR_VERSION_IPV4;
+    bgpstream_log(BGPSTREAM_LOG_ERR, "Could not parse address string %s",
+                  addr_str);
+    return NULL;
   }
-
-  return addr;
 }
 
 uint8_t bgpstream_ipv2idx(bgpstream_addr_version_t v)