Lots of comments added an clarified. Added timeout for the ares version
of Curl_is_resolved() to address Roy Shan's reported problem.
This commit is contained in:
Daniel Stenberg
parent
894dbae455
commit
b8b8473b6d
259
lib/hostip.c
259
lib/hostip.c
@ -88,9 +88,19 @@
|
||||
#define ARES_SUCCESS CURLE_OK
|
||||
#endif
|
||||
|
||||
/* These two symbols are for the global DNS cache */
|
||||
static curl_hash hostname_cache;
|
||||
static int host_cache_initialized;
|
||||
|
||||
|
||||
static void freednsentry(void *freethis);
|
||||
|
||||
/*
|
||||
* my_getaddrinfo() is the generic low-level name resolve API within this
|
||||
* source file. There exist three versions of this function - for different
|
||||
* name resolve layers (selected at build-time). They all take this same set
|
||||
* of arguments
|
||||
*/
|
||||
static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
char *hostname,
|
||||
int port,
|
||||
@ -123,19 +133,30 @@ struct thread_data {
|
||||
};
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Curl_global_host_cache_init() initializes and sets up a global DNS cache.
|
||||
* Global DNS cache is general badness. Do not use. This will be removed in
|
||||
* a future version. Use the share interface instead!
|
||||
*/
|
||||
void Curl_global_host_cache_init(void)
|
||||
{
|
||||
if (!host_cache_initialized) {
|
||||
Curl_hash_init(&hostname_cache, 7, Curl_freednsinfo);
|
||||
Curl_hash_init(&hostname_cache, 7, freednsentry);
|
||||
host_cache_initialized = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Return a pointer to the global cache
|
||||
*/
|
||||
curl_hash *Curl_global_host_cache_get(void)
|
||||
{
|
||||
return &hostname_cache;
|
||||
}
|
||||
|
||||
/*
|
||||
* Destroy and cleanup the global DNS cache
|
||||
*/
|
||||
void Curl_global_host_cache_dtor(void)
|
||||
{
|
||||
if (host_cache_initialized) {
|
||||
@ -144,7 +165,10 @@ void Curl_global_host_cache_dtor(void)
|
||||
}
|
||||
}
|
||||
|
||||
/* count the number of characters that an integer takes up */
|
||||
/*
|
||||
* Minor utility-function:
|
||||
* Count the number of characters that an integer takes up.
|
||||
*/
|
||||
static int _num_chars(int i)
|
||||
{
|
||||
int chars = 0;
|
||||
@ -165,7 +189,10 @@ static int _num_chars(int i)
|
||||
return chars;
|
||||
}
|
||||
|
||||
/* Create a hostcache id */
|
||||
/*
|
||||
* Minor utility-function:
|
||||
* Create a hostcache id string for the DNS caching.
|
||||
*/
|
||||
static char *
|
||||
create_hostcache_id(char *server, int port, size_t *entry_len)
|
||||
{
|
||||
@ -192,6 +219,13 @@ struct hostcache_prune_data {
|
||||
time_t now;
|
||||
};
|
||||
|
||||
/*
|
||||
* This function is set as a callback to be called for every entry in the DNS
|
||||
* cache when we want to prune old unused entries.
|
||||
*
|
||||
* Returning non-zero means remove the entry, return 0 to keep it in the
|
||||
* cache.
|
||||
*/
|
||||
static int
|
||||
hostcache_timestamp_remove(void *datap, void *hc)
|
||||
{
|
||||
@ -209,6 +243,9 @@ hostcache_timestamp_remove(void *datap, void *hc)
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Prune the DNS cache. This assumes that a lock has already been taken.
|
||||
*/
|
||||
static void
|
||||
hostcache_prune(curl_hash *hostcache, int cache_timeout, time_t now)
|
||||
{
|
||||
@ -222,6 +259,10 @@ hostcache_prune(curl_hash *hostcache, int cache_timeout, time_t now)
|
||||
hostcache_timestamp_remove);
|
||||
}
|
||||
|
||||
/*
|
||||
* Library-wide function for pruning the DNS cache. This function takes and
|
||||
* returns the appropriate locks.
|
||||
*/
|
||||
void Curl_hostcache_prune(struct SessionHandle *data)
|
||||
{
|
||||
time_t now;
|
||||
@ -245,15 +286,22 @@ void Curl_hostcache_prune(struct SessionHandle *data)
|
||||
}
|
||||
|
||||
#ifdef HAVE_SIGSETJMP
|
||||
/* Beware this is a global and unique instance */
|
||||
/* 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. */
|
||||
sigjmp_buf curl_jmpenv;
|
||||
#endif
|
||||
|
||||
|
||||
/* When calling Curl_resolv() has resulted in a response with a returned
|
||||
address, we call this function to store the information in the dns
|
||||
cache etc */
|
||||
|
||||
/*
|
||||
* cache_resolv_response() stores a 'Curl_addrinfo' struct in the DNS cache.
|
||||
*
|
||||
* When calling Curl_resolv() has resulted in a response with a returned
|
||||
* address, we call this function to store the information in the dns
|
||||
* cache etc
|
||||
*
|
||||
* Returns the Curl_dns_entry entry pointer or NULL if the storage failed.
|
||||
*/
|
||||
static struct Curl_dns_entry *
|
||||
cache_resolv_response(struct SessionHandle *data,
|
||||
Curl_addrinfo *addr,
|
||||
@ -303,15 +351,22 @@ cache_resolv_response(struct SessionHandle *data,
|
||||
return dns;
|
||||
}
|
||||
|
||||
/* Resolve a name and return a pointer in the 'entry' argument if one
|
||||
is available.
|
||||
|
||||
Return codes:
|
||||
|
||||
-1 = error, no pointer
|
||||
0 = OK, pointer provided
|
||||
1 = waiting for response, no pointer
|
||||
*/
|
||||
/*
|
||||
* 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 (if one
|
||||
* is provided). This function might return immediately if we're 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_resolv_unlock() later (when you're
|
||||
* done using this struct) to decrease the counter again.
|
||||
*
|
||||
* Return codes:
|
||||
*
|
||||
* -1 = error, no pointer
|
||||
* 0 = OK, pointer provided
|
||||
* 1 = waiting for response, no pointer
|
||||
*/
|
||||
int Curl_resolv(struct connectdata *conn,
|
||||
char *hostname,
|
||||
int port,
|
||||
@ -405,6 +460,11 @@ int Curl_resolv(struct connectdata *conn,
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
* Curl_resolv_unlock() unlocks the given cached DNS entry. When this has been
|
||||
* made, the struct may be destroyed due to pruning. It is important that only
|
||||
* one unlock is made for each Curl_resolv() call.
|
||||
*/
|
||||
void Curl_resolv_unlock(struct SessionHandle *data, struct Curl_dns_entry *dns)
|
||||
{
|
||||
if(data->share)
|
||||
@ -438,9 +498,9 @@ void Curl_freeaddrinfo(Curl_addrinfo *p)
|
||||
}
|
||||
|
||||
/*
|
||||
* Free a cache dns entry.
|
||||
* File-internal: free a cache dns entry.
|
||||
*/
|
||||
void Curl_freednsinfo(void *freethis)
|
||||
static void freednsentry(void *freethis)
|
||||
{
|
||||
struct Curl_dns_entry *p = (struct Curl_dns_entry *) freethis;
|
||||
|
||||
@ -449,6 +509,14 @@ void Curl_freednsinfo(void *freethis)
|
||||
free(p);
|
||||
}
|
||||
|
||||
/*
|
||||
* Curl_mk_dnscache() creates a new DNS cache and returns the handle for it.
|
||||
*/
|
||||
curl_hash *Curl_mk_dnscache(void)
|
||||
{
|
||||
return Curl_hash_alloc(7, freednsentry);
|
||||
}
|
||||
|
||||
/* --- resolve name or IP-number --- */
|
||||
|
||||
/* Allocate enough memory to hold the full name information structs and
|
||||
@ -460,6 +528,15 @@ void Curl_freednsinfo(void *freethis)
|
||||
|
||||
#ifdef USE_ARES
|
||||
|
||||
/*
|
||||
* Curl_multi_ares_fdset() is called when someone from the outside world
|
||||
* (using curl_multi_fdset()) wants to get our fd_set setup and we're talking
|
||||
* with ares. The caller must make sure that this function is only called when
|
||||
* we have a working ares channel.
|
||||
*
|
||||
* Returns: CURLE_OK always!
|
||||
*/
|
||||
|
||||
CURLcode Curl_multi_ares_fdset(struct connectdata *conn,
|
||||
fd_set *read_fd_set,
|
||||
fd_set *write_fd_set,
|
||||
@ -473,7 +550,13 @@ CURLcode Curl_multi_ares_fdset(struct connectdata *conn,
|
||||
return CURLE_OK;
|
||||
}
|
||||
|
||||
/* called to check if the name is resolved now */
|
||||
/*
|
||||
* Curl_is_resolved() is called repeatedly to check if a previous name resolve
|
||||
* request has completed. It should also make sure to time-out if the
|
||||
* operation seems to take too long.
|
||||
*
|
||||
* Returns normal CURLcode errors.
|
||||
*/
|
||||
CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
struct Curl_dns_entry **dns)
|
||||
{
|
||||
@ -482,9 +565,20 @@ CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
int count;
|
||||
struct SessionHandle *data = conn->data;
|
||||
int nfds;
|
||||
long diff;
|
||||
|
||||
diff = Curl_tvdiff(Curl_tvnow(),
|
||||
data->progress.t_startsingle)/1000;
|
||||
|
||||
if(diff > 180) {
|
||||
/* Waited >180 seconds, this is a name resolve timeout! */
|
||||
failf(data, "Name resolve timeout after %ld seconds", diff);
|
||||
return CURLE_OPERATION_TIMEDOUT;
|
||||
}
|
||||
|
||||
FD_ZERO(&read_fds);
|
||||
FD_ZERO(&write_fds);
|
||||
|
||||
nfds = ares_fds(data->state.areschannel, &read_fds, &write_fds);
|
||||
|
||||
count = select(nfds, &read_fds, &write_fds, NULL,
|
||||
@ -505,14 +599,15 @@ CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
return CURLE_OK;
|
||||
}
|
||||
|
||||
/* This is a function that locks and waits until the name resolve operation
|
||||
has completed.
|
||||
|
||||
If 'entry' is non-NULL, make it point to the resolved dns entry
|
||||
|
||||
Return CURLE_COULDNT_RESOLVE_HOST if the host was not resolved, and
|
||||
CURLE_OPERATION_TIMEDOUT if a time-out occurred.
|
||||
*/
|
||||
/*
|
||||
* Curl_wait_for_resolv() waits for a resolve to finish. This function should
|
||||
* be avoided since using this risk getting the multi interface to "hang".
|
||||
*
|
||||
* If 'entry' is non-NULL, make it point to the resolved dns entry
|
||||
*
|
||||
* Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved, and
|
||||
* CURLE_OPERATION_TIMEDOUT if a time-out occurred.
|
||||
*/
|
||||
CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
struct Curl_dns_entry **entry)
|
||||
{
|
||||
@ -591,8 +686,16 @@ CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
|
||||
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME)
|
||||
|
||||
/* this function gets called by ares/gethostbyname_thread() when we got
|
||||
the name resolved or not */
|
||||
/*
|
||||
* host_callback() gets called by ares/gethostbyname_thread() when we got the
|
||||
* name resolved (or not!).
|
||||
*
|
||||
* If the status argument is ARES_SUCCESS, we must copy the hostent field
|
||||
* since ares will free it when this function returns. This operation stores
|
||||
* the resolved data in the DNS cache.
|
||||
*
|
||||
* The storage operation locks and unlocks the DNS cache.
|
||||
*/
|
||||
static void host_callback(void *arg, /* "struct connectdata *" */
|
||||
int status,
|
||||
struct hostent *hostent)
|
||||
@ -633,9 +736,11 @@ static void host_callback(void *arg, /* "struct connectdata *" */
|
||||
|
||||
#ifdef USE_ARES
|
||||
/*
|
||||
* Return name information about the given hostname and port number. If
|
||||
* my_getaddrinfo() when using ares for name resolves.
|
||||
*
|
||||
* Returns name information about the given hostname and port number. If
|
||||
* successful, the 'hostent' is returned and the forth argument will point to
|
||||
* memory we need to free after use. That meory *MUST* be freed with
|
||||
* memory we need to free after use. That memory *MUST* be freed with
|
||||
* Curl_freeaddrinfo(), nothing else.
|
||||
*/
|
||||
static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
@ -670,9 +775,14 @@ static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
|
||||
#if !defined(USE_ARES) && !defined(USE_THREADING_GETHOSTBYNAME)
|
||||
|
||||
/* For builds without ARES and threaded gethostbyname, Curl_resolv() can never
|
||||
return wait==TRUE, so this function will never be called. If it still gets
|
||||
called, we return failure at once. */
|
||||
/*
|
||||
* Curl_wait_for_resolv() for builds without ARES and threaded gethostbyname,
|
||||
* Curl_resolv() can never return wait==TRUE, so this function will never be
|
||||
* called. If it still gets called, we return failure at once.
|
||||
*
|
||||
* We provide this function only to allow multi.c to remain unaware if we are
|
||||
* doing asynch resolves or not.
|
||||
*/
|
||||
CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
struct Curl_dns_entry **entry)
|
||||
{
|
||||
@ -681,6 +791,13 @@ CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
return CURLE_COULDNT_RESOLVE_HOST;
|
||||
}
|
||||
|
||||
/*
|
||||
* This function will never be called when built with ares or threaded
|
||||
* resolves. If it still gets called, we return failure at once.
|
||||
*
|
||||
* We provide this function only to allow multi.c to remain unaware if we are
|
||||
* doing asynch resolves or not.
|
||||
*/
|
||||
CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
struct Curl_dns_entry **dns)
|
||||
{
|
||||
@ -692,6 +809,12 @@ CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
#endif
|
||||
|
||||
#if !defined(USE_ARES)
|
||||
/*
|
||||
* Non-ares build.
|
||||
*
|
||||
* We provide this function only to allow multi.c to remain unaware if we are
|
||||
* doing asynch resolves or not.
|
||||
*/
|
||||
CURLcode Curl_multi_ares_fdset(struct connectdata *conn,
|
||||
fd_set *read_fd_set,
|
||||
fd_set *write_fd_set,
|
||||
@ -745,9 +868,11 @@ void curl_freeaddrinfo(struct addrinfo *freethis,
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Return name information about the given hostname and port number. If
|
||||
* my_getaddrinfo() when built ipv6-enabled.
|
||||
*
|
||||
* Returns name information about the given hostname and port number. If
|
||||
* successful, the 'addrinfo' is returned and the forth argument will point to
|
||||
* memory we need to free after use. That meory *MUST* be freed with
|
||||
* memory we need to free after use. That memory *MUST* be freed with
|
||||
* Curl_freeaddrinfo(), nothing else.
|
||||
*/
|
||||
static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
@ -809,9 +934,11 @@ static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
|
||||
#if !defined(HAVE_GETHOSTBYNAME_R) || defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME)
|
||||
static void hostcache_fixoffset(struct hostent *h, long offset);
|
||||
|
||||
/*
|
||||
* Performs a "deep" copy of a hostent into a buffer (returns a pointer to the
|
||||
* copy). Make absolutely sure the destination buffer is big enough!
|
||||
* pack_hostent() is a file-local function that performs a "deep" copy of a
|
||||
* hostent into a buffer (returns a pointer to the copy). Make absolutely sure
|
||||
* the destination buffer is big enough!
|
||||
*/
|
||||
static struct hostent* pack_hostent(char** buf, struct hostent* orig)
|
||||
{
|
||||
@ -901,6 +1028,12 @@ static struct hostent* pack_hostent(char** buf, struct hostent* orig)
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* hostcache_fixoffset() is a utility-function that corrects all pointers in
|
||||
* the given hostent struct according to the offset. This is typically used
|
||||
* when a hostent has been reallocated and needs to be setup properly on the
|
||||
* new address.
|
||||
*/
|
||||
static void hostcache_fixoffset(struct hostent *h, long offset)
|
||||
{
|
||||
int i=0;
|
||||
@ -925,6 +1058,11 @@ static void hostcache_fixoffset(struct hostent *h, long offset)
|
||||
|
||||
#ifndef USE_ARES
|
||||
|
||||
/*
|
||||
* MakeIP() converts the input binary ipv4-address to an ascii string in the
|
||||
* dotted numerical format. 'addr' is a pointer to a buffer that is 'addr_len'
|
||||
* bytes big. 'num' is the 32 bit IP number.
|
||||
*/
|
||||
static char *MakeIP(unsigned long num, char *addr, int addr_len)
|
||||
{
|
||||
#if defined(HAVE_INET_NTOA) || defined(HAVE_INET_NTOA_R)
|
||||
@ -946,9 +1084,13 @@ static char *MakeIP(unsigned long num, char *addr, int addr_len)
|
||||
return (addr);
|
||||
}
|
||||
|
||||
/* The original code to this function was once stolen from the Dancer source
|
||||
code, written by Bjorn Reese, it has since been patched and modified
|
||||
considerably. */
|
||||
/*
|
||||
* my_getaddrinfo() - the ipv4 "traditional" version.
|
||||
*
|
||||
* The original code to this function was once stolen from the Dancer source
|
||||
* code, written by Bjorn Reese, it has since been patched and modified
|
||||
* considerably.
|
||||
*/
|
||||
static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
char *hostname,
|
||||
int port,
|
||||
@ -1148,9 +1290,10 @@ static Curl_addrinfo *my_getaddrinfo(struct connectdata *conn,
|
||||
else {
|
||||
|
||||
#ifdef USE_THREADING_GETHOSTBYNAME
|
||||
/* fire up a new resolver thread! */
|
||||
if (init_gethostbyname_thread(conn,hostname,port)) {
|
||||
*waitp = TRUE; /* please wait for the response */
|
||||
return NULL;
|
||||
*waitp = TRUE; /* please wait for the response */
|
||||
return NULL;
|
||||
}
|
||||
infof(data, "init_gethostbyname_thread() failed for %s; code %lu\n",
|
||||
hostname, GetLastError());
|
||||
@ -1194,7 +1337,11 @@ static void trace_it (const char *fmt, ...)
|
||||
}
|
||||
#endif
|
||||
|
||||
/* For builds without ARES/USE_IPV6, create a resolver thread and wait on it.
|
||||
/*
|
||||
* gethostbyname_thread() resolves a name, calls the host_callback and then
|
||||
* exits.
|
||||
*
|
||||
* For builds without ARES/USE_IPV6, create a resolver thread and wait on it.
|
||||
*/
|
||||
static DWORD WINAPI gethostbyname_thread (void *arg)
|
||||
{
|
||||
@ -1223,13 +1370,17 @@ static DWORD WINAPI gethostbyname_thread (void *arg)
|
||||
static void destroy_thread_data (struct connectdata *conn)
|
||||
{
|
||||
if (conn->async.hostname)
|
||||
free(conn->async.hostname);
|
||||
free(conn->async.hostname);
|
||||
if (conn->async.os_specific)
|
||||
free(conn->async.os_specific);
|
||||
free(conn->async.os_specific);
|
||||
conn->async.hostname = NULL;
|
||||
conn->async.os_specific = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* init_gethostbyname_thread() starts a new thread that performs
|
||||
* the actual resolve. This function returns before the resolve is done.
|
||||
*/
|
||||
static bool init_gethostbyname_thread (struct connectdata *conn,
|
||||
const char *hostname, int port)
|
||||
{
|
||||
@ -1265,7 +1416,14 @@ static bool init_gethostbyname_thread (struct connectdata *conn,
|
||||
return (1);
|
||||
}
|
||||
|
||||
/* called to check if the name is resolved now */
|
||||
/*
|
||||
* Curl_wait_for_resolv() waits for a resolve to finish. This function should
|
||||
* be avoided since using this risk getting the multi interface to "hang".
|
||||
*
|
||||
* If 'entry' is non-NULL, make it point to the resolved dns entry
|
||||
*
|
||||
* This is the version for resolves-in-a-thread.
|
||||
*/
|
||||
CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
struct Curl_dns_entry **entry)
|
||||
{
|
||||
@ -1326,6 +1484,11 @@ CURLcode Curl_wait_for_resolv(struct connectdata *conn,
|
||||
return (rc);
|
||||
}
|
||||
|
||||
/*
|
||||
* Curl_is_resolved() is called repeatedly to check if a previous name resolve
|
||||
* request has completed. It should also make sure to time-out if the
|
||||
* operation seems to take too long.
|
||||
*/
|
||||
CURLcode Curl_is_resolved(struct connectdata *conn,
|
||||
struct Curl_dns_entry **entry)
|
||||
{
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user