Annotation of embedaddon/curl/lib/asyn-ares.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:
! 25: /***********************************************************************
! 26: * Only for ares-enabled builds
! 27: * And only for functions that fulfill the asynch resolver backend API
! 28: * as defined in asyn.h, nothing else belongs in this file!
! 29: **********************************************************************/
! 30:
! 31: #ifdef CURLRES_ARES
! 32:
! 33: #include <limits.h>
! 34: #ifdef HAVE_NETINET_IN_H
! 35: #include <netinet/in.h>
! 36: #endif
! 37: #ifdef HAVE_NETDB_H
! 38: #include <netdb.h>
! 39: #endif
! 40: #ifdef HAVE_ARPA_INET_H
! 41: #include <arpa/inet.h>
! 42: #endif
! 43: #ifdef __VMS
! 44: #include <in.h>
! 45: #include <inet.h>
! 46: #endif
! 47:
! 48: #ifdef HAVE_PROCESS_H
! 49: #include <process.h>
! 50: #endif
! 51:
! 52: #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
! 53: #undef in_addr_t
! 54: #define in_addr_t unsigned long
! 55: #endif
! 56:
! 57: #include "urldata.h"
! 58: #include "sendf.h"
! 59: #include "hostip.h"
! 60: #include "hash.h"
! 61: #include "share.h"
! 62: #include "strerror.h"
! 63: #include "url.h"
! 64: #include "multiif.h"
! 65: #include "inet_pton.h"
! 66: #include "connect.h"
! 67: #include "select.h"
! 68: #include "progress.h"
! 69:
! 70: # if defined(CURL_STATICLIB) && !defined(CARES_STATICLIB) && \
! 71: (defined(WIN32) || defined(__SYMBIAN32__))
! 72: # define CARES_STATICLIB
! 73: # endif
! 74: # include <ares.h>
! 75: # include <ares_version.h> /* really old c-ares didn't include this by
! 76: itself */
! 77:
! 78: #if ARES_VERSION >= 0x010500
! 79: /* c-ares 1.5.0 or later, the callback proto is modified */
! 80: #define HAVE_CARES_CALLBACK_TIMEOUTS 1
! 81: #endif
! 82:
! 83: /* The last 3 #include files should be in this order */
! 84: #include "curl_printf.h"
! 85: #include "curl_memory.h"
! 86: #include "memdebug.h"
! 87:
! 88: struct ResolverResults {
! 89: int num_pending; /* number of ares_gethostbyname() requests */
! 90: Curl_addrinfo *temp_ai; /* intermediary result while fetching c-ares parts */
! 91: int last_status;
! 92: struct curltime happy_eyeballs_dns_time; /* when this timer started, or 0 */
! 93: };
! 94:
! 95: /* How long we are willing to wait for additional parallel responses after
! 96: obtaining a "definitive" one.
! 97:
! 98: This is intended to equal the c-ares default timeout. cURL always uses that
! 99: default value. Unfortunately, c-ares doesn't expose its default timeout in
! 100: its API, but it is officially documented as 5 seconds.
! 101:
! 102: See query_completed_cb() for an explanation of how this is used.
! 103: */
! 104: #define HAPPY_EYEBALLS_DNS_TIMEOUT 5000
! 105:
! 106: /*
! 107: * Curl_resolver_global_init() - the generic low-level asynchronous name
! 108: * resolve API. Called from curl_global_init() to initialize global resolver
! 109: * environment. Initializes ares library.
! 110: */
! 111: int Curl_resolver_global_init(void)
! 112: {
! 113: #ifdef CARES_HAVE_ARES_LIBRARY_INIT
! 114: if(ares_library_init(ARES_LIB_INIT_ALL)) {
! 115: return CURLE_FAILED_INIT;
! 116: }
! 117: #endif
! 118: return CURLE_OK;
! 119: }
! 120:
! 121: /*
! 122: * Curl_resolver_global_cleanup()
! 123: *
! 124: * Called from curl_global_cleanup() to destroy global resolver environment.
! 125: * Deinitializes ares library.
! 126: */
! 127: void Curl_resolver_global_cleanup(void)
! 128: {
! 129: #ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
! 130: ares_library_cleanup();
! 131: #endif
! 132: }
! 133:
! 134:
! 135: static void Curl_ares_sock_state_cb(void *data, ares_socket_t socket_fd,
! 136: int readable, int writable)
! 137: {
! 138: struct Curl_easy *easy = data;
! 139: if(!readable && !writable) {
! 140: DEBUGASSERT(easy);
! 141: Curl_multi_closed(easy, socket_fd);
! 142: }
! 143: }
! 144:
! 145: /*
! 146: * Curl_resolver_init()
! 147: *
! 148: * Called from curl_easy_init() -> Curl_open() to initialize resolver
! 149: * URL-state specific environment ('resolver' member of the UrlState
! 150: * structure). Fills the passed pointer by the initialized ares_channel.
! 151: */
! 152: CURLcode Curl_resolver_init(struct Curl_easy *easy, void **resolver)
! 153: {
! 154: int status;
! 155: struct ares_options options;
! 156: int optmask = ARES_OPT_SOCK_STATE_CB;
! 157: options.sock_state_cb = Curl_ares_sock_state_cb;
! 158: options.sock_state_cb_data = easy;
! 159: status = ares_init_options((ares_channel*)resolver, &options, optmask);
! 160: if(status != ARES_SUCCESS) {
! 161: if(status == ARES_ENOMEM)
! 162: return CURLE_OUT_OF_MEMORY;
! 163: else
! 164: return CURLE_FAILED_INIT;
! 165: }
! 166: return CURLE_OK;
! 167: /* make sure that all other returns from this function should destroy the
! 168: ares channel before returning error! */
! 169: }
! 170:
! 171: /*
! 172: * Curl_resolver_cleanup()
! 173: *
! 174: * Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
! 175: * URL-state specific environment ('resolver' member of the UrlState
! 176: * structure). Destroys the ares channel.
! 177: */
! 178: void Curl_resolver_cleanup(void *resolver)
! 179: {
! 180: ares_destroy((ares_channel)resolver);
! 181: }
! 182:
! 183: /*
! 184: * Curl_resolver_duphandle()
! 185: *
! 186: * Called from curl_easy_duphandle() to duplicate resolver URL-state specific
! 187: * environment ('resolver' member of the UrlState structure). Duplicates the
! 188: * 'from' ares channel and passes the resulting channel to the 'to' pointer.
! 189: */
! 190: CURLcode Curl_resolver_duphandle(struct Curl_easy *easy, void **to, void *from)
! 191: {
! 192: (void)from;
! 193: /*
! 194: * it would be better to call ares_dup instead, but right now
! 195: * it is not possible to set 'sock_state_cb_data' outside of
! 196: * ares_init_options
! 197: */
! 198: return Curl_resolver_init(easy, to);
! 199: }
! 200:
! 201: static void destroy_async_data(struct Curl_async *async);
! 202:
! 203: /*
! 204: * Cancel all possibly still on-going resolves for this connection.
! 205: */
! 206: void Curl_resolver_cancel(struct connectdata *conn)
! 207: {
! 208: if(conn->data && conn->data->state.resolver)
! 209: ares_cancel((ares_channel)conn->data->state.resolver);
! 210: destroy_async_data(&conn->async);
! 211: }
! 212:
! 213: /*
! 214: * We're equivalent to Curl_resolver_cancel() for the c-ares resolver. We
! 215: * never block.
! 216: */
! 217: void Curl_resolver_kill(struct connectdata *conn)
! 218: {
! 219: /* We don't need to check the resolver state because we can be called safely
! 220: at any time and we always do the same thing. */
! 221: Curl_resolver_cancel(conn);
! 222: }
! 223:
! 224: /*
! 225: * destroy_async_data() cleans up async resolver data.
! 226: */
! 227: static void destroy_async_data(struct Curl_async *async)
! 228: {
! 229: free(async->hostname);
! 230:
! 231: if(async->os_specific) {
! 232: struct ResolverResults *res = (struct ResolverResults *)async->os_specific;
! 233: if(res) {
! 234: if(res->temp_ai) {
! 235: Curl_freeaddrinfo(res->temp_ai);
! 236: res->temp_ai = NULL;
! 237: }
! 238: free(res);
! 239: }
! 240: async->os_specific = NULL;
! 241: }
! 242:
! 243: async->hostname = NULL;
! 244: }
! 245:
! 246: /*
! 247: * Curl_resolver_getsock() is called when someone from the outside world
! 248: * (using curl_multi_fdset()) wants to get our fd_set setup and we're talking
! 249: * with ares. The caller must make sure that this function is only called when
! 250: * we have a working ares channel.
! 251: *
! 252: * Returns: sockets-in-use-bitmap
! 253: */
! 254:
! 255: int Curl_resolver_getsock(struct connectdata *conn,
! 256: curl_socket_t *socks)
! 257: {
! 258: struct timeval maxtime;
! 259: struct timeval timebuf;
! 260: struct timeval *timeout;
! 261: long milli;
! 262: int max = ares_getsock((ares_channel)conn->data->state.resolver,
! 263: (ares_socket_t *)socks, MAX_SOCKSPEREASYHANDLE);
! 264:
! 265: maxtime.tv_sec = CURL_TIMEOUT_RESOLVE;
! 266: maxtime.tv_usec = 0;
! 267:
! 268: timeout = ares_timeout((ares_channel)conn->data->state.resolver, &maxtime,
! 269: &timebuf);
! 270: milli = (timeout->tv_sec * 1000) + (timeout->tv_usec/1000);
! 271: if(milli == 0)
! 272: milli += 10;
! 273: Curl_expire(conn->data, milli, EXPIRE_ASYNC_NAME);
! 274:
! 275: return max;
! 276: }
! 277:
! 278: /*
! 279: * waitperform()
! 280: *
! 281: * 1) Ask ares what sockets it currently plays with, then
! 282: * 2) wait for the timeout period to check for action on ares' sockets.
! 283: * 3) tell ares to act on all the sockets marked as "with action"
! 284: *
! 285: * return number of sockets it worked on
! 286: */
! 287:
! 288: static int waitperform(struct connectdata *conn, int timeout_ms)
! 289: {
! 290: struct Curl_easy *data = conn->data;
! 291: int nfds;
! 292: int bitmask;
! 293: ares_socket_t socks[ARES_GETSOCK_MAXNUM];
! 294: struct pollfd pfd[ARES_GETSOCK_MAXNUM];
! 295: int i;
! 296: int num = 0;
! 297:
! 298: bitmask = ares_getsock((ares_channel)data->state.resolver, socks,
! 299: ARES_GETSOCK_MAXNUM);
! 300:
! 301: for(i = 0; i < ARES_GETSOCK_MAXNUM; i++) {
! 302: pfd[i].events = 0;
! 303: pfd[i].revents = 0;
! 304: if(ARES_GETSOCK_READABLE(bitmask, i)) {
! 305: pfd[i].fd = socks[i];
! 306: pfd[i].events |= POLLRDNORM|POLLIN;
! 307: }
! 308: if(ARES_GETSOCK_WRITABLE(bitmask, i)) {
! 309: pfd[i].fd = socks[i];
! 310: pfd[i].events |= POLLWRNORM|POLLOUT;
! 311: }
! 312: if(pfd[i].events != 0)
! 313: num++;
! 314: else
! 315: break;
! 316: }
! 317:
! 318: if(num)
! 319: nfds = Curl_poll(pfd, num, timeout_ms);
! 320: else
! 321: nfds = 0;
! 322:
! 323: if(!nfds)
! 324: /* Call ares_process() unconditonally here, even if we simply timed out
! 325: above, as otherwise the ares name resolve won't timeout! */
! 326: ares_process_fd((ares_channel)data->state.resolver, ARES_SOCKET_BAD,
! 327: ARES_SOCKET_BAD);
! 328: else {
! 329: /* move through the descriptors and ask for processing on them */
! 330: for(i = 0; i < num; i++)
! 331: ares_process_fd((ares_channel)data->state.resolver,
! 332: (pfd[i].revents & (POLLRDNORM|POLLIN))?
! 333: pfd[i].fd:ARES_SOCKET_BAD,
! 334: (pfd[i].revents & (POLLWRNORM|POLLOUT))?
! 335: pfd[i].fd:ARES_SOCKET_BAD);
! 336: }
! 337: return nfds;
! 338: }
! 339:
! 340: /*
! 341: * Curl_resolver_is_resolved() is called repeatedly to check if a previous
! 342: * name resolve request has completed. It should also make sure to time-out if
! 343: * the operation seems to take too long.
! 344: *
! 345: * Returns normal CURLcode errors.
! 346: */
! 347: CURLcode Curl_resolver_is_resolved(struct connectdata *conn,
! 348: struct Curl_dns_entry **dns)
! 349: {
! 350: struct Curl_easy *data = conn->data;
! 351: struct ResolverResults *res = (struct ResolverResults *)
! 352: conn->async.os_specific;
! 353: CURLcode result = CURLE_OK;
! 354:
! 355: if(dns)
! 356: *dns = NULL;
! 357:
! 358: waitperform(conn, 0);
! 359:
! 360: /* Now that we've checked for any last minute results above, see if there are
! 361: any responses still pending when the EXPIRE_HAPPY_EYEBALLS_DNS timer
! 362: expires. */
! 363: if(res
! 364: && res->num_pending
! 365: /* This is only set to non-zero if the timer was started. */
! 366: && (res->happy_eyeballs_dns_time.tv_sec
! 367: || res->happy_eyeballs_dns_time.tv_usec)
! 368: && (Curl_timediff(Curl_now(), res->happy_eyeballs_dns_time)
! 369: >= HAPPY_EYEBALLS_DNS_TIMEOUT)) {
! 370: /* Remember that the EXPIRE_HAPPY_EYEBALLS_DNS timer is no longer
! 371: running. */
! 372: memset(
! 373: &res->happy_eyeballs_dns_time, 0, sizeof(res->happy_eyeballs_dns_time));
! 374:
! 375: /* Cancel the raw c-ares request, which will fire query_completed_cb() with
! 376: ARES_ECANCELLED synchronously for all pending responses. This will
! 377: leave us with res->num_pending == 0, which is perfect for the next
! 378: block. */
! 379: ares_cancel((ares_channel)data->state.resolver);
! 380: DEBUGASSERT(res->num_pending == 0);
! 381: }
! 382:
! 383: if(res && !res->num_pending) {
! 384: if(dns) {
! 385: (void)Curl_addrinfo_callback(conn, res->last_status, res->temp_ai);
! 386: /* temp_ai ownership is moved to the connection, so we need not free-up
! 387: them */
! 388: res->temp_ai = NULL;
! 389: }
! 390: if(!conn->async.dns) {
! 391: failf(data, "Could not resolve: %s (%s)",
! 392: conn->async.hostname, ares_strerror(conn->async.status));
! 393: result = conn->bits.proxy?CURLE_COULDNT_RESOLVE_PROXY:
! 394: CURLE_COULDNT_RESOLVE_HOST;
! 395: }
! 396: else if(dns)
! 397: *dns = conn->async.dns;
! 398:
! 399: destroy_async_data(&conn->async);
! 400: }
! 401:
! 402: return result;
! 403: }
! 404:
! 405: /*
! 406: * Curl_resolver_wait_resolv()
! 407: *
! 408: * Waits for a resolve to finish. This function should be avoided since using
! 409: * this risk getting the multi interface to "hang".
! 410: *
! 411: * If 'entry' is non-NULL, make it point to the resolved dns entry
! 412: *
! 413: * Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved,
! 414: * CURLE_OPERATION_TIMEDOUT if a time-out occurred, or other errors.
! 415: */
! 416: CURLcode Curl_resolver_wait_resolv(struct connectdata *conn,
! 417: struct Curl_dns_entry **entry)
! 418: {
! 419: CURLcode result = CURLE_OK;
! 420: struct Curl_easy *data = conn->data;
! 421: timediff_t timeout;
! 422: struct curltime now = Curl_now();
! 423: struct Curl_dns_entry *temp_entry;
! 424:
! 425: if(entry)
! 426: *entry = NULL; /* clear on entry */
! 427:
! 428: timeout = Curl_timeleft(data, &now, TRUE);
! 429: if(timeout < 0) {
! 430: /* already expired! */
! 431: connclose(conn, "Timed out before name resolve started");
! 432: return CURLE_OPERATION_TIMEDOUT;
! 433: }
! 434: if(!timeout)
! 435: timeout = CURL_TIMEOUT_RESOLVE * 1000; /* default name resolve timeout */
! 436:
! 437: /* Wait for the name resolve query to complete. */
! 438: while(!result) {
! 439: struct timeval *tvp, tv, store;
! 440: int itimeout;
! 441: int timeout_ms;
! 442:
! 443: itimeout = (timeout > (long)INT_MAX) ? INT_MAX : (int)timeout;
! 444:
! 445: store.tv_sec = itimeout/1000;
! 446: store.tv_usec = (itimeout%1000)*1000;
! 447:
! 448: tvp = ares_timeout((ares_channel)data->state.resolver, &store, &tv);
! 449:
! 450: /* use the timeout period ares returned to us above if less than one
! 451: second is left, otherwise just use 1000ms to make sure the progress
! 452: callback gets called frequent enough */
! 453: if(!tvp->tv_sec)
! 454: timeout_ms = (int)(tvp->tv_usec/1000);
! 455: else
! 456: timeout_ms = 1000;
! 457:
! 458: waitperform(conn, timeout_ms);
! 459: result = Curl_resolver_is_resolved(conn, entry?&temp_entry:NULL);
! 460:
! 461: if(result || conn->async.done)
! 462: break;
! 463:
! 464: if(Curl_pgrsUpdate(conn))
! 465: result = CURLE_ABORTED_BY_CALLBACK;
! 466: else {
! 467: struct curltime now2 = Curl_now();
! 468: timediff_t timediff = Curl_timediff(now2, now); /* spent time */
! 469: if(timediff <= 0)
! 470: timeout -= 1; /* always deduct at least 1 */
! 471: else if(timediff > timeout)
! 472: timeout = -1;
! 473: else
! 474: timeout -= (long)timediff;
! 475: now = now2; /* for next loop */
! 476: }
! 477: if(timeout < 0)
! 478: result = CURLE_OPERATION_TIMEDOUT;
! 479: }
! 480: if(result)
! 481: /* failure, so we cancel the ares operation */
! 482: ares_cancel((ares_channel)data->state.resolver);
! 483:
! 484: /* Operation complete, if the lookup was successful we now have the entry
! 485: in the cache. */
! 486: if(entry)
! 487: *entry = conn->async.dns;
! 488:
! 489: if(result)
! 490: /* close the connection, since we can't return failure here without
! 491: cleaning up this connection properly. */
! 492: connclose(conn, "c-ares resolve failed");
! 493:
! 494: return result;
! 495: }
! 496:
! 497: /* Connects results to the list */
! 498: static void compound_results(struct ResolverResults *res,
! 499: Curl_addrinfo *ai)
! 500: {
! 501: Curl_addrinfo *ai_tail;
! 502: if(!ai)
! 503: return;
! 504: ai_tail = ai;
! 505:
! 506: while(ai_tail->ai_next)
! 507: ai_tail = ai_tail->ai_next;
! 508:
! 509: /* Add the new results to the list of old results. */
! 510: ai_tail->ai_next = res->temp_ai;
! 511: res->temp_ai = ai;
! 512: }
! 513:
! 514: /*
! 515: * ares_query_completed_cb() is the callback that ares will call when
! 516: * the host query initiated by ares_gethostbyname() from Curl_getaddrinfo(),
! 517: * when using ares, is completed either successfully or with failure.
! 518: */
! 519: static void query_completed_cb(void *arg, /* (struct connectdata *) */
! 520: int status,
! 521: #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
! 522: int timeouts,
! 523: #endif
! 524: struct hostent *hostent)
! 525: {
! 526: struct connectdata *conn = (struct connectdata *)arg;
! 527: struct ResolverResults *res;
! 528:
! 529: #ifdef HAVE_CARES_CALLBACK_TIMEOUTS
! 530: (void)timeouts; /* ignored */
! 531: #endif
! 532:
! 533: if(ARES_EDESTRUCTION == status)
! 534: /* when this ares handle is getting destroyed, the 'arg' pointer may not
! 535: be valid so only defer it when we know the 'status' says its fine! */
! 536: return;
! 537:
! 538: res = (struct ResolverResults *)conn->async.os_specific;
! 539: if(res) {
! 540: res->num_pending--;
! 541:
! 542: if(CURL_ASYNC_SUCCESS == status) {
! 543: Curl_addrinfo *ai = Curl_he2ai(hostent, conn->async.port);
! 544: if(ai) {
! 545: compound_results(res, ai);
! 546: }
! 547: }
! 548: /* A successful result overwrites any previous error */
! 549: if(res->last_status != ARES_SUCCESS)
! 550: res->last_status = status;
! 551:
! 552: /* If there are responses still pending, we presume they must be the
! 553: complementary IPv4 or IPv6 lookups that we started in parallel in
! 554: Curl_resolver_getaddrinfo() (for Happy Eyeballs). If we've got a
! 555: "definitive" response from one of a set of parallel queries, we need to
! 556: think about how long we're willing to wait for more responses. */
! 557: if(res->num_pending
! 558: /* Only these c-ares status values count as "definitive" for these
! 559: purposes. For example, ARES_ENODATA is what we expect when there is
! 560: no IPv6 entry for a domain name, and that's not a reason to get more
! 561: aggressive in our timeouts for the other response. Other errors are
! 562: either a result of bad input (which should affect all parallel
! 563: requests), local or network conditions, non-definitive server
! 564: responses, or us cancelling the request. */
! 565: && (status == ARES_SUCCESS || status == ARES_ENOTFOUND)) {
! 566: /* Right now, there can only be up to two parallel queries, so don't
! 567: bother handling any other cases. */
! 568: DEBUGASSERT(res->num_pending == 1);
! 569:
! 570: /* It's possible that one of these parallel queries could succeed
! 571: quickly, but the other could always fail or timeout (when we're
! 572: talking to a pool of DNS servers that can only successfully resolve
! 573: IPv4 address, for example).
! 574:
! 575: It's also possible that the other request could always just take
! 576: longer because it needs more time or only the second DNS server can
! 577: fulfill it successfully. But, to align with the philosophy of Happy
! 578: Eyeballs, we don't want to wait _too_ long or users will think
! 579: requests are slow when IPv6 lookups don't actually work (but IPv4 ones
! 580: do).
! 581:
! 582: So, now that we have a usable answer (some IPv4 addresses, some IPv6
! 583: addresses, or "no such domain"), we start a timeout for the remaining
! 584: pending responses. Even though it is typical that this resolved
! 585: request came back quickly, that needn't be the case. It might be that
! 586: this completing request didn't get a result from the first DNS server
! 587: or even the first round of the whole DNS server pool. So it could
! 588: already be quite some time after we issued the DNS queries in the
! 589: first place. Without modifying c-ares, we can't know exactly where in
! 590: its retry cycle we are. We could guess based on how much time has
! 591: gone by, but it doesn't really matter. Happy Eyeballs tells us that,
! 592: given usable information in hand, we simply don't want to wait "too
! 593: much longer" after we get a result.
! 594:
! 595: We simply wait an additional amount of time equal to the default
! 596: c-ares query timeout. That is enough time for a typical parallel
! 597: response to arrive without being "too long". Even on a network
! 598: where one of the two types of queries is failing or timing out
! 599: constantly, this will usually mean we wait a total of the default
! 600: c-ares timeout (5 seconds) plus the round trip time for the successful
! 601: request, which seems bearable. The downside is that c-ares might race
! 602: with us to issue one more retry just before we give up, but it seems
! 603: better to "waste" that request instead of trying to guess the perfect
! 604: timeout to prevent it. After all, we don't even know where in the
! 605: c-ares retry cycle each request is.
! 606: */
! 607: res->happy_eyeballs_dns_time = Curl_now();
! 608: Curl_expire(
! 609: conn->data, HAPPY_EYEBALLS_DNS_TIMEOUT, EXPIRE_HAPPY_EYEBALLS_DNS);
! 610: }
! 611: }
! 612: }
! 613:
! 614: /*
! 615: * Curl_resolver_getaddrinfo() - when using ares
! 616: *
! 617: * Returns name information about the given hostname and port number. If
! 618: * successful, the 'hostent' is returned and the forth argument will point to
! 619: * memory we need to free after use. That memory *MUST* be freed with
! 620: * Curl_freeaddrinfo(), nothing else.
! 621: */
! 622: Curl_addrinfo *Curl_resolver_getaddrinfo(struct connectdata *conn,
! 623: const char *hostname,
! 624: int port,
! 625: int *waitp)
! 626: {
! 627: char *bufp;
! 628: struct Curl_easy *data = conn->data;
! 629: int family = PF_INET;
! 630:
! 631: *waitp = 0; /* default to synchronous response */
! 632:
! 633: #ifdef ENABLE_IPV6 /* CURLRES_IPV6 */
! 634: switch(conn->ip_version) {
! 635: default:
! 636: #if ARES_VERSION >= 0x010601
! 637: family = PF_UNSPEC; /* supported by c-ares since 1.6.1, so for older
! 638: c-ares versions this just falls through and defaults
! 639: to PF_INET */
! 640: break;
! 641: #endif
! 642: case CURL_IPRESOLVE_V4:
! 643: family = PF_INET;
! 644: break;
! 645: case CURL_IPRESOLVE_V6:
! 646: family = PF_INET6;
! 647: break;
! 648: }
! 649: #endif /* CURLRES_IPV6 */
! 650:
! 651: bufp = strdup(hostname);
! 652: if(bufp) {
! 653: struct ResolverResults *res = NULL;
! 654: free(conn->async.hostname);
! 655: conn->async.hostname = bufp;
! 656: conn->async.port = port;
! 657: conn->async.done = FALSE; /* not done */
! 658: conn->async.status = 0; /* clear */
! 659: conn->async.dns = NULL; /* clear */
! 660: res = calloc(sizeof(struct ResolverResults), 1);
! 661: if(!res) {
! 662: free(conn->async.hostname);
! 663: conn->async.hostname = NULL;
! 664: return NULL;
! 665: }
! 666: conn->async.os_specific = res;
! 667:
! 668: /* initial status - failed */
! 669: res->last_status = ARES_ENOTFOUND;
! 670: #ifdef ENABLE_IPV6 /* CURLRES_IPV6 */
! 671: if(family == PF_UNSPEC) {
! 672: if(Curl_ipv6works(conn)) {
! 673: res->num_pending = 2;
! 674:
! 675: /* areschannel is already setup in the Curl_open() function */
! 676: ares_gethostbyname((ares_channel)data->state.resolver, hostname,
! 677: PF_INET, query_completed_cb, conn);
! 678: ares_gethostbyname((ares_channel)data->state.resolver, hostname,
! 679: PF_INET6, query_completed_cb, conn);
! 680: }
! 681: else {
! 682: res->num_pending = 1;
! 683:
! 684: /* areschannel is already setup in the Curl_open() function */
! 685: ares_gethostbyname((ares_channel)data->state.resolver, hostname,
! 686: PF_INET, query_completed_cb, conn);
! 687: }
! 688: }
! 689: else
! 690: #endif /* CURLRES_IPV6 */
! 691: {
! 692: res->num_pending = 1;
! 693:
! 694: /* areschannel is already setup in the Curl_open() function */
! 695: ares_gethostbyname((ares_channel)data->state.resolver, hostname, family,
! 696: query_completed_cb, conn);
! 697: }
! 698:
! 699: *waitp = 1; /* expect asynchronous response */
! 700: }
! 701: return NULL; /* no struct yet */
! 702: }
! 703:
! 704: CURLcode Curl_set_dns_servers(struct Curl_easy *data,
! 705: char *servers)
! 706: {
! 707: CURLcode result = CURLE_NOT_BUILT_IN;
! 708: int ares_result;
! 709:
! 710: /* If server is NULL or empty, this would purge all DNS servers
! 711: * from ares library, which will cause any and all queries to fail.
! 712: * So, just return OK if none are configured and don't actually make
! 713: * any changes to c-ares. This lets c-ares use it's defaults, which
! 714: * it gets from the OS (for instance from /etc/resolv.conf on Linux).
! 715: */
! 716: if(!(servers && servers[0]))
! 717: return CURLE_OK;
! 718:
! 719: #if (ARES_VERSION >= 0x010704)
! 720: #if (ARES_VERSION >= 0x010b00)
! 721: ares_result = ares_set_servers_ports_csv(data->state.resolver, servers);
! 722: #else
! 723: ares_result = ares_set_servers_csv(data->state.resolver, servers);
! 724: #endif
! 725: switch(ares_result) {
! 726: case ARES_SUCCESS:
! 727: result = CURLE_OK;
! 728: break;
! 729: case ARES_ENOMEM:
! 730: result = CURLE_OUT_OF_MEMORY;
! 731: break;
! 732: case ARES_ENOTINITIALIZED:
! 733: case ARES_ENODATA:
! 734: case ARES_EBADSTR:
! 735: default:
! 736: result = CURLE_BAD_FUNCTION_ARGUMENT;
! 737: break;
! 738: }
! 739: #else /* too old c-ares version! */
! 740: (void)data;
! 741: (void)(ares_result);
! 742: #endif
! 743: return result;
! 744: }
! 745:
! 746: CURLcode Curl_set_dns_interface(struct Curl_easy *data,
! 747: const char *interf)
! 748: {
! 749: #if (ARES_VERSION >= 0x010704)
! 750: if(!interf)
! 751: interf = "";
! 752:
! 753: ares_set_local_dev((ares_channel)data->state.resolver, interf);
! 754:
! 755: return CURLE_OK;
! 756: #else /* c-ares version too old! */
! 757: (void)data;
! 758: (void)interf;
! 759: return CURLE_NOT_BUILT_IN;
! 760: #endif
! 761: }
! 762:
! 763: CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
! 764: const char *local_ip4)
! 765: {
! 766: #if (ARES_VERSION >= 0x010704)
! 767: struct in_addr a4;
! 768:
! 769: if((!local_ip4) || (local_ip4[0] == 0)) {
! 770: a4.s_addr = 0; /* disabled: do not bind to a specific address */
! 771: }
! 772: else {
! 773: if(Curl_inet_pton(AF_INET, local_ip4, &a4) != 1) {
! 774: return CURLE_BAD_FUNCTION_ARGUMENT;
! 775: }
! 776: }
! 777:
! 778: ares_set_local_ip4((ares_channel)data->state.resolver, ntohl(a4.s_addr));
! 779:
! 780: return CURLE_OK;
! 781: #else /* c-ares version too old! */
! 782: (void)data;
! 783: (void)local_ip4;
! 784: return CURLE_NOT_BUILT_IN;
! 785: #endif
! 786: }
! 787:
! 788: CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
! 789: const char *local_ip6)
! 790: {
! 791: #if (ARES_VERSION >= 0x010704) && defined(ENABLE_IPV6)
! 792: unsigned char a6[INET6_ADDRSTRLEN];
! 793:
! 794: if((!local_ip6) || (local_ip6[0] == 0)) {
! 795: /* disabled: do not bind to a specific address */
! 796: memset(a6, 0, sizeof(a6));
! 797: }
! 798: else {
! 799: if(Curl_inet_pton(AF_INET6, local_ip6, a6) != 1) {
! 800: return CURLE_BAD_FUNCTION_ARGUMENT;
! 801: }
! 802: }
! 803:
! 804: ares_set_local_ip6((ares_channel)data->state.resolver, a6);
! 805:
! 806: return CURLE_OK;
! 807: #else /* c-ares version too old! */
! 808: (void)data;
! 809: (void)local_ip6;
! 810: return CURLE_NOT_BUILT_IN;
! 811: #endif
! 812: }
! 813: #endif /* CURLRES_ARES */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to asyn-ares.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