contrib/libevent/evutil.c

   1 /*
   2  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "event2/event-config.h"
  28 #include "evconfig-private.h"
  29
  30 #ifdef _WIN32
  31 #include <winsock2.h>
  32 #include <ws2tcpip.h>
  33 #define WIN32_LEAN_AND_MEAN
  34 #include <windows.h>
  35 #undef WIN32_LEAN_AND_MEAN
  36 #include <io.h>
  37 #include <tchar.h>
  38 #include <process.h>
  39 #undef _WIN32_WINNT
  40 /* For structs needed by GetAdaptersAddresses */
  41 #define _WIN32_WINNT 0x0501
  42 #include <iphlpapi.h>
  43 #endif
  44
  45 #include <sys/types.h>
  46 #ifdef EVENT__HAVE_SYS_SOCKET_H
  47 #include <sys/socket.h>
  48 #endif
  49 #ifdef EVENT__HAVE_UNISTD_H
  50 #include <unistd.h>
  51 #endif
  52 #ifdef EVENT__HAVE_FCNTL_H
  53 #include <fcntl.h>
  54 #endif
  55 #ifdef EVENT__HAVE_STDLIB_H
  56 #include <stdlib.h>
  57 #endif
  58 #include <errno.h>
  59 #include <limits.h>
  60 #include <stdio.h>
  61 #include <string.h>
  62 #ifdef EVENT__HAVE_NETINET_IN_H
  63 #include <netinet/in.h>
  64 #endif
  65 #ifdef EVENT__HAVE_NETINET_IN6_H
  66 #include <netinet/in6.h>
  67 #endif
  68 #ifdef EVENT__HAVE_NETINET_TCP_H
  69 #include <netinet/tcp.h>
  70 #endif
  71 #ifdef EVENT__HAVE_ARPA_INET_H
  72 #include <arpa/inet.h>
  73 #endif
  74 #include <time.h>
  75 #include <sys/stat.h>
  76 #ifdef EVENT__HAVE_IFADDRS_H
  77 #include <ifaddrs.h>
  78 #endif
  79
  80 #include "event2/util.h"
  81 #include "util-internal.h"
  82 #include "log-internal.h"
  83 #include "mm-internal.h"
  84 #include "evthread-internal.h"
  85
  86 #include "strlcpy-internal.h"
  87 #include "ipv6-internal.h"
  88
  89 #ifdef _WIN32
  90 #define HT_NO_CACHE_HASH_VALUES
  91 #include "ht-internal.h"
  92 #define open _open
  93 #define read _read
  94 #define close _close
  95 #ifndef fstat
  96 #define fstat _fstati64
  97 #endif
  98 #ifndef stat
  99 #define stat _stati64
 100 #endif
 101 #define mode_t int
 102 #endif
 103
 104 int
 105 evutil_open_closeonexec_(const char *pathname, int flags, unsigned mode)
 106 {
 107         int fd;
 108
 109 #ifdef O_CLOEXEC
 110         fd = open(pathname, flags|O_CLOEXEC, (mode_t)mode);
 111         if (fd >= 0 || errno == EINVAL)
 112                 return fd;
 113         /* If we got an EINVAL, fall through and try without O_CLOEXEC */
 114 #endif
 115         fd = open(pathname, flags, (mode_t)mode);
 116         if (fd < 0)
 117                 return -1;
 118
 119 #if defined(FD_CLOEXEC)
 120         if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) {
 121                 close(fd);
 122                 return -1;
 123         }
 124 #endif
 125
 126         return fd;
 127 }
 128
 129 /**
 130    Read the contents of 'filename' into a newly allocated NUL-terminated
 131    string.  Set *content_out to hold this string, and *len_out to hold its
 132    length (not including the appended NUL).  If 'is_binary', open the file in
 133    binary mode.
 134
 135    Returns 0 on success, -1 if the open fails, and -2 for all other failures.
 136
 137    Used internally only; may go away in a future version.
 138  */
 139 int
 140 evutil_read_file_(const char *filename, char **content_out, size_t *len_out,
 141     int is_binary)
 142 {
 143         int fd, r;
 144         struct stat st;
 145         char *mem;
 146         size_t read_so_far=0;
 147         int mode = O_RDONLY;
 148
 149         EVUTIL_ASSERT(content_out);
 150         EVUTIL_ASSERT(len_out);
 151         *content_out = NULL;
 152         *len_out = 0;
 153
 154 #ifdef O_BINARY
 155         if (is_binary)
 156                 mode |= O_BINARY;
 157 #endif
 158
 159         fd = evutil_open_closeonexec_(filename, mode, 0);
 160         if (fd < 0)
 161                 return -1;
 162         if (fstat(fd, &st) || st.st_size < 0 ||
 163             st.st_size > EV_SSIZE_MAX-1 ) {
 164                 close(fd);
 165                 return -2;
 166         }
 167         mem = mm_malloc((size_t)st.st_size + 1);
 168         if (!mem) {
 169                 close(fd);
 170                 return -2;
 171         }
 172         read_so_far = 0;
 173 #ifdef _WIN32
 174 #define N_TO_READ(x) ((x) > INT_MAX) ? INT_MAX : ((int)(x))
 175 #else
 176 #define N_TO_READ(x) (x)
 177 #endif
 178         while ((r = read(fd, mem+read_so_far, N_TO_READ(st.st_size - read_so_far))) > 0) {
 179                 read_so_far += r;
 180                 if (read_so_far >= (size_t)st.st_size)
 181                         break;
 182                 EVUTIL_ASSERT(read_so_far < (size_t)st.st_size);
 183         }
 184         close(fd);
 185         if (r < 0) {
 186                 mm_free(mem);
 187                 return -2;
 188         }
 189         mem[read_so_far] = 0;
 190
 191         *len_out = read_so_far;
 192         *content_out = mem;
 193         return 0;
 194 }
 195
 196 int
 197 evutil_socketpair(int family, int type, int protocol, evutil_socket_t fd[2])
 198 {
 199 #ifndef _WIN32
 200         return socketpair(family, type, protocol, fd);
 201 #else
 202         return evutil_ersatz_socketpair_(family, type, protocol, fd);
 203 #endif
 204 }
 205
 206 int
 207 evutil_ersatz_socketpair_(int family, int type, int protocol,
 208     evutil_socket_t fd[2])
 209 {
 210         /* This code is originally from Tor.  Used with permission. */
 211
 212         /* This socketpair does not work when localhost is down. So
 213          * it's really not the same thing at all. But it's close enough
 214          * for now, and really, when localhost is down sometimes, we
 215          * have other problems too.
 216          */
 217 #ifdef _WIN32
 218 #define ERR(e) WSA##e
 219 #else
 220 #define ERR(e) e
 221 #endif
 222         evutil_socket_t listener = -1;
 223         evutil_socket_t connector = -1;
 224         evutil_socket_t acceptor = -1;
 225         struct sockaddr_in listen_addr;
 226         struct sockaddr_in connect_addr;
 227         ev_socklen_t size;
 228         int saved_errno = -1;
 229         int family_test;
 230
 231         family_test = family != AF_INET;
 232 #ifdef AF_UNIX
 233         family_test = family_test && (family != AF_UNIX);
 234 #endif
 235         if (protocol || family_test) {
 236                 EVUTIL_SET_SOCKET_ERROR(ERR(EAFNOSUPPORT));
 237                 return -1;
 238         }
 239
 240         if (!fd) {
 241                 EVUTIL_SET_SOCKET_ERROR(ERR(EINVAL));
 242                 return -1;
 243         }
 244
 245         listener = socket(AF_INET, type, 0);
 246         if (listener < 0)
 247                 return -1;
 248         memset(&listen_addr, 0, sizeof(listen_addr));
 249         listen_addr.sin_family = AF_INET;
 250         listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 251         listen_addr.sin_port = 0;       /* kernel chooses port.  */
 252         if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr))
 253                 == -1)
 254                 goto tidy_up_and_fail;
 255         if (listen(listener, 1) == -1)
 256                 goto tidy_up_and_fail;
 257
 258         connector = socket(AF_INET, type, 0);
 259         if (connector < 0)
 260                 goto tidy_up_and_fail;
 261
 262         memset(&connect_addr, 0, sizeof(connect_addr));
 263
 264         /* We want to find out the port number to connect to.  */
 265         size = sizeof(connect_addr);
 266         if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)
 267                 goto tidy_up_and_fail;
 268         if (size != sizeof (connect_addr))
 269                 goto abort_tidy_up_and_fail;
 270         if (connect(connector, (struct sockaddr *) &connect_addr,
 271                                 sizeof(connect_addr)) == -1)
 272                 goto tidy_up_and_fail;
 273
 274         size = sizeof(listen_addr);
 275         acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);
 276         if (acceptor < 0)
 277                 goto tidy_up_and_fail;
 278         if (size != sizeof(listen_addr))
 279                 goto abort_tidy_up_and_fail;
 280         /* Now check we are talking to ourself by matching port and host on the
 281            two sockets.  */
 282         if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)
 283                 goto tidy_up_and_fail;
 284         if (size != sizeof (connect_addr)
 285                 || listen_addr.sin_family != connect_addr.sin_family
 286                 || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
 287                 || listen_addr.sin_port != connect_addr.sin_port)
 288                 goto abort_tidy_up_and_fail;
 289         evutil_closesocket(listener);
 290         fd[0] = connector;
 291         fd[1] = acceptor;
 292
 293         return 0;
 294
 295  abort_tidy_up_and_fail:
 296         saved_errno = ERR(ECONNABORTED);
 297  tidy_up_and_fail:
 298         if (saved_errno < 0)
 299                 saved_errno = EVUTIL_SOCKET_ERROR();
 300         if (listener != -1)
 301                 evutil_closesocket(listener);
 302         if (connector != -1)
 303                 evutil_closesocket(connector);
 304         if (acceptor != -1)
 305                 evutil_closesocket(acceptor);
 306
 307         EVUTIL_SET_SOCKET_ERROR(saved_errno);
 308         return -1;
 309 #undef ERR
 310 }
 311
 312 int
 313 evutil_make_socket_nonblocking(evutil_socket_t fd)
 314 {
 315 #ifdef _WIN32
 316         {
 317                 unsigned long nonblocking = 1;
 318                 if (ioctlsocket(fd, FIONBIO, &nonblocking) == SOCKET_ERROR) {
 319                         event_sock_warn(fd, "fcntl(%d, F_GETFL)", (int)fd);
 320                         return -1;
 321                 }
 322         }
 323 #else
 324         {
 325                 int flags;
 326                 if ((flags = fcntl(fd, F_GETFL, NULL)) < 0) {
 327                         event_warn("fcntl(%d, F_GETFL)", fd);
 328                         return -1;
 329                 }
 330                 if (!(flags & O_NONBLOCK)) {
 331                         if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
 332                                 event_warn("fcntl(%d, F_SETFL)", fd);
 333                                 return -1;
 334                         }
 335                 }
 336         }
 337 #endif
 338         return 0;
 339 }
 340
 341 /* Faster version of evutil_make_socket_nonblocking for internal use.
 342  *
 343  * Requires that no F_SETFL flags were previously set on the fd.
 344  */
 345 static int
 346 evutil_fast_socket_nonblocking(evutil_socket_t fd)
 347 {
 348 #ifdef _WIN32
 349         return evutil_make_socket_nonblocking(fd);
 350 #else
 351         if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
 352                 event_warn("fcntl(%d, F_SETFL)", fd);
 353                 return -1;
 354         }
 355         return 0;
 356 #endif
 357 }
 358
 359 int
 360 evutil_make_listen_socket_reuseable(evutil_socket_t sock)
 361 {
 362 #if defined(SO_REUSEADDR) && !defined(_WIN32)
 363         int one = 1;
 364         /* REUSEADDR on Unix means, "don't hang on to this address after the
 365          * listener is closed."  On Windows, though, it means "don't keep other
 366          * processes from binding to this address while we're using it. */
 367         return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*) &one,
 368             (ev_socklen_t)sizeof(one));
 369 #else
 370         return 0;
 371 #endif
 372 }
 373
 374 int
 375 evutil_make_listen_socket_reuseable_port(evutil_socket_t sock)
 376 {
 377 #if defined __linux__ && defined(SO_REUSEPORT)
 378         int one = 1;
 379         /* REUSEPORT on Linux 3.9+ means, "Multiple servers (processes or
 380          * threads) can bind to the same port if they each set the option. */
 381         return setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (void*) &one,
 382             (ev_socklen_t)sizeof(one));
 383 #else
 384         return 0;
 385 #endif
 386 }
 387
 388 int
 389 evutil_make_tcp_listen_socket_deferred(evutil_socket_t sock)
 390 {
 391 #if defined(EVENT__HAVE_NETINET_TCP_H) && defined(TCP_DEFER_ACCEPT)
 392         int one = 1;
 393
 394         /* TCP_DEFER_ACCEPT tells the kernel to call defer accept() only after data
 395          * has arrived and ready to read */
 396         return setsockopt(sock, IPPROTO_TCP, TCP_DEFER_ACCEPT, &one,
 397                 (ev_socklen_t)sizeof(one));
 398 #endif
 399         return 0;
 400 }
 401
 402 int
 403 evutil_make_socket_closeonexec(evutil_socket_t fd)
 404 {
 405 #if !defined(_WIN32) && defined(EVENT__HAVE_SETFD)
 406         int flags;
 407         if ((flags = fcntl(fd, F_GETFD, NULL)) < 0) {
 408                 event_warn("fcntl(%d, F_GETFD)", fd);
 409                 return -1;
 410         }
 411         if (!(flags & FD_CLOEXEC)) {
 412                 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {
 413                         event_warn("fcntl(%d, F_SETFD)", fd);
 414                         return -1;
 415                 }
 416         }
 417 #endif
 418         return 0;
 419 }
 420
 421 /* Faster version of evutil_make_socket_closeonexec for internal use.
 422  *
 423  * Requires that no F_SETFD flags were previously set on the fd.
 424  */
 425 static int
 426 evutil_fast_socket_closeonexec(evutil_socket_t fd)
 427 {
 428 #if !defined(_WIN32) && defined(EVENT__HAVE_SETFD)
 429         if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
 430                 event_warn("fcntl(%d, F_SETFD)", fd);
 431                 return -1;
 432         }
 433 #endif
 434         return 0;
 435 }
 436
 437 int
 438 evutil_closesocket(evutil_socket_t sock)
 439 {
 440 #ifndef _WIN32
 441         return close(sock);
 442 #else
 443         return closesocket(sock);
 444 #endif
 445 }
 446
 447 ev_int64_t
 448 evutil_strtoll(const char *s, char **endptr, int base)
 449 {
 450 #ifdef EVENT__HAVE_STRTOLL
 451         return (ev_int64_t)strtoll(s, endptr, base);
 452 #elif EVENT__SIZEOF_LONG == 8
 453         return (ev_int64_t)strtol(s, endptr, base);
 454 #elif defined(_WIN32) && defined(_MSC_VER) && _MSC_VER < 1300
 455         /* XXXX on old versions of MS APIs, we only support base
 456          * 10. */
 457         ev_int64_t r;
 458         if (base != 10)
 459                 return 0;
 460         r = (ev_int64_t) _atoi64(s);
 461         while (isspace(*s))
 462                 ++s;
 463         if (*s == '-')
 464                 ++s;
 465         while (isdigit(*s))
 466                 ++s;
 467         if (endptr)
 468                 *endptr = (char*) s;
 469         return r;
 470 #elif defined(_WIN32)
 471         return (ev_int64_t) _strtoi64(s, endptr, base);
 472 #elif defined(EVENT__SIZEOF_LONG_LONG) && EVENT__SIZEOF_LONG_LONG == 8
 473         long long r;
 474         int n;
 475         if (base != 10 && base != 16)
 476                 return 0;
 477         if (base == 10) {
 478                 n = sscanf(s, "%lld", &r);
 479         } else {
 480                 unsigned long long ru=0;
 481                 n = sscanf(s, "%llx", &ru);
 482                 if (ru > EV_INT64_MAX)
 483                         return 0;
 484                 r = (long long) ru;
 485         }
 486         if (n != 1)
 487                 return 0;
 488         while (EVUTIL_ISSPACE_(*s))
 489                 ++s;
 490         if (*s == '-')
 491                 ++s;
 492         if (base == 10) {
 493                 while (EVUTIL_ISDIGIT_(*s))
 494                         ++s;
 495         } else {
 496                 while (EVUTIL_ISXDIGIT_(*s))
 497                         ++s;
 498         }
 499         if (endptr)
 500                 *endptr = (char*) s;
 501         return r;
 502 #else
 503 #error "I don't know how to parse 64-bit integers."
 504 #endif
 505 }
 506
 507 #ifdef _WIN32
 508 int
 509 evutil_socket_geterror(evutil_socket_t sock)
 510 {
 511         int optval, optvallen=sizeof(optval);
 512         int err = WSAGetLastError();
 513         if (err == WSAEWOULDBLOCK && sock >= 0) {
 514                 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval,
 515                                            &optvallen))
 516                         return err;
 517                 if (optval)
 518                         return optval;
 519         }
 520         return err;
 521 }
 522 #endif
 523
 524 /* XXX we should use an enum here. */
 525 /* 2 for connection refused, 1 for connected, 0 for not yet, -1 for error. */
 526 int
 527 evutil_socket_connect_(evutil_socket_t *fd_ptr, const struct sockaddr *sa, int socklen)
 528 {
 529         int made_fd = 0;
 530
 531         if (*fd_ptr < 0) {
 532                 if ((*fd_ptr = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)
 533                         goto err;
 534                 made_fd = 1;
 535                 if (evutil_make_socket_nonblocking(*fd_ptr) < 0) {
 536                         goto err;
 537                 }
 538         }
 539
 540         if (connect(*fd_ptr, sa, socklen) < 0) {
 541                 int e = evutil_socket_geterror(*fd_ptr);
 542                 if (EVUTIL_ERR_CONNECT_RETRIABLE(e))
 543                         return 0;
 544                 if (EVUTIL_ERR_CONNECT_REFUSED(e))
 545                         return 2;
 546                 goto err;
 547         } else {
 548                 return 1;
 549         }
 550
 551 err:
 552         if (made_fd) {
 553                 evutil_closesocket(*fd_ptr);
 554                 *fd_ptr = -1;
 555         }
 556         return -1;
 557 }
 558
 559 /* Check whether a socket on which we called connect() is done
 560    connecting. Return 1 for connected, 0 for not yet, -1 for error.  In the
 561    error case, set the current socket errno to the error that happened during
 562    the connect operation. */
 563 int
 564 evutil_socket_finished_connecting_(evutil_socket_t fd)
 565 {
 566         int e;
 567         ev_socklen_t elen = sizeof(e);
 568
 569         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0)
 570                 return -1;
 571
 572         if (e) {
 573                 if (EVUTIL_ERR_CONNECT_RETRIABLE(e))
 574                         return 0;
 575                 EVUTIL_SET_SOCKET_ERROR(e);
 576                 return -1;
 577         }
 578
 579         return 1;
 580 }
 581
 582 #if (EVUTIL_AI_PASSIVE|EVUTIL_AI_CANONNAME|EVUTIL_AI_NUMERICHOST| \
 583      EVUTIL_AI_NUMERICSERV|EVUTIL_AI_V4MAPPED|EVUTIL_AI_ALL| \
 584      EVUTIL_AI_ADDRCONFIG) != \
 585     (EVUTIL_AI_PASSIVE^EVUTIL_AI_CANONNAME^EVUTIL_AI_NUMERICHOST^ \
 586      EVUTIL_AI_NUMERICSERV^EVUTIL_AI_V4MAPPED^EVUTIL_AI_ALL^ \
 587      EVUTIL_AI_ADDRCONFIG)
 588 #error "Some of our EVUTIL_AI_* flags seem to overlap with system AI_* flags"
 589 #endif
 590
 591 /* We sometimes need to know whether we have an ipv4 address and whether we
 592    have an ipv6 address. If 'have_checked_interfaces', then we've already done
 593    the test.  If 'had_ipv4_address', then it turns out we had an ipv4 address.
 594    If 'had_ipv6_address', then it turns out we had an ipv6 address.   These are
 595    set by evutil_check_interfaces. */
 596 static int have_checked_interfaces, had_ipv4_address, had_ipv6_address;
 597
 598 /* Macro: True iff the IPv4 address 'addr', in host order, is in 127.0.0.0/8
 599  */
 600 #define EVUTIL_V4ADDR_IS_LOCALHOST(addr) (((addr)>>24) == 127)
 601
 602 /* Macro: True iff the IPv4 address 'addr', in host order, is a class D
 603  * (multiclass) address.
 604  */
 605 #define EVUTIL_V4ADDR_IS_CLASSD(addr) ((((addr)>>24) & 0xf0) == 0xe0)
 606
 607 static void
 608 evutil_found_ifaddr(const struct sockaddr *sa)
 609 {
 610         const char ZEROES[] = "\x00\x00\x00\x00\x00\x00\x00\x00"
 611             "\x00\x00\x00\x00\x00\x00\x00\x00";
 612
 613         if (sa->sa_family == AF_INET) {
 614                 const struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 615                 ev_uint32_t addr = ntohl(sin->sin_addr.s_addr);
 616                 if (addr == 0 ||
 617                     EVUTIL_V4ADDR_IS_LOCALHOST(addr) ||
 618                     EVUTIL_V4ADDR_IS_CLASSD(addr)) {
 619                         /* Not actually a usable external address. */
 620                 } else {
 621                         event_debug(("Detected an IPv4 interface"));
 622                         had_ipv4_address = 1;
 623                 }
 624         } else if (sa->sa_family == AF_INET6) {
 625                 const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
 626                 const unsigned char *addr =
 627                     (unsigned char*)sin6->sin6_addr.s6_addr;
 628                 if (!memcmp(addr, ZEROES, 8) ||
 629                     ((addr[0] & 0xfe) == 0xfc) ||
 630                     (addr[0] == 0xfe && (addr[1] & 0xc0) == 0x80) ||
 631                     (addr[0] == 0xfe && (addr[1] & 0xc0) == 0xc0) ||
 632                     (addr[0] == 0xff)) {
 633                         /* This is a reserved, ipv4compat, ipv4map, loopback,
 634                          * link-local, multicast, or unspecified address. */
 635                 } else {
 636                         event_debug(("Detected an IPv6 interface"));
 637                         had_ipv6_address = 1;
 638                 }
 639         }
 640 }
 641
 642 #ifdef _WIN32
 643 typedef ULONG (WINAPI *GetAdaptersAddresses_fn_t)(
 644               ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG);
 645 #endif
 646
 647 static int
 648 evutil_check_ifaddrs(void)
 649 {
 650 #if defined(EVENT__HAVE_GETIFADDRS)
 651         /* Most free Unixy systems provide getifaddrs, which gives us a linked list
 652          * of struct ifaddrs. */
 653         struct ifaddrs *ifa = NULL;
 654         const struct ifaddrs *i;
 655         if (getifaddrs(&ifa) < 0) {
 656                 event_warn("Unable to call getifaddrs()");
 657                 return -1;
 658         }
 659
 660         for (i = ifa; i; i = i->ifa_next) {
 661                 if (!i->ifa_addr)
 662                         continue;
 663                 evutil_found_ifaddr(i->ifa_addr);
 664         }
 665
 666         freeifaddrs(ifa);
 667         return 0;
 668 #elif defined(_WIN32)
 669         /* Windows XP began to provide GetAdaptersAddresses. Windows 2000 had a
 670            "GetAdaptersInfo", but that's deprecated; let's just try
 671            GetAdaptersAddresses and fall back to connect+getsockname.
 672         */
 673         HMODULE lib = evutil_load_windows_system_library_(TEXT("ihplapi.dll"));
 674         GetAdaptersAddresses_fn_t fn;
 675         ULONG size, res;
 676         IP_ADAPTER_ADDRESSES *addresses = NULL, *address;
 677         int result = -1;
 678
 679 #define FLAGS (GAA_FLAG_SKIP_ANYCAST | \
 680                GAA_FLAG_SKIP_MULTICAST | \
 681                GAA_FLAG_SKIP_DNS_SERVER)
 682
 683         if (!lib)
 684                 goto done;
 685
 686         if (!(fn = (GetAdaptersAddresses_fn_t) GetProcAddress(lib, "GetAdaptersAddresses")))
 687                 goto done;
 688
 689         /* Guess how much space we need. */
 690         size = 15*1024;
 691         addresses = mm_malloc(size);
 692         if (!addresses)
 693                 goto done;
 694         res = fn(AF_UNSPEC, FLAGS, NULL, addresses, &size);
 695         if (res == ERROR_BUFFER_OVERFLOW) {
 696                 /* we didn't guess that we needed enough space; try again */
 697                 mm_free(addresses);
 698                 addresses = mm_malloc(size);
 699                 if (!addresses)
 700                         goto done;
 701                 res = fn(AF_UNSPEC, FLAGS, NULL, addresses, &size);
 702         }
 703         if (res != NO_ERROR)
 704                 goto done;
 705
 706         for (address = addresses; address; address = address->Next) {
 707                 IP_ADAPTER_UNICAST_ADDRESS *a;
 708                 for (a = address->FirstUnicastAddress; a; a = a->Next) {
 709                         /* Yes, it's a linked list inside a linked list */
 710                         struct sockaddr *sa = a->Address.lpSockaddr;
 711                         evutil_found_ifaddr(sa);
 712                 }
 713         }
 714
 715         result = 0;
 716 done:
 717         if (lib)
 718                 FreeLibrary(lib);
 719         if (addresses)
 720                 mm_free(addresses);
 721         return result;
 722 #else
 723         return -1;
 724 #endif
 725 }
 726
 727 /* Test whether we have an ipv4 interface and an ipv6 interface.  Return 0 if
 728  * the test seemed successful. */
 729 static int
 730 evutil_check_interfaces(int force_recheck)
 731 {
 732         evutil_socket_t fd = -1;
 733         struct sockaddr_in sin, sin_out;
 734         struct sockaddr_in6 sin6, sin6_out;
 735         ev_socklen_t sin_out_len = sizeof(sin_out);
 736         ev_socklen_t sin6_out_len = sizeof(sin6_out);
 737         int r;
 738         if (have_checked_interfaces && !force_recheck)
 739                 return 0;
 740
 741         if (evutil_check_ifaddrs() == 0) {
 742                 /* Use a nice sane interface, if this system has one. */
 743                 return 0;
 744         }
 745
 746         /* Ugh. There was no nice sane interface.  So to check whether we have
 747          * an interface open for a given protocol, will try to make a UDP
 748          * 'connection' to a remote host on the internet.  We don't actually
 749          * use it, so the address doesn't matter, but we want to pick one that
 750          * keep us from using a host- or link-local interface. */
 751         memset(&sin, 0, sizeof(sin));
 752         sin.sin_family = AF_INET;
 753         sin.sin_port = htons(53);
 754         r = evutil_inet_pton(AF_INET, "18.244.0.188", &sin.sin_addr);
 755         EVUTIL_ASSERT(r);
 756
 757         memset(&sin6, 0, sizeof(sin6));
 758         sin6.sin6_family = AF_INET6;
 759         sin6.sin6_port = htons(53);
 760         r = evutil_inet_pton(AF_INET6, "2001:4860:b002::68", &sin6.sin6_addr);
 761         EVUTIL_ASSERT(r);
 762
 763         memset(&sin_out, 0, sizeof(sin_out));
 764         memset(&sin6_out, 0, sizeof(sin6_out));
 765
 766         /* XXX some errnos mean 'no address'; some mean 'not enough sockets'. */
 767         if ((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) >= 0 &&
 768             connect(fd, (struct sockaddr*)&sin, sizeof(sin)) == 0 &&
 769             getsockname(fd, (struct sockaddr*)&sin_out, &sin_out_len) == 0) {
 770                 /* We might have an IPv4 interface. */
 771                 evutil_found_ifaddr((struct sockaddr*) &sin_out);
 772         }
 773         if (fd >= 0)
 774                 evutil_closesocket(fd);
 775
 776         if ((fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) >= 0 &&
 777             connect(fd, (struct sockaddr*)&sin6, sizeof(sin6)) == 0 &&
 778             getsockname(fd, (struct sockaddr*)&sin6_out, &sin6_out_len) == 0) {
 779                 /* We might have an IPv6 interface. */
 780                 evutil_found_ifaddr((struct sockaddr*) &sin6_out);
 781         }
 782
 783         if (fd >= 0)
 784                 evutil_closesocket(fd);
 785
 786         return 0;
 787 }
 788
 789 /* Internal addrinfo flag.  This one is set when we allocate the addrinfo from
 790  * inside libevent.  Otherwise, the built-in getaddrinfo() function allocated
 791  * it, and we should trust what they said.
 792  **/
 793 #define EVUTIL_AI_LIBEVENT_ALLOCATED 0x80000000
 794
 795 /* Helper: construct a new addrinfo containing the socket address in
 796  * 'sa', which must be a sockaddr_in or a sockaddr_in6.  Take the
 797  * socktype and protocol info from hints.  If they weren't set, then
 798  * allocate both a TCP and a UDP addrinfo.
 799  */
 800 struct evutil_addrinfo *
 801 evutil_new_addrinfo_(struct sockaddr *sa, ev_socklen_t socklen,
 802     const struct evutil_addrinfo *hints)
 803 {
 804         struct evutil_addrinfo *res;
 805         EVUTIL_ASSERT(hints);
 806
 807         if (hints->ai_socktype == 0 && hints->ai_protocol == 0) {
 808                 /* Indecisive user! Give them a UDP and a TCP. */
 809                 struct evutil_addrinfo *r1, *r2;
 810                 struct evutil_addrinfo tmp;
 811                 memcpy(&tmp, hints, sizeof(tmp));
 812                 tmp.ai_socktype = SOCK_STREAM; tmp.ai_protocol = IPPROTO_TCP;
 813                 r1 = evutil_new_addrinfo_(sa, socklen, &tmp);
 814                 if (!r1)
 815                         return NULL;
 816                 tmp.ai_socktype = SOCK_DGRAM; tmp.ai_protocol = IPPROTO_UDP;
 817                 r2 = evutil_new_addrinfo_(sa, socklen, &tmp);
 818                 if (!r2) {
 819                         evutil_freeaddrinfo(r1);
 820                         return NULL;
 821                 }
 822                 r1->ai_next = r2;
 823                 return r1;
 824         }
 825
 826         /* We're going to allocate extra space to hold the sockaddr. */
 827         res = mm_calloc(1,sizeof(struct evutil_addrinfo)+socklen);
 828         if (!res)
 829                 return NULL;
 830         res->ai_addr = (struct sockaddr*)
 831             (((char*)res) + sizeof(struct evutil_addrinfo));
 832         memcpy(res->ai_addr, sa, socklen);
 833         res->ai_addrlen = socklen;
 834         res->ai_family = sa->sa_family; /* Same or not? XXX */
 835         res->ai_flags = EVUTIL_AI_LIBEVENT_ALLOCATED;
 836         res->ai_socktype = hints->ai_socktype;
 837         res->ai_protocol = hints->ai_protocol;
 838
 839         return res;
 840 }
 841
 842 /* Append the addrinfo 'append' to the end of 'first', and return the start of
 843  * the list.  Either element can be NULL, in which case we return the element
 844  * that is not NULL. */
 845 struct evutil_addrinfo *
 846 evutil_addrinfo_append_(struct evutil_addrinfo *first,
 847     struct evutil_addrinfo *append)
 848 {
 849         struct evutil_addrinfo *ai = first;
 850         if (!ai)
 851                 return append;
 852         while (ai->ai_next)
 853                 ai = ai->ai_next;
 854         ai->ai_next = append;
 855
 856         return first;
 857 }
 858
 859 static int
 860 parse_numeric_servname(const char *servname)
 861 {
 862         int n;
 863         char *endptr=NULL;
 864         n = (int) strtol(servname, &endptr, 10);
 865         if (n>=0 && n <= 65535 && servname[0] && endptr && !endptr[0])
 866                 return n;
 867         else
 868                 return -1;
 869 }
 870
 871 /** Parse a service name in 'servname', which can be a decimal port.
 872  * Return the port number, or -1 on error.
 873  */
 874 static int
 875 evutil_parse_servname(const char *servname, const char *protocol,
 876     const struct evutil_addrinfo *hints)
 877 {
 878         int n = parse_numeric_servname(servname);
 879         if (n>=0)
 880                 return n;
 881 #if defined(EVENT__HAVE_GETSERVBYNAME) || defined(_WIN32)
 882         if (!(hints->ai_flags & EVUTIL_AI_NUMERICSERV)) {
 883                 struct servent *ent = getservbyname(servname, protocol);
 884                 if (ent) {
 885                         return ntohs(ent->s_port);
 886                 }
 887         }
 888 #endif
 889         return -1;
 890 }
 891
 892 /* Return a string corresponding to a protocol number that we can pass to
 893  * getservyname.  */
 894 static const char *
 895 evutil_unparse_protoname(int proto)
 896 {
 897         switch (proto) {
 898         case 0:
 899                 return NULL;
 900         case IPPROTO_TCP:
 901                 return "tcp";
 902         case IPPROTO_UDP:
 903                 return "udp";
 904 #ifdef IPPROTO_SCTP
 905         case IPPROTO_SCTP:
 906                 return "sctp";
 907 #endif
 908         default:
 909 #ifdef EVENT__HAVE_GETPROTOBYNUMBER
 910                 {
 911                         struct protoent *ent = getprotobynumber(proto);
 912                         if (ent)
 913                                 return ent->p_name;
 914                 }
 915 #endif
 916                 return NULL;
 917         }
 918 }
 919
 920 static void
 921 evutil_getaddrinfo_infer_protocols(struct evutil_addrinfo *hints)
 922 {
 923         /* If we can guess the protocol from the socktype, do so. */
 924         if (!hints->ai_protocol && hints->ai_socktype) {
 925                 if (hints->ai_socktype == SOCK_DGRAM)
 926                         hints->ai_protocol = IPPROTO_UDP;
 927                 else if (hints->ai_socktype == SOCK_STREAM)
 928                         hints->ai_protocol = IPPROTO_TCP;
 929         }
 930
 931         /* Set the socktype if it isn't set. */
 932         if (!hints->ai_socktype && hints->ai_protocol) {
 933                 if (hints->ai_protocol == IPPROTO_UDP)
 934                         hints->ai_socktype = SOCK_DGRAM;
 935                 else if (hints->ai_protocol == IPPROTO_TCP)
 936                         hints->ai_socktype = SOCK_STREAM;
 937 #ifdef IPPROTO_SCTP
 938                 else if (hints->ai_protocol == IPPROTO_SCTP)
 939                         hints->ai_socktype = SOCK_STREAM;
 940 #endif
 941         }
 942 }
 943
 944 #if AF_UNSPEC != PF_UNSPEC
 945 #error "I cannot build on a system where AF_UNSPEC != PF_UNSPEC"
 946 #endif
 947
 948 /** Implements the part of looking up hosts by name that's common to both
 949  * the blocking and nonblocking resolver:
 950  *   - Adjust 'hints' to have a reasonable socktype and protocol.
 951  *   - Look up the port based on 'servname', and store it in *portnum,
 952  *   - Handle the nodename==NULL case
 953  *   - Handle some invalid arguments cases.
 954  *   - Handle the cases where nodename is an IPv4 or IPv6 address.
 955  *
 956  * If we need the resolver to look up the hostname, we return
 957  * EVUTIL_EAI_NEED_RESOLVE.  Otherwise, we can completely implement
 958  * getaddrinfo: we return 0 or an appropriate EVUTIL_EAI_* error, and
 959  * set *res as getaddrinfo would.
 960  */
 961 int
 962 evutil_getaddrinfo_common_(const char *nodename, const char *servname,
 963     struct evutil_addrinfo *hints, struct evutil_addrinfo **res, int *portnum)
 964 {
 965         int port = 0;
 966         const char *pname;
 967
 968         if (nodename == NULL && servname == NULL)
 969                 return EVUTIL_EAI_NONAME;
 970
 971         /* We only understand 3 families */
 972         if (hints->ai_family != PF_UNSPEC && hints->ai_family != PF_INET &&
 973             hints->ai_family != PF_INET6)
 974                 return EVUTIL_EAI_FAMILY;
 975
 976         evutil_getaddrinfo_infer_protocols(hints);
 977
 978         /* Look up the port number and protocol, if possible. */
 979         pname = evutil_unparse_protoname(hints->ai_protocol);
 980         if (servname) {
 981                 /* XXXX We could look at the protocol we got back from
 982                  * getservbyname, but it doesn't seem too useful. */
 983                 port = evutil_parse_servname(servname, pname, hints);
 984                 if (port < 0) {
 985                         return EVUTIL_EAI_NONAME;
 986                 }
 987         }
 988
 989         /* If we have no node name, then we're supposed to bind to 'any' and
 990          * connect to localhost. */
 991         if (nodename == NULL) {
 992                 struct evutil_addrinfo *res4=NULL, *res6=NULL;
 993                 if (hints->ai_family != PF_INET) { /* INET6 or UNSPEC. */
 994                         struct sockaddr_in6 sin6;
 995                         memset(&sin6, 0, sizeof(sin6));
 996                         sin6.sin6_family = AF_INET6;
 997                         sin6.sin6_port = htons(port);
 998                         if (hints->ai_flags & EVUTIL_AI_PASSIVE) {
 999                                 /* Bind to :: */
1000                         } else {
1001                                 /* connect to ::1 */
1002                                 sin6.sin6_addr.s6_addr[15] = 1;
1003                         }
1004                         res6 = evutil_new_addrinfo_((struct sockaddr*)&sin6,
1005                             sizeof(sin6), hints);
1006                         if (!res6)
1007                                 return EVUTIL_EAI_MEMORY;
1008                 }
1009
1010                 if (hints->ai_family != PF_INET6) { /* INET or UNSPEC */
1011                         struct sockaddr_in sin;
1012                         memset(&sin, 0, sizeof(sin));
1013                         sin.sin_family = AF_INET;
1014                         sin.sin_port = htons(port);
1015                         if (hints->ai_flags & EVUTIL_AI_PASSIVE) {
1016                                 /* Bind to 0.0.0.0 */
1017                         } else {
1018                                 /* connect to 127.0.0.1 */
1019                                 sin.sin_addr.s_addr = htonl(0x7f000001);
1020                         }
1021                         res4 = evutil_new_addrinfo_((struct sockaddr*)&sin,
1022                             sizeof(sin), hints);
1023                         if (!res4) {
1024                                 if (res6)
1025                                         evutil_freeaddrinfo(res6);
1026                                 return EVUTIL_EAI_MEMORY;
1027                         }
1028                 }
1029                 *res = evutil_addrinfo_append_(res4, res6);
1030                 return 0;
1031         }
1032
1033         /* If we can, we should try to parse the hostname without resolving
1034          * it. */
1035         /* Try ipv6. */
1036         if (hints->ai_family == PF_INET6 || hints->ai_family == PF_UNSPEC) {
1037                 struct sockaddr_in6 sin6;
1038                 memset(&sin6, 0, sizeof(sin6));
1039                 if (1==evutil_inet_pton(AF_INET6, nodename, &sin6.sin6_addr)) {
1040                         /* Got an ipv6 address. */
1041                         sin6.sin6_family = AF_INET6;
1042                         sin6.sin6_port = htons(port);
1043                         *res = evutil_new_addrinfo_((struct sockaddr*)&sin6,
1044                             sizeof(sin6), hints);
1045                         if (!*res)
1046                                 return EVUTIL_EAI_MEMORY;
1047                         return 0;
1048                 }
1049         }
1050
1051         /* Try ipv4. */
1052         if (hints->ai_family == PF_INET || hints->ai_family == PF_UNSPEC) {
1053                 struct sockaddr_in sin;
1054                 memset(&sin, 0, sizeof(sin));
1055                 if (1==evutil_inet_pton(AF_INET, nodename, &sin.sin_addr)) {
1056                         /* Got an ipv6 address. */
1057                         sin.sin_family = AF_INET;
1058                         sin.sin_port = htons(port);
1059                         *res = evutil_new_addrinfo_((struct sockaddr*)&sin,
1060                             sizeof(sin), hints);
1061                         if (!*res)
1062                                 return EVUTIL_EAI_MEMORY;
1063                         return 0;
1064                 }
1065         }
1066
1067
1068         /* If we have reached this point, we definitely need to do a DNS
1069          * lookup. */
1070         if ((hints->ai_flags & EVUTIL_AI_NUMERICHOST)) {
1071                 /* If we're not allowed to do one, then say so. */
1072                 return EVUTIL_EAI_NONAME;
1073         }
1074         *portnum = port;
1075         return EVUTIL_EAI_NEED_RESOLVE;
1076 }
1077
1078 #ifdef EVENT__HAVE_GETADDRINFO
1079 #define USE_NATIVE_GETADDRINFO
1080 #endif
1081
1082 #ifdef USE_NATIVE_GETADDRINFO
1083 /* A mask of all the flags that we declare, so we can clear them before calling
1084  * the native getaddrinfo */
1085 static const unsigned int ALL_NONNATIVE_AI_FLAGS =
1086 #ifndef AI_PASSIVE
1087     EVUTIL_AI_PASSIVE |
1088 #endif
1089 #ifndef AI_CANONNAME
1090     EVUTIL_AI_CANONNAME |
1091 #endif
1092 #ifndef AI_NUMERICHOST
1093     EVUTIL_AI_NUMERICHOST |
1094 #endif
1095 #ifndef AI_NUMERICSERV
1096     EVUTIL_AI_NUMERICSERV |
1097 #endif
1098 #ifndef AI_ADDRCONFIG
1099     EVUTIL_AI_ADDRCONFIG |
1100 #endif
1101 #ifndef AI_ALL
1102     EVUTIL_AI_ALL |
1103 #endif
1104 #ifndef AI_V4MAPPED
1105     EVUTIL_AI_V4MAPPED |
1106 #endif
1107     EVUTIL_AI_LIBEVENT_ALLOCATED;
1108
1109 static const unsigned int ALL_NATIVE_AI_FLAGS =
1110 #ifdef AI_PASSIVE
1111     AI_PASSIVE |
1112 #endif
1113 #ifdef AI_CANONNAME
1114     AI_CANONNAME |
1115 #endif
1116 #ifdef AI_NUMERICHOST
1117     AI_NUMERICHOST |
1118 #endif
1119 #ifdef AI_NUMERICSERV
1120     AI_NUMERICSERV |
1121 #endif
1122 #ifdef AI_ADDRCONFIG
1123     AI_ADDRCONFIG |
1124 #endif
1125 #ifdef AI_ALL
1126     AI_ALL |
1127 #endif
1128 #ifdef AI_V4MAPPED
1129     AI_V4MAPPED |
1130 #endif
1131     0;
1132 #endif
1133
1134 #ifndef USE_NATIVE_GETADDRINFO
1135 /* Helper for systems with no getaddrinfo(): make one or more addrinfos out of
1136  * a struct hostent.
1137  */
1138 static struct evutil_addrinfo *
1139 addrinfo_from_hostent(const struct hostent *ent,
1140     int port, const struct evutil_addrinfo *hints)
1141 {
1142         int i;
1143         struct sockaddr_in sin;
1144         struct sockaddr_in6 sin6;
1145         struct sockaddr *sa;
1146         int socklen;
1147         struct evutil_addrinfo *res=NULL, *ai;
1148         void *addrp;
1149
1150         if (ent->h_addrtype == PF_INET) {
1151                 memset(&sin, 0, sizeof(sin));
1152                 sin.sin_family = AF_INET;
1153                 sin.sin_port = htons(port);
1154                 sa = (struct sockaddr *)&sin;
1155                 socklen = sizeof(struct sockaddr_in);
1156                 addrp = &sin.sin_addr;
1157                 if (ent->h_length != sizeof(sin.sin_addr)) {
1158                         event_warnx("Weird h_length from gethostbyname");
1159                         return NULL;
1160                 }
1161         } else if (ent->h_addrtype == PF_INET6) {
1162                 memset(&sin6, 0, sizeof(sin6));
1163                 sin6.sin6_family = AF_INET6;
1164                 sin6.sin6_port = htons(port);
1165                 sa = (struct sockaddr *)&sin6;
1166                 socklen = sizeof(struct sockaddr_in6);
1167                 addrp = &sin6.sin6_addr;
1168                 if (ent->h_length != sizeof(sin6.sin6_addr)) {
1169                         event_warnx("Weird h_length from gethostbyname");
1170                         return NULL;
1171                 }
1172         } else
1173                 return NULL;
1174
1175         for (i = 0; ent->h_addr_list[i]; ++i) {
1176                 memcpy(addrp, ent->h_addr_list[i], ent->h_length);
1177                 ai = evutil_new_addrinfo_(sa, socklen, hints);
1178                 if (!ai) {
1179                         evutil_freeaddrinfo(res);
1180                         return NULL;
1181                 }
1182                 res = evutil_addrinfo_append_(res, ai);
1183         }
1184
1185         if (res && ((hints->ai_flags & EVUTIL_AI_CANONNAME) && ent->h_name)) {
1186                 res->ai_canonname = mm_strdup(ent->h_name);
1187                 if (res->ai_canonname == NULL) {
1188                         evutil_freeaddrinfo(res);
1189                         return NULL;
1190                 }
1191         }
1192
1193         return res;
1194 }
1195 #endif
1196
1197 /* If the EVUTIL_AI_ADDRCONFIG flag is set on hints->ai_flags, and
1198  * hints->ai_family is PF_UNSPEC, then revise the value of hints->ai_family so
1199  * that we'll only get addresses we could maybe connect to.
1200  */
1201 void
1202 evutil_adjust_hints_for_addrconfig_(struct evutil_addrinfo *hints)
1203 {
1204         if (!(hints->ai_flags & EVUTIL_AI_ADDRCONFIG))
1205                 return;
1206         if (hints->ai_family != PF_UNSPEC)
1207                 return;
1208         if (!have_checked_interfaces)
1209                 evutil_check_interfaces(0);
1210         if (had_ipv4_address && !had_ipv6_address) {
1211                 hints->ai_family = PF_INET;
1212         } else if (!had_ipv4_address && had_ipv6_address) {
1213                 hints->ai_family = PF_INET6;
1214         }
1215 }
1216
1217 #ifdef USE_NATIVE_GETADDRINFO
1218 static int need_numeric_port_hack_=0;
1219 static int need_socktype_protocol_hack_=0;
1220 static int tested_for_getaddrinfo_hacks=0;
1221
1222 /* Some older BSDs (like OpenBSD up to 4.6) used to believe that
1223    giving a numeric port without giving an ai_socktype was verboten.
1224    We test for this so we can apply an appropriate workaround.  If it
1225    turns out that the bug is present, then:
1226
1227     - If nodename==NULL and servname is numeric, we build an answer
1228       ourselves using evutil_getaddrinfo_common_().
1229
1230     - If nodename!=NULL and servname is numeric, then we set
1231       servname=NULL when calling getaddrinfo, and post-process the
1232       result to set the ports on it.
1233
1234    We test for this bug at runtime, since otherwise we can't have the
1235    same binary run on multiple BSD versions.
1236
1237    - Some versions of Solaris believe that it's nice to leave to protocol
1238      field set to 0.  We test for this so we can apply an appropriate
1239      workaround.
1240 */
1241 static struct evutil_addrinfo *ai_find_protocol(struct evutil_addrinfo *ai)
1242 {
1243         while (ai) {
1244                 if (ai->ai_protocol)
1245                         return ai;
1246                 ai = ai->ai_next;
1247         }
1248         return NULL;
1249 }
1250 static void
1251 test_for_getaddrinfo_hacks(void)
1252 {
1253         int r, r2;
1254         struct evutil_addrinfo *ai=NULL, *ai2=NULL, *ai3=NULL;
1255         struct evutil_addrinfo hints;
1256
1257         memset(&hints,0,sizeof(hints));
1258         hints.ai_family = PF_UNSPEC;
1259         hints.ai_flags =
1260 #ifdef AI_NUMERICHOST
1261             AI_NUMERICHOST |
1262 #endif
1263 #ifdef AI_NUMERICSERV
1264             AI_NUMERICSERV |
1265 #endif
1266             0;
1267         r = getaddrinfo("1.2.3.4", "80", &hints, &ai);
1268         getaddrinfo("1.2.3.4", NULL, &hints, &ai3);
1269         hints.ai_socktype = SOCK_STREAM;
1270         r2 = getaddrinfo("1.2.3.4", "80", &hints, &ai2);
1271         if (r2 == 0 && r != 0) {
1272                 need_numeric_port_hack_=1;
1273         }
1274         if (!ai_find_protocol(ai2) || !ai_find_protocol(ai3)) {
1275                 need_socktype_protocol_hack_=1;
1276         }
1277
1278         if (ai)
1279                 freeaddrinfo(ai);
1280         if (ai2)
1281                 freeaddrinfo(ai2);
1282         if (ai3)
1283                 freeaddrinfo(ai3);
1284         tested_for_getaddrinfo_hacks=1;
1285 }
1286
1287 static inline int
1288 need_numeric_port_hack(void)
1289 {
1290         if (!tested_for_getaddrinfo_hacks)
1291                 test_for_getaddrinfo_hacks();
1292         return need_numeric_port_hack_;
1293 }
1294
1295 static inline int
1296 need_socktype_protocol_hack(void)
1297 {
1298         if (!tested_for_getaddrinfo_hacks)
1299                 test_for_getaddrinfo_hacks();
1300         return need_socktype_protocol_hack_;
1301 }
1302
1303 static void
1304 apply_numeric_port_hack(int port, struct evutil_addrinfo **ai)
1305 {
1306         /* Now we run through the list and set the ports on all of the
1307          * results where ports would make sense. */
1308         for ( ; *ai; ai = &(*ai)->ai_next) {
1309                 struct sockaddr *sa = (*ai)->ai_addr;
1310                 if (sa && sa->sa_family == AF_INET) {
1311                         struct sockaddr_in *sin = (struct sockaddr_in*)sa;
1312                         sin->sin_port = htons(port);
1313                 } else if (sa && sa->sa_family == AF_INET6) {
1314                         struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)sa;
1315                         sin6->sin6_port = htons(port);
1316                 } else {
1317                         /* A numeric port makes no sense here; remove this one
1318                          * from the list. */
1319                         struct evutil_addrinfo *victim = *ai;
1320                         *ai = victim->ai_next;
1321                         victim->ai_next = NULL;
1322                         freeaddrinfo(victim);
1323                 }
1324         }
1325 }
1326
1327 static int
1328 apply_socktype_protocol_hack(struct evutil_addrinfo *ai)
1329 {
1330         struct evutil_addrinfo *ai_new;
1331         for (; ai; ai = ai->ai_next) {
1332                 evutil_getaddrinfo_infer_protocols(ai);
1333                 if (ai->ai_socktype || ai->ai_protocol)
1334                         continue;
1335                 ai_new = mm_malloc(sizeof(*ai_new));
1336                 if (!ai_new)
1337                         return -1;
1338                 memcpy(ai_new, ai, sizeof(*ai_new));
1339                 ai->ai_socktype = SOCK_STREAM;
1340                 ai->ai_protocol = IPPROTO_TCP;
1341                 ai_new->ai_socktype = SOCK_DGRAM;
1342                 ai_new->ai_protocol = IPPROTO_UDP;
1343
1344                 ai_new->ai_next = ai->ai_next;
1345                 ai->ai_next = ai_new;
1346         }
1347         return 0;
1348 }
1349 #endif
1350
1351 int
1352 evutil_getaddrinfo(const char *nodename, const char *servname,
1353     const struct evutil_addrinfo *hints_in, struct evutil_addrinfo **res)
1354 {
1355 #ifdef USE_NATIVE_GETADDRINFO
1356         struct evutil_addrinfo hints;
1357         int portnum=-1, need_np_hack, err;
1358
1359         if (hints_in) {
1360                 memcpy(&hints, hints_in, sizeof(hints));
1361         } else {
1362                 memset(&hints, 0, sizeof(hints));
1363                 hints.ai_family = PF_UNSPEC;
1364         }
1365
1366 #ifndef AI_ADDRCONFIG
1367         /* Not every system has AI_ADDRCONFIG, so fake it. */
1368         if (hints.ai_family == PF_UNSPEC &&
1369             (hints.ai_flags & EVUTIL_AI_ADDRCONFIG)) {
1370                 evutil_adjust_hints_for_addrconfig_(&hints);
1371         }
1372 #endif
1373
1374 #ifndef AI_NUMERICSERV
1375         /* Not every system has AI_NUMERICSERV, so fake it. */
1376         if (hints.ai_flags & EVUTIL_AI_NUMERICSERV) {
1377                 if (servname && parse_numeric_servname(servname)<0)
1378                         return EVUTIL_EAI_NONAME;
1379         }
1380 #endif
1381
1382         /* Enough operating systems handle enough common non-resolve
1383          * cases here weirdly enough that we are better off just
1384          * overriding them.  For example:
1385          *
1386          * - Windows doesn't like to infer the protocol from the
1387          *   socket type, or fill in socket or protocol types much at
1388          *   all.  It also seems to do its own broken implicit
1389          *   always-on version of AI_ADDRCONFIG that keeps it from
1390          *   ever resolving even a literal IPv6 address when
1391          *   ai_addrtype is PF_UNSPEC.
1392          */
1393 #ifdef _WIN32
1394         {
1395                 int tmp_port;
1396                 err = evutil_getaddrinfo_common_(nodename,servname,&hints,
1397                     res, &tmp_port);
1398                 if (err == 0 ||
1399                     err == EVUTIL_EAI_MEMORY ||
1400                     err == EVUTIL_EAI_NONAME)
1401                         return err;
1402                 /* If we make it here, the system getaddrinfo can
1403                  * have a crack at it. */
1404         }
1405 #endif
1406
1407         /* See documentation for need_numeric_port_hack above.*/
1408         need_np_hack = need_numeric_port_hack() && servname && !hints.ai_socktype
1409             && ((portnum=parse_numeric_servname(servname)) >= 0);
1410         if (need_np_hack) {
1411                 if (!nodename)
1412                         return evutil_getaddrinfo_common_(
1413                                 NULL,servname,&hints, res, &portnum);
1414                 servname = NULL;
1415         }
1416
1417         if (need_socktype_protocol_hack()) {
1418                 evutil_getaddrinfo_infer_protocols(&hints);
1419         }
1420
1421         /* Make sure that we didn't actually steal any AI_FLAGS values that
1422          * the system is using.  (This is a constant expression, and should ge
1423          * optimized out.)
1424          *
1425          * XXXX Turn this into a compile-time failure rather than a run-time
1426          * failure.
1427          */
1428         EVUTIL_ASSERT((ALL_NONNATIVE_AI_FLAGS & ALL_NATIVE_AI_FLAGS) == 0);
1429
1430         /* Clear any flags that only libevent understands. */
1431         hints.ai_flags &= ~ALL_NONNATIVE_AI_FLAGS;
1432
1433         err = getaddrinfo(nodename, servname, &hints, res);
1434         if (need_np_hack)
1435                 apply_numeric_port_hack(portnum, res);
1436
1437         if (need_socktype_protocol_hack()) {
1438                 if (apply_socktype_protocol_hack(*res) < 0) {
1439                         evutil_freeaddrinfo(*res);
1440                         *res = NULL;
1441                         return EVUTIL_EAI_MEMORY;
1442                 }
1443         }
1444         return err;
1445 #else
1446         int port=0, err;
1447         struct hostent *ent = NULL;
1448         struct evutil_addrinfo hints;
1449
1450         if (hints_in) {
1451                 memcpy(&hints, hints_in, sizeof(hints));
1452         } else {
1453                 memset(&hints, 0, sizeof(hints));
1454                 hints.ai_family = PF_UNSPEC;
1455         }
1456
1457         evutil_adjust_hints_for_addrconfig_(&hints);
1458
1459         err = evutil_getaddrinfo_common_(nodename, servname, &hints, res, &port);
1460         if (err != EVUTIL_EAI_NEED_RESOLVE) {
1461                 /* We either succeeded or failed.  No need to continue */
1462                 return err;
1463         }
1464
1465         err = 0;
1466         /* Use any of the various gethostbyname_r variants as available. */
1467         {
1468 #ifdef EVENT__HAVE_GETHOSTBYNAME_R_6_ARG
1469                 /* This one is what glibc provides. */
1470                 char buf[2048];
1471                 struct hostent hostent;
1472                 int r;
1473                 r = gethostbyname_r(nodename, &hostent, buf, sizeof(buf), &ent,
1474                     &err);
1475 #elif defined(EVENT__HAVE_GETHOSTBYNAME_R_5_ARG)
1476                 char buf[2048];
1477                 struct hostent hostent;
1478                 ent = gethostbyname_r(nodename, &hostent, buf, sizeof(buf),
1479                     &err);
1480 #elif defined(EVENT__HAVE_GETHOSTBYNAME_R_3_ARG)
1481                 struct hostent_data data;
1482                 struct hostent hostent;
1483                 memset(&data, 0, sizeof(data));
1484                 err = gethostbyname_r(nodename, &hostent, &data);
1485                 ent = err ? NULL : &hostent;
1486 #else
1487                 /* fall back to gethostbyname. */
1488                 /* XXXX This needs a lock everywhere but Windows. */
1489                 ent = gethostbyname(nodename);
1490 #ifdef _WIN32
1491                 err = WSAGetLastError();
1492 #else
1493                 err = h_errno;
1494 #endif
1495 #endif
1496
1497                 /* Now we have either ent or err set. */
1498                 if (!ent) {
1499                         /* XXX is this right for windows ? */
1500                         switch (err) {
1501                         case TRY_AGAIN:
1502                                 return EVUTIL_EAI_AGAIN;
1503                         case NO_RECOVERY:
1504                         default:
1505                                 return EVUTIL_EAI_FAIL;
1506                         case HOST_NOT_FOUND:
1507                                 return EVUTIL_EAI_NONAME;
1508                         case NO_ADDRESS:
1509 #if NO_DATA != NO_ADDRESS
1510                         case NO_DATA:
1511 #endif
1512                                 return EVUTIL_EAI_NODATA;
1513                         }
1514                 }
1515
1516                 if (ent->h_addrtype != hints.ai_family &&
1517                     hints.ai_family != PF_UNSPEC) {
1518                         /* This wasn't the type we were hoping for.  Too bad
1519                          * we never had a chance to ask gethostbyname for what
1520                          * we wanted. */
1521                         return EVUTIL_EAI_NONAME;
1522                 }
1523
1524                 /* Make sure we got _some_ answers. */
1525                 if (ent->h_length == 0)
1526                         return EVUTIL_EAI_NODATA;
1527
1528                 /* If we got an address type we don't know how to make a
1529                    sockaddr for, give up. */
1530                 if (ent->h_addrtype != PF_INET && ent->h_addrtype != PF_INET6)
1531                         return EVUTIL_EAI_FAMILY;
1532
1533                 *res = addrinfo_from_hostent(ent, port, &hints);
1534                 if (! *res)
1535                         return EVUTIL_EAI_MEMORY;
1536         }
1537
1538         return 0;
1539 #endif
1540 }
1541
1542 void
1543 evutil_freeaddrinfo(struct evutil_addrinfo *ai)
1544 {
1545 #ifdef EVENT__HAVE_GETADDRINFO
1546         if (!(ai->ai_flags & EVUTIL_AI_LIBEVENT_ALLOCATED)) {
1547                 freeaddrinfo(ai);
1548                 return;
1549         }
1550 #endif
1551         while (ai) {
1552                 struct evutil_addrinfo *next = ai->ai_next;
1553                 if (ai->ai_canonname)
1554                         mm_free(ai->ai_canonname);
1555                 mm_free(ai);
1556                 ai = next;
1557         }
1558 }
1559
1560 static evdns_getaddrinfo_fn evdns_getaddrinfo_impl = NULL;
1561 static evdns_getaddrinfo_cancel_fn evdns_getaddrinfo_cancel_impl = NULL;
1562
1563 void
1564 evutil_set_evdns_getaddrinfo_fn_(evdns_getaddrinfo_fn fn)
1565 {
1566         if (!evdns_getaddrinfo_impl)
1567                 evdns_getaddrinfo_impl = fn;
1568 }
1569 void
1570 evutil_set_evdns_getaddrinfo_cancel_fn_(evdns_getaddrinfo_cancel_fn fn)
1571 {
1572         if (!evdns_getaddrinfo_cancel_impl)
1573                 evdns_getaddrinfo_cancel_impl = fn;
1574 }
1575
1576 /* Internal helper function: act like evdns_getaddrinfo if dns_base is set;
1577  * otherwise do a blocking resolve and pass the result to the callback in the
1578  * way that evdns_getaddrinfo would.
1579  */
1580 struct evdns_getaddrinfo_request *evutil_getaddrinfo_async_(
1581     struct evdns_base *dns_base,
1582     const char *nodename, const char *servname,
1583     const struct evutil_addrinfo *hints_in,
1584     void (*cb)(int, struct evutil_addrinfo *, void *), void *arg)
1585 {
1586         if (dns_base && evdns_getaddrinfo_impl) {
1587                 return evdns_getaddrinfo_impl(
1588                         dns_base, nodename, servname, hints_in, cb, arg);
1589         } else {
1590                 struct evutil_addrinfo *ai=NULL;
1591                 int err;
1592                 err = evutil_getaddrinfo(nodename, servname, hints_in, &ai);
1593                 cb(err, ai, arg);
1594                 return NULL;
1595         }
1596 }
1597
1598 void evutil_getaddrinfo_cancel_async_(struct evdns_getaddrinfo_request *data)
1599 {
1600         if (evdns_getaddrinfo_cancel_impl && data) {
1601                 evdns_getaddrinfo_cancel_impl(data);
1602         }
1603 }
1604
1605 const char *
1606 evutil_gai_strerror(int err)
1607 {
1608         /* As a sneaky side-benefit, this case statement will get most
1609          * compilers to tell us if any of the error codes we defined
1610          * conflict with the platform's native error codes. */
1611         switch (err) {
1612         case EVUTIL_EAI_CANCEL:
1613                 return "Request canceled";
1614         case 0:
1615                 return "No error";
1616
1617         case EVUTIL_EAI_ADDRFAMILY:
1618                 return "address family for nodename not supported";
1619         case EVUTIL_EAI_AGAIN:
1620                 return "temporary failure in name resolution";
1621         case EVUTIL_EAI_BADFLAGS:
1622                 return "invalid value for ai_flags";
1623         case EVUTIL_EAI_FAIL:
1624                 return "non-recoverable failure in name resolution";
1625         case EVUTIL_EAI_FAMILY:
1626                 return "ai_family not supported";
1627         case EVUTIL_EAI_MEMORY:
1628                 return "memory allocation failure";
1629         case EVUTIL_EAI_NODATA:
1630                 return "no address associated with nodename";
1631         case EVUTIL_EAI_NONAME:
1632                 return "nodename nor servname provided, or not known";
1633         case EVUTIL_EAI_SERVICE:
1634                 return "servname not supported for ai_socktype";
1635         case EVUTIL_EAI_SOCKTYPE:
1636                 return "ai_socktype not supported";
1637         case EVUTIL_EAI_SYSTEM:
1638                 return "system error";
1639         default:
1640 #if defined(USE_NATIVE_GETADDRINFO) && defined(_WIN32)
1641                 return gai_strerrorA(err);
1642 #elif defined(USE_NATIVE_GETADDRINFO)
1643                 return gai_strerror(err);
1644 #else
1645                 return "Unknown error code";
1646 #endif
1647         }
1648 }
1649
1650 #ifdef _WIN32
1651 /* destructively remove a trailing line terminator from s */
1652 static void
1653 chomp (char *s)
1654 {
1655         size_t len;
1656         if (s && (len = strlen (s)) > 0 && s[len - 1] == '\n') {
1657                 s[--len] = 0;
1658                 if (len > 0 && s[len - 1] == '\r')
1659                         s[--len] = 0;
1660         }
1661 }
1662
1663 /* FormatMessage returns allocated strings, but evutil_socket_error_to_string
1664  * is supposed to return a string which is good indefinitely without having
1665  * to be freed.  To make this work without leaking memory, we cache the
1666  * string the first time FormatMessage is called on a particular error
1667  * code, and then return the cached string on subsequent calls with the
1668  * same code.  The strings aren't freed until libevent_global_shutdown
1669  * (or never).  We use a linked list to cache the errors, because we
1670  * only expect there to be a few dozen, and that should be fast enough.
1671  */
1672
1673 struct cached_sock_errs_entry {
1674         HT_ENTRY(cached_sock_errs_entry) node;
1675         DWORD code;
1676         char *msg; /* allocated with LocalAlloc; free with LocalFree */
1677 };
1678
1679 static inline unsigned
1680 hash_cached_sock_errs(const struct cached_sock_errs_entry *e)
1681 {
1682         /* Use Murmur3's 32-bit finalizer as an integer hash function */
1683         DWORD h = e->code;
1684         h ^= h >> 16;
1685         h *= 0x85ebca6b;
1686         h ^= h >> 13;
1687         h *= 0xc2b2ae35;
1688         h ^= h >> 16;
1689         return h;
1690 }
1691
1692 static inline int
1693 eq_cached_sock_errs(const struct cached_sock_errs_entry *a,
1694                     const struct cached_sock_errs_entry *b)
1695 {
1696         return a->code == b->code;
1697 }
1698
1699 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1700 static void *windows_socket_errors_lock_ = NULL;
1701 #endif
1702
1703 static HT_HEAD(cached_sock_errs_map, cached_sock_errs_entry)
1704      windows_socket_errors = HT_INITIALIZER();
1705
1706 HT_PROTOTYPE(cached_sock_errs_map,
1707              cached_sock_errs_entry,
1708              node,
1709              hash_cached_sock_errs,
1710              eq_cached_sock_errs);
1711
1712 HT_GENERATE(cached_sock_errs_map,
1713             cached_sock_errs_entry,
1714             node,
1715             hash_cached_sock_errs,
1716             eq_cached_sock_errs,
1717             0.5,
1718             mm_malloc,
1719             mm_realloc,
1720             mm_free);
1721
1722 /** Equivalent to strerror, but for windows socket errors. */
1723 const char *
1724 evutil_socket_error_to_string(int errcode)
1725 {
1726         struct cached_sock_errs_entry *errs, *newerr, find;
1727         char *msg = NULL;
1728
1729         EVLOCK_LOCK(windows_socket_errors_lock_, 0);
1730
1731         find.code = errcode;
1732         errs = HT_FIND(cached_sock_errs_map, &windows_socket_errors, &find);
1733         if (errs) {
1734                 msg = errs->msg;
1735                 goto done;
1736         }
1737
1738         if (0 != FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
1739                                FORMAT_MESSAGE_IGNORE_INSERTS |
1740                                FORMAT_MESSAGE_ALLOCATE_BUFFER,
1741                                NULL, errcode, 0, (char *)&msg, 0, NULL))
1742                 chomp (msg);    /* because message has trailing newline */
1743         else {
1744                 size_t len = 50;
1745                 /* use LocalAlloc because FormatMessage does */
1746                 msg = LocalAlloc(LMEM_FIXED, len);
1747                 if (!msg) {
1748                         msg = (char *)"LocalAlloc failed during Winsock error";
1749                         goto done;
1750                 }
1751                 evutil_snprintf(msg, len, "winsock error 0x%08x", errcode);
1752         }
1753
1754         newerr = (struct cached_sock_errs_entry *)
1755                 mm_malloc(sizeof (struct cached_sock_errs_entry));
1756
1757         if (!newerr) {
1758                 LocalFree(msg);
1759                 msg = (char *)"malloc failed during Winsock error";
1760                 goto done;
1761         }
1762
1763         newerr->code = errcode;
1764         newerr->msg = msg;
1765         HT_INSERT(cached_sock_errs_map, &windows_socket_errors, newerr);
1766
1767  done:
1768         EVLOCK_UNLOCK(windows_socket_errors_lock_, 0);
1769
1770         return msg;
1771 }
1772
1773 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1774 int
1775 evutil_global_setup_locks_(const int enable_locks)
1776 {
1777         EVTHREAD_SETUP_GLOBAL_LOCK(windows_socket_errors_lock_, 0);
1778         return 0;
1779 }
1780 #endif
1781
1782 static void
1783 evutil_free_sock_err_globals(void)
1784 {
1785         struct cached_sock_errs_entry **errs, *tofree;
1786
1787         for (errs = HT_START(cached_sock_errs_map, &windows_socket_errors)
1788                      ; errs; ) {
1789                 tofree = *errs;
1790                 errs = HT_NEXT_RMV(cached_sock_errs_map,
1791                                    &windows_socket_errors,
1792                                    errs);
1793                 LocalFree(tofree->msg);
1794                 mm_free(tofree);
1795         }
1796
1797         HT_CLEAR(cached_sock_errs_map, &windows_socket_errors);
1798
1799 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1800         if (windows_socket_errors_lock_ != NULL) {
1801                 EVTHREAD_FREE_LOCK(windows_socket_errors_lock_, 0);
1802                 windows_socket_errors_lock_ = NULL;
1803         }
1804 #endif
1805 }
1806
1807 #else
1808
1809 #ifndef EVENT__DISABLE_THREAD_SUPPORT
1810 int
1811 evutil_global_setup_locks_(const int enable_locks)
1812 {
1813         return 0;
1814 }
1815 #endif
1816
1817 static void
1818 evutil_free_sock_err_globals(void)
1819 {
1820 }
1821
1822 #endif
1823
1824 int
1825 evutil_snprintf(char *buf, size_t buflen, const char *format, ...)
1826 {
1827         int r;
1828         va_list ap;
1829         va_start(ap, format);
1830         r = evutil_vsnprintf(buf, buflen, format, ap);
1831         va_end(ap);
1832         return r;
1833 }
1834
1835 int
1836 evutil_vsnprintf(char *buf, size_t buflen, const char *format, va_list ap)
1837 {
1838         int r;
1839         if (!buflen)
1840                 return 0;
1841 #if defined(_MSC_VER) || defined(_WIN32)
1842         r = _vsnprintf(buf, buflen, format, ap);
1843         if (r < 0)
1844                 r = _vscprintf(format, ap);
1845 #elif defined(sgi)
1846         /* Make sure we always use the correct vsnprintf on IRIX */
1847         extern int      _xpg5_vsnprintf(char * __restrict,
1848                 __SGI_LIBC_NAMESPACE_QUALIFIER size_t,
1849                 const char * __restrict, /* va_list */ char *);
1850
1851         r = _xpg5_vsnprintf(buf, buflen, format, ap);
1852 #else
1853         r = vsnprintf(buf, buflen, format, ap);
1854 #endif
1855         buf[buflen-1] = '\0';
1856         return r;
1857 }
1858
1859 #define USE_INTERNAL_NTOP
1860 #define USE_INTERNAL_PTON
1861
1862 const char *
1863 evutil_inet_ntop(int af, const void *src, char *dst, size_t len)
1864 {
1865 #if defined(EVENT__HAVE_INET_NTOP) && !defined(USE_INTERNAL_NTOP)
1866         return inet_ntop(af, src, dst, len);
1867 #else
1868         if (af == AF_INET) {
1869                 const struct in_addr *in = src;
1870                 const ev_uint32_t a = ntohl(in->s_addr);
1871                 int r;
1872                 r = evutil_snprintf(dst, len, "%d.%d.%d.%d",
1873                     (int)(ev_uint8_t)((a>>24)&0xff),
1874                     (int)(ev_uint8_t)((a>>16)&0xff),
1875                     (int)(ev_uint8_t)((a>>8 )&0xff),
1876                     (int)(ev_uint8_t)((a    )&0xff));
1877                 if (r<0||(size_t)r>=len)
1878                         return NULL;
1879                 else
1880                         return dst;
1881 #ifdef AF_INET6
1882         } else if (af == AF_INET6) {
1883                 const struct in6_addr *addr = src;
1884                 char buf[64], *cp;
1885                 int longestGapLen = 0, longestGapPos = -1, i,
1886                         curGapPos = -1, curGapLen = 0;
1887                 ev_uint16_t words[8];
1888                 for (i = 0; i < 8; ++i) {
1889                         words[i] =
1890                             (((ev_uint16_t)addr->s6_addr[2*i])<<8) + addr->s6_addr[2*i+1];
1891                 }
1892                 if (words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 &&
1893                     words[4] == 0 && ((words[5] == 0 && words[6] && words[7]) ||
1894                         (words[5] == 0xffff))) {
1895                         /* This is an IPv4 address. */
1896                         if (words[5] == 0) {
1897                                 evutil_snprintf(buf, sizeof(buf), "::%d.%d.%d.%d",
1898                                     addr->s6_addr[12], addr->s6_addr[13],
1899                                     addr->s6_addr[14], addr->s6_addr[15]);
1900                         } else {
1901                                 evutil_snprintf(buf, sizeof(buf), "::%x:%d.%d.%d.%d", words[5],
1902                                     addr->s6_addr[12], addr->s6_addr[13],
1903                                     addr->s6_addr[14], addr->s6_addr[15]);
1904                         }
1905                         if (strlen(buf) > len)
1906                                 return NULL;
1907                         strlcpy(dst, buf, len);
1908                         return dst;
1909                 }
1910                 i = 0;
1911                 while (i < 8) {
1912                         if (words[i] == 0) {
1913                                 curGapPos = i++;
1914                                 curGapLen = 1;
1915                                 while (i<8 && words[i] == 0) {
1916                                         ++i; ++curGapLen;
1917                                 }
1918                                 if (curGapLen > longestGapLen) {
1919                                         longestGapPos = curGapPos;
1920                                         longestGapLen = curGapLen;
1921                                 }
1922                         } else {
1923                                 ++i;
1924                         }
1925                 }
1926                 if (longestGapLen<=1)
1927                         longestGapPos = -1;
1928
1929                 cp = buf;
1930                 for (i = 0; i < 8; ++i) {
1931                         if (words[i] == 0 && longestGapPos == i) {
1932                                 if (i == 0)
1933                                         *cp++ = ':';
1934                                 *cp++ = ':';
1935                                 while (i < 8 && words[i] == 0)
1936                                         ++i;
1937                                 --i; /* to compensate for loop increment. */
1938                         } else {
1939                                 evutil_snprintf(cp,
1940                                                                 sizeof(buf)-(cp-buf), "%x", (unsigned)words[i]);
1941                                 cp += strlen(cp);
1942                                 if (i != 7)
1943                                         *cp++ = ':';
1944                         }
1945                 }
1946                 *cp = '\0';
1947                 if (strlen(buf) > len)
1948                         return NULL;
1949                 strlcpy(dst, buf, len);
1950                 return dst;
1951 #endif
1952         } else {
1953                 return NULL;
1954         }
1955 #endif
1956 }
1957
1958 int
1959 evutil_inet_pton(int af, const char *src, void *dst)
1960 {
1961 #if defined(EVENT__HAVE_INET_PTON) && !defined(USE_INTERNAL_PTON)
1962         return inet_pton(af, src, dst);
1963 #else
1964         if (af == AF_INET) {
1965                 unsigned a,b,c,d;
1966                 char more;
1967                 struct in_addr *addr = dst;
1968                 if (sscanf(src, "%u.%u.%u.%u%c", &a,&b,&c,&d,&more) != 4)
1969                         return 0;
1970                 if (a > 255) return 0;
1971                 if (b > 255) return 0;
1972                 if (c > 255) return 0;
1973                 if (d > 255) return 0;
1974                 addr->s_addr = htonl((a<<24) | (b<<16) | (c<<8) | d);
1975                 return 1;
1976 #ifdef AF_INET6
1977         } else if (af == AF_INET6) {
1978                 struct in6_addr *out = dst;
1979                 ev_uint16_t words[8];
1980                 int gapPos = -1, i, setWords=0;
1981                 const char *dot = strchr(src, '.');
1982                 const char *eow; /* end of words. */
1983                 if (dot == src)
1984                         return 0;
1985                 else if (!dot)
1986                         eow = src+strlen(src);
1987                 else {
1988                         unsigned byte1,byte2,byte3,byte4;
1989                         char more;
1990                         for (eow = dot-1; eow >= src && EVUTIL_ISDIGIT_(*eow); --eow)
1991                                 ;
1992                         ++eow;
1993
1994                         /* We use "scanf" because some platform inet_aton()s are too lax
1995                          * about IPv4 addresses of the form "1.2.3" */
1996                         if (sscanf(eow, "%u.%u.%u.%u%c",
1997                                            &byte1,&byte2,&byte3,&byte4,&more) != 4)
1998                                 return 0;
1999
2000                         if (byte1 > 255 ||
2001                             byte2 > 255 ||
2002                             byte3 > 255 ||
2003                             byte4 > 255)
2004                                 return 0;
2005
2006                         words[6] = (byte1<<8) | byte2;
2007                         words[7] = (byte3<<8) | byte4;
2008                         setWords += 2;
2009                 }
2010
2011                 i = 0;
2012                 while (src < eow) {
2013                         if (i > 7)
2014                                 return 0;
2015                         if (EVUTIL_ISXDIGIT_(*src)) {
2016                                 char *next;
2017                                 long r = strtol(src, &next, 16);
2018                                 if (next > 4+src)
2019                                         return 0;
2020                                 if (next == src)
2021                                         return 0;
2022                                 if (r<0 || r>65536)
2023                                         return 0;
2024
2025                                 words[i++] = (ev_uint16_t)r;
2026                                 setWords++;
2027                                 src = next;
2028                                 if (*src != ':' && src != eow)
2029                                         return 0;
2030                                 ++src;
2031                         } else if (*src == ':' && i > 0 && gapPos==-1) {
2032                                 gapPos = i;
2033                                 ++src;
2034                         } else if (*src == ':' && i == 0 && src[1] == ':' && gapPos==-1) {
2035                                 gapPos = i;
2036                                 src += 2;
2037                         } else {
2038                                 return 0;
2039                         }
2040                 }
2041
2042                 if (setWords > 8 ||
2043                         (setWords == 8 && gapPos != -1) ||
2044                         (setWords < 8 && gapPos == -1))
2045                         return 0;
2046
2047                 if (gapPos >= 0) {
2048                         int nToMove = setWords - (dot ? 2 : 0) - gapPos;
2049                         int gapLen = 8 - setWords;
2050                         /* assert(nToMove >= 0); */
2051                         if (nToMove < 0)
2052                                 return -1; /* should be impossible */
2053                         memmove(&words[gapPos+gapLen], &words[gapPos],
2054                                         sizeof(ev_uint16_t)*nToMove);
2055                         memset(&words[gapPos], 0, sizeof(ev_uint16_t)*gapLen);
2056                 }
2057                 for (i = 0; i < 8; ++i) {
2058                         out->s6_addr[2*i  ] = words[i] >> 8;
2059                         out->s6_addr[2*i+1] = words[i] & 0xff;
2060                 }
2061
2062                 return 1;
2063 #endif
2064         } else {
2065                 return -1;
2066         }
2067 #endif
2068 }
2069
2070 int
2071 evutil_parse_sockaddr_port(const char *ip_as_string, struct sockaddr *out, int *outlen)
2072 {
2073         int port;
2074         char buf[128];
2075         const char *cp, *addr_part, *port_part;
2076         int is_ipv6;
2077         /* recognized formats are:
2078          * [ipv6]:port
2079          * ipv6
2080          * [ipv6]
2081          * ipv4:port
2082          * ipv4
2083          */
2084
2085         cp = strchr(ip_as_string, ':');
2086         if (*ip_as_string == '[') {
2087                 size_t len;
2088                 if (!(cp = strchr(ip_as_string, ']'))) {
2089                         return -1;
2090                 }
2091                 len = ( cp-(ip_as_string + 1) );
2092                 if (len > sizeof(buf)-1) {
2093                         return -1;
2094                 }
2095                 memcpy(buf, ip_as_string+1, len);
2096                 buf[len] = '\0';
2097                 addr_part = buf;
2098                 if (cp[1] == ':')
2099                         port_part = cp+2;
2100                 else
2101                         port_part = NULL;
2102                 is_ipv6 = 1;
2103         } else if (cp && strchr(cp+1, ':')) {
2104                 is_ipv6 = 1;
2105                 addr_part = ip_as_string;
2106                 port_part = NULL;
2107         } else if (cp) {
2108                 is_ipv6 = 0;
2109                 if (cp - ip_as_string > (int)sizeof(buf)-1) {
2110                         return -1;
2111                 }
2112                 memcpy(buf, ip_as_string, cp-ip_as_string);
2113                 buf[cp-ip_as_string] = '\0';
2114                 addr_part = buf;
2115                 port_part = cp+1;
2116         } else {
2117                 addr_part = ip_as_string;
2118                 port_part = NULL;
2119                 is_ipv6 = 0;
2120         }
2121
2122         if (port_part == NULL) {
2123                 port = 0;
2124         } else {
2125                 port = atoi(port_part);
2126                 if (port <= 0 || port > 65535) {
2127                         return -1;
2128                 }
2129         }
2130
2131         if (!addr_part)
2132                 return -1; /* Should be impossible. */
2133 #ifdef AF_INET6
2134         if (is_ipv6)
2135         {
2136                 struct sockaddr_in6 sin6;
2137                 memset(&sin6, 0, sizeof(sin6));
2138 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
2139                 sin6.sin6_len = sizeof(sin6);
2140 #endif
2141                 sin6.sin6_family = AF_INET6;
2142                 sin6.sin6_port = htons(port);
2143                 if (1 != evutil_inet_pton(AF_INET6, addr_part, &sin6.sin6_addr))
2144                         return -1;
2145                 if ((int)sizeof(sin6) > *outlen)
2146                         return -1;
2147                 memset(out, 0, *outlen);
2148                 memcpy(out, &sin6, sizeof(sin6));
2149                 *outlen = sizeof(sin6);
2150                 return 0;
2151         }
2152         else
2153 #endif
2154         {
2155                 struct sockaddr_in sin;
2156                 memset(&sin, 0, sizeof(sin));
2157 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
2158                 sin.sin_len = sizeof(sin);
2159 #endif
2160                 sin.sin_family = AF_INET;
2161                 sin.sin_port = htons(port);
2162                 if (1 != evutil_inet_pton(AF_INET, addr_part, &sin.sin_addr))
2163                         return -1;
2164                 if ((int)sizeof(sin) > *outlen)
2165                         return -1;
2166                 memset(out, 0, *outlen);
2167                 memcpy(out, &sin, sizeof(sin));
2168                 *outlen = sizeof(sin);
2169                 return 0;
2170         }
2171 }
2172
2173 const char *
2174 evutil_format_sockaddr_port_(const struct sockaddr *sa, char *out, size_t outlen)
2175 {
2176         char b[128];
2177         const char *res=NULL;
2178         int port;
2179         if (sa->sa_family == AF_INET) {
2180                 const struct sockaddr_in *sin = (const struct sockaddr_in*)sa;
2181                 res = evutil_inet_ntop(AF_INET, &sin->sin_addr,b,sizeof(b));
2182                 port = ntohs(sin->sin_port);
2183                 if (res) {
2184                         evutil_snprintf(out, outlen, "%s:%d", b, port);
2185                         return out;
2186                 }
2187         } else if (sa->sa_family == AF_INET6) {
2188                 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6*)sa;
2189                 res = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr,b,sizeof(b));
2190                 port = ntohs(sin6->sin6_port);
2191                 if (res) {
2192                         evutil_snprintf(out, outlen, "[%s]:%d", b, port);
2193                         return out;
2194                 }
2195         }
2196
2197         evutil_snprintf(out, outlen, "<addr with socktype %d>",
2198             (int)sa->sa_family);
2199         return out;
2200 }
2201
2202 int
2203 evutil_sockaddr_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2,
2204     int include_port)
2205 {
2206         int r;
2207         if (0 != (r = (sa1->sa_family - sa2->sa_family)))
2208                 return r;
2209
2210         if (sa1->sa_family == AF_INET) {
2211                 const struct sockaddr_in *sin1, *sin2;
2212                 sin1 = (const struct sockaddr_in *)sa1;
2213                 sin2 = (const struct sockaddr_in *)sa2;
2214                 if (sin1->sin_addr.s_addr < sin2->sin_addr.s_addr)
2215                         return -1;
2216                 else if (sin1->sin_addr.s_addr > sin2->sin_addr.s_addr)
2217                         return 1;
2218                 else if (include_port &&
2219                     (r = ((int)sin1->sin_port - (int)sin2->sin_port)))
2220                         return r;
2221                 else
2222                         return 0;
2223         }
2224 #ifdef AF_INET6
2225         else if (sa1->sa_family == AF_INET6) {
2226                 const struct sockaddr_in6 *sin1, *sin2;
2227                 sin1 = (const struct sockaddr_in6 *)sa1;
2228                 sin2 = (const struct sockaddr_in6 *)sa2;
2229                 if ((r = memcmp(sin1->sin6_addr.s6_addr, sin2->sin6_addr.s6_addr, 16)))
2230                         return r;
2231                 else if (include_port &&
2232                     (r = ((int)sin1->sin6_port - (int)sin2->sin6_port)))
2233                         return r;
2234                 else
2235                         return 0;
2236         }
2237 #endif
2238         return 1;
2239 }
2240
2241 /* Tables to implement ctypes-replacement EVUTIL_IS*() functions.  Each table
2242  * has 256 bits to look up whether a character is in some set or not.  This
2243  * fails on non-ASCII platforms, but so does every other place where we
2244  * take a char and write it onto the network.
2245  **/
2246 static const ev_uint32_t EVUTIL_ISALPHA_TABLE[8] =
2247   { 0, 0, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 };
2248 static const ev_uint32_t EVUTIL_ISALNUM_TABLE[8] =
2249   { 0, 0x3ff0000, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 };
2250 static const ev_uint32_t EVUTIL_ISSPACE_TABLE[8] = { 0x3e00, 0x1, 0, 0, 0, 0, 0, 0 };
2251 static const ev_uint32_t EVUTIL_ISXDIGIT_TABLE[8] =
2252   { 0, 0x3ff0000, 0x7e, 0x7e, 0, 0, 0, 0 };
2253 static const ev_uint32_t EVUTIL_ISDIGIT_TABLE[8] = { 0, 0x3ff0000, 0, 0, 0, 0, 0, 0 };
2254 static const ev_uint32_t EVUTIL_ISPRINT_TABLE[8] =
2255   { 0, 0xffffffff, 0xffffffff, 0x7fffffff, 0, 0, 0, 0x0 };
2256 static const ev_uint32_t EVUTIL_ISUPPER_TABLE[8] = { 0, 0, 0x7fffffe, 0, 0, 0, 0, 0 };
2257 static const ev_uint32_t EVUTIL_ISLOWER_TABLE[8] = { 0, 0, 0, 0x7fffffe, 0, 0, 0, 0 };
2258 /* Upper-casing and lowercasing tables to map characters to upper/lowercase
2259  * equivalents. */
2260 static const unsigned char EVUTIL_TOUPPER_TABLE[256] = {
2261   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
2262   16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
2263   32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
2264   48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
2265   64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
2266   80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,
2267   96,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,
2268   80,81,82,83,84,85,86,87,88,89,90,123,124,125,126,127,
2269   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
2270   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
2271   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
2272   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
2273   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
2274   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
2275   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
2276   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
2277 };
2278 static const unsigned char EVUTIL_TOLOWER_TABLE[256] = {
2279   0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
2280   16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,
2281   32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,
2282   48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
2283   64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
2284   112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,95,
2285   96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,
2286   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
2287   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
2288   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
2289   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
2290   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
2291   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
2292   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
2293   224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,
2294   240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
2295 };
2296
2297 #define IMPL_CTYPE_FN(name)                                             \
2298         int EVUTIL_##name##_(char c) {                                  \
2299                 ev_uint8_t u = c;                                       \
2300                 return !!(EVUTIL_##name##_TABLE[(u >> 5) & 7] & (1 << (u & 31))); \
2301         }
2302 IMPL_CTYPE_FN(ISALPHA)
2303 IMPL_CTYPE_FN(ISALNUM)
2304 IMPL_CTYPE_FN(ISSPACE)
2305 IMPL_CTYPE_FN(ISDIGIT)
2306 IMPL_CTYPE_FN(ISXDIGIT)
2307 IMPL_CTYPE_FN(ISPRINT)
2308 IMPL_CTYPE_FN(ISLOWER)
2309 IMPL_CTYPE_FN(ISUPPER)
2310
2311 char EVUTIL_TOLOWER_(char c)
2312 {
2313         return ((char)EVUTIL_TOLOWER_TABLE[(ev_uint8_t)c]);
2314 }
2315 char EVUTIL_TOUPPER_(char c)
2316 {
2317         return ((char)EVUTIL_TOUPPER_TABLE[(ev_uint8_t)c]);
2318 }
2319 int
2320 evutil_ascii_strcasecmp(const char *s1, const char *s2)
2321 {
2322         char c1, c2;
2323         while (1) {
2324                 c1 = EVUTIL_TOLOWER_(*s1++);
2325                 c2 = EVUTIL_TOLOWER_(*s2++);
2326                 if (c1 < c2)
2327                         return -1;
2328                 else if (c1 > c2)
2329                         return 1;
2330                 else if (c1 == 0)
2331                         return 0;
2332         }
2333 }
2334 int evutil_ascii_strncasecmp(const char *s1, const char *s2, size_t n)
2335 {
2336         char c1, c2;
2337         while (n--) {
2338                 c1 = EVUTIL_TOLOWER_(*s1++);
2339                 c2 = EVUTIL_TOLOWER_(*s2++);
2340                 if (c1 < c2)
2341                         return -1;
2342                 else if (c1 > c2)
2343                         return 1;
2344                 else if (c1 == 0)
2345                         return 0;
2346         }
2347         return 0;
2348 }
2349
2350 void
2351 evutil_rtrim_lws_(char *str)
2352 {
2353         char *cp;
2354
2355         if (str == NULL)
2356                 return;
2357
2358         if ((cp = strchr(str, '\0')) == NULL || (cp == str))
2359                 return;
2360
2361         --cp;
2362
2363         while (*cp == ' ' || *cp == '\t') {
2364                 *cp = '\0';
2365                 if (cp == str)
2366                         break;
2367                 --cp;
2368         }
2369 }
2370
2371 static int
2372 evutil_issetugid(void)
2373 {
2374 #ifdef EVENT__HAVE_ISSETUGID
2375         return issetugid();
2376 #else
2377
2378 #ifdef EVENT__HAVE_GETEUID
2379         if (getuid() != geteuid())
2380                 return 1;
2381 #endif
2382 #ifdef EVENT__HAVE_GETEGID
2383         if (getgid() != getegid())
2384                 return 1;
2385 #endif
2386         return 0;
2387 #endif
2388 }
2389
2390 const char *
2391 evutil_getenv_(const char *varname)
2392 {
2393         if (evutil_issetugid())
2394                 return NULL;
2395
2396         return getenv(varname);
2397 }
2398
2399 ev_uint32_t
2400 evutil_weakrand_seed_(struct evutil_weakrand_state *state, ev_uint32_t seed)
2401 {
2402         if (seed == 0) {
2403                 struct timeval tv;
2404                 evutil_gettimeofday(&tv, NULL);
2405                 seed = (ev_uint32_t)tv.tv_sec + (ev_uint32_t)tv.tv_usec;
2406 #ifdef _WIN32
2407                 seed += (ev_uint32_t) _getpid();
2408 #else
2409                 seed += (ev_uint32_t) getpid();
2410 #endif
2411         }
2412         state->seed = seed;
2413         return seed;
2414 }
2415
2416 ev_int32_t
2417 evutil_weakrand_(struct evutil_weakrand_state *state)
2418 {
2419         /* This RNG implementation is a linear congruential generator, with
2420          * modulus 2^31, multiplier 1103515245, and addend 12345.  It's also
2421          * used by OpenBSD, and by Glibc's TYPE_0 RNG.
2422          *
2423          * The linear congruential generator is not an industrial-strength
2424          * RNG!  It's fast, but it can have higher-order patterns.  Notably,
2425          * the low bits tend to have periodicity.
2426          */
2427         state->seed = ((state->seed) * 1103515245 + 12345) & 0x7fffffff;
2428         return (ev_int32_t)(state->seed);
2429 }
2430
2431 ev_int32_t
2432 evutil_weakrand_range_(struct evutil_weakrand_state *state, ev_int32_t top)
2433 {
2434         ev_int32_t divisor, result;
2435
2436         /* We can't just do weakrand() % top, since the low bits of the LCG
2437          * are less random than the high ones.  (Specifically, since the LCG
2438          * modulus is 2^N, every 2^m for m<N will divide the modulus, and so
2439          * therefore the low m bits of the LCG will have period 2^m.) */
2440         divisor = EVUTIL_WEAKRAND_MAX / top;
2441         do {
2442                 result = evutil_weakrand_(state) / divisor;
2443         } while (result >= top);
2444         return result;
2445 }
2446
2447 /**
2448  * Volatile pointer to memset: we use this to keep the compiler from
2449  * eliminating our call to memset.
2450  */
2451 void * (*volatile evutil_memset_volatile_)(void *, int, size_t) = memset;
2452
2453 void
2454 evutil_memclear_(void *mem, size_t len)
2455 {
2456         evutil_memset_volatile_(mem, 0, len);
2457 }
2458
2459 int
2460 evutil_sockaddr_is_loopback_(const struct sockaddr *addr)
2461 {
2462         static const char LOOPBACK_S6[16] =
2463             "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1";
2464         if (addr->sa_family == AF_INET) {
2465                 struct sockaddr_in *sin = (struct sockaddr_in *)addr;
2466                 return (ntohl(sin->sin_addr.s_addr) & 0xff000000) == 0x7f000000;
2467         } else if (addr->sa_family == AF_INET6) {
2468                 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
2469                 return !memcmp(sin6->sin6_addr.s6_addr, LOOPBACK_S6, 16);
2470         }
2471         return 0;
2472 }
2473
2474 int
2475 evutil_hex_char_to_int_(char c)
2476 {
2477         switch(c)
2478         {
2479                 case '0': return 0;
2480                 case '1': return 1;
2481                 case '2': return 2;
2482                 case '3': return 3;
2483                 case '4': return 4;
2484                 case '5': return 5;
2485                 case '6': return 6;
2486                 case '7': return 7;
2487                 case '8': return 8;
2488                 case '9': return 9;
2489                 case 'A': case 'a': return 10;
2490                 case 'B': case 'b': return 11;
2491                 case 'C': case 'c': return 12;
2492                 case 'D': case 'd': return 13;
2493                 case 'E': case 'e': return 14;
2494                 case 'F': case 'f': return 15;
2495         }
2496         return -1;
2497 }
2498
2499 #ifdef _WIN32
2500 HMODULE
2501 evutil_load_windows_system_library_(const TCHAR *library_name)
2502 {
2503   TCHAR path[MAX_PATH];
2504   unsigned n;
2505   n = GetSystemDirectory(path, MAX_PATH);
2506   if (n == 0 || n + _tcslen(library_name) + 2 >= MAX_PATH)
2507     return 0;
2508   _tcscat(path, TEXT("\\"));
2509   _tcscat(path, library_name);
2510   return LoadLibrary(path);
2511 }
2512 #endif
2513
2514 /* Internal wrapper around 'socket' to provide Linux-style support for
2515  * syscall-saving methods where available.
2516  *
2517  * In addition to regular socket behavior, you can use a bitwise or to set the
2518  * flags EVUTIL_SOCK_NONBLOCK and EVUTIL_SOCK_CLOEXEC in the 'type' argument,
2519  * to make the socket nonblocking or close-on-exec with as few syscalls as
2520  * possible.
2521  */
2522 evutil_socket_t
2523 evutil_socket_(int domain, int type, int protocol)
2524 {
2525         evutil_socket_t r;
2526 #if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
2527         r = socket(domain, type, protocol);
2528         if (r >= 0)
2529                 return r;
2530         else if ((type & (SOCK_NONBLOCK|SOCK_CLOEXEC)) == 0)
2531                 return -1;
2532 #endif
2533 #define SOCKET_TYPE_MASK (~(EVUTIL_SOCK_NONBLOCK|EVUTIL_SOCK_CLOEXEC))
2534         r = socket(domain, type & SOCKET_TYPE_MASK, protocol);
2535         if (r < 0)
2536                 return -1;
2537         if (type & EVUTIL_SOCK_NONBLOCK) {
2538                 if (evutil_fast_socket_nonblocking(r) < 0) {
2539                         evutil_closesocket(r);
2540                         return -1;
2541                 }
2542         }
2543         if (type & EVUTIL_SOCK_CLOEXEC) {
2544                 if (evutil_fast_socket_closeonexec(r) < 0) {
2545                         evutil_closesocket(r);
2546                         return -1;
2547                 }
2548         }
2549         return r;
2550 }
2551
2552 /* Internal wrapper around 'accept' or 'accept4' to provide Linux-style
2553  * support for syscall-saving methods where available.
2554  *
2555  * In addition to regular accept behavior, you can set one or more of flags
2556  * EVUTIL_SOCK_NONBLOCK and EVUTIL_SOCK_CLOEXEC in the 'flags' argument, to
2557  * make the socket nonblocking or close-on-exec with as few syscalls as
2558  * possible.
2559  */
2560 evutil_socket_t
2561 evutil_accept4_(evutil_socket_t sockfd, struct sockaddr *addr,
2562     ev_socklen_t *addrlen, int flags)
2563 {
2564         evutil_socket_t result;
2565 #if defined(EVENT__HAVE_ACCEPT4) && defined(SOCK_CLOEXEC) && defined(SOCK_NONBLOCK)
2566         result = accept4(sockfd, addr, addrlen, flags);
2567         if (result >= 0 || (errno != EINVAL && errno != ENOSYS)) {
2568                 /* A nonnegative result means that we succeeded, so return.
2569                  * Failing with EINVAL means that an option wasn't supported,
2570                  * and failing with ENOSYS means that the syscall wasn't
2571                  * there: in those cases we want to fall back.  Otherwise, we
2572                  * got a real error, and we should return. */
2573                 return result;
2574         }
2575 #endif
2576         result = accept(sockfd, addr, addrlen);
2577         if (result < 0)
2578                 return result;
2579
2580         if (flags & EVUTIL_SOCK_CLOEXEC) {
2581                 if (evutil_fast_socket_closeonexec(result) < 0) {
2582                         evutil_closesocket(result);
2583                         return -1;
2584                 }
2585         }
2586         if (flags & EVUTIL_SOCK_NONBLOCK) {
2587                 if (evutil_fast_socket_nonblocking(result) < 0) {
2588                         evutil_closesocket(result);
2589                         return -1;
2590                 }
2591         }
2592         return result;
2593 }
2594
2595 /* Internal function: Set fd[0] and fd[1] to a pair of fds such that writes on
2596  * fd[0] get read from fd[1].  Make both fds nonblocking and close-on-exec.
2597  * Return 0 on success, -1 on failure.
2598  */
2599 int
2600 evutil_make_internal_pipe_(evutil_socket_t fd[2])
2601 {
2602         /*
2603           Making the second socket nonblocking is a bit subtle, given that we
2604           ignore any EAGAIN returns when writing to it, and you don't usally
2605           do that for a nonblocking socket. But if the kernel gives us EAGAIN,
2606           then there's no need to add any more data to the buffer, since
2607           the main thread is already either about to wake up and drain it,
2608           or woken up and in the process of draining it.
2609         */
2610
2611 #if defined(EVENT__HAVE_PIPE2)
2612         if (pipe2(fd, O_NONBLOCK|O_CLOEXEC) == 0)
2613                 return 0;
2614 #endif
2615 #if defined(EVENT__HAVE_PIPE)
2616         if (pipe(fd) == 0) {
2617                 if (evutil_fast_socket_nonblocking(fd[0]) < 0 ||
2618                     evutil_fast_socket_nonblocking(fd[1]) < 0 ||
2619                     evutil_fast_socket_closeonexec(fd[0]) < 0 ||
2620                     evutil_fast_socket_closeonexec(fd[1]) < 0) {
2621                         close(fd[0]);
2622                         close(fd[1]);
2623                         fd[0] = fd[1] = -1;
2624                         return -1;
2625                 }
2626                 return 0;
2627         } else {
2628                 event_warn("%s: pipe", __func__);
2629         }
2630 #endif
2631
2632 #ifdef _WIN32
2633 #define LOCAL_SOCKETPAIR_AF AF_INET
2634 #else
2635 #define LOCAL_SOCKETPAIR_AF AF_UNIX
2636 #endif
2637         if (evutil_socketpair(LOCAL_SOCKETPAIR_AF, SOCK_STREAM, 0, fd) == 0) {
2638                 if (evutil_fast_socket_nonblocking(fd[0]) < 0 ||
2639                     evutil_fast_socket_nonblocking(fd[1]) < 0 ||
2640                     evutil_fast_socket_closeonexec(fd[0]) < 0 ||
2641                     evutil_fast_socket_closeonexec(fd[1]) < 0) {
2642                         evutil_closesocket(fd[0]);
2643                         evutil_closesocket(fd[1]);
2644                         fd[0] = fd[1] = -1;
2645                         return -1;
2646                 }
2647                 return 0;
2648         }
2649         fd[0] = fd[1] = -1;
2650         return -1;
2651 }
2652
2653 /* Wrapper around eventfd on systems that provide it.  Unlike the system
2654  * eventfd, it always supports EVUTIL_EFD_CLOEXEC and EVUTIL_EFD_NONBLOCK as
2655  * flags.  Returns -1 on error or if eventfd is not supported.
2656  */
2657 evutil_socket_t
2658 evutil_eventfd_(unsigned initval, int flags)
2659 {
2660 #if defined(EVENT__HAVE_EVENTFD) && defined(EVENT__HAVE_SYS_EVENTFD_H)
2661         int r;
2662 #if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
2663         r = eventfd(initval, flags);
2664         if (r >= 0 || flags == 0)
2665                 return r;
2666 #endif
2667         r = eventfd(initval, 0);
2668         if (r < 0)
2669                 return r;
2670         if (flags & EVUTIL_EFD_CLOEXEC) {
2671                 if (evutil_fast_socket_closeonexec(r) < 0) {
2672                         evutil_closesocket(r);
2673                         return -1;
2674                 }
2675         }
2676         if (flags & EVUTIL_EFD_NONBLOCK) {
2677                 if (evutil_fast_socket_nonblocking(r) < 0) {
2678                         evutil_closesocket(r);
2679                         return -1;
2680                 }
2681         }
2682         return r;
2683 #else
2684         return -1;
2685 #endif
2686 }
2687
2688 void
2689 evutil_free_globals_(void)
2690 {
2691         evutil_free_secure_rng_globals_();
2692         evutil_free_sock_err_globals();
2693 }