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

 *                                  _   _ ____  _

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

#include <netinet/udp.h>

#endif

#ifdef HAVE_NETINET_IP_H

#include <netinet/ip.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 HAVE_IFADDRS_H

#include <ifaddrs.h>

#endif

#ifdef HAVE_NET_IF_H

#include <net/if.h>

#endif

#ifdef __VMS

#include <in.h>

#include <inet.h>

#endif

#include "urldata.h"

#include "curl_trc.h"

#include "if2ip.h"

#include "cfilters.h"

#include "cf-socket.h"

#include "connect.h"

#include "curl_addrinfo.h"

#include "select.h"

#include "multiif.h"

#include "curlx/inet_ntop.h"

#include "curlx/inet_pton.h"

#include "progress.h"

#include "conncache.h"

#include "multihandle.h"

#include "rand.h"

#include "sockaddr.h"

#include "curlx/strdup.h"

#include "curlx/nonblock.h"

#include "curlx/strcopy.h"

#include "curlx/version_win32.h"

#include "curlx/strerr.h"

#include "curlx/strparse.h"

#ifdef _WIN32

#include <mstcpip.h> /* for TCP_INITIAL_RTO_PARAMETERS */

#endif

/* retrieves ip address and port from a sockaddr structure. note it calls

 * curlx_inet_ntop() and returns CURLcode.

 * @unittest 1607

 */

UNITTEST CURLcode sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,

                                  char *addr, uint16_t *port);

UNITTEST CURLcode sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,

                                  char *addr, uint16_t *port)

{

  CURLcode result;

  struct sockaddr_in *si = NULL;

#ifdef USE_IPV6

  struct sockaddr_in6 *si6 = NULL;

#endif

#ifdef USE_UNIX_SOCKETS

  struct sockaddr_un *su = NULL;

#else

  (void)salen;

#endif

  switch(sa->sa_family) {

  case AF_INET:

    si = (struct sockaddr_in *)(void *)sa;

    result = curlx_inet_ntop(sa->sa_family, &si->sin_addr, addr,

                             MAX_IPADR_LEN);

    if(!result) {

      *port = ntohs(si->sin_port);

      return result;

    }

    break;

#ifdef USE_IPV6

  case AF_INET6:

    si6 = (struct sockaddr_in6 *)(void *)sa;

    result = curlx_inet_ntop(sa->sa_family, &si6->sin6_addr, addr,

                             MAX_IPADR_LEN);

    if(!result) {

      *port = ntohs(si6->sin6_port);

      return result;

    }

    break;

#endif

#ifdef USE_UNIX_SOCKETS

  case AF_UNIX:

    if(salen > (curl_socklen_t)sizeof(CURL_SA_FAMILY_T)) {

      su = (struct sockaddr_un *)sa;

      curl_msnprintf(addr, MAX_IPADR_LEN, "%s", su->sun_path);

    }

    else

      addr[0] = 0; /* socket with no name */

    *port = 0;

    return CURLE_OK;

#endif

  default:

    result = CURLE_UNSUPPORTED_PROTOCOL;

    break;

  }

  addr[0] = '\0';

  *port = 0;

  return result;

}

static void tcpnodelay(struct Curl_cfilter *cf,

                       struct Curl_easy *data,

                       curl_socket_t sockfd)

{

#if defined(TCP_NODELAY) && defined(CURL_TCP_NODELAY_SUPPORTED)

  curl_socklen_t onoff = (curl_socklen_t)1;

  int level = IPPROTO_TCP;

  VERBOSE(char buffer[STRERROR_LEN]);

  if(setsockopt(sockfd, level, TCP_NODELAY, (void *)&onoff, sizeof(onoff)) < 0)

    CURL_TRC_CF(data, cf, "Could not set TCP_NODELAY: %s",

                curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));

#else

  (void)cf;

  (void)data;

  (void)sockfd;

#endif

}

#if defined(USE_WINSOCK) || defined(TCP_KEEPIDLE) ||               \

  defined(TCP_KEEPALIVE) || defined(TCP_KEEPALIVE_THRESHOLD) ||    \

  defined(TCP_KEEPINTVL) || defined(TCP_KEEPALIVE_ABORT_THRESHOLD)

#if defined(USE_WINSOCK) || \

  (defined(__sun) && !defined(TCP_KEEPIDLE)) || \

  (defined(__DragonFly__) && __DragonFly_version < 500702) || \

  (defined(_WIN32) && !defined(TCP_KEEPIDLE))

/* Solaris < 11.4, DragonFlyBSD < 500702 and Windows < 10.0.16299

 * use millisecond units. */

#define KEEPALIVE_FACTOR(x) ((x) *= 1000)

#else

#define KEEPALIVE_FACTOR(x)

#endif

#endif

static void tcpkeepalive(struct Curl_cfilter *cf,

                         struct Curl_easy *data,

                         curl_socket_t sockfd)

{

  int optval = data->set.tcp_keepalive ? 1 : 0;

  /* only set IDLE and INTVL if setting KEEPALIVE is successful */

  if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,

                (void *)&optval, sizeof(optval)) < 0) {

    CURL_TRC_CF(data, cf, "Failed to set SO_KEEPALIVE on fd "

                "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

  }

  else {

#ifdef USE_WINSOCK

    /* Windows 10, version 1709 (10.0.16299) and later versions can use

       setsockopt() TCP_KEEP*. Older versions return with failure. */

    if(curlx_verify_windows_version(10, 0, 16299, PLATFORM_WINNT,

                                    VERSION_GREATER_THAN_EQUAL)) {

      CURL_TRC_CF(data, cf, "Set TCP_KEEP* on fd=%" FMT_SOCKET_T, sockfd);

      optval = curlx_sltosi(data->set.tcp_keepidle);

/* Offered by mingw-w64 v12+, MS SDK 6.0A/VS2008+ */

#ifndef TCP_KEEPALIVE

#define TCP_KEEPALIVE 3

#endif

/* Offered by mingw-w64 v12+, MS SDK 10.0.15063.0/VS2017 15.1+ */

#ifndef TCP_KEEPCNT

#define TCP_KEEPCNT 16

#endif

/* Offered by mingw-w64 v12+, MS SDK 10.0.16299.0/VS2017 15.4+ */

#ifndef TCP_KEEPIDLE

#define TCP_KEEPIDLE TCP_KEEPALIVE

#endif

#ifndef TCP_KEEPINTVL

#define TCP_KEEPINTVL 17

#endif

      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,

                    (const char *)&optval, sizeof(optval)) < 0) {

        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPIDLE on fd "

                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

      }

      optval = curlx_sltosi(data->set.tcp_keepintvl);

      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,

                    (const char *)&optval, sizeof(optval)) < 0) {

        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPINTVL on fd "

                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

      }

      optval = curlx_sltosi(data->set.tcp_keepcnt);

      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,

                    (const char *)&optval, sizeof(optval)) < 0) {

        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPCNT on fd "

                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

      }

    }

    else {

/* Offered by mingw-w64 and MS SDK. Latter only when targeting Win7+. */

#ifndef SIO_KEEPALIVE_VALS

#define SIO_KEEPALIVE_VALS  _WSAIOW(IOC_VENDOR, 4)

      struct tcp_keepalive {

        u_long onoff;

        u_long keepalivetime;

        u_long keepaliveinterval;

      };

#endif

      struct tcp_keepalive vals;

      DWORD dummy;

      vals.onoff = 1;

      optval = curlx_sltosi(data->set.tcp_keepidle);

      KEEPALIVE_FACTOR(optval);

      vals.keepalivetime = (u_long)optval;

      optval = curlx_sltosi(data->set.tcp_keepintvl);

      KEEPALIVE_FACTOR(optval);

      vals.keepaliveinterval = (u_long)optval;

      if(WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, (LPVOID)&vals, sizeof(vals),

                  NULL, 0, &dummy, NULL, NULL) != 0) {

        CURL_TRC_CF(data, cf, "Failed to set SIO_KEEPALIVE_VALS on fd "

                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

      }

    }

#else /* !USE_WINSOCK */

#ifdef TCP_KEEPIDLE

    optval = curlx_sltosi(data->set.tcp_keepidle);

    KEEPALIVE_FACTOR(optval);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPIDLE on fd "

                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#elif defined(TCP_KEEPALIVE)

    /* macOS style */

    optval = curlx_sltosi(data->set.tcp_keepidle);

    KEEPALIVE_FACTOR(optval);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE on fd "

                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#elif defined(TCP_KEEPALIVE_THRESHOLD)

    /* Solaris <11.4 style */

    optval = curlx_sltosi(data->set.tcp_keepidle);

    KEEPALIVE_FACTOR(optval);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE_THRESHOLD on fd "

                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#endif

#ifdef TCP_KEEPINTVL

    optval = curlx_sltosi(data->set.tcp_keepintvl);

    KEEPALIVE_FACTOR(optval);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPINTVL on fd "

                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#elif defined(TCP_KEEPALIVE_ABORT_THRESHOLD)

    /* Solaris <11.4 style */

    /* TCP_KEEPALIVE_ABORT_THRESHOLD should equal to

     * TCP_KEEPCNT * TCP_KEEPINTVL on other platforms.

     * The default value of TCP_KEEPCNT is 9 on Linux,

     * 8 on *BSD/macOS, 5 or 10 on Windows. We use the

     * default config for Solaris <11.4 because there is

     * no default value for TCP_KEEPCNT on Solaris 11.4.

     *

     * Note that the consequent probes will not be sent

     * at equal intervals on Solaris, but will be sent

     * using the exponential backoff algorithm. */

    {

      int keepcnt = curlx_sltosi(data->set.tcp_keepcnt);

      int keepintvl = curlx_sltosi(data->set.tcp_keepintvl);

      if(keepcnt > 0 && keepintvl > (INT_MAX / keepcnt))

        optval = INT_MAX;

      else

        optval = keepcnt * keepintvl;

    }

    KEEPALIVE_FACTOR(optval);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE_ABORT_THRESHOLD"

                  " on fd %" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#endif

#ifdef TCP_KEEPCNT

    optval = curlx_sltosi(data->set.tcp_keepcnt);

    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,

                  (void *)&optval, sizeof(optval)) < 0) {

      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPCNT on fd "

                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);

    }

#endif

#endif /* USE_WINSOCK */

  }

}

/**

 * Assign the addrinfo `ai` to the Curl_sockaddr_ex `addr` with

 * transport determining socktype and protocol.

 */

CURLcode Curl_socket_addr_from_ai(struct Curl_sockaddr_ex *addr,

                                  const struct Curl_addrinfo *ai,

                                  uint8_t transport)

{

  /*

   * The Curl_sockaddr_ex structure is libcurl's external API

   * curl_sockaddr structure with enough space available to directly hold

   * any protocol-specific address structures. The variable declared here

   * will be used to pass / receive data to/from the fopensocket callback

   * if this has been set, before that, it is initialized from parameters.

   */

  addr->family = ai->ai_family;

  addr->socktype = Curl_socktype_for_transport(transport);

  addr->protocol = Curl_protocol_for_transport(transport);

  addr->addrlen = (unsigned int)ai->ai_addrlen;

  DEBUGASSERT(addr->addrlen <= sizeof(addr->curl_sa_addrbuf));

  if(addr->addrlen > sizeof(addr->curl_sa_addrbuf))

    return CURLE_TOO_LARGE;

  memcpy(&addr->curl_sa_addrbuf, ai->ai_addr, addr->addrlen);

  return CURLE_OK;

}

#ifdef USE_SO_NOSIGPIPE

int Curl_sock_nosigpipe(curl_socket_t sockfd)

{

  int onoff = 1;

  return setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE,

                    (void *)&onoff, sizeof(onoff));

}

#endif /* USE_SO_NOSIGPIPE */

#if defined(USE_IPV6) && defined(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)

static uint32_t get_scope_id(struct Curl_easy *data,

                             struct sockaddr_in6 *sa6)

{

  uint32_t scope_id = 0;

  if(data->conn->scope_id)

    return data->conn->scope_id;

  /* NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign) */

  scope_id = sa6->sin6_scope_id;

  if(!scope_id && IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr)) {

    /* The resolver did not set scope_id for this link-local address.

     * Try to determine it from the system's network interfaces.

     * Without a scope_id, connect() to a link-local address fails

     * with EINVAL on Linux.

     * NOTE: On multi-homed hosts with several interfaces having

     * link-local addresses, this picks the first one found, which

     * may not be the correct outgoing interface. */

#if defined(HAVE_GETIFADDRS) && defined(HAVE_NET_IF_H)

    struct ifaddrs *ifa, *ifa_list;

    if(getifaddrs(&ifa_list) == 0) {

      for(ifa = ifa_list; ifa; ifa = ifa->ifa_next) {

        if(ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET6 &&

           (ifa->ifa_flags & IFF_UP) &&

           !(ifa->ifa_flags & IFF_LOOPBACK)) {

          struct sockaddr_in6 *s6 = (void *)ifa->ifa_addr;

          if(IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr) && s6->sin6_scope_id) {

            scope_id = s6->sin6_scope_id;

            infof(data,

                  "determined scope_id=%lu for link-local address "

                  "from local interface",

                  (unsigned long)scope_id);

            break;

          }

        }

      }

      freeifaddrs(ifa_list);

    }

#endif /* HAVE_GETIFADDRS && HAVE_NET_IF_H */

  }

  return scope_id;

}

#endif

static CURLcode socket_open(struct Curl_easy *data,

                            struct Curl_sockaddr_ex *addr,

                            curl_socket_t *sockfd)

{

  char errbuf[STRERROR_LEN];

#ifdef SOCK_CLOEXEC

  addr->socktype |= SOCK_CLOEXEC;

#endif

  DEBUGASSERT(data);

  DEBUGASSERT(data->conn);

  if(data->set.fopensocket) {

    /*

     * If the opensocket callback is set, all the destination address

     * information is passed to the callback. Depending on this information the

     * callback may opt to abort the connection, this is indicated returning

     * CURL_SOCKET_BAD; otherwise it will return a not-connected socket. When

     * the callback returns a valid socket the destination address information

     * might have been changed and this 'new' address will actually be used

     * here to connect.

     */

    struct Curl_mapi_guard guard;

    CURL_CBAPI_START(&guard, data, easy_fopensocket);

    *sockfd = data->set.fopensocket(data->set.opensocket_client,

                                    CURLSOCKTYPE_IPCXN,

                                    (struct curl_sockaddr *)addr);

    CURL_CBAPI_END(&guard);

  }

  else {

    /* opensocket callback not set, so create the socket now */

#ifdef DEBUGBUILD

    if((addr->family == AF_INET6) && getenv("CURL_DBG_SOCK_FAIL_IPV6")) {

      failf(data, "CURL_DBG_SOCK_FAIL_IPV6: failed to open socket");

      return CURLE_COULDNT_CONNECT;

    }

#endif

    *sockfd = CURL_SOCKET(addr->family, addr->socktype, addr->protocol);

    if((*sockfd == CURL_SOCKET_BAD) && (SOCKERRNO == SOCKENOMEM))

      return CURLE_OUT_OF_MEMORY;

  }

  if(*sockfd == CURL_SOCKET_BAD) {

    /* no socket, no connection */

    failf(data, "failed to open socket: %s",

          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));

    return CURLE_COULDNT_CONNECT;

  }

#ifdef USE_SO_NOSIGPIPE

  if(Curl_sock_nosigpipe(*sockfd) < 0) {

    failf(data, "setsockopt enable SO_NOSIGPIPE: %s",

          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));

    sclose(*sockfd);

    *sockfd = CURL_SOCKET_BAD;

    return CURLE_COULDNT_CONNECT;

  }

#endif /* USE_SO_NOSIGPIPE */

#if defined(HAVE_FCNTL) && !defined(SOCK_CLOEXEC)

  if(fcntl(*sockfd, F_SETFD, FD_CLOEXEC) < 0) {

    failf(data, "fcntl set CLOEXEC: %s",

          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));

    sclose(*sockfd);

    *sockfd = CURL_SOCKET_BAD;

    return CURLE_COULDNT_CONNECT;

  }

#endif

#if defined(USE_IPV6) && defined(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)

  if(addr->family == AF_INET6) {

    struct sockaddr_in6 * const sa6 = (void *)&addr->curl_sa_addr;

    sa6->sin6_scope_id = get_scope_id(data, sa6);

  }

#endif

  return CURLE_OK;

}

/*

 * Create a socket based on info from 'conn' and 'ai'.

 *

 * 'addr' should be a pointer to the correct struct to get data back, or NULL.

 * 'sockfd' must be a pointer to a socket descriptor.

 *

 * If the open socket callback is set, used that!

 *

 */

CURLcode Curl_socket_open(struct Curl_easy *data,

                          const struct Curl_addrinfo *ai,

                          struct Curl_sockaddr_ex *addr,

                          uint8_t transport,

                          curl_socket_t *sockfd)

{

  struct Curl_sockaddr_ex dummy;

  CURLcode result;

  if(!addr)

    /* if the caller does not want info back, use a local temp copy */

    addr = &dummy;

  result = Curl_socket_addr_from_ai(addr, ai, transport);

  if(result)

    return result;

  return socket_open(data, addr, sockfd);

}

static int socket_close(struct Curl_easy *data, struct connectdata *conn,

                        int use_callback, curl_socket_t sock)

{

  if(sock == CURL_SOCKET_BAD)

    return 0;

  if(use_callback && conn && conn->fclosesocket) {

    struct Curl_mapi_guard guard;

    int rc;

    Curl_multi_will_close(data, sock);

    CURL_CBAPI_START(&guard, data, easy_closesocket);

    rc = conn->fclosesocket(conn->closesocket_client, sock);

    CURL_CBAPI_END(&guard);

    return rc;

  }

  if(conn)

    /* tell the multi-socket code about this */

    Curl_multi_will_close(data, sock);

  sclose(sock);

  return 0;

}

/*

 * Close a socket.

 *

 * 'conn' can be NULL, beware!

 */

int Curl_socket_close(struct Curl_easy *data, struct connectdata *conn,

                      curl_socket_t sock)

{

  return socket_close(data, conn, FALSE, sock);

}

/*

 * Curl_parse_interface()

 *

 * This is used to parse interface argument in the following formats.

 * In all the examples, `host` can be an IP address or a hostname.

 *

 *   <iface_or_host> - can be either an interface name or a host.

 *   if!<iface> - interface name.

 *   host!<host> - hostname.

 *   ifhost!<iface>!<host> - interface name and hostname.

 *

 * Parameters:

 *

 * input  [in]     - input string.

 * len    [in]     - length of the input string.

 * dev    [in/out] - address where a pointer to newly allocated memory

 *                   holding the interface-or-host will be stored upon

 *                   completion.

 * iface  [in/out] - address where a pointer to newly allocated memory

 *                   holding the interface will be stored upon completion.

 * host   [in/out] - address where a pointer to newly allocated memory

 *                   holding the host will be stored upon completion.

 *

 * Returns CURLE_OK on success.

 */

CURLcode Curl_parse_interface(const char *input,

                              char **dev, char **iface, char **host)

{

  static const char if_prefix[] = "if!";

  static const char host_prefix[] = "host!";

  static const char if_host_prefix[] = "ifhost!";

  size_t len;

  DEBUGASSERT(dev);

  DEBUGASSERT(iface);

  DEBUGASSERT(host);

  len = strlen(input);

  if(len > 512)

    return CURLE_BAD_FUNCTION_ARGUMENT;

  if(!strncmp(if_prefix, input, strlen(if_prefix))) {

    input += strlen(if_prefix);

    if(!*input)

      return CURLE_BAD_FUNCTION_ARGUMENT;

    *iface = curlx_memdup0(input, len - strlen(if_prefix));

    return *iface ? CURLE_OK : CURLE_OUT_OF_MEMORY;

  }

  else if(!strncmp(host_prefix, input, strlen(host_prefix))) {

    input += strlen(host_prefix);

    if(!*input)

      return CURLE_BAD_FUNCTION_ARGUMENT;

    *host = curlx_memdup0(input, len - strlen(host_prefix));

    return *host ? CURLE_OK : CURLE_OUT_OF_MEMORY;

  }

  else if(!strncmp(if_host_prefix, input, strlen(if_host_prefix))) {

    const char *host_part;

    input += strlen(if_host_prefix);

    len -= strlen(if_host_prefix);

    host_part = memchr(input, '!', len);

    if(!host_part || !*(host_part + 1))

      return CURLE_BAD_FUNCTION_ARGUMENT;

    *iface = curlx_memdup0(input, host_part - input);

    if(!*iface)

      return CURLE_OUT_OF_MEMORY;

    ++host_part;

    *host = curlx_memdup0(host_part, len - (host_part - input));

    if(!*host) {

      curlx_safefree(*iface);

      return CURLE_OUT_OF_MEMORY;

    }

    return CURLE_OK;

  }

  if(!*input)

    return CURLE_BAD_FUNCTION_ARGUMENT;

  *dev = curlx_memdup0(input, len);

  return *dev ? CURLE_OK : CURLE_OUT_OF_MEMORY;

}

#ifndef CURL_DISABLE_BINDLOCAL

static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,

                          curl_socket_t sockfd, int af, unsigned int scope,

                          uint8_t transport)

{

  struct Curl_sockaddr_storage sa;

  struct sockaddr *sock = (struct sockaddr *)&sa;  /* bind to this address */

  curl_socklen_t sizeof_sa = 0; /* size of the data sock points to */

  struct sockaddr_in *si4 = (struct sockaddr_in *)&sa;

#ifdef USE_IPV6

  struct sockaddr_in6 *si6 = (struct sockaddr_in6 *)&sa;

#endif

  struct Curl_dns_entry *h = NULL;

  unsigned short port = data->set.localport; /* use this port number, 0 for

                                                "random" */

  /* how many port numbers to try to bind to, increasing one at a time */

  int portnum = data->set.localportrange;

  const char *dev = CURL_EASY_STR(data, STRING_DEVICE);

  const char *iface_input = CURL_EASY_STR(data, STRING_INTERFACE);

  const char *host_input = CURL_EASY_STR(data, STRING_BINDHOST);

  const char *iface = iface_input ? iface_input : dev;

  const char *host = host_input ? host_input : dev;

  int sockerr;

#ifdef IP_BIND_ADDRESS_NO_PORT

  int on = 1;

#endif

#ifndef USE_IPV6

  (void)scope;

#endif

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

   * Select device to bind socket to

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

  if(!iface && !host && !port)

    /* no local kind of binding was requested */

    return CURLE_OK;

  else if(iface && (strlen(iface) >= 255))

    return CURLE_BAD_FUNCTION_ARGUMENT;

  memset(&sa, 0, sizeof(struct Curl_sockaddr_storage));

  if(iface || host) {

    char myhost[256] = "";

    int done = 0; /* -1 for error, 1 for address found */

    if2ip_result_t if2ip_result = IF2IP_NOT_FOUND;

#ifdef SO_BINDTODEVICE

    if(iface) {

      /*

       * This binds the local socket to a particular interface. This will

       * force even requests to other local interfaces to go out the external

       * interface. Only bind to the interface when specified as interface,

       * not as a hostname or ip address.

       *

       * The interface might be a VRF, eg: vrf-blue, which means it cannot be

       * converted to an IP address and would fail Curl_if2ip. Try to

       * use it straight away.

       */

      if(setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE,

                    iface, (curl_socklen_t)strlen(iface) + 1) == 0) {

        /* This is often "errno 1, error: Operation not permitted" if you are

         * not running as root or another suitable privileged user. If it

         * succeeds it means the parameter was a valid interface and not an IP

         * address. Return immediately.

         */

        if(!host_input) {

          infof(data, "socket successfully bound to interface '%s'", iface);

          return CURLE_OK;

        }

      }

    }

#endif

    if(!host_input) {

      /* Discover IP from input device, then bind to it */

      if2ip_result = Curl_if2ip(af,

#ifdef USE_IPV6

                                scope, conn->scope_id,

#endif

                                iface, myhost, sizeof(myhost));

    }

    switch(if2ip_result) {

    case IF2IP_NOT_FOUND:

      if(iface_input && !host_input) {

        /* Do not fall back to treating it as a hostname */

        char buffer[STRERROR_LEN];

        data->state.os_errno = sockerr = SOCKERRNO;

        failf(data, "Could not bind to interface '%s' with errno %d: %s",

              iface, sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));

        return CURLE_INTERFACE_FAILED;

      }

      break;

    case IF2IP_AF_NOT_SUPPORTED:

      /* Signal the caller to try another address family if available */

      return CURLE_UNSUPPORTED_PROTOCOL;

    case IF2IP_FOUND:

      /*

       * We now have the numerical IP address in the 'myhost' buffer

       */

      host = myhost;

      infof(data, "Local Interface %s is ip %s using address family %d",

            iface, host, af);

      done = 1;

      break;

    }

    if(!iface_input || host_input) {

      /*

       * This was not an interface, resolve the name as a hostname

       * or IP number

       *

       * Temporarily force name resolution to use only the address type

       * of the connection. The resolve functions should really be changed

       * to take a type parameter instead.

       */

      uint8_t dns_queries = (af == AF_INET) ?

                            CURL_DNSQ_A : (CURL_DNSQ_A | CURL_DNSQ_AAAA);

#ifdef USE_IPV6

      if(af == AF_INET6)

        dns_queries = CURL_DNSQ_AAAA;

#endif

      (void)Curl_resolv_blocking(data, dns_queries, host, 80, transport, &h);

      if(h) {

        int h_af = h->addr->ai_family;

        /* convert the resolved address, sizeof myhost >= INET_ADDRSTRLEN */

        Curl_printable_address(h->addr, myhost, sizeof(myhost));

        infof(data, "Name '%s' family %d resolved to '%s' family %d",

              host, af, myhost, h_af);

        Curl_dns_entry_unlink(data, &h); /* this will NULL, potential free h */

        if(af != h_af) {

          /* bad IP version combo, signal the caller to try another address

             family if available */

          return CURLE_UNSUPPORTED_PROTOCOL;

        }

        done = 1;

      }

      else {

        /*

         * provided dev was no interface (or interfaces are not supported

         * e.g. Solaris) no ip address and no domain we fail here

         */

        done = -1;

      }

    }

    if(done > 0) {

#ifdef USE_IPV6

      /* IPv6 address */

      if(af == AF_INET6) {

#ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID

        char *scope_ptr = strchr(myhost, '%');

        if(scope_ptr)

          *(scope_ptr++) = '\0';

#endif

        if(curlx_inet_pton(AF_INET6, myhost, &si6->sin6_addr) > 0) {

          si6->sin6_family = AF_INET6;

          si6->sin6_port = htons(port);

#ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID

          if(scope_ptr) {

            /* The "myhost" string either comes from Curl_if2ip or from

               Curl_printable_address. The latter returns only numeric scope

               IDs and the former returns none at all. Making the scope ID,

               if present, known to be numeric */

            curl_off_t scope_id;

            if(curlx_str_number((const char **)CURL_UNCONST(&scope_ptr),

                                &scope_id, UINT_MAX))

              return CURLE_UNSUPPORTED_PROTOCOL;

            si6->sin6_scope_id = (unsigned int)scope_id;

          }

#endif

        }

        sizeof_sa = sizeof(struct sockaddr_in6);

      }

      else

#endif

      /* IPv4 address */

      if((af == AF_INET) &&

         (curlx_inet_pton(AF_INET, myhost, &si4->sin_addr) > 0)) {

        si4->sin_family = AF_INET;

        si4->sin_port = htons(port);

        sizeof_sa = sizeof(struct sockaddr_in);

      }

    }

    if(done < 1) {

      /* errorbuf is set false so failf will overwrite any message already in

         the error buffer, so the user receives this error message instead of a

         generic resolve error. */

      char buffer[STRERROR_LEN];

      data->state.errorbuf = FALSE;

      data->state.os_errno = sockerr = SOCKERRNO;

      failf(data, "Could not bind to '%s' with errno %d: %s", host,

            sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));

      return CURLE_INTERFACE_FAILED;

    }

  }

  else {

    /* no device was given, prepare sa to match af's needs */

#ifdef USE_IPV6

    if(af == AF_INET6) {

      si6->sin6_family = AF_INET6;

      si6->sin6_port = htons(port);

      sizeof_sa = sizeof(struct sockaddr_in6);

    }

    else

#endif

    if(af == AF_INET) {

      si4->sin_family = AF_INET;

      si4->sin_port = htons(port);

      sizeof_sa = sizeof(struct sockaddr_in);

    }

  }

#ifdef IP_BIND_ADDRESS_NO_PORT

  (void)setsockopt(sockfd, SOL_IP, IP_BIND_ADDRESS_NO_PORT, &on, sizeof(on));

#endif

  for(;;) {

    if(bind(sockfd, sock, sizeof_sa) >= 0) {

      /* we succeeded to bind */

      infof(data, "Local port: %hu", port);

      conn->bits.bound = TRUE;

      return CURLE_OK;

    }

    if(--portnum > 0) {

      port++; /* try next port */

      if(port == 0)

        break;

      infof(data, "Bind to local port %d failed, trying next", port - 1);

      /* We reuse/clobber the port variable here below */

      if(sock->sa_family == AF_INET)

        si4->sin_port = htons(port);

#ifdef USE_IPV6

      else

        si6->sin6_port = htons(port);

#endif

    }

    else

      break;

  }

  {

    char buffer[STRERROR_LEN];

    data->state.os_errno = sockerr = SOCKERRNO;

    failf(data, "bind failed with errno %d: %s",

          sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));

  }

  return CURLE_INTERFACE_FAILED;

}

#endif

/*

 * verifyconnect() returns TRUE if the connect really has happened.

 */

static bool verifyconnect(curl_socket_t sockfd, int *psockerr)

{

  bool rc = TRUE;

#ifdef SO_ERROR

  int sockerr = 0;

  curl_socklen_t errSize = sizeof(sockerr);

#ifdef _WIN32

  /*

   * In October 2003 we effectively nullified this function on Windows due to

   * problems with it using all CPU in multi-threaded cases.

   *

   * In May 2004, we brought it back to offer more info back on connect

   * failures. We could reproduce the former problems with this function, but

   * could avoid them by adding this SleepEx() call below:

   *

   *    "I do not have Rational Quantify, but the hint from his post was

   *    ntdll::NtRemoveIoCompletion(). I would assume the SleepEx (or maybe

   *    Sleep(0) would be enough?) would release whatever

   *    mutex/critical-section the ntdll call is waiting on.

   *

   *    Someone got to verify this on Win-NT 4.0, 2000."

   */

  SleepEx(0, FALSE);

#endif

  if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&sockerr, &errSize))

    sockerr = SOCKERRNO;

#if defined(EBADIOCTL) && defined(__minix)

  /* Minix 3.1.x does not support getsockopt on UDP sockets */

  if(EBADIOCTL == sockerr) {

    SET_SOCKERRNO(0);

    sockerr = 0;

  }

#endif

  if((sockerr == 0) || (SOCKEISCONN == sockerr))

    /* we are connected, awesome! */

    rc = TRUE;

  else

    /* This was not a successful connect */

    rc = FALSE;

  if(psockerr)

    *psockerr = sockerr;

#else

  (void)sockfd;

  if(psockerr)

    *psockerr = SOCKERRNO;

#endif

  return rc;

}

/**

 * Determine the curl code for a socket connect() == -1 with errno.

 */

static CURLcode socket_connect_result(struct Curl_easy *data,

                                      const char *ipaddress, int sockerr)

{

  if(sockerr == SOCKEINPROGRESS || SOCK_EAGAIN(sockerr))

    return CURLE_OK;

  /* unknown error, fallthrough and try another address! */

  {

    VERBOSE(char buffer[STRERROR_LEN]);

    infof(data, "Immediate connect fail for %s: %s", ipaddress,

          curlx_strerror(sockerr, buffer, sizeof(buffer)));

    NOVERBOSE((void)ipaddress);

  }

  data->state.os_errno = sockerr;

  /* connect failed */

  return CURLE_COULDNT_CONNECT;

}

struct cf_socket_ctx {

  struct Curl_peer *peer;

  struct Curl_sockaddr_ex addr;      /* address to connect to */

  curl_socket_t sock;                /* current attempt socket */

  struct ip_quadruple ip;            /* The IP quadruple 2x(addr+port) */

  struct curltime started_at;        /* when socket was created */

  struct curltime connected_at;      /* when socket connected/got first byte */

  struct curltime first_byte_at;     /* when first byte was recvd */

#ifdef USE_WINSOCK

  struct curltime last_sndbuf_query_at;  /* when SO_SNDBUF last queried */

  ULONG sndbuf_size;                     /* the last set SO_SNDBUF size */

#endif

  int sockerr;                       /* socket error of last failure or 0 */

#ifdef DEBUGBUILD

  int wblock_percent;                /* percent of writes doing EAGAIN */

  int wpartial_percent;              /* percent of bytes written in send */

  int rblock_percent;                /* percent of reads doing EAGAIN */

  size_t recv_max;                   /* max enforced read size */

#endif

  uint8_t transport;

  BIT(got_first_byte);               /* if first byte was received */

  BIT(listening);                    /* socket is listening */

  BIT(accepted);                     /* socket was accepted, not connected */

  BIT(sock_connected);               /* socket is "connected", e.g. in UDP */

  BIT(active);

  BIT(stats_reported);

};

static CURLcode cf_socket_ctx_init(struct cf_socket_ctx *ctx,

                                   struct Curl_peer *peer,

                                   struct Curl_sockaddr_ex *addr,

                                   uint8_t transport)

{

  memset(ctx, 0, sizeof(*ctx));

  Curl_peer_link(&ctx->peer, peer);

  ctx->sock = CURL_SOCKET_BAD;

  ctx->transport = transport;

  ctx->addr = *addr;

#ifdef DEBUGBUILD

  {

    const char *p = getenv("CURL_DBG_SOCK_WBLOCK");

    if(p) {

      curl_off_t l;

      if(!curlx_str_number(&p, &l, 100))

        ctx->wblock_percent = (int)l;

    }