/***************************************************************************

 *                                  _   _ ____  _

 *  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_NETDB_H

#include <netdb.h>

#endif

#ifdef HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#ifdef HAVE_NET_IF_H

#include <net/if.h>

#endif

#ifdef HAVE_IPHLPAPI_H

#include <Iphlpapi.h>

#endif

#ifdef HAVE_SYS_IOCTL_H

#include <sys/ioctl.h>

#endif

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#ifdef __VMS

#include <in.h>

#include <inet.h>

#endif

#ifdef HAVE_SYS_UN_H

#include <sys/un.h>

#endif

#ifndef HAVE_SOCKET

#error "We cannot compile without socket() support!"

#endif

#if defined(HAVE_IF_NAMETOINDEX) && defined(USE_WINSOCK)

#if defined(__MINGW32__) && (__MINGW64_VERSION_MAJOR <= 5)

#include <wincrypt.h>  /* workaround for old mingw-w64 missing to include it */

#endif

#include <iphlpapi.h>

#endif

#include "urldata.h"

#include "mime.h"

#include "bufref.h"

#include "vtls/vtls.h"

#include "vssh/vssh.h"

#include "hostip.h"

#include "transfer.h"

#include "curl_addrinfo.h"

#include "curl_trc.h"

#include "progress.h"

#include "cookie.h"

#include "strcase.h"

#include "escape.h"

#include "curl_share.h"

#include "http_digest.h"

#include "multiif.h"

#include "getinfo.h"

#include "pop3.h"

#include "urlapi-int.h"

#include "system_win32.h"

#include "hsts.h"

#include "noproxy.h"

#include "cfilters.h"

#include "idn.h"

#include "http_proxy.h"

#include "conncache.h"

#include "multihandle.h"

#include "curlx/strdup.h"

#include "setopt.h"

#include "altsvc.h"

#include "curlx/dynbuf.h"

#include "headers.h"

#include "curlx/strerr.h"

#include "curlx/strparse.h"

/* And now for the protocols */

#include "ftp.h"

#include "dict.h"

#include "telnet.h"

#include "tftp.h"

#include "http.h"

#include "file.h"

#include "curl_ldap.h"

#include "vssh/ssh.h"

#include "imap.h"

#include "url.h"

#include "connect.h"

#include "curl_rtmp.h"

#include "gopher.h"

#include "mqtt.h"

#include "rtsp.h"

#include "smtp.h"

#include "ws.h"

#ifdef USE_NGHTTP2

static void data_priority_cleanup(struct Curl_easy *data);

#else

#define data_priority_cleanup(x)

#endif

/* Some parts of the code (e.g. chunked encoding) assume this buffer has more

 * than a few bytes to play with. Do not let it become too small or bad things

 * will happen.

 */

#if READBUFFER_SIZE < READBUFFER_MIN

# error READBUFFER_SIZE is too small

#endif

#if !defined(CURL_DISABLE_PROXY) && defined(USE_UNIX_SOCKETS)

#define UNIX_SOCKET_PREFIX "localhost"

#endif

/* Reject URLs exceeding this length */

#define MAX_URL_LEN 0xffff

/*

 * get_protocol_family()

 *

 * This is used to return the protocol family for a given protocol.

 *

 * Parameters:

 *

 * 's'  [in]  - struct Curl_scheme pointer.

 *

 * Returns the family as a single bit protocol identifier.

 */

static curl_prot_t get_protocol_family(const struct Curl_scheme *s)

{

  DEBUGASSERT(s);

  DEBUGASSERT(s->family);

  return s->family;

}

void Curl_freeset(struct Curl_easy *data)

{

  /* Free all dynamic strings stored in the data->set substructure. */

  enum dupstring i;

  enum dupblob j;

  for(i = (enum dupstring)0; i < STRING_LAST; i++) {

    Curl_safefree(data->set.str[i]);

  }

  for(j = (enum dupblob)0; j < BLOB_LAST; j++) {

    Curl_safefree(data->set.blobs[j]);

  }

  Curl_bufref_free(&data->state.referer);

  Curl_bufref_free(&data->state.url);

#if !defined(CURL_DISABLE_MIME) || !defined(CURL_DISABLE_FORM_API)

  Curl_mime_cleanpart(data->set.mimepostp);

  Curl_safefree(data->set.mimepostp);

#endif

#ifndef CURL_DISABLE_COOKIES

  curl_slist_free_all(data->state.cookielist);

  data->state.cookielist = NULL;

#endif

}

/* free the URL pieces */

static void up_free(struct Curl_easy *data)

{

  struct urlpieces *up = &data->state.up;

  Curl_safefree(up->scheme);

  Curl_safefree(up->hostname);

  Curl_safefree(up->port);

  Curl_safefree(up->user);

  Curl_safefree(up->password);

  Curl_safefree(up->options);

  Curl_safefree(up->path);

  Curl_safefree(up->query);

  curl_url_cleanup(data->state.uh);

  data->state.uh = NULL;

}

/*

 * This is the internal function curl_easy_cleanup() calls. This should

 * cleanup and free all resources associated with this sessionhandle.

 *

 * We ignore SIGPIPE when this is called from curl_easy_cleanup.

 */

CURLcode Curl_close(struct Curl_easy **datap)

{

  struct Curl_easy *data;

  if(!datap || !*datap)

    return CURLE_OK;

  data = *datap;

  *datap = NULL;

  if(!data->state.internal && data->multi) {

    /* This handle is still part of a multi handle, take care of this first

       and detach this handle from there.

       This detaches the connection. */

    curl_multi_remove_handle(data->multi, data);

  }

  else {

    /* Detach connection if any is left. This should not be normal, but can be

       the case for example with CONNECT_ONLY + recv/send (test 556) */

    Curl_detach_connection(data);

    if(!data->state.internal && data->multi_easy) {

      /* when curl_easy_perform() is used, it creates its own multi handle to

         use and this is the one */

      curl_multi_cleanup(data->multi_easy);

      data->multi_easy = NULL;

    }

  }

  DEBUGASSERT(!data->conn || data->state.internal);

  Curl_expire_clear(data); /* shut off any timers left */

  if(data->state.rangestringalloc)

    curlx_free(data->state.range);

  /* release any resolve information this transfer kept */

  Curl_async_destroy(data);

  Curl_resolv_unlink(data, &data->state.dns[0]); /* done with this */

  Curl_resolv_unlink(data, &data->state.dns[1]);

  data->set.verbose = FALSE; /* no more calls to DEBUGFUNCTION */

  data->magic = 0; /* force a clear AFTER the possibly enforced removal from

                    * the multi handle and async dns shutdown. The multi

                    * handle might check the magic and so might any

                    * DEBUGFUNCTION invoked for tracing */

  /* freed here in case DONE was not called */

  Curl_req_free(&data->req, data);

  /* Close down all open SSL info and sessions */

  Curl_ssl_close_all(data);

  Curl_safefree(data->state.first_host);

  Curl_ssl_free_certinfo(data);

  Curl_bufref_free(&data->state.referer);

  up_free(data);

  curlx_dyn_free(&data->state.headerb);

  Curl_flush_cookies(data, TRUE);

#ifndef CURL_DISABLE_ALTSVC

  Curl_altsvc_save(data, data->asi, data->set.str[STRING_ALTSVC]);

  Curl_altsvc_cleanup(&data->asi);

#endif

#ifndef CURL_DISABLE_HSTS

  Curl_hsts_save(data, data->hsts, data->set.str[STRING_HSTS]);

  if(!data->share || !data->share->hsts)

    Curl_hsts_cleanup(&data->hsts);

  curl_slist_free_all(data->state.hstslist); /* clean up list */

#endif

#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_DIGEST_AUTH)

  Curl_http_auth_cleanup_digest(data);

#endif

  Curl_safefree(data->state.most_recent_ftp_entrypath);

  Curl_safefree(data->info.contenttype);

  Curl_safefree(data->info.wouldredirect);

  data_priority_cleanup(data);

  /* No longer a dirty share, if it exists */

  if(data->share) {

    Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);

    data->share->dirty--;

    Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);

  }

  Curl_hash_destroy(&data->meta_hash);

#ifndef CURL_DISABLE_PROXY

  Curl_safefree(data->state.aptr.proxyuserpwd);

#endif

  Curl_safefree(data->state.aptr.uagent);

  Curl_safefree(data->state.aptr.userpwd);

  Curl_safefree(data->state.aptr.accept_encoding);

  Curl_safefree(data->state.aptr.rangeline);

  Curl_safefree(data->state.aptr.ref);

  Curl_safefree(data->state.aptr.host);

#ifndef CURL_DISABLE_COOKIES

  Curl_safefree(data->state.aptr.cookiehost);

#endif

#ifndef CURL_DISABLE_RTSP

  Curl_safefree(data->state.aptr.rtsp_transport);

#endif

  Curl_safefree(data->state.aptr.user);

  Curl_safefree(data->state.aptr.passwd);

#ifndef CURL_DISABLE_PROXY

  Curl_safefree(data->state.aptr.proxyuser);

  Curl_safefree(data->state.aptr.proxypasswd);

#endif

#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_FORM_API)

  Curl_mime_cleanpart(data->state.formp);

  Curl_safefree(data->state.formp);

#endif

  /* destruct wildcard structures if it is needed */

  Curl_wildcard_dtor(&data->wildcard);

  Curl_freeset(data);

  Curl_headers_cleanup(data);

  Curl_netrc_cleanup(&data->state.netrc);

  curlx_free(data);

  return CURLE_OK;

}

/*

 * Initialize the UserDefined fields within a Curl_easy.

 * This may be safely called on a new or existing Curl_easy.

 */

void Curl_init_userdefined(struct Curl_easy *data)

{

  struct UserDefined *set = &data->set;

  set->out = stdout;  /* default output to stdout */

  set->in_set = stdin;  /* default input from stdin */

  set->err = stderr;  /* default stderr to stderr */

#if defined(__clang__) && __clang_major__ >= 16

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wcast-function-type-strict"

#endif

  /* use fwrite as default function to store output */

  set->fwrite_func = (curl_write_callback)fwrite;

  /* use fread as default function to read input */

  set->fread_func_set = (curl_read_callback)fread;

#if defined(__clang__) && __clang_major__ >= 16

#pragma clang diagnostic pop

#endif

  set->is_fread_set = 0;

  set->seek_client = ZERO_NULL;

  set->filesize = -1;        /* we do not know the size */

  set->postfieldsize = -1;   /* unknown size */

  set->maxredirs = 30;       /* sensible default */

  set->method = HTTPREQ_GET; /* Default HTTP request */

#ifndef CURL_DISABLE_RTSP

  set->rtspreq = RTSPREQ_OPTIONS; /* Default RTSP request */

#endif

#ifndef CURL_DISABLE_FTP

  set->ftp_use_epsv = TRUE;   /* FTP defaults to EPSV operations */

  set->ftp_use_eprt = TRUE;   /* FTP defaults to EPRT operations */

  set->ftp_use_pret = FALSE;  /* mainly useful for drftpd servers */

  set->ftp_filemethod = FTPFILE_MULTICWD;

  set->ftp_skip_ip = TRUE;    /* skip PASV IP by default */

#endif

  set->dns_cache_timeout_ms = 60000; /* Timeout every 60 seconds by default */

  /* Timeout every 24 hours by default */

  set->general_ssl.ca_cache_timeout = 24 * 60 * 60;

  set->httpauth = CURLAUTH_BASIC;  /* defaults to basic */

#ifndef CURL_DISABLE_PROXY

  set->proxyport = 0;

  set->proxytype = CURLPROXY_HTTP; /* defaults to HTTP proxy */

  set->proxyauth = CURLAUTH_BASIC; /* defaults to basic */

  /* SOCKS5 proxy auth defaults to username/password + GSS-API */

  set->socks5auth = CURLAUTH_BASIC | CURLAUTH_GSSAPI;

#endif

  Curl_ssl_easy_config_init(data);

#ifndef CURL_DISABLE_DOH

  set->doh_verifyhost = TRUE;

  set->doh_verifypeer = TRUE;

#endif

#ifdef USE_SSH

  /* defaults to any auth type */

  set->ssh_auth_types = CURLSSH_AUTH_DEFAULT;

  set->new_directory_perms = 0755; /* Default permissions */

#endif

  set->new_file_perms = 0644;    /* Default permissions */

  set->allowed_protocols = (curl_prot_t) CURLPROTO_64ALL;

  set->redir_protocols = CURLPROTO_REDIR;

#if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)

  /*

   * disallow unprotected protection negotiation NEC reference implementation

   * seem not to follow rfc1961 section 4.3/4.4

   */

  set->socks5_gssapi_nec = FALSE;

#endif

  /* set default minimum TLS version */

#ifdef USE_SSL

  Curl_setopt_SSLVERSION(data, CURLOPT_SSLVERSION, CURL_SSLVERSION_DEFAULT);

#ifndef CURL_DISABLE_PROXY

  Curl_setopt_SSLVERSION(data, CURLOPT_PROXY_SSLVERSION,

                         CURL_SSLVERSION_DEFAULT);

#endif

#endif

#ifndef CURL_DISABLE_FTP

  set->wildcard_enabled = FALSE;

  set->chunk_bgn = ZERO_NULL;

  set->chunk_end = ZERO_NULL;

  set->fnmatch = ZERO_NULL;

#endif

  set->tcp_keepalive = FALSE;

  set->tcp_keepintvl = 60;

  set->tcp_keepidle = 60;

  set->tcp_keepcnt = 9;

  set->tcp_fastopen = FALSE;

  set->tcp_nodelay = TRUE;

  set->ssl_enable_alpn = TRUE;

  set->expect_100_timeout = 1000L; /* Wait for a second by default. */

  set->sep_headers = TRUE; /* separated header lists by default */

  set->buffer_size = READBUFFER_SIZE;

  set->upload_buffer_size = UPLOADBUFFER_DEFAULT;

  set->happy_eyeballs_timeout = CURL_HET_DEFAULT;

  set->upkeep_interval_ms = CURL_UPKEEP_INTERVAL_DEFAULT;

  set->maxconnects = DEFAULT_CONNCACHE_SIZE; /* for easy handles */

  set->conn_max_idle_ms = 118 * 1000;

  set->conn_max_age_ms = 24 * 3600 * 1000;

  set->http09_allowed = FALSE;

  set->httpwant = CURL_HTTP_VERSION_NONE;

#if defined(USE_HTTP2) || defined(USE_HTTP3)

  memset(&set->priority, 0, sizeof(set->priority));

#endif

  set->quick_exit = 0L;

#ifndef CURL_DISABLE_WEBSOCKETS

  set->ws_raw_mode = FALSE;

  set->ws_no_auto_pong = FALSE;

#endif

}

/* easy->meta_hash destructor. Should never be called as elements

 * MUST be added with their own destructor */

static void easy_meta_freeentry(void *p)

{

  (void)p;

  /* Will always be FALSE. Cannot use a 0 assert here since compilers

   * are not in agreement if they then want a NORETURN attribute or

   * not. *sigh* */

  DEBUGASSERT(p == NULL);

}

/**

 * Curl_open()

 *

 * @param curl is a pointer to a sessionhandle pointer that gets set by this

 * function.

 * @return CURLcode

 */

CURLcode Curl_open(struct Curl_easy **curl)

{

  struct Curl_easy *data;

  /* simple start-up: alloc the struct, init it with zeroes and return */

  data = curlx_calloc(1, sizeof(struct Curl_easy));

  if(!data) {

    /* this is a serious error */

    DEBUGF(curl_mfprintf(stderr, "Error: calloc of Curl_easy failed\n"));

    return CURLE_OUT_OF_MEMORY;

  }

  data->magic = CURLEASY_MAGIC_NUMBER;

  /* most recent connection is not yet defined */

  data->state.lastconnect_id = -1;

  data->state.recent_conn_id = -1;

  /* and not assigned an id yet */

  data->id = -1;

  data->mid = UINT32_MAX;

  data->master_mid = UINT32_MAX;

  data->progress.hide = TRUE;

  data->state.current_speed = -1; /* init to negative == impossible */

  Curl_hash_init(&data->meta_hash, 23,

                 Curl_hash_str, curlx_str_key_compare, easy_meta_freeentry);

  curlx_dyn_init(&data->state.headerb, CURL_MAX_HTTP_HEADER);

  Curl_bufref_init(&data->state.url);

  Curl_bufref_init(&data->state.referer);

  Curl_req_init(&data->req);

  Curl_initinfo(data);

#ifndef CURL_DISABLE_HTTP

  Curl_llist_init(&data->state.httphdrs, NULL);

#endif

  Curl_netrc_init(&data->state.netrc);

  Curl_init_userdefined(data);

  *curl = data;

  return CURLE_OK;

}

void Curl_conn_free(struct Curl_easy *data, struct connectdata *conn)

{

  size_t i;

  DEBUGASSERT(conn);

  if(conn->scheme && conn->scheme->run->disconnect &&

     !conn->bits.shutdown_handler)

    conn->scheme->run->disconnect(data, conn, TRUE);

  for(i = 0; i < CURL_ARRAYSIZE(conn->cfilter); ++i) {

    Curl_conn_cf_discard_all(data, conn, (int)i);

  }

  Curl_free_idnconverted_hostname(&conn->host);

  Curl_free_idnconverted_hostname(&conn->conn_to_host);

#ifndef CURL_DISABLE_PROXY

  Curl_free_idnconverted_hostname(&conn->http_proxy.host);

  Curl_free_idnconverted_hostname(&conn->socks_proxy.host);

  Curl_safefree(conn->http_proxy.user);

  Curl_safefree(conn->socks_proxy.user);

  Curl_safefree(conn->http_proxy.passwd);

  Curl_safefree(conn->socks_proxy.passwd);

  Curl_safefree(conn->http_proxy.host.rawalloc); /* http proxy name buffer */

  Curl_safefree(conn->socks_proxy.host.rawalloc); /* socks proxy name buffer */

#endif

  Curl_safefree(conn->user);

  Curl_safefree(conn->passwd);

  Curl_safefree(conn->sasl_authzid);

  Curl_safefree(conn->options);

  Curl_safefree(conn->oauth_bearer);

  Curl_safefree(conn->host.rawalloc); /* hostname buffer */

  Curl_safefree(conn->conn_to_host.rawalloc); /* hostname buffer */

  Curl_safefree(conn->secondaryhostname);

  Curl_safefree(conn->localdev);

  Curl_ssl_conn_config_cleanup(conn);

#ifdef USE_UNIX_SOCKETS

  Curl_safefree(conn->unix_domain_socket);

#endif

  Curl_safefree(conn->destination);

  Curl_hash_destroy(&conn->meta_hash);

  curlx_free(conn); /* free all the connection oriented data */

}

/*

 * xfer_may_multiplex()

 *

 * Return a TRUE, iff the transfer can be done over an (appropriate)

 * multiplexed connection.

 */

static bool xfer_may_multiplex(const struct Curl_easy *data,

                               const struct connectdata *conn)

{

#ifndef CURL_DISABLE_HTTP

  /* If an HTTP protocol and multiplexing is enabled */

  if((conn->scheme->protocol & PROTO_FAMILY_HTTP) &&

     (!conn->bits.protoconnstart || !conn->bits.close)) {

    if(Curl_multiplex_wanted(data->multi) &&

       (data->state.http_neg.allowed & (CURL_HTTP_V2x | CURL_HTTP_V3x)))

      /* allows HTTP/2 or newer */

      return TRUE;

  }

#else

  (void)data;

  (void)conn;

#endif

  return FALSE;

}

#ifndef CURL_DISABLE_PROXY

static bool proxy_info_matches(const struct proxy_info *data,

                               const struct proxy_info *needle)

{

  if((data->proxytype == needle->proxytype) &&

     (data->port == needle->port) &&

     curl_strequal(data->host.name, needle->host.name)) {

    if(Curl_timestrcmp(data->user, needle->user) ||

       Curl_timestrcmp(data->passwd, needle->passwd))

      return FALSE;

    return TRUE;

  }

  return FALSE;

}

#endif

/* A connection has to have been idle for less than 'conn_max_idle_ms'

   (the success rate is too low after this), or created less than

   'conn_max_age_ms' ago, to be subject for reuse. */

static bool conn_maxage(struct Curl_easy *data,

                        struct connectdata *conn,

                        struct curltime now)

{

  timediff_t age_ms;

  if(data->set.conn_max_idle_ms) {

    age_ms = curlx_ptimediff_ms(&now, &conn->lastused);

    if(age_ms > data->set.conn_max_idle_ms) {

      infof(data, "Too old connection (%" FMT_TIMEDIFF_T

            " ms idle, max idle is %" FMT_TIMEDIFF_T " ms), disconnect it",

            age_ms, data->set.conn_max_idle_ms);

      return TRUE;

    }

  }

  if(data->set.conn_max_age_ms) {

    age_ms = curlx_ptimediff_ms(&now, &conn->created);

    if(age_ms > data->set.conn_max_age_ms) {

      infof(data,

            "Too old connection (created %" FMT_TIMEDIFF_T

            " ms ago, max lifetime is %" FMT_TIMEDIFF_T " ms), disconnect it",

            age_ms, data->set.conn_max_age_ms);

      return TRUE;

    }

  }

  return FALSE;

}

/*

 * Return TRUE iff the given connection is considered dead.

 */

bool Curl_conn_seems_dead(struct connectdata *conn,

                          struct Curl_easy *data)

{

  DEBUGASSERT(!data->conn);

  if(!CONN_INUSE(conn)) {

    /* The check for a dead socket makes sense only if the connection is not in

       use */

    bool dead;

    if(conn_maxage(data, conn, *Curl_pgrs_now(data))) {

      /* avoid check if already too old */

      dead = TRUE;

    }

    else if(conn->scheme->run->connection_check) {

      /* The protocol has a special method for checking the state of the

         connection. Use it to check if the connection is dead. */

      unsigned int state;

      /* briefly attach the connection to this transfer for the purpose of

         checking it */

      Curl_attach_connection(data, conn);

      state = conn->scheme->run->connection_check(data, conn,

                                                     CONNCHECK_ISDEAD);

      dead = (state & CONNRESULT_DEAD);

      /* detach the connection again */

      Curl_detach_connection(data);

    }

    else {

      bool input_pending = FALSE;

      Curl_attach_connection(data, conn);

      dead = !Curl_conn_is_alive(data, conn, &input_pending);

      if(input_pending) {

        /* For reuse, we want a "clean" connection state. The includes

         * that we expect - in general - no waiting input data. Input

         * waiting might be a TLS Notify Close, for example. We reject

         * that.

         * For protocols where data from other end may arrive at

         * any time (HTTP/2 PING for example), the protocol handler needs

         * to install its own `connection_check` callback.

         */

        DEBUGF(infof(data, "connection has input pending, not reusable"));

        dead = TRUE;

      }

      Curl_detach_connection(data);

    }

    if(dead) {

      /* remove connection from cpool */

      infof(data, "Connection %" FMT_OFF_T " seems to be dead",

            conn->connection_id);

      return TRUE;

    }

  }

  return FALSE;

}

CURLcode Curl_conn_upkeep(struct Curl_easy *data,

                          struct connectdata *conn)

{

  CURLcode result = CURLE_OK;

  if(curlx_ptimediff_ms(Curl_pgrs_now(data), &conn->keepalive) <=

     data->set.upkeep_interval_ms)

    return result;

  /* briefly attach for action */

  Curl_attach_connection(data, conn);

  if(conn->scheme->run->connection_check) {

    /* Do a protocol-specific keepalive check on the connection. */

    unsigned int rc;

    rc = conn->scheme->run->connection_check(data, conn,

                                                CONNCHECK_KEEPALIVE);

    if(rc & CONNRESULT_DEAD)

      result = CURLE_RECV_ERROR;

  }

  else {

    /* Do the generic action on the FIRSTSOCKET filter chain */

    result = Curl_conn_keep_alive(data, conn, FIRSTSOCKET);

  }

  Curl_detach_connection(data);

  conn->keepalive = *Curl_pgrs_now(data);

  return result;

}

#ifdef USE_SSH

static bool ssh_config_matches(struct connectdata *one,

                               struct connectdata *two)

{

  struct ssh_conn *sshc1, *sshc2;

  sshc1 = Curl_conn_meta_get(one, CURL_META_SSH_CONN);

  sshc2 = Curl_conn_meta_get(two, CURL_META_SSH_CONN);

  return sshc1 && sshc2 && Curl_safecmp(sshc1->rsa, sshc2->rsa) &&

         Curl_safecmp(sshc1->rsa_pub, sshc2->rsa_pub);

}

#endif

struct url_conn_match {

  struct connectdata *found;

  struct Curl_easy *data;

  struct connectdata *needle;

  BIT(may_multiplex);

  BIT(want_ntlm_http);

  BIT(want_proxy_ntlm_http);

  BIT(want_nego_http);

  BIT(want_proxy_nego_http);

  BIT(wait_pipe);

  BIT(force_reuse);

  BIT(seen_pending_conn);

  BIT(seen_single_use_conn);

  BIT(seen_multiplex_conn);

};

static bool url_match_connect_config(struct connectdata *conn,

                                     struct url_conn_match *m)

{

  /* connect-only or to-be-closed connections will not be reused */

  if(conn->connect_only || conn->bits.close || conn->bits.no_reuse)

    return FALSE;

  /* ip_version must match */

  if(m->data->set.ipver != CURL_IPRESOLVE_WHATEVER &&

     m->data->set.ipver != conn->ip_version)

    return FALSE;

  if(m->needle->localdev || m->needle->localport) {

    /* If we are bound to a specific local end (IP+port), we must not reuse a

       random other one, although if we did not ask for a particular one we

       can reuse one that was bound.

       This comparison is a bit rough and too strict. Since the input

       parameters can be specified in numerous ways and still end up the same

       it would take a lot of processing to make it really accurate. Instead,

       this matching will assume that reuses of bound connections will most

       likely also reuse the exact same binding parameters and missing out a

       few edge cases should not hurt anyone much.

    */

    if((conn->localport != m->needle->localport) ||

       (conn->localportrange != m->needle->localportrange) ||

       (m->needle->localdev &&

        (!conn->localdev || strcmp(conn->localdev, m->needle->localdev))))

      return FALSE;

  }

  if(m->needle->bits.conn_to_host != conn->bits.conn_to_host)

    /* do not mix connections that use the "connect to host" feature and

     * connections that do not use this feature */

    return FALSE;

  if(m->needle->bits.conn_to_port != conn->bits.conn_to_port)

    /* do not mix connections that use the "connect to port" feature and

     * connections that do not use this feature */

    return FALSE;

  /* Does `conn` use the correct protocol? */

#ifdef USE_UNIX_SOCKETS

  if(m->needle->unix_domain_socket) {

    if(!conn->unix_domain_socket)

      return FALSE;

    if(strcmp(m->needle->unix_domain_socket, conn->unix_domain_socket))

      return FALSE;

    if(m->needle->bits.abstract_unix_socket != conn->bits.abstract_unix_socket)

      return FALSE;

  }

  else if(conn->unix_domain_socket)

    return FALSE;

#endif

  return TRUE;

}

static bool url_match_fully_connected(struct connectdata *conn,

                                      struct url_conn_match *m)

{

  if(!Curl_conn_is_connected(conn, FIRSTSOCKET) ||

     conn->bits.upgrade_in_progress) {

    /* Not yet connected, or a protocol upgrade is in progress. The later

     * happens for HTTP/2 Upgrade: requests that need a response. */

    if(m->may_multiplex) {

      m->seen_pending_conn = TRUE;

      /* Do not pick a connection that has not connected yet */

      infof(m->data, "Connection #%" FMT_OFF_T

            " is not open enough, cannot reuse", conn->connection_id);

    }

    /* Do not pick a connection that has not connected yet */

    return FALSE;

  }

  return TRUE;

}

static bool url_match_multi(struct connectdata *conn,

                            struct url_conn_match *m)

{

  if(CONN_INUSE(conn)) {

    DEBUGASSERT(conn->attached_multi);

    if(conn->attached_multi != m->data->multi)

      return FALSE;

  }

  return TRUE;

}

static bool url_match_multiplex_needs(struct connectdata *conn,

                                      struct url_conn_match *m)

{

  if(CONN_INUSE(conn)) {

    if(!conn->bits.multiplex) {

      /* conn busy and conn cannot take more transfers */

      m->seen_single_use_conn = TRUE;

      return FALSE;

    }

    m->seen_multiplex_conn = TRUE;

    if(!m->may_multiplex || !url_match_multi(conn, m))

      /* conn busy and transfer cannot be multiplexed */

      return FALSE;

  }

  return TRUE;

}

static bool url_match_multiplex_limits(struct connectdata *conn,

                                       struct url_conn_match *m)

{

  if(CONN_INUSE(conn) && m->may_multiplex) {

    DEBUGASSERT(conn->bits.multiplex);

    /* If multiplexed, make sure we do not go over concurrency limit */

    if(conn->attached_xfers >=

            Curl_multi_max_concurrent_streams(m->data->multi)) {

      infof(m->data, "client side MAX_CONCURRENT_STREAMS reached"

            ", skip (%u)", conn->attached_xfers);

      return FALSE;

    }

    if(conn->attached_xfers >=

       Curl_conn_get_max_concurrent(m->data, conn, FIRSTSOCKET)) {

      infof(m->data, "MAX_CONCURRENT_STREAMS reached, skip (%u)",

            conn->attached_xfers);

      return FALSE;

    }

    /* When not multiplexed, we have a match here! */

    infof(m->data, "Multiplexed connection found");

  }

  return TRUE;

}

static bool url_match_ssl_use(struct connectdata *conn,

                              struct url_conn_match *m)

{

  if(m->needle->scheme->flags & PROTOPT_SSL) {

    /* We are looking for SSL, if `conn` does not do it, not a match. */

    if(!Curl_conn_is_ssl(conn, FIRSTSOCKET))

      return FALSE;

  }

  else if(Curl_conn_is_ssl(conn, FIRSTSOCKET)) {

    /* If the protocol does not allow reuse of SSL connections OR

       is of another protocol family, not a match. */

    if(!(m->needle->scheme->flags & PROTOPT_SSL_REUSE) ||

       (get_protocol_family(conn->scheme) != m->needle->scheme->protocol))

      return FALSE;

  }

  return TRUE;

}

#ifndef CURL_DISABLE_PROXY

static bool url_match_proxy_use(struct connectdata *conn,

                                struct url_conn_match *m)

{

  if(m->needle->bits.httpproxy != conn->bits.httpproxy ||

     m->needle->bits.socksproxy != conn->bits.socksproxy)

    return FALSE;

  if(m->needle->bits.socksproxy &&

     !proxy_info_matches(&m->needle->socks_proxy, &conn->socks_proxy))

    return FALSE;

  if(m->needle->bits.httpproxy) {

    if(m->needle->bits.tunnel_proxy != conn->bits.tunnel_proxy)

      return FALSE;

    if(!proxy_info_matches(&m->needle->http_proxy, &conn->http_proxy))

      return FALSE;

    if(IS_HTTPS_PROXY(m->needle->http_proxy.proxytype)) {

      /* https proxies come in different types, http/1.1, h2, ... */

      if(m->needle->http_proxy.proxytype != conn->http_proxy.proxytype)

        return FALSE;

      /* match SSL config to proxy */

      if(!Curl_ssl_conn_config_match(m->data, conn, TRUE)) {

        DEBUGF(infof(m->data,

                     "Connection #%" FMT_OFF_T

                     " has different SSL proxy parameters, cannot reuse",

                     conn->connection_id));

        return FALSE;

      }

      /* the SSL config to the server, which may apply here is checked

       * further below */

    }

  }

  return TRUE;

}

#else

#define url_match_proxy_use(c, m) ((void)(c), (void)(m), TRUE)

#endif

#ifndef CURL_DISABLE_HTTP

static bool url_match_http_multiplex(struct connectdata *conn,

                                     struct url_conn_match *m)

{

  if(m->may_multiplex &&

     (m->data->state.http_neg.allowed & (CURL_HTTP_V2x | CURL_HTTP_V3x)) &&

     (m->needle->scheme->protocol & CURLPROTO_HTTP) &&

     !conn->httpversion_seen) {

    if(m->data->set.pipewait) {

      infof(m->data, "Server upgrade does not support multiplex yet, wait");

      m->found = NULL;

      m->wait_pipe = TRUE;

      return TRUE; /* stop searching, we want to wait */

    }