r15106@tombo: nickm | 2007-12-04 00:08:35 -0500

 Change tor_addr_t to be a tagged union of in_addr and in6_addr, not of sockaddr_in and sockaddr_in6.  It's hardly used in the main code as it is, but let's get it right before it gets popular.


svn:r12660

ChangeLog

@@ -38,6 +38,9 @@ Changes in version 0.2.0.13-alpha - 2007-12-??
     - Authorities and caches fetch the v2 networkstatus documents
       less often, now that v3 is encouraged.
 
+  o Code simplifications:
+    - 
+
 
 Changes in version 0.2.0.12-alpha - 2007-11-16
   This twelfth development snapshot fixes some more build problems as

src/common/compat.c

@@ -1093,12 +1093,12 @@ tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr)
     return -1;
   } else if (tor_inet_pton(AF_INET, name, &iaddr)) {
     /* It's an IPv4 IP. */
-    addr->sa.sin_family = AF_INET;
-    memcpy(&addr->sa.sin_addr, &iaddr, sizeof(struct in_addr));
+    addr->family = AF_INET;
+    memcpy(&addr->addr.in_addr, &iaddr, sizeof(struct in_addr));
     return 0;
   } else if (tor_inet_pton(AF_INET6, name, &iaddr6)) {
-    addr->sa6.sin6_family = AF_INET6;
-    memcpy(&addr->sa6.sin6_addr, &iaddr6, sizeof(struct in6_addr));
+    addr->family = AF_INET6;
+    memcpy(&addr->addr.in6_addr, &iaddr6, sizeof(struct in6_addr));
     return 0;
   } else {
 #ifdef HAVE_GETADDRINFO
@@ -1129,14 +1129,14 @@ tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr)
       if (!best)
         best = res;
       if (best->ai_family == AF_INET) {
-        addr->sa.sin_family = AF_INET;
-        memcpy(&addr->sa.sin_addr,
+        addr->family = AF_INET;
+        memcpy(&addr->addr.in_addr,
                &((struct sockaddr_in*)best->ai_addr)->sin_addr,
                sizeof(struct in_addr));
         result = 0;
       } else if (best->ai_family == AF_INET6) {
-        addr->sa6.sin6_family = AF_INET6;
-        memcpy(&addr->sa6.sin6_addr,
+        addr->family = AF_INET6;
+        memcpy(&addr->addr.in6_addr,
                &((struct sockaddr_in6*)best->ai_addr)->sin6_addr,
                sizeof(struct in6_addr));
         result = 0;
@@ -1172,11 +1172,11 @@ tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr)
 #endif
 #endif /* endif HAVE_GETHOSTBYNAME_R_6_ARG. */
     if (ent) {
-      addr->sa.sin_family = ent->h_addrtype;
+      addr->family = ent->h_addrtype;
       if (ent->h_addrtype == AF_INET) {
-        memcpy(&addr->sa.sin_addr, ent->h_addr, sizeof(struct in_addr));
+        memcpy(&addr->addr.in_addr, ent->h_addr, sizeof(struct in_addr));
       } else if (ent->h_addrtype == AF_INET6) {
-        memcpy(&addr->sa6.sin6_addr, ent->h_addr, sizeof(struct in6_addr));
+        memcpy(&addr->addr.in6_addr, ent->h_addr, sizeof(struct in6_addr));
       } else {
         tor_assert(0); /* gethostbyname() returned a bizarre addrtype */
       }

src/common/compat.h

@@ -325,12 +325,13 @@ struct sockaddr_in6 {
 
 typedef uint8_t maskbits_t;
 struct in_addr;
-typedef union tor_addr_t
+typedef struct tor_addr_t
 {
-  /* XXXX020 There are extra fields in sockaddr_in and sockaddr_in6 that
-   * make this union waste space.  Do we care? */
-  struct sockaddr_in sa;
-  struct sockaddr_in6 sa6;
+  sa_family_t family;
+  union {
+    struct in_addr in_addr;
+    struct in6_addr in6_addr;
+  } addr;
 } tor_addr_t;
 
 /* XXXX020 rename these. */
@@ -340,12 +341,11 @@ static INLINE uint32_t IPV4MAPh(const tor_addr_t *a);
 static INLINE uint16_t IN_FAMILY(const tor_addr_t *a);
 static INLINE const struct in_addr *IN4_ADDRESS(const tor_addr_t *a);
 static INLINE const struct in6_addr *IN6_ADDRESS(const tor_addr_t *a);
-static INLINE uint16_t IN_PORT(const tor_addr_t *a);
 
 static INLINE const struct in6_addr *
 IN6_ADDRESS(const tor_addr_t *a)
 {
-  return &a->sa6.sin6_addr;
+  return &a->addr.in6_addr;
 }
 
 #define IN6_ADDRESS16(x) S6_ADDR16(*IN6_ADDRESS(x))
@@ -354,7 +354,7 @@ IN6_ADDRESS(const tor_addr_t *a)
 static INLINE uint32_t
 IPV4IP(const tor_addr_t *a)
 {
-  return a->sa.sin_addr.s_addr;
+  return a->addr.in_addr.s_addr;
 }
 static INLINE uint32_t IPV4IPh(const tor_addr_t *a)
 {
@@ -369,20 +369,12 @@ IPV4MAPh(const tor_addr_t *a)
 static INLINE uint16_t
 IN_FAMILY(const tor_addr_t *a)
 {
-  return a->sa.sin_family;
+  return a->family;
 }
 static INLINE const struct in_addr *
 IN4_ADDRESS(const tor_addr_t *a)
 {
-  return &a->sa.sin_addr;
-}
-static INLINE uint16_t
-IN_PORT(const tor_addr_t *a)
-{
-  if (IN_FAMILY(a) == AF_INET)
-    return a->sa.sin_port;
-  else
-    return a->sa6.sin6_port;
+  return &a->addr.in_addr;
 }
 
 #define INET_NTOA_BUF_LEN 16 /* 255.255.255.255 */

src/common/util.c

@@ -2108,8 +2108,8 @@ int
 is_internal_IP(uint32_t ip, int for_listening)
 {
   tor_addr_t myaddr;
-  myaddr.sa.sin_family = AF_INET;
-  myaddr.sa.sin_addr.s_addr = htonl(ip);
+  myaddr.family = AF_INET;
+  myaddr.addr.in_addr.s_addr = htonl(ip);
 
   return tor_addr_is_internal(&myaddr, for_listening);
 }
@@ -2519,12 +2519,12 @@ tor_addr_parse_mask_ports(const char *s, tor_addr_t *addr_out,
   memset(addr_out, 0, sizeof(tor_addr_t));
 
   if (!strcmp(address, "*")) {
-    addr_out->sa.sin_family = AF_INET; /* AF_UNSPEC ???? XXXXX020 */
+    addr_out->family = AF_INET; /* AF_UNSPEC ???? XXXXX020 */
     any_flag = 1;
-  } else if (tor_inet_pton(AF_INET6, address, &addr_out->sa6.sin6_addr) > 0) {
-    addr_out->sa6.sin6_family = AF_INET6;
-  } else if (tor_inet_pton(AF_INET, address, &addr_out->sa.sin_addr) > 0) {
-    addr_out->sa.sin_family = AF_INET;
+  } else if (tor_inet_pton(AF_INET6, address, &addr_out->addr.in6_addr) > 0) {
+    addr_out->family = AF_INET6;
+  } else if (tor_inet_pton(AF_INET, address, &addr_out->addr.in_addr) > 0) {
+    addr_out->family = AF_INET;
   } else {
     log_warn(LD_GENERAL, "Malformed IP %s in address pattern; rejecting.",
              escaped(address));
@@ -2708,8 +2708,8 @@ tor_addr_from_ipv4(tor_addr_t *dest, uint32_t v4addr)
 {
   tor_assert(dest);
   memset(dest, 0, sizeof(dest));
-  dest->sa.sin_family = AF_INET;
-  dest->sa.sin_addr.s_addr = htonl(v4addr);
+  dest->family = AF_INET;
+  dest->addr.in_addr.s_addr = htonl(v4addr);
 }
 
 /** Copy a tor_addr_t from <b>src</b> to <b>dest</b>.

src/or/test.c

@@ -1074,38 +1074,38 @@ _test_eq_ip6(struct in6_addr *a, struct in6_addr *b, const char *e1,
 /*XXXX020 make this macro give useful output on failure, and follow the
  * conventions of the other test macros.  */
 #define test_internal_ip(a,b) STMT_BEGIN             \
-    r = tor_inet_pton(AF_INET6, a, &t1.sa6.sin6_addr); \
+    r = tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr); \
     test_assert(r==1);                               \
-    t1.sa6.sin6_family = AF_INET6;                   \
+    t1.family = AF_INET6;                            \
     r = tor_addr_is_internal(&t1, b);                \
     test_assert(r==1);                               \
   STMT_END
 
 /*XXXX020 make this macro give useful output on failure, and follow the
  * conventions of the other test macros.  */
-#define test_external_ip(a,b) STMT_BEGIN             \
-    r = tor_inet_pton(AF_INET6, a, &t1.sa6.sin6_addr); \
-    test_assert(r==1);                               \
-    t1.sa6.sin6_family = AF_INET6;                   \
-    r = tor_addr_is_internal(&t1, b);                \
-    test_assert(r==0);                               \
+#define test_external_ip(a,b) STMT_BEGIN               \
+    r = tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr); \
+    test_assert(r==1);                                 \
+    t1.family = AF_INET6;                              \
+    r = tor_addr_is_internal(&t1, b);                  \
+    test_assert(r==0);                                 \
   STMT_END
 
 /*XXXX020 make this macro give useful output on failure, and follow the
  * conventions of the other test macros.  */
 #define test_addr_convert6(a,b) STMT_BEGIN           \
-    tor_inet_pton(AF_INET6, a, &t1.sa6.sin6_addr);   \
-    tor_inet_pton(AF_INET6, b, &t2.sa6.sin6_addr);   \
-    t1.sa6.sin6_family = AF_INET6;                   \
-    t2.sa6.sin6_family = AF_INET6;                   \
+    tor_inet_pton(AF_INET6, a, &t1.addr.in6_addr);   \
+    tor_inet_pton(AF_INET6, b, &t2.addr.in6_addr);   \
+    t1.family = AF_INET6;                            \
+    t2.family = AF_INET6;                            \
   STMT_END
 
 /*XXXX020 make this macro give useful output on failure, and follow the
  * conventions of the other test macros. */
 #define test_addr_parse(xx) STMT_BEGIN                                \
     r=tor_addr_parse_mask_ports(xx, &t1, &mask, &port1, &port2);      \
-    t2.sa6.sin6_family = AF_INET6;                                    \
-    p1=tor_inet_ntop(AF_INET6, &t1.sa6.sin6_addr, bug, sizeof(bug));  \
+    t2.family = AF_INET6;                                             \
+    p1=tor_inet_ntop(AF_INET6, &t1.addr.in6_addr, bug, sizeof(bug));  \
   STMT_END
 
 /*XXXX020 make this macro give useful output on failure, and follow the
@@ -1309,7 +1309,7 @@ test_util_ip6_helpers(void)
   test_assert(TOR_ADDR_BUF_LEN >=
               sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"));
 
-  test_assert(sizeof(tor_addr_t) >= sizeof(struct sockaddr_in6));
+  test_assert(sizeof(tor_addr_t) >= sizeof(struct in6_addr));
 
   /* get interface addresses */
   r = get_interface_address6(0, AF_INET, &t1);