984 lines
28 KiB
C
984 lines
28 KiB
C
/***************************************************************************
|
|
* _ _ ____ _
|
|
* 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> /* <netinet/tcp.h> may need it */
|
|
#endif
|
|
#ifdef HAVE_SYS_UN_H
|
|
#include <sys/un.h> /* for sockaddr_un */
|
|
#endif
|
|
#ifdef HAVE_LINUX_TCP_H
|
|
#include <linux/tcp.h>
|
|
#elif defined(HAVE_NETINET_TCP_H)
|
|
#include <netinet/tcp.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_IOCTL_H
|
|
#include <sys/ioctl.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 "urldata.h"
|
|
#include "connect.h"
|
|
#include "cfilters.h"
|
|
#include "cf-ip-happy.h"
|
|
#include "curl_trc.h"
|
|
#include "multiif.h"
|
|
#include "progress.h"
|
|
#include "select.h"
|
|
#include "vquic/vquic.h" /* for quic cfilters */
|
|
|
|
/* The last 2 #include files should be in this order */
|
|
#include "curl_memory.h"
|
|
#include "memdebug.h"
|
|
|
|
|
|
struct transport_provider {
|
|
int transport;
|
|
cf_ip_connect_create *cf_create;
|
|
};
|
|
|
|
static
|
|
#ifndef UNITTESTS
|
|
const
|
|
#endif
|
|
struct transport_provider transport_providers[] = {
|
|
{ TRNSPRT_TCP, Curl_cf_tcp_create },
|
|
#if !defined(CURL_DISABLE_HTTP) && defined(USE_HTTP3)
|
|
{ TRNSPRT_QUIC, Curl_cf_quic_create },
|
|
#endif
|
|
#ifndef CURL_DISABLE_TFTP
|
|
{ TRNSPRT_UDP, Curl_cf_udp_create },
|
|
#endif
|
|
#ifdef USE_UNIX_SOCKETS
|
|
{ TRNSPRT_UNIX, Curl_cf_unix_create },
|
|
#endif
|
|
};
|
|
|
|
static cf_ip_connect_create *get_cf_create(int transport)
|
|
{
|
|
size_t i;
|
|
for(i = 0; i < CURL_ARRAYSIZE(transport_providers); ++i) {
|
|
if(transport == transport_providers[i].transport)
|
|
return transport_providers[i].cf_create;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef UNITTESTS
|
|
/* used by unit2600.c */
|
|
void Curl_debug_set_transport_provider(int transport,
|
|
cf_ip_connect_create *cf_create)
|
|
{
|
|
size_t i;
|
|
for(i = 0; i < CURL_ARRAYSIZE(transport_providers); ++i) {
|
|
if(transport == transport_providers[i].transport) {
|
|
transport_providers[i].cf_create = cf_create;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#endif /* UNITTESTS */
|
|
|
|
|
|
struct cf_ai_iter {
|
|
const struct Curl_addrinfo *head;
|
|
const struct Curl_addrinfo *last;
|
|
int ai_family;
|
|
int n;
|
|
};
|
|
|
|
static void cf_ai_iter_init(struct cf_ai_iter *iter,
|
|
const struct Curl_addrinfo *list,
|
|
int ai_family)
|
|
{
|
|
iter->head = list;
|
|
iter->ai_family = ai_family;
|
|
iter->last = NULL;
|
|
iter->n = -1;
|
|
}
|
|
|
|
static const struct Curl_addrinfo *cf_ai_iter_next(struct cf_ai_iter *iter)
|
|
{
|
|
const struct Curl_addrinfo *addr;
|
|
if(iter->n < 0) {
|
|
iter->n++;
|
|
for(addr = iter->head; addr; addr = addr->ai_next) {
|
|
if(addr->ai_family == iter->ai_family)
|
|
break;
|
|
}
|
|
iter->last = addr;
|
|
}
|
|
else if(iter->last) {
|
|
iter->n++;
|
|
for(addr = iter->last->ai_next; addr; addr = addr->ai_next) {
|
|
if(addr->ai_family == iter->ai_family)
|
|
break;
|
|
}
|
|
iter->last = addr;
|
|
}
|
|
return iter->last;
|
|
}
|
|
|
|
static bool cf_ai_iter_has_more(struct cf_ai_iter *iter)
|
|
{
|
|
const struct Curl_addrinfo *addr = iter->last ? iter->last->ai_next :
|
|
((iter->n < 0) ? iter->head : NULL);
|
|
while(addr) {
|
|
if(addr->ai_family == iter->ai_family)
|
|
return TRUE;
|
|
addr = addr->ai_next;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
struct cf_ip_attempt {
|
|
struct cf_ip_attempt *next;
|
|
const struct Curl_addrinfo *addr; /* List of addresses to try, not owned */
|
|
struct Curl_cfilter *cf; /* current sub-cfilter connecting */
|
|
cf_ip_connect_create *cf_create;
|
|
struct curltime started; /* start of current attempt */
|
|
CURLcode result;
|
|
int ai_family;
|
|
int transport;
|
|
int error;
|
|
BIT(connected); /* cf has connected */
|
|
BIT(shutdown); /* cf has shutdown */
|
|
BIT(inconclusive); /* connect was not a hard failure, we
|
|
* might talk to a restarting server */
|
|
};
|
|
|
|
static void cf_ip_attempt_free(struct cf_ip_attempt *a,
|
|
struct Curl_easy *data)
|
|
{
|
|
if(a) {
|
|
if(a->cf)
|
|
Curl_conn_cf_discard_chain(&a->cf, data);
|
|
free(a);
|
|
}
|
|
}
|
|
|
|
static CURLcode cf_ip_attempt_new(struct cf_ip_attempt **pa,
|
|
struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
const struct Curl_addrinfo *addr,
|
|
int ai_family,
|
|
int transport,
|
|
cf_ip_connect_create *cf_create)
|
|
{
|
|
struct Curl_cfilter *wcf;
|
|
struct cf_ip_attempt *a;
|
|
CURLcode result = CURLE_OK;
|
|
|
|
*pa = NULL;
|
|
a = calloc(1, sizeof(*a));
|
|
if(!a)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
a->addr = addr;
|
|
a->ai_family = ai_family;
|
|
a->transport = transport;
|
|
a->result = CURLE_OK;
|
|
a->cf_create = cf_create;
|
|
*pa = a;
|
|
|
|
result = a->cf_create(&a->cf, data, cf->conn, a->addr, transport);
|
|
if(result)
|
|
goto out;
|
|
|
|
/* the new filter might have sub-filters */
|
|
for(wcf = a->cf; wcf; wcf = wcf->next) {
|
|
wcf->conn = cf->conn;
|
|
wcf->sockindex = cf->sockindex;
|
|
}
|
|
|
|
out:
|
|
if(result) {
|
|
cf_ip_attempt_free(a, data);
|
|
*pa = NULL;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static CURLcode cf_ip_attempt_connect(struct cf_ip_attempt *a,
|
|
struct Curl_easy *data,
|
|
bool *connected)
|
|
{
|
|
*connected = a->connected;
|
|
if(!a->result && !*connected) {
|
|
/* evaluate again */
|
|
a->result = Curl_conn_cf_connect(a->cf, data, connected);
|
|
|
|
if(!a->result) {
|
|
if(*connected) {
|
|
a->connected = TRUE;
|
|
}
|
|
}
|
|
else if(a->result == CURLE_WEIRD_SERVER_REPLY)
|
|
a->inconclusive = TRUE;
|
|
}
|
|
return a->result;
|
|
}
|
|
|
|
struct cf_ip_ballers {
|
|
struct cf_ip_attempt *running;
|
|
struct cf_ip_attempt *winner;
|
|
struct cf_ai_iter addr_iter;
|
|
#ifdef USE_IPV6
|
|
struct cf_ai_iter ipv6_iter;
|
|
#endif
|
|
cf_ip_connect_create *cf_create; /* for creating cf */
|
|
struct curltime started;
|
|
struct curltime last_attempt_started;
|
|
timediff_t attempt_delay_ms;
|
|
int last_attempt_ai_family;
|
|
int transport;
|
|
};
|
|
|
|
static CURLcode cf_ip_attempt_restart(struct cf_ip_attempt *a,
|
|
struct Curl_cfilter *cf,
|
|
struct Curl_easy *data)
|
|
{
|
|
struct Curl_cfilter *cf_prev = a->cf;
|
|
struct Curl_cfilter *wcf;
|
|
CURLcode result;
|
|
|
|
/* When restarting, we tear down and existing filter *after* we
|
|
* started up the new one. This gives us a new socket number and
|
|
* probably a new local port. Which may prevent confusion. */
|
|
a->result = CURLE_OK;
|
|
a->connected = FALSE;
|
|
a->inconclusive = FALSE;
|
|
a->cf = NULL;
|
|
|
|
result = a->cf_create(&a->cf, data, cf->conn, a->addr, a->transport);
|
|
if(!result) {
|
|
bool dummy;
|
|
/* the new filter might have sub-filters */
|
|
for(wcf = a->cf; wcf; wcf = wcf->next) {
|
|
wcf->conn = cf->conn;
|
|
wcf->sockindex = cf->sockindex;
|
|
}
|
|
a->result = cf_ip_attempt_connect(a, data, &dummy);
|
|
}
|
|
if(cf_prev)
|
|
Curl_conn_cf_discard_chain(&cf_prev, data);
|
|
return result;
|
|
}
|
|
|
|
static void cf_ip_ballers_clear(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
struct cf_ip_ballers *bs)
|
|
{
|
|
(void)cf;
|
|
while(bs->running) {
|
|
struct cf_ip_attempt *a = bs->running;
|
|
bs->running = a->next;
|
|
cf_ip_attempt_free(a, data);
|
|
}
|
|
cf_ip_attempt_free(bs->winner, data);
|
|
bs->winner = NULL;
|
|
}
|
|
|
|
static CURLcode cf_ip_ballers_init(struct cf_ip_ballers *bs, int ip_version,
|
|
const struct Curl_addrinfo *addr_list,
|
|
cf_ip_connect_create *cf_create,
|
|
int transport,
|
|
timediff_t attempt_delay_ms)
|
|
{
|
|
memset(bs, 0, sizeof(*bs));
|
|
bs->cf_create = cf_create;
|
|
bs->transport = transport;
|
|
bs->attempt_delay_ms = attempt_delay_ms;
|
|
bs->last_attempt_ai_family = AF_INET; /* so AF_INET6 is next */
|
|
|
|
if(transport == TRNSPRT_UNIX) {
|
|
#ifdef USE_UNIX_SOCKETS
|
|
cf_ai_iter_init(&bs->addr_iter, addr_list, AF_UNIX);
|
|
#else
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
#endif
|
|
}
|
|
else { /* TCP/UDP/QUIC */
|
|
#ifdef USE_IPV6
|
|
if(ip_version == CURL_IPRESOLVE_V6)
|
|
cf_ai_iter_init(&bs->addr_iter, NULL, AF_INET);
|
|
else
|
|
cf_ai_iter_init(&bs->addr_iter, addr_list, AF_INET);
|
|
|
|
if(ip_version == CURL_IPRESOLVE_V4)
|
|
cf_ai_iter_init(&bs->ipv6_iter, NULL, AF_INET6);
|
|
else
|
|
cf_ai_iter_init(&bs->ipv6_iter, addr_list, AF_INET6);
|
|
#else
|
|
(void)ip_version;
|
|
cf_ai_iter_init(&bs->addr_iter, addr_list, AF_INET);
|
|
#endif
|
|
}
|
|
return CURLE_OK;
|
|
}
|
|
|
|
static CURLcode cf_ip_ballers_run(struct cf_ip_ballers *bs,
|
|
struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
bool *connected)
|
|
{
|
|
CURLcode result = CURLE_OK;
|
|
struct cf_ip_attempt *a = NULL, **panchor;
|
|
bool do_more;
|
|
struct curltime now;
|
|
timediff_t next_expire_ms;
|
|
int i, inconclusive, ongoing;
|
|
|
|
if(bs->winner)
|
|
return CURLE_OK;
|
|
|
|
evaluate:
|
|
now = curlx_now();
|
|
ongoing = inconclusive = 0;
|
|
|
|
/* check if a running baller connects now */
|
|
i = -1;
|
|
for(panchor = &bs->running; *panchor; panchor = &((*panchor)->next)) {
|
|
++i;
|
|
a = *panchor;
|
|
a->result = cf_ip_attempt_connect(a, data, connected);
|
|
if(!a->result) {
|
|
if(*connected) {
|
|
/* connected, declare the winner, remove from running,
|
|
* clear remaining running list. */
|
|
CURL_TRC_CF(data, cf, "connect attempt #%d successful", i);
|
|
bs->winner = a;
|
|
*panchor = a->next;
|
|
a->next = NULL;
|
|
while(bs->running) {
|
|
a = bs->running;
|
|
bs->running = a->next;
|
|
cf_ip_attempt_free(a, data);
|
|
}
|
|
return CURLE_OK;
|
|
}
|
|
/* still running */
|
|
++ongoing;
|
|
}
|
|
else if(a->inconclusive) /* failed, but inconclusive */
|
|
++inconclusive;
|
|
}
|
|
if(bs->running)
|
|
CURL_TRC_CF(data, cf, "checked connect attempts: "
|
|
"%d ongoing, %d inconclusive", ongoing, inconclusive);
|
|
|
|
/* no attempt connected yet, start another one? */
|
|
if(!ongoing) {
|
|
if(!bs->started.tv_sec && !bs->started.tv_usec)
|
|
bs->started = now;
|
|
do_more = TRUE;
|
|
}
|
|
else {
|
|
bool more_possible = cf_ai_iter_has_more(&bs->addr_iter);
|
|
#ifdef USE_IPV6
|
|
if(!more_possible)
|
|
more_possible = cf_ai_iter_has_more(&bs->ipv6_iter);
|
|
#endif
|
|
do_more = more_possible &&
|
|
(curlx_timediff(now, bs->last_attempt_started) >=
|
|
bs->attempt_delay_ms);
|
|
if(do_more)
|
|
CURL_TRC_CF(data, cf, "happy eyeballs timeout expired, "
|
|
"start next attempt");
|
|
}
|
|
|
|
if(do_more) {
|
|
/* start the next attempt if there is another ip address to try.
|
|
* Alternate between address families when possible. */
|
|
const struct Curl_addrinfo *addr = NULL;
|
|
int ai_family = 0;
|
|
#ifdef USE_IPV6
|
|
if((bs->last_attempt_ai_family == AF_INET) ||
|
|
!cf_ai_iter_has_more(&bs->addr_iter)) {
|
|
addr = cf_ai_iter_next(&bs->ipv6_iter);
|
|
ai_family = bs->ipv6_iter.ai_family;
|
|
}
|
|
#endif
|
|
if(!addr) {
|
|
addr = cf_ai_iter_next(&bs->addr_iter);
|
|
ai_family = bs->addr_iter.ai_family;
|
|
}
|
|
|
|
if(addr) { /* try another address */
|
|
result = cf_ip_attempt_new(&a, cf, data, addr, ai_family,
|
|
bs->transport, bs->cf_create);
|
|
CURL_TRC_CF(data, cf, "starting %s attempt for ipv%s -> %d",
|
|
bs->running ? "next" : "first",
|
|
(ai_family == AF_INET) ? "4" : "6", result);
|
|
if(result)
|
|
goto out;
|
|
DEBUGASSERT(a);
|
|
|
|
/* append to running list */
|
|
panchor = &bs->running;
|
|
while(*panchor)
|
|
panchor = &((*panchor)->next);
|
|
*panchor = a;
|
|
bs->last_attempt_started = now;
|
|
bs->last_attempt_ai_family = ai_family;
|
|
/* and run everything again */
|
|
goto evaluate;
|
|
}
|
|
else if(inconclusive) {
|
|
/* tried all addresses, no success but some where inconclusive.
|
|
* Let's restart the inconclusive ones. */
|
|
timediff_t since_ms = curlx_timediff(now, bs->last_attempt_started);
|
|
timediff_t delay_ms = bs->attempt_delay_ms - since_ms;
|
|
if(delay_ms <= 0) {
|
|
CURL_TRC_CF(data, cf, "all attempts inconclusive, restarting one");
|
|
i = -1;
|
|
for(a = bs->running; a; a = a->next) {
|
|
++i;
|
|
if(!a->inconclusive)
|
|
continue;
|
|
result = cf_ip_attempt_restart(a, cf, data);
|
|
CURL_TRC_CF(data, cf, "restarted baller %d -> %d", i, result);
|
|
if(result) /* serious failure */
|
|
goto out;
|
|
bs->last_attempt_started = now;
|
|
goto evaluate;
|
|
}
|
|
DEBUGASSERT(0); /* should not come here */
|
|
}
|
|
else {
|
|
/* let's wait some more before restarting */
|
|
infof(data, "connect attempts inconclusive, retrying "
|
|
"in %" FMT_TIMEDIFF_T "ms", delay_ms);
|
|
Curl_expire(data, delay_ms, EXPIRE_HAPPY_EYEBALLS);
|
|
}
|
|
/* attempt timeout for restart has not expired yet */
|
|
goto out;
|
|
}
|
|
else if(!ongoing) {
|
|
/* no more addresses, no inconclusive attempts */
|
|
CURL_TRC_CF(data, cf, "no more attempts to try");
|
|
result = CURLE_COULDNT_CONNECT;
|
|
i = 0;
|
|
for(a = bs->running; a; a = a->next) {
|
|
CURL_TRC_CF(data, cf, "baller %d: result=%d", i, a->result);
|
|
if(a->result)
|
|
result = a->result;
|
|
}
|
|
}
|
|
}
|
|
|
|
out:
|
|
if(!result) {
|
|
bool more_possible;
|
|
|
|
/* when do we need to be called again? */
|
|
next_expire_ms = Curl_timeleft(data, &now, TRUE);
|
|
if(next_expire_ms <= 0) {
|
|
failf(data, "Connection timeout after %" FMT_OFF_T " ms",
|
|
curlx_timediff(now, data->progress.t_startsingle));
|
|
return CURLE_OPERATION_TIMEDOUT;
|
|
}
|
|
|
|
more_possible = cf_ai_iter_has_more(&bs->addr_iter);
|
|
#ifdef USE_IPV6
|
|
if(!more_possible)
|
|
more_possible = cf_ai_iter_has_more(&bs->ipv6_iter);
|
|
#endif
|
|
if(more_possible) {
|
|
timediff_t expire_ms, elapsed_ms;
|
|
elapsed_ms = curlx_timediff(now, bs->last_attempt_started);
|
|
expire_ms = CURLMAX(bs->attempt_delay_ms - elapsed_ms, 0);
|
|
next_expire_ms = CURLMIN(next_expire_ms, expire_ms);
|
|
if(next_expire_ms <= 0) {
|
|
CURL_TRC_CF(data, cf, "HAPPY_EYBALLS timeout due, re-evaluate");
|
|
goto evaluate;
|
|
}
|
|
CURL_TRC_CF(data, cf, "next HAPPY_EYBALLS timeout in %" FMT_TIMEDIFF_T
|
|
"ms", next_expire_ms);
|
|
Curl_expire(data, next_expire_ms, EXPIRE_HAPPY_EYEBALLS);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static CURLcode cf_ip_ballers_shutdown(struct cf_ip_ballers *bs,
|
|
struct Curl_easy *data,
|
|
bool *done)
|
|
{
|
|
struct cf_ip_attempt *a;
|
|
|
|
/* shutdown all ballers that have not done so already. If one fails,
|
|
* continue shutting down others until all are shutdown. */
|
|
*done = TRUE;
|
|
for(a = bs->running; a; a = a->next) {
|
|
bool bdone = FALSE;
|
|
if(a->shutdown)
|
|
continue;
|
|
a->result = a->cf->cft->do_shutdown(a->cf, data, &bdone);
|
|
if(a->result || bdone)
|
|
a->shutdown = TRUE; /* treat a failed shutdown as done */
|
|
else
|
|
*done = FALSE;
|
|
}
|
|
return CURLE_OK;
|
|
}
|
|
|
|
static CURLcode cf_ip_ballers_pollset(struct cf_ip_ballers *bs,
|
|
struct Curl_easy *data,
|
|
struct easy_pollset *ps)
|
|
{
|
|
struct cf_ip_attempt *a;
|
|
CURLcode result = CURLE_OK;
|
|
for(a = bs->running; a && !result; a = a->next) {
|
|
if(a->result)
|
|
continue;
|
|
result = Curl_conn_cf_adjust_pollset(a->cf, data, ps);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static bool cf_ip_ballers_pending(struct cf_ip_ballers *bs,
|
|
const struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_attempt *a;
|
|
|
|
for(a = bs->running; a; a = a->next) {
|
|
if(a->result)
|
|
continue;
|
|
if(a->cf->cft->has_data_pending(a->cf, data))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static struct curltime cf_ip_ballers_max_time(struct cf_ip_ballers *bs,
|
|
struct Curl_easy *data,
|
|
int query)
|
|
{
|
|
struct curltime t, tmax;
|
|
struct cf_ip_attempt *a;
|
|
|
|
memset(&tmax, 0, sizeof(tmax));
|
|
for(a = bs->running; a; a = a->next) {
|
|
memset(&t, 0, sizeof(t));
|
|
if(!a->cf->cft->query(a->cf, data, query, NULL, &t)) {
|
|
if((t.tv_sec || t.tv_usec) && curlx_timediff_us(t, tmax) > 0)
|
|
tmax = t;
|
|
}
|
|
}
|
|
return tmax;
|
|
}
|
|
|
|
static int cf_ip_ballers_min_reply_ms(struct cf_ip_ballers *bs,
|
|
struct Curl_easy *data)
|
|
{
|
|
int reply_ms = -1, breply_ms;
|
|
struct cf_ip_attempt *a;
|
|
|
|
for(a = bs->running; a; a = a->next) {
|
|
if(!a->cf->cft->query(a->cf, data, CF_QUERY_CONNECT_REPLY_MS,
|
|
&breply_ms, NULL)) {
|
|
if(breply_ms >= 0 && (reply_ms < 0 || breply_ms < reply_ms))
|
|
reply_ms = breply_ms;
|
|
}
|
|
}
|
|
return reply_ms;
|
|
}
|
|
|
|
|
|
typedef enum {
|
|
SCFST_INIT,
|
|
SCFST_WAITING,
|
|
SCFST_DONE
|
|
} cf_connect_state;
|
|
|
|
struct cf_ip_happy_ctx {
|
|
int transport;
|
|
cf_ip_connect_create *cf_create;
|
|
cf_connect_state state;
|
|
struct cf_ip_ballers ballers;
|
|
struct curltime started;
|
|
};
|
|
|
|
|
|
static CURLcode is_connected(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
bool *connected)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
struct connectdata *conn = cf->conn;
|
|
CURLcode result;
|
|
|
|
result = cf_ip_ballers_run(&ctx->ballers, cf, data, connected);
|
|
|
|
if(!result)
|
|
return CURLE_OK;
|
|
|
|
{
|
|
const char *hostname, *proxy_name = NULL;
|
|
char viamsg[160];
|
|
#ifndef CURL_DISABLE_PROXY
|
|
if(conn->bits.socksproxy)
|
|
proxy_name = conn->socks_proxy.host.name;
|
|
else if(conn->bits.httpproxy)
|
|
proxy_name = conn->http_proxy.host.name;
|
|
#endif
|
|
hostname = conn->bits.conn_to_host ? conn->conn_to_host.name :
|
|
conn->host.name;
|
|
|
|
#ifdef USE_UNIX_SOCKETS
|
|
if(conn->unix_domain_socket)
|
|
curl_msnprintf(viamsg, sizeof(viamsg), "over %s",
|
|
conn->unix_domain_socket);
|
|
else
|
|
#endif
|
|
{
|
|
int port;
|
|
if(cf->sockindex == SECONDARYSOCKET)
|
|
port = conn->secondary_port;
|
|
else if(cf->conn->bits.conn_to_port)
|
|
port = conn->conn_to_port;
|
|
else
|
|
port = conn->remote_port;
|
|
curl_msnprintf(viamsg, sizeof(viamsg), "port %u", port);
|
|
}
|
|
|
|
failf(data, "Failed to connect to %s %s %s%s%safter "
|
|
"%" FMT_TIMEDIFF_T " ms: %s",
|
|
hostname, viamsg,
|
|
proxy_name ? "via " : "",
|
|
proxy_name ? proxy_name : "",
|
|
proxy_name ? " " : "",
|
|
curlx_timediff(curlx_now(), data->progress.t_startsingle),
|
|
curl_easy_strerror(result));
|
|
}
|
|
|
|
#ifdef SOCKETIMEDOUT
|
|
if(SOCKETIMEDOUT == data->state.os_errno)
|
|
result = CURLE_OPERATION_TIMEDOUT;
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Connect to the given host with timeout, proxy or remote does not matter.
|
|
* There might be more than one IP address to try out.
|
|
*/
|
|
static CURLcode start_connect(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
struct Curl_dns_entry *dns = data->state.dns[cf->sockindex];
|
|
|
|
if(!dns)
|
|
return CURLE_FAILED_INIT;
|
|
|
|
if(Curl_timeleft(data, NULL, TRUE) < 0) {
|
|
/* a precaution, no need to continue if time already is up */
|
|
failf(data, "Connection time-out");
|
|
return CURLE_OPERATION_TIMEDOUT;
|
|
}
|
|
|
|
CURL_TRC_CF(data, cf, "init ip ballers for transport %d", ctx->transport);
|
|
ctx->started = curlx_now();
|
|
return cf_ip_ballers_init(&ctx->ballers, cf->conn->ip_version,
|
|
dns->addr, ctx->cf_create, ctx->transport,
|
|
data->set.happy_eyeballs_timeout);
|
|
}
|
|
|
|
static void cf_ip_happy_ctx_clear(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
|
|
DEBUGASSERT(ctx);
|
|
DEBUGASSERT(data);
|
|
cf_ip_ballers_clear(cf, data, &ctx->ballers);
|
|
}
|
|
|
|
static CURLcode cf_ip_happy_shutdown(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
bool *done)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
CURLcode result = CURLE_OK;
|
|
|
|
DEBUGASSERT(data);
|
|
if(cf->connected) {
|
|
*done = TRUE;
|
|
return CURLE_OK;
|
|
}
|
|
|
|
result = cf_ip_ballers_shutdown(&ctx->ballers, data, done);
|
|
CURL_TRC_CF(data, cf, "shutdown -> %d, done=%d", result, *done);
|
|
return result;
|
|
}
|
|
|
|
static CURLcode cf_ip_happy_adjust_pollset(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
struct easy_pollset *ps)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
CURLcode result = CURLE_OK;
|
|
|
|
if(!cf->connected) {
|
|
result = cf_ip_ballers_pollset(&ctx->ballers, data, ps);
|
|
CURL_TRC_CF(data, cf, "adjust_pollset -> %d, %d socks", result, ps->n);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static CURLcode cf_ip_happy_connect(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
bool *done)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
CURLcode result = CURLE_OK;
|
|
|
|
if(cf->connected) {
|
|
*done = TRUE;
|
|
return CURLE_OK;
|
|
}
|
|
|
|
DEBUGASSERT(ctx);
|
|
*done = FALSE;
|
|
|
|
switch(ctx->state) {
|
|
case SCFST_INIT:
|
|
DEBUGASSERT(CURL_SOCKET_BAD == Curl_conn_cf_get_socket(cf, data));
|
|
DEBUGASSERT(!cf->connected);
|
|
result = start_connect(cf, data);
|
|
if(result)
|
|
return result;
|
|
ctx->state = SCFST_WAITING;
|
|
FALLTHROUGH();
|
|
case SCFST_WAITING:
|
|
result = is_connected(cf, data, done);
|
|
if(!result && *done) {
|
|
DEBUGASSERT(ctx->ballers.winner);
|
|
DEBUGASSERT(ctx->ballers.winner->cf);
|
|
DEBUGASSERT(ctx->ballers.winner->cf->connected);
|
|
/* we have a winner. Install and activate it.
|
|
* close/free all others. */
|
|
ctx->state = SCFST_DONE;
|
|
cf->connected = TRUE;
|
|
cf->next = ctx->ballers.winner->cf;
|
|
ctx->ballers.winner->cf = NULL;
|
|
cf_ip_happy_ctx_clear(cf, data);
|
|
Curl_expire_done(data, EXPIRE_HAPPY_EYEBALLS);
|
|
|
|
if(cf->conn->handler->protocol & PROTO_FAMILY_SSH)
|
|
Curl_pgrsTime(data, TIMER_APPCONNECT); /* we are connected already */
|
|
#ifndef CURL_DISABLE_VERBOSE_STRINGS
|
|
if(Curl_trc_cf_is_verbose(cf, data)) {
|
|
struct ip_quadruple ipquad;
|
|
bool is_ipv6;
|
|
if(!Curl_conn_cf_get_ip_info(cf->next, data, &is_ipv6, &ipquad)) {
|
|
const char *host;
|
|
int port;
|
|
Curl_conn_get_current_host(data, cf->sockindex, &host, &port);
|
|
CURL_TRC_CF(data, cf, "Connected to %s (%s) port %u",
|
|
host, ipquad.remote_ip, ipquad.remote_port);
|
|
}
|
|
}
|
|
#endif
|
|
data->info.numconnects++; /* to track the # of connections made */
|
|
}
|
|
break;
|
|
case SCFST_DONE:
|
|
*done = TRUE;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void cf_ip_happy_close(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
|
|
CURL_TRC_CF(data, cf, "close");
|
|
cf_ip_happy_ctx_clear(cf, data);
|
|
cf->connected = FALSE;
|
|
ctx->state = SCFST_INIT;
|
|
|
|
if(cf->next) {
|
|
cf->next->cft->do_close(cf->next, data);
|
|
Curl_conn_cf_discard_chain(&cf->next, data);
|
|
}
|
|
}
|
|
|
|
static bool cf_ip_happy_data_pending(struct Curl_cfilter *cf,
|
|
const struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
|
|
if(!cf->connected) {
|
|
return cf_ip_ballers_pending(&ctx->ballers, data);
|
|
}
|
|
return cf->next->cft->has_data_pending(cf->next, data);
|
|
}
|
|
|
|
static CURLcode cf_ip_happy_query(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data,
|
|
int query, int *pres1, void *pres2)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
|
|
if(!cf->connected) {
|
|
switch(query) {
|
|
case CF_QUERY_CONNECT_REPLY_MS: {
|
|
*pres1 = cf_ip_ballers_min_reply_ms(&ctx->ballers, data);
|
|
CURL_TRC_CF(data, cf, "query connect reply: %dms", *pres1);
|
|
return CURLE_OK;
|
|
}
|
|
case CF_QUERY_TIMER_CONNECT: {
|
|
struct curltime *when = pres2;
|
|
*when = cf_ip_ballers_max_time(&ctx->ballers, data,
|
|
CF_QUERY_TIMER_CONNECT);
|
|
return CURLE_OK;
|
|
}
|
|
case CF_QUERY_TIMER_APPCONNECT: {
|
|
struct curltime *when = pres2;
|
|
*when = cf_ip_ballers_max_time(&ctx->ballers, data,
|
|
CF_QUERY_TIMER_APPCONNECT);
|
|
return CURLE_OK;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return cf->next ?
|
|
cf->next->cft->query(cf->next, data, query, pres1, pres2) :
|
|
CURLE_UNKNOWN_OPTION;
|
|
}
|
|
|
|
static void cf_ip_happy_destroy(struct Curl_cfilter *cf,
|
|
struct Curl_easy *data)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = cf->ctx;
|
|
|
|
CURL_TRC_CF(data, cf, "destroy");
|
|
if(ctx) {
|
|
cf_ip_happy_ctx_clear(cf, data);
|
|
}
|
|
/* release any resources held in state */
|
|
Curl_safefree(ctx);
|
|
}
|
|
|
|
struct Curl_cftype Curl_cft_ip_happy = {
|
|
"HAPPY-EYEBALLS",
|
|
0,
|
|
CURL_LOG_LVL_NONE,
|
|
cf_ip_happy_destroy,
|
|
cf_ip_happy_connect,
|
|
cf_ip_happy_close,
|
|
cf_ip_happy_shutdown,
|
|
cf_ip_happy_adjust_pollset,
|
|
cf_ip_happy_data_pending,
|
|
Curl_cf_def_send,
|
|
Curl_cf_def_recv,
|
|
Curl_cf_def_cntrl,
|
|
Curl_cf_def_conn_is_alive,
|
|
Curl_cf_def_conn_keep_alive,
|
|
cf_ip_happy_query,
|
|
};
|
|
|
|
/**
|
|
* Create an IP happy eyeball connection filter that uses the, once resolved,
|
|
* address information to connect on ip families based on connection
|
|
* configuration.
|
|
* @param pcf output, the created cfilter
|
|
* @param data easy handle used in creation
|
|
* @param conn connection the filter is created for
|
|
* @param cf_create method to create the sub-filters performing the
|
|
* actual connects.
|
|
*/
|
|
static CURLcode cf_ip_happy_create(struct Curl_cfilter **pcf,
|
|
struct Curl_easy *data,
|
|
struct connectdata *conn,
|
|
cf_ip_connect_create *cf_create,
|
|
int transport)
|
|
{
|
|
struct cf_ip_happy_ctx *ctx = NULL;
|
|
CURLcode result;
|
|
|
|
(void)data;
|
|
(void)conn;
|
|
*pcf = NULL;
|
|
ctx = calloc(1, sizeof(*ctx));
|
|
if(!ctx) {
|
|
result = CURLE_OUT_OF_MEMORY;
|
|
goto out;
|
|
}
|
|
ctx->transport = transport;
|
|
ctx->cf_create = cf_create;
|
|
|
|
result = Curl_cf_create(pcf, &Curl_cft_ip_happy, ctx);
|
|
|
|
out:
|
|
if(result) {
|
|
Curl_safefree(*pcf);
|
|
free(ctx);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
CURLcode cf_ip_happy_insert_after(struct Curl_cfilter *cf_at,
|
|
struct Curl_easy *data,
|
|
int transport)
|
|
{
|
|
cf_ip_connect_create *cf_create;
|
|
struct Curl_cfilter *cf;
|
|
CURLcode result;
|
|
|
|
/* Need to be first */
|
|
DEBUGASSERT(cf_at);
|
|
cf_create = get_cf_create(transport);
|
|
if(!cf_create) {
|
|
CURL_TRC_CF(data, cf_at, "unsupported transport type %d", transport);
|
|
return CURLE_UNSUPPORTED_PROTOCOL;
|
|
}
|
|
result = cf_ip_happy_create(&cf, data, cf_at->conn, cf_create, transport);
|
|
if(result)
|
|
return result;
|
|
|
|
Curl_conn_cf_insert_after(cf_at, cf);
|
|
return CURLE_OK;
|
|
}
|