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

 *                                  _   _ ____  _

 *  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 can't 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. Don't 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;

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

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

    }

  }

  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 wasn't called */

  Curl_free_request_state(data);

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

  Curl_ssl_close_all(data);

  Curl_safefree(data->state.first_host);

  Curl_safefree(data->state.scratch);

  Curl_ssl_free_certinfo(data);

  /* Cleanup possible redirect junk */

  free(data->req.newurl);

  data->req.newurl = NULL;

  if(data->state.referer_alloc) {

    Curl_safefree(data->state.referer);

    data->state.referer_alloc = FALSE;

  }

  data->state.referer = NULL;

  up_free(data);

  Curl_safefree(data->state.buffer);

  Curl_dyn_free(&data->state.headerb);

  Curl_safefree(data->state.ulbuf);

  Curl_flush_cookies(data, TRUE);

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

  Curl_altsvc_cleanup(&data->asi);

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

#ifndef CURL_DISABLE_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);

  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_safefree(data->state.aptr.proxyuserpwd);

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

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

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

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

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

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

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

#ifndef CURL_DISABLE_DOH

  if(data->req.doh) {

    Curl_dyn_free(&data->req.doh->probe[0].serverdoh);

    Curl_dyn_free(&data->req.doh->probe[1].serverdoh);

    curl_slist_free_all(data->req.doh->headers);

    Curl_safefree(data->req.doh);

  }

#endif

#ifndef CURL_DISABLE_HTTP

  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_func = ZERO_NULL;

  set->seek_client = ZERO_NULL;

  set->filesize = -1;        /* we don't 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_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP |

                         CURLPROTO_FTPS;

#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 is the selected SSL backend then these locations are

   * ignored. We allow setting CA location for schannel only when explicitly

   * specified by the user via CURLOPT_CAINFO / --cacert.

   */

  if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL) {

#if defined(CURL_CA_BUNDLE)

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

    if(result)

      return result;

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

                            CURL_CA_BUNDLE);

    if(result)

      return result;

#endif

#if defined(CURL_CA_PATH)

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

    if(result)

      return result;

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

    if(result)

      return result;

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

  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->progress.flags |= PGRS_HIDE;

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

  }

  if(result) {

    Curl_dyn_free(&data->state.headerb);

    Curl_freeset(data);

    free(data);

    data = NULL;

  }

  else

    *curl = data;

  return result;

}

static void conn_shutdown(struct Curl_easy *data)

{

  DEBUGASSERT(data);

  infof(data, "Closing connection");

  /* possible left-overs from the async name resolvers */

  Curl_resolver_cancel(data);

  Curl_conn_close(data, SECONDARYSOCKET);

  Curl_conn_close(data, FIRSTSOCKET);

}

static void 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_resolver_cleanup(conn->resolve_async.resolver);

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

#ifndef CURL_DISABLE_HTTP

  Curl_dyn_free(&conn->trailer);

#endif

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

  Curl_safefree(conn->conn_to_host.rawalloc); /* host name 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

  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 cache 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

 * isn't strictly bound to the life-time of *this* particular connection.

 *

 */

void Curl_disconnect(struct Curl_easy *data,

                     struct connectdata *conn, bool dead_connection)

{

  /* there must be a connection to close */

  DEBUGASSERT(conn);

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

  DEBUGASSERT(!conn->bundle);

  /* 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 #%"

         CURL_FORMAT_CURL_OFF_T ", dead=%d)",

         conn->connection_id, dead_connection));

  /*

   * If this connection isn't marked to force-close, leave it open if there

   * are other users of it

   */

  if(CONN_INUSE(conn) && !dead_connection) {

    DEBUGF(infof(data, "Curl_disconnect when inuse: %zu", CONN_INUSE(conn)));

    return;

  }

  if(conn->dns_entry) {

    Curl_resolv_unlock(data, conn->dns_entry);

    conn->dns_entry = NULL;

  }

  /* 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 dead in CONNECT_ONLY situations */

    dead_connection = TRUE;

  /* temporarily attach the connection to this transfer handle for the

     disconnect and shutdown */

  Curl_attach_connection(data, conn);

  if(conn->handler && conn->handler->disconnect)

    /* This is set if protocol-specific cleanups should be made */

    conn->handler->disconnect(data, conn, dead_connection);

  conn_shutdown(data);

  Curl_resolver_cancel(data);

  /* detach it again */

  Curl_detach_connection(data);

  conn_free(data, conn);

}

/*

 * IsMultiplexingPossible()

 *

 * Return a bitmask with the available multiplexing options for the given

 * requested connection.

 */

static int IsMultiplexingPossible(const struct Curl_easy *handle,

                                  const struct connectdata *conn)

{

  int avail = 0;

  /* 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(handle->multi) &&

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

      /* allows HTTP/2 */

      avail |= CURLPIPE_MULTIPLEX;

  }

  return avail;

}

#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, won't 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 (%" CURL_FORMAT_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 (%" CURL_FORMAT_TIMEDIFF_T

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

    return TRUE;

  }

  return FALSE;

}

/*

 * This function checks if the given connection is dead and extracts it from

 * the connection cache if so.

 *

 * When this is called as a Curl_conncache_foreach() callback, the connection

 * cache lock is held!

 *

 * Returns TRUE if the connection was dead and extracted.

 */

static bool extract_if_dead(struct connectdata *conn,

                            struct Curl_easy *data)

{

  if(!CONN_INUSE(conn)) {

    /* The check for a dead socket makes sense only if the connection isn't in

       use */

    bool dead;

    struct curltime now = Curl_now();

    if(conn_maxage(data, conn, now)) {

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

      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.

         */

        dead = TRUE;

      }

      Curl_detach_connection(data);

    }

    if(dead) {

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

            conn->connection_id);

      Curl_conncache_remove_conn(data, conn, FALSE);

      return TRUE;

    }

  }

  return FALSE;

}

struct prunedead {

  struct Curl_easy *data;

  struct connectdata *extracted;

};

/*

 * Wrapper to use extract_if_dead() function in Curl_conncache_foreach()

 *

 */

static int call_extract_if_dead(struct Curl_easy *data,

                                struct connectdata *conn, void *param)

{

  struct prunedead *p = (struct prunedead *)param;

  if(extract_if_dead(conn, data)) {

    /* stop the iteration here, pass back the connection that was extracted */

    p->extracted = conn;

    return 1;

  }

  return 0; /* continue iteration */

}

/*

 * This function scans the connection cache for half-open/dead connections,

 * closes and removes them. The cleanup is done at most once per second.

 *

 * When called, this transfer has no connection attached.

 */

static void prune_dead_connections(struct Curl_easy *data)

{

  struct curltime now = Curl_now();

  timediff_t elapsed;

  DEBUGASSERT(!data->conn); /* no connection */

  CONNCACHE_LOCK(data);

  elapsed =

    Curl_timediff(now, data->state.conn_cache->last_cleanup);

  CONNCACHE_UNLOCK(data);

  if(elapsed >= 1000L) {

    struct prunedead prune;

    prune.data = data;

    prune.extracted = NULL;

    while(Curl_conncache_foreach(data, data->state.conn_cache, &prune,

                                 call_extract_if_dead)) {

      /* unlocked */

      /* remove connection from cache */

      Curl_conncache_remove_conn(data, prune.extracted, TRUE);

      /* disconnect it */

      Curl_disconnect(data, prune.extracted, TRUE);

    }

    CONNCACHE_LOCK(data);

    data->state.conn_cache->last_cleanup = now;

    CONNCACHE_UNLOCK(data);

  }

}

#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

/*

 * Given one filled in connection struct (named needle), this function should

 * detect if there already is one that has all the significant details

 * exactly the same and thus should be used instead.

 *

 * If there is a match, this function returns TRUE - and has marked the

 * connection as 'in-use'. It must later be called with ConnectionDone() to

 * return back to 'idle' (unused) state.

 *

 * The force_reuse flag is set if the connection must be used.

 */

static bool

ConnectionExists(struct Curl_easy *data,

                 struct connectdata *needle,

                 struct connectdata **usethis,

                 bool *force_reuse,

                 bool *waitpipe)

{

  struct connectdata *chosen = NULL;

  bool foundPendingCandidate = FALSE;

  bool canmultiplex = FALSE;

  struct connectbundle *bundle;

  struct Curl_llist_element *curr;

#ifdef USE_NTLM

  bool wantNTLMhttp = ((data->state.authhost.want &

                        (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&

                       (needle->handler->protocol & PROTO_FAMILY_HTTP));

#ifndef CURL_DISABLE_PROXY

  bool wantProxyNTLMhttp = (needle->bits.proxy_user_passwd &&

                            ((data->state.authproxy.want &

                              (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&

                             (needle->handler->protocol & PROTO_FAMILY_HTTP)));

#else

  bool wantProxyNTLMhttp = FALSE;

#endif

#endif

  /* plain HTTP with upgrade */

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

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

  *usethis = NULL;

  *force_reuse = FALSE;

  *waitpipe = FALSE;

  /* Look up the bundle with all the connections to this particular host.

     Locks the connection cache, beware of early returns! */

  bundle = Curl_conncache_find_bundle(data, needle, data->state.conn_cache);

  if(!bundle) {

    CONNCACHE_UNLOCK(data);

    return FALSE;

  }

  infof(data, "Found bundle for host: %p [%s]",

        (void *)bundle, (bundle->multiuse == BUNDLE_MULTIPLEX ?

                         "can multiplex" : "serially"));

  /* We can only multiplex iff the transfer allows it AND we know

   * that the server we want to talk to supports it as well. */

  canmultiplex = FALSE;

  if(IsMultiplexingPossible(data, needle)) {

    if(bundle->multiuse == BUNDLE_UNKNOWN) {

      if(data->set.pipewait) {

        infof(data, "Server doesn't support multiplex yet, wait");

        *waitpipe = TRUE;

        CONNCACHE_UNLOCK(data);

        return FALSE; /* no reuse */

      }

      infof(data, "Server doesn't support multiplex (yet)");

    }

    else if(bundle->multiuse == BUNDLE_MULTIPLEX) {

      if(Curl_multiplex_wanted(data->multi))

        canmultiplex = TRUE;

      else

        infof(data, "Could multiplex, but not asked to");

    }

    else if(bundle->multiuse == BUNDLE_NO_MULTIUSE) {

      infof(data, "Can not multiplex, even if we wanted to");

    }

  }

  curr = bundle->conn_list.head;

  while(curr) {

    struct connectdata *check = curr->ptr;

    /* Get next node now. We might remove a dead `check` connection which

     * would invalidate `curr` as well. */

    curr = curr->next;