mirror of
https://github.com/curl/curl.git
synced 2026-08-10 22:00:54 +03:00
56e40ae6a5
"asyn" is the internal name under which both c-ares and threaded resolver operate. Make the naming more consistent. Implement the c-ares resolver in `asyn-ares.*` and the threaded resolver in `asyn-thrdd.*`. The common functions are in `asyn-base.c`. When `CURLRES_ASYNCH` is defined, either of the two is used and `data->state.async` exists. Members of that struct vary for the selected implementation, but have the fields `hostname`, `port` and `ip_version` always present. This are populated when the async resolving starts and eliminate the need to pass them again when checking on the status and processing the results of the resolving. Add a `Curl_resolv_blocking()` to `hostip.h` that relieves FTP and SOCKS from having to repeat the same code. `Curl_resolv_check()` remains the function to check for status of ongoing resolving. Now it also performs internally the check if the needed DNS entry exists in the dnscache and if so, aborts the asnyc operation. (libcurl right now does not check for duplicate resolve attempts. an area for future improvements). The number of functions in `asyn.h` has been reduced. There were subtle difference in "cancel()" and "kill()" calls, both replaced by `Curl_async_shutdown()` now. This changes behaviour for threaded resolver insofar as the resolving thread is now always joined unless `data->set.quick_exit` is set. Before this was only done on some code paths. A future improvement would be a thread pool that keeps a limit and also could handle joins more gracefully. DoH, not previously tagged under "asny", has its struct `doh_probes` now also in `data->state.async`, moved there from `data->req` because it makes more sense. Further integration of DoH underneath the "asyn" umbrella seems like a good idea. Closes #16963
270 lines
8.3 KiB
C
270 lines
8.3 KiB
C
#ifndef HEADER_CURL_ASYN_H
|
|
#define HEADER_CURL_ASYN_H
|
|
/***************************************************************************
|
|
* _ _ ____ _
|
|
* 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 CURLRES_ASYNCH
|
|
|
|
#include "curl_addrinfo.h"
|
|
#include "httpsrr.h"
|
|
|
|
struct addrinfo;
|
|
struct hostent;
|
|
struct Curl_easy;
|
|
struct connectdata;
|
|
struct Curl_dns_entry;
|
|
|
|
#if defined(CURLRES_ARES) && defined(CURLRES_THREADED)
|
|
#error cannot have both CURLRES_ARES and CURLRES_THREADED defined
|
|
#endif
|
|
|
|
/*
|
|
* This header defines all functions in the internal asynch resolver interface.
|
|
* All asynch resolvers need to provide these functions.
|
|
* asyn-ares.c and asyn-thread.c are the current implementations of asynch
|
|
* resolver backends.
|
|
*/
|
|
|
|
/*
|
|
* Curl_async_global_init()
|
|
*
|
|
* Called from curl_global_init() to initialize global resolver environment.
|
|
* Returning anything else than CURLE_OK fails curl_global_init().
|
|
*/
|
|
int Curl_async_global_init(void);
|
|
|
|
/*
|
|
* Curl_async_global_cleanup()
|
|
* Called from curl_global_cleanup() to destroy global resolver environment.
|
|
*/
|
|
void Curl_async_global_cleanup(void);
|
|
|
|
/*
|
|
* Curl_async_get_impl()
|
|
* Get the resolver implementation instance (c-ares channel) or NULL
|
|
* for passing to application callback.
|
|
*/
|
|
CURLcode Curl_async_get_impl(struct Curl_easy *easy, void **impl);
|
|
|
|
/*
|
|
* Curl_async_shutdown().
|
|
*
|
|
* This frees the resources of any async resolve operation.
|
|
*/
|
|
void Curl_async_shutdown(struct Curl_easy *data);
|
|
|
|
/* Curl_async_getsock()
|
|
*
|
|
* This function is called from the Curl_multi_getsock() function. 'sock' is a
|
|
* pointer to an array to hold the file descriptors, with 'numsock' being the
|
|
* size of that array (in number of entries). This function is supposed to
|
|
* return bitmask indicating what file descriptors (referring to array indexes
|
|
* in the 'sock' array) to wait for, read/write.
|
|
*/
|
|
int Curl_async_getsock(struct Curl_easy *data, curl_socket_t *sock);
|
|
|
|
/*
|
|
* Curl_async_is_resolved()
|
|
*
|
|
* 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_async_is_resolved(struct Curl_easy *data,
|
|
struct Curl_dns_entry **dns);
|
|
|
|
/*
|
|
* Curl_async_await()
|
|
*
|
|
* Waits for a resolve to finish. This function should be avoided since using
|
|
* this risk getting the multi interface to "hang".
|
|
*
|
|
* On return 'entry' is assigned the resolved dns (CURLE_OK or NULL otherwise.
|
|
*
|
|
* Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved,
|
|
* CURLE_OPERATION_TIMEDOUT if a time-out occurred, or other errors.
|
|
*/
|
|
CURLcode Curl_async_await(struct Curl_easy *data,
|
|
struct Curl_dns_entry **dnsentry);
|
|
|
|
/*
|
|
* Curl_async_getaddrinfo() - when using this resolver
|
|
*
|
|
* Returns name information about the given hostname and port number. If
|
|
* successful, the 'hostent' is returned and the fourth argument will point to
|
|
* memory we need to free after use. That memory *MUST* be freed with
|
|
* Curl_freeaddrinfo(), nothing else.
|
|
*
|
|
* Each resolver backend must of course make sure to return data in the
|
|
* correct format to comply with this.
|
|
*/
|
|
struct Curl_addrinfo *Curl_async_getaddrinfo(struct Curl_easy *data,
|
|
const char *hostname,
|
|
int port,
|
|
int ip_version,
|
|
int *waitp);
|
|
|
|
#ifdef USE_ARES
|
|
/* common functions for c-ares and threaded resolver with HTTPSRR */
|
|
#include <ares.h>
|
|
|
|
int Curl_ares_getsock(struct Curl_easy *data,
|
|
ares_channel channel,
|
|
curl_socket_t *socks);
|
|
int Curl_ares_perform(ares_channel channel,
|
|
timediff_t timeout_ms);
|
|
#endif
|
|
|
|
#ifdef CURLRES_ARES
|
|
/* async resolving implementation using c-ares alone */
|
|
struct async_ares_ctx {
|
|
ares_channel channel;
|
|
int num_pending; /* number of outstanding c-ares requests */
|
|
struct Curl_addrinfo *temp_ai; /* intermediary result while fetching c-ares
|
|
parts */
|
|
int last_status;
|
|
CURLcode result; /* CURLE_OK or error handling response */
|
|
#ifndef HAVE_CARES_GETADDRINFO
|
|
struct curltime happy_eyeballs_dns_time; /* when this timer started, or 0 */
|
|
#endif
|
|
#ifdef USE_HTTPSRR
|
|
struct Curl_https_rrinfo hinfo;
|
|
#endif
|
|
};
|
|
|
|
/*
|
|
* Function provided by the resolver backend to set DNS servers to use.
|
|
*/
|
|
CURLcode Curl_set_dns_servers(struct Curl_easy *data, char *servers);
|
|
|
|
/*
|
|
* Function provided by the resolver backend to set
|
|
* outgoing interface to use for DNS requests
|
|
*/
|
|
CURLcode Curl_set_dns_interface(struct Curl_easy *data,
|
|
const char *interf);
|
|
|
|
/*
|
|
* Function provided by the resolver backend to set
|
|
* local IPv4 address to use as source address for DNS requests
|
|
*/
|
|
CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
|
|
const char *local_ip4);
|
|
|
|
/*
|
|
* Function provided by the resolver backend to set
|
|
* local IPv6 address to use as source address for DNS requests
|
|
*/
|
|
CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
|
|
const char *local_ip6);
|
|
|
|
#endif /* CURLRES_ARES */
|
|
|
|
#ifdef CURLRES_THREADED
|
|
/* async resolving implementation using POSIX threads */
|
|
#include "curl_threads.h"
|
|
|
|
/* Context for threaded address resolver */
|
|
struct async_thrdd_addr_ctx {
|
|
curl_thread_t thread_hnd;
|
|
char *hostname; /* hostname to resolve, Curl_async.hostname
|
|
duplicate */
|
|
curl_mutex_t mutx;
|
|
#ifndef CURL_DISABLE_SOCKETPAIR
|
|
curl_socket_t sock_pair[2]; /* eventfd/pipes/socket pair */
|
|
#endif
|
|
struct Curl_addrinfo *res;
|
|
#ifdef HAVE_GETADDRINFO
|
|
struct addrinfo hints;
|
|
#endif
|
|
struct curltime start;
|
|
timediff_t interval_end;
|
|
unsigned int poll_interval;
|
|
int port;
|
|
int sock_error;
|
|
int ref_count;
|
|
};
|
|
|
|
/* Context for threaded resolver */
|
|
struct async_thrdd_ctx {
|
|
/* `addr` is a pointer since this memory is shared with a started
|
|
* thread. Since threads cannot be killed, we use reference counting
|
|
* so that we can "release" our pointer to this memory while the
|
|
* thread is still running. */
|
|
struct async_thrdd_addr_ctx *addr;
|
|
#if defined(USE_HTTPSRR) && defined(USE_ARES)
|
|
struct {
|
|
ares_channel channel;
|
|
struct Curl_https_rrinfo hinfo;
|
|
CURLcode result;
|
|
BIT(done);
|
|
} rr;
|
|
#endif
|
|
};
|
|
|
|
#endif /* CURLRES_THREADED */
|
|
|
|
#ifndef CURL_DISABLE_DOH
|
|
struct doh_probes;
|
|
#endif
|
|
|
|
#else /* CURLRES_ASYNCH */
|
|
|
|
/* convert these functions if an asynch resolver is not used */
|
|
#define Curl_async_get_impl(x,y) (*(y) = NULL, CURLE_OK)
|
|
#define Curl_async_shutdown(x) Curl_nop_stmt
|
|
#define Curl_async_is_resolved(x,y) CURLE_COULDNT_RESOLVE_HOST
|
|
#define Curl_async_await(x,y) CURLE_COULDNT_RESOLVE_HOST
|
|
#define Curl_async_global_init() CURLE_OK
|
|
#define Curl_async_global_cleanup() Curl_nop_stmt
|
|
|
|
#endif /* !CURLRES_ASYNCH */
|
|
|
|
#if defined(CURLRES_ASYNCH) || !defined(CURL_DISABLE_DOH)
|
|
#define USE_CURL_ASYNC
|
|
|
|
struct Curl_async {
|
|
#ifdef CURLRES_ARES /* */
|
|
struct async_ares_ctx ares;
|
|
#elif defined(CURLRES_THREADED)
|
|
struct async_thrdd_ctx thrdd;
|
|
#endif
|
|
#ifndef CURL_DISABLE_DOH
|
|
struct doh_probes *doh; /* DoH specific data for this request */
|
|
#endif
|
|
struct Curl_dns_entry *dns; /* result of resolving on success */
|
|
char *hostname; /* copy of the params resolv started with */
|
|
int port;
|
|
int ip_version;
|
|
BIT(done);
|
|
};
|
|
|
|
#endif
|
|
|
|
/********** end of generic resolver interface functions *****************/
|
|
#endif /* HEADER_CURL_ASYN_H */
|