/*************************************************************************** * _ _ ____ _ * Project ___| | | | _ \| | * / __| | | | |_) | | * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * * Copyright (C) Daniel Stenberg, , et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at https://curl.se/docs/copyright.html. * * You may opt to use, copy, modify, merge, publish, distribute and/or sell * copies of the Software, and permit persons to whom the Software is * furnished to do so, under the terms of the COPYING file. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * * SPDX-License-Identifier: curl * ***************************************************************************/ #include "curl_setup.h" #ifdef HAVE_NETINET_IN_H #include #endif #ifdef HAVE_NETINET_IN6_H #include #endif #ifdef HAVE_NETDB_H #include #endif #ifdef HAVE_ARPA_INET_H #include #endif #ifdef __VMS #include #include #endif #include /* for sigjmp_buf, sigsetjmp() */ #include #include "urldata.h" #include "curl_addrinfo.h" #include "curl_trc.h" #include "dnscache.h" #include "hostip.h" #include "httpsrr.h" #include "url.h" #include "multiif.h" #include "progress.h" #include "doh.h" #include "select.h" #include "strcase.h" #include "easy_lock.h" #include "curlx/inet_ntop.h" #include "curlx/inet_pton.h" #include "curlx/strcopy.h" #include "curlx/strparse.h" #if defined(CURLRES_SYNCH) && \ defined(HAVE_ALARM) && \ defined(SIGALRM) && \ defined(HAVE_SIGSETJMP) && \ defined(GLOBAL_INIT_IS_THREADSAFE) /* alarm-based timeouts can only be used with all the dependencies satisfied */ #define USE_ALARM_TIMEOUT #endif #define MAX_HOSTCACHE_LEN (255 + 7) /* max FQDN + colon + port number + zero */ #define MAX_DNS_CACHE_SIZE 29999 #define RESOLV_FAIL(for_proxy) \ ((for_proxy) ? CURLE_COULDNT_RESOLVE_PROXY : CURLE_COULDNT_RESOLVE_HOST) #define IS_RESOLV_FAIL(result) \ (((result) == CURLE_COULDNT_RESOLVE_HOST) || \ ((result) == CURLE_COULDNT_RESOLVE_PROXY)) /* * ipv6works() returns TRUE if IPv6 seems to work. */ #ifdef USE_IPV6 static bool ipv6works(struct Curl_easy *data); #else #define ipv6works(x) FALSE #endif /* * hostip.c explained * ================== * * The main COMPILE-TIME DEFINES to keep in mind when reading the host*.c * source file are these: * * CURLRES_IPV6 - this host has getaddrinfo() and family, and thus we use * that. The host may not be able to resolve IPv6, but we do not really have to * take that into account. Hosts that are not IPv6-enabled have CURLRES_IPV4 * defined. * * USE_RESOLV_ARES - is defined if libcurl is built to use c-ares for * asynchronous name resolves. This can be Windows or *nix. * * USE_RESOLV_THREADED - is defined if libcurl is built to run under (native) * Windows, and then the name resolve will be done in a new thread, and the * supported API will be the same as for ares-builds. * * If any of the two previous are defined, CURLRES_ASYNCH is defined too. If * libcurl is not built to use an asynchronous resolver, CURLRES_SYNCH is * defined. * * The host*.c sources files are split up like this: * * hostip.c - method-independent resolver functions and utility functions * hostip4.c - IPv4 specific functions * hostip6.c - IPv6 specific functions * asyn.h - common functions for all async resolvers * The two asynchronous name resolver backends are implemented in: * asyn-ares.c - async resolver using c-ares * asyn-thread.c - async resolver using POSIX threads * * The hostip.h is the united header file for all this. It defines the * CURLRES_* defines based on the config*.h and curl_setup.h defines. */ uint8_t Curl_resolv_dns_queries(struct Curl_easy *data, uint8_t ip_version) { (void)data; switch(ip_version) { case CURL_IPRESOLVE_V6: return CURL_DNSQ_AAAA; case CURL_IPRESOLVE_V4: return CURL_DNSQ_A; default: if(ipv6works(data)) return (CURL_DNSQ_A | CURL_DNSQ_AAAA); else return CURL_DNSQ_A; } } #ifdef CURLVERBOSE const char *Curl_resolv_query_str(uint8_t dns_queries) { switch(dns_queries) { case (CURL_DNSQ_A | CURL_DNSQ_AAAA | CURL_DNSQ_HTTPS): return "A+AAAA+HTTPS"; case (CURL_DNSQ_A | CURL_DNSQ_AAAA): return "A+AAAA"; case (CURL_DNSQ_AAAA | CURL_DNSQ_HTTPS): return "AAAA+HTTPS"; case (CURL_DNSQ_AAAA): return "AAAA"; case (CURL_DNSQ_A | CURL_DNSQ_HTTPS): return "A+HTTPS"; case (CURL_DNSQ_A): return "A"; case (CURL_DNSQ_HTTPS): return "HTTPS"; case 0: return "-"; default: DEBUGASSERT(0); return "???"; } } #endif /* * Curl_printable_address() stores a printable version of the 1st address * given in the 'ai' argument. The result will be stored in the buf that is * bufsize bytes big. * * If the conversion fails, the target buffer is empty. */ void Curl_printable_address(const struct Curl_addrinfo *ai, char *buf, size_t bufsize) { DEBUGASSERT(bufsize); buf[0] = 0; switch(ai->ai_family) { case AF_INET: { const struct sockaddr_in *sa4 = (const void *)ai->ai_addr; const struct in_addr *ipaddr4 = &sa4->sin_addr; (void)curlx_inet_ntop(ai->ai_family, (const void *)ipaddr4, buf, bufsize); break; } #ifdef USE_IPV6 case AF_INET6: { const struct sockaddr_in6 *sa6 = (const void *)ai->ai_addr; const struct in6_addr *ipaddr6 = &sa6->sin6_addr; (void)curlx_inet_ntop(ai->ai_family, (const void *)ipaddr6, buf, bufsize); break; } #endif default: break; } } #ifdef USE_ALARM_TIMEOUT /* Beware this is a global and unique instance. This is used to store the return address that we can jump back to from inside a signal handler. This is not thread-safe stuff. */ static sigjmp_buf curl_jmpenv; static curl_simple_lock curl_jmpenv_lock = CURL_SIMPLE_LOCK_INIT; #endif #ifdef USE_IPV6 /* return a static IPv6 ::1 for the name */ static struct Curl_addrinfo *get_localhost6(uint16_t port, const char *name) { struct Curl_addrinfo *ca; const size_t ss_size = sizeof(struct sockaddr_in6); const size_t hostlen = strlen(name); struct sockaddr_in6 sa6; unsigned char ipv6[16]; unsigned short port16 = (unsigned short)(port & 0xffff); ca = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + hostlen + 1); if(!ca) return NULL; memset(&sa6, 0, sizeof(sa6)); sa6.sin6_family = AF_INET6; sa6.sin6_port = htons(port16); (void)curlx_inet_pton(AF_INET6, "::1", ipv6); memcpy(&sa6.sin6_addr, ipv6, sizeof(ipv6)); ca->ai_flags = 0; ca->ai_family = AF_INET6; ca->ai_socktype = SOCK_STREAM; ca->ai_protocol = IPPROTO_TCP; ca->ai_addrlen = (curl_socklen_t)ss_size; ca->ai_next = NULL; ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo)); memcpy(ca->ai_addr, &sa6, ss_size); ca->ai_canonname = (char *)ca->ai_addr + ss_size; curlx_strcopy(ca->ai_canonname, hostlen + 1, name, hostlen); return ca; } #else #define get_localhost6(x, y) NULL #endif /* return a static IPv4 127.0.0.1 for the given name */ static struct Curl_addrinfo *get_localhost(uint16_t port, const char *name) { struct Curl_addrinfo *ca; struct Curl_addrinfo *ca6; const size_t ss_size = sizeof(struct sockaddr_in); const size_t hostlen = strlen(name); struct sockaddr_in sa; unsigned int ipv4; unsigned short port16 = (unsigned short)(port & 0xffff); /* memset to clear the sa.sin_zero field */ memset(&sa, 0, sizeof(sa)); sa.sin_family = AF_INET; sa.sin_port = htons(port16); if(curlx_inet_pton(AF_INET, "127.0.0.1", (char *)&ipv4) < 1) return NULL; memcpy(&sa.sin_addr, &ipv4, sizeof(ipv4)); ca = curlx_calloc(1, sizeof(struct Curl_addrinfo) + ss_size + hostlen + 1); if(!ca) return NULL; ca->ai_flags = 0; ca->ai_family = AF_INET; ca->ai_socktype = SOCK_STREAM; ca->ai_protocol = IPPROTO_TCP; ca->ai_addrlen = (curl_socklen_t)ss_size; ca->ai_addr = (void *)((char *)ca + sizeof(struct Curl_addrinfo)); memcpy(ca->ai_addr, &sa, ss_size); ca->ai_canonname = (char *)ca->ai_addr + ss_size; curlx_strcopy(ca->ai_canonname, hostlen + 1, name, hostlen); ca6 = get_localhost6(port, name); if(!ca6) return ca; ca6->ai_next = ca; return ca6; } #ifdef USE_IPV6 /* the nature of most systems is that IPv6 status does not come and go during a program's lifetime so we only probe the first time and then we have the info kept for fast reuse */ CURLcode Curl_probeipv6(struct Curl_multi *multi) { /* probe to see if we have a working IPv6 stack */ curl_socket_t s = CURL_SOCKET(PF_INET6, SOCK_DGRAM, 0); multi->ipv6_works = FALSE; if(s == CURL_SOCKET_BAD) { if(SOCKERRNO == SOCKENOMEM) return CURLE_OUT_OF_MEMORY; } else { multi->ipv6_works = TRUE; sclose(s); } return CURLE_OK; } /* * ipv6works() returns TRUE if IPv6 seems to work. */ static bool ipv6works(struct Curl_easy *data) { DEBUGASSERT(data); DEBUGASSERT(data->multi); return data ? data->multi->ipv6_works : FALSE; } #endif /* USE_IPV6 */ /* * Curl_host_is_ipnum() returns TRUE if the given string is a numerical IPv4 * (or IPv6 if supported) address. */ bool Curl_host_is_ipnum(const char *hostname) { struct in_addr in; #ifdef USE_IPV6 struct in6_addr in6; #endif if(curlx_inet_pton(AF_INET, hostname, &in) > 0 #ifdef USE_IPV6 || curlx_inet_pton(AF_INET6, hostname, &in6) > 0 #endif ) return TRUE; return FALSE; } /* return TRUE if 'part' is a case insensitive tail of 'full' */ static bool tailmatch(const char *full, size_t flen, const char *part, size_t plen) { if(plen > flen) return FALSE; return curl_strnequal(part, &full[flen - plen], plen); } static CURLcode hostip_resolv_failed(struct Curl_easy *data, const char *hostname, bool for_proxy) { failf(data, "Could not resolve %s: %s", for_proxy ? "proxy" : "host", hostname); return RESOLV_FAIL(for_proxy); } static bool can_resolve_dns_queries(struct Curl_easy *data, uint8_t dns_queries) { (void)data; if((CURL_DNSQ_IP(dns_queries) == CURL_DNSQ_AAAA) && !ipv6works(data)) return FALSE; return TRUE; } CURLcode Curl_resolv_announce_start(struct Curl_easy *data, void *resolver) { if(data->set.resolver_start) { int rc; CURL_TRC_DNS(data, "announcing resolve to application"); Curl_set_in_callback(data, TRUE); rc = data->set.resolver_start(resolver, NULL, data->set.resolver_start_client); Curl_set_in_callback(data, FALSE); if(rc) { CURL_TRC_DNS(data, "application aborted resolve"); return CURLE_ABORTED_BY_CALLBACK; } } return CURLE_OK; } #ifdef USE_CURL_ASYNC static struct Curl_resolv_async *hostip_async_new(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, bool for_proxy, timediff_t timeout_ms) { struct Curl_resolv_async *async; size_t hostlen = strlen(hostname); if(!data->multi) { DEBUGASSERT(0); return NULL; } /* struct size already includes the NUL for hostname */ async = curlx_calloc(1, sizeof(*async) + hostlen); if(!async) return NULL; /* Give every async resolve operation a "unique" id. This may * wrap around after a long time, making collisions highly unlikely. * As we keep the async structs at the easy handle, chances of * easy `mid plus resolv->id` colliding should be astronomical. * `resolv_id == 0` is never used. */ if(data->multi->last_resolv_id == UINT32_MAX) data->multi->last_resolv_id = 1; /* wrap around */ else data->multi->last_resolv_id++; async->id = data->multi->last_resolv_id; async->dns_queries = dns_queries; async->port = port; async->transport = transport; async->for_proxy = for_proxy; async->start = *Curl_pgrs_now(data); async->timeout_ms = timeout_ms; if(hostlen) { memcpy(async->hostname, hostname, hostlen); async->is_ipaddr = Curl_is_ipaddr(async->hostname); if(async->is_ipaddr) async->is_ipv4addr = Curl_is_ipv4addr(async->hostname); } return async; } static CURLcode hostip_resolv_take_result(struct Curl_easy *data, struct Curl_resolv_async *async, struct Curl_dns_entry **pdns) { CURLcode result; /* If async resolving is ongoing, this must be set */ if(!async) return CURLE_FAILED_INIT; #ifndef CURL_DISABLE_DOH if(async->doh) result = Curl_doh_take_result(data, async, pdns); else #endif result = Curl_async_take_result(data, async, pdns); if(result == CURLE_AGAIN) { CURL_TRC_DNS(data, "resolve incomplete, queries=%s, responses=%s, " "ongoing=%d for %s:%d", Curl_resolv_query_str(async->dns_queries), Curl_resolv_query_str(async->dns_responses), async->queries_ongoing, async->hostname, async->port); result = CURLE_OK; } else if(result) { result = Curl_async_failed(data, async, NULL); } else { CURL_TRC_DNS(data, "resolve complete for %s:%u", async->hostname, async->port); DEBUGASSERT(*pdns); } return result; } timediff_t Curl_resolv_elapsed_ms(struct Curl_easy *data, uint32_t resolv_id) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); if(!async) return CURL_TIMEOUT_RESOLVE_MS; return curlx_ptimediff_ms(Curl_pgrs_now(data), &async->start); } bool Curl_resolv_has_answers(struct Curl_easy *data, uint32_t resolv_id, uint8_t dns_queries) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); uint8_t check_queries; /* a no longer existing/running resolve has all answers. */ if(!async || async->done) return TRUE; /* Relevant are only queries undertaken. Others are considered answered. */ check_queries = (dns_queries & async->dns_queries); if((check_queries & async->dns_responses) != check_queries) { return FALSE; } return TRUE; } const struct Curl_addrinfo *Curl_resolv_get_ai(struct Curl_easy *data, uint32_t resolv_id, int ai_family, unsigned int index) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); (void)index; if(!async) return NULL; if((ai_family == AF_INET) && !(async->dns_queries & CURL_DNSQ_A)) return NULL; #ifdef USE_IPV6 if((ai_family == AF_INET6) && !(async->dns_queries & CURL_DNSQ_AAAA)) return NULL; #endif return Curl_async_get_ai(data, async, ai_family, index); } #ifdef USE_HTTPSRR const struct Curl_https_rrinfo * Curl_resolv_get_https(struct Curl_easy *data, uint32_t resolv_id) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); if(!async) return NULL; return Curl_async_get_https(data, async); } bool Curl_resolv_knows_https(struct Curl_easy *data, uint32_t resolv_id) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); if(!async) return TRUE; return Curl_async_knows_https(data, async); } #endif /* USE_HTTPSRR */ #endif /* USE_CURL_ASYNC */ static CURLcode hostip_resolv_start(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, bool for_proxy, timediff_t timeout_ms, bool allowDOH, uint32_t *presolv_id, struct Curl_dns_entry **pdns) { #ifdef USE_CURL_ASYNC struct Curl_resolv_async *async = NULL; #endif struct Curl_addrinfo *addr = NULL; size_t hostname_len; CURLcode result = CURLE_OK; (void)timeout_ms; /* not in all ifdefs */ *presolv_id = 0; *pdns = NULL; /* Check for "known" things to resolve ourselves. */ #ifndef USE_RESOLVE_ON_IPS if(Curl_is_ipaddr(hostname)) { /* test655 verifies that the announce is done, even though there * is no real resolving. So, keep doing this. */ result = Curl_resolv_announce_start(data, NULL); if(result) goto out; /* shortcut literal IP addresses, if we are not told to resolve them. */ result = Curl_str2addr(hostname, port, &addr); goto out; } #endif hostname_len = strlen(hostname); if(curl_strequal(hostname, "localhost") || curl_strequal(hostname, "localhost.") || tailmatch(hostname, hostname_len, STRCONST(".localhost")) || tailmatch(hostname, hostname_len, STRCONST(".localhost."))) { result = Curl_resolv_announce_start(data, NULL); if(result) goto out; addr = get_localhost(port, hostname); if(!addr) result = CURLE_OUT_OF_MEMORY; goto out; } #ifndef CURL_DISABLE_DOH if(!Curl_is_ipaddr(hostname) && allowDOH && data->set.doh) { result = Curl_resolv_announce_start(data, NULL); if(result) goto out; if(!async) { async = hostip_async_new(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms); if(!async) { result = CURLE_OUT_OF_MEMORY; goto out; } } result = Curl_doh(data, async); goto out; } #else (void)allowDOH; #endif /* Can we provide the requested IP specifics in resolving? */ if(!can_resolve_dns_queries(data, dns_queries)) { result = RESOLV_FAIL(for_proxy); goto out; } #ifdef CURLRES_ASYNCH (void)addr; if(!async) { async = hostip_async_new(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms); if(!async) { result = CURLE_OUT_OF_MEMORY; goto out; } } result = Curl_async_getaddrinfo(data, async); if(result == CURLE_AGAIN) { /* the answer might be there already. Check. */ CURLcode r2 = hostip_resolv_take_result(data, async, pdns); if(r2) result = r2; else if(*pdns) result = CURLE_OK; } #else result = Curl_resolv_announce_start(data, NULL); if(result) goto out; addr = Curl_sync_getaddrinfo(data, dns_queries, hostname, port, transport); if(!addr) result = RESOLV_FAIL(for_proxy); #endif out: if(!result) { if(addr) { /* we got a response, create a dns entry, add to cache, return */ DEBUGASSERT(!*pdns); *pdns = Curl_dnscache_mk_entry(data, dns_queries, &addr, hostname, port); if(!*pdns) result = CURLE_OUT_OF_MEMORY; } else if(!*pdns) result = CURLE_AGAIN; } else if(*pdns) Curl_dns_entry_unlink(data, pdns); else if(addr) Curl_freeaddrinfo(addr); #ifdef USE_CURL_ASYNC if(async) { if(result == CURLE_AGAIN) { /* still need it, link, return id. */ *presolv_id = async->id; async->next = data->state.async; data->state.async = async; } else { Curl_async_destroy(data, async); } } #endif return result; } static CURLcode hostip_resolv(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, bool for_proxy, timediff_t timeout_ms, bool allowDOH, uint32_t *presolv_id, struct Curl_dns_entry **pdns) { size_t hostname_len; CURLcode result = RESOLV_FAIL(for_proxy); bool cache_dns = FALSE; (void)timeout_ms; /* not used in all ifdefs */ *presolv_id = 0; *pdns = NULL; #ifdef CURL_DISABLE_DOH (void)allowDOH; #endif /* We should intentionally error and not resolve .onion TLDs */ hostname_len = strlen(hostname); DEBUGASSERT(hostname_len); if(hostname_len >= 7 && (curl_strequal(&hostname[hostname_len - 6], ".onion") || curl_strequal(&hostname[hostname_len - 7], ".onion."))) { failf(data, "Not resolving .onion address (RFC 7686)"); goto out; } #ifdef DEBUGBUILD CURL_TRC_DNS(data, "hostip_resolv(%s:%u, queries=%s)", hostname, port, Curl_resolv_query_str(dns_queries)); if((CURL_DNSQ_IP(dns_queries) == CURL_DNSQ_AAAA) && getenv("CURL_DBG_RESOLV_FAIL_IPV6")) { infof(data, "DEBUG fail ipv6 resolve"); result = hostip_resolv_failed(data, hostname, for_proxy); goto out; } #endif /* Let's check our DNS cache first */ result = Curl_dnscache_get(data, dns_queries, hostname, port, pdns); if(*pdns) { infof(data, "Hostname %s was found in DNS cache", hostname); result = CURLE_OK; } else if(result) { infof(data, "Negative DNS entry"); result = hostip_resolv_failed(data, hostname, for_proxy); } else { /* No luck, we need to start resolving. */ cache_dns = TRUE; result = hostip_resolv_start(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms, allowDOH, presolv_id, pdns); } out: if(result && (result != CURLE_AGAIN)) { Curl_dns_entry_unlink(data, pdns); if(IS_RESOLV_FAIL(result)) { if(cache_dns) Curl_dnscache_add_negative(data, dns_queries, hostname, port); failf(data, "Could not resolve: %s:%u", hostname, port); } else { failf(data, "Error %d resolving %s:%u", result, hostname, port); } } else if(cache_dns && *pdns) { result = Curl_dnscache_add(data, *pdns); if(result) Curl_dns_entry_unlink(data, pdns); } return result; } CURLcode Curl_resolv_blocking(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, struct Curl_dns_entry **pdns) { CURLcode result; uint32_t resolv_id; DEBUGASSERT(hostname && *hostname); *pdns = NULL; /* We cannot do a blocking resolve using DoH currently */ result = hostip_resolv(data, dns_queries, hostname, port, transport, FALSE, 0, FALSE, &resolv_id, pdns); switch(result) { case CURLE_OK: DEBUGASSERT(*pdns); break; #ifdef USE_CURL_ASYNC case CURLE_AGAIN: DEBUGASSERT(!*pdns); result = Curl_async_await(data, resolv_id, pdns); Curl_resolv_destroy(data, resolv_id); break; #endif default: break; } return result; } #ifdef USE_ALARM_TIMEOUT /* * This signal handler jumps back into the main libcurl code and continues * execution. This effectively causes the remainder of the application to run * within a signal handler which is nonportable and could lead to problems. */ CURL_NORETURN static void alarmfunc(int sig) { (void)sig; siglongjmp(curl_jmpenv, 1); } #endif /* USE_ALARM_TIMEOUT */ #ifdef USE_ALARM_TIMEOUT static CURLcode resolv_alarm_timeout(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, bool for_proxy, timediff_t timeout_ms, uint32_t *presolv_id, struct Curl_dns_entry **entry) { #ifdef HAVE_SIGACTION struct sigaction keep_sigact; /* store the old struct here */ volatile bool keep_copysig = FALSE; /* whether old sigact has been saved */ struct sigaction sigact; #else #ifdef HAVE_SIGNAL void (*keep_sigact)(int); /* store the old handler here */ #endif /* HAVE_SIGNAL */ #endif /* HAVE_SIGACTION */ volatile long timeout; volatile unsigned int prev_alarm = 0; CURLcode result; DEBUGASSERT(hostname && *hostname); DEBUGASSERT(timeout_ms > 0); DEBUGASSERT(!data->set.no_signal); #ifndef CURL_DISABLE_DOH DEBUGASSERT(!data->set.doh); #endif *entry = NULL; timeout = (timeout_ms > LONG_MAX) ? LONG_MAX : (long)timeout_ms; if(timeout < 1000) { /* The alarm() function only provides integer second resolution, so if we want to wait less than one second we must bail out already now. */ failf(data, "remaining timeout of %ld too small to resolve via SIGALRM method", timeout); return CURLE_OPERATION_TIMEDOUT; } /* This allows us to time-out from the name resolver, as the timeout will generate a signal and we will siglongjmp() from that here. This technique has problems (see alarmfunc). This should be the last thing we do before calling Curl_resolv(), as otherwise we would have to worry about variables that get modified before we invoke Curl_resolv() (and thus use "volatile"). */ curl_simple_lock_lock(&curl_jmpenv_lock); if(sigsetjmp(curl_jmpenv, 1)) { /* this is coming from a siglongjmp() after an alarm signal */ failf(data, "name lookup timed out"); result = CURLE_OPERATION_TIMEDOUT; goto clean_up; } else { /************************************************************* * Set signal handler to catch SIGALRM * Store the old value to be able to set it back later! *************************************************************/ #ifdef HAVE_SIGACTION sigaction(SIGALRM, NULL, &sigact); keep_sigact = sigact; keep_copysig = TRUE; /* yes, we have a copy */ sigact.sa_handler = alarmfunc; #ifdef SA_RESTART /* HP-UX does not have SA_RESTART but defaults to that behavior! */ sigact.sa_flags &= ~SA_RESTART; #endif /* now set the new struct */ sigaction(SIGALRM, &sigact, NULL); #else /* HAVE_SIGACTION */ /* no sigaction(), revert to the much lamer signal() */ #ifdef HAVE_SIGNAL keep_sigact = signal(SIGALRM, alarmfunc); #endif #endif /* HAVE_SIGACTION */ /* alarm() makes a signal get sent when the timeout fires off, and that will abort system calls */ prev_alarm = alarm(curlx_sltoui(timeout / 1000L)); } /* Perform the actual name resolution. This might be interrupted by an * alarm if it takes too long. */ result = hostip_resolv(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms, FALSE, presolv_id, entry); clean_up: if(!prev_alarm) /* deactivate a possibly active alarm before uninstalling the handler */ alarm(0); #ifdef HAVE_SIGACTION if(keep_copysig) { /* we got a struct as it looked before, now put that one back nice and clean */ sigaction(SIGALRM, &keep_sigact, NULL); /* put it back */ } #else #ifdef HAVE_SIGNAL /* restore the previous SIGALRM handler */ signal(SIGALRM, keep_sigact); #endif #endif /* HAVE_SIGACTION */ curl_simple_lock_unlock(&curl_jmpenv_lock); /* switch back the alarm() to either zero or to what it was before minus the time we spent until now! */ if(prev_alarm) { /* there was an alarm() set before us, now put it back */ timediff_t elapsed_secs = curlx_ptimediff_ms(Curl_pgrs_now(data), &data->conn->created) / 1000; /* the alarm period is counted in even number of seconds */ unsigned long alarm_set = (unsigned long)(prev_alarm - elapsed_secs); if(!alarm_set || ((alarm_set >= 0x80000000) && (prev_alarm < 0x80000000))) { /* if the alarm time-left reached zero or turned "negative" (counted with unsigned values), we should fire off a SIGALRM here, but we will not, and zero would be to switch it off so we never set it to less than 1! */ alarm(1); result = CURLE_OPERATION_TIMEDOUT; failf(data, "Previous alarm fired off"); } else alarm((unsigned int)alarm_set); } return result; } #endif /* USE_ALARM_TIMEOUT */ /* * Curl_resolv() is the main name resolve function within libcurl. It resolves * a name and returns a pointer to the entry in the 'entry' argument. This * function might return immediately if we are using asynch resolves. See the * return codes. * * The cache entry we return will get its 'inuse' counter increased when this * function is used. You MUST call Curl_dns_entry_unlink() later (when you are * done using this struct) to decrease the reference counter again. * * If built with a synchronous resolver and use of signals is not * disabled by the application, then a nonzero timeout will cause a * timeout after the specified number of milliseconds. Otherwise, timeout * is ignored. * * Return codes: * CURLE_OK = success, *pdns set to non-NULL * CURLE_AGAIN = resolving in progress, *pdns == NULL * any other CURLcode error, *pdns == NULL */ CURLcode Curl_resolv(struct Curl_easy *data, uint8_t dns_queries, const char *hostname, uint16_t port, uint8_t transport, bool for_proxy, timediff_t timeout_ms, uint32_t *presolv_id, struct Curl_dns_entry **pdns) { DEBUGASSERT(hostname && *hostname); *presolv_id = 0; *pdns = NULL; if(timeout_ms < 0) /* got an already expired timeout */ return CURLE_OPERATION_TIMEDOUT; else if(!timeout_ms) timeout_ms = CURL_TIMEOUT_RESOLVE_MS; #ifdef USE_ALARM_TIMEOUT if(timeout_ms && data->set.no_signal) { /* Cannot use ALARM when signals are disabled */ timeout_ms = 0; } if(timeout_ms && !Curl_doh_wanted(data)) { return resolv_alarm_timeout(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms, presolv_id, pdns); } #endif /* !USE_ALARM_TIMEOUT */ #ifndef CURLRES_ASYNCH if(timeout_ms) infof(data, "timeout on name lookup is not supported"); #endif return hostip_resolv(data, dns_queries, hostname, port, transport, for_proxy, timeout_ms, TRUE, presolv_id, pdns); } #ifdef USE_CURL_ASYNC struct Curl_resolv_async *Curl_async_get(struct Curl_easy *data, uint32_t resolv_id) { struct Curl_resolv_async *async = data->state.async; for(; async; async = async->next) { if(async->id == resolv_id) return async; } return NULL; } CURLcode Curl_resolv_take_result(struct Curl_easy *data, uint32_t resolv_id, struct Curl_dns_entry **pdns) { struct Curl_resolv_async *async = Curl_async_get(data, resolv_id); CURLcode result; /* If async resolving is ongoing, this must be set */ if(!async) return CURLE_FAILED_INIT; /* check if we have the name resolved by now (from someone else) */ result = Curl_dnscache_get(data, async->dns_queries, async->hostname, async->port, pdns); if(*pdns) { /* Tell a possibly async resolver we no longer need the results. */ infof(data, "Hostname '%s' was found in DNS cache", async->hostname); Curl_async_shutdown(data, async); return CURLE_OK; } else if(result) { Curl_async_shutdown(data, async); return Curl_async_failed(data, async, NULL); } result = hostip_resolv_take_result(data, async, pdns); if(*pdns) { /* Add to cache */ result = Curl_dnscache_add(data, *pdns); if(result) Curl_dns_entry_unlink(data, pdns); } else if(IS_RESOLV_FAIL(result)) { Curl_dnscache_add_negative(data, async->dns_queries, async->hostname, async->port); failf(data, "Could not resolve: %s:%u", async->hostname, async->port); } else if(result) { failf(data, "Error %d resolving %s:%u", result, async->hostname, async->port); } return result; } CURLcode Curl_resolv_pollset(struct Curl_easy *data, struct easy_pollset *ps) { struct Curl_resolv_async *async = data->state.async; CURLcode result = CURLE_OK; (void)ps; for(; async && !result; async = async->next) { #ifndef CURL_DISABLE_DOH if(async->doh) /* DoH has nothing for the pollset */ continue; #endif result = Curl_async_pollset(data, async, ps); } return result; } void Curl_resolv_destroy(struct Curl_easy *data, uint32_t resolv_id) { struct Curl_resolv_async **panchor = &data->state.async; for(; *panchor; panchor = &(*panchor)->next) { struct Curl_resolv_async *async = *panchor; if(async->id == resolv_id) { *panchor = async->next; Curl_async_destroy(data, async); break; } } } void Curl_resolv_shutdown_all(struct Curl_easy *data) { struct Curl_resolv_async *async = data->state.async; for(; async; async = async->next) { Curl_async_shutdown(data, async); } } void Curl_resolv_destroy_all(struct Curl_easy *data) { while(data->state.async) { struct Curl_resolv_async *async = data->state.async; data->state.async = async->next; Curl_async_destroy(data, async); } } #endif /* USE_CURL_ASYNC */ #ifdef USE_UNIX_SOCKETS CURLcode Curl_resolv_unix(struct Curl_easy *data, const char *unix_path, bool abstract_path, struct Curl_dns_entry **pdns) { struct Curl_addrinfo *addr; CURLcode result; DEBUGASSERT(unix_path); *pdns = NULL; result = Curl_unix2addr(unix_path, abstract_path, &addr); if(result) { if(result == CURLE_TOO_LARGE) { /* Long paths are not supported for now */ failf(data, "Unix socket path too long: '%s'", unix_path); result = CURLE_COULDNT_RESOLVE_HOST; } return result; } *pdns = Curl_dnscache_mk_entry(data, 0, &addr, NULL, 0); return *pdns ? CURLE_OK : CURLE_OUT_OF_MEMORY; } #endif /* USE_UNIX_SOCKETS */