lib/asyn-thread.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@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 */