Annotation of embedaddon/curl/lib/hostip.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: #ifdef HAVE_NETINET_IN_H
! 26: #include <netinet/in.h>
! 27: #endif
! 28: #ifdef HAVE_NETINET_IN6_H
! 29: #include <netinet/in6.h>
! 30: #endif
! 31: #ifdef HAVE_NETDB_H
! 32: #include <netdb.h>
! 33: #endif
! 34: #ifdef HAVE_ARPA_INET_H
! 35: #include <arpa/inet.h>
! 36: #endif
! 37: #ifdef __VMS
! 38: #include <in.h>
! 39: #include <inet.h>
! 40: #endif
! 41:
! 42: #ifdef HAVE_SETJMP_H
! 43: #include <setjmp.h>
! 44: #endif
! 45: #ifdef HAVE_SIGNAL_H
! 46: #include <signal.h>
! 47: #endif
! 48:
! 49: #ifdef HAVE_PROCESS_H
! 50: #include <process.h>
! 51: #endif
! 52:
! 53: #include "urldata.h"
! 54: #include "sendf.h"
! 55: #include "hostip.h"
! 56: #include "hash.h"
! 57: #include "rand.h"
! 58: #include "share.h"
! 59: #include "strerror.h"
! 60: #include "url.h"
! 61: #include "inet_ntop.h"
! 62: #include "inet_pton.h"
! 63: #include "multiif.h"
! 64: #include "doh.h"
! 65: #include "warnless.h"
! 66: /* The last 3 #include files should be in this order */
! 67: #include "curl_printf.h"
! 68: #include "curl_memory.h"
! 69: #include "memdebug.h"
! 70:
! 71: #if defined(CURLRES_SYNCH) && \
! 72: defined(HAVE_ALARM) && defined(SIGALRM) && defined(HAVE_SIGSETJMP)
! 73: /* alarm-based timeouts can only be used with all the dependencies satisfied */
! 74: #define USE_ALARM_TIMEOUT
! 75: #endif
! 76:
! 77: #define MAX_HOSTCACHE_LEN (255 + 7) /* max FQDN + colon + port number + zero */
! 78:
! 79: /*
! 80: * hostip.c explained
! 81: * ==================
! 82: *
! 83: * The main COMPILE-TIME DEFINES to keep in mind when reading the host*.c
! 84: * source file are these:
! 85: *
! 86: * CURLRES_IPV6 - this host has getaddrinfo() and family, and thus we use
! 87: * that. The host may not be able to resolve IPv6, but we don't really have to
! 88: * take that into account. Hosts that aren't IPv6-enabled have CURLRES_IPV4
! 89: * defined.
! 90: *
! 91: * CURLRES_ARES - is defined if libcurl is built to use c-ares for
! 92: * asynchronous name resolves. This can be Windows or *nix.
! 93: *
! 94: * CURLRES_THREADED - is defined if libcurl is built to run under (native)
! 95: * Windows, and then the name resolve will be done in a new thread, and the
! 96: * supported API will be the same as for ares-builds.
! 97: *
! 98: * If any of the two previous are defined, CURLRES_ASYNCH is defined too. If
! 99: * libcurl is not built to use an asynchronous resolver, CURLRES_SYNCH is
! 100: * defined.
! 101: *
! 102: * The host*.c sources files are split up like this:
! 103: *
! 104: * hostip.c - method-independent resolver functions and utility functions
! 105: * hostasyn.c - functions for asynchronous name resolves
! 106: * hostsyn.c - functions for synchronous name resolves
! 107: * hostip4.c - IPv4 specific functions
! 108: * hostip6.c - IPv6 specific functions
! 109: *
! 110: * The two asynchronous name resolver backends are implemented in:
! 111: * asyn-ares.c - functions for ares-using name resolves
! 112: * asyn-thread.c - functions for threaded name resolves
! 113:
! 114: * The hostip.h is the united header file for all this. It defines the
! 115: * CURLRES_* defines based on the config*.h and curl_setup.h defines.
! 116: */
! 117:
! 118: static void freednsentry(void *freethis);
! 119:
! 120: /*
! 121: * Return # of addresses in a Curl_addrinfo struct
! 122: */
! 123: int Curl_num_addresses(const Curl_addrinfo *addr)
! 124: {
! 125: int i = 0;
! 126: while(addr) {
! 127: addr = addr->ai_next;
! 128: i++;
! 129: }
! 130: return i;
! 131: }
! 132:
! 133: /*
! 134: * Curl_printable_address() returns a printable version of the 1st address
! 135: * given in the 'ai' argument. The result will be stored in the buf that is
! 136: * bufsize bytes big.
! 137: *
! 138: * If the conversion fails, it returns NULL.
! 139: */
! 140: const char *
! 141: Curl_printable_address(const Curl_addrinfo *ai, char *buf, size_t bufsize)
! 142: {
! 143: const struct sockaddr_in *sa4;
! 144: const struct in_addr *ipaddr4;
! 145: #ifdef ENABLE_IPV6
! 146: const struct sockaddr_in6 *sa6;
! 147: const struct in6_addr *ipaddr6;
! 148: #endif
! 149:
! 150: switch(ai->ai_family) {
! 151: case AF_INET:
! 152: sa4 = (const void *)ai->ai_addr;
! 153: ipaddr4 = &sa4->sin_addr;
! 154: return Curl_inet_ntop(ai->ai_family, (const void *)ipaddr4, buf,
! 155: bufsize);
! 156: #ifdef ENABLE_IPV6
! 157: case AF_INET6:
! 158: sa6 = (const void *)ai->ai_addr;
! 159: ipaddr6 = &sa6->sin6_addr;
! 160: return Curl_inet_ntop(ai->ai_family, (const void *)ipaddr6, buf,
! 161: bufsize);
! 162: #endif
! 163: default:
! 164: break;
! 165: }
! 166: return NULL;
! 167: }
! 168:
! 169: /*
! 170: * Create a hostcache id string for the provided host + port, to be used by
! 171: * the DNS caching. Without alloc.
! 172: */
! 173: static void
! 174: create_hostcache_id(const char *name, int port, char *ptr, size_t buflen)
! 175: {
! 176: size_t len = strlen(name);
! 177: if(len > (buflen - 7))
! 178: len = buflen - 7;
! 179: /* store and lower case the name */
! 180: while(len--)
! 181: *ptr++ = (char)TOLOWER(*name++);
! 182: msnprintf(ptr, 7, ":%u", port);
! 183: }
! 184:
! 185: struct hostcache_prune_data {
! 186: long cache_timeout;
! 187: time_t now;
! 188: };
! 189:
! 190: /*
! 191: * This function is set as a callback to be called for every entry in the DNS
! 192: * cache when we want to prune old unused entries.
! 193: *
! 194: * Returning non-zero means remove the entry, return 0 to keep it in the
! 195: * cache.
! 196: */
! 197: static int
! 198: hostcache_timestamp_remove(void *datap, void *hc)
! 199: {
! 200: struct hostcache_prune_data *data =
! 201: (struct hostcache_prune_data *) datap;
! 202: struct Curl_dns_entry *c = (struct Curl_dns_entry *) hc;
! 203:
! 204: return (0 != c->timestamp)
! 205: && (data->now - c->timestamp >= data->cache_timeout);
! 206: }
! 207:
! 208: /*
! 209: * Prune the DNS cache. This assumes that a lock has already been taken.
! 210: */
! 211: static void
! 212: hostcache_prune(struct curl_hash *hostcache, long cache_timeout, time_t now)
! 213: {
! 214: struct hostcache_prune_data user;
! 215:
! 216: user.cache_timeout = cache_timeout;
! 217: user.now = now;
! 218:
! 219: Curl_hash_clean_with_criterium(hostcache,
! 220: (void *) &user,
! 221: hostcache_timestamp_remove);
! 222: }
! 223:
! 224: /*
! 225: * Library-wide function for pruning the DNS cache. This function takes and
! 226: * returns the appropriate locks.
! 227: */
! 228: void Curl_hostcache_prune(struct Curl_easy *data)
! 229: {
! 230: time_t now;
! 231:
! 232: if((data->set.dns_cache_timeout == -1) || !data->dns.hostcache)
! 233: /* cache forever means never prune, and NULL hostcache means
! 234: we can't do it */
! 235: return;
! 236:
! 237: if(data->share)
! 238: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 239:
! 240: time(&now);
! 241:
! 242: /* Remove outdated and unused entries from the hostcache */
! 243: hostcache_prune(data->dns.hostcache,
! 244: data->set.dns_cache_timeout,
! 245: now);
! 246:
! 247: if(data->share)
! 248: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 249: }
! 250:
! 251: #ifdef HAVE_SIGSETJMP
! 252: /* Beware this is a global and unique instance. This is used to store the
! 253: return address that we can jump back to from inside a signal handler. This
! 254: is not thread-safe stuff. */
! 255: sigjmp_buf curl_jmpenv;
! 256: #endif
! 257:
! 258: /* lookup address, returns entry if found and not stale */
! 259: static struct Curl_dns_entry *
! 260: fetch_addr(struct connectdata *conn,
! 261: const char *hostname,
! 262: int port)
! 263: {
! 264: struct Curl_dns_entry *dns = NULL;
! 265: size_t entry_len;
! 266: struct Curl_easy *data = conn->data;
! 267: char entry_id[MAX_HOSTCACHE_LEN];
! 268:
! 269: /* Create an entry id, based upon the hostname and port */
! 270: create_hostcache_id(hostname, port, entry_id, sizeof(entry_id));
! 271: entry_len = strlen(entry_id);
! 272:
! 273: /* See if its already in our dns cache */
! 274: dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
! 275:
! 276: /* No entry found in cache, check if we might have a wildcard entry */
! 277: if(!dns && data->change.wildcard_resolve) {
! 278: create_hostcache_id("*", port, entry_id, sizeof(entry_id));
! 279: entry_len = strlen(entry_id);
! 280:
! 281: /* See if it's already in our dns cache */
! 282: dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
! 283: }
! 284:
! 285: if(dns && (data->set.dns_cache_timeout != -1)) {
! 286: /* See whether the returned entry is stale. Done before we release lock */
! 287: struct hostcache_prune_data user;
! 288:
! 289: time(&user.now);
! 290: user.cache_timeout = data->set.dns_cache_timeout;
! 291:
! 292: if(hostcache_timestamp_remove(&user, dns)) {
! 293: infof(data, "Hostname in DNS cache was stale, zapped\n");
! 294: dns = NULL; /* the memory deallocation is being handled by the hash */
! 295: Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
! 296: }
! 297: }
! 298:
! 299: return dns;
! 300: }
! 301:
! 302: /*
! 303: * Curl_fetch_addr() fetches a 'Curl_dns_entry' already in the DNS cache.
! 304: *
! 305: * Curl_resolv() checks initially and multi_runsingle() checks each time
! 306: * it discovers the handle in the state WAITRESOLVE whether the hostname
! 307: * has already been resolved and the address has already been stored in
! 308: * the DNS cache. This short circuits waiting for a lot of pending
! 309: * lookups for the same hostname requested by different handles.
! 310: *
! 311: * Returns the Curl_dns_entry entry pointer or NULL if not in the cache.
! 312: *
! 313: * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after
! 314: * use, or we'll leak memory!
! 315: */
! 316: struct Curl_dns_entry *
! 317: Curl_fetch_addr(struct connectdata *conn,
! 318: const char *hostname,
! 319: int port)
! 320: {
! 321: struct Curl_easy *data = conn->data;
! 322: struct Curl_dns_entry *dns = NULL;
! 323:
! 324: if(data->share)
! 325: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 326:
! 327: dns = fetch_addr(conn, hostname, port);
! 328:
! 329: if(dns)
! 330: dns->inuse++; /* we use it! */
! 331:
! 332: if(data->share)
! 333: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 334:
! 335: return dns;
! 336: }
! 337:
! 338: #ifndef CURL_DISABLE_SHUFFLE_DNS
! 339: UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
! 340: Curl_addrinfo **addr);
! 341: /*
! 342: * Curl_shuffle_addr() shuffles the order of addresses in a 'Curl_addrinfo'
! 343: * struct by re-linking its linked list.
! 344: *
! 345: * The addr argument should be the address of a pointer to the head node of a
! 346: * `Curl_addrinfo` list and it will be modified to point to the new head after
! 347: * shuffling.
! 348: *
! 349: * Not declared static only to make it easy to use in a unit test!
! 350: *
! 351: * @unittest: 1608
! 352: */
! 353: UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
! 354: Curl_addrinfo **addr)
! 355: {
! 356: CURLcode result = CURLE_OK;
! 357: const int num_addrs = Curl_num_addresses(*addr);
! 358:
! 359: if(num_addrs > 1) {
! 360: Curl_addrinfo **nodes;
! 361: infof(data, "Shuffling %i addresses", num_addrs);
! 362:
! 363: nodes = malloc(num_addrs*sizeof(*nodes));
! 364: if(nodes) {
! 365: int i;
! 366: unsigned int *rnd;
! 367: const size_t rnd_size = num_addrs * sizeof(*rnd);
! 368:
! 369: /* build a plain array of Curl_addrinfo pointers */
! 370: nodes[0] = *addr;
! 371: for(i = 1; i < num_addrs; i++) {
! 372: nodes[i] = nodes[i-1]->ai_next;
! 373: }
! 374:
! 375: rnd = malloc(rnd_size);
! 376: if(rnd) {
! 377: /* Fisher-Yates shuffle */
! 378: if(Curl_rand(data, (unsigned char *)rnd, rnd_size) == CURLE_OK) {
! 379: Curl_addrinfo *swap_tmp;
! 380: for(i = num_addrs - 1; i > 0; i--) {
! 381: swap_tmp = nodes[rnd[i] % (i + 1)];
! 382: nodes[rnd[i] % (i + 1)] = nodes[i];
! 383: nodes[i] = swap_tmp;
! 384: }
! 385:
! 386: /* relink list in the new order */
! 387: for(i = 1; i < num_addrs; i++) {
! 388: nodes[i-1]->ai_next = nodes[i];
! 389: }
! 390:
! 391: nodes[num_addrs-1]->ai_next = NULL;
! 392: *addr = nodes[0];
! 393: }
! 394: free(rnd);
! 395: }
! 396: else
! 397: result = CURLE_OUT_OF_MEMORY;
! 398: free(nodes);
! 399: }
! 400: else
! 401: result = CURLE_OUT_OF_MEMORY;
! 402: }
! 403: return result;
! 404: }
! 405: #endif
! 406:
! 407: /*
! 408: * Curl_cache_addr() stores a 'Curl_addrinfo' struct in the DNS cache.
! 409: *
! 410: * When calling Curl_resolv() has resulted in a response with a returned
! 411: * address, we call this function to store the information in the dns
! 412: * cache etc
! 413: *
! 414: * Returns the Curl_dns_entry entry pointer or NULL if the storage failed.
! 415: */
! 416: struct Curl_dns_entry *
! 417: Curl_cache_addr(struct Curl_easy *data,
! 418: Curl_addrinfo *addr,
! 419: const char *hostname,
! 420: int port)
! 421: {
! 422: char entry_id[MAX_HOSTCACHE_LEN];
! 423: size_t entry_len;
! 424: struct Curl_dns_entry *dns;
! 425: struct Curl_dns_entry *dns2;
! 426:
! 427: #ifndef CURL_DISABLE_SHUFFLE_DNS
! 428: /* shuffle addresses if requested */
! 429: if(data->set.dns_shuffle_addresses) {
! 430: CURLcode result = Curl_shuffle_addr(data, &addr);
! 431: if(result)
! 432: return NULL;
! 433: }
! 434: #endif
! 435:
! 436: /* Create a new cache entry */
! 437: dns = calloc(1, sizeof(struct Curl_dns_entry));
! 438: if(!dns) {
! 439: return NULL;
! 440: }
! 441:
! 442: /* Create an entry id, based upon the hostname and port */
! 443: create_hostcache_id(hostname, port, entry_id, sizeof(entry_id));
! 444: entry_len = strlen(entry_id);
! 445:
! 446: dns->inuse = 1; /* the cache has the first reference */
! 447: dns->addr = addr; /* this is the address(es) */
! 448: time(&dns->timestamp);
! 449: if(dns->timestamp == 0)
! 450: dns->timestamp = 1; /* zero indicates CURLOPT_RESOLVE entry */
! 451:
! 452: /* Store the resolved data in our DNS cache. */
! 453: dns2 = Curl_hash_add(data->dns.hostcache, entry_id, entry_len + 1,
! 454: (void *)dns);
! 455: if(!dns2) {
! 456: free(dns);
! 457: return NULL;
! 458: }
! 459:
! 460: dns = dns2;
! 461: dns->inuse++; /* mark entry as in-use */
! 462: return dns;
! 463: }
! 464:
! 465: /*
! 466: * Curl_resolv() is the main name resolve function within libcurl. It resolves
! 467: * a name and returns a pointer to the entry in the 'entry' argument (if one
! 468: * is provided). This function might return immediately if we're using asynch
! 469: * resolves. See the return codes.
! 470: *
! 471: * The cache entry we return will get its 'inuse' counter increased when this
! 472: * function is used. You MUST call Curl_resolv_unlock() later (when you're
! 473: * done using this struct) to decrease the counter again.
! 474: *
! 475: * In debug mode, we specifically test for an interface name "LocalHost"
! 476: * and resolve "localhost" instead as a means to permit test cases
! 477: * to connect to a local test server with any host name.
! 478: *
! 479: * Return codes:
! 480: *
! 481: * CURLRESOLV_ERROR (-1) = error, no pointer
! 482: * CURLRESOLV_RESOLVED (0) = OK, pointer provided
! 483: * CURLRESOLV_PENDING (1) = waiting for response, no pointer
! 484: */
! 485:
! 486: enum resolve_t Curl_resolv(struct connectdata *conn,
! 487: const char *hostname,
! 488: int port,
! 489: bool allowDOH,
! 490: struct Curl_dns_entry **entry)
! 491: {
! 492: struct Curl_dns_entry *dns = NULL;
! 493: struct Curl_easy *data = conn->data;
! 494: CURLcode result;
! 495: enum resolve_t rc = CURLRESOLV_ERROR; /* default to failure */
! 496:
! 497: *entry = NULL;
! 498:
! 499: if(data->share)
! 500: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 501:
! 502: dns = fetch_addr(conn, hostname, port);
! 503:
! 504: if(dns) {
! 505: infof(data, "Hostname %s was found in DNS cache\n", hostname);
! 506: dns->inuse++; /* we use it! */
! 507: rc = CURLRESOLV_RESOLVED;
! 508: }
! 509:
! 510: if(data->share)
! 511: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 512:
! 513: if(!dns) {
! 514: /* The entry was not in the cache. Resolve it to IP address */
! 515:
! 516: Curl_addrinfo *addr = NULL;
! 517: int respwait = 0;
! 518: #ifndef USE_RESOLVE_ON_IPS
! 519: struct in_addr in;
! 520: #endif
! 521:
! 522: /* notify the resolver start callback */
! 523: if(data->set.resolver_start) {
! 524: int st;
! 525: Curl_set_in_callback(data, true);
! 526: st = data->set.resolver_start(data->state.resolver, NULL,
! 527: data->set.resolver_start_client);
! 528: Curl_set_in_callback(data, false);
! 529: if(st)
! 530: return CURLRESOLV_ERROR;
! 531: }
! 532:
! 533: #ifndef USE_RESOLVE_ON_IPS
! 534: /* First check if this is an IPv4 address string */
! 535: if(Curl_inet_pton(AF_INET, hostname, &in) > 0)
! 536: /* This is a dotted IP address 123.123.123.123-style */
! 537: addr = Curl_ip2addr(AF_INET, &in, hostname, port);
! 538: #ifdef ENABLE_IPV6
! 539: if(!addr) {
! 540: struct in6_addr in6;
! 541: /* check if this is an IPv6 address string */
! 542: if(Curl_inet_pton(AF_INET6, hostname, &in6) > 0)
! 543: /* This is an IPv6 address literal */
! 544: addr = Curl_ip2addr(AF_INET6, &in6, hostname, port);
! 545: }
! 546: #endif /* ENABLE_IPV6 */
! 547: #endif /* !USE_RESOLVE_ON_IPS */
! 548:
! 549: if(!addr) {
! 550: /* Check what IP specifics the app has requested and if we can provide
! 551: * it. If not, bail out. */
! 552: if(!Curl_ipvalid(conn))
! 553: return CURLRESOLV_ERROR;
! 554:
! 555: if(allowDOH && data->set.doh) {
! 556: addr = Curl_doh(conn, hostname, port, &respwait);
! 557: }
! 558: else {
! 559: /* If Curl_getaddrinfo() returns NULL, 'respwait' might be set to a
! 560: non-zero value indicating that we need to wait for the response to
! 561: the resolve call */
! 562: addr = Curl_getaddrinfo(conn,
! 563: #ifdef DEBUGBUILD
! 564: (data->set.str[STRING_DEVICE]
! 565: && !strcmp(data->set.str[STRING_DEVICE],
! 566: "LocalHost"))?"localhost":
! 567: #endif
! 568: hostname, port, &respwait);
! 569: }
! 570: }
! 571: if(!addr) {
! 572: if(respwait) {
! 573: /* the response to our resolve call will come asynchronously at
! 574: a later time, good or bad */
! 575: /* First, check that we haven't received the info by now */
! 576: result = Curl_resolv_check(conn, &dns);
! 577: if(result) /* error detected */
! 578: return CURLRESOLV_ERROR;
! 579: if(dns)
! 580: rc = CURLRESOLV_RESOLVED; /* pointer provided */
! 581: else
! 582: rc = CURLRESOLV_PENDING; /* no info yet */
! 583: }
! 584: }
! 585: else {
! 586: if(data->share)
! 587: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 588:
! 589: /* we got a response, store it in the cache */
! 590: dns = Curl_cache_addr(data, addr, hostname, port);
! 591:
! 592: if(data->share)
! 593: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 594:
! 595: if(!dns)
! 596: /* returned failure, bail out nicely */
! 597: Curl_freeaddrinfo(addr);
! 598: else
! 599: rc = CURLRESOLV_RESOLVED;
! 600: }
! 601: }
! 602:
! 603: *entry = dns;
! 604:
! 605: return rc;
! 606: }
! 607:
! 608: #ifdef USE_ALARM_TIMEOUT
! 609: /*
! 610: * This signal handler jumps back into the main libcurl code and continues
! 611: * execution. This effectively causes the remainder of the application to run
! 612: * within a signal handler which is nonportable and could lead to problems.
! 613: */
! 614: static
! 615: RETSIGTYPE alarmfunc(int sig)
! 616: {
! 617: /* this is for "-ansi -Wall -pedantic" to stop complaining! (rabe) */
! 618: (void)sig;
! 619: siglongjmp(curl_jmpenv, 1);
! 620: }
! 621: #endif /* USE_ALARM_TIMEOUT */
! 622:
! 623: /*
! 624: * Curl_resolv_timeout() is the same as Curl_resolv() but specifies a
! 625: * timeout. This function might return immediately if we're using asynch
! 626: * resolves. See the return codes.
! 627: *
! 628: * The cache entry we return will get its 'inuse' counter increased when this
! 629: * function is used. You MUST call Curl_resolv_unlock() later (when you're
! 630: * done using this struct) to decrease the counter again.
! 631: *
! 632: * If built with a synchronous resolver and use of signals is not
! 633: * disabled by the application, then a nonzero timeout will cause a
! 634: * timeout after the specified number of milliseconds. Otherwise, timeout
! 635: * is ignored.
! 636: *
! 637: * Return codes:
! 638: *
! 639: * CURLRESOLV_TIMEDOUT(-2) = warning, time too short or previous alarm expired
! 640: * CURLRESOLV_ERROR (-1) = error, no pointer
! 641: * CURLRESOLV_RESOLVED (0) = OK, pointer provided
! 642: * CURLRESOLV_PENDING (1) = waiting for response, no pointer
! 643: */
! 644:
! 645: enum resolve_t Curl_resolv_timeout(struct connectdata *conn,
! 646: const char *hostname,
! 647: int port,
! 648: struct Curl_dns_entry **entry,
! 649: timediff_t timeoutms)
! 650: {
! 651: #ifdef USE_ALARM_TIMEOUT
! 652: #ifdef HAVE_SIGACTION
! 653: struct sigaction keep_sigact; /* store the old struct here */
! 654: volatile bool keep_copysig = FALSE; /* whether old sigact has been saved */
! 655: struct sigaction sigact;
! 656: #else
! 657: #ifdef HAVE_SIGNAL
! 658: void (*keep_sigact)(int); /* store the old handler here */
! 659: #endif /* HAVE_SIGNAL */
! 660: #endif /* HAVE_SIGACTION */
! 661: volatile long timeout;
! 662: volatile unsigned int prev_alarm = 0;
! 663: struct Curl_easy *data = conn->data;
! 664: #endif /* USE_ALARM_TIMEOUT */
! 665: enum resolve_t rc;
! 666:
! 667: *entry = NULL;
! 668:
! 669: if(timeoutms < 0)
! 670: /* got an already expired timeout */
! 671: return CURLRESOLV_TIMEDOUT;
! 672:
! 673: #ifdef USE_ALARM_TIMEOUT
! 674: if(data->set.no_signal)
! 675: /* Ignore the timeout when signals are disabled */
! 676: timeout = 0;
! 677: else
! 678: timeout = (timeoutms > LONG_MAX) ? LONG_MAX : (long)timeoutms;
! 679:
! 680: if(!timeout)
! 681: /* USE_ALARM_TIMEOUT defined, but no timeout actually requested */
! 682: return Curl_resolv(conn, hostname, port, TRUE, entry);
! 683:
! 684: if(timeout < 1000) {
! 685: /* The alarm() function only provides integer second resolution, so if
! 686: we want to wait less than one second we must bail out already now. */
! 687: failf(data,
! 688: "remaining timeout of %ld too small to resolve via SIGALRM method",
! 689: timeout);
! 690: return CURLRESOLV_TIMEDOUT;
! 691: }
! 692: /* This allows us to time-out from the name resolver, as the timeout
! 693: will generate a signal and we will siglongjmp() from that here.
! 694: This technique has problems (see alarmfunc).
! 695: This should be the last thing we do before calling Curl_resolv(),
! 696: as otherwise we'd have to worry about variables that get modified
! 697: before we invoke Curl_resolv() (and thus use "volatile"). */
! 698: if(sigsetjmp(curl_jmpenv, 1)) {
! 699: /* this is coming from a siglongjmp() after an alarm signal */
! 700: failf(data, "name lookup timed out");
! 701: rc = CURLRESOLV_ERROR;
! 702: goto clean_up;
! 703: }
! 704: else {
! 705: /*************************************************************
! 706: * Set signal handler to catch SIGALRM
! 707: * Store the old value to be able to set it back later!
! 708: *************************************************************/
! 709: #ifdef HAVE_SIGACTION
! 710: sigaction(SIGALRM, NULL, &sigact);
! 711: keep_sigact = sigact;
! 712: keep_copysig = TRUE; /* yes, we have a copy */
! 713: sigact.sa_handler = alarmfunc;
! 714: #ifdef SA_RESTART
! 715: /* HPUX doesn't have SA_RESTART but defaults to that behaviour! */
! 716: sigact.sa_flags &= ~SA_RESTART;
! 717: #endif
! 718: /* now set the new struct */
! 719: sigaction(SIGALRM, &sigact, NULL);
! 720: #else /* HAVE_SIGACTION */
! 721: /* no sigaction(), revert to the much lamer signal() */
! 722: #ifdef HAVE_SIGNAL
! 723: keep_sigact = signal(SIGALRM, alarmfunc);
! 724: #endif
! 725: #endif /* HAVE_SIGACTION */
! 726:
! 727: /* alarm() makes a signal get sent when the timeout fires off, and that
! 728: will abort system calls */
! 729: prev_alarm = alarm(curlx_sltoui(timeout/1000L));
! 730: }
! 731:
! 732: #else
! 733: #ifndef CURLRES_ASYNCH
! 734: if(timeoutms)
! 735: infof(conn->data, "timeout on name lookup is not supported\n");
! 736: #else
! 737: (void)timeoutms; /* timeoutms not used with an async resolver */
! 738: #endif
! 739: #endif /* USE_ALARM_TIMEOUT */
! 740:
! 741: /* Perform the actual name resolution. This might be interrupted by an
! 742: * alarm if it takes too long.
! 743: */
! 744: rc = Curl_resolv(conn, hostname, port, TRUE, entry);
! 745:
! 746: #ifdef USE_ALARM_TIMEOUT
! 747: clean_up:
! 748:
! 749: if(!prev_alarm)
! 750: /* deactivate a possibly active alarm before uninstalling the handler */
! 751: alarm(0);
! 752:
! 753: #ifdef HAVE_SIGACTION
! 754: if(keep_copysig) {
! 755: /* we got a struct as it looked before, now put that one back nice
! 756: and clean */
! 757: sigaction(SIGALRM, &keep_sigact, NULL); /* put it back */
! 758: }
! 759: #else
! 760: #ifdef HAVE_SIGNAL
! 761: /* restore the previous SIGALRM handler */
! 762: signal(SIGALRM, keep_sigact);
! 763: #endif
! 764: #endif /* HAVE_SIGACTION */
! 765:
! 766: /* switch back the alarm() to either zero or to what it was before minus
! 767: the time we spent until now! */
! 768: if(prev_alarm) {
! 769: /* there was an alarm() set before us, now put it back */
! 770: timediff_t elapsed_secs = Curl_timediff(Curl_now(),
! 771: conn->created) / 1000;
! 772:
! 773: /* the alarm period is counted in even number of seconds */
! 774: unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs);
! 775:
! 776: if(!alarm_set ||
! 777: ((alarm_set >= 0x80000000) && (prev_alarm < 0x80000000)) ) {
! 778: /* if the alarm time-left reached zero or turned "negative" (counted
! 779: with unsigned values), we should fire off a SIGALRM here, but we
! 780: won't, and zero would be to switch it off so we never set it to
! 781: less than 1! */
! 782: alarm(1);
! 783: rc = CURLRESOLV_TIMEDOUT;
! 784: failf(data, "Previous alarm fired off!");
! 785: }
! 786: else
! 787: alarm((unsigned int)alarm_set);
! 788: }
! 789: #endif /* USE_ALARM_TIMEOUT */
! 790:
! 791: return rc;
! 792: }
! 793:
! 794: /*
! 795: * Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been
! 796: * made, the struct may be destroyed due to pruning. It is important that only
! 797: * one unlock is made for each Curl_resolv() call.
! 798: *
! 799: * May be called with 'data' == NULL for global cache.
! 800: */
! 801: void Curl_resolv_unlock(struct Curl_easy *data, struct Curl_dns_entry *dns)
! 802: {
! 803: if(data && data->share)
! 804: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 805:
! 806: freednsentry(dns);
! 807:
! 808: if(data && data->share)
! 809: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 810: }
! 811:
! 812: /*
! 813: * File-internal: release cache dns entry reference, free if inuse drops to 0
! 814: */
! 815: static void freednsentry(void *freethis)
! 816: {
! 817: struct Curl_dns_entry *dns = (struct Curl_dns_entry *) freethis;
! 818: DEBUGASSERT(dns && (dns->inuse>0));
! 819:
! 820: dns->inuse--;
! 821: if(dns->inuse == 0) {
! 822: Curl_freeaddrinfo(dns->addr);
! 823: free(dns);
! 824: }
! 825: }
! 826:
! 827: /*
! 828: * Curl_mk_dnscache() inits a new DNS cache and returns success/failure.
! 829: */
! 830: int Curl_mk_dnscache(struct curl_hash *hash)
! 831: {
! 832: return Curl_hash_init(hash, 7, Curl_hash_str, Curl_str_key_compare,
! 833: freednsentry);
! 834: }
! 835:
! 836: /*
! 837: * Curl_hostcache_clean()
! 838: *
! 839: * This _can_ be called with 'data' == NULL but then of course no locking
! 840: * can be done!
! 841: */
! 842:
! 843: void Curl_hostcache_clean(struct Curl_easy *data,
! 844: struct curl_hash *hash)
! 845: {
! 846: if(data && data->share)
! 847: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 848:
! 849: Curl_hash_clean(hash);
! 850:
! 851: if(data && data->share)
! 852: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 853: }
! 854:
! 855:
! 856: CURLcode Curl_loadhostpairs(struct Curl_easy *data)
! 857: {
! 858: struct curl_slist *hostp;
! 859: char hostname[256];
! 860: int port = 0;
! 861:
! 862: /* Default is no wildcard found */
! 863: data->change.wildcard_resolve = false;
! 864:
! 865: for(hostp = data->change.resolve; hostp; hostp = hostp->next) {
! 866: char entry_id[MAX_HOSTCACHE_LEN];
! 867: if(!hostp->data)
! 868: continue;
! 869: if(hostp->data[0] == '-') {
! 870: size_t entry_len;
! 871:
! 872: if(2 != sscanf(hostp->data + 1, "%255[^:]:%d", hostname, &port)) {
! 873: infof(data, "Couldn't parse CURLOPT_RESOLVE removal entry '%s'!\n",
! 874: hostp->data);
! 875: continue;
! 876: }
! 877:
! 878: /* Create an entry id, based upon the hostname and port */
! 879: create_hostcache_id(hostname, port, entry_id, sizeof(entry_id));
! 880: entry_len = strlen(entry_id);
! 881:
! 882: if(data->share)
! 883: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 884:
! 885: /* delete entry, ignore if it didn't exist */
! 886: Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
! 887:
! 888: if(data->share)
! 889: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 890: }
! 891: else {
! 892: struct Curl_dns_entry *dns;
! 893: Curl_addrinfo *head = NULL, *tail = NULL;
! 894: size_t entry_len;
! 895: char address[64];
! 896: #if !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 897: char *addresses = NULL;
! 898: #endif
! 899: char *addr_begin;
! 900: char *addr_end;
! 901: char *port_ptr;
! 902: char *end_ptr;
! 903: char *host_end;
! 904: unsigned long tmp_port;
! 905: bool error = true;
! 906:
! 907: host_end = strchr(hostp->data, ':');
! 908: if(!host_end ||
! 909: ((host_end - hostp->data) >= (ptrdiff_t)sizeof(hostname)))
! 910: goto err;
! 911:
! 912: memcpy(hostname, hostp->data, host_end - hostp->data);
! 913: hostname[host_end - hostp->data] = '\0';
! 914:
! 915: port_ptr = host_end + 1;
! 916: tmp_port = strtoul(port_ptr, &end_ptr, 10);
! 917: if(tmp_port > USHRT_MAX || end_ptr == port_ptr || *end_ptr != ':')
! 918: goto err;
! 919:
! 920: port = (int)tmp_port;
! 921: #if !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 922: addresses = end_ptr + 1;
! 923: #endif
! 924:
! 925: while(*end_ptr) {
! 926: size_t alen;
! 927: Curl_addrinfo *ai;
! 928:
! 929: addr_begin = end_ptr + 1;
! 930: addr_end = strchr(addr_begin, ',');
! 931: if(!addr_end)
! 932: addr_end = addr_begin + strlen(addr_begin);
! 933: end_ptr = addr_end;
! 934:
! 935: /* allow IP(v6) address within [brackets] */
! 936: if(*addr_begin == '[') {
! 937: if(addr_end == addr_begin || *(addr_end - 1) != ']')
! 938: goto err;
! 939: ++addr_begin;
! 940: --addr_end;
! 941: }
! 942:
! 943: alen = addr_end - addr_begin;
! 944: if(!alen)
! 945: continue;
! 946:
! 947: if(alen >= sizeof(address))
! 948: goto err;
! 949:
! 950: memcpy(address, addr_begin, alen);
! 951: address[alen] = '\0';
! 952:
! 953: #ifndef ENABLE_IPV6
! 954: if(strchr(address, ':')) {
! 955: infof(data, "Ignoring resolve address '%s', missing IPv6 support.\n",
! 956: address);
! 957: continue;
! 958: }
! 959: #endif
! 960:
! 961: ai = Curl_str2addr(address, port);
! 962: if(!ai) {
! 963: infof(data, "Resolve address '%s' found illegal!\n", address);
! 964: goto err;
! 965: }
! 966:
! 967: if(tail) {
! 968: tail->ai_next = ai;
! 969: tail = tail->ai_next;
! 970: }
! 971: else {
! 972: head = tail = ai;
! 973: }
! 974: }
! 975:
! 976: if(!head)
! 977: goto err;
! 978:
! 979: error = false;
! 980: err:
! 981: if(error) {
! 982: infof(data, "Couldn't parse CURLOPT_RESOLVE entry '%s'!\n",
! 983: hostp->data);
! 984: Curl_freeaddrinfo(head);
! 985: continue;
! 986: }
! 987:
! 988: /* Create an entry id, based upon the hostname and port */
! 989: create_hostcache_id(hostname, port, entry_id, sizeof(entry_id));
! 990: entry_len = strlen(entry_id);
! 991:
! 992: if(data->share)
! 993: Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
! 994:
! 995: /* See if its already in our dns cache */
! 996: dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
! 997:
! 998: if(dns) {
! 999: infof(data, "RESOLVE %s:%d is - old addresses discarded!\n",
! 1000: hostname, port);
! 1001: /* delete old entry entry, there are two reasons for this
! 1002: 1. old entry may have different addresses.
! 1003: 2. even if entry with correct addresses is already in the cache,
! 1004: but if it is close to expire, then by the time next http
! 1005: request is made, it can get expired and pruned because old
! 1006: entry is not necessarily marked as added by CURLOPT_RESOLVE. */
! 1007:
! 1008: Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
! 1009: }
! 1010:
! 1011: /* put this new host in the cache */
! 1012: dns = Curl_cache_addr(data, head, hostname, port);
! 1013: if(dns) {
! 1014: dns->timestamp = 0; /* mark as added by CURLOPT_RESOLVE */
! 1015: /* release the returned reference; the cache itself will keep the
! 1016: * entry alive: */
! 1017: dns->inuse--;
! 1018: }
! 1019:
! 1020: if(data->share)
! 1021: Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
! 1022:
! 1023: if(!dns) {
! 1024: Curl_freeaddrinfo(head);
! 1025: return CURLE_OUT_OF_MEMORY;
! 1026: }
! 1027: infof(data, "Added %s:%d:%s to DNS cache\n",
! 1028: hostname, port, addresses);
! 1029:
! 1030: /* Wildcard hostname */
! 1031: if(hostname[0] == '*' && hostname[1] == '\0') {
! 1032: infof(data, "RESOLVE %s:%d is wildcard, enabling wildcard checks\n",
! 1033: hostname, port);
! 1034: data->change.wildcard_resolve = true;
! 1035: }
! 1036: }
! 1037: }
! 1038: data->change.resolve = NULL; /* dealt with now */
! 1039:
! 1040: return CURLE_OK;
! 1041: }
! 1042:
! 1043: CURLcode Curl_resolv_check(struct connectdata *conn,
! 1044: struct Curl_dns_entry **dns)
! 1045: {
! 1046: #if defined(CURL_DISABLE_DOH) && !defined(CURLRES_ASYNCH)
! 1047: (void)dns;
! 1048: #endif
! 1049:
! 1050: if(conn->data->set.doh)
! 1051: return Curl_doh_is_resolved(conn, dns);
! 1052: return Curl_resolver_is_resolved(conn, dns);
! 1053: }
! 1054:
! 1055: int Curl_resolv_getsock(struct connectdata *conn,
! 1056: curl_socket_t *socks)
! 1057: {
! 1058: #ifdef CURLRES_ASYNCH
! 1059: if(conn->data->set.doh)
! 1060: /* nothing to wait for during DOH resolve, those handles have their own
! 1061: sockets */
! 1062: return GETSOCK_BLANK;
! 1063: return Curl_resolver_getsock(conn, socks);
! 1064: #else
! 1065: (void)conn;
! 1066: (void)socks;
! 1067: return GETSOCK_BLANK;
! 1068: #endif
! 1069: }
! 1070:
! 1071: /* Call this function after Curl_connect() has returned async=TRUE and
! 1072: then a successful name resolve has been received.
! 1073:
! 1074: Note: this function disconnects and frees the conn data in case of
! 1075: resolve failure */
! 1076: CURLcode Curl_once_resolved(struct connectdata *conn,
! 1077: bool *protocol_done)
! 1078: {
! 1079: CURLcode result;
! 1080:
! 1081: if(conn->async.dns) {
! 1082: conn->dns_entry = conn->async.dns;
! 1083: conn->async.dns = NULL;
! 1084: }
! 1085:
! 1086: result = Curl_setup_conn(conn, protocol_done);
! 1087:
! 1088: if(result)
! 1089: /* We're not allowed to return failure with memory left allocated
! 1090: in the connectdata struct, free those here */
! 1091: Curl_disconnect(conn->data, conn, TRUE); /* close the connection */
! 1092:
! 1093: return result;
! 1094: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hostip.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