/*

 * 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"

#define _GNU_SOURCE

#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>

#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_ARPA_INET_H

#include <arpa/inet.h>

#endif

#ifndef _EVENT_HAVE_GETTIMEOFDAY

#include <sys/timeb.h>

#include <time.h>

#endif

#include <sys/stat.h>

#include "event2/util.h"

#include "util-internal.h"

#include "log-internal.h"

#include "mm-internal.h"

#include "strlcpy-internal.h"

#include "ipv6-internal.h"

#ifdef WIN32

#define open _open

#define read _read

#define close _close

#define fstat _fstati64

#define stat _stati64

#define mode_t int

#endif

int

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

{

	int fd;

#ifdef O_CLOEXEC

	flags |= O_CLOEXEC;

#endif

	if (flags & O_CREAT)

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

	else

		fd = open(pathname, flags);

	if (fd < 0)

		return -1;

#if !defined(O_CLOEXEC) && defined(FD_CLOEXEC)

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

		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;

	if (protocol

		|| (family != AF_INET

#ifdef AF_UNIX

		    && family != AF_UNIX

#endif

		)) {

		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;

	/* 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

	{

		u_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 (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {

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

			return -1;

		}

	}

#endif

	return 0;

}

int

evutil_make_listen_socket_reuseable(evutil_socket_t sock)

{

#ifndef 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_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 (fcntl(fd, F_SETFD, flags | 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

}

#ifndef _EVENT_HAVE_GETTIMEOFDAY

/* No gettimeofday; this muse be windows. */

int

evutil_gettimeofday(struct timeval *tv, struct timezone *tz)

{

	struct _timeb tb;

	if (tv == NULL)

		return -1;

	/* XXXX

	 * _ftime is not the greatest interface here; GetSystemTimeAsFileTime

	 * would give us better resolution, whereas something cobbled together

	 * with GetTickCount could maybe give us monotonic behavior.

	 *

	 * Either way, I think this value might be skewed to ignore the

	 * timezone, and just return local time.  That's not so good.

	 */

	_ftime(&tb);

	tv->tv_sec = (long) tb.time;

	tv->tv_usec = ((int) tb.millitm) * 1000;

	return 0;

}

#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, 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)

/* 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)

{

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

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

	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;

	char buf[128];

	if (have_checked_interfaces && !force_recheck)

		return 0;

	/* To check whether we have an interface open for a given protocol, we

	 * 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. */

		ev_uint32_t addr = ntohl(sin_out.sin_addr.s_addr);

		if (addr == 0 ||

		    EVUTIL_V4ADDR_IS_LOCALHOST(addr) ||

		    EVUTIL_V4ADDR_IS_CLASSD(addr)) {

			evutil_inet_ntop(AF_INET, &sin_out.sin_addr,

			    buf, sizeof(buf));

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

			 * link-local or unspecified address.  The host should

			 * never have given it to us; it could never connect

			 * to sin. */

			event_warnx("Got a strange local ipv4 address %s",buf);

		} else {

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

			had_ipv4_address = 1;

		}

	}

	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. */

		const unsigned char *addr =

		    (unsigned char*)sin6_out.sin6_addr.s6_addr;

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

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

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

			 * link-local or unspecified address.  The host should

			 * never have given it to us; it could never connect

			 * to sin6. */

			evutil_inet_ntop(AF_INET6, &sin6_out.sin6_addr,

			    buf, sizeof(buf));

			event_warnx("Got a strange local ipv6 address %s",buf);

		} else {

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

			had_ipv6_address = 1;

		}

	}

	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 {

				/* connect to ::1 */

				sin6.sin6_addr.s6_addr[15] = 1;

			}

			res6 = evutil_new_addrinfo((struct sockaddr*)&sin6,

			    sizeof(sin6), hints);

			if (!res6)

				return EVUTIL_EAI_MEMORY;

		}

		if (hints->ai_family != PF_INET6) { /* INET or UNSPEC */

			struct sockaddr_in sin;

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

			sin.sin_family = AF_INET;

			sin.sin_port = htons(port);

			if (hints->ai_flags & EVUTIL_AI_PASSIVE) {

				/* Bind to 0.0.0.0 */

			} else {

				/* connect to 127.0.0.1 */

				sin.sin_addr.s_addr = htonl(0x7f000001);

			}

			res4 = evutil_new_addrinfo((struct sockaddr*)&sin,

			    sizeof(sin), hints);

			if (!res4) {

				if (res6)

					evutil_freeaddrinfo(res6);

				return EVUTIL_EAI_MEMORY;

			}

		}

		*res = evutil_addrinfo_append(res4, res6);

		return 0;

	}

	/* If we can, we should try to parse the hostname without resolving