1 /* $NetBSD: evutil.c,v 1.4 2013/04/12 20:02:00 christos Exp $ */ 2 /* 3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "event2/event-config.h" 29 #include <sys/cdefs.h> 30 __RCSID("$NetBSD: evutil.c,v 1.4 2013/04/12 20:02:00 christos Exp $"); 31 32 #define _GNU_SOURCE 33 34 #ifdef WIN32 35 #include <winsock2.h> 36 #include <ws2tcpip.h> 37 #define WIN32_LEAN_AND_MEAN 38 #include <windows.h> 39 #undef WIN32_LEAN_AND_MEAN 40 #include <io.h> 41 #include <tchar.h> 42 #endif 43 44 #include <sys/types.h> 45 #ifdef _EVENT_HAVE_SYS_SOCKET_H 46 #include <sys/socket.h> 47 #endif 48 #ifdef _EVENT_HAVE_UNISTD_H 49 #include <unistd.h> 50 #endif 51 #ifdef _EVENT_HAVE_FCNTL_H 52 #include <fcntl.h> 53 #endif 54 #ifdef _EVENT_HAVE_STDLIB_H 55 #include <stdlib.h> 56 #endif 57 #include <errno.h> 58 #include <limits.h> 59 #include <stdio.h> 60 #include <string.h> 61 #ifdef _EVENT_HAVE_NETINET_IN_H 62 #include <netinet/in.h> 63 #endif 64 #ifdef _EVENT_HAVE_NETINET_IN6_H 65 #include <netinet/in6.h> 66 #endif 67 #ifdef _EVENT_HAVE_ARPA_INET_H 68 #include <arpa/inet.h> 69 #endif 70 71 #ifndef _EVENT_HAVE_GETTIMEOFDAY 72 #include <sys/timeb.h> 73 #include <time.h> 74 #endif 75 #include <sys/stat.h> 76 77 #include "event2/util.h" 78 #include "util-internal.h" 79 #include "log-internal.h" 80 #include "mm-internal.h" 81 82 #include "strlcpy-internal.h" 83 #include "ipv6-internal.h" 84 85 #ifdef WIN32 86 #define open _open 87 #define read _read 88 #define close _close 89 #define fstat _fstati64 90 #define stat _stati64 91 #define mode_t int 92 #endif 93 94 int 95 evutil_open_closeonexec(const char *pathname, int flags, unsigned mode) 96 { 97 int fd; 98 99 #ifdef O_CLOEXEC 100 flags |= O_CLOEXEC; 101 #endif 102 103 if (flags & O_CREAT) 104 fd = open(pathname, flags, (mode_t)mode); 105 else 106 fd = open(pathname, flags); 107 if (fd < 0) 108 return -1; 109 110 #if !defined(O_CLOEXEC) && defined(FD_CLOEXEC) 111 if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) 112 return -1; 113 #endif 114 115 return fd; 116 } 117 118 /** 119 Read the contents of 'filename' into a newly allocated NUL-terminated 120 string. Set *content_out to hold this string, and *len_out to hold its 121 length (not including the appended NUL). If 'is_binary', open the file in 122 binary mode. 123 124 Returns 0 on success, -1 if the open fails, and -2 for all other failures. 125 126 Used internally only; may go away in a future version. 127 */ 128 int 129 evutil_read_file(const char *filename, char **content_out, size_t *len_out, 130 int is_binary) 131 { 132 int fd, r; 133 struct stat st; 134 char *mem; 135 size_t read_so_far=0; 136 int mode = O_RDONLY; 137 138 EVUTIL_ASSERT(content_out); 139 EVUTIL_ASSERT(len_out); 140 *content_out = NULL; 141 *len_out = 0; 142 143 #ifdef O_BINARY 144 if (is_binary) 145 mode |= O_BINARY; 146 #endif 147 148 fd = evutil_open_closeonexec(filename, mode, 0); 149 if (fd < 0) 150 return -1; 151 if (fstat(fd, &st) || st.st_size < 0 || 152 st.st_size > EV_SSIZE_MAX-1 ) { 153 close(fd); 154 return -2; 155 } 156 mem = mm_malloc((size_t)st.st_size + 1); 157 if (!mem) { 158 close(fd); 159 return -2; 160 } 161 read_so_far = 0; 162 #ifdef WIN32 163 #define N_TO_READ(x) ((x) > INT_MAX) ? INT_MAX : ((int)(x)) 164 #else 165 #define N_TO_READ(x) (x) 166 #endif 167 while ((r = read(fd, mem+read_so_far, N_TO_READ(st.st_size - read_so_far))) > 0) { 168 read_so_far += r; 169 if (read_so_far >= (size_t)st.st_size) 170 break; 171 EVUTIL_ASSERT(read_so_far < (size_t)st.st_size); 172 } 173 close(fd); 174 if (r < 0) { 175 mm_free(mem); 176 return -2; 177 } 178 mem[read_so_far] = 0; 179 180 *len_out = read_so_far; 181 *content_out = mem; 182 return 0; 183 } 184 185 int 186 evutil_socketpair(int family, int type, int protocol, evutil_socket_t fd[2]) 187 { 188 #ifndef WIN32 189 return socketpair(family, type, protocol, fd); 190 #else 191 return evutil_ersatz_socketpair(family, type, protocol, fd); 192 #endif 193 } 194 195 int 196 evutil_ersatz_socketpair(int family, int type, int protocol, 197 evutil_socket_t fd[2]) 198 { 199 /* This code is originally from Tor. Used with permission. */ 200 201 /* This socketpair does not work when localhost is down. So 202 * it's really not the same thing at all. But it's close enough 203 * for now, and really, when localhost is down sometimes, we 204 * have other problems too. 205 */ 206 #ifdef WIN32 207 #define ERR(e) WSA##e 208 #else 209 #define ERR(e) e 210 #endif 211 evutil_socket_t listener = -1; 212 evutil_socket_t connector = -1; 213 evutil_socket_t acceptor = -1; 214 struct sockaddr_in listen_addr; 215 struct sockaddr_in connect_addr; 216 ev_socklen_t size; 217 int saved_errno = -1; 218 219 if (protocol 220 || (family != AF_INET 221 #ifdef AF_UNIX 222 && family != AF_UNIX 223 #endif 224 )) { 225 EVUTIL_SET_SOCKET_ERROR(ERR(EAFNOSUPPORT)); 226 return -1; 227 } 228 if (!fd) { 229 EVUTIL_SET_SOCKET_ERROR(ERR(EINVAL)); 230 return -1; 231 } 232 233 listener = socket(AF_INET, type, 0); 234 if (listener < 0) 235 return -1; 236 memset(&listen_addr, 0, sizeof(listen_addr)); 237 listen_addr.sin_family = AF_INET; 238 listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 239 listen_addr.sin_port = 0; /* kernel chooses port. */ 240 if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr)) 241 == -1) 242 goto tidy_up_and_fail; 243 if (listen(listener, 1) == -1) 244 goto tidy_up_and_fail; 245 246 connector = socket(AF_INET, type, 0); 247 if (connector < 0) 248 goto tidy_up_and_fail; 249 /* We want to find out the port number to connect to. */ 250 size = sizeof(connect_addr); 251 if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1) 252 goto tidy_up_and_fail; 253 if (size != sizeof (connect_addr)) 254 goto abort_tidy_up_and_fail; 255 if (connect(connector, (struct sockaddr *) &connect_addr, 256 sizeof(connect_addr)) == -1) 257 goto tidy_up_and_fail; 258 259 size = sizeof(listen_addr); 260 acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size); 261 if (acceptor < 0) 262 goto tidy_up_and_fail; 263 if (size != sizeof(listen_addr)) 264 goto abort_tidy_up_and_fail; 265 evutil_closesocket(listener); 266 /* Now check we are talking to ourself by matching port and host on the 267 two sockets. */ 268 if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1) 269 goto tidy_up_and_fail; 270 if (size != sizeof (connect_addr) 271 || listen_addr.sin_family != connect_addr.sin_family 272 || listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr 273 || listen_addr.sin_port != connect_addr.sin_port) 274 goto abort_tidy_up_and_fail; 275 fd[0] = connector; 276 fd[1] = acceptor; 277 278 return 0; 279 280 abort_tidy_up_and_fail: 281 saved_errno = ERR(ECONNABORTED); 282 tidy_up_and_fail: 283 if (saved_errno < 0) 284 saved_errno = EVUTIL_SOCKET_ERROR(); 285 if (listener != -1) 286 evutil_closesocket(listener); 287 if (connector != -1) 288 evutil_closesocket(connector); 289 if (acceptor != -1) 290 evutil_closesocket(acceptor); 291 292 EVUTIL_SET_SOCKET_ERROR(saved_errno); 293 return -1; 294 #undef ERR 295 } 296 297 int 298 evutil_make_socket_nonblocking(evutil_socket_t fd) 299 { 300 #ifdef WIN32 301 { 302 u_long nonblocking = 1; 303 if (ioctlsocket(fd, FIONBIO, &nonblocking) == SOCKET_ERROR) { 304 event_sock_warn(fd, "fcntl(%d, F_GETFL)", (int)fd); 305 return -1; 306 } 307 } 308 #else 309 { 310 int flags; 311 if ((flags = fcntl(fd, F_GETFL, NULL)) < 0) { 312 event_warn("fcntl(%d, F_GETFL)", fd); 313 return -1; 314 } 315 if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) { 316 event_warn("fcntl(%d, F_SETFL)", fd); 317 return -1; 318 } 319 } 320 #endif 321 return 0; 322 } 323 324 int 325 evutil_make_listen_socket_reuseable(evutil_socket_t sock) 326 { 327 #ifndef WIN32 328 int one = 1; 329 /* REUSEADDR on Unix means, "don't hang on to this address after the 330 * listener is closed." On Windows, though, it means "don't keep other 331 * processes from binding to this address while we're using it. */ 332 return setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*) &one, 333 (ev_socklen_t)sizeof(one)); 334 #else 335 return 0; 336 #endif 337 } 338 339 int 340 evutil_make_socket_closeonexec(evutil_socket_t fd) 341 { 342 #if !defined(WIN32) && defined(_EVENT_HAVE_SETFD) 343 int flags; 344 if ((flags = fcntl(fd, F_GETFD, NULL)) < 0) { 345 event_warn("fcntl(%d, F_GETFD)", fd); 346 return -1; 347 } 348 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { 349 event_warn("fcntl(%d, F_SETFD)", fd); 350 return -1; 351 } 352 #endif 353 return 0; 354 } 355 356 int 357 evutil_closesocket(evutil_socket_t sock) 358 { 359 #ifndef WIN32 360 return close(sock); 361 #else 362 return closesocket(sock); 363 #endif 364 } 365 366 ev_int64_t 367 evutil_strtoll(const char *s, char **endptr, int base) 368 { 369 #ifdef _EVENT_HAVE_STRTOLL 370 return (ev_int64_t)strtoll(s, endptr, base); 371 #elif _EVENT_SIZEOF_LONG == 8 372 return (ev_int64_t)strtol(s, endptr, base); 373 #elif defined(WIN32) && defined(_MSC_VER) && _MSC_VER < 1300 374 /* XXXX on old versions of MS APIs, we only support base 375 * 10. */ 376 ev_int64_t r; 377 if (base != 10) 378 return 0; 379 r = (ev_int64_t) _atoi64(s); 380 while (isspace(*s)) 381 ++s; 382 if (*s == '-') 383 ++s; 384 while (isdigit(*s)) 385 ++s; 386 if (endptr) 387 *endptr = (char*) s; 388 return r; 389 #elif defined(WIN32) 390 return (ev_int64_t) _strtoi64(s, endptr, base); 391 #elif defined(_EVENT_SIZEOF_LONG_LONG) && _EVENT_SIZEOF_LONG_LONG == 8 392 long long r; 393 int n; 394 if (base != 10 && base != 16) 395 return 0; 396 if (base == 10) { 397 n = sscanf(s, "%lld", &r); 398 } else { 399 unsigned long long ru=0; 400 n = sscanf(s, "%llx", &ru); 401 if (ru > EV_INT64_MAX) 402 return 0; 403 r = (long long) ru; 404 } 405 if (n != 1) 406 return 0; 407 while (EVUTIL_ISSPACE(*s)) 408 ++s; 409 if (*s == '-') 410 ++s; 411 if (base == 10) { 412 while (EVUTIL_ISDIGIT(*s)) 413 ++s; 414 } else { 415 while (EVUTIL_ISXDIGIT(*s)) 416 ++s; 417 } 418 if (endptr) 419 *endptr = (char*) s; 420 return r; 421 #else 422 #error "I don't know how to parse 64-bit integers." 423 #endif 424 } 425 426 #ifndef _EVENT_HAVE_GETTIMEOFDAY 427 /* No gettimeofday; this muse be windows. */ 428 int 429 evutil_gettimeofday(struct timeval *tv, struct timezone *tz) 430 { 431 struct _timeb tb; 432 433 if (tv == NULL) 434 return -1; 435 436 /* XXXX 437 * _ftime is not the greatest interface here; GetSystemTimeAsFileTime 438 * would give us better resolution, whereas something cobbled together 439 * with GetTickCount could maybe give us monotonic behavior. 440 * 441 * Either way, I think this value might be skewed to ignore the 442 * timezone, and just return local time. That's not so good. 443 */ 444 _ftime(&tb); 445 tv->tv_sec = (long) tb.time; 446 tv->tv_usec = ((int) tb.millitm) * 1000; 447 return 0; 448 } 449 #endif 450 451 #ifdef WIN32 452 int 453 evutil_socket_geterror(evutil_socket_t sock) 454 { 455 int optval, optvallen=sizeof(optval); 456 int err = WSAGetLastError(); 457 if (err == WSAEWOULDBLOCK && sock >= 0) { 458 if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&optval, 459 &optvallen)) 460 return err; 461 if (optval) 462 return optval; 463 } 464 return err; 465 } 466 #endif 467 468 /* XXX we should use an enum here. */ 469 /* 2 for connection refused, 1 for connected, 0 for not yet, -1 for error. */ 470 int 471 evutil_socket_connect(evutil_socket_t *fd_ptr, struct sockaddr *sa, int socklen) 472 { 473 int made_fd = 0; 474 475 if (*fd_ptr < 0) { 476 if ((*fd_ptr = socket(sa->sa_family, SOCK_STREAM, 0)) < 0) 477 goto err; 478 made_fd = 1; 479 if (evutil_make_socket_nonblocking(*fd_ptr) < 0) { 480 goto err; 481 } 482 } 483 484 if (connect(*fd_ptr, sa, socklen) < 0) { 485 int e = evutil_socket_geterror(*fd_ptr); 486 if (EVUTIL_ERR_CONNECT_RETRIABLE(e)) 487 return 0; 488 if (EVUTIL_ERR_CONNECT_REFUSED(e)) 489 return 2; 490 goto err; 491 } else { 492 return 1; 493 } 494 495 err: 496 if (made_fd) { 497 evutil_closesocket(*fd_ptr); 498 *fd_ptr = -1; 499 } 500 return -1; 501 } 502 503 /* Check whether a socket on which we called connect() is done 504 connecting. Return 1 for connected, 0 for not yet, -1 for error. In the 505 error case, set the current socket errno to the error that happened during 506 the connect operation. */ 507 int 508 evutil_socket_finished_connecting(evutil_socket_t fd) 509 { 510 int e; 511 ev_socklen_t elen = sizeof(e); 512 513 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&e, &elen) < 0) 514 return -1; 515 516 if (e) { 517 if (EVUTIL_ERR_CONNECT_RETRIABLE(e)) 518 return 0; 519 EVUTIL_SET_SOCKET_ERROR(e); 520 return -1; 521 } 522 523 return 1; 524 } 525 526 #if (EVUTIL_AI_PASSIVE|EVUTIL_AI_CANONNAME|EVUTIL_AI_NUMERICHOST| \ 527 EVUTIL_AI_NUMERICSERV|EVUTIL_AI_V4MAPPED|EVUTIL_AI_ALL| \ 528 EVUTIL_AI_ADDRCONFIG) != \ 529 (EVUTIL_AI_PASSIVE^EVUTIL_AI_CANONNAME^EVUTIL_AI_NUMERICHOST^ \ 530 EVUTIL_AI_NUMERICSERV^EVUTIL_AI_V4MAPPED^EVUTIL_AI_ALL^ \ 531 EVUTIL_AI_ADDRCONFIG) 532 #error "Some of our EVUTIL_AI_* flags seem to overlap with system AI_* flags" 533 #endif 534 535 /* We sometimes need to know whether we have an ipv4 address and whether we 536 have an ipv6 address. If 'have_checked_interfaces', then we've already done 537 the test. If 'had_ipv4_address', then it turns out we had an ipv4 address. 538 If 'had_ipv6_address', then it turns out we had an ipv6 address. These are 539 set by evutil_check_interfaces. */ 540 static int have_checked_interfaces, had_ipv4_address, had_ipv6_address; 541 542 /* Macro: True iff the IPv4 address 'addr', in host order, is in 127.0.0.0/8 543 */ 544 #define EVUTIL_V4ADDR_IS_LOCALHOST(addr) (((addr)>>24) == 127) 545 546 /* Macro: True iff the IPv4 address 'addr', in host order, is a class D 547 * (multiclass) address. 548 */ 549 #define EVUTIL_V4ADDR_IS_CLASSD(addr) ((((addr)>>24) & 0xf0) == 0xe0) 550 551 /* Test whether we have an ipv4 interface and an ipv6 interface. Return 0 if 552 * the test seemed successful. */ 553 static int 554 evutil_check_interfaces(int force_recheck) 555 { 556 const char ZEROES[] = "\x00\x00\x00\x00\x00\x00\x00\x00" 557 "\x00\x00\x00\x00\x00\x00\x00\x00"; 558 evutil_socket_t fd = -1; 559 struct sockaddr_in sin, sin_out; 560 struct sockaddr_in6 sin6, sin6_out; 561 ev_socklen_t sin_out_len = sizeof(sin_out); 562 ev_socklen_t sin6_out_len = sizeof(sin6_out); 563 int r; 564 char buf[128]; 565 if (have_checked_interfaces && !force_recheck) 566 return 0; 567 568 /* To check whether we have an interface open for a given protocol, we 569 * try to make a UDP 'connection' to a remote host on the internet. 570 * We don't actually use it, so the address doesn't matter, but we 571 * want to pick one that keep us from using a host- or link-local 572 * interface. */ 573 memset(&sin, 0, sizeof(sin)); 574 sin.sin_family = AF_INET; 575 sin.sin_port = htons(53); 576 r = evutil_inet_pton(AF_INET, "18.244.0.188", &sin.sin_addr); 577 EVUTIL_ASSERT(r); 578 579 memset(&sin6, 0, sizeof(sin6)); 580 sin6.sin6_family = AF_INET6; 581 sin6.sin6_port = htons(53); 582 r = evutil_inet_pton(AF_INET6, "2001:4860:b002::68", &sin6.sin6_addr); 583 EVUTIL_ASSERT(r); 584 585 memset(&sin_out, 0, sizeof(sin_out)); 586 memset(&sin6_out, 0, sizeof(sin6_out)); 587 588 /* XXX some errnos mean 'no address'; some mean 'not enough sockets'. */ 589 if ((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) >= 0 && 590 connect(fd, (struct sockaddr*)&sin, sizeof(sin)) == 0 && 591 getsockname(fd, (struct sockaddr*)&sin_out, &sin_out_len) == 0) { 592 /* We might have an IPv4 interface. */ 593 ev_uint32_t addr = ntohl(sin_out.sin_addr.s_addr); 594 if (addr == 0 || 595 EVUTIL_V4ADDR_IS_LOCALHOST(addr) || 596 EVUTIL_V4ADDR_IS_CLASSD(addr)) { 597 evutil_inet_ntop(AF_INET, &sin_out.sin_addr, 598 buf, sizeof(buf)); 599 /* This is a reserved, ipv4compat, ipv4map, loopback, 600 * link-local or unspecified address. The host should 601 * never have given it to us; it could never connect 602 * to sin. */ 603 event_warnx("Got a strange local ipv4 address %s",buf); 604 } else { 605 event_debug(("Detected an IPv4 interface")); 606 had_ipv4_address = 1; 607 } 608 } 609 if (fd >= 0) 610 evutil_closesocket(fd); 611 612 if ((fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) >= 0 && 613 connect(fd, (struct sockaddr*)&sin6, sizeof(sin6)) == 0 && 614 getsockname(fd, (struct sockaddr*)&sin6_out, &sin6_out_len) == 0) { 615 /* We might have an IPv6 interface. */ 616 const unsigned char *addr = 617 (unsigned char*)sin6_out.sin6_addr.s6_addr; 618 if (!memcmp(addr, ZEROES, 8) || 619 (addr[0] == 0xfe && (addr[1] & 0xc0) == 0x80)) { 620 /* This is a reserved, ipv4compat, ipv4map, loopback, 621 * link-local or unspecified address. The host should 622 * never have given it to us; it could never connect 623 * to sin6. */ 624 evutil_inet_ntop(AF_INET6, &sin6_out.sin6_addr, 625 buf, sizeof(buf)); 626 event_warnx("Got a strange local ipv6 address %s",buf); 627 } else { 628 event_debug(("Detected an IPv4 interface")); 629 had_ipv6_address = 1; 630 } 631 } 632 633 if (fd >= 0) 634 evutil_closesocket(fd); 635 636 return 0; 637 } 638 639 /* Internal addrinfo flag. This one is set when we allocate the addrinfo from 640 * inside libevent. Otherwise, the built-in getaddrinfo() function allocated 641 * it, and we should trust what they said. 642 **/ 643 #define EVUTIL_AI_LIBEVENT_ALLOCATED 0x80000000 644 645 /* Helper: construct a new addrinfo containing the socket address in 646 * 'sa', which must be a sockaddr_in or a sockaddr_in6. Take the 647 * socktype and protocol info from hints. If they weren't set, then 648 * allocate both a TCP and a UDP addrinfo. 649 */ 650 struct evutil_addrinfo * 651 evutil_new_addrinfo(struct sockaddr *sa, ev_socklen_t socklen, 652 const struct evutil_addrinfo *hints) 653 { 654 struct evutil_addrinfo *res; 655 EVUTIL_ASSERT(hints); 656 657 if (hints->ai_socktype == 0 && hints->ai_protocol == 0) { 658 /* Indecisive user! Give them a UDP and a TCP. */ 659 struct evutil_addrinfo *r1, *r2; 660 struct evutil_addrinfo tmp; 661 memcpy(&tmp, hints, sizeof(tmp)); 662 tmp.ai_socktype = SOCK_STREAM; tmp.ai_protocol = IPPROTO_TCP; 663 r1 = evutil_new_addrinfo(sa, socklen, &tmp); 664 if (!r1) 665 return NULL; 666 tmp.ai_socktype = SOCK_DGRAM; tmp.ai_protocol = IPPROTO_UDP; 667 r2 = evutil_new_addrinfo(sa, socklen, &tmp); 668 if (!r2) { 669 evutil_freeaddrinfo(r1); 670 return NULL; 671 } 672 r1->ai_next = r2; 673 return r1; 674 } 675 676 /* We're going to allocate extra space to hold the sockaddr. */ 677 res = mm_calloc(1,sizeof(struct evutil_addrinfo)+socklen); 678 if (!res) 679 return NULL; 680 res->ai_addr = (struct sockaddr*) 681 (((char*)res) + sizeof(struct evutil_addrinfo)); 682 memcpy(res->ai_addr, sa, socklen); 683 res->ai_addrlen = socklen; 684 res->ai_family = sa->sa_family; /* Same or not? XXX */ 685 res->ai_flags = EVUTIL_AI_LIBEVENT_ALLOCATED; 686 res->ai_socktype = hints->ai_socktype; 687 res->ai_protocol = hints->ai_protocol; 688 689 return res; 690 } 691 692 /* Append the addrinfo 'append' to the end of 'first', and return the start of 693 * the list. Either element can be NULL, in which case we return the element 694 * that is not NULL. */ 695 struct evutil_addrinfo * 696 evutil_addrinfo_append(struct evutil_addrinfo *first, 697 struct evutil_addrinfo *append) 698 { 699 struct evutil_addrinfo *ai = first; 700 if (!ai) 701 return append; 702 while (ai->ai_next) 703 ai = ai->ai_next; 704 ai->ai_next = append; 705 706 return first; 707 } 708 709 static int 710 parse_numeric_servname(const char *servname) 711 { 712 int n; 713 char *endptr=NULL; 714 n = (int) strtol(servname, &endptr, 10); 715 if (n>=0 && n <= 65535 && servname[0] && endptr && !endptr[0]) 716 return n; 717 else 718 return -1; 719 } 720 721 /** Parse a service name in 'servname', which can be a decimal port. 722 * Return the port number, or -1 on error. 723 */ 724 static int 725 evutil_parse_servname(const char *servname, const char *protocol, 726 const struct evutil_addrinfo *hints) 727 { 728 int n = parse_numeric_servname(servname); 729 if (n>=0) 730 return n; 731 #if defined(_EVENT_HAVE_GETSERVBYNAME) || defined(WIN32) 732 if (!(hints->ai_flags & EVUTIL_AI_NUMERICSERV)) { 733 struct servent *ent = getservbyname(servname, protocol); 734 if (ent) { 735 return ntohs(ent->s_port); 736 } 737 } 738 #endif 739 return -1; 740 } 741 742 /* Return a string corresponding to a protocol number that we can pass to 743 * getservyname. */ 744 static const char * 745 evutil_unparse_protoname(int proto) 746 { 747 switch (proto) { 748 case 0: 749 return NULL; 750 case IPPROTO_TCP: 751 return "tcp"; 752 case IPPROTO_UDP: 753 return "udp"; 754 #ifdef IPPROTO_SCTP 755 case IPPROTO_SCTP: 756 return "sctp"; 757 #endif 758 default: 759 #ifdef _EVENT_HAVE_GETPROTOBYNUMBER 760 { 761 struct protoent *ent = getprotobynumber(proto); 762 if (ent) 763 return ent->p_name; 764 } 765 #endif 766 return NULL; 767 } 768 } 769 770 static void 771 evutil_getaddrinfo_infer_protocols(struct evutil_addrinfo *hints) 772 { 773 /* If we can guess the protocol from the socktype, do so. */ 774 if (!hints->ai_protocol && hints->ai_socktype) { 775 if (hints->ai_socktype == SOCK_DGRAM) 776 hints->ai_protocol = IPPROTO_UDP; 777 else if (hints->ai_socktype == SOCK_STREAM) 778 hints->ai_protocol = IPPROTO_TCP; 779 } 780 781 /* Set the socktype if it isn't set. */ 782 if (!hints->ai_socktype && hints->ai_protocol) { 783 if (hints->ai_protocol == IPPROTO_UDP) 784 hints->ai_socktype = SOCK_DGRAM; 785 else if (hints->ai_protocol == IPPROTO_TCP) 786 hints->ai_socktype = SOCK_STREAM; 787 #ifdef IPPROTO_SCTP 788 else if (hints->ai_protocol == IPPROTO_SCTP) 789 hints->ai_socktype = SOCK_STREAM; 790 #endif 791 } 792 } 793 794 #if AF_UNSPEC != PF_UNSPEC 795 #error "I cannot build on a system where AF_UNSPEC != PF_UNSPEC" 796 #endif 797 798 /** Implements the part of looking up hosts by name that's common to both 799 * the blocking and nonblocking resolver: 800 * - Adjust 'hints' to have a reasonable socktype and protocol. 801 * - Look up the port based on 'servname', and store it in *portnum, 802 * - Handle the nodename==NULL case 803 * - Handle some invalid arguments cases. 804 * - Handle the cases where nodename is an IPv4 or IPv6 address. 805 * 806 * If we need the resolver to look up the hostname, we return 807 * EVUTIL_EAI_NEED_RESOLVE. Otherwise, we can completely implement 808 * getaddrinfo: we return 0 or an appropriate EVUTIL_EAI_* error, and 809 * set *res as getaddrinfo would. 810 */ 811 int 812 evutil_getaddrinfo_common(const char *nodename, const char *servname, 813 struct evutil_addrinfo *hints, struct evutil_addrinfo **res, int *portnum) 814 { 815 int port = 0; 816 const char *pname; 817 818 if (nodename == NULL && servname == NULL) 819 return EVUTIL_EAI_NONAME; 820 821 /* We only understand 3 families */ 822 if (hints->ai_family != PF_UNSPEC && hints->ai_family != PF_INET && 823 hints->ai_family != PF_INET6) 824 return EVUTIL_EAI_FAMILY; 825 826 evutil_getaddrinfo_infer_protocols(hints); 827 828 /* Look up the port number and protocol, if possible. */ 829 pname = evutil_unparse_protoname(hints->ai_protocol); 830 if (servname) { 831 /* XXXX We could look at the protocol we got back from 832 * getservbyname, but it doesn't seem too useful. */ 833 port = evutil_parse_servname(servname, pname, hints); 834 if (port < 0) { 835 return EVUTIL_EAI_NONAME; 836 } 837 } 838 839 /* If we have no node name, then we're supposed to bind to 'any' and 840 * connect to localhost. */ 841 if (nodename == NULL) { 842 struct evutil_addrinfo *res4=NULL, *res6=NULL; 843 if (hints->ai_family != PF_INET) { /* INET6 or UNSPEC. */ 844 struct sockaddr_in6 sin6; 845 memset(&sin6, 0, sizeof(sin6)); 846 sin6.sin6_family = AF_INET6; 847 sin6.sin6_port = htons(port); 848 if (hints->ai_flags & EVUTIL_AI_PASSIVE) { 849 /* Bind to :: */ 850 } else { 851 /* connect to ::1 */ 852 sin6.sin6_addr.s6_addr[15] = 1; 853 } 854 res6 = evutil_new_addrinfo((struct sockaddr*)&sin6, 855 sizeof(sin6), hints); 856 if (!res6) 857 return EVUTIL_EAI_MEMORY; 858 } 859 860 if (hints->ai_family != PF_INET6) { /* INET or UNSPEC */ 861 struct sockaddr_in sin; 862 memset(&sin, 0, sizeof(sin)); 863 sin.sin_family = AF_INET; 864 sin.sin_port = htons(port); 865 if (hints->ai_flags & EVUTIL_AI_PASSIVE) { 866 /* Bind to 0.0.0.0 */ 867 } else { 868 /* connect to 127.0.0.1 */ 869 sin.sin_addr.s_addr = htonl(0x7f000001); 870 } 871 res4 = evutil_new_addrinfo((struct sockaddr*)&sin, 872 sizeof(sin), hints); 873 if (!res4) { 874 if (res6) 875 evutil_freeaddrinfo(res6); 876 return EVUTIL_EAI_MEMORY; 877 } 878 } 879 *res = evutil_addrinfo_append(res4, res6); 880 return 0; 881 } 882 883 /* If we can, we should try to parse the hostname without resolving 884 * it. */ 885 /* Try ipv6. */ 886 if (hints->ai_family == PF_INET6 || hints->ai_family == PF_UNSPEC) { 887 struct sockaddr_in6 sin6; 888 memset(&sin6, 0, sizeof(sin6)); 889 if (1==evutil_inet_pton(AF_INET6, nodename, &sin6.sin6_addr)) { 890 /* Got an ipv6 address. */ 891 sin6.sin6_family = AF_INET6; 892 sin6.sin6_port = htons(port); 893 *res = evutil_new_addrinfo((struct sockaddr*)&sin6, 894 sizeof(sin6), hints); 895 if (!*res) 896 return EVUTIL_EAI_MEMORY; 897 return 0; 898 } 899 } 900 901 /* Try ipv4. */ 902 if (hints->ai_family == PF_INET || hints->ai_family == PF_UNSPEC) { 903 struct sockaddr_in sin; 904 memset(&sin, 0, sizeof(sin)); 905 if (1==evutil_inet_pton(AF_INET, nodename, &sin.sin_addr)) { 906 /* Got an ipv6 address. */ 907 sin.sin_family = AF_INET; 908 sin.sin_port = htons(port); 909 *res = evutil_new_addrinfo((struct sockaddr*)&sin, 910 sizeof(sin), hints); 911 if (!*res) 912 return EVUTIL_EAI_MEMORY; 913 return 0; 914 } 915 } 916 917 918 /* If we have reached this point, we definitely need to do a DNS 919 * lookup. */ 920 if ((hints->ai_flags & EVUTIL_AI_NUMERICHOST)) { 921 /* If we're not allowed to do one, then say so. */ 922 return EVUTIL_EAI_NONAME; 923 } 924 *portnum = port; 925 return EVUTIL_EAI_NEED_RESOLVE; 926 } 927 928 #ifdef _EVENT_HAVE_GETADDRINFO 929 #define USE_NATIVE_GETADDRINFO 930 #endif 931 932 #ifdef USE_NATIVE_GETADDRINFO 933 /* A mask of all the flags that we declare, so we can clear them before calling 934 * the native getaddrinfo */ 935 static const unsigned int ALL_NONNATIVE_AI_FLAGS = 936 #ifndef AI_PASSIVE 937 EVUTIL_AI_PASSIVE | 938 #endif 939 #ifndef AI_CANONNAME 940 EVUTIL_AI_CANONNAME | 941 #endif 942 #ifndef AI_NUMERICHOST 943 EVUTIL_AI_NUMERICHOST | 944 #endif 945 #ifndef AI_NUMERICSERV 946 EVUTIL_AI_NUMERICSERV | 947 #endif 948 #ifndef AI_ADDRCONFIG 949 EVUTIL_AI_ADDRCONFIG | 950 #endif 951 #ifndef AI_ALL 952 EVUTIL_AI_ALL | 953 #endif 954 #ifndef AI_V4MAPPED 955 EVUTIL_AI_V4MAPPED | 956 #endif 957 EVUTIL_AI_LIBEVENT_ALLOCATED; 958 959 static const unsigned int ALL_NATIVE_AI_FLAGS = 960 #ifdef AI_PASSIVE 961 AI_PASSIVE | 962 #endif 963 #ifdef AI_CANONNAME 964 AI_CANONNAME | 965 #endif 966 #ifdef AI_NUMERICHOST 967 AI_NUMERICHOST | 968 #endif 969 #ifdef AI_NUMERICSERV 970 AI_NUMERICSERV | 971 #endif 972 #ifdef AI_ADDRCONFIG 973 AI_ADDRCONFIG | 974 #endif 975 #ifdef AI_ALL 976 AI_ALL | 977 #endif 978 #ifdef AI_V4MAPPED 979 AI_V4MAPPED | 980 #endif 981 0; 982 #endif 983 984 #ifndef USE_NATIVE_GETADDRINFO 985 /* Helper for systems with no getaddrinfo(): make one or more addrinfos out of 986 * a struct hostent. 987 */ 988 static struct evutil_addrinfo * 989 addrinfo_from_hostent(const struct hostent *ent, 990 int port, const struct evutil_addrinfo *hints) 991 { 992 int i; 993 struct sockaddr_in sin; 994 struct sockaddr_in6 sin6; 995 struct sockaddr *sa; 996 int socklen; 997 struct evutil_addrinfo *res=NULL, *ai; 998 void *addrp; 999 1000 if (ent->h_addrtype == PF_INET) { 1001 memset(&sin, 0, sizeof(sin)); 1002 sin.sin_family = AF_INET; 1003 sin.sin_port = htons(port); 1004 sa = (struct sockaddr *)&sin; 1005 socklen = sizeof(struct sockaddr_in); 1006 addrp = &sin.sin_addr; 1007 if (ent->h_length != sizeof(sin.sin_addr)) { 1008 event_warnx("Weird h_length from gethostbyname"); 1009 return NULL; 1010 } 1011 } else if (ent->h_addrtype == PF_INET6) { 1012 memset(&sin6, 0, sizeof(sin6)); 1013 sin6.sin6_family = AF_INET6; 1014 sin6.sin6_port = htons(port); 1015 sa = (struct sockaddr *)&sin6; 1016 socklen = sizeof(struct sockaddr_in); 1017 addrp = &sin6.sin6_addr; 1018 if (ent->h_length != sizeof(sin6.sin6_addr)) { 1019 event_warnx("Weird h_length from gethostbyname"); 1020 return NULL; 1021 } 1022 } else 1023 return NULL; 1024 1025 for (i = 0; ent->h_addr_list[i]; ++i) { 1026 memcpy(addrp, ent->h_addr_list[i], ent->h_length); 1027 ai = evutil_new_addrinfo(sa, socklen, hints); 1028 if (!ai) { 1029 evutil_freeaddrinfo(res); 1030 return NULL; 1031 } 1032 res = evutil_addrinfo_append(res, ai); 1033 } 1034 1035 if (res && ((hints->ai_flags & EVUTIL_AI_CANONNAME) && ent->h_name)) { 1036 res->ai_canonname = mm_strdup(ent->h_name); 1037 if (res->ai_canonname == NULL) { 1038 evutil_freeaddrinfo(res); 1039 return NULL; 1040 } 1041 } 1042 1043 return res; 1044 } 1045 #endif 1046 1047 /* If the EVUTIL_AI_ADDRCONFIG flag is set on hints->ai_flags, and 1048 * hints->ai_family is PF_UNSPEC, then revise the value of hints->ai_family so 1049 * that we'll only get addresses we could maybe connect to. 1050 */ 1051 void 1052 evutil_adjust_hints_for_addrconfig(struct evutil_addrinfo *hints) 1053 { 1054 if (!(hints->ai_flags & EVUTIL_AI_ADDRCONFIG)) 1055 return; 1056 if (hints->ai_family != PF_UNSPEC) 1057 return; 1058 if (!have_checked_interfaces) 1059 evutil_check_interfaces(0); 1060 if (had_ipv4_address && !had_ipv6_address) { 1061 hints->ai_family = PF_INET; 1062 } else if (!had_ipv4_address && had_ipv6_address) { 1063 hints->ai_family = PF_INET6; 1064 } 1065 } 1066 1067 #ifdef USE_NATIVE_GETADDRINFO 1068 static int need_numeric_port_hack_=0; 1069 static int need_socktype_protocol_hack_=0; 1070 static int tested_for_getaddrinfo_hacks=0; 1071 1072 /* Some older BSDs (like OpenBSD up to 4.6) used to believe that 1073 giving a numeric port without giving an ai_socktype was verboten. 1074 We test for this so we can apply an appropriate workaround. If it 1075 turns out that the bug is present, then: 1076 1077 - If nodename==NULL and servname is numeric, we build an answer 1078 ourselves using evutil_getaddrinfo_common(). 1079 1080 - If nodename!=NULL and servname is numeric, then we set 1081 servname=NULL when calling getaddrinfo, and post-process the 1082 result to set the ports on it. 1083 1084 We test for this bug at runtime, since otherwise we can't have the 1085 same binary run on multiple BSD versions. 1086 1087 - Some versions of Solaris believe that it's nice to leave to protocol 1088 field set to 0. We test for this so we can apply an appropriate 1089 workaround. 1090 */ 1091 static void 1092 test_for_getaddrinfo_hacks(void) 1093 { 1094 int r, r2; 1095 struct evutil_addrinfo *ai=NULL, *ai2=NULL; 1096 struct evutil_addrinfo hints; 1097 1098 memset(&hints,0,sizeof(hints)); 1099 hints.ai_family = PF_UNSPEC; 1100 hints.ai_flags = 1101 #ifdef AI_NUMERICHOST 1102 AI_NUMERICHOST | 1103 #endif 1104 #ifdef AI_NUMERICSERV 1105 AI_NUMERICSERV | 1106 #endif 1107 0; 1108 r = getaddrinfo("1.2.3.4", "80", &hints, &ai); 1109 hints.ai_socktype = SOCK_STREAM; 1110 r2 = getaddrinfo("1.2.3.4", "80", &hints, &ai2); 1111 if (r2 == 0 && r != 0) { 1112 need_numeric_port_hack_=1; 1113 } 1114 if (ai2 && ai2->ai_protocol == 0) { 1115 need_socktype_protocol_hack_=1; 1116 } 1117 1118 if (ai) 1119 freeaddrinfo(ai); 1120 if (ai2) 1121 freeaddrinfo(ai2); 1122 tested_for_getaddrinfo_hacks=1; 1123 } 1124 1125 static inline int 1126 need_numeric_port_hack(void) 1127 { 1128 if (!tested_for_getaddrinfo_hacks) 1129 test_for_getaddrinfo_hacks(); 1130 return need_numeric_port_hack_; 1131 } 1132 1133 static inline int 1134 need_socktype_protocol_hack(void) 1135 { 1136 if (!tested_for_getaddrinfo_hacks) 1137 test_for_getaddrinfo_hacks(); 1138 return need_socktype_protocol_hack_; 1139 } 1140 1141 static void 1142 apply_numeric_port_hack(int port, struct evutil_addrinfo **ai) 1143 { 1144 /* Now we run through the list and set the ports on all of the 1145 * results where ports would make sense. */ 1146 for ( ; *ai; ai = &(*ai)->ai_next) { 1147 struct sockaddr *sa = (*ai)->ai_addr; 1148 if (sa && sa->sa_family == AF_INET) { 1149 struct sockaddr_in *sin = (struct sockaddr_in*)sa; 1150 sin->sin_port = htons(port); 1151 } else if (sa && sa->sa_family == AF_INET6) { 1152 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)sa; 1153 sin6->sin6_port = htons(port); 1154 } else { 1155 /* A numeric port makes no sense here; remove this one 1156 * from the list. */ 1157 struct evutil_addrinfo *victim = *ai; 1158 *ai = victim->ai_next; 1159 victim->ai_next = NULL; 1160 freeaddrinfo(victim); 1161 } 1162 } 1163 } 1164 1165 static int 1166 apply_socktype_protocol_hack(struct evutil_addrinfo *ai) 1167 { 1168 struct evutil_addrinfo *ai_new; 1169 for (; ai; ai = ai->ai_next) { 1170 evutil_getaddrinfo_infer_protocols(ai); 1171 if (ai->ai_socktype || ai->ai_protocol) 1172 continue; 1173 ai_new = mm_malloc(sizeof(*ai_new)); 1174 if (!ai_new) 1175 return -1; 1176 memcpy(ai_new, ai, sizeof(*ai_new)); 1177 ai->ai_socktype = SOCK_STREAM; 1178 ai->ai_protocol = IPPROTO_TCP; 1179 ai_new->ai_socktype = SOCK_DGRAM; 1180 ai_new->ai_protocol = IPPROTO_UDP; 1181 1182 ai_new->ai_next = ai->ai_next; 1183 ai->ai_next = ai_new; 1184 } 1185 return 0; 1186 } 1187 #endif 1188 1189 int 1190 evutil_getaddrinfo(const char *nodename, const char *servname, 1191 const struct evutil_addrinfo *hints_in, struct evutil_addrinfo **res) 1192 { 1193 #ifdef USE_NATIVE_GETADDRINFO 1194 struct evutil_addrinfo hints; 1195 int portnum=-1, need_np_hack, err; 1196 1197 if (hints_in) { 1198 memcpy(&hints, hints_in, sizeof(hints)); 1199 } else { 1200 memset(&hints, 0, sizeof(hints)); 1201 hints.ai_family = PF_UNSPEC; 1202 } 1203 1204 #ifndef AI_ADDRCONFIG 1205 /* Not every system has AI_ADDRCONFIG, so fake it. */ 1206 if (hints.ai_family == PF_UNSPEC && 1207 (hints.ai_flags & EVUTIL_AI_ADDRCONFIG)) { 1208 evutil_adjust_hints_for_addrconfig(&hints); 1209 } 1210 #endif 1211 1212 #ifndef AI_NUMERICSERV 1213 /* Not every system has AI_NUMERICSERV, so fake it. */ 1214 if (hints.ai_flags & EVUTIL_AI_NUMERICSERV) { 1215 if (servname && parse_numeric_servname(servname)<0) 1216 return EVUTIL_EAI_NONAME; 1217 } 1218 #endif 1219 1220 /* Enough operating systems handle enough common non-resolve 1221 * cases here weirdly enough that we are better off just 1222 * overriding them. For example: 1223 * 1224 * - Windows doesn't like to infer the protocol from the 1225 * socket type, or fill in socket or protocol types much at 1226 * all. It also seems to do its own broken implicit 1227 * always-on version of AI_ADDRCONFIG that keeps it from 1228 * ever resolving even a literal IPv6 address when 1229 * ai_addrtype is PF_UNSPEC. 1230 */ 1231 #ifdef WIN32 1232 { 1233 int tmp_port; 1234 err = evutil_getaddrinfo_common(nodename,servname,&hints, 1235 res, &tmp_port); 1236 if (err == 0 || 1237 err == EVUTIL_EAI_MEMORY || 1238 err == EVUTIL_EAI_NONAME) 1239 return err; 1240 /* If we make it here, the system getaddrinfo can 1241 * have a crack at it. */ 1242 } 1243 #endif 1244 1245 /* See documentation for need_numeric_port_hack above.*/ 1246 need_np_hack = need_numeric_port_hack() && servname && !hints.ai_socktype 1247 && ((portnum=parse_numeric_servname(servname)) >= 0); 1248 if (need_np_hack) { 1249 if (!nodename) 1250 return evutil_getaddrinfo_common( 1251 NULL,servname,&hints, res, &portnum); 1252 servname = NULL; 1253 } 1254 1255 if (need_socktype_protocol_hack()) { 1256 evutil_getaddrinfo_infer_protocols(&hints); 1257 } 1258 1259 /* Make sure that we didn't actually steal any AI_FLAGS values that 1260 * the system is using. (This is a constant expression, and should ge 1261 * optimized out.) 1262 * 1263 * XXXX Turn this into a compile-time failure rather than a run-time 1264 * failure. 1265 */ 1266 EVUTIL_ASSERT((ALL_NONNATIVE_AI_FLAGS & ALL_NATIVE_AI_FLAGS) == 0); 1267 1268 /* Clear any flags that only libevent understands. */ 1269 hints.ai_flags &= ~ALL_NONNATIVE_AI_FLAGS; 1270 1271 err = getaddrinfo(nodename, servname, &hints, res); 1272 if (need_np_hack) 1273 apply_numeric_port_hack(portnum, res); 1274 1275 if (need_socktype_protocol_hack()) { 1276 if (apply_socktype_protocol_hack(*res) < 0) { 1277 evutil_freeaddrinfo(*res); 1278 *res = NULL; 1279 return EVUTIL_EAI_MEMORY; 1280 } 1281 } 1282 return err; 1283 #else 1284 int port=0, err; 1285 struct hostent *ent = NULL; 1286 struct evutil_addrinfo hints; 1287 1288 if (hints_in) { 1289 memcpy(&hints, hints_in, sizeof(hints)); 1290 } else { 1291 memset(&hints, 0, sizeof(hints)); 1292 hints.ai_family = PF_UNSPEC; 1293 } 1294 1295 evutil_adjust_hints_for_addrconfig(&hints); 1296 1297 err = evutil_getaddrinfo_common(nodename, servname, &hints, res, &port); 1298 if (err != EVUTIL_EAI_NEED_RESOLVE) { 1299 /* We either succeeded or failed. No need to continue */ 1300 return err; 1301 } 1302 1303 err = 0; 1304 /* Use any of the various gethostbyname_r variants as available. */ 1305 { 1306 #ifdef _EVENT_HAVE_GETHOSTBYNAME_R_6_ARG 1307 /* This one is what glibc provides. */ 1308 char buf[2048]; 1309 struct hostent hostent; 1310 int r; 1311 r = gethostbyname_r(nodename, &hostent, buf, sizeof(buf), &ent, 1312 &err); 1313 #elif defined(_EVENT_HAVE_GETHOSTBYNAME_R_5_ARG) 1314 char buf[2048]; 1315 struct hostent hostent; 1316 ent = gethostbyname_r(nodename, &hostent, buf, sizeof(buf), 1317 &err); 1318 #elif defined(_EVENT_HAVE_GETHOSTBYNAME_R_3_ARG) 1319 struct hostent_data data; 1320 struct hostent hostent; 1321 memset(&data, 0, sizeof(data)); 1322 err = gethostbyname_r(nodename, &hostent, &data); 1323 ent = err ? NULL : &hostent; 1324 #else 1325 /* fall back to gethostbyname. */ 1326 /* XXXX This needs a lock everywhere but Windows. */ 1327 ent = gethostbyname(nodename); 1328 #ifdef WIN32 1329 err = WSAGetLastError(); 1330 #else 1331 err = h_errno; 1332 #endif 1333 #endif 1334 1335 /* Now we have either ent or err set. */ 1336 if (!ent) { 1337 /* XXX is this right for windows ? */ 1338 switch (err) { 1339 case TRY_AGAIN: 1340 return EVUTIL_EAI_AGAIN; 1341 case NO_RECOVERY: 1342 default: 1343 return EVUTIL_EAI_FAIL; 1344 case HOST_NOT_FOUND: 1345 return EVUTIL_EAI_NONAME; 1346 case NO_ADDRESS: 1347 #if NO_DATA != NO_ADDRESS 1348 case NO_DATA: 1349 #endif 1350 return EVUTIL_EAI_NODATA; 1351 } 1352 } 1353 1354 if (ent->h_addrtype != hints.ai_family && 1355 hints.ai_family != PF_UNSPEC) { 1356 /* This wasn't the type we were hoping for. Too bad 1357 * we never had a chance to ask gethostbyname for what 1358 * we wanted. */ 1359 return EVUTIL_EAI_NONAME; 1360 } 1361 1362 /* Make sure we got _some_ answers. */ 1363 if (ent->h_length == 0) 1364 return EVUTIL_EAI_NODATA; 1365 1366 /* If we got an address type we don't know how to make a 1367 sockaddr for, give up. */ 1368 if (ent->h_addrtype != PF_INET && ent->h_addrtype != PF_INET6) 1369 return EVUTIL_EAI_FAMILY; 1370 1371 *res = addrinfo_from_hostent(ent, port, &hints); 1372 if (! *res) 1373 return EVUTIL_EAI_MEMORY; 1374 } 1375 1376 return 0; 1377 #endif 1378 } 1379 1380 void 1381 evutil_freeaddrinfo(struct evutil_addrinfo *ai) 1382 { 1383 #ifdef _EVENT_HAVE_GETADDRINFO 1384 if (!(ai->ai_flags & EVUTIL_AI_LIBEVENT_ALLOCATED)) { 1385 freeaddrinfo(ai); 1386 return; 1387 } 1388 #endif 1389 while (ai) { 1390 struct evutil_addrinfo *next = ai->ai_next; 1391 if (ai->ai_canonname) 1392 mm_free(ai->ai_canonname); 1393 mm_free(ai); 1394 ai = next; 1395 } 1396 } 1397 1398 static evdns_getaddrinfo_fn evdns_getaddrinfo_impl = NULL; 1399 1400 void 1401 evutil_set_evdns_getaddrinfo_fn(evdns_getaddrinfo_fn fn) 1402 { 1403 if (!evdns_getaddrinfo_impl) 1404 evdns_getaddrinfo_impl = fn; 1405 } 1406 1407 /* Internal helper function: act like evdns_getaddrinfo if dns_base is set; 1408 * otherwise do a blocking resolve and pass the result to the callback in the 1409 * way that evdns_getaddrinfo would. 1410 */ 1411 int 1412 evutil_getaddrinfo_async(struct evdns_base *dns_base, 1413 const char *nodename, const char *servname, 1414 const struct evutil_addrinfo *hints_in, 1415 void (*cb)(int, struct evutil_addrinfo *, void *), void *arg) 1416 { 1417 if (dns_base && evdns_getaddrinfo_impl) { 1418 evdns_getaddrinfo_impl( 1419 dns_base, nodename, servname, hints_in, cb, arg); 1420 } else { 1421 struct evutil_addrinfo *ai=NULL; 1422 int err; 1423 err = evutil_getaddrinfo(nodename, servname, hints_in, &ai); 1424 cb(err, ai, arg); 1425 } 1426 return 0; 1427 } 1428 1429 const char * 1430 evutil_gai_strerror(int err) 1431 { 1432 /* As a sneaky side-benefit, this case statement will get most 1433 * compilers to tell us if any of the error codes we defined 1434 * conflict with the platform's native error codes. */ 1435 switch (err) { 1436 case EVUTIL_EAI_CANCEL: 1437 return "Request canceled"; 1438 case 0: 1439 return "No error"; 1440 1441 case EVUTIL_EAI_ADDRFAMILY: 1442 return "address family for nodename not supported"; 1443 case EVUTIL_EAI_AGAIN: 1444 return "temporary failure in name resolution"; 1445 case EVUTIL_EAI_BADFLAGS: 1446 return "invalid value for ai_flags"; 1447 case EVUTIL_EAI_FAIL: 1448 return "non-recoverable failure in name resolution"; 1449 case EVUTIL_EAI_FAMILY: 1450 return "ai_family not supported"; 1451 case EVUTIL_EAI_MEMORY: 1452 return "memory allocation failure"; 1453 case EVUTIL_EAI_NODATA: 1454 return "no address associated with nodename"; 1455 case EVUTIL_EAI_NONAME: 1456 return "nodename nor servname provided, or not known"; 1457 case EVUTIL_EAI_SERVICE: 1458 return "servname not supported for ai_socktype"; 1459 case EVUTIL_EAI_SOCKTYPE: 1460 return "ai_socktype not supported"; 1461 case EVUTIL_EAI_SYSTEM: 1462 return "system error"; 1463 default: 1464 #if defined(USE_NATIVE_GETADDRINFO) && defined(WIN32) 1465 return gai_strerrorA(err); 1466 #elif defined(USE_NATIVE_GETADDRINFO) 1467 return gai_strerror(err); 1468 #else 1469 return "Unknown error code"; 1470 #endif 1471 } 1472 } 1473 1474 #ifdef WIN32 1475 #define E(code, s) { code, (s " [" #code " ]") } 1476 static struct { int code; const char *msg; } windows_socket_errors[] = { 1477 E(WSAEINTR, "Interrupted function call"), 1478 E(WSAEACCES, "Permission denied"), 1479 E(WSAEFAULT, "Bad address"), 1480 E(WSAEINVAL, "Invalid argument"), 1481 E(WSAEMFILE, "Too many open files"), 1482 E(WSAEWOULDBLOCK, "Resource temporarily unavailable"), 1483 E(WSAEINPROGRESS, "Operation now in progress"), 1484 E(WSAEALREADY, "Operation already in progress"), 1485 E(WSAENOTSOCK, "Socket operation on nonsocket"), 1486 E(WSAEDESTADDRREQ, "Destination address required"), 1487 E(WSAEMSGSIZE, "Message too long"), 1488 E(WSAEPROTOTYPE, "Protocol wrong for socket"), 1489 E(WSAENOPROTOOPT, "Bad protocol option"), 1490 E(WSAEPROTONOSUPPORT, "Protocol not supported"), 1491 E(WSAESOCKTNOSUPPORT, "Socket type not supported"), 1492 /* What's the difference between NOTSUPP and NOSUPPORT? :) */ 1493 E(WSAEOPNOTSUPP, "Operation not supported"), 1494 E(WSAEPFNOSUPPORT, "Protocol family not supported"), 1495 E(WSAEAFNOSUPPORT, "Address family not supported by protocol family"), 1496 E(WSAEADDRINUSE, "Address already in use"), 1497 E(WSAEADDRNOTAVAIL, "Cannot assign requested address"), 1498 E(WSAENETDOWN, "Network is down"), 1499 E(WSAENETUNREACH, "Network is unreachable"), 1500 E(WSAENETRESET, "Network dropped connection on reset"), 1501 E(WSAECONNABORTED, "Software caused connection abort"), 1502 E(WSAECONNRESET, "Connection reset by peer"), 1503 E(WSAENOBUFS, "No buffer space available"), 1504 E(WSAEISCONN, "Socket is already connected"), 1505 E(WSAENOTCONN, "Socket is not connected"), 1506 E(WSAESHUTDOWN, "Cannot send after socket shutdown"), 1507 E(WSAETIMEDOUT, "Connection timed out"), 1508 E(WSAECONNREFUSED, "Connection refused"), 1509 E(WSAEHOSTDOWN, "Host is down"), 1510 E(WSAEHOSTUNREACH, "No route to host"), 1511 E(WSAEPROCLIM, "Too many processes"), 1512 1513 /* Yes, some of these start with WSA, not WSAE. No, I don't know why. */ 1514 E(WSASYSNOTREADY, "Network subsystem is unavailable"), 1515 E(WSAVERNOTSUPPORTED, "Winsock.dll out of range"), 1516 E(WSANOTINITIALISED, "Successful WSAStartup not yet performed"), 1517 E(WSAEDISCON, "Graceful shutdown now in progress"), 1518 #ifdef WSATYPE_NOT_FOUND 1519 E(WSATYPE_NOT_FOUND, "Class type not found"), 1520 #endif 1521 E(WSAHOST_NOT_FOUND, "Host not found"), 1522 E(WSATRY_AGAIN, "Nonauthoritative host not found"), 1523 E(WSANO_RECOVERY, "This is a nonrecoverable error"), 1524 E(WSANO_DATA, "Valid name, no data record of requested type)"), 1525 1526 /* There are some more error codes whose numeric values are marked 1527 * <b>OS dependent</b>. They start with WSA_, apparently for the same 1528 * reason that practitioners of some craft traditions deliberately 1529 * introduce imperfections into their baskets and rugs "to allow the 1530 * evil spirits to escape." If we catch them, then our binaries 1531 * might not report consistent results across versions of Windows. 1532 * Thus, I'm going to let them all fall through. 1533 */ 1534 { -1, NULL }, 1535 }; 1536 #undef E 1537 /** Equivalent to strerror, but for windows socket errors. */ 1538 const char * 1539 evutil_socket_error_to_string(int errcode) 1540 { 1541 /* XXXX Is there really no built-in function to do this? */ 1542 int i; 1543 for (i=0; windows_socket_errors[i].code >= 0; ++i) { 1544 if (errcode == windows_socket_errors[i].code) 1545 return windows_socket_errors[i].msg; 1546 } 1547 return strerror(errcode); 1548 } 1549 #endif 1550 1551 int 1552 evutil_snprintf(char *buf, size_t buflen, const char *format, ...) 1553 { 1554 int r; 1555 va_list ap; 1556 va_start(ap, format); 1557 r = evutil_vsnprintf(buf, buflen, format, ap); 1558 va_end(ap); 1559 return r; 1560 } 1561 1562 int 1563 evutil_vsnprintf(char *buf, size_t buflen, const char *format, va_list ap) 1564 { 1565 int r; 1566 if (!buflen) 1567 return 0; 1568 #ifdef _MSC_VER 1569 r = _vsnprintf(buf, buflen, format, ap); 1570 if (r < 0) 1571 r = _vscprintf(format, ap); 1572 #elif defined(sgi) 1573 /* Make sure we always use the correct vsnprintf on IRIX */ 1574 extern int _xpg5_vsnprintf(char * __restrict, 1575 __SGI_LIBC_NAMESPACE_QUALIFIER size_t, 1576 const char * __restrict, /* va_list */ char *); 1577 1578 r = _xpg5_vsnprintf(buf, buflen, format, ap); 1579 #else 1580 r = vsnprintf(buf, buflen, format, ap); 1581 #endif 1582 buf[buflen-1] = '\0'; 1583 return r; 1584 } 1585 1586 #define USE_INTERNAL_NTOP 1587 #define USE_INTERNAL_PTON 1588 1589 const char * 1590 evutil_inet_ntop(int af, const void *src, char *dst, size_t len) 1591 { 1592 #if defined(_EVENT_HAVE_INET_NTOP) && !defined(USE_INTERNAL_NTOP) 1593 return inet_ntop(af, src, dst, len); 1594 #else 1595 if (af == AF_INET) { 1596 const struct in_addr *in = src; 1597 const ev_uint32_t a = ntohl(in->s_addr); 1598 int r; 1599 r = evutil_snprintf(dst, len, "%d.%d.%d.%d", 1600 (int)(ev_uint8_t)((a>>24)&0xff), 1601 (int)(ev_uint8_t)((a>>16)&0xff), 1602 (int)(ev_uint8_t)((a>>8 )&0xff), 1603 (int)(ev_uint8_t)((a )&0xff)); 1604 if (r<0||(size_t)r>=len) 1605 return NULL; 1606 else 1607 return dst; 1608 #ifdef AF_INET6 1609 } else if (af == AF_INET6) { 1610 const struct in6_addr *addr = src; 1611 char buf[64], *cp; 1612 int longestGapLen = 0, longestGapPos = -1, i, 1613 curGapPos = -1, curGapLen = 0; 1614 ev_uint16_t words[8]; 1615 for (i = 0; i < 8; ++i) { 1616 words[i] = 1617 (((ev_uint16_t)addr->s6_addr[2*i])<<8) + addr->s6_addr[2*i+1]; 1618 } 1619 if (words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 && 1620 words[4] == 0 && ((words[5] == 0 && words[6] && words[7]) || 1621 (words[5] == 0xffff))) { 1622 /* This is an IPv4 address. */ 1623 if (words[5] == 0) { 1624 evutil_snprintf(buf, sizeof(buf), "::%d.%d.%d.%d", 1625 addr->s6_addr[12], addr->s6_addr[13], 1626 addr->s6_addr[14], addr->s6_addr[15]); 1627 } else { 1628 evutil_snprintf(buf, sizeof(buf), "::%x:%d.%d.%d.%d", words[5], 1629 addr->s6_addr[12], addr->s6_addr[13], 1630 addr->s6_addr[14], addr->s6_addr[15]); 1631 } 1632 if (strlen(buf) > len) 1633 return NULL; 1634 strlcpy(dst, buf, len); 1635 return dst; 1636 } 1637 i = 0; 1638 while (i < 8) { 1639 if (words[i] == 0) { 1640 curGapPos = i++; 1641 curGapLen = 1; 1642 while (i<8 && words[i] == 0) { 1643 ++i; ++curGapLen; 1644 } 1645 if (curGapLen > longestGapLen) { 1646 longestGapPos = curGapPos; 1647 longestGapLen = curGapLen; 1648 } 1649 } else { 1650 ++i; 1651 } 1652 } 1653 if (longestGapLen<=1) 1654 longestGapPos = -1; 1655 1656 cp = buf; 1657 for (i = 0; i < 8; ++i) { 1658 if (words[i] == 0 && longestGapPos == i) { 1659 if (i == 0) 1660 *cp++ = ':'; 1661 *cp++ = ':'; 1662 while (i < 8 && words[i] == 0) 1663 ++i; 1664 --i; /* to compensate for loop increment. */ 1665 } else { 1666 evutil_snprintf(cp, 1667 sizeof(buf)-(cp-buf), "%x", (unsigned)words[i]); 1668 cp += strlen(cp); 1669 if (i != 7) 1670 *cp++ = ':'; 1671 } 1672 } 1673 *cp = '\0'; 1674 if (strlen(buf) > len) 1675 return NULL; 1676 strlcpy(dst, buf, len); 1677 return dst; 1678 #endif 1679 } else { 1680 return NULL; 1681 } 1682 #endif 1683 } 1684 1685 int 1686 evutil_inet_pton(int af, const char *src, void *dst) 1687 { 1688 #if defined(_EVENT_HAVE_INET_PTON) && !defined(USE_INTERNAL_PTON) 1689 return inet_pton(af, src, dst); 1690 #else 1691 if (af == AF_INET) { 1692 int a,b,c,d; 1693 char more; 1694 struct in_addr *addr = dst; 1695 if (sscanf(src, "%d.%d.%d.%d%c", &a,&b,&c,&d,&more) != 4) 1696 return 0; 1697 if (a < 0 || a > 255) return 0; 1698 if (b < 0 || b > 255) return 0; 1699 if (c < 0 || c > 255) return 0; 1700 if (d < 0 || d > 255) return 0; 1701 addr->s_addr = htonl((a<<24) | (b<<16) | (c<<8) | d); 1702 return 1; 1703 #ifdef AF_INET6 1704 } else if (af == AF_INET6) { 1705 struct in6_addr *out = dst; 1706 ev_uint16_t words[8]; 1707 int gapPos = -1, i, setWords=0; 1708 const char *dot = strchr(src, '.'); 1709 const char *eow; /* end of words. */ 1710 if (dot == src) 1711 return 0; 1712 else if (!dot) 1713 eow = src+strlen(src); 1714 else { 1715 int byte1,byte2,byte3,byte4; 1716 char more; 1717 for (eow = dot-1; eow >= src && EVUTIL_ISDIGIT(*eow); --eow) 1718 ; 1719 ++eow; 1720 1721 /* We use "scanf" because some platform inet_aton()s are too lax 1722 * about IPv4 addresses of the form "1.2.3" */ 1723 if (sscanf(eow, "%d.%d.%d.%d%c", 1724 &byte1,&byte2,&byte3,&byte4,&more) != 4) 1725 return 0; 1726 1727 if (byte1 > 255 || byte1 < 0 || 1728 byte2 > 255 || byte2 < 0 || 1729 byte3 > 255 || byte3 < 0 || 1730 byte4 > 255 || byte4 < 0) 1731 return 0; 1732 1733 words[6] = (byte1<<8) | byte2; 1734 words[7] = (byte3<<8) | byte4; 1735 setWords += 2; 1736 } 1737 1738 i = 0; 1739 while (src < eow) { 1740 if (i > 7) 1741 return 0; 1742 if (EVUTIL_ISXDIGIT(*src)) { 1743 char *next; 1744 long r = strtol(src, &next, 16); 1745 if (next > 4+src) 1746 return 0; 1747 if (next == src) 1748 return 0; 1749 if (r<0 || r>65536) 1750 return 0; 1751 1752 words[i++] = (ev_uint16_t)r; 1753 setWords++; 1754 src = next; 1755 if (*src != ':' && src != eow) 1756 return 0; 1757 ++src; 1758 } else if (*src == ':' && i > 0 && gapPos==-1) { 1759 gapPos = i; 1760 ++src; 1761 } else if (*src == ':' && i == 0 && src[1] == ':' && gapPos==-1) { 1762 gapPos = i; 1763 src += 2; 1764 } else { 1765 return 0; 1766 } 1767 } 1768 1769 if (setWords > 8 || 1770 (setWords == 8 && gapPos != -1) || 1771 (setWords < 8 && gapPos == -1)) 1772 return 0; 1773 1774 if (gapPos >= 0) { 1775 int nToMove = setWords - (dot ? 2 : 0) - gapPos; 1776 int gapLen = 8 - setWords; 1777 /* assert(nToMove >= 0); */ 1778 if (nToMove < 0) 1779 return -1; /* should be impossible */ 1780 memmove(&words[gapPos+gapLen], &words[gapPos], 1781 sizeof(ev_uint16_t)*nToMove); 1782 memset(&words[gapPos], 0, sizeof(ev_uint16_t)*gapLen); 1783 } 1784 for (i = 0; i < 8; ++i) { 1785 out->s6_addr[2*i ] = words[i] >> 8; 1786 out->s6_addr[2*i+1] = words[i] & 0xff; 1787 } 1788 1789 return 1; 1790 #endif 1791 } else { 1792 return -1; 1793 } 1794 #endif 1795 } 1796 1797 int 1798 evutil_parse_sockaddr_port(const char *ip_as_string, struct sockaddr *out, int *outlen) 1799 { 1800 int port; 1801 char buf[128]; 1802 const char *cp, *addr_part, *port_part; 1803 int is_ipv6; 1804 /* recognized formats are: 1805 * [ipv6]:port 1806 * ipv6 1807 * [ipv6] 1808 * ipv4:port 1809 * ipv4 1810 */ 1811 1812 cp = strchr(ip_as_string, ':'); 1813 if (*ip_as_string == '[') { 1814 int len; 1815 if (!(cp = strchr(ip_as_string, ']'))) { 1816 return -1; 1817 } 1818 len = (int) ( cp-(ip_as_string + 1) ); 1819 if (len > (int)sizeof(buf)-1) { 1820 return -1; 1821 } 1822 memcpy(buf, ip_as_string+1, len); 1823 buf[len] = '\0'; 1824 addr_part = buf; 1825 if (cp[1] == ':') 1826 port_part = cp+2; 1827 else 1828 port_part = NULL; 1829 is_ipv6 = 1; 1830 } else if (cp && strchr(cp+1, ':')) { 1831 is_ipv6 = 1; 1832 addr_part = ip_as_string; 1833 port_part = NULL; 1834 } else if (cp) { 1835 is_ipv6 = 0; 1836 if (cp - ip_as_string > (int)sizeof(buf)-1) { 1837 return -1; 1838 } 1839 memcpy(buf, ip_as_string, cp-ip_as_string); 1840 buf[cp-ip_as_string] = '\0'; 1841 addr_part = buf; 1842 port_part = cp+1; 1843 } else { 1844 addr_part = ip_as_string; 1845 port_part = NULL; 1846 is_ipv6 = 0; 1847 } 1848 1849 if (port_part == NULL) { 1850 port = 0; 1851 } else { 1852 port = atoi(port_part); 1853 if (port <= 0 || port > 65535) { 1854 return -1; 1855 } 1856 } 1857 1858 if (!addr_part) 1859 return -1; /* Should be impossible. */ 1860 #ifdef AF_INET6 1861 if (is_ipv6) 1862 { 1863 struct sockaddr_in6 sin6; 1864 memset(&sin6, 0, sizeof(sin6)); 1865 #ifdef _EVENT_HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN 1866 sin6.sin6_len = sizeof(sin6); 1867 #endif 1868 sin6.sin6_family = AF_INET6; 1869 sin6.sin6_port = htons(port); 1870 if (1 != evutil_inet_pton(AF_INET6, addr_part, &sin6.sin6_addr)) 1871 return -1; 1872 if ((int)sizeof(sin6) > *outlen) 1873 return -1; 1874 memset(out, 0, *outlen); 1875 memcpy(out, &sin6, sizeof(sin6)); 1876 *outlen = sizeof(sin6); 1877 return 0; 1878 } 1879 else 1880 #endif 1881 { 1882 struct sockaddr_in sin; 1883 memset(&sin, 0, sizeof(sin)); 1884 #ifdef _EVENT_HAVE_STRUCT_SOCKADDR_IN_SIN_LEN 1885 sin.sin_len = sizeof(sin); 1886 #endif 1887 sin.sin_family = AF_INET; 1888 sin.sin_port = htons(port); 1889 if (1 != evutil_inet_pton(AF_INET, addr_part, &sin.sin_addr)) 1890 return -1; 1891 if ((int)sizeof(sin) > *outlen) 1892 return -1; 1893 memset(out, 0, *outlen); 1894 memcpy(out, &sin, sizeof(sin)); 1895 *outlen = sizeof(sin); 1896 return 0; 1897 } 1898 } 1899 1900 const char * 1901 evutil_format_sockaddr_port(const struct sockaddr *sa, char *out, size_t outlen) 1902 { 1903 char b[128]; 1904 const char *res=NULL; 1905 int port; 1906 if (sa->sa_family == AF_INET) { 1907 const struct sockaddr_in *sin = (const struct sockaddr_in*)sa; 1908 res = evutil_inet_ntop(AF_INET, &sin->sin_addr,b,sizeof(b)); 1909 port = ntohs(sin->sin_port); 1910 if (res) { 1911 evutil_snprintf(out, outlen, "%s:%d", b, port); 1912 return out; 1913 } 1914 } else if (sa->sa_family == AF_INET6) { 1915 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6*)sa; 1916 res = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr,b,sizeof(b)); 1917 port = ntohs(sin6->sin6_port); 1918 if (res) { 1919 evutil_snprintf(out, outlen, "[%s]:%d", b, port); 1920 return out; 1921 } 1922 } 1923 1924 evutil_snprintf(out, outlen, "<addr with socktype %d>", 1925 (int)sa->sa_family); 1926 return out; 1927 } 1928 1929 int 1930 evutil_sockaddr_cmp(const struct sockaddr *sa1, const struct sockaddr *sa2, 1931 int include_port) 1932 { 1933 int r; 1934 if (0 != (r = (sa1->sa_family - sa2->sa_family))) 1935 return r; 1936 1937 if (sa1->sa_family == AF_INET) { 1938 const struct sockaddr_in *sin1, *sin2; 1939 sin1 = (const struct sockaddr_in *)sa1; 1940 sin2 = (const struct sockaddr_in *)sa2; 1941 if (sin1->sin_addr.s_addr < sin2->sin_addr.s_addr) 1942 return -1; 1943 else if (sin1->sin_addr.s_addr > sin2->sin_addr.s_addr) 1944 return 1; 1945 else if (include_port && 1946 (r = ((int)sin1->sin_port - (int)sin2->sin_port))) 1947 return r; 1948 else 1949 return 0; 1950 } 1951 #ifdef AF_INET6 1952 else if (sa1->sa_family == AF_INET6) { 1953 const struct sockaddr_in6 *sin1, *sin2; 1954 sin1 = (const struct sockaddr_in6 *)sa1; 1955 sin2 = (const struct sockaddr_in6 *)sa2; 1956 if ((r = memcmp(sin1->sin6_addr.s6_addr, sin2->sin6_addr.s6_addr, 16))) 1957 return r; 1958 else if (include_port && 1959 (r = ((int)sin1->sin6_port - (int)sin2->sin6_port))) 1960 return r; 1961 else 1962 return 0; 1963 } 1964 #endif 1965 return 1; 1966 } 1967 1968 /* Tables to implement ctypes-replacement EVUTIL_IS*() functions. Each table 1969 * has 256 bits to look up whether a character is in some set or not. This 1970 * fails on non-ASCII platforms, but so does every other place where we 1971 * take a char and write it onto the network. 1972 **/ 1973 static const ev_uint32_t EVUTIL_ISALPHA_TABLE[8] = 1974 { 0, 0, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 }; 1975 static const ev_uint32_t EVUTIL_ISALNUM_TABLE[8] = 1976 { 0, 0x3ff0000, 0x7fffffe, 0x7fffffe, 0, 0, 0, 0 }; 1977 static const ev_uint32_t EVUTIL_ISSPACE_TABLE[8] = { 0x3e00, 0x1, 0, 0, 0, 0, 0, 0 }; 1978 static const ev_uint32_t EVUTIL_ISXDIGIT_TABLE[8] = 1979 { 0, 0x3ff0000, 0x7e, 0x7e, 0, 0, 0, 0 }; 1980 static const ev_uint32_t EVUTIL_ISDIGIT_TABLE[8] = { 0, 0x3ff0000, 0, 0, 0, 0, 0, 0 }; 1981 static const ev_uint32_t EVUTIL_ISPRINT_TABLE[8] = 1982 { 0, 0xffffffff, 0xffffffff, 0x7fffffff, 0, 0, 0, 0x0 }; 1983 static const ev_uint32_t EVUTIL_ISUPPER_TABLE[8] = { 0, 0, 0x7fffffe, 0, 0, 0, 0, 0 }; 1984 static const ev_uint32_t EVUTIL_ISLOWER_TABLE[8] = { 0, 0, 0, 0x7fffffe, 0, 0, 0, 0 }; 1985 /* Upper-casing and lowercasing tables to map characters to upper/lowercase 1986 * equivalents. */ 1987 static const unsigned char EVUTIL_TOUPPER_TABLE[256] = { 1988 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 1989 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 1990 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, 1991 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63, 1992 64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79, 1993 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95, 1994 96,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79, 1995 80,81,82,83,84,85,86,87,88,89,90,123,124,125,126,127, 1996 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, 1997 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, 1998 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175, 1999 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, 2000 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, 2001 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, 2002 224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, 2003 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, 2004 }; 2005 static const unsigned char EVUTIL_TOLOWER_TABLE[256] = { 2006 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 2007 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 2008 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, 2009 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63, 2010 64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111, 2011 112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,95, 2012 96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111, 2013 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, 2014 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, 2015 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, 2016 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175, 2017 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, 2018 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, 2019 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, 2020 224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, 2021 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, 2022 }; 2023 2024 #define IMPL_CTYPE_FN(name) \ 2025 int EVUTIL_##name(char c) { \ 2026 ev_uint8_t u = c; \ 2027 return !!(EVUTIL_##name##_TABLE[(u >> 5) & 7] & (1 << (u & 31))); \ 2028 } 2029 IMPL_CTYPE_FN(ISALPHA) 2030 IMPL_CTYPE_FN(ISALNUM) 2031 IMPL_CTYPE_FN(ISSPACE) 2032 IMPL_CTYPE_FN(ISDIGIT) 2033 IMPL_CTYPE_FN(ISXDIGIT) 2034 IMPL_CTYPE_FN(ISPRINT) 2035 IMPL_CTYPE_FN(ISLOWER) 2036 IMPL_CTYPE_FN(ISUPPER) 2037 2038 char EVUTIL_TOLOWER(char c) 2039 { 2040 return ((char)EVUTIL_TOLOWER_TABLE[(ev_uint8_t)c]); 2041 } 2042 char EVUTIL_TOUPPER(char c) 2043 { 2044 return ((char)EVUTIL_TOUPPER_TABLE[(ev_uint8_t)c]); 2045 } 2046 int 2047 evutil_ascii_strcasecmp(const char *s1, const char *s2) 2048 { 2049 char c1, c2; 2050 while (1) { 2051 c1 = EVUTIL_TOLOWER(*s1++); 2052 c2 = EVUTIL_TOLOWER(*s2++); 2053 if (c1 < c2) 2054 return -1; 2055 else if (c1 > c2) 2056 return 1; 2057 else if (c1 == 0) 2058 return 0; 2059 } 2060 } 2061 int evutil_ascii_strncasecmp(const char *s1, const char *s2, size_t n) 2062 { 2063 char c1, c2; 2064 while (n--) { 2065 c1 = EVUTIL_TOLOWER(*s1++); 2066 c2 = EVUTIL_TOLOWER(*s2++); 2067 if (c1 < c2) 2068 return -1; 2069 else if (c1 > c2) 2070 return 1; 2071 else if (c1 == 0) 2072 return 0; 2073 } 2074 return 0; 2075 } 2076 2077 static int 2078 evutil_issetugid(void) 2079 { 2080 #ifdef _EVENT_HAVE_ISSETUGID 2081 return issetugid(); 2082 #else 2083 2084 #ifdef _EVENT_HAVE_GETEUID 2085 if (getuid() != geteuid()) 2086 return 1; 2087 #endif 2088 #ifdef _EVENT_HAVE_GETEGID 2089 if (getgid() != getegid()) 2090 return 1; 2091 #endif 2092 return 0; 2093 #endif 2094 } 2095 2096 const char * 2097 evutil_getenv(const char *varname) 2098 { 2099 if (evutil_issetugid()) 2100 return NULL; 2101 2102 return getenv(varname); 2103 } 2104 2105 long 2106 _evutil_weakrand(void) 2107 { 2108 #ifdef WIN32 2109 return rand(); 2110 #else 2111 return random(); 2112 #endif 2113 } 2114 2115 int 2116 evutil_sockaddr_is_loopback(const struct sockaddr *addr) 2117 { 2118 static const char LOOPBACK_S6[16] = 2119 "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1"; 2120 if (addr->sa_family == AF_INET) { 2121 const struct sockaddr_in *sin = (const struct sockaddr_in *)addr; 2122 return (ntohl(sin->sin_addr.s_addr) & 0xff000000) == 0x7f000000; 2123 } else if (addr->sa_family == AF_INET6) { 2124 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)addr; 2125 return !memcmp(sin6->sin6_addr.s6_addr, LOOPBACK_S6, 16); 2126 } 2127 return 0; 2128 } 2129 2130 #define MAX_SECONDS_IN_MSEC_LONG \ 2131 (((LONG_MAX) - 999) / 1000) 2132 2133 long 2134 evutil_tv_to_msec(const struct timeval *tv) 2135 { 2136 if (tv->tv_usec > 1000000 || tv->tv_sec > MAX_SECONDS_IN_MSEC_LONG) 2137 return -1; 2138 2139 return (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000); 2140 } 2141 2142 int 2143 evutil_hex_char_to_int(char c) 2144 { 2145 switch(c) 2146 { 2147 case '0': return 0; 2148 case '1': return 1; 2149 case '2': return 2; 2150 case '3': return 3; 2151 case '4': return 4; 2152 case '5': return 5; 2153 case '6': return 6; 2154 case '7': return 7; 2155 case '8': return 8; 2156 case '9': return 9; 2157 case 'A': case 'a': return 10; 2158 case 'B': case 'b': return 11; 2159 case 'C': case 'c': return 12; 2160 case 'D': case 'd': return 13; 2161 case 'E': case 'e': return 14; 2162 case 'F': case 'f': return 15; 2163 } 2164 return -1; 2165 } 2166 2167 #ifdef WIN32 2168 HANDLE 2169 evutil_load_windows_system_library(const TCHAR *library_name) 2170 { 2171 TCHAR path[MAX_PATH]; 2172 unsigned n; 2173 n = GetSystemDirectory(path, MAX_PATH); 2174 if (n == 0 || n + _tcslen(library_name) + 2 >= MAX_PATH) 2175 return 0; 2176 _tcscat(path, TEXT("\\")); 2177 _tcscat(path, library_name); 2178 return LoadLibrary(path); 2179 } 2180 #endif 2181 2182