1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel (at) haxx.se>, et al. 9 * 10 * This software is licensed as described in the file COPYING, which 11 * you should have received as part of this distribution. The terms 12 * are also available at https://curl.haxx.se/docs/copyright.html. 13 * 14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 15 * copies of the Software, and permit persons to whom the Software is 16 * furnished to do so, under the terms of the COPYING file. 17 * 18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 19 * KIND, either express or implied. 20 * 21 ***************************************************************************/ 22 23 #include "curl_setup.h" 24 25 /*********************************************************************** 26 * Only for threaded name resolves builds 27 **********************************************************************/ 28 #ifdef CURLRES_THREADED 29 30 #ifdef HAVE_NETINET_IN_H 31 #include <netinet/in.h> 32 #endif 33 #ifdef HAVE_NETDB_H 34 #include <netdb.h> 35 #endif 36 #ifdef HAVE_ARPA_INET_H 37 #include <arpa/inet.h> 38 #endif 39 #ifdef __VMS 40 #include <in.h> 41 #include <inet.h> 42 #endif 43 44 #if defined(USE_THREADS_POSIX) 45 # ifdef HAVE_PTHREAD_H 46 # include <pthread.h> 47 # endif 48 #elif defined(USE_THREADS_WIN32) 49 # ifdef HAVE_PROCESS_H 50 # include <process.h> 51 # endif 52 #endif 53 54 #if (defined(NETWARE) && defined(__NOVELL_LIBC__)) 55 #undef in_addr_t 56 #define in_addr_t unsigned long 57 #endif 58 59 #ifdef HAVE_GETADDRINFO 60 # define RESOLVER_ENOMEM EAI_MEMORY 61 #else 62 # define RESOLVER_ENOMEM ENOMEM 63 #endif 64 65 #include "urldata.h" 66 #include "sendf.h" 67 #include "hostip.h" 68 #include "hash.h" 69 #include "share.h" 70 #include "strerror.h" 71 #include "url.h" 72 #include "multiif.h" 73 #include "inet_pton.h" 74 #include "inet_ntop.h" 75 #include "curl_threads.h" 76 #include "connect.h" 77 /* The last 3 #include files should be in this order */ 78 #include "curl_printf.h" 79 #include "curl_memory.h" 80 #include "memdebug.h" 81 82 /* 83 * Curl_resolver_global_init() 84 * Called from curl_global_init() to initialize global resolver environment. 85 * Does nothing here. 86 */ 87 int Curl_resolver_global_init(void) 88 { 89 return CURLE_OK; 90 } 91 92 /* 93 * Curl_resolver_global_cleanup() 94 * Called from curl_global_cleanup() to destroy global resolver environment. 95 * Does nothing here. 96 */ 97 void Curl_resolver_global_cleanup(void) 98 { 99 } 100 101 /* 102 * Curl_resolver_init() 103 * Called from curl_easy_init() -> Curl_open() to initialize resolver 104 * URL-state specific environment ('resolver' member of the UrlState 105 * structure). Does nothing here. 106 */ 107 CURLcode Curl_resolver_init(void **resolver) 108 { 109 (void)resolver; 110 return CURLE_OK; 111 } 112 113 /* 114 * Curl_resolver_cleanup() 115 * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver 116 * URL-state specific environment ('resolver' member of the UrlState 117 * structure). Does nothing here. 118 */ 119 void Curl_resolver_cleanup(void *resolver) 120 { 121 (void)resolver; 122 } 123 124 /* 125 * Curl_resolver_duphandle() 126 * Called from curl_easy_duphandle() to duplicate resolver URL state-specific 127 * environment ('resolver' member of the UrlState structure). Does nothing 128 * here. 129 */ 130 int Curl_resolver_duphandle(void **to, void *from) 131 { 132 (void)to; 133 (void)from; 134 return CURLE_OK; 135 } 136 137 static void destroy_async_data(struct Curl_async *); 138 139 /* 140 * Cancel all possibly still on-going resolves for this connection. 141 */ 142 void Curl_resolver_cancel(struct connectdata *conn) 143 { 144 destroy_async_data(&conn->async); 145 } 146 147 /* This function is used to init a threaded resolve */ 148 static bool init_resolve_thread(struct connectdata *conn, 149 const char *hostname, int port, 150 const struct addrinfo *hints); 151 152 153 /* Data for synchronization between resolver thread and its parent */ 154 struct thread_sync_data { 155 curl_mutex_t * mtx; 156 int done; 157 158 char *hostname; /* hostname to resolve, Curl_async.hostname 159 duplicate */ 160 int port; 161 int sock_error; 162 Curl_addrinfo *res; 163 #ifdef HAVE_GETADDRINFO 164 struct addrinfo hints; 165 #endif 166 struct thread_data *td; /* for thread-self cleanup */ 167 }; 168 169 struct thread_data { 170 curl_thread_t thread_hnd; 171 unsigned int poll_interval; 172 time_t interval_end; 173 struct thread_sync_data tsd; 174 }; 175 176 static struct thread_sync_data *conn_thread_sync_data(struct connectdata *conn) 177 { 178 return &(((struct thread_data *)conn->async.os_specific)->tsd); 179 } 180 181 #define CONN_THREAD_SYNC_DATA(conn) &(((conn)->async.os_specific)->tsd); 182 183 /* Destroy resolver thread synchronization data */ 184 static 185 void destroy_thread_sync_data(struct thread_sync_data * tsd) 186 { 187 if(tsd->mtx) { 188 Curl_mutex_destroy(tsd->mtx); 189 free(tsd->mtx); 190 } 191 192 free(tsd->hostname); 193 194 if(tsd->res) 195 Curl_freeaddrinfo(tsd->res); 196 197 memset(tsd, 0, sizeof(*tsd)); 198 } 199 200 /* Initialize resolver thread synchronization data */ 201 static 202 int init_thread_sync_data(struct thread_data * td, 203 const char *hostname, 204 int port, 205 const struct addrinfo *hints) 206 { 207 struct thread_sync_data *tsd = &td->tsd; 208 209 memset(tsd, 0, sizeof(*tsd)); 210 211 tsd->td = td; 212 tsd->port = port; 213 /* Treat the request as done until the thread actually starts so any early 214 * cleanup gets done properly. 215 */ 216 tsd->done = 1; 217 #ifdef HAVE_GETADDRINFO 218 DEBUGASSERT(hints); 219 tsd->hints = *hints; 220 #else 221 (void) hints; 222 #endif 223 224 tsd->mtx = malloc(sizeof(curl_mutex_t)); 225 if(tsd->mtx == NULL) 226 goto err_exit; 227 228 Curl_mutex_init(tsd->mtx); 229 230 tsd->sock_error = CURL_ASYNC_SUCCESS; 231 232 /* Copying hostname string because original can be destroyed by parent 233 * thread during gethostbyname execution. 234 */ 235 tsd->hostname = strdup(hostname); 236 if(!tsd->hostname) 237 goto err_exit; 238 239 return 1; 240 241 err_exit: 242 /* Memory allocation failed */ 243 destroy_thread_sync_data(tsd); 244 return 0; 245 } 246 247 static int getaddrinfo_complete(struct connectdata *conn) 248 { 249 struct thread_sync_data *tsd = conn_thread_sync_data(conn); 250 int rc; 251 252 rc = Curl_addrinfo_callback(conn, tsd->sock_error, tsd->res); 253 /* The tsd->res structure has been copied to async.dns and perhaps the DNS 254 cache. Set our copy to NULL so destroy_thread_sync_data doesn't free it. 255 */ 256 tsd->res = NULL; 257 258 return rc; 259 } 260 261 262 #ifdef HAVE_GETADDRINFO 263 264 /* 265 * getaddrinfo_thread() resolves a name and then exits. 266 * 267 * For builds without ARES, but with ENABLE_IPV6, create a resolver thread 268 * and wait on it. 269 */ 270 static unsigned int CURL_STDCALL getaddrinfo_thread(void *arg) 271 { 272 struct thread_sync_data *tsd = (struct thread_sync_data*)arg; 273 struct thread_data *td = tsd->td; 274 char service[12]; 275 int rc; 276 277 snprintf(service, sizeof(service), "%d", tsd->port); 278 279 rc = Curl_getaddrinfo_ex(tsd->hostname, service, &tsd->hints, &tsd->res); 280 281 if(rc != 0) { 282 tsd->sock_error = SOCKERRNO?SOCKERRNO:rc; 283 if(tsd->sock_error == 0) 284 tsd->sock_error = RESOLVER_ENOMEM; 285 } 286 else { 287 Curl_addrinfo_set_port(tsd->res, tsd->port); 288 } 289 290 Curl_mutex_acquire(tsd->mtx); 291 if(tsd->done) { 292 /* too late, gotta clean up the mess */ 293 Curl_mutex_release(tsd->mtx); 294 destroy_thread_sync_data(tsd); 295 free(td); 296 } 297 else { 298 tsd->done = 1; 299 Curl_mutex_release(tsd->mtx); 300 } 301 302 return 0; 303 } 304 305 #else /* HAVE_GETADDRINFO */ 306 307 /* 308 * gethostbyname_thread() resolves a name and then exits. 309 */ 310 static unsigned int CURL_STDCALL gethostbyname_thread(void *arg) 311 { 312 struct thread_sync_data *tsd = (struct thread_sync_data *)arg; 313 struct thread_data *td = tsd->td; 314 315 tsd->res = Curl_ipv4_resolve_r(tsd->hostname, tsd->port); 316 317 if(!tsd->res) { 318 tsd->sock_error = SOCKERRNO; 319 if(tsd->sock_error == 0) 320 tsd->sock_error = RESOLVER_ENOMEM; 321 } 322 323 Curl_mutex_acquire(tsd->mtx); 324 if(tsd->done) { 325 /* too late, gotta clean up the mess */ 326 Curl_mutex_release(tsd->mtx); 327 destroy_thread_sync_data(tsd); 328 free(td); 329 } 330 else { 331 tsd->done = 1; 332 Curl_mutex_release(tsd->mtx); 333 } 334 335 return 0; 336 } 337 338 #endif /* HAVE_GETADDRINFO */ 339 340 /* 341 * destroy_async_data() cleans up async resolver data and thread handle. 342 */ 343 static void destroy_async_data(struct Curl_async *async) 344 { 345 if(async->os_specific) { 346 struct thread_data *td = (struct thread_data*) async->os_specific; 347 int done; 348 349 /* 350 * if the thread is still blocking in the resolve syscall, detach it and 351 * let the thread do the cleanup... 352 */ 353 Curl_mutex_acquire(td->tsd.mtx); 354 done = td->tsd.done; 355 td->tsd.done = 1; 356 Curl_mutex_release(td->tsd.mtx); 357 358 if(!done) { 359 Curl_thread_destroy(td->thread_hnd); 360 } 361 else { 362 if(td->thread_hnd != curl_thread_t_null) 363 Curl_thread_join(&td->thread_hnd); 364 365 destroy_thread_sync_data(&td->tsd); 366 367 free(async->os_specific); 368 } 369 } 370 async->os_specific = NULL; 371 372 free(async->hostname); 373 async->hostname = NULL; 374 } 375 376 /* 377 * init_resolve_thread() starts a new thread that performs the actual 378 * resolve. This function returns before the resolve is done. 379 * 380 * Returns FALSE in case of failure, otherwise TRUE. 381 */ 382 static bool init_resolve_thread(struct connectdata *conn, 383 const char *hostname, int port, 384 const struct addrinfo *hints) 385 { 386 struct thread_data *td = calloc(1, sizeof(struct thread_data)); 387 int err = ENOMEM; 388 389 conn->async.os_specific = (void *)td; 390 if(!td) 391 goto errno_exit; 392 393 conn->async.port = port; 394 conn->async.done = FALSE; 395 conn->async.status = 0; 396 conn->async.dns = NULL; 397 td->thread_hnd = curl_thread_t_null; 398 399 if(!init_thread_sync_data(td, hostname, port, hints)) { 400 conn->async.os_specific = NULL; 401 free(td); 402 goto errno_exit; 403 } 404 405 free(conn->async.hostname); 406 conn->async.hostname = strdup(hostname); 407 if(!conn->async.hostname) 408 goto err_exit; 409 410 /* The thread will set this to 1 when complete. */ 411 td->tsd.done = 0; 412 413 #ifdef HAVE_GETADDRINFO 414 td->thread_hnd = Curl_thread_create(getaddrinfo_thread, &td->tsd); 415 #else 416 td->thread_hnd = Curl_thread_create(gethostbyname_thread, &td->tsd); 417 #endif 418 419 if(!td->thread_hnd) { 420 /* The thread never started, so mark it as done here for proper cleanup. */ 421 td->tsd.done = 1; 422 err = errno; 423 goto err_exit; 424 } 425 426 return TRUE; 427 428 err_exit: 429 destroy_async_data(&conn->async); 430 431 errno_exit: 432 errno = err; 433 return FALSE; 434 } 435 436 /* 437 * resolver_error() calls failf() with the appropriate message after a resolve 438 * error 439 */ 440 441 static CURLcode resolver_error(struct connectdata *conn) 442 { 443 const char *host_or_proxy; 444 CURLcode result; 445 446 if(conn->bits.httpproxy) { 447 host_or_proxy = "proxy"; 448 result = CURLE_COULDNT_RESOLVE_PROXY; 449 } 450 else { 451 host_or_proxy = "host"; 452 result = CURLE_COULDNT_RESOLVE_HOST; 453 } 454 455 failf(conn->data, "Could not resolve %s: %s", host_or_proxy, 456 conn->async.hostname); 457 458 return result; 459 } 460 461 /* 462 * Curl_resolver_wait_resolv() 463 * 464 * waits for a resolve to finish. This function should be avoided since using 465 * this risk getting the multi interface to "hang". 466 * 467 * If 'entry' is non-NULL, make it point to the resolved dns entry 468 * 469 * This is the version for resolves-in-a-thread. 470 */ 471 CURLcode Curl_resolver_wait_resolv(struct connectdata *conn, 472 struct Curl_dns_entry **entry) 473 { 474 struct thread_data *td = (struct thread_data*) conn->async.os_specific; 475 CURLcode result = CURLE_OK; 476 477 DEBUGASSERT(conn && td); 478 479 /* wait for the thread to resolve the name */ 480 if(Curl_thread_join(&td->thread_hnd)) 481 result = getaddrinfo_complete(conn); 482 else 483 DEBUGASSERT(0); 484 485 conn->async.done = TRUE; 486 487 if(entry) 488 *entry = conn->async.dns; 489 490 if(!conn->async.dns) 491 /* a name was not resolved, report error */ 492 result = resolver_error(conn); 493 494 destroy_async_data(&conn->async); 495 496 if(!conn->async.dns) 497 connclose(conn, "asynch resolve failed"); 498 499 return result; 500 } 501 502 /* 503 * Curl_resolver_is_resolved() is called repeatedly to check if a previous 504 * name resolve request has completed. It should also make sure to time-out if 505 * the operation seems to take too long. 506 */ 507 CURLcode Curl_resolver_is_resolved(struct connectdata *conn, 508 struct Curl_dns_entry **entry) 509 { 510 struct Curl_easy *data = conn->data; 511 struct thread_data *td = (struct thread_data*) conn->async.os_specific; 512 int done = 0; 513 514 *entry = NULL; 515 516 if(!td) { 517 DEBUGASSERT(td); 518 return CURLE_COULDNT_RESOLVE_HOST; 519 } 520 521 Curl_mutex_acquire(td->tsd.mtx); 522 done = td->tsd.done; 523 Curl_mutex_release(td->tsd.mtx); 524 525 if(done) { 526 getaddrinfo_complete(conn); 527 528 if(!conn->async.dns) { 529 CURLcode result = resolver_error(conn); 530 destroy_async_data(&conn->async); 531 return result; 532 } 533 destroy_async_data(&conn->async); 534 *entry = conn->async.dns; 535 } 536 else { 537 /* poll for name lookup done with exponential backoff up to 250ms */ 538 timediff_t elapsed = Curl_timediff(Curl_now(), 539 data->progress.t_startsingle); 540 if(elapsed < 0) 541 elapsed = 0; 542 543 if(td->poll_interval == 0) 544 /* Start at 1ms poll interval */ 545 td->poll_interval = 1; 546 else if(elapsed >= td->interval_end) 547 /* Back-off exponentially if last interval expired */ 548 td->poll_interval *= 2; 549 550 if(td->poll_interval > 250) 551 td->poll_interval = 250; 552 553 td->interval_end = elapsed + td->poll_interval; 554 Curl_expire(conn->data, td->poll_interval, EXPIRE_ASYNC_NAME); 555 } 556 557 return CURLE_OK; 558 } 559 560 int Curl_resolver_getsock(struct connectdata *conn, 561 curl_socket_t *socks, 562 int numsocks) 563 { 564 (void)conn; 565 (void)socks; 566 (void)numsocks; 567 return 0; 568 } 569 570 #ifndef HAVE_GETADDRINFO 571 /* 572 * Curl_getaddrinfo() - for platforms without getaddrinfo 573 */ 574 Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn, 575 const char *hostname, 576 int port, 577 int *waitp) 578 { 579 struct in_addr in; 580 581 *waitp = 0; /* default to synchronous response */ 582 583 if(Curl_inet_pton(AF_INET, hostname, &in) > 0) 584 /* This is a dotted IP address 123.123.123.123-style */ 585 return Curl_ip2addr(AF_INET, &in, hostname, port); 586 587 /* fire up a new resolver thread! */ 588 if(init_resolve_thread(conn, hostname, port, NULL)) { 589 *waitp = 1; /* expect asynchronous response */ 590 return NULL; 591 } 592 593 /* fall-back to blocking version */ 594 return Curl_ipv4_resolve_r(hostname, port); 595 } 596 597 #else /* !HAVE_GETADDRINFO */ 598 599 /* 600 * Curl_resolver_getaddrinfo() - for getaddrinfo 601 */ 602 Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn, 603 const char *hostname, 604 int port, 605 int *waitp) 606 { 607 struct addrinfo hints; 608 Curl_addrinfo *res; 609 int error; 610 char sbuf[12]; 611 int pf = PF_INET; 612 613 *waitp = 0; /* default to synchronous response */ 614 615 #ifndef USE_RESOLVE_ON_IPS 616 { 617 struct in_addr in; 618 /* First check if this is an IPv4 address string */ 619 if(Curl_inet_pton(AF_INET, hostname, &in) > 0) 620 /* This is a dotted IP address 123.123.123.123-style */ 621 return Curl_ip2addr(AF_INET, &in, hostname, port); 622 } 623 #ifdef CURLRES_IPV6 624 { 625 struct in6_addr in6; 626 /* check if this is an IPv6 address string */ 627 if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0) 628 /* This is an IPv6 address literal */ 629 return Curl_ip2addr(AF_INET6, &in6, hostname, port); 630 } 631 #endif /* CURLRES_IPV6 */ 632 #endif /* !USE_RESOLVE_ON_IPS */ 633 634 #ifdef CURLRES_IPV6 635 /* 636 * Check if a limited name resolve has been requested. 637 */ 638 switch(conn->ip_version) { 639 case CURL_IPRESOLVE_V4: 640 pf = PF_INET; 641 break; 642 case CURL_IPRESOLVE_V6: 643 pf = PF_INET6; 644 break; 645 default: 646 pf = PF_UNSPEC; 647 break; 648 } 649 650 if((pf != PF_INET) && !Curl_ipv6works()) 651 /* The stack seems to be a non-IPv6 one */ 652 pf = PF_INET; 653 #endif /* CURLRES_IPV6 */ 654 655 memset(&hints, 0, sizeof(hints)); 656 hints.ai_family = pf; 657 hints.ai_socktype = conn->socktype; 658 659 snprintf(sbuf, sizeof(sbuf), "%d", port); 660 661 /* fire up a new resolver thread! */ 662 if(init_resolve_thread(conn, hostname, port, &hints)) { 663 *waitp = 1; /* expect asynchronous response */ 664 return NULL; 665 } 666 667 /* fall-back to blocking version */ 668 infof(conn->data, "init_resolve_thread() failed for %s; %s\n", 669 hostname, Curl_strerror(conn, errno)); 670 671 error = Curl_getaddrinfo_ex(hostname, sbuf, &hints, &res); 672 if(error) { 673 infof(conn->data, "getaddrinfo() failed for %s:%d; %s\n", 674 hostname, port, Curl_strerror(conn, SOCKERRNO)); 675 return NULL; 676 } 677 else { 678 Curl_addrinfo_set_port(res, port); 679 } 680 681 return res; 682 } 683 684 #endif /* !HAVE_GETADDRINFO */ 685 686 CURLcode Curl_set_dns_servers(struct Curl_easy *data, 687 char *servers) 688 { 689 (void)data; 690 (void)servers; 691 return CURLE_NOT_BUILT_IN; 692 693 } 694 695 CURLcode Curl_set_dns_interface(struct Curl_easy *data, 696 const char *interf) 697 { 698 (void)data; 699 (void)interf; 700 return CURLE_NOT_BUILT_IN; 701 } 702 703 CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data, 704 const char *local_ip4) 705 { 706 (void)data; 707 (void)local_ip4; 708 return CURLE_NOT_BUILT_IN; 709 } 710 711 CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data, 712 const char *local_ip6) 713 { 714 (void)data; 715 (void)local_ip6; 716 return CURLE_NOT_BUILT_IN; 717 } 718 719 #endif /* CURLRES_THREADED */ 720
