Annotation of embedaddon/curl/lib/asyn-thread.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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: #include "socketpair.h"
! 25:
! 26: /***********************************************************************
! 27: * Only for threaded name resolves builds
! 28: **********************************************************************/
! 29: #ifdef CURLRES_THREADED
! 30:
! 31: #ifdef HAVE_NETINET_IN_H
! 32: #include <netinet/in.h>
! 33: #endif
! 34: #ifdef HAVE_NETDB_H
! 35: #include <netdb.h>
! 36: #endif
! 37: #ifdef HAVE_ARPA_INET_H
! 38: #include <arpa/inet.h>
! 39: #endif
! 40: #ifdef __VMS
! 41: #include <in.h>
! 42: #include <inet.h>
! 43: #endif
! 44:
! 45: #if defined(USE_THREADS_POSIX)
! 46: # ifdef HAVE_PTHREAD_H
! 47: # include <pthread.h>
! 48: # endif
! 49: #elif defined(USE_THREADS_WIN32)
! 50: # ifdef HAVE_PROCESS_H
! 51: # include <process.h>
! 52: # endif
! 53: #endif
! 54:
! 55: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
! 56: #undef in_addr_t
! 57: #define in_addr_t unsigned long
! 58: #endif
! 59:
! 60: #ifdef HAVE_GETADDRINFO
! 61: # define RESOLVER_ENOMEM EAI_MEMORY
! 62: #else
! 63: # define RESOLVER_ENOMEM ENOMEM
! 64: #endif
! 65:
! 66: #include "urldata.h"
! 67: #include "sendf.h"
! 68: #include "hostip.h"
! 69: #include "hash.h"
! 70: #include "share.h"
! 71: #include "strerror.h"
! 72: #include "url.h"
! 73: #include "multiif.h"
! 74: #include "inet_ntop.h"
! 75: #include "curl_threads.h"
! 76: #include "connect.h"
! 77: #include "socketpair.h"
! 78: /* The last 3 #include files should be in this order */
! 79: #include "curl_printf.h"
! 80: #include "curl_memory.h"
! 81: #include "memdebug.h"
! 82:
! 83: struct resdata {
! 84: struct curltime start;
! 85: };
! 86:
! 87: /*
! 88: * Curl_resolver_global_init()
! 89: * Called from curl_global_init() to initialize global resolver environment.
! 90: * Does nothing here.
! 91: */
! 92: int Curl_resolver_global_init(void)
! 93: {
! 94: return CURLE_OK;
! 95: }
! 96:
! 97: /*
! 98: * Curl_resolver_global_cleanup()
! 99: * Called from curl_global_cleanup() to destroy global resolver environment.
! 100: * Does nothing here.
! 101: */
! 102: void Curl_resolver_global_cleanup(void)
! 103: {
! 104: }
! 105:
! 106: /*
! 107: * Curl_resolver_init()
! 108: * Called from curl_easy_init() -> Curl_open() to initialize resolver
! 109: * URL-state specific environment ('resolver' member of the UrlState
! 110: * structure).
! 111: */
! 112: CURLcode Curl_resolver_init(struct Curl_easy *easy, void **resolver)
! 113: {
! 114: (void)easy;
! 115: *resolver = calloc(1, sizeof(struct resdata));
! 116: if(!*resolver)
! 117: return CURLE_OUT_OF_MEMORY;
! 118: return CURLE_OK;
! 119: }
! 120:
! 121: /*
! 122: * Curl_resolver_cleanup()
! 123: * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
! 124: * URL-state specific environment ('resolver' member of the UrlState
! 125: * structure).
! 126: */
! 127: void Curl_resolver_cleanup(void *resolver)
! 128: {
! 129: free(resolver);
! 130: }
! 131:
! 132: /*
! 133: * Curl_resolver_duphandle()
! 134: * Called from curl_easy_duphandle() to duplicate resolver URL state-specific
! 135: * environment ('resolver' member of the UrlState structure).
! 136: */
! 137: CURLcode Curl_resolver_duphandle(struct Curl_easy *easy, void **to, void *from)
! 138: {
! 139: (void)from;
! 140: return Curl_resolver_init(easy, to);
! 141: }
! 142:
! 143: static void destroy_async_data(struct Curl_async *);
! 144:
! 145: /*
! 146: * Cancel all possibly still on-going resolves for this connection.
! 147: */
! 148: void Curl_resolver_cancel(struct connectdata *conn)
! 149: {
! 150: destroy_async_data(&conn->async);
! 151: }
! 152:
! 153: /* This function is used to init a threaded resolve */
! 154: static bool init_resolve_thread(struct connectdata *conn,
! 155: const char *hostname, int port,
! 156: const struct addrinfo *hints);
! 157:
! 158:
! 159: /* Data for synchronization between resolver thread and its parent */
! 160: struct thread_sync_data {
! 161: curl_mutex_t * mtx;
! 162: int done;
! 163:
! 164: char *hostname; /* hostname to resolve, Curl_async.hostname
! 165: duplicate */
! 166: int port;
! 167: #ifdef USE_SOCKETPAIR
! 168: struct connectdata *conn;
! 169: curl_socket_t sock_pair[2]; /* socket pair */
! 170: #endif
! 171: int sock_error;
! 172: Curl_addrinfo *res;
! 173: #ifdef HAVE_GETADDRINFO
! 174: struct addrinfo hints;
! 175: #endif
! 176: struct thread_data *td; /* for thread-self cleanup */
! 177: };
! 178:
! 179: struct thread_data {
! 180: curl_thread_t thread_hnd;
! 181: unsigned int poll_interval;
! 182: time_t interval_end;
! 183: struct thread_sync_data tsd;
! 184: };
! 185:
! 186: static struct thread_sync_data *conn_thread_sync_data(struct connectdata *conn)
! 187: {
! 188: return &(((struct thread_data *)conn->async.os_specific)->tsd);
! 189: }
! 190:
! 191: /* Destroy resolver thread synchronization data */
! 192: static
! 193: void destroy_thread_sync_data(struct thread_sync_data * tsd)
! 194: {
! 195: if(tsd->mtx) {
! 196: Curl_mutex_destroy(tsd->mtx);
! 197: free(tsd->mtx);
! 198: }
! 199:
! 200: free(tsd->hostname);
! 201:
! 202: if(tsd->res)
! 203: Curl_freeaddrinfo(tsd->res);
! 204:
! 205: #ifdef USE_SOCKETPAIR
! 206: /*
! 207: * close one end of the socket pair (may be done in resolver thread);
! 208: * the other end (for reading) is always closed in the parent thread.
! 209: */
! 210: if(tsd->sock_pair[1] != CURL_SOCKET_BAD) {
! 211: sclose(tsd->sock_pair[1]);
! 212: }
! 213: #endif
! 214: memset(tsd, 0, sizeof(*tsd));
! 215: }
! 216:
! 217: /* Initialize resolver thread synchronization data */
! 218: static
! 219: int init_thread_sync_data(struct thread_data * td,
! 220: const char *hostname,
! 221: int port,
! 222: const struct addrinfo *hints)
! 223: {
! 224: struct thread_sync_data *tsd = &td->tsd;
! 225:
! 226: memset(tsd, 0, sizeof(*tsd));
! 227:
! 228: tsd->td = td;
! 229: tsd->port = port;
! 230: /* Treat the request as done until the thread actually starts so any early
! 231: * cleanup gets done properly.
! 232: */
! 233: tsd->done = 1;
! 234: #ifdef HAVE_GETADDRINFO
! 235: DEBUGASSERT(hints);
! 236: tsd->hints = *hints;
! 237: #else
! 238: (void) hints;
! 239: #endif
! 240:
! 241: tsd->mtx = malloc(sizeof(curl_mutex_t));
! 242: if(tsd->mtx == NULL)
! 243: goto err_exit;
! 244:
! 245: Curl_mutex_init(tsd->mtx);
! 246:
! 247: #ifdef USE_SOCKETPAIR
! 248: /* create socket pair, avoid AF_LOCAL since it doesn't build on Solaris */
! 249: if(Curl_socketpair(AF_UNIX, SOCK_STREAM, 0, &tsd->sock_pair[0]) < 0) {
! 250: tsd->sock_pair[0] = CURL_SOCKET_BAD;
! 251: tsd->sock_pair[1] = CURL_SOCKET_BAD;
! 252: goto err_exit;
! 253: }
! 254: #endif
! 255: tsd->sock_error = CURL_ASYNC_SUCCESS;
! 256:
! 257: /* Copying hostname string because original can be destroyed by parent
! 258: * thread during gethostbyname execution.
! 259: */
! 260: tsd->hostname = strdup(hostname);
! 261: if(!tsd->hostname)
! 262: goto err_exit;
! 263:
! 264: return 1;
! 265:
! 266: err_exit:
! 267: /* Memory allocation failed */
! 268: destroy_thread_sync_data(tsd);
! 269: return 0;
! 270: }
! 271:
! 272: static int getaddrinfo_complete(struct connectdata *conn)
! 273: {
! 274: struct thread_sync_data *tsd = conn_thread_sync_data(conn);
! 275: int rc;
! 276:
! 277: rc = Curl_addrinfo_callback(conn, tsd->sock_error, tsd->res);
! 278: /* The tsd->res structure has been copied to async.dns and perhaps the DNS
! 279: cache. Set our copy to NULL so destroy_thread_sync_data doesn't free it.
! 280: */
! 281: tsd->res = NULL;
! 282:
! 283: return rc;
! 284: }
! 285:
! 286:
! 287: #ifdef HAVE_GETADDRINFO
! 288:
! 289: /*
! 290: * getaddrinfo_thread() resolves a name and then exits.
! 291: *
! 292: * For builds without ARES, but with ENABLE_IPV6, create a resolver thread
! 293: * and wait on it.
! 294: */
! 295: static unsigned int CURL_STDCALL getaddrinfo_thread(void *arg)
! 296: {
! 297: struct thread_sync_data *tsd = (struct thread_sync_data*)arg;
! 298: struct thread_data *td = tsd->td;
! 299: char service[12];
! 300: int rc;
! 301: #ifdef USE_SOCKETPAIR
! 302: char buf[1];
! 303: #endif
! 304:
! 305: msnprintf(service, sizeof(service), "%d", tsd->port);
! 306:
! 307: rc = Curl_getaddrinfo_ex(tsd->hostname, service, &tsd->hints, &tsd->res);
! 308:
! 309: if(rc != 0) {
! 310: tsd->sock_error = SOCKERRNO?SOCKERRNO:rc;
! 311: if(tsd->sock_error == 0)
! 312: tsd->sock_error = RESOLVER_ENOMEM;
! 313: }
! 314: else {
! 315: Curl_addrinfo_set_port(tsd->res, tsd->port);
! 316: }
! 317:
! 318: Curl_mutex_acquire(tsd->mtx);
! 319: if(tsd->done) {
! 320: /* too late, gotta clean up the mess */
! 321: Curl_mutex_release(tsd->mtx);
! 322: destroy_thread_sync_data(tsd);
! 323: free(td);
! 324: }
! 325: else {
! 326: #ifdef USE_SOCKETPAIR
! 327: if(tsd->sock_pair[1] != CURL_SOCKET_BAD) {
! 328: /* DNS has been resolved, signal client task */
! 329: buf[0] = 1;
! 330: if(swrite(tsd->sock_pair[1], buf, sizeof(buf)) < 0) {
! 331: /* update sock_erro to errno */
! 332: tsd->sock_error = SOCKERRNO;
! 333: }
! 334: }
! 335: #endif
! 336: tsd->done = 1;
! 337: Curl_mutex_release(tsd->mtx);
! 338: }
! 339:
! 340: return 0;
! 341: }
! 342:
! 343: #else /* HAVE_GETADDRINFO */
! 344:
! 345: /*
! 346: * gethostbyname_thread() resolves a name and then exits.
! 347: */
! 348: static unsigned int CURL_STDCALL gethostbyname_thread(void *arg)
! 349: {
! 350: struct thread_sync_data *tsd = (struct thread_sync_data *)arg;
! 351: struct thread_data *td = tsd->td;
! 352:
! 353: tsd->res = Curl_ipv4_resolve_r(tsd->hostname, tsd->port);
! 354:
! 355: if(!tsd->res) {
! 356: tsd->sock_error = SOCKERRNO;
! 357: if(tsd->sock_error == 0)
! 358: tsd->sock_error = RESOLVER_ENOMEM;
! 359: }
! 360:
! 361: Curl_mutex_acquire(tsd->mtx);
! 362: if(tsd->done) {
! 363: /* too late, gotta clean up the mess */
! 364: Curl_mutex_release(tsd->mtx);
! 365: destroy_thread_sync_data(tsd);
! 366: free(td);
! 367: }
! 368: else {
! 369: tsd->done = 1;
! 370: Curl_mutex_release(tsd->mtx);
! 371: }
! 372:
! 373: return 0;
! 374: }
! 375:
! 376: #endif /* HAVE_GETADDRINFO */
! 377:
! 378: /*
! 379: * destroy_async_data() cleans up async resolver data and thread handle.
! 380: */
! 381: static void destroy_async_data(struct Curl_async *async)
! 382: {
! 383: if(async->os_specific) {
! 384: struct thread_data *td = (struct thread_data*) async->os_specific;
! 385: int done;
! 386: #ifdef USE_SOCKETPAIR
! 387: curl_socket_t sock_rd = td->tsd.sock_pair[0];
! 388: struct connectdata *conn = td->tsd.conn;
! 389: #endif
! 390:
! 391: /*
! 392: * if the thread is still blocking in the resolve syscall, detach it and
! 393: * let the thread do the cleanup...
! 394: */
! 395: Curl_mutex_acquire(td->tsd.mtx);
! 396: done = td->tsd.done;
! 397: td->tsd.done = 1;
! 398: Curl_mutex_release(td->tsd.mtx);
! 399:
! 400: if(!done) {
! 401: Curl_thread_destroy(td->thread_hnd);
! 402: }
! 403: else {
! 404: if(td->thread_hnd != curl_thread_t_null)
! 405: Curl_thread_join(&td->thread_hnd);
! 406:
! 407: destroy_thread_sync_data(&td->tsd);
! 408:
! 409: free(async->os_specific);
! 410: }
! 411: #ifdef USE_SOCKETPAIR
! 412: /*
! 413: * ensure CURLMOPT_SOCKETFUNCTION fires CURL_POLL_REMOVE
! 414: * before the FD is invalidated to avoid EBADF on EPOLL_CTL_DEL
! 415: */
! 416: if(conn)
! 417: Curl_multi_closed(conn->data, sock_rd);
! 418: sclose(sock_rd);
! 419: #endif
! 420: }
! 421: async->os_specific = NULL;
! 422:
! 423: free(async->hostname);
! 424: async->hostname = NULL;
! 425: }
! 426:
! 427: /*
! 428: * init_resolve_thread() starts a new thread that performs the actual
! 429: * resolve. This function returns before the resolve is done.
! 430: *
! 431: * Returns FALSE in case of failure, otherwise TRUE.
! 432: */
! 433: static bool init_resolve_thread(struct connectdata *conn,
! 434: const char *hostname, int port,
! 435: const struct addrinfo *hints)
! 436: {
! 437: struct thread_data *td = calloc(1, sizeof(struct thread_data));
! 438: int err = ENOMEM;
! 439:
! 440: conn->async.os_specific = (void *)td;
! 441: if(!td)
! 442: goto errno_exit;
! 443:
! 444: conn->async.port = port;
! 445: conn->async.done = FALSE;
! 446: conn->async.status = 0;
! 447: conn->async.dns = NULL;
! 448: td->thread_hnd = curl_thread_t_null;
! 449:
! 450: if(!init_thread_sync_data(td, hostname, port, hints)) {
! 451: conn->async.os_specific = NULL;
! 452: free(td);
! 453: goto errno_exit;
! 454: }
! 455:
! 456: free(conn->async.hostname);
! 457: conn->async.hostname = strdup(hostname);
! 458: if(!conn->async.hostname)
! 459: goto err_exit;
! 460:
! 461: /* The thread will set this to 1 when complete. */
! 462: td->tsd.done = 0;
! 463:
! 464: #ifdef HAVE_GETADDRINFO
! 465: td->thread_hnd = Curl_thread_create(getaddrinfo_thread, &td->tsd);
! 466: #else
! 467: td->thread_hnd = Curl_thread_create(gethostbyname_thread, &td->tsd);
! 468: #endif
! 469:
! 470: if(!td->thread_hnd) {
! 471: /* The thread never started, so mark it as done here for proper cleanup. */
! 472: td->tsd.done = 1;
! 473: err = errno;
! 474: goto err_exit;
! 475: }
! 476:
! 477: return TRUE;
! 478:
! 479: err_exit:
! 480: destroy_async_data(&conn->async);
! 481:
! 482: errno_exit:
! 483: errno = err;
! 484: return FALSE;
! 485: }
! 486:
! 487: /*
! 488: * resolver_error() calls failf() with the appropriate message after a resolve
! 489: * error
! 490: */
! 491:
! 492: static CURLcode resolver_error(struct connectdata *conn)
! 493: {
! 494: const char *host_or_proxy;
! 495: CURLcode result;
! 496:
! 497: if(conn->bits.httpproxy) {
! 498: host_or_proxy = "proxy";
! 499: result = CURLE_COULDNT_RESOLVE_PROXY;
! 500: }
! 501: else {
! 502: host_or_proxy = "host";
! 503: result = CURLE_COULDNT_RESOLVE_HOST;
! 504: }
! 505:
! 506: failf(conn->data, "Could not resolve %s: %s", host_or_proxy,
! 507: conn->async.hostname);
! 508:
! 509: return result;
! 510: }
! 511:
! 512: static CURLcode thread_wait_resolv(struct connectdata *conn,
! 513: struct Curl_dns_entry **entry,
! 514: bool report)
! 515: {
! 516: struct thread_data *td = (struct thread_data*) conn->async.os_specific;
! 517: CURLcode result = CURLE_OK;
! 518:
! 519: DEBUGASSERT(conn && td);
! 520: DEBUGASSERT(td->thread_hnd != curl_thread_t_null);
! 521:
! 522: /* wait for the thread to resolve the name */
! 523: if(Curl_thread_join(&td->thread_hnd)) {
! 524: if(entry)
! 525: result = getaddrinfo_complete(conn);
! 526: }
! 527: else
! 528: DEBUGASSERT(0);
! 529:
! 530: conn->async.done = TRUE;
! 531:
! 532: if(entry)
! 533: *entry = conn->async.dns;
! 534:
! 535: if(!conn->async.dns && report)
! 536: /* a name was not resolved, report error */
! 537: result = resolver_error(conn);
! 538:
! 539: destroy_async_data(&conn->async);
! 540:
! 541: if(!conn->async.dns && report)
! 542: connclose(conn, "asynch resolve failed");
! 543:
! 544: return result;
! 545: }
! 546:
! 547:
! 548: /*
! 549: * Until we gain a way to signal the resolver threads to stop early, we must
! 550: * simply wait for them and ignore their results.
! 551: */
! 552: void Curl_resolver_kill(struct connectdata *conn)
! 553: {
! 554: struct thread_data *td = (struct thread_data*) conn->async.os_specific;
! 555:
! 556: /* If we're still resolving, we must wait for the threads to fully clean up,
! 557: unfortunately. Otherwise, we can simply cancel to clean up any resolver
! 558: data. */
! 559: if(td && td->thread_hnd != curl_thread_t_null)
! 560: (void)thread_wait_resolv(conn, NULL, FALSE);
! 561: else
! 562: Curl_resolver_cancel(conn);
! 563: }
! 564:
! 565: /*
! 566: * Curl_resolver_wait_resolv()
! 567: *
! 568: * Waits for a resolve to finish. This function should be avoided since using
! 569: * this risk getting the multi interface to "hang".
! 570: *
! 571: * If 'entry' is non-NULL, make it point to the resolved dns entry
! 572: *
! 573: * Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved,
! 574: * CURLE_OPERATION_TIMEDOUT if a time-out occurred, or other errors.
! 575: *
! 576: * This is the version for resolves-in-a-thread.
! 577: */
! 578: CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
! 579: struct Curl_dns_entry **entry)
! 580: {
! 581: return thread_wait_resolv(conn, entry, TRUE);
! 582: }
! 583:
! 584: /*
! 585: * Curl_resolver_is_resolved() is called repeatedly to check if a previous
! 586: * name resolve request has completed. It should also make sure to time-out if
! 587: * the operation seems to take too long.
! 588: */
! 589: CURLcode Curl_resolver_is_resolved(struct connectdata *conn,
! 590: struct Curl_dns_entry **entry)
! 591: {
! 592: struct Curl_easy *data = conn->data;
! 593: struct thread_data *td = (struct thread_data*) conn->async.os_specific;
! 594: int done = 0;
! 595:
! 596: *entry = NULL;
! 597:
! 598: if(!td) {
! 599: DEBUGASSERT(td);
! 600: return CURLE_COULDNT_RESOLVE_HOST;
! 601: }
! 602:
! 603: Curl_mutex_acquire(td->tsd.mtx);
! 604: done = td->tsd.done;
! 605: Curl_mutex_release(td->tsd.mtx);
! 606:
! 607: if(done) {
! 608: getaddrinfo_complete(conn);
! 609:
! 610: if(!conn->async.dns) {
! 611: CURLcode result = resolver_error(conn);
! 612: destroy_async_data(&conn->async);
! 613: return result;
! 614: }
! 615: destroy_async_data(&conn->async);
! 616: *entry = conn->async.dns;
! 617: }
! 618: else {
! 619: /* poll for name lookup done with exponential backoff up to 250ms */
! 620: /* should be fine even if this converts to 32 bit */
! 621: time_t elapsed = (time_t)Curl_timediff(Curl_now(),
! 622: data->progress.t_startsingle);
! 623: if(elapsed < 0)
! 624: elapsed = 0;
! 625:
! 626: if(td->poll_interval == 0)
! 627: /* Start at 1ms poll interval */
! 628: td->poll_interval = 1;
! 629: else if(elapsed >= td->interval_end)
! 630: /* Back-off exponentially if last interval expired */
! 631: td->poll_interval *= 2;
! 632:
! 633: if(td->poll_interval > 250)
! 634: td->poll_interval = 250;
! 635:
! 636: td->interval_end = elapsed + td->poll_interval;
! 637: Curl_expire(conn->data, td->poll_interval, EXPIRE_ASYNC_NAME);
! 638: }
! 639:
! 640: return CURLE_OK;
! 641: }
! 642:
! 643: int Curl_resolver_getsock(struct connectdata *conn,
! 644: curl_socket_t *socks)
! 645: {
! 646: int ret_val = 0;
! 647: time_t milli;
! 648: timediff_t ms;
! 649: struct Curl_easy *data = conn->data;
! 650: struct resdata *reslv = (struct resdata *)data->state.resolver;
! 651: #ifdef USE_SOCKETPAIR
! 652: struct thread_data *td = (struct thread_data*)conn->async.os_specific;
! 653: #else
! 654: (void)socks;
! 655: #endif
! 656:
! 657: #ifdef USE_SOCKETPAIR
! 658: if(td) {
! 659: /* return read fd to client for polling the DNS resolution status */
! 660: socks[0] = td->tsd.sock_pair[0];
! 661: DEBUGASSERT(td->tsd.conn == conn || !td->tsd.conn);
! 662: td->tsd.conn = conn;
! 663: ret_val = GETSOCK_READSOCK(0);
! 664: }
! 665: else {
! 666: #endif
! 667: ms = Curl_timediff(Curl_now(), reslv->start);
! 668: if(ms < 3)
! 669: milli = 0;
! 670: else if(ms <= 50)
! 671: milli = (time_t)ms/3;
! 672: else if(ms <= 250)
! 673: milli = 50;
! 674: else
! 675: milli = 200;
! 676: Curl_expire(data, milli, EXPIRE_ASYNC_NAME);
! 677: #ifdef USE_SOCKETPAIR
! 678: }
! 679: #endif
! 680:
! 681:
! 682: return ret_val;
! 683: }
! 684:
! 685: #ifndef HAVE_GETADDRINFO
! 686: /*
! 687: * Curl_getaddrinfo() - for platforms without getaddrinfo
! 688: */
! 689: Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn,
! 690: const char *hostname,
! 691: int port,
! 692: int *waitp)
! 693: {
! 694: struct Curl_easy *data = conn->data;
! 695: struct resdata *reslv = (struct resdata *)data->state.resolver;
! 696:
! 697: *waitp = 0; /* default to synchronous response */
! 698:
! 699: reslv->start = Curl_now();
! 700:
! 701: /* fire up a new resolver thread! */
! 702: if(init_resolve_thread(conn, hostname, port, NULL)) {
! 703: *waitp = 1; /* expect asynchronous response */
! 704: return NULL;
! 705: }
! 706:
! 707: failf(conn->data, "getaddrinfo() thread failed\n");
! 708:
! 709: return NULL;
! 710: }
! 711:
! 712: #else /* !HAVE_GETADDRINFO */
! 713:
! 714: /*
! 715: * Curl_resolver_getaddrinfo() - for getaddrinfo
! 716: */
! 717: Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn,
! 718: const char *hostname,
! 719: int port,
! 720: int *waitp)
! 721: {
! 722: struct addrinfo hints;
! 723: int pf = PF_INET;
! 724: struct Curl_easy *data = conn->data;
! 725: struct resdata *reslv = (struct resdata *)data->state.resolver;
! 726:
! 727: *waitp = 0; /* default to synchronous response */
! 728:
! 729: #ifdef CURLRES_IPV6
! 730: /*
! 731: * Check if a limited name resolve has been requested.
! 732: */
! 733: switch(conn->ip_version) {
! 734: case CURL_IPRESOLVE_V4:
! 735: pf = PF_INET;
! 736: break;
! 737: case CURL_IPRESOLVE_V6:
! 738: pf = PF_INET6;
! 739: break;
! 740: default:
! 741: pf = PF_UNSPEC;
! 742: break;
! 743: }
! 744:
! 745: if((pf != PF_INET) && !Curl_ipv6works(conn))
! 746: /* The stack seems to be a non-IPv6 one */
! 747: pf = PF_INET;
! 748: #endif /* CURLRES_IPV6 */
! 749:
! 750: memset(&hints, 0, sizeof(hints));
! 751: hints.ai_family = pf;
! 752: hints.ai_socktype = (conn->transport == TRNSPRT_TCP)?
! 753: SOCK_STREAM : SOCK_DGRAM;
! 754:
! 755: reslv->start = Curl_now();
! 756: /* fire up a new resolver thread! */
! 757: if(init_resolve_thread(conn, hostname, port, &hints)) {
! 758: *waitp = 1; /* expect asynchronous response */
! 759: return NULL;
! 760: }
! 761:
! 762: failf(data, "getaddrinfo() thread failed to start\n");
! 763: return NULL;
! 764:
! 765: }
! 766:
! 767: #endif /* !HAVE_GETADDRINFO */
! 768:
! 769: CURLcode Curl_set_dns_servers(struct Curl_easy *data,
! 770: char *servers)
! 771: {
! 772: (void)data;
! 773: (void)servers;
! 774: return CURLE_NOT_BUILT_IN;
! 775:
! 776: }
! 777:
! 778: CURLcode Curl_set_dns_interface(struct Curl_easy *data,
! 779: const char *interf)
! 780: {
! 781: (void)data;
! 782: (void)interf;
! 783: return CURLE_NOT_BUILT_IN;
! 784: }
! 785:
! 786: CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
! 787: const char *local_ip4)
! 788: {
! 789: (void)data;
! 790: (void)local_ip4;
! 791: return CURLE_NOT_BUILT_IN;
! 792: }
! 793:
! 794: CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
! 795: const char *local_ip6)
! 796: {
! 797: (void)data;
! 798: (void)local_ip6;
! 799: return CURLE_NOT_BUILT_IN;
! 800: }
! 801:
! 802: #endif /* CURLRES_THREADED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to asyn-thread.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib