luna - curl/lib/cf-socket.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26#ifdef HAVE_NETINET_IN_H
  27#include <netinet/in.h> /* <netinet/tcp.h> may need it */
  28#endif
  29#ifdef HAVE_LINUX_TCP_H
  30#include <linux/tcp.h>
  31#elif defined(HAVE_NETINET_TCP_H)
  32#include <netinet/tcp.h>
  33#endif
  34#ifdef HAVE_NETINET_UDP_H
  35#include <netinet/udp.h>
  36#endif
  37#ifdef HAVE_SYS_IOCTL_H
  38#include <sys/ioctl.h>
  39#endif
  40#ifdef HAVE_NETDB_H
  41#include <netdb.h>
  42#endif
  43#ifdef HAVE_ARPA_INET_H
  44#include <arpa/inet.h>
  45#endif
  46
  47#ifdef __VMS
  48#include <in.h>
  49#include <inet.h>
  50#endif
  51
  52#include "urldata.h"
  53#include "curl_trc.h"
  54#include "if2ip.h"
  55#include "cfilters.h"
  56#include "cf-socket.h"
  57#include "connect.h"
  58#include "curl_addrinfo.h"
  59#include "select.h"
  60#include "multiif.h"
  61#include "curlx/inet_pton.h"
  62#include "progress.h"
  63#include "conncache.h"
  64#include "multihandle.h"
  65#include "rand.h"
  66#include "curlx/strdup.h"
  67#include "system_win32.h"
  68#include "curlx/nonblock.h"
  69#include "curlx/strcopy.h"
  70#include "curlx/version_win32.h"
  71#include "curlx/strerr.h"
  72#include "curlx/strparse.h"
  73
  74
  75static void tcpnodelay(struct Curl_cfilter *cf,
  76                       struct Curl_easy *data,
  77                       curl_socket_t sockfd)
  78{
  79#if defined(TCP_NODELAY) && defined(CURL_TCP_NODELAY_SUPPORTED)
  80  curl_socklen_t onoff = (curl_socklen_t)1;
  81  int level = IPPROTO_TCP;
  82  VERBOSE(char buffer[STRERROR_LEN]);
  83
  84  if(setsockopt(sockfd, level, TCP_NODELAY,
  85                (void *)&onoff, sizeof(onoff)) < 0)
  86    CURL_TRC_CF(data, cf, "Could not set TCP_NODELAY: %s",
  87                curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
  88#else
  89  (void)cf;
  90  (void)data;
  91  (void)sockfd;
  92#endif
  93}
  94
  95#if defined(USE_WINSOCK) || defined(TCP_KEEPIDLE) || \
  96  defined(TCP_KEEPALIVE) || defined(TCP_KEEPALIVE_THRESHOLD) || \
  97  defined(TCP_KEEPINTVL) || defined(TCP_KEEPALIVE_ABORT_THRESHOLD)
  98#if defined(USE_WINSOCK) || \
  99  (defined(__sun) && !defined(TCP_KEEPIDLE)) || \
 100  (defined(__DragonFly__) && __DragonFly_version < 500702) || \
 101  (defined(_WIN32) && !defined(TCP_KEEPIDLE))
 102/* Solaris < 11.4, DragonFlyBSD < 500702 and Windows < 10.0.16299
 103 * use millisecond units. */
 104#define KEEPALIVE_FACTOR(x) ((x) *= 1000)
 105#else
 106#define KEEPALIVE_FACTOR(x)
 107#endif
 108#endif
 109
 110static void tcpkeepalive(struct Curl_cfilter *cf,
 111                         struct Curl_easy *data,
 112                         curl_socket_t sockfd)
 113{
 114  int optval = data->set.tcp_keepalive ? 1 : 0;
 115
 116  /* only set IDLE and INTVL if setting KEEPALIVE is successful */
 117  if(setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE,
 118                (void *)&optval, sizeof(optval)) < 0) {
 119    CURL_TRC_CF(data, cf, "Failed to set SO_KEEPALIVE on fd "
 120                "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 121  }
 122  else {
 123#ifdef USE_WINSOCK
 124    /* Windows 10, version 1709 (10.0.16299) and later versions can use
 125       setsockopt() TCP_KEEP*. Older versions return with failure. */
 126    if(curlx_verify_windows_version(10, 0, 16299, PLATFORM_WINNT,
 127                                    VERSION_GREATER_THAN_EQUAL)) {
 128      CURL_TRC_CF(data, cf, "Set TCP_KEEP* on fd=%" FMT_SOCKET_T, sockfd);
 129      optval = curlx_sltosi(data->set.tcp_keepidle);
 130/* Offered by mingw-w64 v12+, MS SDK 6.0A/VS2008+ */
 131#ifndef TCP_KEEPALIVE
 132#define TCP_KEEPALIVE 3
 133#endif
 134/* Offered by mingw-w64 v12+, MS SDK 10.0.15063.0/VS2017 15.1+ */
 135#ifndef TCP_KEEPCNT
 136#define TCP_KEEPCNT 16
 137#endif
 138/* Offered by mingw-w64 v12+, MS SDK 10.0.16299.0/VS2017 15.4+ */
 139#ifndef TCP_KEEPIDLE
 140#define TCP_KEEPIDLE TCP_KEEPALIVE
 141#endif
 142#ifndef TCP_KEEPINTVL
 143#define TCP_KEEPINTVL 17
 144#endif
 145      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
 146                    (const char *)&optval, sizeof(optval)) < 0) {
 147        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPIDLE on fd "
 148                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 149      }
 150      optval = curlx_sltosi(data->set.tcp_keepintvl);
 151      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,
 152                    (const char *)&optval, sizeof(optval)) < 0) {
 153        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPINTVL on fd "
 154                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 155      }
 156      optval = curlx_sltosi(data->set.tcp_keepcnt);
 157      if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,
 158                    (const char *)&optval, sizeof(optval)) < 0) {
 159        CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPCNT on fd "
 160                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 161      }
 162    }
 163    else {
 164/* Offered by mingw-w64 and MS SDK. Latter only when targeting Win7+. */
 165#ifndef SIO_KEEPALIVE_VALS
 166#define SIO_KEEPALIVE_VALS  _WSAIOW(IOC_VENDOR, 4)
 167      struct tcp_keepalive {
 168        u_long onoff;
 169        u_long keepalivetime;
 170        u_long keepaliveinterval;
 171      };
 172#endif
 173      struct tcp_keepalive vals;
 174      DWORD dummy;
 175      vals.onoff = 1;
 176      optval = curlx_sltosi(data->set.tcp_keepidle);
 177      KEEPALIVE_FACTOR(optval);
 178      vals.keepalivetime = (u_long)optval;
 179      optval = curlx_sltosi(data->set.tcp_keepintvl);
 180      KEEPALIVE_FACTOR(optval);
 181      vals.keepaliveinterval = (u_long)optval;
 182      if(WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, (LPVOID)&vals, sizeof(vals),
 183                  NULL, 0, &dummy, NULL, NULL) != 0) {
 184        CURL_TRC_CF(data, cf, "Failed to set SIO_KEEPALIVE_VALS on fd "
 185                    "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 186      }
 187    }
 188#else /* !USE_WINSOCK */
 189#ifdef TCP_KEEPIDLE
 190    optval = curlx_sltosi(data->set.tcp_keepidle);
 191    KEEPALIVE_FACTOR(optval);
 192    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
 193                  (void *)&optval, sizeof(optval)) < 0) {
 194      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPIDLE on fd "
 195                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 196    }
 197#elif defined(TCP_KEEPALIVE)
 198    /* macOS style */
 199    optval = curlx_sltosi(data->set.tcp_keepidle);
 200    KEEPALIVE_FACTOR(optval);
 201    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE,
 202                  (void *)&optval, sizeof(optval)) < 0) {
 203      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE on fd "
 204                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 205    }
 206#elif defined(TCP_KEEPALIVE_THRESHOLD)
 207    /* Solaris <11.4 style */
 208    optval = curlx_sltosi(data->set.tcp_keepidle);
 209    KEEPALIVE_FACTOR(optval);
 210    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD,
 211                  (void *)&optval, sizeof(optval)) < 0) {
 212      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE_THRESHOLD on fd "
 213                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 214    }
 215#endif
 216#ifdef TCP_KEEPINTVL
 217    optval = curlx_sltosi(data->set.tcp_keepintvl);
 218    KEEPALIVE_FACTOR(optval);
 219    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,
 220                  (void *)&optval, sizeof(optval)) < 0) {
 221      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPINTVL on fd "
 222                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 223    }
 224#elif defined(TCP_KEEPALIVE_ABORT_THRESHOLD)
 225    /* Solaris <11.4 style */
 226    /* TCP_KEEPALIVE_ABORT_THRESHOLD should equal to
 227     * TCP_KEEPCNT * TCP_KEEPINTVL on other platforms.
 228     * The default value of TCP_KEEPCNT is 9 on Linux,
 229     * 8 on *BSD/macOS, 5 or 10 on Windows. We use the
 230     * default config for Solaris <11.4 because there is
 231     * no default value for TCP_KEEPCNT on Solaris 11.4.
 232     *
 233     * Note that the consequent probes will not be sent
 234     * at equal intervals on Solaris, but will be sent
 235     * using the exponential backoff algorithm. */
 236    {
 237      int keepcnt = curlx_sltosi(data->set.tcp_keepcnt);
 238      int keepintvl = curlx_sltosi(data->set.tcp_keepintvl);
 239
 240      if(keepcnt > 0 && keepintvl > (INT_MAX / keepcnt))
 241        optval = INT_MAX;
 242      else
 243        optval = keepcnt * keepintvl;
 244    }
 245    KEEPALIVE_FACTOR(optval);
 246    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD,
 247                  (void *)&optval, sizeof(optval)) < 0) {
 248      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPALIVE_ABORT_THRESHOLD"
 249                  " on fd %" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 250    }
 251#endif
 252#ifdef TCP_KEEPCNT
 253    optval = curlx_sltosi(data->set.tcp_keepcnt);
 254    if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT,
 255                  (void *)&optval, sizeof(optval)) < 0) {
 256      CURL_TRC_CF(data, cf, "Failed to set TCP_KEEPCNT on fd "
 257                  "%" FMT_SOCKET_T ": errno %d", sockfd, SOCKERRNO);
 258    }
 259#endif
 260#endif /* USE_WINSOCK */
 261  }
 262}
 263
 264/**
 265 * Assign the addrinfo `ai` to the Curl_sockaddr_ex `addr` with
 266 * transport determining socktype and protocol.
 267 */
 268CURLcode Curl_socket_addr_from_ai(struct Curl_sockaddr_ex *addr,
 269                                  const struct Curl_addrinfo *ai,
 270                                  uint8_t transport)
 271{
 272  /*
 273   * The Curl_sockaddr_ex structure is libcurl's external API
 274   * curl_sockaddr structure with enough space available to directly hold
 275   * any protocol-specific address structures. The variable declared here
 276   * will be used to pass / receive data to/from the fopensocket callback
 277   * if this has been set, before that, it is initialized from parameters.
 278   */
 279  addr->family = ai->ai_family;
 280  addr->socktype = Curl_socktype_for_transport(transport);
 281  addr->protocol = Curl_protocol_for_transport(transport);
 282  addr->addrlen = (unsigned int)ai->ai_addrlen;
 283
 284  DEBUGASSERT(addr->addrlen <= sizeof(addr->curl_sa_addrbuf));
 285  if(addr->addrlen > sizeof(addr->curl_sa_addrbuf))
 286    return CURLE_TOO_LARGE;
 287
 288  memcpy(&addr->curl_sa_addrbuf, ai->ai_addr, addr->addrlen);
 289  return CURLE_OK;
 290}
 291
 292#ifdef USE_SO_NOSIGPIPE
 293int Curl_sock_nosigpipe(curl_socket_t sockfd)
 294{
 295  int onoff = 1;
 296  return setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE,
 297                    (void *)&onoff, sizeof(onoff));
 298}
 299#endif /* USE_SO_NOSIGPIPE */
 300
 301static CURLcode socket_open(struct Curl_easy *data,
 302                            struct Curl_sockaddr_ex *addr,
 303                            curl_socket_t *sockfd)
 304{
 305  char errbuf[STRERROR_LEN];
 306
 307#ifdef SOCK_CLOEXEC
 308  addr->socktype |= SOCK_CLOEXEC;
 309#endif
 310
 311  DEBUGASSERT(data);
 312  DEBUGASSERT(data->conn);
 313  if(data->set.fopensocket) {
 314    /*
 315     * If the opensocket callback is set, all the destination address
 316     * information is passed to the callback. Depending on this information the
 317     * callback may opt to abort the connection, this is indicated returning
 318     * CURL_SOCKET_BAD; otherwise it will return a not-connected socket. When
 319     * the callback returns a valid socket the destination address information
 320     * might have been changed and this 'new' address will actually be used
 321     * here to connect.
 322     */
 323    Curl_set_in_callback(data, TRUE);
 324    *sockfd = data->set.fopensocket(data->set.opensocket_client,
 325                                    CURLSOCKTYPE_IPCXN,
 326                                    (struct curl_sockaddr *)addr);
 327    Curl_set_in_callback(data, FALSE);
 328  }
 329  else {
 330    /* opensocket callback not set, so create the socket now */
 331#ifdef DEBUGBUILD
 332    if((addr->family == AF_INET6) && getenv("CURL_DBG_SOCK_FAIL_IPV6")) {
 333      failf(data, "CURL_DBG_SOCK_FAIL_IPV6: failed to open socket");
 334      return CURLE_COULDNT_CONNECT;
 335    }
 336#endif
 337    *sockfd = CURL_SOCKET(addr->family, addr->socktype, addr->protocol);
 338    if((*sockfd == CURL_SOCKET_BAD) && (SOCKERRNO == SOCKENOMEM))
 339      return CURLE_OUT_OF_MEMORY;
 340  }
 341
 342  if(*sockfd == CURL_SOCKET_BAD) {
 343    /* no socket, no connection */
 344    failf(data, "failed to open socket: %s",
 345          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
 346    return CURLE_COULDNT_CONNECT;
 347  }
 348
 349#ifdef USE_SO_NOSIGPIPE
 350  if(Curl_sock_nosigpipe(*sockfd) < 0) {
 351    failf(data, "setsockopt enable SO_NOSIGPIPE: %s",
 352          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
 353    sclose(*sockfd);
 354    *sockfd = CURL_SOCKET_BAD;
 355    return CURLE_COULDNT_CONNECT;
 356  }
 357#endif /* USE_SO_NOSIGPIPE */
 358
 359#if defined(HAVE_FCNTL) && !defined(SOCK_CLOEXEC)
 360  if(fcntl(*sockfd, F_SETFD, FD_CLOEXEC) < 0) {
 361    failf(data, "fcntl set CLOEXEC: %s",
 362          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
 363    sclose(*sockfd);
 364    *sockfd = CURL_SOCKET_BAD;
 365    return CURLE_COULDNT_CONNECT;
 366  }
 367#endif
 368
 369#if defined(USE_IPV6) && defined(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
 370  if(data->conn->scope_id && (addr->family == AF_INET6)) {
 371    struct sockaddr_in6 * const sa6 = (void *)&addr->curl_sa_addr;
 372    sa6->sin6_scope_id = data->conn->scope_id;
 373  }
 374#endif
 375  return CURLE_OK;
 376}
 377
 378/*
 379 * Create a socket based on info from 'conn' and 'ai'.
 380 *
 381 * 'addr' should be a pointer to the correct struct to get data back, or NULL.
 382 * 'sockfd' must be a pointer to a socket descriptor.
 383 *
 384 * If the open socket callback is set, used that!
 385 *
 386 */
 387CURLcode Curl_socket_open(struct Curl_easy *data,
 388                          const struct Curl_addrinfo *ai,
 389                          struct Curl_sockaddr_ex *addr,
 390                          uint8_t transport,
 391                          curl_socket_t *sockfd)
 392{
 393  struct Curl_sockaddr_ex dummy;
 394  CURLcode result;
 395
 396  if(!addr)
 397    /* if the caller does not want info back, use a local temp copy */
 398    addr = &dummy;
 399
 400  result = Curl_socket_addr_from_ai(addr, ai, transport);
 401  if(result)
 402    return result;
 403
 404  return socket_open(data, addr, sockfd);
 405}
 406
 407static int socket_close(struct Curl_easy *data, struct connectdata *conn,
 408                        int use_callback, curl_socket_t sock)
 409{
 410  if(sock == CURL_SOCKET_BAD)
 411    return 0;
 412
 413  if(use_callback && conn && conn->fclosesocket) {
 414    int rc;
 415    Curl_multi_will_close(data, sock);
 416    Curl_set_in_callback(data, TRUE);
 417    rc = conn->fclosesocket(conn->closesocket_client, sock);
 418    Curl_set_in_callback(data, FALSE);
 419    return rc;
 420  }
 421
 422  if(conn)
 423    /* tell the multi-socket code about this */
 424    Curl_multi_will_close(data, sock);
 425
 426  sclose(sock);
 427
 428  return 0;
 429}
 430
 431/*
 432 * Close a socket.
 433 *
 434 * 'conn' can be NULL, beware!
 435 */
 436int Curl_socket_close(struct Curl_easy *data, struct connectdata *conn,
 437                      curl_socket_t sock)
 438{
 439  return socket_close(data, conn, FALSE, sock);
 440}
 441
 442/*
 443 * Curl_parse_interface()
 444 *
 445 * This is used to parse interface argument in the following formats.
 446 * In all the examples, `host` can be an IP address or a hostname.
 447 *
 448 *   <iface_or_host> - can be either an interface name or a host.
 449 *   if!<iface> - interface name.
 450 *   host!<host> - hostname.
 451 *   ifhost!<iface>!<host> - interface name and hostname.
 452 *
 453 * Parameters:
 454 *
 455 * input  [in]     - input string.
 456 * len    [in]     - length of the input string.
 457 * dev    [in/out] - address where a pointer to newly allocated memory
 458 *                   holding the interface-or-host will be stored upon
 459 *                   completion.
 460 * iface  [in/out] - address where a pointer to newly allocated memory
 461 *                   holding the interface will be stored upon completion.
 462 * host   [in/out] - address where a pointer to newly allocated memory
 463 *                   holding the host will be stored upon completion.
 464 *
 465 * Returns CURLE_OK on success.
 466 */
 467CURLcode Curl_parse_interface(const char *input,
 468                              char **dev, char **iface, char **host)
 469{
 470  static const char if_prefix[] = "if!";
 471  static const char host_prefix[] = "host!";
 472  static const char if_host_prefix[] = "ifhost!";
 473  size_t len;
 474
 475  DEBUGASSERT(dev);
 476  DEBUGASSERT(iface);
 477  DEBUGASSERT(host);
 478
 479  len = strlen(input);
 480  if(len > 512)
 481    return CURLE_BAD_FUNCTION_ARGUMENT;
 482
 483  if(!strncmp(if_prefix, input, strlen(if_prefix))) {
 484    input += strlen(if_prefix);
 485    if(!*input)
 486      return CURLE_BAD_FUNCTION_ARGUMENT;
 487    *iface = curlx_memdup0(input, len - strlen(if_prefix));
 488    return *iface ? CURLE_OK : CURLE_OUT_OF_MEMORY;
 489  }
 490  else if(!strncmp(host_prefix, input, strlen(host_prefix))) {
 491    input += strlen(host_prefix);
 492    if(!*input)
 493      return CURLE_BAD_FUNCTION_ARGUMENT;
 494    *host = curlx_memdup0(input, len - strlen(host_prefix));
 495    return *host ? CURLE_OK : CURLE_OUT_OF_MEMORY;
 496  }
 497  else if(!strncmp(if_host_prefix, input, strlen(if_host_prefix))) {
 498    const char *host_part;
 499    input += strlen(if_host_prefix);
 500    len -= strlen(if_host_prefix);
 501    host_part = memchr(input, '!', len);
 502    if(!host_part || !*(host_part + 1))
 503      return CURLE_BAD_FUNCTION_ARGUMENT;
 504    *iface = curlx_memdup0(input, host_part - input);
 505    if(!*iface)
 506      return CURLE_OUT_OF_MEMORY;
 507    ++host_part;
 508    *host = curlx_memdup0(host_part, len - (host_part - input));
 509    if(!*host) {
 510      curlx_free(*iface);
 511      *iface = NULL;
 512      return CURLE_OUT_OF_MEMORY;
 513    }
 514    return CURLE_OK;
 515  }
 516
 517  if(!*input)
 518    return CURLE_BAD_FUNCTION_ARGUMENT;
 519  *dev = curlx_memdup0(input, len);
 520  return *dev ? CURLE_OK : CURLE_OUT_OF_MEMORY;
 521}
 522
 523#ifndef CURL_DISABLE_BINDLOCAL
 524static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
 525                          curl_socket_t sockfd, int af, unsigned int scope,
 526                          uint8_t transport)
 527{
 528  struct Curl_sockaddr_storage sa;
 529  struct sockaddr *sock = (struct sockaddr *)&sa;  /* bind to this address */
 530  curl_socklen_t sizeof_sa = 0; /* size of the data sock points to */
 531  struct sockaddr_in *si4 = (struct sockaddr_in *)&sa;
 532#ifdef USE_IPV6
 533  struct sockaddr_in6 *si6 = (struct sockaddr_in6 *)&sa;
 534#endif
 535
 536  struct Curl_dns_entry *h = NULL;
 537  unsigned short port = data->set.localport; /* use this port number, 0 for
 538                                                "random" */
 539  /* how many port numbers to try to bind to, increasing one at a time */
 540  int portnum = data->set.localportrange;
 541  const char *dev = data->set.str[STRING_DEVICE];
 542  const char *iface_input = data->set.str[STRING_INTERFACE];
 543  const char *host_input = data->set.str[STRING_BINDHOST];
 544  const char *iface = iface_input ? iface_input : dev;
 545  const char *host = host_input ? host_input : dev;
 546  int error;
 547#ifdef IP_BIND_ADDRESS_NO_PORT
 548  int on = 1;
 549#endif
 550#ifndef USE_IPV6
 551  (void)scope;
 552#endif
 553
 554  /*************************************************************
 555   * Select device to bind socket to
 556   *************************************************************/
 557  if(!iface && !host && !port)
 558    /* no local kind of binding was requested */
 559    return CURLE_OK;
 560  else if(iface && (strlen(iface) >= 255))
 561    return CURLE_BAD_FUNCTION_ARGUMENT;
 562
 563  memset(&sa, 0, sizeof(struct Curl_sockaddr_storage));
 564
 565  if(iface || host) {
 566    char myhost[256] = "";
 567    int done = 0; /* -1 for error, 1 for address found */
 568    if2ip_result_t if2ip_result = IF2IP_NOT_FOUND;
 569
 570#ifdef SO_BINDTODEVICE
 571    if(iface) {
 572      /*
 573       * This binds the local socket to a particular interface. This will
 574       * force even requests to other local interfaces to go out the external
 575       * interface. Only bind to the interface when specified as interface,
 576       * not as a hostname or ip address.
 577       *
 578       * The interface might be a VRF, eg: vrf-blue, which means it cannot be
 579       * converted to an IP address and would fail Curl_if2ip. Try to
 580       * use it straight away.
 581       */
 582      if(setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE,
 583                    iface, (curl_socklen_t)strlen(iface) + 1) == 0) {
 584        /* This is often "errno 1, error: Operation not permitted" if you are
 585         * not running as root or another suitable privileged user. If it
 586         * succeeds it means the parameter was a valid interface and not an IP
 587         * address. Return immediately.
 588         */
 589        if(!host_input) {
 590          infof(data, "socket successfully bound to interface '%s'", iface);
 591          return CURLE_OK;
 592        }
 593      }
 594    }
 595#endif
 596    if(!host_input) {
 597      /* Discover IP from input device, then bind to it */
 598      if2ip_result = Curl_if2ip(af,
 599#ifdef USE_IPV6
 600                                scope, conn->scope_id,
 601#endif
 602                                iface, myhost, sizeof(myhost));
 603    }
 604    switch(if2ip_result) {
 605    case IF2IP_NOT_FOUND:
 606      if(iface_input && !host_input) {
 607        /* Do not fall back to treating it as a hostname */
 608        char buffer[STRERROR_LEN];
 609        data->state.os_errno = error = SOCKERRNO;
 610        failf(data, "Could not bind to interface '%s' with errno %d: %s",
 611              iface, error, curlx_strerror(error, buffer, sizeof(buffer)));
 612        return CURLE_INTERFACE_FAILED;
 613      }
 614      break;
 615    case IF2IP_AF_NOT_SUPPORTED:
 616      /* Signal the caller to try another address family if available */
 617      return CURLE_UNSUPPORTED_PROTOCOL;
 618    case IF2IP_FOUND:
 619      /*
 620       * We now have the numerical IP address in the 'myhost' buffer
 621       */
 622      host = myhost;
 623      infof(data, "Local Interface %s is ip %s using address family %i",
 624            iface, host, af);
 625      done = 1;
 626      break;
 627    }
 628    if(!iface_input || host_input) {
 629      /*
 630       * This was not an interface, resolve the name as a hostname
 631       * or IP number
 632       *
 633       * Temporarily force name resolution to use only the address type
 634       * of the connection. The resolve functions should really be changed
 635       * to take a type parameter instead.
 636       */
 637      uint8_t dns_queries = (af == AF_INET) ?
 638                            CURL_DNSQ_A : (CURL_DNSQ_A | CURL_DNSQ_AAAA);
 639#ifdef USE_IPV6
 640      if(af == AF_INET6)
 641        dns_queries = CURL_DNSQ_AAAA;
 642#endif
 643
 644      (void)Curl_resolv_blocking(data, dns_queries, host, 80, transport, &h);
 645      if(h) {
 646        int h_af = h->addr->ai_family;
 647        /* convert the resolved address, sizeof myhost >= INET_ADDRSTRLEN */
 648        Curl_printable_address(h->addr, myhost, sizeof(myhost));
 649        infof(data, "Name '%s' family %i resolved to '%s' family %i",
 650              host, af, myhost, h_af);
 651        Curl_dns_entry_unlink(data, &h); /* this will NULL, potential free h */
 652        if(af != h_af) {
 653          /* bad IP version combo, signal the caller to try another address
 654             family if available */
 655          return CURLE_UNSUPPORTED_PROTOCOL;
 656        }
 657        done = 1;
 658      }
 659      else {
 660        /*
 661         * provided dev was no interface (or interfaces are not supported
 662         * e.g. Solaris) no ip address and no domain we fail here
 663         */
 664        done = -1;
 665      }
 666    }
 667
 668    if(done > 0) {
 669#ifdef USE_IPV6
 670      /* IPv6 address */
 671      if(af == AF_INET6) {
 672#ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
 673        char *scope_ptr = strchr(myhost, '%');
 674        if(scope_ptr)
 675          *(scope_ptr++) = '\0';
 676#endif
 677        if(curlx_inet_pton(AF_INET6, myhost, &si6->sin6_addr) > 0) {
 678          si6->sin6_family = AF_INET6;
 679          si6->sin6_port = htons(port);
 680#ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
 681          if(scope_ptr) {
 682            /* The "myhost" string either comes from Curl_if2ip or from
 683               Curl_printable_address. The latter returns only numeric scope
 684               IDs and the former returns none at all. Making the scope ID,
 685               if present, known to be numeric */
 686            curl_off_t scope_id;
 687            if(curlx_str_number((const char **)CURL_UNCONST(&scope_ptr),
 688                                &scope_id, UINT_MAX))
 689              return CURLE_UNSUPPORTED_PROTOCOL;
 690            si6->sin6_scope_id = (unsigned int)scope_id;
 691          }
 692#endif
 693        }
 694        sizeof_sa = sizeof(struct sockaddr_in6);
 695      }
 696      else
 697#endif
 698      /* IPv4 address */
 699      if((af == AF_INET) &&
 700         (curlx_inet_pton(AF_INET, myhost, &si4->sin_addr) > 0)) {
 701        si4->sin_family = AF_INET;
 702        si4->sin_port = htons(port);
 703        sizeof_sa = sizeof(struct sockaddr_in);
 704      }
 705    }
 706
 707    if(done < 1) {
 708      /* errorbuf is set false so failf will overwrite any message already in
 709         the error buffer, so the user receives this error message instead of a
 710         generic resolve error. */
 711      char buffer[STRERROR_LEN];
 712      data->state.errorbuf = FALSE;
 713      data->state.os_errno = error = SOCKERRNO;
 714      failf(data, "Could not bind to '%s' with errno %d: %s", host,
 715            error, curlx_strerror(error, buffer, sizeof(buffer)));
 716      return CURLE_INTERFACE_FAILED;
 717    }
 718  }
 719  else {
 720    /* no device was given, prepare sa to match af's needs */
 721#ifdef USE_IPV6
 722    if(af == AF_INET6) {
 723      si6->sin6_family = AF_INET6;
 724      si6->sin6_port = htons(port);
 725      sizeof_sa = sizeof(struct sockaddr_in6);
 726    }
 727    else
 728#endif
 729    if(af == AF_INET) {
 730      si4->sin_family = AF_INET;
 731      si4->sin_port = htons(port);
 732      sizeof_sa = sizeof(struct sockaddr_in);
 733    }
 734  }
 735#ifdef IP_BIND_ADDRESS_NO_PORT
 736  (void)setsockopt(sockfd, SOL_IP, IP_BIND_ADDRESS_NO_PORT, &on, sizeof(on));
 737#endif
 738  for(;;) {
 739    if(bind(sockfd, sock, sizeof_sa) >= 0) {
 740      /* we succeeded to bind */
 741      infof(data, "Local port: %hu", port);
 742      conn->bits.bound = TRUE;
 743      return CURLE_OK;
 744    }
 745
 746    if(--portnum > 0) {
 747      port++; /* try next port */
 748      if(port == 0)
 749        break;
 750      infof(data, "Bind to local port %d failed, trying next", port - 1);
 751      /* We reuse/clobber the port variable here below */
 752      if(sock->sa_family == AF_INET)
 753        si4->sin_port = htons(port);
 754#ifdef USE_IPV6
 755      else
 756        si6->sin6_port = htons(port);
 757#endif
 758    }
 759    else
 760      break;
 761  }
 762  {
 763    char buffer[STRERROR_LEN];
 764    data->state.os_errno = error = SOCKERRNO;
 765    failf(data, "bind failed with errno %d: %s",
 766          error, curlx_strerror(error, buffer, sizeof(buffer)));
 767  }
 768
 769  return CURLE_INTERFACE_FAILED;
 770}
 771#endif
 772
 773/*
 774 * verifyconnect() returns TRUE if the connect really has happened.
 775 */
 776static bool verifyconnect(curl_socket_t sockfd, int *error)
 777{
 778  bool rc = TRUE;
 779#ifdef SO_ERROR
 780  int err = 0;
 781  curl_socklen_t errSize = sizeof(err);
 782
 783#ifdef _WIN32
 784  /*
 785   * In October 2003 we effectively nullified this function on Windows due to
 786   * problems with it using all CPU in multi-threaded cases.
 787   *
 788   * In May 2004, we brought it back to offer more info back on connect
 789   * failures. We could reproduce the former problems with this function, but
 790   * could avoid them by adding this SleepEx() call below:
 791   *
 792   *    "I do not have Rational Quantify, but the hint from his post was
 793   *    ntdll::NtRemoveIoCompletion(). I would assume the SleepEx (or maybe
 794   *    Sleep(0) would be enough?) would release whatever
 795   *    mutex/critical-section the ntdll call is waiting on.
 796   *
 797   *    Someone got to verify this on Win-NT 4.0, 2000."
 798   */
 799  SleepEx(0, FALSE);
 800#endif
 801
 802  if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize))
 803    err = SOCKERRNO;
 804#if defined(EBADIOCTL) && defined(__minix)
 805  /* Minix 3.1.x does not support getsockopt on UDP sockets */
 806  if(EBADIOCTL == err) {
 807    SET_SOCKERRNO(0);
 808    err = 0;
 809  }
 810#endif
 811  if((err == 0) || (SOCKEISCONN == err))
 812    /* we are connected, awesome! */
 813    rc = TRUE;
 814  else
 815    /* This was not a successful connect */
 816    rc = FALSE;
 817  if(error)
 818    *error = err;
 819#else
 820  (void)sockfd;
 821  if(error)
 822    *error = SOCKERRNO;
 823#endif
 824  return rc;
 825}
 826
 827/**
 828 * Determine the curl code for a socket connect() == -1 with errno.
 829 */
 830static CURLcode socket_connect_result(struct Curl_easy *data,
 831                                      const char *ipaddress, int error)
 832{
 833  switch(error) {
 834  case SOCKEINPROGRESS:
 835  case SOCKEWOULDBLOCK:
 836#ifdef EAGAIN
 837#if (EAGAIN) != (SOCKEWOULDBLOCK)
 838    /* On some platforms EAGAIN and EWOULDBLOCK are the
 839     * same value, and on others they are different, hence
 840     * the odd #if
 841     */
 842  case EAGAIN:
 843#endif
 844#endif
 845    return CURLE_OK;
 846
 847  default:
 848    /* unknown error, fallthrough and try another address! */
 849    {
 850      VERBOSE(char buffer[STRERROR_LEN]);
 851      infof(data, "Immediate connect fail for %s: %s", ipaddress,
 852            curlx_strerror(error, buffer, sizeof(buffer)));
 853      NOVERBOSE((void)ipaddress);
 854    }
 855    data->state.os_errno = error;
 856    /* connect failed */
 857    return CURLE_COULDNT_CONNECT;
 858  }
 859}
 860
 861struct cf_socket_ctx {
 862  uint8_t transport;
 863  struct Curl_sockaddr_ex addr;      /* address to connect to */
 864  curl_socket_t sock;                /* current attempt socket */
 865  struct ip_quadruple ip;            /* The IP quadruple 2x(addr+port) */
 866  struct curltime started_at;        /* when socket was created */
 867  struct curltime connected_at;      /* when socket connected/got first byte */
 868  struct curltime first_byte_at;     /* when first byte was recvd */
 869#ifdef USE_WINSOCK
 870  struct curltime last_sndbuf_query_at;  /* when SO_SNDBUF last queried */
 871  ULONG sndbuf_size;                     /* the last set SO_SNDBUF size */
 872#endif
 873  int error;                         /* errno of last failure or 0 */
 874#ifdef DEBUGBUILD
 875  int wblock_percent;                /* percent of writes doing EAGAIN */
 876  int wpartial_percent;              /* percent of bytes written in send */
 877  int rblock_percent;                /* percent of reads doing EAGAIN */
 878  size_t recv_max;                   /* max enforced read size */
 879#endif
 880  BIT(got_first_byte);               /* if first byte was received */
 881  BIT(listening);                    /* socket is listening */
 882  BIT(accepted);                     /* socket was accepted, not connected */
 883  BIT(sock_connected);               /* socket is "connected", e.g. in UDP */
 884  BIT(active);
 885};
 886
 887static CURLcode cf_socket_ctx_init(struct cf_socket_ctx *ctx,
 888                                   struct Curl_sockaddr_ex *addr,
 889                                   uint8_t transport)
 890{
 891  memset(ctx, 0, sizeof(*ctx));
 892  ctx->sock = CURL_SOCKET_BAD;
 893  ctx->transport = transport;
 894  ctx->addr = *addr;
 895
 896#ifdef DEBUGBUILD
 897  {
 898    const char *p = getenv("CURL_DBG_SOCK_WBLOCK");
 899    if(p) {
 900      curl_off_t l;
 901      if(!curlx_str_number(&p, &l, 100))
 902        ctx->wblock_percent = (int)l;
 903    }
 904    p = getenv("CURL_DBG_SOCK_WPARTIAL");
 905    if(p) {
 906      curl_off_t l;
 907      if(!curlx_str_number(&p, &l, 100))
 908        ctx->wpartial_percent = (int)l;
 909    }
 910    p = getenv("CURL_DBG_SOCK_RBLOCK");
 911    if(p) {
 912      curl_off_t l;
 913      if(!curlx_str_number(&p, &l, 100))
 914        ctx->rblock_percent = (int)l;
 915    }
 916    p = getenv("CURL_DBG_SOCK_RMAX");
 917    if(p) {
 918      curl_off_t l;
 919      if(!curlx_str_number(&p, &l, CURL_OFF_T_MAX))
 920        ctx->recv_max = (size_t)l;
 921    }
 922  }
 923#endif
 924
 925  return CURLE_OK;
 926}
 927
 928static void cf_socket_close(struct Curl_cfilter *cf, struct Curl_easy *data)
 929{
 930  struct cf_socket_ctx *ctx = cf->ctx;
 931
 932  if(ctx && ctx->sock != CURL_SOCKET_BAD) {
 933    CURL_TRC_CF(data, cf, "cf_socket_close, fd=%" FMT_SOCKET_T, ctx->sock);
 934    if(ctx->sock == cf->conn->sock[cf->sockindex])
 935      cf->conn->sock[cf->sockindex] = CURL_SOCKET_BAD;
 936    socket_close(data, cf->conn, !ctx->accepted, ctx->sock);
 937    ctx->sock = CURL_SOCKET_BAD;
 938    ctx->active = FALSE;
 939    memset(&ctx->started_at, 0, sizeof(ctx->started_at));
 940    memset(&ctx->connected_at, 0, sizeof(ctx->connected_at));
 941  }
 942
 943  cf->connected = FALSE;
 944}
 945
 946static CURLcode cf_socket_shutdown(struct Curl_cfilter *cf,
 947                                   struct Curl_easy *data,
 948                                   bool *done)
 949{
 950  if(cf->connected) {
 951    struct cf_socket_ctx *ctx = cf->ctx;
 952
 953    CURL_TRC_CF(data, cf, "cf_socket_shutdown, fd=%" FMT_SOCKET_T, ctx->sock);
 954    /* On TCP, and when the socket looks well and non-blocking mode
 955     * can be enabled, receive dangling bytes before close to avoid
 956     * entering RST states unnecessarily. */
 957    if(ctx->sock != CURL_SOCKET_BAD &&
 958       ctx->transport == TRNSPRT_TCP &&
 959       (curlx_nonblock(ctx->sock, TRUE) >= 0)) {
 960      unsigned char buf[1024];
 961      (void)sread(ctx->sock, buf, sizeof(buf));
 962    }
 963  }
 964  *done = TRUE;
 965  return CURLE_OK;
 966}
 967
 968static void cf_socket_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
 969{
 970  struct cf_socket_ctx *ctx = cf->ctx;
 971
 972  cf_socket_close(cf, data);
 973  CURL_TRC_CF(data, cf, "destroy");
 974  curlx_free(ctx);
 975  cf->ctx = NULL;
 976}
 977
 978static void set_local_ip(struct Curl_cfilter *cf,
 979                         struct Curl_easy *data)
 980{
 981  struct cf_socket_ctx *ctx = cf->ctx;
 982  ctx->ip.local_ip[0] = 0;
 983  ctx->ip.local_port = 0;
 984
 985#ifdef HAVE_GETSOCKNAME
 986  if((ctx->sock != CURL_SOCKET_BAD) &&
 987     !(data->conn->scheme->protocol & CURLPROTO_TFTP)) {
 988    /* TFTP does not connect, so it cannot get the IP like this */
 989    struct Curl_sockaddr_storage ssloc;
 990    curl_socklen_t slen = sizeof(struct Curl_sockaddr_storage);
 991    VERBOSE(char buffer[STRERROR_LEN]);
 992
 993    memset(&ssloc, 0, sizeof(ssloc));
 994    if(getsockname(ctx->sock, (struct sockaddr *)&ssloc, &slen)) {
 995      VERBOSE(int error = SOCKERRNO);
 996      infof(data, "getsockname() failed with errno %d: %s",
 997            error, curlx_strerror(error, buffer, sizeof(buffer)));
 998    }
 999    else if(!Curl_addr2string((struct sockaddr *)&ssloc, slen,
1000                              ctx->ip.local_ip, &ctx->ip.local_port)) {
1001      infof(data, "ssloc inet_ntop() failed with errno %d: %s",
1002            errno, curlx_strerror(errno, buffer, sizeof(buffer)));
1003    }
1004  }
1005#else
1006  (void)data;
1007#endif
1008}
1009
1010static CURLcode set_remote_ip(struct Curl_cfilter *cf,
1011                              struct Curl_easy *data)
1012{
1013  struct cf_socket_ctx *ctx = cf->ctx;
1014
1015  /* store remote address and port used in this connection attempt */
1016  ctx->ip.transport = ctx->transport;
1017  if(!Curl_addr2string(&ctx->addr.curl_sa_addr,
1018                       (curl_socklen_t)ctx->addr.addrlen,
1019                       ctx->ip.remote_ip, &ctx->ip.remote_port)) {
1020    char buffer[STRERROR_LEN];
1021
1022    ctx->error = errno;
1023    /* malformed address or bug in inet_ntop, try next address */
1024    failf(data, "curl_sa_addr inet_ntop() failed with errno %d: %s",
1025          errno, curlx_strerror(errno, buffer, sizeof(buffer)));
1026    return CURLE_FAILED_INIT;
1027  }
1028  return CURLE_OK;
1029}
1030
1031/* to figure out the type of the socket safely, remove the possibly ORed
1032   bits before comparing */
1033static int cf_socktype(int x)
1034{
1035#ifdef SOCK_CLOEXEC
1036  x &= ~SOCK_CLOEXEC;
1037#endif
1038#ifdef SOCK_NONBLOCK
1039  x &= ~SOCK_NONBLOCK;
1040#endif
1041  return x;
1042}
1043
1044static CURLcode cf_socket_open(struct Curl_cfilter *cf,
1045                               struct Curl_easy *data)
1046{
1047  struct cf_socket_ctx *ctx = cf->ctx;
1048  int error = 0;
1049  bool isconnected = FALSE;
1050  CURLcode result = CURLE_COULDNT_CONNECT;
1051  bool is_tcp;
1052
1053  DEBUGASSERT(ctx->sock == CURL_SOCKET_BAD);
1054  ctx->started_at = *Curl_pgrs_now(data);
1055#ifdef SOCK_NONBLOCK
1056  /* Do not tuck SOCK_NONBLOCK into socktype when opensocket callback is set
1057   * because we would not know how socketype is about to be used in the
1058   * callback, SOCK_NONBLOCK might get factored out before calling socket().
1059   */
1060  if(!data->set.fopensocket)
1061    ctx->addr.socktype |= SOCK_NONBLOCK;
1062#endif
1063  result = socket_open(data, &ctx->addr, &ctx->sock);
1064#ifdef SOCK_NONBLOCK
1065  /* Restore the socktype after the socket is created. */
1066  if(!data->set.fopensocket)
1067    ctx->addr.socktype &= ~SOCK_NONBLOCK;
1068#endif
1069  if(result)
1070    goto out;
1071
1072  result = set_remote_ip(cf, data);
1073  if(result)
1074    goto out;
1075
1076#ifdef USE_IPV6
1077  if(ctx->addr.family == AF_INET6) {
1078#ifdef USE_WINSOCK
1079    /* Turn on support for IPv4-mapped IPv6 addresses.
1080     * Linux kernel, NetBSD, FreeBSD, Darwin, lwIP: default is off;
1081     * Windows Vista and later: default is on;
1082     * DragonFly BSD: acts like off, and dummy setting;
1083     * OpenBSD and earlier Windows: unsupported.
1084     * Linux: controlled by /proc/sys/net/ipv6/bindv6only.
1085     */
1086    int on = 0;
1087    (void)setsockopt(ctx->sock, IPPROTO_IPV6, IPV6_V6ONLY,
1088                     (void *)&on, sizeof(on));
1089#endif
1090    infof(data, "  Trying [%s]:%d...", ctx->ip.remote_ip, ctx->ip.remote_port);
1091  }
1092  else
1093#endif
1094    infof(data, "  Trying %s:%d...", ctx->ip.remote_ip, ctx->ip.remote_port);
1095
1096#ifdef USE_IPV6
1097  is_tcp = (ctx->addr.family == AF_INET ||
1098            ctx->addr.family == AF_INET6) &&
1099    cf_socktype(ctx->addr.socktype) == SOCK_STREAM;
1100#else
1101  is_tcp = (ctx->addr.family == AF_INET) &&
1102    cf_socktype(ctx->addr.socktype) == SOCK_STREAM;
1103#endif
1104  if(is_tcp && data->set.tcp_nodelay)
1105    tcpnodelay(cf, data, ctx->sock);
1106
1107  if(is_tcp && data->set.tcp_keepalive)
1108    tcpkeepalive(cf, data, ctx->sock);
1109
1110  if(data->set.fsockopt) {
1111    /* activate callback for setting socket options */
1112    Curl_set_in_callback(data, TRUE);
1113    error = data->set.fsockopt(data->set.sockopt_client,
1114                               ctx->sock,
1115                               CURLSOCKTYPE_IPCXN);
1116    Curl_set_in_callback(data, FALSE);
1117
1118    if(error == CURL_SOCKOPT_ALREADY_CONNECTED)
1119      isconnected = TRUE;
1120    else if(error) {
1121      result = CURLE_ABORTED_BY_CALLBACK;
1122      goto out;
1123    }
1124  }
1125
1126#ifndef CURL_DISABLE_BINDLOCAL
1127  /* possibly bind the local end to an IP, interface or port */
1128  if(ctx->addr.family == AF_INET
1129#ifdef USE_IPV6
1130     || ctx->addr.family == AF_INET6
1131#endif
1132    ) {
1133    result = bindlocal(data, cf->conn, ctx->sock, ctx->addr.family,
1134                       Curl_ipv6_scope(&ctx->addr.curl_sa_addr),
1135                       ctx->transport);
1136    if(result) {
1137      if(result == CURLE_UNSUPPORTED_PROTOCOL) {
1138        /* The address family is not supported on this interface.
1139           We can continue trying addresses */
1140        result = CURLE_COULDNT_CONNECT;
1141      }
1142      goto out;
1143    }
1144  }
1145#endif
1146
1147#ifndef SOCK_NONBLOCK
1148  /* Set socket non-blocking, must be a non-blocking socket for
1149   * a non-blocking connect. */
1150  error = curlx_nonblock(ctx->sock, TRUE);
1151  if(error < 0) {
1152    result = CURLE_UNSUPPORTED_PROTOCOL;
1153    ctx->error = SOCKERRNO;
1154    goto out;
1155  }
1156#else
1157  if(data->set.fopensocket) {
1158    /* Set socket non-blocking, must be a non-blocking socket for
1159     * a non-blocking connect. */
1160    error = curlx_nonblock(ctx->sock, TRUE);
1161    if(error < 0) {
1162      result = CURLE_UNSUPPORTED_PROTOCOL;
1163      ctx->error = SOCKERRNO;
1164      goto out;
1165    }
1166  }
1167#endif
1168  ctx->sock_connected = (cf_socktype(ctx->addr.socktype) != SOCK_DGRAM);
1169out:
1170  if(result) {
1171    if(ctx->sock != CURL_SOCKET_BAD) {
1172      socket_close(data, cf->conn, TRUE, ctx->sock);
1173      ctx->sock = CURL_SOCKET_BAD;
1174    }
1175  }
1176  else if(isconnected) {
1177    set_local_ip(cf, data);
1178    ctx->connected_at = *Curl_pgrs_now(data);
1179    cf->connected = TRUE;
1180  }
1181  CURL_TRC_CF(data, cf, "cf_socket_open() -> %d, fd=%" FMT_SOCKET_T,
1182              result, ctx->sock);
1183  return result;
1184}
1185
1186static int do_connect(struct Curl_cfilter *cf, struct Curl_easy *data,
1187                      bool is_tcp_fastopen)
1188{
1189  struct cf_socket_ctx *ctx = cf->ctx;
1190#ifdef TCP_FASTOPEN_CONNECT
1191  int optval = 1;
1192#endif
1193  int rc = -1;
1194
1195  (void)data;
1196  if(is_tcp_fastopen) {
1197#ifdef CONNECT_DATA_IDEMPOTENT /* Darwin */
1198#  ifdef HAVE_BUILTIN_AVAILABLE
1199    /* while connectx function is available since macOS 10.11 / iOS 9,
1200       it did not have the interface declared correctly until
1201       Xcode 9 / macOS SDK 10.13 */
1202    if(__builtin_available(macOS 10.11, iOS 9.0, tvOS 9.0, watchOS 2.0, *)) {
1203      sa_endpoints_t endpoints;
1204      endpoints.sae_srcif = 0;
1205      endpoints.sae_srcaddr = NULL;
1206      endpoints.sae_srcaddrlen = 0;
1207      endpoints.sae_dstaddr = &ctx->addr.curl_sa_addr;
1208      endpoints.sae_dstaddrlen = ctx->addr.addrlen;
1209
1210      rc = connectx(ctx->sock, &endpoints, SAE_ASSOCID_ANY,
1211                    CONNECT_RESUME_ON_READ_WRITE | CONNECT_DATA_IDEMPOTENT,
1212                    NULL, 0, NULL, NULL);
1213    }
1214    else {
1215      rc = connect(ctx->sock, &ctx->addr.curl_sa_addr, ctx->addr.addrlen);
1216    }
1217#  else
1218    rc = connect(ctx->sock, &ctx->addr.curl_sa_addr, ctx->addr.addrlen);
1219#  endif /* HAVE_BUILTIN_AVAILABLE */
1220#elif defined(TCP_FASTOPEN_CONNECT) /* Linux >= 4.11 */
1221    if(setsockopt(ctx->sock, IPPROTO_TCP, TCP_FASTOPEN_CONNECT,
1222                  (void *)&optval, sizeof(optval)) < 0)
1223      CURL_TRC_CF(data, cf, "Failed to enable TCP Fast Open on fd %"
1224                  FMT_SOCKET_T, ctx->sock);
1225
1226    rc = connect(ctx->sock, &ctx->addr.curl_sa_addr, ctx->addr.addrlen);
1227#elif defined(MSG_FASTOPEN) /* old Linux */
1228    if(Curl_conn_is_ssl(cf->conn, cf->sockindex))
1229      rc = connect(ctx->sock, &ctx->addr.curl_sa_addr, ctx->addr.addrlen);
1230    else
1231      rc = 0; /* Do nothing */
1232#endif
1233  }
1234  else {
1235    rc = connect(ctx->sock, &ctx->addr.curl_sa_addr,
1236                 (curl_socklen_t)ctx->addr.addrlen);
1237  }
1238  return rc;
1239}
1240
1241static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
1242                               struct Curl_easy *data,
1243                               bool *done)
1244{
1245  struct cf_socket_ctx *ctx = cf->ctx;
1246  CURLcode result = CURLE_COULDNT_CONNECT;
1247  int rc = 0;
1248
1249  if(cf->connected) {
1250    *done = TRUE;
1251    return CURLE_OK;
1252  }
1253
1254  *done = FALSE; /* a negative world view is best */
1255  if(ctx->sock == CURL_SOCKET_BAD) {
1256    int error;
1257
1258    result = cf_socket_open(cf, data);
1259    if(result)
1260      goto out;
1261
1262    if(cf->connected) {
1263      *done = TRUE;
1264      return CURLE_OK;
1265    }
1266
1267    /* Connect TCP socket */
1268    rc = do_connect(cf, data, (bool)cf->conn->bits.tcp_fastopen);
1269    error = SOCKERRNO;
1270    set_local_ip(cf, data);
1271    CURL_TRC_CF(data, cf, "local address %s port %d...",
1272                ctx->ip.local_ip, ctx->ip.local_port);
1273    if(rc == -1) {
1274      result = socket_connect_result(data, ctx->ip.remote_ip, error);
1275      goto out;
1276    }
1277  }
1278
1279#ifdef mpeix
1280  /* Call this function once now, and ignore the results. We do this to
1281     "clear" the error state on the socket so that we can later read it
1282     reliably. This is reported necessary on the MPE/iX operating
1283     system. */
1284  (void)verifyconnect(ctx->sock, NULL);
1285#endif
1286  /* check socket for connect */
1287  rc = SOCKET_WRITABLE(ctx->sock, 0);
1288
1289  if(rc == 0) { /* no connection yet */
1290    CURL_TRC_CF(data, cf, "not connected yet on fd=%" FMT_SOCKET_T, ctx->sock);
1291    return CURLE_OK;
1292  }
1293  else if(rc == CURL_CSELECT_OUT || cf->conn->bits.tcp_fastopen) {
1294    if(verifyconnect(ctx->sock, &ctx->error)) {
1295      /* we are connected with TCP, awesome! */
1296      ctx->connected_at = *Curl_pgrs_now(data);
1297      set_local_ip(cf, data);
1298      *done = TRUE;
1299      cf->connected = TRUE;
1300      CURL_TRC_CF(data, cf, "connected on fd=%" FMT_SOCKET_T, ctx->sock);
1301      return CURLE_OK;
1302    }
1303  }
1304  else if(rc & CURL_CSELECT_ERR) {
1305    CURL_TRC_CF(data, cf, "poll/select error on fd=%" FMT_SOCKET_T, ctx->sock);
1306    (void)verifyconnect(ctx->sock, &ctx->error);
1307    result = CURLE_COULDNT_CONNECT;
1308  }
1309
1310out:
1311  if(result) {
1312    VERBOSE(char buffer[STRERROR_LEN]);
1313    set_local_ip(cf, data);
1314    if(ctx->error) {
1315      data->state.os_errno = ctx->error;
1316      SET_SOCKERRNO(ctx->error);
1317      VERBOSE(curlx_strerror(ctx->error, buffer, sizeof(buffer)));
1318    }
1319    else {
1320      VERBOSE(curlx_strcopy(buffer, sizeof(buffer), STRCONST("peer closed")));
1321    }
1322    if(ctx->sock != CURL_SOCKET_BAD) {
1323      socket_close(data, cf->conn, TRUE, ctx->sock);
1324      ctx->sock = CURL_SOCKET_BAD;
1325    }
1326    infof(data, "connect to %s port %u from %s port %d failed: %s",
1327          ctx->ip.remote_ip, ctx->ip.remote_port,
1328          ctx->ip.local_ip, ctx->ip.local_port,
1329          curlx_strerror(ctx->error, buffer, sizeof(buffer)));
1330    *done = FALSE;
1331  }
1332  return result;
1333}
1334
1335static CURLcode cf_socket_adjust_pollset(struct Curl_cfilter *cf,
1336                                         struct Curl_easy *data,
1337                                         struct easy_pollset *ps)
1338{
1339  struct cf_socket_ctx *ctx = cf->ctx;
1340  CURLcode result = CURLE_OK;
1341
1342  if(ctx->sock != CURL_SOCKET_BAD) {
1343    /* A listening socket filter needs to be connected before the accept
1344     * for some weird FTP interaction. This should be rewritten, so that
1345     * FTP no longer does the socket checks and accept calls and delegates
1346     * all that to the filter. */
1347    if(ctx->listening) {
1348      result = Curl_pollset_set_in_only(data, ps, ctx->sock);
1349      CURL_TRC_CF(data, cf, "adjust_pollset, listening, POLLIN fd=%"
1350                  FMT_SOCKET_T, ctx->sock);
1351    }
1352    else if(!cf->connected) {
1353      result = Curl_pollset_set_out_only(data, ps, ctx->sock);
1354      CURL_TRC_CF(data, cf, "adjust_pollset, !connected, POLLOUT fd=%"
1355                  FMT_SOCKET_T, ctx->sock);
1356    }
1357    else if(!ctx->active) {
1358      result = Curl_pollset_add_in(data, ps, ctx->sock);
1359      CURL_TRC_CF(data, cf, "adjust_pollset, !active, POLLIN fd=%"
1360                  FMT_SOCKET_T, ctx->sock);
1361    }
1362  }
1363  return result;
1364}
1365
1366#ifdef USE_WINSOCK
1367
1368/* Offered by mingw-w64 v13+, MS SDK 7.0A/VS2010+ */
1369#ifndef SIO_IDEAL_SEND_BACKLOG_QUERY
1370#define SIO_IDEAL_SEND_BACKLOG_QUERY 0x4004747B
1371#endif
1372
1373static void win_update_sndbuf_size(struct Curl_easy *data,
1374                                   struct cf_socket_ctx *ctx)
1375{
1376  ULONG ideal;
1377  DWORD ideallen;
1378
1379  if(curlx_ptimediff_ms(Curl_pgrs_now(data),
1380                        &ctx->last_sndbuf_query_at) > 1000) {
1381    if(!WSAIoctl(ctx->sock, SIO_IDEAL_SEND_BACKLOG_QUERY, 0, 0,
1382                 &ideal, sizeof(ideal), &ideallen, 0, 0) &&
1383       ideal != ctx->sndbuf_size &&
1384       !setsockopt(ctx->sock, SOL_SOCKET, SO_SNDBUF,
1385                   (const char *)&ideal, sizeof(ideal))) {
1386      ctx->sndbuf_size = ideal;
1387    }
1388    ctx->last_sndbuf_query_at = *Curl_pgrs_now(data);
1389  }
1390}
1391
1392#endif /* USE_WINSOCK */
1393
1394static CURLcode cf_socket_send(struct Curl_cfilter *cf, struct Curl_easy *data,
1395                               const uint8_t *buf, size_t len, bool eos,
1396                               size_t *pnwritten)
1397{
1398  struct cf_socket_ctx *ctx = cf->ctx;
1399  curl_socket_t fdsave;
1400  ssize_t rv;
1401  CURLcode result = CURLE_OK;
1402  VERBOSE(size_t orig_len = len);
1403
1404  (void)eos;
1405  *pnwritten = 0;
1406  fdsave = cf->conn->sock[cf->sockindex];
1407  cf->conn->sock[cf->sockindex] = ctx->sock;
1408
1409#ifdef DEBUGBUILD
1410  /* simulate network blocking/partial writes */
1411  if(ctx->wblock_percent > 0) {
1412    unsigned char c = 0;
1413    Curl_rand_bytes(data, FALSE, &c, 1);
1414    if(c >= ((100 - ctx->wblock_percent) * 256 / 100)) {
1415      CURL_TRC_CF(data, cf, "send(len=%zu) SIMULATE EWOULDBLOCK", orig_len);
1416      cf->conn->sock[cf->sockindex] = fdsave;
1417      return CURLE_AGAIN;
1418    }
1419  }
1420  if(cf->cft != &Curl_cft_udp && ctx->wpartial_percent > 0 && len > 8) {
1421    len = len * ctx->wpartial_percent / 100;
1422    if(!len)
1423      len = 1;
1424    CURL_TRC_CF(data, cf, "send(len=%zu) SIMULATE partial write of %zu bytes",
1425                orig_len, len);
1426  }
1427#endif
1428
1429#if defined(MSG_FASTOPEN) && !defined(TCP_FASTOPEN_CONNECT) /* Linux */
1430  if(cf->conn->bits.tcp_fastopen) {
1431    rv = sendto(ctx->sock, buf, len, MSG_FASTOPEN,
1432                &ctx->addr.curl_sa_addr, ctx->addr.addrlen);
1433    cf->conn->bits.tcp_fastopen = FALSE;
1434  }
1435  else
1436#endif
1437    rv = swrite(ctx->sock, buf, len);
1438
1439  if(!curlx_sztouz(rv, pnwritten)) {
1440    int sockerr = SOCKERRNO;
1441
1442    if(
1443#ifdef USE_WINSOCK
1444      /* This is how Windows does it */
1445      (SOCKEWOULDBLOCK == sockerr)
1446#else
1447      /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
1448         due to its inability to send off data without blocking. We therefore
1449         treat both error codes the same here */
1450      (SOCKEWOULDBLOCK == sockerr) ||
1451      (EAGAIN == sockerr) || (SOCKEINTR == sockerr) ||
1452      (SOCKEINPROGRESS == sockerr)
1453#endif
1454      ) {
1455      /* EWOULDBLOCK */
1456      result = CURLE_AGAIN;
1457    }
1458    else {
1459      char buffer[STRERROR_LEN];
1460      failf(data, "Send failure: %s",
1461            curlx_strerror(sockerr, buffer, sizeof(buffer)));
1462      data->state.os_errno = sockerr;
1463      result = CURLE_SEND_ERROR;
1464    }
1465  }
1466
1467#ifdef USE_WINSOCK
1468  if(!result)
1469    win_update_sndbuf_size(data, ctx);
1470#endif
1471
1472  CURL_TRC_CF(data, cf, "send(len=%zu) -> %d, %zu",
1473              orig_len, result, *pnwritten);
1474  cf->conn->sock[cf->sockindex] = fdsave;
1475  return result;
1476}
1477
1478static CURLcode cf_socket_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
1479                               char *buf, size_t len, size_t *pnread)
1480{
1481  struct cf_socket_ctx *ctx = cf->ctx;
1482  CURLcode result = CURLE_OK;
1483  ssize_t rv;
1484
1485  *pnread = 0;
1486#ifdef DEBUGBUILD
1487  /* simulate network blocking/partial reads */
1488  if(cf->cft != &Curl_cft_udp && ctx->rblock_percent > 0) {
1489    unsigned char c = 0;
1490    Curl_rand(data, &c, 1);
1491    if(c >= ((100 - ctx->rblock_percent) * 256 / 100)) {
1492      CURL_TRC_CF(data, cf, "recv(len=%zu) SIMULATE EWOULDBLOCK", len);
1493      return CURLE_AGAIN;
1494    }
1495  }
1496  if(cf->cft != &Curl_cft_udp && ctx->recv_max && ctx->recv_max < len) {
1497    CURL_TRC_CF(data, cf, "recv(len=%zu) SIMULATE max read of %zu bytes",
1498                len, ctx->recv_max);
1499    len = ctx->recv_max;
1500  }
1501#endif
1502
1503  rv = sread(ctx->sock, buf, len);
1504
1505  if(!curlx_sztouz(rv, pnread)) {
1506    int sockerr = SOCKERRNO;
1507
1508    if(
1509#ifdef USE_WINSOCK
1510      /* This is how Windows does it */
1511      (SOCKEWOULDBLOCK == sockerr)
1512#else
1513      /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
1514         due to its inability to send off data without blocking. We therefore
1515         treat both error codes the same here */
1516      (SOCKEWOULDBLOCK == sockerr) ||
1517      (EAGAIN == sockerr) || (SOCKEINTR == sockerr)
1518#endif
1519      ) {
1520      /* EWOULDBLOCK */
1521      result = CURLE_AGAIN;
1522    }
1523    else {
1524      char buffer[STRERROR_LEN];
1525      failf(data, "Recv failure: %s",
1526            curlx_strerror(sockerr, buffer, sizeof(buffer)));
1527      data->state.os_errno = sockerr;
1528      result = CURLE_RECV_ERROR;
1529    }
1530  }
1531
1532  CURL_TRC_CF(data, cf, "recv(len=%zu) -> %d, %zu", len, result, *pnread);
1533  if(!result && !ctx->got_first_byte) {
1534    ctx->first_byte_at = *Curl_pgrs_now(data);
1535    ctx->got_first_byte = TRUE;
1536  }
1537  return result;
1538}
1539
1540static void cf_socket_update_data(struct Curl_cfilter *cf,
1541                                  struct Curl_easy *data)
1542{
1543  /* Update the IP info held in the transfer, if we have that. */
1544  if(cf->connected && (cf->sockindex == FIRSTSOCKET)) {
1545    struct cf_socket_ctx *ctx = cf->ctx;
1546    data->info.primary = ctx->ip;
1547    /* not sure if this is redundant... */
1548    data->info.conn_remote_port = cf->conn->origin->port;
1549  }
1550}
1551
1552static void cf_socket_active(struct Curl_cfilter *cf, struct Curl_easy *data)
1553{
1554  struct cf_socket_ctx *ctx = cf->ctx;
1555
1556  /* use this socket from now on */
1557  cf->conn->sock[cf->sockindex] = ctx->sock;
1558  set_local_ip(cf, data);
1559#ifdef USE_IPV6
1560  if(cf->sockindex == FIRSTSOCKET)
1561    cf->conn->bits.ipv6 = (ctx->addr.family == AF_INET6);
1562#endif
1563  ctx->active = TRUE;
1564}
1565
1566static CURLcode cf_socket_cntrl(struct Curl_cfilter *cf,
1567                                struct Curl_easy *data,
1568                                int event, int arg1, void *arg2)
1569{
1570  struct cf_socket_ctx *ctx = cf->ctx;
1571
1572  (void)arg1;
1573  (void)arg2;
1574  switch(event) {
1575  case CF_CTRL_CONN_INFO_UPDATE:
1576    cf_socket_active(cf, data);
1577    cf_socket_update_data(cf, data);
1578    break;
1579  case CF_CTRL_DATA_SETUP:
1580    cf_socket_update_data(cf, data);
1581    break;
1582  case CF_CTRL_FORGET_SOCKET:
1583    ctx->sock = CURL_SOCKET_BAD;
1584    break;
1585  }
1586  return CURLE_OK;
1587}
1588
1589static bool cf_socket_conn_is_alive(struct Curl_cfilter *cf,
1590                                    struct Curl_easy *data,
1591                                    bool *input_pending)
1592{
1593  struct cf_socket_ctx *ctx = cf->ctx;
1594  struct pollfd pfd[1];
1595  int r;
1596
1597  *input_pending = FALSE;
1598
1599  if(!ctx || ctx->sock == CURL_SOCKET_BAD)
1600    return FALSE;
1601
1602  /* Check with 0 timeout if there are any events pending on the socket */
1603  pfd[0].fd = ctx->sock;
1604  pfd[0].events = POLLRDNORM | POLLIN | POLLRDBAND | POLLPRI;
1605  pfd[0].revents = 0;
1606
1607  r = Curl_poll(pfd, 1, 0);
1608  if(r < 0) {
1609    CURL_TRC_CF(data, cf, "is_alive: poll error, assume dead");
1610    return FALSE;
1611  }
1612  else if(r == 0) {
1613    CURL_TRC_CF(data, cf, "is_alive: poll timeout, assume alive");
1614    return TRUE;
1615  }
1616  else if(pfd[0].revents & (POLLERR | POLLHUP | POLLPRI | POLLNVAL)) {
1617    CURL_TRC_CF(data, cf, "is_alive: err/hup/etc events, assume dead");
1618    return FALSE;
1619  }
1620
1621  CURL_TRC_CF(data, cf, "is_alive: valid events, looks alive");
1622  *input_pending = TRUE;
1623  return TRUE;
1624}
1625
1626static CURLcode cf_socket_query(struct Curl_cfilter *cf,
1627                                struct Curl_easy *data,
1628                                int query, int *pres1, void *pres2)
1629{
1630  struct cf_socket_ctx *ctx = cf->ctx;
1631
1632  switch(query) {
1633  case CF_QUERY_SOCKET:
1634    DEBUGASSERT(pres2);
1635    *((curl_socket_t *)pres2) = ctx->sock;
1636    return CURLE_OK;
1637  case CF_QUERY_TRANSPORT:
1638    DEBUGASSERT(pres1);
1639    *pres1 = ctx->transport;
1640    return CURLE_OK;
1641  case CF_QUERY_REMOTE_ADDR:
1642    DEBUGASSERT(pres2);
1643    *((const struct Curl_sockaddr_ex **)pres2) = cf->connected ?
1644                                                 &ctx->addr : NULL;
1645    return CURLE_OK;
1646  case CF_QUERY_CONNECT_REPLY_MS:
1647    if(ctx->got_first_byte) {
1648      timediff_t ms = curlx_ptimediff_ms(&ctx->first_byte_at,
1649                                         &ctx->started_at);
1650      *pres1 = (ms < INT_MAX) ? (int)ms : INT_MAX;
1651    }
1652    else
1653      *pres1 = -1;
1654    return CURLE_OK;
1655  case CF_QUERY_TIMER_CONNECT: {
1656    struct curltime *when = pres2;
1657    switch(ctx->transport) {
1658    case TRNSPRT_UDP:
1659    case TRNSPRT_QUIC:
1660      /* Since UDP connected sockets work different from TCP, we use the
1661       * time of the first byte from the peer as the "connect" time. */
1662      if(ctx->got_first_byte) {
1663        *when = ctx->first_byte_at;
1664        break;
1665      }
1666      FALLTHROUGH();
1667    default:
1668      *when = ctx->connected_at;
1669      break;
1670    }
1671    return CURLE_OK;
1672  }
1673  case CF_QUERY_IP_INFO:
1674#ifdef USE_IPV6
1675    *pres1 = (ctx->addr.family == AF_INET6);
1676#else
1677    *pres1 = FALSE;
1678#endif
1679    *(struct ip_quadruple *)pres2 = ctx->ip;
1680    return CURLE_OK;
1681  default:
1682    break;
1683  }
1684  return cf->next ?
1685    cf->next->cft->query(cf->next, data, query, pres1, pres2) :
1686    CURLE_UNKNOWN_OPTION;
1687}
1688
1689struct Curl_cftype Curl_cft_tcp = {
1690  "TCP",
1691  CF_TYPE_IP_CONNECT,
1692  CURL_LOG_LVL_NONE,
1693  cf_socket_destroy,
1694  cf_tcp_connect,
1695  cf_socket_close,
1696  cf_socket_shutdown,
1697  cf_socket_adjust_pollset,
1698  Curl_cf_def_data_pending,
1699  cf_socket_send,
1700  cf_socket_recv,
1701  cf_socket_cntrl,
1702  cf_socket_conn_is_alive,
1703  Curl_cf_def_conn_keep_alive,
1704  cf_socket_query,
1705};
1706
1707CURLcode Curl_cf_tcp_create(struct Curl_cfilter **pcf,
1708                            struct Curl_easy *data,
1709                            struct connectdata *conn,
1710                            struct Curl_sockaddr_ex *addr,
1711                            uint8_t transport)
1712{
1713  struct cf_socket_ctx *ctx = NULL;
1714  struct Curl_cfilter *cf = NULL;
1715  CURLcode result;
1716
1717  (void)data;
1718  (void)conn;
1719  DEBUGASSERT(transport == TRNSPRT_TCP);
1720  if(!addr) {
1721    result = CURLE_BAD_FUNCTION_ARGUMENT;
1722    goto out;
1723  }
1724
1725  ctx = curlx_calloc(1, sizeof(*ctx));
1726  if(!ctx) {
1727    result = CURLE_OUT_OF_MEMORY;
1728    goto out;
1729  }
1730
1731  result = cf_socket_ctx_init(ctx, addr, transport);
1732  if(result)
1733    goto out;
1734
1735  result = Curl_cf_create(&cf, &Curl_cft_tcp, ctx);
1736
1737out:
1738  *pcf = (!result) ? cf : NULL;
1739  if(result) {
1740    curlx_safefree(cf);
1741    curlx_safefree(ctx);
1742  }
1743
1744  return result;
1745}
1746
1747#ifdef __linux__
1748static void linux_quic_mtu(struct cf_socket_ctx *ctx)
1749{
1750  int val;
1751  switch(ctx->addr.family) {
1752#ifdef IP_MTU_DISCOVER
1753  case AF_INET:
1754    val = IP_PMTUDISC_DO;
1755    (void)setsockopt(ctx->sock, IPPROTO_IP, IP_MTU_DISCOVER, &val,
1756                     sizeof(val));
1757    break;
1758#endif
1759#ifdef IPV6_MTU_DISCOVER
1760  case AF_INET6:
1761    val = IPV6_PMTUDISC_DO;
1762    (void)setsockopt(ctx->sock, IPPROTO_IPV6, IPV6_MTU_DISCOVER, &val,
1763                     sizeof(val));
1764    break;
1765#endif
1766  }
1767}
1768#else
1769#define linux_quic_mtu(x)
1770#endif
1771
1772#if defined(UDP_GRO) &&                                                 \
1773  (defined(HAVE_SENDMMSG) || defined(HAVE_SENDMSG)) &&                  \
1774  ((defined(USE_NGTCP2) && defined(USE_NGHTTP3)) || defined(USE_QUICHE))
1775static void linux_quic_gro(struct cf_socket_ctx *ctx)
1776{
1777  int one = 1;
1778  (void)setsockopt(ctx->sock, IPPROTO_UDP, UDP_GRO, &one,
1779                   (socklen_t)sizeof(one));
1780}
1781#else
1782#define linux_quic_gro(x)
1783#endif
1784
1785static CURLcode cf_udp_setup_quic(struct Curl_cfilter *cf,
1786                                  struct Curl_easy *data)
1787{
1788  struct cf_socket_ctx *ctx = cf->ctx;
1789  int rc;
1790
1791  /* QUIC needs a connected socket, nonblocking */
1792  DEBUGASSERT(ctx->sock != CURL_SOCKET_BAD);
1793
1794  /* error: The 1st argument to 'connect' is -1 but should be >= 0
1795     NOLINTNEXTLINE(clang-analyzer-unix.StdCLibraryFunctions) */
1796  rc = connect(ctx->sock, &ctx->addr.curl_sa_addr,
1797               (curl_socklen_t)ctx->addr.addrlen);
1798  if(rc == -1) {
1799    return socket_connect_result(data, ctx->ip.remote_ip, SOCKERRNO);
1800  }
1801  ctx->sock_connected = TRUE;
1802  set_local_ip(cf, data);
1803  CURL_TRC_CF(data, cf, "%s socket %" FMT_SOCKET_T
1804              " connected: [%s:%d] -> [%s:%d]",
1805              (ctx->transport == TRNSPRT_QUIC) ? "QUIC" : "UDP",
1806              ctx->sock, ctx->ip.local_ip, ctx->ip.local_port,
1807              ctx->ip.remote_ip, ctx->ip.remote_port);
1808
1809  /* Currently, cf->ctx->sock is always non-blocking because the only
1810   * caller to cf_udp_setup_quic() is cf_udp_connect() that passes the
1811   * non-blocking socket created by cf_socket_open() to it. Thus, we
1812   * do not need to call curlx_nonblock() in cf_udp_setup_quic() anymore.
1813   */
1814  linux_quic_mtu(ctx);
1815  linux_quic_gro(ctx);
1816
1817  return CURLE_OK;
1818}
1819
1820static CURLcode cf_udp_connect(struct Curl_cfilter *cf,
1821                               struct Curl_easy *data,
1822                               bool *done)
1823{
1824  struct cf_socket_ctx *ctx = cf->ctx;
1825  CURLcode result = CURLE_COULDNT_CONNECT;
1826
1827  if(cf->connected) {
1828    *done = TRUE;
1829    return CURLE_OK;
1830  }
1831
1832  *done = FALSE;
1833  if(ctx->sock == CURL_SOCKET_BAD) {
1834    result = cf_socket_open(cf, data);
1835    if(result) {
1836      CURL_TRC_CF(data, cf, "cf_udp_connect(), open failed -> %d", result);
1837      goto out;
1838    }
1839
1840    if(ctx->transport == TRNSPRT_QUIC) {
1841      result = cf_udp_setup_quic(cf, data);
1842      if(result)
1843        goto out;
1844      CURL_TRC_CF(data, cf, "cf_udp_connect(), opened socket=%"
1845                  FMT_SOCKET_T " (%s:%d)",
1846                  ctx->sock, ctx->ip.local_ip, ctx->ip.local_port);
1847    }
1848    *done = TRUE;
1849    cf->connected = TRUE;
1850  }
1851out:
1852  return result;
1853}
1854
1855struct Curl_cftype Curl_cft_udp = {
1856  "UDP",
1857  CF_TYPE_IP_CONNECT,
1858  CURL_LOG_LVL_NONE,
1859  cf_socket_destroy,
1860  cf_udp_connect,
1861  cf_socket_close,
1862  cf_socket_shutdown,
1863  cf_socket_adjust_pollset,
1864  Curl_cf_def_data_pending,
1865  cf_socket_send,
1866  cf_socket_recv,
1867  cf_socket_cntrl,
1868  cf_socket_conn_is_alive,
1869  Curl_cf_def_conn_keep_alive,
1870  cf_socket_query,
1871};
1872
1873CURLcode Curl_cf_udp_create(struct Curl_cfilter **pcf,
1874                            struct Curl_easy *data,
1875                            struct connectdata *conn,
1876                            struct Curl_sockaddr_ex *addr,
1877                            uint8_t transport)
1878{
1879  struct cf_socket_ctx *ctx = NULL;
1880  struct Curl_cfilter *cf = NULL;
1881  CURLcode result;
1882
1883  (void)data;
1884  (void)conn;
1885  DEBUGASSERT(transport == TRNSPRT_UDP || transport == TRNSPRT_QUIC);
1886  ctx = curlx_calloc(1, sizeof(*ctx));
1887  if(!ctx) {
1888    result = CURLE_OUT_OF_MEMORY;
1889    goto out;
1890  }
1891
1892  result = cf_socket_ctx_init(ctx, addr, transport);
1893  if(result)
1894    goto out;
1895
1896  result = Curl_cf_create(&cf, &Curl_cft_udp, ctx);
1897
1898out:
1899  *pcf = (!result) ? cf : NULL;
1900  if(result) {
1901    curlx_safefree(cf);
1902    curlx_safefree(ctx);
1903  }
1904
1905  return result;
1906}
1907
1908/* this is the TCP filter which can also handle this case */
1909struct Curl_cftype Curl_cft_unix = {
1910  "UNIX",
1911  CF_TYPE_IP_CONNECT,
1912  CURL_LOG_LVL_NONE,
1913  cf_socket_destroy,
1914  cf_tcp_connect,
1915  cf_socket_close,
1916  cf_socket_shutdown,
1917  cf_socket_adjust_pollset,
1918  Curl_cf_def_data_pending,
1919  cf_socket_send,
1920  cf_socket_recv,
1921  cf_socket_cntrl,
1922  cf_socket_conn_is_alive,
1923  Curl_cf_def_conn_keep_alive,
1924  cf_socket_query,
1925};
1926
1927CURLcode Curl_cf_unix_create(struct Curl_cfilter **pcf,
1928                             struct Curl_easy *data,
1929                             struct connectdata *conn,
1930                             struct Curl_sockaddr_ex *addr,
1931                             uint8_t transport)
1932{
1933  struct cf_socket_ctx *ctx = NULL;
1934  struct Curl_cfilter *cf = NULL;
1935  CURLcode result;
1936
1937  (void)data;
1938  (void)conn;
1939  DEBUGASSERT(transport == TRNSPRT_UNIX);
1940  ctx = curlx_calloc(1, sizeof(*ctx));
1941  if(!ctx) {
1942    result = CURLE_OUT_OF_MEMORY;
1943    goto out;
1944  }
1945
1946  result = cf_socket_ctx_init(ctx, addr, transport);
1947  if(result)
1948    goto out;
1949
1950  result = Curl_cf_create(&cf, &Curl_cft_unix, ctx);
1951
1952out:
1953  *pcf = (!result) ? cf : NULL;
1954  if(result) {
1955    curlx_safefree(cf);
1956    curlx_safefree(ctx);
1957  }
1958
1959  return result;
1960}
1961
1962static timediff_t cf_tcp_accept_timeleft(struct Curl_cfilter *cf,
1963                                         struct Curl_easy *data)
1964{
1965  struct cf_socket_ctx *ctx = cf->ctx;
1966  timediff_t timeout_ms = DEFAULT_ACCEPT_TIMEOUT;
1967  timediff_t other_ms;
1968
1969#ifndef CURL_DISABLE_FTP
1970  if(data->set.accepttimeout > 0)
1971    timeout_ms = data->set.accepttimeout;
1972#endif
1973
1974  /* check if the generic timeout possibly is set shorter */
1975  other_ms = Curl_timeleft_ms(data);
1976  if(other_ms && (other_ms < timeout_ms))
1977    /* note that this also works fine for when other_ms happens to be negative
1978       due to it already having elapsed */
1979    timeout_ms = other_ms;
1980  else {
1981    /* subtract elapsed time */
1982    timeout_ms -= curlx_ptimediff_ms(Curl_pgrs_now(data), &ctx->started_at);
1983    if(!timeout_ms)
1984      /* avoid returning 0 as that means no timeout! */
1985      timeout_ms = -1;
1986  }
1987  return timeout_ms;
1988}
1989
1990static void cf_tcp_set_accepted_remote_ip(struct Curl_cfilter *cf,
1991                                          struct Curl_easy *data)
1992{
1993  struct cf_socket_ctx *ctx = cf->ctx;
1994#ifdef HAVE_GETPEERNAME
1995  char buffer[STRERROR_LEN];
1996  struct Curl_sockaddr_storage ssrem;
1997  curl_socklen_t plen;
1998
1999  ctx->ip.remote_ip[0] = 0;
2000  ctx->ip.remote_port = 0;
2001  plen = sizeof(ssrem);
2002  memset(&ssrem, 0, plen);
2003  if(getpeername(ctx->sock, (struct sockaddr *)&ssrem, &plen)) {
2004    int error = SOCKERRNO;
2005    failf(data, "getpeername() failed with errno %d: %s",
2006          error, curlx_strerror(error, buffer, sizeof(buffer)));
2007    return;
2008  }
2009  if(!Curl_addr2string((struct sockaddr *)&ssrem, plen,
2010                       ctx->ip.remote_ip, &ctx->ip.remote_port)) {
2011    failf(data, "ssrem inet_ntop() failed with errno %d: %s",
2012          errno, curlx_strerror(errno, buffer, sizeof(buffer)));
2013    return;
2014  }
2015#else
2016  ctx->ip.remote_ip[0] = 0;
2017  ctx->ip.remote_port = 0;
2018  (void)data;
2019#endif
2020}
2021
2022static CURLcode cf_tcp_accept_connect(struct Curl_cfilter *cf,
2023                                      struct Curl_easy *data,
2024                                      bool *done)
2025{
2026  struct cf_socket_ctx *ctx = cf->ctx;
2027  char errbuf[STRERROR_LEN];
2028#ifdef USE_IPV6
2029  struct Curl_sockaddr_storage add;
2030#else
2031  struct sockaddr_in add;
2032#endif
2033  curl_socklen_t size = (curl_socklen_t)sizeof(add);
2034  curl_socket_t s_accepted = CURL_SOCKET_BAD;
2035  timediff_t timeout_ms;
2036  int socketstate = 0;
2037  bool incoming = FALSE;
2038
2039  /* we start accepted, if we ever close, we cannot go on */
2040  (void)data;
2041  if(cf->connected) {
2042    *done = TRUE;
2043    return CURLE_OK;
2044  }
2045
2046  *done = FALSE;
2047  timeout_ms = cf_tcp_accept_timeleft(cf, data);
2048  if(timeout_ms < 0) {
2049    /* if a timeout was already reached, bail out */
2050    failf(data, "Accept timeout occurred while waiting server connect");
2051    return CURLE_FTP_ACCEPT_TIMEOUT;
2052  }
2053
2054  CURL_TRC_CF(data, cf, "Checking for incoming on fd=%" FMT_SOCKET_T
2055              " ip=%s:%d", ctx->sock, ctx->ip.local_ip, ctx->ip.local_port);
2056  socketstate = SOCKET_READABLE(ctx->sock, 0);
2057  CURL_TRC_CF(data, cf, "socket_check -> %x", socketstate);
2058  switch(socketstate) {
2059  case -1: /* error */
2060    /* let's die here */
2061    failf(data, "Error while waiting for server connect");
2062    return CURLE_FTP_ACCEPT_FAILED;
2063  default:
2064    if(socketstate & CURL_CSELECT_IN) {
2065      infof(data, "Ready to accept data connection from server");
2066      incoming = TRUE;
2067    }
2068    break;
2069  }
2070
2071  if(!incoming) {
2072    CURL_TRC_CF(data, cf, "nothing heard from the server yet");
2073    return CURLE_OK;
2074  }
2075
2076  size = sizeof(add);
2077#ifdef HAVE_ACCEPT4
2078  s_accepted = CURL_ACCEPT4(ctx->sock, (struct sockaddr *)&add, &size,
2079                            SOCK_NONBLOCK | SOCK_CLOEXEC);
2080#else
2081  s_accepted = CURL_ACCEPT(ctx->sock, (struct sockaddr *)&add, &size);
2082#endif
2083
2084  if(s_accepted == CURL_SOCKET_BAD) {
2085    failf(data, "Error accept()ing server connect: %s",
2086          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
2087    return CURLE_FTP_ACCEPT_FAILED;
2088  }
2089#ifndef HAVE_ACCEPT4
2090#ifdef HAVE_FCNTL
2091  if(fcntl(s_accepted, F_SETFD, FD_CLOEXEC) < 0) {
2092    failf(data, "fcntl set CLOEXEC: %s",
2093          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
2094    Curl_socket_close(data, cf->conn, s_accepted);
2095    return CURLE_FTP_ACCEPT_FAILED;
2096  }
2097#endif /* HAVE_FCNTL */
2098  if(curlx_nonblock(s_accepted, TRUE) < 0) {
2099    failf(data, "set socket NONBLOCK: %s",
2100          curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf)));
2101    Curl_socket_close(data, cf->conn, s_accepted);
2102    return CURLE_FTP_ACCEPT_FAILED;
2103  }
2104#endif /* !HAVE_ACCEPT4 */
2105  infof(data, "Connection accepted from server");
2106
2107  /* Replace any filter on SECONDARY with one listening on this socket */
2108  ctx->listening = FALSE;
2109  ctx->accepted = TRUE;
2110  socket_close(data, cf->conn, TRUE, ctx->sock);
2111  ctx->sock = s_accepted;
2112
2113  cf->conn->sock[cf->sockindex] = ctx->sock;
2114  cf_tcp_set_accepted_remote_ip(cf, data);
2115  set_local_ip(cf, data);
2116  ctx->active = TRUE;
2117  ctx->connected_at = *Curl_pgrs_now(data);
2118  cf->connected = TRUE;
2119  CURL_TRC_CF(data, cf, "accepted_set(sock=%" FMT_SOCKET_T
2120              ", remote=%s port=%d)",
2121              ctx->sock, ctx->ip.remote_ip, ctx->ip.remote_port);
2122
2123  if(data->set.fsockopt) {
2124    int error = 0;
2125
2126    /* activate callback for setting socket options */
2127    Curl_set_in_callback(data, true);
2128    error = data->set.fsockopt(data->set.sockopt_client,
2129                               ctx->sock, CURLSOCKTYPE_ACCEPT);
2130    Curl_set_in_callback(data, false);
2131
2132    if(error)
2133      return CURLE_ABORTED_BY_CALLBACK;
2134  }
2135  *done = TRUE;
2136  return CURLE_OK;
2137}
2138
2139struct Curl_cftype Curl_cft_tcp_accept = {
2140  "TCP-ACCEPT",
2141  CF_TYPE_IP_CONNECT,
2142  CURL_LOG_LVL_NONE,
2143  cf_socket_destroy,
2144  cf_tcp_accept_connect,
2145  cf_socket_close,
2146  cf_socket_shutdown,
2147  cf_socket_adjust_pollset,
2148  Curl_cf_def_data_pending,
2149  cf_socket_send,
2150  cf_socket_recv,
2151  cf_socket_cntrl,
2152  cf_socket_conn_is_alive,
2153  Curl_cf_def_conn_keep_alive,
2154  cf_socket_query,
2155};
2156
2157CURLcode Curl_conn_tcp_listen_set(struct Curl_easy *data,
2158                                  struct connectdata *conn,
2159                                  int sockindex, curl_socket_t *s)
2160{
2161  CURLcode result;
2162  struct Curl_cfilter *cf = NULL;
2163  struct cf_socket_ctx *ctx = NULL;
2164
2165  /* replace any existing */
2166  Curl_conn_cf_discard_all(data, conn, sockindex);
2167  DEBUGASSERT(conn->sock[sockindex] == CURL_SOCKET_BAD);
2168
2169  ctx = curlx_calloc(1, sizeof(*ctx));
2170  if(!ctx) {
2171    result = CURLE_OUT_OF_MEMORY;
2172    goto out;
2173  }
2174  ctx->transport = TRNSPRT_TCP;
2175  ctx->sock = *s;
2176  ctx->listening = TRUE;
2177  ctx->accepted = FALSE;
2178  result = Curl_cf_create(&cf, &Curl_cft_tcp_accept, ctx);
2179  if(result)
2180    goto out;
2181  Curl_conn_cf_add(data, conn, sockindex, cf);
2182
2183  ctx->started_at = *Curl_pgrs_now(data);
2184  conn->sock[sockindex] = ctx->sock;
2185  set_local_ip(cf, data);
2186  CURL_TRC_CF(data, cf, "set filter for listen socket fd=%" FMT_SOCKET_T
2187              " ip=%s:%d", ctx->sock,
2188              ctx->ip.local_ip, ctx->ip.local_port);
2189
2190out:
2191  if(result) {
2192    curlx_safefree(cf);
2193    curlx_safefree(ctx);
2194  }
2195  return result;
2196}
2197
2198bool Curl_conn_is_tcp_listen(struct Curl_easy *data,
2199                             int sockindex)
2200{
2201  struct Curl_cfilter *cf = data->conn->cfilter[sockindex];
2202  while(cf) {
2203    if(cf->cft == &Curl_cft_tcp_accept)
2204      return TRUE;
2205    cf = cf->next;
2206  }
2207  return FALSE;
2208}
2209
2210/**
2211 * Return TRUE iff `cf` is a socket filter.
2212 */
2213static bool cf_is_socket(struct Curl_cfilter *cf)
2214{
2215  return cf && (cf->cft == &Curl_cft_tcp ||
2216                cf->cft == &Curl_cft_udp ||
2217                cf->cft == &Curl_cft_unix ||
2218                cf->cft == &Curl_cft_tcp_accept);
2219}
2220
2221CURLcode Curl_cf_socket_peek(struct Curl_cfilter *cf,
2222                             struct Curl_easy *data,
2223                             curl_socket_t *psock,
2224                             const struct Curl_sockaddr_ex **paddr,
2225                             struct ip_quadruple *pip)
2226{
2227  (void)data;
2228  if(cf_is_socket(cf) && cf->ctx) {
2229    struct cf_socket_ctx *ctx = cf->ctx;
2230
2231    if(psock)
2232      *psock = ctx->sock;
2233    if(paddr)
2234      *paddr = &ctx->addr;
2235    if(pip)
2236      *pip = ctx->ip;
2237    return CURLE_OK;
2238  }
2239  return CURLE_FAILED_INIT;
2240}