Update networking layer w/ CURL and emscripten impl

2025-11-08 01:50:36 +11:00
parent a17925904d
commit f6874dc55a
4105 changed files with 694617 additions and 179 deletions
@@ -0,0 +1,983 @@
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  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;
+}