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