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