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

 *                                  _   _ ____  _

 *  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

#include <limits.h>

#include "doh.h"

#include "urldata.h"

#include "netrc.h"

#include "formdata.h"

#include "mime.h"

#include "vtls/vtls.h"

#include "hostip.h"

#include "transfer.h"

#include "sendf.h"

#include "progress.h"

#include "cookie.h"

#include "strcase.h"

#include "strerror.h"

#include "escape.h"

#include "strtok.h"

#include "share.h"

#include "content_encoding.h"

#include "http_digest.h"

#include "http_negotiate.h"

#include "select.h"

#include "multiif.h"

#include "easyif.h"

#include "speedcheck.h"

#include "warnless.h"

#include "getinfo.h"

#include "urlapi-int.h"

#include "system_win32.h"

#include "hsts.h"

#include "noproxy.h"

#include "cfilters.h"

#include "idn.h"

/* And now for the protocols */

#include "ftp.h"

#include "dict.h"

#include "telnet.h"

#include "tftp.h"

#include "http.h"

#include "http2.h"

#include "file.h"

#include "curl_ldap.h"

#include "vssh/ssh.h"

#include "imap.h"

#include "url.h"

#include "connect.h"

#include "inet_ntop.h"

#include "http_ntlm.h"

#include "curl_rtmp.h"

#include "gopher.h"

#include "mqtt.h"

#include "http_proxy.h"

#include "conncache.h"

#include "multihandle.h"

#include "strdup.h"

#include "setopt.h"

#include "altsvc.h"

#include "dynbuf.h"

#include "headers.h"

/* The last 3 #include files should be in this order */

#include "curl_printf.h"

#include "curl_memory.h"

#include "memdebug.h"

#ifndef ARRAYSIZE

#define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))

#endif

#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 at

 * more than just 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

#ifdef 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:

*

* 'h'  [in]  - struct Curl_handler pointer.

*

* Returns the family as a single bit protocol identifier.

*/

static curl_prot_t get_protocol_family(const struct Curl_handler *h)

{

  DEBUGASSERT(h);

  DEBUGASSERT(h->family);

  return h->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]);

  }

  if(data->state.referer_alloc) {

    Curl_safefree(data->state.referer);

    data->state.referer_alloc = FALSE;

  }

  data->state.referer = NULL;

  if(data->state.url_alloc) {

    Curl_safefree(data->state.url);

    data->state.url_alloc = FALSE;

  }

  data->state.url = NULL;

  Curl_mime_cleanpart(&data->set.mimepost);

#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;

  /* 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) {

    if(data->multi)

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

         and detach this handle from there. */

      curl_multi_remove_handle(data->multi, data);

    if(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;

    }

  }

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

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

                      the multi handle, since that function uses the magic

                      field! */

  if(data->state.rangestringalloc)

    free(data->state.range);

  /* freed here just 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);

  if(data->state.referer_alloc) {

    Curl_safefree(data->state.referer);

    data->state.referer_alloc = FALSE;

  }

  data->state.referer = NULL;

  up_free(data);

  Curl_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->info.contenttype);

  Curl_safefree(data->info.wouldredirect);

  /* this destroys the channel and we cannot use it anymore after this */

  Curl_resolver_cancel(data);

  Curl_resolver_cleanup(data->state.async.resolver);

  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);

  }

#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.te);

  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);

  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.

 */

CURLcode Curl_init_userdefined(struct Curl_easy *data)

{

  struct UserDefined *set = &data->set;

  CURLcode result = CURLE_OK;

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

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

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

  /* 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;

  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 = 60; /* Timeout every 60 seconds by default */

  /* Set the default size of the SSL session ID cache */

  set->general_ssl.max_ssl_sessions = 5;

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

  /* make libcurl quiet by default: */

  set->hide_progress = TRUE;  /* CURLOPT_NOPROGRESS changes these */

  Curl_mime_initpart(&set->mimepost);

  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_ALL;

  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 the default CA cert bundle/path detected/specified at build time.

   *

   * If Schannel or SecureTransport is the selected SSL backend then these

   * locations are ignored. We allow setting CA location for schannel and

   * securetransport when explicitly specified by the user via

   *  CURLOPT_CAINFO / --cacert.

   */

  if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL &&

     Curl_ssl_backend() != CURLSSLBACKEND_SECURETRANSPORT) {

#if defined(CURL_CA_BUNDLE)

    result = Curl_setstropt(&set->str[STRING_SSL_CAFILE], CURL_CA_BUNDLE);

    if(result)

      return result;

#ifndef CURL_DISABLE_PROXY

    result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_PROXY],

                            CURL_CA_BUNDLE);

    if(result)

      return result;

#endif

#endif

#if defined(CURL_CA_PATH)

    result = Curl_setstropt(&set->str[STRING_SSL_CAPATH], CURL_CA_PATH);

    if(result)

      return result;

#ifndef CURL_DISABLE_PROXY

    result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_PROXY], CURL_CA_PATH);

    if(result)

      return result;

#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->maxage_conn = 118;

  set->maxlifetime_conn = 0;

  set->http09_allowed = FALSE;

#ifdef USE_HTTP2

  set->httpwant = CURL_HTTP_VERSION_2TLS

#else

  set->httpwant = CURL_HTTP_VERSION_1_1

#endif

    ;

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

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

#endif

  set->quick_exit = 0L;

  return result;

}

/**

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

{

  CURLcode result;

  struct Curl_easy *data;

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

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

  if(!data) {

    /* this is a very serious error */

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

    return CURLE_OUT_OF_MEMORY;

  }

  data->magic = CURLEASY_MAGIC_NUMBER;

  Curl_req_init(&data->req);

  result = Curl_resolver_init(data, &data->state.async.resolver);

  if(result) {

    DEBUGF(fprintf(stderr, "Error: resolver_init failed\n"));

    Curl_req_free(&data->req, data);

    free(data);

    return result;

  }

  result = Curl_init_userdefined(data);

  if(!result) {

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

    Curl_initinfo(data);

    /* 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 = -1;

#ifndef CURL_DISABLE_DOH

    data->set.dohfor_mid = -1;

#endif

    data->progress.flags |= PGRS_HIDE;

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

#ifndef CURL_DISABLE_HTTP

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

#endif

  }

  if(result) {

    Curl_resolver_cleanup(data->state.async.resolver);

    Curl_dyn_free(&data->state.headerb);

    Curl_freeset(data);

    Curl_req_free(&data->req, data);

    free(data);

    data = NULL;

  }

  else

    *curl = data;

  return result;

}

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

{

  size_t i;

  DEBUGASSERT(conn);

  for(i = 0; i < 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->hostname_resolve);

  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);

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

}

/*

 * Disconnects the given connection. Note the connection may not be the

 * primary connection, like when freeing room in the connection pool or

 * killing of a dead old connection.

 *

 * A connection needs an easy handle when closing down. We support this passed

 * in separately since the connection to get closed here is often already

 * disassociated from an easy handle.

 *

 * This function MUST NOT reset state in the Curl_easy struct if that

 * is not strictly bound to the life-time of *this* particular connection.

 */

bool Curl_on_disconnect(struct Curl_easy *data,

                        struct connectdata *conn, bool aborted)

{

  /* there must be a connection to close */

  DEBUGASSERT(conn);

  /* it must be removed from the connection pool */

  DEBUGASSERT(!conn->bits.in_cpool);

  /* there must be an associated transfer */

  DEBUGASSERT(data);

  /* the transfer must be detached from the connection */

  DEBUGASSERT(!data->conn);

  DEBUGF(infof(data, "Curl_disconnect(conn #%" FMT_OFF_T ", aborted=%d)",

         conn->connection_id, aborted));

  if(conn->dns_entry)

    Curl_resolv_unlink(data, &conn->dns_entry);

  /* Cleanup NTLM connection-related data */

  Curl_http_auth_cleanup_ntlm(conn);

  /* Cleanup NEGOTIATE connection-related data */

  Curl_http_auth_cleanup_negotiate(conn);

  if(conn->connect_only)

    /* treat the connection as aborted in CONNECT_ONLY situations */

    aborted = TRUE;

  return aborted;

}

/*

 * Curl_xfer_may_multiplex()

 *

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

 * multiplexed connection.

 */

static bool Curl_xfer_may_multiplex(const struct Curl_easy *data,

                                    const struct connectdata *conn)

{

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

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

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

    if(Curl_multiplex_wanted(data->multi) &&

       (data->state.httpwant >= CURL_HTTP_VERSION_2))

      /* allows HTTP/2 or newer */

      return TRUE;

  }

  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) &&

     strcasecompare(data->host.name, needle->host.name))

    return TRUE;

  return FALSE;

}

static bool

socks_proxy_info_matches(const struct proxy_info *data,

                         const struct proxy_info *needle)

{

  if(!proxy_info_matches(data, needle))

    return FALSE;

  /* the user information is case-sensitive

     or at least it is not defined as case-insensitive

     see https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.1 */

  /* curl_strequal does a case insensitive comparison,

     so do not use it here! */

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

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

    return FALSE;

  return TRUE;

}

#else

/* disabled, will not get called */

#define proxy_info_matches(x,y) FALSE

#define socks_proxy_info_matches(x,y) FALSE

#endif

/* A connection has to have been idle for a shorter time than 'maxage_conn'

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

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

static bool conn_maxage(struct Curl_easy *data,

                        struct connectdata *conn,

                        struct curltime now)

{

  timediff_t idletime, lifetime;

  idletime = Curl_timediff(now, conn->lastused);

  idletime /= 1000; /* integer seconds is fine */

  if(idletime > data->set.maxage_conn) {

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

          " seconds idle), disconnect it", idletime);

    return TRUE;

  }

  lifetime = Curl_timediff(now, conn->created);

  lifetime /= 1000; /* integer seconds is fine */

  if(data->set.maxlifetime_conn && lifetime > data->set.maxlifetime_conn) {

    infof(data,

          "Too old connection (%" FMT_TIMEDIFF_T

          " seconds since creation), disconnect it", lifetime);

    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,

                          struct curltime *pnow)

{

  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;

    struct curltime now;

    if(!pnow) {

      now = Curl_now();

      pnow = &now;

    }

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

      /* avoid check if already too old */

      dead = TRUE;

    }

    else if(conn->handler->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->handler->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,

                          struct curltime *now)

{

  CURLcode result = CURLE_OK;

  if(Curl_timediff(*now, conn->keepalive) <= data->set.upkeep_interval_ms)

    return result;

  /* briefly attach for action */

  Curl_attach_connection(data, conn);

  if(conn->handler->connection_check) {

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

    unsigned int rc;

    rc = conn->handler->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 = *now;

  return result;

}

#ifdef USE_SSH

static bool ssh_config_matches(struct connectdata *one,

                               struct connectdata *two)

{

  return (Curl_safecmp(one->proto.sshc.rsa, two->proto.sshc.rsa) &&

          Curl_safecmp(one->proto.sshc.rsa_pub, two->proto.sshc.rsa_pub));

}

#else

#define ssh_config_matches(x,y) FALSE

#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(wait_pipe);

  BIT(force_reuse);

  BIT(seen_pending_conn);

  BIT(seen_single_use_conn);

  BIT(seen_multiplex_conn);

};

static bool url_match_conn(struct connectdata *conn, void *userdata)

{

  struct url_conn_match *match = userdata;

  struct Curl_easy *data = match->data;

  struct connectdata *needle = match->needle;

  /* Check if `conn` can be used for transfer `data` */

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

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

    return FALSE;

  if(data->set.ipver != CURL_IPRESOLVE_WHATEVER

     && data->set.ipver != conn->ip_version) {

    /* skip because the connection is not via the requested IP version */

    return FALSE;

  }

  if(needle->localdev || 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 very much.

    */

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

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

       (needle->localdev &&

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

      return FALSE;

  }

  if(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(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;

  if(!Curl_conn_is_connected(conn, FIRSTSOCKET) ||

     conn->bits.asks_multiplex) {

    /* Not yet connected, or not yet decided if it multiplexes. The later

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

    if(match->may_multiplex) {

      match->seen_pending_conn = TRUE;

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

      infof(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;

  }

  /* `conn` is connected. If it has transfers, can we add ours to it? */

  if(CONN_INUSE(conn)) {

    if(!conn->bits.multiplex) {

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

      match->seen_single_use_conn = TRUE;

      return FALSE;

    }

    match->seen_multiplex_conn = TRUE;

    if(!match->may_multiplex)

      /* conn busy and transfer cannot be multiplexed */

      return FALSE;

    else {

      /* transfer and conn multiplex. Are they on the same multi? */

      struct Curl_llist_node *e = Curl_llist_head(&conn->easyq);

      struct Curl_easy *entry = Curl_node_elem(e);

      if(entry->multi != data->multi)

        return FALSE;

    }

  }

  /* `conn` is connected and we could add the transfer to it, if

   * all the other criteria do match. */

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

#ifdef USE_UNIX_SOCKETS

  if(needle->unix_domain_socket) {

    if(!conn->unix_domain_socket)

      return FALSE;

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

      return FALSE;

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

      return FALSE;

  }

  else if(conn->unix_domain_socket)

    return FALSE;

#endif

  if((needle->handler->flags&PROTOPT_SSL) !=

     (conn->handler->flags&PROTOPT_SSL))

    /* do not do mixed SSL and non-SSL connections */

    if(get_protocol_family(conn->handler) !=

       needle->handler->protocol || !conn->bits.tls_upgraded)

      /* except protocols that have been upgraded via TLS */

      return FALSE;

#ifndef CURL_DISABLE_PROXY

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

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

    return FALSE;

  if(needle->bits.socksproxy &&

    !socks_proxy_info_matches(&needle->socks_proxy,

                              &conn->socks_proxy))

    return FALSE;

  if(needle->bits.httpproxy) {

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

      return FALSE;

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

      return FALSE;

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

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

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

        return FALSE;

      /* match SSL config to proxy */

      if(!Curl_ssl_conn_config_match(data, conn, TRUE)) {

        DEBUGF(infof(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 */

    }

  }

#endif

  if(match->may_multiplex &&

     (data->state.httpwant == CURL_HTTP_VERSION_2_0) &&

     (needle->handler->protocol & CURLPROTO_HTTP) &&

     !conn->httpversion) {

    if(data->set.pipewait) {

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

      match->found = NULL;

      match->wait_pipe = TRUE;

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

    }

    infof(data, "Server upgrade cannot be used");

    return FALSE;

  }