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