lib/asyn-thread.c

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