git-market/curl-curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-04-11 12:01:42 +08:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity
master
curl-curl/lib/hostip.c
Stefan Eissing a28540787c
asyn-ares: connect async 
Make separate queries for A and AAAA records. Hand out A/AAAA/HTTPS
information before all queries are complete.

Closes #21205
2026-04-09 09:32:12 +02:00

1116 lines
33 KiB
C
Raw Permalink Blame History

/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, 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 <netinet/in.h>
#endif
#ifdef HAVE_NETINET_IN6_H
#include <netinet/in6.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef __VMS
#include <in.h>
#include <inet.h>
#endif
#include <setjmp.h> /* for sigjmp_buf, sigsetjmp() */
#include <signal.h>
#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
/*
* 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.
*/
/*
* 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.
*/
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(Curl_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
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;
#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;
}
/*
* Curl_ipv6works() returns TRUE if IPv6 seems to work.
*/
bool Curl_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 bool can_resolve_dns_queries(struct Curl_easy *data,
uint8_t dns_queries)
{
(void)data;
if((CURL_DNSQ_IP(dns_queries) == CURL_DNSQ_AAAA) && !Curl_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,
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->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(data->conn->bits.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, "result incomplete, queries=%s, responses=%s, "
"ongoing=%d", Curl_resolv_query_str(async->dns_queries),
Curl_resolv_query_str(async->dns_responses),
async->queries_ongoing);
result = CURLE_OK;
}
else if(result) {
CURL_TRC_DNS(data, "result error %d", result);
Curl_resolver_error(data, NULL);
}
else {
CURL_TRC_DNS(data, "result complete");
DEBUGASSERT(*pdns);
}
return result;
}
const struct Curl_addrinfo *
Curl_resolv_get_ai(struct Curl_easy *data, uint32_t resolv_id,
int ai_family, unsigned int index)
{
#ifdef CURLRES_ASYNCH
struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
if(async)
return Curl_async_get_ai(data, async, ai_family, index);
#else
(void)data;
(void)resolv_id;
(void)ai_family;
(void)index;
#endif
return NULL;
}
#ifdef USE_HTTPSRR
const struct Curl_https_rrinfo *
Curl_resolv_get_https(struct Curl_easy *data, uint32_t resolv_id)
{
#ifdef CURLRES_ASYNCH
struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
if(async)
return Curl_async_get_https(data, async);
#else
(void)data;
(void)resolv_id;
#endif
return NULL;
}
bool Curl_resolv_knows_https(struct Curl_easy *data, uint32_t resolv_id)
{
#ifdef CURLRES_ASYNCH
struct Curl_resolv_async *async = Curl_async_get(data, resolv_id);
if(async)
return Curl_async_knows_https(data, async);
#else
(void)data;
(void)resolv_id;
#endif
return TRUE;
}
#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,
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, 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 = CURLE_COULDNT_RESOLVE_HOST;
goto out;
}
#ifdef CURLRES_ASYNCH
(void)addr;
if(!async) {
async = hostip_async_new(data, dns_queries, hostname, port,
transport, 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 = CURLE_COULDNT_RESOLVE_HOST;
#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,
timediff_t timeout_ms,
bool allowDOH,
uint32_t *presolv_id,
struct Curl_dns_entry **pdns)
{
size_t hostname_len;
CURLcode result = CURLE_COULDNT_RESOLVE_HOST;
bool cache_dns = FALSE;
(void)timeout_ms; /* not used in all ifdefs */
*presolv_id = 0;
*pdns = NULL;
#ifndef CURL_DISABLE_DOH
data->conn->bits.doh = FALSE; /* default is not */
#else
(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 = Curl_resolver_error(data, NULL);
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 = Curl_resolver_error(data, NULL);
}
else {
/* No luck, we need to start resolving. */
cache_dns = TRUE;
result = hostip_resolv_start(data, dns_queries, hostname, port,
transport, timeout_ms, allowDOH,
presolv_id, pdns);
}
out:
if(result && (result != CURLE_AGAIN)) {
Curl_dns_entry_unlink(data, pdns);
if((result == CURLE_COULDNT_RESOLVE_HOST) ||
(result == CURLE_COULDNT_RESOLVE_PROXY)) {
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, 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,
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,
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, *entry set to non-NULL
* CURLE_AGAIN = resolving in progress, *entry == NULL
* CURLE_COULDNT_RESOLVE_HOST = error, *entry == NULL
* CURLE_OPERATION_TIMEDOUT = timeout expired, *entry == NULL
*/
CURLcode Curl_resolv(struct Curl_easy *data,
uint8_t dns_queries,
const char *hostname,
uint16_t port,
uint8_t transport,
timediff_t timeout_ms,
uint32_t *presolv_id,
struct Curl_dns_entry **entry)
{
DEBUGASSERT(hostname && *hostname);
*presolv_id = 0;
*entry = 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,
timeout_ms, presolv_id, entry);
}
#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,
timeout_ms, TRUE, presolv_id, entry);
}
#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_resolver_error(data, 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((result == CURLE_COULDNT_RESOLVE_HOST) ||
(result == CURLE_COULDNT_RESOLVE_PROXY)) {
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 */
/*
* Curl_resolver_error() calls failf() with the appropriate message after a
* resolve error
*/
CURLcode Curl_resolver_error(struct Curl_easy *data, const char *detail)
{
struct connectdata *conn = data->conn;
const char *host_or_proxy = "host";
const char *name = conn->host.dispname;
CURLcode result = CURLE_COULDNT_RESOLVE_HOST;
#ifndef CURL_DISABLE_PROXY
if(conn->bits.proxy) {
host_or_proxy = "proxy";
result = CURLE_COULDNT_RESOLVE_PROXY;
name = conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname :
conn->http_proxy.host.dispname;
}
#endif
failf(data, "Could not resolve %s: %s%s%s%s", host_or_proxy, name,
detail ? " (" : "", detail ? detail : "", detail ? ")" : "");
return result;
}
#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 */
Reference in New Issue View Git Blame Copy Permalink