src/common/address.c

   1 /* Copyright (c) 2003-2004, Roger Dingledine
   2  * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
   3  * Copyright (c) 2007-2008, The Tor Project, Inc. */
   4 /* See LICENSE for licensing information */
   5 /* $Id$ */
   6 const char address_c_id[] =
   7   "$Id$";
   8
   9 /**
  10  * \file address.c
  11  * \brief DOCDOC
  12  **/
  13
  14 /* This is required on rh7 to make strptime not complain.
  15  * We also need it to make memmem get defined (where available)
  16  */
  17 #define _GNU_SOURCE
  18
  19 #include "orconfig.h"
  20 #include "compat.h"
  21 #include "util.h"
  22 #include "address.h"
  23 #include "log.h"
  24
  25 #ifdef MS_WINDOWS
  26 #include <process.h>
  27 #include <windows.h>
  28 #endif
  29
  30 #ifdef HAVE_UNAME
  31 #include <sys/utsname.h>
  32 #endif
  33 #ifdef HAVE_SYS_TIME_H
  34 #include <sys/time.h>
  35 #endif
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39 #ifdef HAVE_SYS_FCNTL_H
  40 #include <sys/fcntl.h>
  41 #endif
  42 #ifdef HAVE_PWD_H
  43 #include <pwd.h>
  44 #endif
  45 #ifdef HAVE_GRP_H
  46 #include <grp.h>
  47 #endif
  48 #ifdef HAVE_FCNTL_H
  49 #include <fcntl.h>
  50 #endif
  51 #ifdef HAVE_SYS_RESOURCE_H
  52 #include <sys/resource.h>
  53 #endif
  54 #ifdef HAVE_ERRNO_H
  55 #include <errno.h>
  56 #endif
  57 #ifdef HAVE_NETINET_IN_H
  58 #include <netinet/in.h>
  59 #endif
  60 #ifdef HAVE_ARPA_INET_H
  61 #include <arpa/inet.h>
  62 #endif
  63 #ifndef HAVE_GETTIMEOFDAY
  64 #ifdef HAVE_FTIME
  65 #include <sys/timeb.h>
  66 #endif
  67 #endif
  68 #ifdef HAVE_SYS_SOCKET_H
  69 #include <sys/socket.h>
  70 #endif
  71 #ifdef HAVE_NETDB_H
  72 #include <netdb.h>
  73 #endif
  74 #ifdef HAVE_SYS_PARAM_H
  75 #include <sys/param.h> /* FreeBSD needs this to know what version it is */
  76 #endif
  77 #include <stdarg.h>
  78 #include <stdio.h>
  79 #include <stdlib.h>
  80 #include <string.h>
  81 #include <assert.h>
  82 #ifdef HAVE_PTHREAD_H
  83 #include <pthread.h>
  84 #endif
  85 #ifdef HAVE_SIGNAL_H
  86 #include <signal.h>
  87 #endif
  88 #ifdef HAVE_UTIME_H
  89 #include <utime.h>
  90 #endif
  91 #ifdef HAVE_SYS_UTIME_H
  92 #include <sys/utime.h>
  93 #endif
  94 #ifdef HAVE_SYS_MMAN_H
  95 #include <sys/mman.h>
  96 #endif
  97 #ifdef HAVE_SYS_SYSLIMITS_H
  98 #include <sys/syslimits.h>
  99 #endif
 100
 101 /** Convert the tor_addr_t in <b>a</b>, with port in <b>port</b>, into a
 102  * socklen object in *<b>sa_out</b> of object size <b>len</b>.  If not enough
 103  * room is free, or on error, return -1.  Else return the length of the
 104  * sockaddr. */
 105 socklen_t
 106 tor_addr_to_sockaddr(const tor_addr_t *a,
 107                      uint16_t port,
 108                      struct sockaddr *sa_out,
 109                      socklen_t len)
 110 {
 111   if (a->family == AF_INET) {
 112     struct sockaddr_in *sin;
 113     if (len < sizeof(struct sockaddr_in))
 114       return -1;
 115     sin = (struct sockaddr_in *)sa_out;
 116     sin->sin_family = AF_INET;
 117     sin->sin_port = port;
 118     sin->sin_addr.s_addr = a->addr.in_addr.s_addr;
 119     return sizeof(struct sockaddr_in);
 120   } else if (a->family == AF_INET6) {
 121     struct sockaddr_in6 *sin6;
 122     if (len < sizeof(struct sockaddr_in6))
 123       return -1;
 124     sin6 = (struct sockaddr_in6 *)sa_out;
 125     memset(sin6, 0, sizeof(struct sockaddr_in6));
 126     sin6->sin6_family = AF_INET6;
 127     sin6->sin6_port = port;
 128     memcpy(&sin6->sin6_addr, &a->addr.in6_addr, sizeof(struct in6_addr));
 129     return sizeof(struct sockaddr_in6);
 130   } else {
 131     return -1;
 132   }
 133 }
 134
 135 /** Set the tor_addr_t in <b>a</b> to contain the socket address contained in
 136  * <b>sa</b>. */
 137 void
 138 tor_addr_from_sockaddr(tor_addr_t *a, const struct sockaddr *sa)
 139 {
 140   tor_assert(a);
 141   tor_assert(sa);
 142   memset(a, 0, sizeof(tor_addr_t));
 143   if (sa->sa_family == AF_INET) {
 144     struct sockaddr_in *sin = (struct sockaddr_in *) sa;
 145     a->family = AF_INET;
 146     a->addr.in_addr.s_addr = sin->sin_addr.s_addr;
 147   } else if (sa->sa_family == AF_INET6) {
 148     struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
 149     a->family = AF_INET6;
 150     memcpy(&a->addr.in6_addr, &sin6->sin6_addr, sizeof(struct in6_addr));
 151   } else {
 152     a->family = AF_UNSPEC;
 153   }
 154 }
 155
 156 /** Similar behavior to Unix gethostbyname: resolve <b>name</b>, and set
 157  * *<b>addr</b> to the proper IP address and family. The <b>family</b>
 158  * argument (which must be AF_INET, AF_INET6, or AF_UNSPEC) declares a
 159  * <i>preferred</i> family, though another one may be returned if only one
 160  * family is implemented for this address.
 161  *
 162  * Return 0 on success, -1 on failure; 1 on transient failure.
 163  */
 164 int
 165 tor_addr_lookup(const char *name, uint16_t family, tor_addr_t *addr)
 166 {
 167   /* Perhaps eventually this should be replaced by a tor_getaddrinfo or
 168    * something.
 169    */
 170   struct in_addr iaddr;
 171   struct in6_addr iaddr6;
 172   tor_assert(name);
 173   tor_assert(addr);
 174   tor_assert(family == AF_INET || family == AF_INET6 || family == AF_UNSPEC);
 175   memset(addr, 0, sizeof(addr)); /* Clear the extraneous fields. */
 176   if (!*name) {
 177     /* Empty address is an error. */
 178     return -1;
 179   } else if (tor_inet_pton(AF_INET, name, &iaddr)) {
 180     /* It's an IPv4 IP. */
 181     addr->family = AF_INET;
 182     memcpy(&addr->addr.in_addr, &iaddr, sizeof(struct in_addr));
 183     return 0;
 184   } else if (tor_inet_pton(AF_INET6, name, &iaddr6)) {
 185     addr->family = AF_INET6;
 186     memcpy(&addr->addr.in6_addr, &iaddr6, sizeof(struct in6_addr));
 187     return 0;
 188   } else {
 189 #ifdef HAVE_GETADDRINFO
 190     int err;
 191     struct addrinfo *res=NULL, *res_p;
 192     struct addrinfo *best=NULL;
 193     struct addrinfo hints;
 194     int result = -1;
 195     memset(&hints, 0, sizeof(hints));
 196     hints.ai_family = family;
 197     hints.ai_socktype = SOCK_STREAM;
 198     err = getaddrinfo(name, NULL, &hints, &res);
 199     if (!err) {
 200       best = NULL;
 201       for (res_p = res; res_p; res_p = res_p->ai_next) {
 202         if (family == AF_UNSPEC) {
 203           if (res_p->ai_family == AF_INET) {
 204             best = res_p;
 205             break;
 206           } else if (res_p->ai_family == AF_INET6 && !best) {
 207             best = res_p;
 208           }
 209         } else if (family == res_p->ai_family) {
 210           best = res_p;
 211           break;
 212         }
 213       }
 214       if (!best)
 215         best = res;
 216       if (best->ai_family == AF_INET) {
 217         addr->family = AF_INET;
 218         memcpy(&addr->addr.in_addr,
 219                &((struct sockaddr_in*)best->ai_addr)->sin_addr,
 220                sizeof(struct in_addr));
 221         result = 0;
 222       } else if (best->ai_family == AF_INET6) {
 223         addr->family = AF_INET6;
 224         memcpy(&addr->addr.in6_addr,
 225                &((struct sockaddr_in6*)best->ai_addr)->sin6_addr,
 226                sizeof(struct in6_addr));
 227         result = 0;
 228       }
 229       freeaddrinfo(res);
 230       return result;
 231     }
 232     return (err == EAI_AGAIN) ? 1 : -1;
 233 #else
 234     struct hostent *ent;
 235     int err;
 236 #ifdef HAVE_GETHOSTBYNAME_R_6_ARG
 237     char buf[2048];
 238     struct hostent hostent;
 239     int r;
 240     r = gethostbyname_r(name, &hostent, buf, sizeof(buf), &ent, &err);
 241 #elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
 242     char buf[2048];
 243     struct hostent hostent;
 244     ent = gethostbyname_r(name, &hostent, buf, sizeof(buf), &err);
 245 #elif defined(HAVE_GETHOSTBYNAME_R_3_ARG)
 246     struct hostent_data data;
 247     struct hostent hent;
 248     memset(&data, 0, sizeof(data));
 249     err = gethostbyname_r(name, &hent, &data);
 250     ent = err ? NULL : &hent;
 251 #else
 252     ent = gethostbyname(name);
 253 #ifdef MS_WINDOWS
 254     err = WSAGetLastError();
 255 #else
 256     err = h_errno;
 257 #endif
 258 #endif /* endif HAVE_GETHOSTBYNAME_R_6_ARG. */
 259     if (ent) {
 260       addr->family = ent->h_addrtype;
 261       if (ent->h_addrtype == AF_INET) {
 262         memcpy(&addr->addr.in_addr, ent->h_addr, sizeof(struct in_addr));
 263       } else if (ent->h_addrtype == AF_INET6) {
 264         memcpy(&addr->addr.in6_addr, ent->h_addr, sizeof(struct in6_addr));
 265       } else {
 266         tor_assert(0); /* gethostbyname() returned a bizarre addrtype */
 267       }
 268       return 0;
 269     }
 270 #ifdef MS_WINDOWS
 271     return (err == WSATRY_AGAIN) ? 1 : -1;
 272 #else
 273     return (err == TRY_AGAIN) ? 1 : -1;
 274 #endif
 275 #endif
 276   }
 277 }
 278
 279 /** Return true iff <b>ip</b> is an IP reserved to localhost or local networks
 280  * in RFC1918 or RFC4193 or RFC4291. (fec0::/10, deprecated by RFC3879, is
 281  * also treated as internal for now.)
 282  */
 283 int
 284 tor_addr_is_internal(const tor_addr_t *addr, int for_listening)
 285 {
 286   uint32_t iph4 = 0;
 287   uint32_t iph6[4];
 288   sa_family_t v_family;
 289   v_family = tor_addr_family(addr);
 290
 291   if (v_family == AF_INET) {
 292     iph4 = tor_addr_to_ipv4h(addr);
 293   } else if (v_family == AF_INET6) {
 294     if (tor_addr_is_v4(addr)) { /* v4-mapped */
 295       v_family = AF_INET;
 296       iph4 = ntohl(tor_addr_to_in6_addr32(addr)[3]);
 297     }
 298   }
 299
 300   if (v_family == AF_INET6) {
 301     const uint32_t *a32 = tor_addr_to_in6_addr32(addr);
 302     iph6[0] = ntohl(a32[0]);
 303     iph6[1] = ntohl(a32[1]);
 304     iph6[2] = ntohl(a32[2]);
 305     iph6[3] = ntohl(a32[3]);
 306     if (for_listening && !iph6[0] && !iph6[1] && !iph6[2] && !iph6[3]) /* :: */
 307       return 0;
 308
 309     if (((iph6[0] & 0xfe000000) == 0xfc000000) || /* fc00/7  - RFC4193 */
 310         ((iph6[0] & 0xffc00000) == 0xfe800000) || /* fe80/10 - RFC4291 */
 311         ((iph6[0] & 0xffc00000) == 0xfec00000))   /* fec0/10 D- RFC3879 */
 312       return 1;
 313
 314     if (!iph6[0] && !iph6[1] && !iph6[2] &&
 315         ((iph6[3] & 0xfffffffe) == 0x00000000))  /* ::/127 */
 316       return 1;
 317
 318     return 0;
 319   } else if (v_family == AF_INET) {
 320     if (for_listening && !iph4) /* special case for binding to 0.0.0.0 */
 321       return 0;
 322     if (((iph4 & 0xff000000) == 0x0a000000) || /*       10/8 */
 323         ((iph4 & 0xff000000) == 0x00000000) || /*        0/8 */
 324         ((iph4 & 0xff000000) == 0x7f000000) || /*      127/8 */
 325         ((iph4 & 0xffff0000) == 0xa9fe0000) || /* 169.254/16 */
 326         ((iph4 & 0xfff00000) == 0xac100000) || /*  172.16/12 */
 327         ((iph4 & 0xffff0000) == 0xc0a80000))   /* 192.168/16 */
 328       return 1;
 329     return 0;
 330   }
 331
 332   /* unknown address family... assume it's not safe for external use */
 333   /* rather than tor_assert(0) */
 334   log_warn(LD_BUG, "tor_addr_is_internal() called with a non-IP address.");
 335   return 1;
 336 }
 337
 338 /** Convert a tor_addr_t <b>addr</b> into a string, and store it in
 339  *  <b>dest</b> of size <b>len</b>.  Returns a pointer to dest on success,
 340  *  or NULL on failure.  If <b>decorate</b>, surround IPv6 addresses with
 341  *  brackets.
 342  */
 343 const char *
 344 tor_addr_to_str(char *dest, const tor_addr_t *addr, int len, int decorate)
 345 {
 346   const char *ptr;
 347   tor_assert(addr && dest);
 348
 349   switch (tor_addr_family(addr)) {
 350     case AF_INET:
 351       if (len<3)
 352         return NULL;
 353         ptr = tor_inet_ntop(AF_INET, &addr->addr.in_addr, dest, len);
 354       break;
 355     case AF_INET6:
 356       if (decorate)
 357         ptr = tor_inet_ntop(AF_INET6, &addr->addr.in6_addr, dest+1, len-2);
 358       else
 359         ptr = tor_inet_ntop(AF_INET6, &addr->addr.in6_addr, dest, len);
 360       if (ptr && decorate) {
 361         *dest = '[';
 362         memcpy(dest+strlen(dest), "]", 2);
 363         tor_assert(ptr == dest+1);
 364         ptr = dest;
 365       }
 366       break;
 367     default:
 368       return NULL;
 369   }
 370   return ptr;
 371 }
 372
 373 /** Parse a string <b>s</b> containing an IPv4/IPv6 address, and possibly
 374  *  a mask and port or port range.  Store the parsed address in
 375  *  <b>addr_out</b>, a mask (if any) in <b>mask_out</b>, and port(s) (if any)
 376  *  in <b>port_min_out</b> and <b>port_max_out</b>.
 377  *
 378  * The syntax is:
 379  *   Address OptMask OptPortRange
 380  *   Address ::= IPv4Address / "[" IPv6Address "]" / "*"
 381  *   OptMask ::= "/" Integer /
 382  *   OptPortRange ::= ":*" / ":" Integer / ":" Integer "-" Integer /
 383  *
 384  *  - If mask, minport, or maxport are NULL, we do not want these
 385  *    options to be set; treat them as an error if present.
 386  *  - If the string has no mask, the mask is set to /32 (IPv4) or /128 (IPv6).
 387  *  - If the string has one port, it is placed in both min and max port
 388  *    variables.
 389  *  - If the string has no port(s), port_(min|max)_out are set to 1 and 65535.
 390  *
 391  *  Return an address family on success, or -1 if an invalid address string is
 392  *  provided.
 393  */
 394 int
 395 tor_addr_parse_mask_ports(const char *s, tor_addr_t *addr_out,
 396                           maskbits_t *maskbits_out,
 397                           uint16_t *port_min_out, uint16_t *port_max_out)
 398 {
 399   char *base = NULL, *address, *mask = NULL, *port = NULL, *rbracket = NULL;
 400   char *endptr;
 401   int any_flag=0, v4map=0;
 402
 403   tor_assert(s);
 404   tor_assert(addr_out);
 405
 406   /* IP, [], /mask, ports */
 407 #define MAX_ADDRESS_LENGTH (TOR_ADDR_BUF_LEN+2+(1+INET_NTOA_BUF_LEN)+12+1)
 408
 409   if (strlen(s) > MAX_ADDRESS_LENGTH) {
 410     log_warn(LD_GENERAL, "Impossibly long IP %s; rejecting", escaped(s));
 411     goto err;
 412   }
 413   base = tor_strdup(s);
 414
 415   /* Break 'base' into separate strings. */
 416   address = base;
 417   if (*address == '[') {  /* Probably IPv6 */
 418     address++;
 419     rbracket = strchr(address, ']');
 420     if (!rbracket) {
 421       log_warn(LD_GENERAL,
 422                "No closing IPv6 bracket in address pattern; rejecting.");
 423       goto err;
 424     }
 425   }
 426   mask = strchr((rbracket?rbracket:address),'/');
 427   port = strchr((mask?mask:(rbracket?rbracket:address)), ':');
 428   if (port)
 429     *port++ = '\0';
 430   if (mask)
 431     *mask++ = '\0';
 432   if (rbracket)
 433     *rbracket = '\0';
 434   if (port && mask)
 435     tor_assert(port > mask);
 436   if (mask && rbracket)
 437     tor_assert(mask > rbracket);
 438
 439   /* Now "address" is the a.b.c.d|'*'|abcd::1 part...
 440    *     "mask" is the Mask|Maskbits part...
 441    * and "port" is the *|port|min-max part.
 442    */
 443
 444   /* Process the address portion */
 445   memset(addr_out, 0, sizeof(tor_addr_t));
 446
 447   if (!strcmp(address, "*")) {
 448     addr_out->family = AF_INET; /* AF_UNSPEC ???? XXXX_IP6 */
 449     any_flag = 1;
 450   } else if (tor_inet_pton(AF_INET6, address, &addr_out->addr.in6_addr) > 0) {
 451     addr_out->family = AF_INET6;
 452   } else if (tor_inet_pton(AF_INET, address, &addr_out->addr.in_addr) > 0) {
 453     addr_out->family = AF_INET;
 454   } else {
 455     log_warn(LD_GENERAL, "Malformed IP %s in address pattern; rejecting.",
 456              escaped(address));
 457     goto err;
 458   }
 459
 460   v4map = tor_addr_is_v4(addr_out);
 461
 462 /*
 463 #ifdef ALWAYS_V6_MAP
 464   if (v_family == AF_INET) {
 465     v_family = AF_INET6;
 466     IN_ADDR6(addr_out).s6_addr32[3] = IN6_ADDRESS(addr_out).s_addr;
 467     memset(&IN6_ADDRESS(addr_out), 0, 10);
 468     IN_ADDR6(addr_out).s6_addr16[5] = 0xffff;
 469   }
 470 #else
 471   if (v_family == AF_INET6 && v4map) {
 472     v_family = AF_INET;
 473     IN4_ADDRESS((addr_out).s_addr = IN6_ADDRESS(addr_out).s6_addr32[3];
 474   }
 475 #endif
 476 */
 477
 478   /* Parse mask */
 479   if (maskbits_out) {
 480     int bits = 0;
 481     struct in_addr v4mask;
 482
 483     if (mask) {  /* the caller (tried to) specify a mask */
 484       bits = (int) strtol(mask, &endptr, 10);
 485       if (!*endptr) {  /* strtol converted everything, so it was an integer */
 486         if ((bits<0 || bits>128) ||
 487             ((tor_addr_family(addr_out) == AF_INET) && bits > 32)) {
 488           log_warn(LD_GENERAL,
 489                    "Bad number of mask bits (%d) on address range; rejecting.",
 490                    bits);
 491           goto err;
 492         }
 493       } else {  /* mask might still be an address-style mask */
 494         if (tor_inet_pton(AF_INET, mask, &v4mask) > 0) {
 495           bits = addr_mask_get_bits(ntohl(v4mask.s_addr));
 496           if (bits < 0) {
 497             log_warn(LD_GENERAL,
 498                      "IPv4-style mask %s is not a prefix address; rejecting.",
 499                      escaped(mask));
 500             goto err;
 501           }
 502         } else { /* Not IPv4; we don't do address-style IPv6 masks. */
 503           log_warn(LD_GENERAL,
 504                    "Malformed mask on address range %s; rejecting.",
 505                    escaped(s));
 506           goto err;
 507         }
 508       }
 509       if (tor_addr_family(addr_out) == AF_INET6 && v4map) {
 510         if (bits > 32 && bits < 96) { /* Crazy */
 511           log_warn(LD_GENERAL,
 512                    "Bad mask bits %i for V4-mapped V6 address; rejecting.",
 513                    bits);
 514           goto err;
 515         }
 516         /* XXXX_IP6 is this really what we want? */
 517         bits = 96 + bits%32; /* map v4-mapped masks onto 96-128 bits */
 518       }
 519     } else { /* pick an appropriate mask, as none was given */
 520       if (any_flag)
 521         bits = 0;  /* This is okay whether it's V6 or V4 (FIX V4-mapped V6!) */
 522       else if (tor_addr_family(addr_out) == AF_INET)
 523         bits = 32;
 524       else if (tor_addr_family(addr_out) == AF_INET6)
 525         bits = 128;
 526     }
 527     *maskbits_out = (maskbits_t) bits;
 528   } else {
 529     if (mask) {
 530       log_warn(LD_GENERAL,
 531                "Unexpected mask in addrss %s; rejecting", escaped(s));
 532       goto err;
 533     }
 534   }
 535
 536   /* Parse port(s) */
 537   if (port_min_out) {
 538     uint16_t port2;
 539     if (!port_max_out) /* caller specified one port; fake the second one */
 540       port_max_out = &port2;
 541
 542     if (parse_port_range(port, port_min_out, port_max_out) < 0) {
 543       goto err;
 544     } else if ((*port_min_out != *port_max_out) && port_max_out == &port2) {
 545       log_warn(LD_GENERAL,
 546                "Wanted one port from address range, but there are two.");
 547
 548       port_max_out = NULL;  /* caller specified one port, so set this back */
 549       goto err;
 550     }
 551   } else {
 552     if (port) {
 553       log_warn(LD_GENERAL,
 554                "Unexpected ports in addrss %s; rejecting", escaped(s));
 555       goto err;
 556     }
 557   }
 558
 559   tor_free(base);
 560   return tor_addr_family(addr_out);
 561  err:
 562   tor_free(base);
 563   return -1;
 564 }
 565
 566 /** Determine whether an address is IPv4, either native or ipv4-mapped ipv6.
 567  * Note that this is about representation only, as any decent stack will
 568  * reject ipv4-mapped addresses received on the wire (and won't use them
 569  * on the wire either).
 570  */
 571 int
 572 tor_addr_is_v4(const tor_addr_t *addr)
 573 {
 574   tor_assert(addr);
 575
 576   if (tor_addr_family(addr) == AF_INET)
 577     return 1;
 578
 579   if (tor_addr_family(addr) == AF_INET6) {
 580     /* First two don't need to be ordered */
 581     uint32_t *a32 = tor_addr_to_in6_addr32(addr);
 582     if (a32[0] == 0 && a32[1] == 0 && ntohl(a32[2]) == 0x0000ffffu)
 583       return 1;
 584   }
 585
 586   return 0; /* Not IPv4 - unknown family or a full-blood IPv6 address */
 587 }
 588
 589 /** Determine whether an address <b>addr</b> is null, either all zeroes or
 590  *  belonging to family AF_UNSPEC.
 591  */
 592 int
 593 tor_addr_is_null(const tor_addr_t *addr)
 594 {
 595   tor_assert(addr);
 596
 597   switch (tor_addr_family(addr)) {
 598     case AF_INET6: {
 599       uint32_t *a32 = tor_addr_to_in6_addr32(addr);
 600       return (a32[0] == 0) && (a32[1] == 0) && (a32[2] == 0) && (a32[3] == 0);
 601     }
 602     case AF_INET:
 603       return (tor_addr_to_ipv4n(addr) == 0);
 604     case AF_UNSPEC:
 605       return 1;
 606     default:
 607       log_warn(LD_BUG, "Called with unknown address family %d",
 608                (int)tor_addr_family(addr));
 609       return 0;
 610   }
 611   //return 1;
 612 }
 613
 614 /** Return true iff <b>addr</b> is a loopback address */
 615 int
 616 tor_addr_is_loopback(const tor_addr_t *addr)
 617 {
 618   tor_assert(addr);
 619   switch (tor_addr_family(addr)) {
 620     case AF_INET6: {
 621       /* ::1 */
 622       uint32_t *a32 = tor_addr_to_in6_addr32(addr);
 623       return (a32[0] == 0) && (a32[1] == 0) && (a32[2] == 0) && (a32[3] == 1);
 624     }
 625     case AF_INET:
 626       /* 127.0.0.1 */
 627       return (tor_addr_to_ipv4h(addr) & 0xff000000) == 0x7f000000;
 628     case AF_UNSPEC:
 629       return 0;
 630     default:
 631       tor_fragile_assert();
 632       return 0;
 633   }
 634 }
 635
 636 /** Take a 32-bit host-order ipv4 address <b>v4addr</b> and store it in the
 637  *  tor_addr *<b>dest</b>.
 638  */
 639 /*  XXXX_IP6 Temporary, for use while 32-bit int addresses are still being
 640  *  passed around. */
 641 void
 642 tor_addr_from_ipv4h(tor_addr_t *dest, uint32_t v4addr)
 643 {
 644   tor_assert(dest);
 645   memset(dest, 0, sizeof(dest));
 646   dest->family = AF_INET;
 647   dest->addr.in_addr.s_addr = htonl(v4addr);
 648 }
 649
 650 /** Copy a tor_addr_t from <b>src</b> to <b>dest</b>.
 651  */
 652 void
 653 tor_addr_copy(tor_addr_t *dest, const tor_addr_t *src)
 654 {
 655   tor_assert(src && dest);
 656   memcpy(dest, src, sizeof(tor_addr_t));
 657 }
 658
 659 /** Given two addresses <b>addr1</b> and <b>addr2</b>, return 0 if the two
 660  * addresses are equivalent under the mask mbits, less than 0 if addr1
 661  * preceeds addr2, and greater than 0 otherwise.
 662  *
 663  * Different address families (IPv4 vs IPv6) are always considered unequal.
 664  *   NOT QUITE XXXX DOCDOC.
 665  */
 666 int
 667 tor_addr_compare(const tor_addr_t *addr1, const tor_addr_t *addr2,
 668                  tor_addr_comparison_t how)
 669 {
 670   return tor_addr_compare_masked(addr1, addr2, 128, how);
 671 }
 672
 673 /** As tor_addr_compare(), but only looks at the first <b>mask</b> bits of
 674  * the address.
 675  *
 676  * Reduce over-specific masks (>128 for ipv6, >32 for ipv4) to 128 or 32.
 677  */
 678 int
 679 tor_addr_compare_masked(const tor_addr_t *addr1, const tor_addr_t *addr2,
 680                         maskbits_t mbits, tor_addr_comparison_t how)
 681 {
 682   uint32_t ip4a=0, ip4b=0;
 683   sa_family_t v_family[2];
 684   int idx;
 685   uint32_t masked_a, masked_b;
 686
 687   tor_assert(addr1 && addr2);
 688
 689   if (how == CMP_EXACT) {
 690     int r = ((int)addr2->family) - ((int)addr1->family);
 691     if (r) return r;
 692     switch (addr1->family) {
 693       case AF_UNSPEC:
 694         return 0; /* All unspecified addresses are equal */
 695       case AF_INET: {
 696         uint32_t a1 = ntohl(addr1->addr.in_addr.s_addr);
 697         uint32_t a2 = ntohl(addr2->addr.in_addr.s_addr);
 698         a1 >>= (32-mbits);
 699         a2 >>= (32-mbits);
 700         return (a1 < a2) ? -1 : (a1 == a2) ? 0 : 1;
 701       }
 702       case AF_INET6: {
 703         uint8_t *a1 = addr1->addr.in6_addr.s6_addr;
 704         uint8_t *a2 = addr2->addr.in6_addr.s6_addr;
 705         const int bytes = mbits >> 3;
 706         const int leftover_bits = mbits & 7;
 707         if (bytes && (r = memcmp(a1, a2, bytes))) {
 708           return r;
 709         } else if (leftover_bits) {
 710           uint8_t b1 = a1[bytes] >> (8-leftover_bits);
 711           uint8_t b2 = a2[bytes] >> (8-leftover_bits);
 712           return (b1 < b2) ? -1 : (b1 == b2) ? 0 : 1;
 713         } else {
 714           return 0;
 715         }
 716       }
 717       default:
 718         tor_fragile_assert();
 719         return 0;
 720     }
 721   }
 722
 723   /* XXXX021 this code doesn't handle mask bits right it's using v4-mapped v6
 724    * addresses.  If I ask whether ::ffff:1.2.3.4 and ::ffff:1.2.7.8 are the
 725    * same in the first 16 bits, it will say "yes."  That's not so intuitive.
 726    *
 727    * XXXX021 Also, it's way too complicated.
 728    */
 729
 730   v_family[0] = tor_addr_family(addr1);
 731   v_family[1] = tor_addr_family(addr2);
 732
 733   /* All UNSPEC addresses are equal; they are unequal to all other addresses.*/
 734   if (v_family[0] == AF_UNSPEC) {
 735     if (v_family[1] == AF_UNSPEC)
 736       return 0;
 737     else
 738       return 1;
 739   } else {
 740     if (v_family[1] == AF_UNSPEC)
 741       return -1;
 742   }
 743
 744   if (v_family[0] == AF_INET) { /* If this is native IPv4, note the address */
 745     /* Later we risk overwriting a v4-mapped address */
 746     ip4a = tor_addr_to_ipv4h(addr1);
 747   } else if ((v_family[0] == AF_INET6) && tor_addr_is_v4(addr1)) {
 748     v_family[0] = AF_INET;
 749     ip4a = tor_addr_to_mapped_ipv4h(addr1);
 750   }
 751
 752   if (v_family[1] == AF_INET) { /* If this is native IPv4, note the address */
 753     /* Later we risk overwriting a v4-mapped address */
 754     ip4b = tor_addr_to_ipv4h(addr2);
 755   } else if ((v_family[1] == AF_INET6) && tor_addr_is_v4(addr2)) {
 756     v_family[1] = AF_INET;
 757     ip4b = tor_addr_to_mapped_ipv4h(addr2);
 758   }
 759
 760   if (v_family[0] > v_family[1]) /* Comparison of virtual families */
 761     return 1;
 762   else if (v_family[0] < v_family[1])
 763     return -1;
 764
 765   if (mbits == 0)  /* Under a complete wildcard mask, consider them equal */
 766     return 0;
 767
 768   if (v_family[0] == AF_INET) { /* Real or mapped IPv4 */
 769     if (mbits >= 32) {
 770       masked_a = ip4a;
 771       masked_b = ip4b;
 772     } else if (mbits == 0) {
 773       return 0;
 774     } else {
 775       masked_a = ip4a >> (32-mbits);
 776       masked_b = ip4b >> (32-mbits);
 777     }
 778     if (masked_a < masked_b)
 779       return -1;
 780     else if (masked_a > masked_b)
 781       return 1;
 782     return 0;
 783   } else if (v_family[0] == AF_INET6) { /* Real IPv6 */
 784     const uint32_t *a1 = tor_addr_to_in6_addr32(addr1);
 785     const uint32_t *a2 = tor_addr_to_in6_addr32(addr2);
 786     for (idx = 0; idx < 4; ++idx) {
 787       uint32_t masked_a = ntohl(a1[idx]);
 788       uint32_t masked_b = ntohl(a2[idx]);
 789       if (!mbits) {
 790         return 0; /* Mask covers both addresses from here on */
 791       } else if (mbits < 32) {
 792         masked_a >>= (32-mbits);
 793         masked_b >>= (32-mbits);
 794       }
 795
 796       if (masked_a > masked_b)
 797         return 1;
 798       else if (masked_a < masked_b)
 799         return -1;
 800
 801       if (mbits < 32)
 802         return 0;
 803       mbits -= 32;
 804     }
 805     return 0;
 806   }
 807
 808   tor_assert(0);  /* Unknown address family */
 809   return -1; /* unknown address family, return unequal? */
 810
 811 }
 812
 813 /** Return a hash code based on the address addr */
 814 unsigned int
 815 tor_addr_hash(const tor_addr_t *addr)
 816 {
 817   switch (tor_addr_family(addr)) {
 818   case AF_INET:
 819     return tor_addr_to_ipv4h(addr);
 820   case AF_UNSPEC:
 821     return 0x4e4d5342;
 822   case AF_INET6: {
 823     const uint32_t *u = tor_addr_to_in6_addr32(addr);
 824     return u[0] + u[1] + u[2] + u[3];
 825     }
 826   default:
 827     tor_fragile_assert();
 828     return 0;
 829   }
 830 }
 831
 832 /** Return a newly allocatd string with a representation of <b>addr</b>. */
 833 char *
 834 tor_dup_addr(const tor_addr_t *addr)
 835 {
 836   char buf[TOR_ADDR_BUF_LEN];
 837   tor_addr_to_str(buf, addr, sizeof(buf), 0);
 838   return tor_strdup(buf);
 839 }
 840
 841 /** Convert the string in <b>src</b> to a tor_addr_t <b>addr</b>.
 842  *
 843  *  Return an address family on success, or -1 if an invalid address string is
 844  *  provided. */
 845 int
 846 tor_addr_from_str(tor_addr_t *addr, const char *src)
 847 {
 848   tor_assert(addr && src);
 849   return tor_addr_parse_mask_ports(src, addr, NULL, NULL, NULL);
 850 }
 851
 852 /** Set *<b>addr</b> to the IP address (if any) of whatever interface
 853  * connects to the internet.  This address should only be used in checking
 854  * whether our address has changed.  Return 0 on success, -1 on failure.
 855  */
 856 int
 857 get_interface_address6(int severity, sa_family_t family, tor_addr_t *addr)
 858 {
 859   int sock=-1, r=-1;
 860   struct sockaddr_storage my_addr, target_addr;
 861   socklen_t my_addr_len;
 862
 863   tor_assert(addr);
 864
 865   memset(addr, 0, sizeof(tor_addr_t));
 866   memset(&target_addr, 0, sizeof(target_addr));
 867   my_addr_len = (socklen_t)sizeof(my_addr);
 868   /* Use the "discard" service port */
 869   ((struct sockaddr_in*)&target_addr)->sin_port = 9;
 870   /* Don't worry: no packets are sent. We just need to use a real address
 871    * on the actual internet. */
 872   if (family == AF_INET6) {
 873     struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&target_addr;
 874     sock = tor_open_socket(PF_INET6,SOCK_DGRAM,IPPROTO_UDP);
 875     my_addr_len = (socklen_t)sizeof(struct sockaddr_in6);
 876     sin6->sin6_family = AF_INET6;
 877     S6_ADDR16(sin6->sin6_addr)[0] = htons(0x2002); /* 2002:: */
 878   } else if (family == AF_INET) {
 879     struct sockaddr_in *sin = (struct sockaddr_in*)&target_addr;
 880     sock = tor_open_socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
 881     my_addr_len = (socklen_t)sizeof(struct sockaddr_in);
 882     sin->sin_family = AF_INET;
 883     sin->sin_addr.s_addr = htonl(0x12000001); /* 18.0.0.1 */
 884   } else {
 885     return -1;
 886   }
 887   if (sock < 0) {
 888     int e = tor_socket_errno(-1);
 889     log_fn(severity, LD_NET, "unable to create socket: %s",
 890            tor_socket_strerror(e));
 891     goto err;
 892   }
 893
 894   if (connect(sock,(struct sockaddr *)&target_addr,
 895               (socklen_t)sizeof(target_addr))<0) {
 896     int e = tor_socket_errno(sock);
 897     log_fn(severity, LD_NET, "connect() failed: %s", tor_socket_strerror(e));
 898     goto err;
 899   }
 900
 901   if (getsockname(sock,(struct sockaddr*)&my_addr, &my_addr_len)) {
 902     int e = tor_socket_errno(sock);
 903     log_fn(severity, LD_NET, "getsockname() to determine interface failed: %s",
 904            tor_socket_strerror(e));
 905     goto err;
 906   }
 907
 908   memcpy(addr, &my_addr, sizeof(tor_addr_t));
 909   r=0;
 910  err:
 911   if (sock >= 0)
 912     tor_close_socket(sock);
 913   return r;
 914 }
 915
 916 /* ======
 917  * IPv4 helpers
 918  * XXXX021 IPv6 deprecate some of these.
 919  */
 920
 921 /** Return true iff <b>ip</b> (in host order) is an IP reserved to localhost,
 922  * or reserved for local networks by RFC 1918.
 923  */
 924 int
 925 is_internal_IP(uint32_t ip, int for_listening)
 926 {
 927   tor_addr_t myaddr;
 928   myaddr.family = AF_INET;
 929   myaddr.addr.in_addr.s_addr = htonl(ip);
 930
 931   return tor_addr_is_internal(&myaddr, for_listening);
 932 }
 933
 934 /** Parse a string of the form "host[:port]" from <b>addrport</b>.  If
 935  * <b>address</b> is provided, set *<b>address</b> to a copy of the
 936  * host portion of the string.  If <b>addr</b> is provided, try to
 937  * resolve the host portion of the string and store it into
 938  * *<b>addr</b> (in host byte order).  If <b>port_out</b> is provided,
 939  * store the port number into *<b>port_out</b>, or 0 if no port is given.
 940  * If <b>port_out</b> is NULL, then there must be no port number in
 941  * <b>addrport</b>.
 942  * Return 0 on success, -1 on failure.
 943  */
 944 int
 945 parse_addr_port(int severity, const char *addrport, char **address,
 946                 uint32_t *addr, uint16_t *port_out)
 947 {
 948   const char *colon;
 949   char *_address = NULL;
 950   int _port;
 951   int ok = 1;
 952
 953   tor_assert(addrport);
 954
 955   colon = strchr(addrport, ':');
 956   if (colon) {
 957     _address = tor_strndup(addrport, colon-addrport);
 958     _port = (int) tor_parse_long(colon+1,10,1,65535,NULL,NULL);
 959     if (!_port) {
 960       log_fn(severity, LD_GENERAL, "Port %s out of range", escaped(colon+1));
 961       ok = 0;
 962     }
 963     if (!port_out) {
 964       char *esc_addrport = esc_for_log(addrport);
 965       log_fn(severity, LD_GENERAL,
 966              "Port %s given on %s when not required",
 967              escaped(colon+1), esc_addrport);
 968       tor_free(esc_addrport);
 969       ok = 0;
 970     }
 971   } else {
 972     _address = tor_strdup(addrport);
 973     _port = 0;
 974   }
 975
 976   if (addr) {
 977     /* There's an addr pointer, so we need to resolve the hostname. */
 978     if (tor_lookup_hostname(_address,addr)) {
 979       log_fn(severity, LD_NET, "Couldn't look up %s", escaped(_address));
 980       ok = 0;
 981       *addr = 0;
 982     }
 983   }
 984
 985   if (address && ok) {
 986     *address = _address;
 987   } else {
 988     if (address)
 989       *address = NULL;
 990     tor_free(_address);
 991   }
 992   if (port_out)
 993     *port_out = ok ? ((uint16_t) _port) : 0;
 994
 995   return ok ? 0 : -1;
 996 }
 997
 998 /** If <b>mask</b> is an address mask for a bit-prefix, return the number of
 999  * bits.  Otherwise, return -1. */
1000 int
1001 addr_mask_get_bits(uint32_t mask)
1002 {
1003   int i;
1004   if (mask == 0)
1005     return 0;
1006   if (mask == 0xFFFFFFFFu)
1007     return 32;
1008   for (i=0; i<=32; ++i) {
1009     if (mask == (uint32_t) ~((1u<<(32-i))-1)) {
1010       return i;
1011     }
1012   }
1013   return -1;
1014 }
1015
1016 /** Compare two addresses <b>a1</b> and <b>a2</b> for equality under a
1017  * netmask of <b>mbits</b> bits.  Return -1, 0, or 1.
1018  *
1019  * XXXX_IP6 Temporary function to allow masks as bitcounts everywhere.  This
1020  * will be replaced with an IPv6-aware version as soon as 32-bit addresses are
1021  * no longer passed around.
1022  */
1023 int
1024 addr_mask_cmp_bits(uint32_t a1, uint32_t a2, maskbits_t bits)
1025 {
1026   if (bits > 32)
1027     bits = 32;
1028   else if (bits == 0)
1029     return 0;
1030
1031   a1 >>= (32-bits);
1032   a2 >>= (32-bits);
1033
1034   if (a1 < a2)
1035     return -1;
1036   else if (a1 > a2)
1037     return 1;
1038   else
1039     return 0;
1040 }
1041
1042 /** Parse a string <b>s</b> in the format of (*|port(-maxport)?)?, setting the
1043  * various *out pointers as appropriate.  Return 0 on success, -1 on failure.
1044  */
1045 int
1046 parse_port_range(const char *port, uint16_t *port_min_out,
1047                  uint16_t *port_max_out)
1048 {
1049   int port_min, port_max, ok;
1050   tor_assert(port_min_out);
1051   tor_assert(port_max_out);
1052
1053   if (!port || *port == '\0' || strcmp(port, "*") == 0) {
1054     port_min = 1;
1055     port_max = 65535;
1056   } else {
1057     char *endptr = NULL;
1058     port_min = (int)tor_parse_long(port, 10, 0, 65535, &ok, &endptr);
1059     if (!ok) {
1060       log_warn(LD_GENERAL,
1061                "Malformed port %s on address range; rejecting.",
1062                escaped(port));
1063       return -1;
1064     } else if (endptr && *endptr == '-') {
1065       port = endptr+1;
1066       endptr = NULL;
1067       port_max = (int)tor_parse_long(port, 10, 1, 65536, &ok, &endptr);
1068       if (!ok) {
1069         log_warn(LD_GENERAL,
1070                  "Malformed port %s on address range; rejecting.",
1071                  escaped(port));
1072         return -1;
1073       }
1074     } else {
1075       port_max = port_min;
1076     }
1077     if (port_min > port_max) {
1078       log_warn(LD_GENERAL, "Insane port range on address policy; rejecting.");
1079       return -1;
1080     }
1081   }
1082
1083   if (port_min < 1)
1084     port_min = 1;
1085   if (port_max > 65535)
1086     port_max = 65535;
1087
1088   *port_min_out = (uint16_t) port_min;
1089   *port_max_out = (uint16_t) port_max;
1090
1091   return 0;
1092 }
1093
1094 /** Parse a string <b>s</b> in the format of
1095  * (IP(/mask|/mask-bits)?|*)(:(*|port(-maxport))?)?, setting the various
1096  * *out pointers as appropriate.  Return 0 on success, -1 on failure.
1097  */
1098 int
1099 parse_addr_and_port_range(const char *s, uint32_t *addr_out,
1100                           maskbits_t *maskbits_out, uint16_t *port_min_out,
1101                           uint16_t *port_max_out)
1102 {
1103   char *address;
1104   char *mask, *port, *endptr;
1105   struct in_addr in;
1106   int bits;
1107
1108   tor_assert(s);
1109   tor_assert(addr_out);
1110   tor_assert(maskbits_out);
1111   tor_assert(port_min_out);
1112   tor_assert(port_max_out);
1113
1114   address = tor_strdup(s);
1115   /* Break 'address' into separate strings.
1116    */
1117   mask = strchr(address,'/');
1118   port = strchr(mask?mask:address,':');
1119   if (mask)
1120     *mask++ = '\0';
1121   if (port)
1122     *port++ = '\0';
1123   /* Now "address" is the IP|'*' part...
1124    *     "mask" is the Mask|Maskbits part...
1125    * and "port" is the *|port|min-max part.
1126    */
1127
1128   if (strcmp(address,"*")==0) {
1129     *addr_out = 0;
1130   } else if (tor_inet_aton(address, &in) != 0) {
1131     *addr_out = ntohl(in.s_addr);
1132   } else {
1133     log_warn(LD_GENERAL, "Malformed IP %s in address pattern; rejecting.",
1134              escaped(address));
1135     goto err;
1136   }
1137
1138   if (!mask) {
1139     if (strcmp(address,"*")==0)
1140       *maskbits_out = 0;
1141     else
1142       *maskbits_out = 32;
1143   } else {
1144     endptr = NULL;
1145     bits = (int) strtol(mask, &endptr, 10);
1146     if (!*endptr) {
1147       /* strtol handled the whole mask. */
1148       if (bits < 0 || bits > 32) {
1149         log_warn(LD_GENERAL,
1150                  "Bad number of mask bits on address range; rejecting.");
1151         goto err;
1152       }
1153       *maskbits_out = bits;
1154     } else if (tor_inet_aton(mask, &in) != 0) {
1155       bits = addr_mask_get_bits(ntohl(in.s_addr));
1156       if (bits < 0) {
1157         log_warn(LD_GENERAL,
1158                  "Mask %s on address range isn't a prefix; dropping",
1159                  escaped(mask));
1160         goto err;
1161       }
1162       *maskbits_out = bits;
1163     } else {
1164       log_warn(LD_GENERAL,
1165                "Malformed mask %s on address range; rejecting.",
1166                escaped(mask));
1167       goto err;
1168     }
1169   }
1170
1171   if (parse_port_range(port, port_min_out, port_max_out)<0)
1172     goto err;
1173
1174   tor_free(address);
1175   return 0;
1176  err:
1177   tor_free(address);
1178   return -1;
1179 }
1180
1181 /** Given an IPv4 in_addr struct *<b>in</b> (in network order, as usual),
1182  *  write it as a string into the <b>buf_len</b>-byte buffer in
1183  *  <b>buf</b>.
1184  */
1185 int
1186 tor_inet_ntoa(const struct in_addr *in, char *buf, size_t buf_len)
1187 {
1188   uint32_t a = ntohl(in->s_addr);
1189   return tor_snprintf(buf, buf_len, "%d.%d.%d.%d",
1190                       (int)(uint8_t)((a>>24)&0xff),
1191                       (int)(uint8_t)((a>>16)&0xff),
1192                       (int)(uint8_t)((a>>8 )&0xff),
1193                       (int)(uint8_t)((a    )&0xff));
1194 }
1195
1196 /** Given a host-order <b>addr</b>, call tor_inet_ntop() on it
1197  *  and return a strdup of the resulting address.
1198  */
1199 char *
1200 tor_dup_ip(uint32_t addr)
1201 {
1202   char buf[TOR_ADDR_BUF_LEN];
1203   struct in_addr in;
1204
1205   in.s_addr = htonl(addr);
1206   tor_inet_ntop(AF_INET, &in, buf, sizeof(buf));
1207   return tor_strdup(buf);
1208 }
1209
1210 /**
1211  * Set *<b>addr</b> to the host-order IPv4 address (if any) of whatever
1212  * interface connects to the internet.  This address should only be used in
1213  * checking whether our address has changed.  Return 0 on success, -1 on
1214  * failure.
1215  */
1216 int
1217 get_interface_address(int severity, uint32_t *addr)
1218 {
1219   tor_addr_t local_addr;
1220   int r;
1221
1222   r = get_interface_address6(severity, AF_INET, &local_addr);
1223   if (r>=0)
1224     *addr = tor_addr_to_ipv4h(&local_addr);
1225   return r;
1226 }
1227