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