/*

* Copyright (c) 2007-2012 Niels Provos and Nick Mathewson

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. The name of the author may not be used to endorse or promote products

* derived from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "event2/event-config.h"

#include "evconfig-private.h"

#ifdef _WIN32

#include <winsock2.h>

#include <ws2tcpip.h>

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#undef WIN32_LEAN_AND_MEAN

#include <io.h>

#include <tchar.h>

#include <process.h>

#undef _WIN32_WINNT

/* For structs needed by GetAdaptersAddresses */

#define _WIN32_WINNT 0x0501

#include <iphlpapi.h>

#endif

#include <sys/types.h>

#ifdef EVENT__HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#ifdef EVENT__HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef EVENT__HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef EVENT__HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <string.h>

#ifdef EVENT__HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#ifdef EVENT__HAVE_NETINET_IN6_H

#include <netinet/in6.h>

#endif

#ifdef EVENT__HAVE_NETINET_TCP_H

#include <netinet/tcp.h>

#endif

#ifdef EVENT__HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#include <time.h>

#include <sys/stat.h>

#ifdef EVENT__HAVE_IFADDRS_H

#include <ifaddrs.h>

#endif

#include "event2/util.h"

#include "util-internal.h"

#include "log-internal.h"

#include "mm-internal.h"

#include "evthread-internal.h"

#include "strlcpy-internal.h"

#include "ipv6-internal.h"

#ifdef _WIN32

#define HT_NO_CACHE_HASH_VALUES

#include "ht-internal.h"

#define open _open

#define read _read

#define close _close

#ifndef fstat

#define fstat _fstati64

#endif

#ifndef stat

#define stat _stati64

#endif

#define mode_t int

#endif

int

evutil_open_closeonexec_(const char *pathname, int flags, unsigned mode)

{

int fd;

#ifdef O_CLOEXEC

fd = open(pathname, flags|O_CLOEXEC, (mode_t)mode);

if (fd >= 0 || errno == EINVAL)

return fd;

/* If we got an EINVAL, fall through and try without O_CLOEXEC */

#endif

fd = open(pathname, flags, (mode_t)mode);

if (fd < 0)

return -1;

#if defined(FD_CLOEXEC)

if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) {

close(fd);

return -1;

}

#endif

return fd;

}

/**

Read the contents of 'filename' into a newly allocated NUL-terminated

string. Set *content_out to hold this string, and *len_out to hold its

length (not including the appended NUL). If 'is_binary', open the file in

binary mode.

Returns 0 on success, -1 if the open fails, and -2 for all other failures.

Used internally only; may go away in a future version.

*/

int

evutil_read_file_(const char *filename, char **content_out, size_t *len_out,

int is_binary)

{

int fd, r;

struct stat st;

char *mem;

size_t read_so_far=0;

int mode = O_RDONLY;

EVUTIL_ASSERT(content_out);

EVUTIL_ASSERT(len_out);

*content_out = NULL;

*len_out = 0;

#ifdef O_BINARY

if (is_binary)

mode |= O_BINARY;

#endif

fd = evutil_open_closeonexec_(filename, mode, 0);

if (fd < 0)

return -1;

if (fstat(fd, &st) || st.st_size < 0 ||

st.st_size > EV_SSIZE_MAX-1 ) {

close(fd);

return -2;

}

mem = mm_malloc((size_t)st.st_size 1);

if (!mem) {

close(fd);

return -2;

}

read_so_far = 0;

#ifdef _WIN32

#define N_TO_READ(x) ((x) > INT_MAX) ? INT_MAX : ((int)(x))

#else

#define N_TO_READ(x) (x)

#endif

while ((r = read(fd, mem read_so_far, N_TO_READ(st.st_size - read_so_far))) > 0) {

read_so_far = r;

if (read_so_far >= (size_t)st.st_size)

break;

EVUTIL_ASSERT(read_so_far < (size_t)st.st_size);

}

close(fd);

if (r < 0) {

mm_free(mem);

return -2;

}

mem[read_so_far] = 0;

*len_out = read_so_far;

*content_out = mem;

return 0;

}

int

evutil_socketpair(int family, int type, int protocol, evutil_socket_t fd[2])

{

#ifndef _WIN32

return socketpair(family, type, protocol, fd);

#else

return evutil_ersatz_socketpair_(family, type, protocol, fd);

#endif

}

int

evutil_ersatz_socketpair_(int family, int type, int protocol,

evutil_socket_t fd[2])

{

/* This code is originally from Tor. Used with permission. */

/* This socketpair does not work when localhost is down. So

* it's really not the same thing at all. But it's close enough

* for now, and really, when localhost is down sometimes, we

* have other problems too.

*/

#ifdef _WIN32

#define ERR(e) WSA##e

#else

#define ERR(e) e

#endif

evutil_socket_t listener = -1;

evutil_socket_t connector = -1;

evutil_socket_t acceptor = -1;

struct sockaddr_in listen_addr;

struct sockaddr_in connect_addr;

ev_socklen_t size;

int saved_errno = -1;

int family_test;

family_test = family != AF_INET;

#ifdef AF_UNIX

family_test = family_test && (family != AF_UNIX);

#endif

if (protocol || family_test) {

EVUTIL_SET_SOCKET_ERROR(ERR(EAFNOSUPPORT));

return -1;

}

if (!fd) {

EVUTIL_SET_SOCKET_ERROR(ERR(EINVAL));

return -1;

}

listener = socket(AF_INET, type, 0);

if (listener < 0)

return -1;

memset(&listen_addr, 0, sizeof(listen_addr));

listen_addr.sin_family = AF_INET;

listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

listen_addr.sin_port = 0; /* kernel chooses port. */

if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr))

== -1)

goto tidy_up_and_fail;

if (listen(listener, 1) == -1)

goto tidy_up_and_fail;

connector = socket(AF_INET, type, 0);

if (connector < 0)

goto tidy_up_and_fail;

memset(&connect_addr, 0, sizeof(connect_addr));

/* We want to find out the port number to connect to. */

size = sizeof(connect_addr);

if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)

goto tidy_up_and_fail;

if (size != sizeof (connect_addr))

goto abort_tidy_up_and_fail;

if (connect(connector, (struct sockaddr *) &connect_addr,

sizeof(connect_addr)) == -1)

goto tidy_up_and_fail;

size = sizeof(listen_addr);

acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);

if (acceptor < 0)

goto tidy_up_and_fail;

if (size != sizeof(listen_addr))

goto abort_tidy_up_and_fail;

/* Now check we are talking to ourself by matching port and host on the

two sockets. */

if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)

goto tidy_up_and_fail;

if (size != sizeof (connect_addr)

|| listen_addr.sin_family != connect_addr.sin_family

|| listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr

|| listen_addr.sin_port != connect_addr.sin_port)

goto abort_tidy_up_and_fail;

evutil_closesocket(listener);

fd[0] = connector;

fd[1] = acceptor;

return 0;

abort_tidy_up_and_fail:

saved_errno = ERR(ECONNABORTED);

tidy_up_and_fail:

if (saved_errno < 0)

saved_errno = EVUTIL_SOCKET_ERROR();

if (listener != -1)

evutil_closesocket(listener);

if (connector != -1)

evutil_closesocket(connector);

if (acceptor != -1)

evutil_closesocket(acceptor);

EVUTIL_SET_SOCKET_ERROR(saved_errno);

return -1;

#undef ERR

}

int

evutil_make_socket_nonblocking(evutil_socket_t fd)

{

#ifdef _WIN32

{

unsigned long nonblocking = 1;

if (ioctlsocket(fd, FIONBIO, &nonblocking) == SOCKET_ERROR) {

event_sock_warn(fd, "fcntl(%d, F_GETFL)", (int)fd);

return -1;

}

}

#else

{

int flags;

if ((flags = fcntl(fd, F_GETFL, NULL)) < 0) {

event_warn("fcntl(%d, F_GETFL)", fd);

return -1;

}

if (!(flags & O_NONBLOCK)) {

if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {

event_warn("fcntl(%d, F_SETFL)", fd);

return -1;

}

}

}

#endif

return 0;

}

/* Faster version of evutil_make_socket_nonblocking for internal use.

*

* Requires that no F_SETFL flags were previously set on the fd.

*/

static int

evutil_fast_socket_nonblocking(evutil_socket_t fd)

{

#ifdef _WIN32

return evutil_make_socket_nonblocking(fd);

#else

if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {

event_warn("fcntl(%d, F_SETFL)", fd);

return -1;

}

return 0;

#endif

}

int

evutil_make_listen_socket_reuseable(evutil_socket_t sock)

{

#if defined(SO_REUSEADDR) && !defined(_WIN32)

int one = 1;

/* REUSEADDR on Unix means, "don't hang on to this address after the

* listener is closed." On Windows, though, it means "don't keep other

* processes from binding to this address while we're using it. */

return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*) &one,

(ev_socklen_t)sizeof(one));

#else

return 0;

#endif

}

int

evutil_make_listen_socket_reuseable_port(evutil_socket_t sock)

{

#if defined __linux__ && defined(SO_REUSEPORT)

int one = 1;

/* REUSEPORT on Linux 3.9 means, "Multiple servers (processes or

* threads) can bind to the same port if they each set the option. */

return setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (void*) &one,

(ev_socklen_t)sizeof(one));

#else

return 0;

#endif

}

int

evutil_make_tcp_listen_socket_deferred(evutil_socket_t sock)

{

#if defined(EVENT__HAVE_NETINET_TCP_H) && defined(TCP_DEFER_ACCEPT)

int one = 1;

/* TCP_DEFER_ACCEPT tells the kernel to call defer accept() only after data

* has arrived and ready to read */

return setsockopt(sock, IPPROTO_TCP, TCP_DEFER_ACCEPT, &one,

(ev_socklen_t)sizeof(one));

#endif

return 0;

}

int

evutil_make_socket_closeonexec(evutil_socket_t fd)

{

#if !defined(_WIN32) && defined(EVENT__HAVE_SETFD)

int flags;

if ((flags = fcntl(fd, F_GETFD, NULL)) < 0) {

event_warn("fcntl(%d, F_GETFD)", fd);

return -1;

}

if (!(flags & FD_CLOEXEC)) {

if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) {

event_warn("fcntl(%d, F_SETFD)", fd);

return -1;

}

}

#endif

return 0;

}

/* Faster version of evutil_make_socket_closeonexec for internal use.

*

* Requires that no F_SETFD flags were previously set on the fd.

*/

static int

evutil_fast_socket_closeonexec(evutil_socket_t fd)

{

#if !defined(_WIN32) && defined(EVENT__HAVE_SETFD)

if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {

event_warn("fcntl(%d, F_SETFD)", fd);

return -1;

}

#endif

return 0;

}

int

evutil_closesocket(evutil_socket_t sock)

{

#ifndef _WIN32

return close(sock);

#else

return closesocket(sock);

#endif

}

ev_int64_t

evutil_strtoll(const char *s, char **endptr, int base)

{

#ifdef EVENT__HAVE_STRTOLL

return (ev_int64_t)strtoll(s, endptr, base);

#elif EVENT__SIZEOF_LONG == 8

return (ev_int64_t)strtol(s, endptr, base);

#elif defined(_WIN32) && defined(_MSC_VER) && _MSC_VER < 1300

/* XXXX on old versions of MS APIs, we only support base

* 10. */

ev_int64_t r;

if (base != 10)

return 0;

r = (ev_int64_t) _atoi64(s);

while (isspace(*s))

s;

if (*s == '-')

s;

while (isdigit(*s))

s;

if (endptr)

*endptr = (char*) s;

return r;

#elif defined(_WIN32)

return (ev_int64_t) _strtoi64(s, endptr, base);

#elif defined(EVENT__SIZEOF_LONG_LONG) && EVENT__SIZEOF_LONG_LONG == 8

long long r;

int n;

if (base != 10 && base != 16)

return 0;

if (base == 10) {

n = sscanf(s, "%lld", &r);

} else {

unsigned long long ru=0;

n = sscanf(s, "%llx", &ru);

if (ru > EV_INT64_MAX)

return 0;

r = (long long) ru;

}

if (n != 1)

return 0;

while (EVUTIL_ISSPACE_(*s))

s;

if (*s == '-')

s;

if (base == 10) {

while (EVUTIL_ISDIGIT_(*s))

s;

} else {

while (EVUTIL_ISXDIGIT_(*s))

s;

}

if (endptr)

*endptr = (char*) s;

return r;

#else

#error "I don't know how to parse 64-bit integers."

#endif

}

#ifdef _WIN32

int

evutil_socket_geterror(evutil_socket_t sock)

{

int optval, optvallen=sizeof(optval);

int err = WSAGetLastError();

if (err == WSAEWOULDBLOCK && sock >= 0) {

if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval,

&optvallen))

return err;

if (optval)

return optval;

}

return err;

}

#endif

/* XXX we should use an enum here. */

/* 2 for connection refused, 1 for connected, 0 for not yet, -1 for error. */

int

evutil_socket_connect_(evutil_socket_t *fd_ptr, const struct sockaddr *sa, int socklen)

{

int made_fd = 0;

if (*fd_ptr < 0) {

if ((*fd_ptr = socket(sa->sa_family, SOCK_STREAM, 0)) < 0)

goto err;

made_fd = 1;

if (evutil_make_socket_nonblocking(*fd_ptr) < 0) {

goto err;

}

}

if (connect(*fd_ptr, sa, socklen) < 0) {

int e = evutil_socket_geterror(*fd_ptr);

if (EVUTIL_ERR_CONNECT_RETRIABLE(e))

return 0;

if (EVUTIL_ERR_CONNECT_REFUSED(e))

return 2;

goto err;

} else {

return 1;

}

err:

if (made_fd) {

evutil_closesocket(*fd_ptr);

*fd_ptr = -1;

}

return -1;

}

/* Check whether a socket on which we called connect() is done

connecting. Return 1 for connected, 0 for not yet, -1 for error. In the

error case, set the current socket errno to the error that happened during

the connect operation. */

int

evutil_socket_finished_connecting_(evutil_socket_t fd)

{

int e;

ev_socklen_t elen = sizeof(e);

if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0)

return -1;

if (e) {

if (EVUTIL_ERR_CONNECT_RETRIABLE(e))

return 0;

EVUTIL_SET_SOCKET_ERROR(e);

return -1;

}

return 1;

}

#if (EVUTIL_AI_PASSIVE|EVUTIL_AI_CANONNAME|EVUTIL_AI_NUMERICHOST| \

EVUTIL_AI_NUMERICSERV|EVUTIL_AI_V4MAPPED|EVUTIL_AI_ALL| \

EVUTIL_AI_ADDRCONFIG) != \

(EVUTIL_AI_PASSIVE^EVUTIL_AI_CANONNAME^EVUTIL_AI_NUMERICHOST^ \

EVUTIL_AI_NUMERICSERV^EVUTIL_AI_V4MAPPED^EVUTIL_AI_ALL^ \

EVUTIL_AI_ADDRCONFIG)

#error "Some of our EVUTIL_AI_* flags seem to overlap with system AI_* flags"

#endif

/* We sometimes need to know whether we have an ipv4 address and whether we

have an ipv6 address. If 'have_checked_interfaces', then we've already done

the test. If 'had_ipv4_address', then it turns out we had an ipv4 address.

If 'had_ipv6_address', then it turns out we had an ipv6 address. These are

set by evutil_check_interfaces. */

static int have_checked_interfaces, had_ipv4_address, had_ipv6_address;

/* Macro: True iff the IPv4 address 'addr', in host order, is in 127.0.0.0/8

*/

#define EVUTIL_V4ADDR_IS_LOCALHOST(addr) (((addr)>>24) == 127)

/* Macro: True iff the IPv4 address 'addr', in host order, is a class D

* (multiclass) address.

*/

#define EVUTIL_V4ADDR_IS_CLASSD(addr) ((((addr)>>24) & 0xf0) == 0xe0)

static void

evutil_found_ifaddr(const struct sockaddr *sa)

{

const char ZEROES[] = "\x00\x00\x00\x00\x00\x00\x00\x00"

"\x00\x00\x00\x00\x00\x00\x00\x00";

if (sa->sa_family == AF_INET) {

const struct sockaddr_in *sin = (struct sockaddr_in *)sa;

ev_uint32_t addr = ntohl(sin->sin_addr.s_addr);

if (addr == 0 ||

EVUTIL_V4ADDR_IS_LOCALHOST(addr) ||

EVUTIL_V4ADDR_IS_CLASSD(addr)) {

/* Not actually a usable external address. */

} else {

event_debug(("Detected an IPv4 interface"));

had_ipv4_address = 1;

}

} else if (sa->sa_family == AF_INET6) {

const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

const unsigned char *addr =

(unsigned char*)sin6->sin6_addr.s6_addr;

if (!memcmp(addr, ZEROES, 8) ||

((addr[0] & 0xfe) == 0xfc) ||

(addr[0] == 0xfe && (addr[1] & 0xc0) == 0x80) ||

(addr[0] == 0xfe && (addr[1] & 0xc0) == 0xc0) ||

(addr[0] == 0xff)) {

/* This is a reserved, ipv4compat, ipv4map, loopback,

* link-local, multicast, or unspecified address. */

} else {

event_debug(("Detected an IPv6 interface"));

had_ipv6_address = 1;

}

}

}

#ifdef _WIN32

typedef ULONG (WINAPI *GetAdaptersAddresses_fn_t)(

ULONG, ULONG, PVOID, PIP_ADAPTER_ADDRESSES, PULONG);

#endif

static int

evutil_check_ifaddrs(void)

{

#if defined(EVENT__HAVE_GETIFADDRS)

/* Most free Unixy systems provide getifaddrs, which gives us a linked list

* of struct ifaddrs. */

struct ifaddrs *ifa = NULL;

const struct ifaddrs *i;

if (getifaddrs(&ifa) < 0) {

event_warn("Unable to call getifaddrs()");

return -1;

}

for (i = ifa; i; i = i->ifa_next) {

if (!i->ifa_addr)

continue;

evutil_found_ifaddr(i->ifa_addr);

}

freeifaddrs(ifa);

return 0;

#elif defined(_WIN32)

/* Windows XP began to provide GetAdaptersAddresses. Windows 2000 had a

"GetAdaptersInfo", but that's deprecated; let's just try

GetAdaptersAddresses and fall back to connect getsockname.

*/

HMODULE lib = evutil_load_windows_system_library_(TEXT("ihplapi.dll"));

GetAdaptersAddresses_fn_t fn;

ULONG size, res;

IP_ADAPTER_ADDRESSES *addresses = NULL, *address;

int result = -1;

#define FLAGS (GAA_FLAG_SKIP_ANYCAST | \

if (!lib)

goto done;

if (!(fn = (GetAdaptersAddresses_fn_t) GetProcAddress(lib, "GetAdaptersAddresses")))

goto done;

/* Guess how much space we need. */

size = 15*1024;

addresses = mm_malloc(size);

if (!addresses)

goto done;

res = fn(AF_UNSPEC, FLAGS, NULL, addresses, &size);

if (res == ERROR_BUFFER_OVERFLOW) {

/* we didn't guess that we needed enough space; try again */

mm_free(addresses);

addresses = mm_malloc(size);

if (!addresses)

goto done;

res = fn(AF_UNSPEC, FLAGS, NULL, addresses, &size);

}

if (res != NO_ERROR)

goto done;

for (address = addresses; address; address = address->Next) {

IP_ADAPTER_UNICAST_ADDRESS *a;

for (a = address->FirstUnicastAddress; a; a = a->Next) {

/* Yes, it's a linked list inside a linked list */

struct sockaddr *sa = a->Address.lpSockaddr;

evutil_found_ifaddr(sa);

}

}

result = 0;

done:

if (lib)

FreeLibrary(lib);

if (addresses)

mm_free(addresses);

return result;

#else

return -1;

#endif

}

/* Test whether we have an ipv4 interface and an ipv6 interface. Return 0 if

* the test seemed successful. */

static int

evutil_check_interfaces(int force_recheck)

{

evutil_socket_t fd = -1;

struct sockaddr_in sin, sin_out;

struct sockaddr_in6 sin6, sin6_out;

ev_socklen_t sin_out_len = sizeof(sin_out);

ev_socklen_t sin6_out_len = sizeof(sin6_out);

int r;

if (have_checked_interfaces && !force_recheck)

return 0;

if (evutil_check_ifaddrs() == 0) {

/* Use a nice sane interface, if this system has one. */

return 0;

}

/* Ugh. There was no nice sane interface. So to check whether we have

* an interface open for a given protocol, will try to make a UDP

* 'connection' to a remote host on the internet. We don't actually

* use it, so the address doesn't matter, but we want to pick one that

* keep us from using a host- or link-local interface. */

memset(&sin, 0, sizeof(sin));

sin.sin_family = AF_INET;

sin.sin_port = htons(53);

r = evutil_inet_pton(AF_INET, "18.244.0.188", &sin.sin_addr);

EVUTIL_ASSERT(r);

memset(&sin6, 0, sizeof(sin6));

sin6.sin6_family = AF_INET6;

sin6.sin6_port = htons(53);

r = evutil_inet_pton(AF_INET6, "2001:4860:b002::68", &sin6.sin6_addr);

EVUTIL_ASSERT(r);

memset(&sin_out, 0, sizeof(sin_out));

memset(&sin6_out, 0, sizeof(sin6_out));

/* XXX some errnos mean 'no address'; some mean 'not enough sockets'. */

if ((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) >= 0 &&

connect(fd, (struct sockaddr*)&sin, sizeof(sin)) == 0 &&

getsockname(fd, (struct sockaddr*)&sin_out, &sin_out_len) == 0) {

/* We might have an IPv4 interface. */

evutil_found_ifaddr((struct sockaddr*) &sin_out);

}

if (fd >= 0)

evutil_closesocket(fd);

if ((fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) >= 0 &&

connect(fd, (struct sockaddr*)&sin6, sizeof(sin6)) == 0 &&

getsockname(fd, (struct sockaddr*)&sin6_out, &sin6_out_len) == 0) {

/* We might have an IPv6 interface. */

evutil_found_ifaddr((struct sockaddr*) &sin6_out);

}

if (fd >= 0)

evutil_closesocket(fd);

return 0;

}

/* Internal addrinfo flag. This one is set when we allocate the addrinfo from

* inside libevent. Otherwise, the built-in getaddrinfo() function allocated

* it, and we should trust what they said.

**/

#define EVUTIL_AI_LIBEVENT_ALLOCATED 0x80000000

/* Helper: construct a new addrinfo containing the socket address in

* 'sa', which must be a sockaddr_in or a sockaddr_in6. Take the

* socktype and protocol info from hints. If they weren't set, then

* allocate both a TCP and a UDP addrinfo.

*/

struct evutil_addrinfo *

evutil_new_addrinfo_(struct sockaddr *sa, ev_socklen_t socklen,

const struct evutil_addrinfo *hints)

{

struct evutil_addrinfo *res;

EVUTIL_ASSERT(hints);

if (hints->ai_socktype == 0 && hints->ai_protocol == 0) {

/* Indecisive user! Give them a UDP and a TCP. */

struct evutil_addrinfo *r1, *r2;

struct evutil_addrinfo tmp;

memcpy(&tmp, hints, sizeof(tmp));

tmp.ai_socktype = SOCK_STREAM; tmp.ai_protocol = IPPROTO_TCP;

r1 = evutil_new_addrinfo_(sa, socklen, &tmp);

if (!r1)

return NULL;

tmp.ai_socktype = SOCK_DGRAM; tmp.ai_protocol = IPPROTO_UDP;

r2 = evutil_new_addrinfo_(sa, socklen, &tmp);

if (!r2) {

evutil_freeaddrinfo(r1);

return NULL;

}

r1->ai_next = r2;

return r1;

}

/* We're going to allocate extra space to hold the sockaddr. */

res = mm_calloc(1,sizeof(struct evutil_addrinfo) socklen);

if (!res)

return NULL;

res->ai_addr = (struct sockaddr*)

(((char*)res) sizeof(struct evutil_addrinfo));

memcpy(res->ai_addr, sa, socklen);

res->ai_addrlen = socklen;

res->ai_family = sa->sa_family; /* Same or not? XXX */

res->ai_flags = EVUTIL_AI_LIBEVENT_ALLOCATED;

res->ai_socktype = hints->ai_socktype;

res->ai_protocol = hints->ai_protocol;

return res;

}

/* Append the addrinfo 'append' to the end of 'first', and return the start of

* the list. Either element can be NULL, in which case we return the element

* that is not NULL. */

struct evutil_addrinfo *

evutil_addrinfo_append_(struct evutil_addrinfo *first,

struct evutil_addrinfo *append)

{

struct evutil_addrinfo *ai = first;

if (!ai)

return append;

while (ai->ai_next)

ai = ai->ai_next;

ai->ai_next = append;

return first;

}

static int

parse_numeric_servname(const char *servname)

{

int n;

char *endptr=NULL;

n = (int) strtol(servname, &endptr, 10);

if (n>=0 && n <= 65535 && servname[0] && endptr && !endptr[0])

return n;

else

return -1;

}

/** Parse a service name in 'servname', which can be a decimal port.

* Return the port number, or -1 on error.

*/

static int

evutil_parse_servname(const char *servname, const char *protocol,

const struct evutil_addrinfo *hints)

{

int n = parse_numeric_servname(servname);

if (n>=0)

return n;

#if defined(EVENT__HAVE_GETSERVBYNAME) || defined(_WIN32)

if (!(hints->ai_flags & EVUTIL_AI_NUMERICSERV)) {

struct servent *ent = getservbyname(servname, protocol);

if (ent) {

return ntohs(ent->s_port);

}

}

#endif

return -1;

}

/* Return a string corresponding to a protocol number that we can pass to

* getservyname. */

static const char *

evutil_unparse_protoname(int proto)

{

switch (proto) {

case 0:

return NULL;

case IPPROTO_TCP:

return "tcp";

case IPPROTO_UDP:

return "udp";

#ifdef IPPROTO_SCTP

case IPPROTO_SCTP:

return "sctp";

#endif

default:

#ifdef EVENT__HAVE_GETPROTOBYNUMBER

{

struct protoent *ent = getprotobynumber(proto);

if (ent)

return ent->p_name;

}

#endif

return NULL;

}

}

static void

evutil_getaddrinfo_infer_protocols(struct evutil_addrinfo *hints)

{

/* If we can guess the protocol from the socktype, do so. */

if (!hints->ai_protocol && hints->ai_socktype) {

if (hints->ai_socktype == SOCK_DGRAM)

hints->ai_protocol = IPPROTO_UDP;

else if (hints->ai_socktype == SOCK_STREAM)

hints->ai_protocol = IPPROTO_TCP;

}

/* Set the socktype if it isn't set. */

if (!hints->ai_socktype && hints->ai_protocol) {

if (hints->ai_protocol == IPPROTO_UDP)

hints->ai_socktype = SOCK_DGRAM;

else if (hints->ai_protocol == IPPROTO_TCP)

hints->ai_socktype = SOCK_STREAM;

#ifdef IPPROTO_SCTP

else if (hints->ai_protocol == IPPROTO_SCTP)

hints->ai_socktype = SOCK_STREAM;

#endif

}

}

#if AF_UNSPEC != PF_UNSPEC

#error "I cannot build on a system where AF_UNSPEC != PF_UNSPEC"

#endif

/** Implements the part of looking up hosts by name that's common to both

* the blocking and nonblocking resolver:

* - Adjust 'hints' to have a reasonable socktype and protocol.

* - Look up the port based on 'servname', and store it in *portnum,

* - Handle the nodename==NULL case

* - Handle some invalid arguments cases.

* - Handle the cases where nodename is an IPv4 or IPv6 address.

*

* If we need the resolver to look up the hostname, we return

* EVUTIL_EAI_NEED_RESOLVE. Otherwise, we can completely implement

* getaddrinfo: we return 0 or an appropriate EVUTIL_EAI_* error, and

* set *res as getaddrinfo would.

*/

int

evutil_getaddrinfo_common_(const char *nodename, const char *servname,

struct evutil_addrinfo *hints, struct evutil_addrinfo **res, int *portnum)

{

int port = 0;

const char *pname;

if (nodename == NULL && servname == NULL)

return EVUTIL_EAI_NONAME;

/* We only understand 3 families */

if (hints->ai_family != PF_UNSPEC && hints->ai_family != PF_INET &&

hints->ai_family != PF_INET6)

return EVUTIL_EAI_FAMILY;

evutil_getaddrinfo_infer_protocols(hints);

/* Look up the port number and protocol, if possible. */

pname = evutil_unparse_protoname(hints->ai_protocol);

if (servname) {

/* XXXX We could look at the protocol we got back from

* getservbyname, but it doesn't seem too useful. */

port = evutil_parse_servname(servname, pname, hints);

if (port < 0) {

return EVUTIL_EAI_NONAME;

}

}

/* If we have no node name, then we're supposed to bind to 'any' and

* connect to localhost. */

if (nodename == NULL) {

struct evutil_addrinfo *res4=NULL, *res6=NULL;

if (hints->ai_family != PF_INET) { /* INET6 or UNSPEC. */

struct sockaddr_in6 sin6;

memset(&sin6, 0, sizeof(sin6));

sin6.sin6_family = AF_INET6;

sin6.sin6_port = htons(port);

if (hints->ai_flags & EVUTIL_AI_PASSIVE) {

/* Bind to :: */

} else {