Annotation of embedaddon/curl/lib/connect.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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.haxx.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: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #ifdef HAVE_NETINET_IN_H
! 26: #include <netinet/in.h> /* <netinet/tcp.h> may need it */
! 27: #endif
! 28: #ifdef HAVE_SYS_UN_H
! 29: #include <sys/un.h> /* for sockaddr_un */
! 30: #endif
! 31: #ifdef HAVE_LINUX_TCP_H
! 32: #include <linux/tcp.h>
! 33: #elif defined(HAVE_NETINET_TCP_H)
! 34: #include <netinet/tcp.h>
! 35: #endif
! 36: #ifdef HAVE_SYS_IOCTL_H
! 37: #include <sys/ioctl.h>
! 38: #endif
! 39: #ifdef HAVE_NETDB_H
! 40: #include <netdb.h>
! 41: #endif
! 42: #ifdef HAVE_FCNTL_H
! 43: #include <fcntl.h>
! 44: #endif
! 45: #ifdef HAVE_ARPA_INET_H
! 46: #include <arpa/inet.h>
! 47: #endif
! 48:
! 49: #if (defined(HAVE_IOCTL_FIONBIO) && defined(NETWARE))
! 50: #include <sys/filio.h>
! 51: #endif
! 52: #ifdef NETWARE
! 53: #undef in_addr_t
! 54: #define in_addr_t unsigned long
! 55: #endif
! 56: #ifdef __VMS
! 57: #include <in.h>
! 58: #include <inet.h>
! 59: #endif
! 60:
! 61: #include "urldata.h"
! 62: #include "sendf.h"
! 63: #include "if2ip.h"
! 64: #include "strerror.h"
! 65: #include "connect.h"
! 66: #include "select.h"
! 67: #include "url.h" /* for Curl_safefree() */
! 68: #include "multiif.h"
! 69: #include "sockaddr.h" /* required for Curl_sockaddr_storage */
! 70: #include "inet_ntop.h"
! 71: #include "inet_pton.h"
! 72: #include "vtls/vtls.h" /* for Curl_ssl_check_cxn() */
! 73: #include "progress.h"
! 74: #include "warnless.h"
! 75: #include "conncache.h"
! 76: #include "multihandle.h"
! 77: #include "system_win32.h"
! 78: #include "quic.h"
! 79: #include "socks.h"
! 80:
! 81: /* The last 3 #include files should be in this order */
! 82: #include "curl_printf.h"
! 83: #include "curl_memory.h"
! 84: #include "memdebug.h"
! 85:
! 86: #ifdef __SYMBIAN32__
! 87: /* This isn't actually supported under Symbian OS */
! 88: #undef SO_NOSIGPIPE
! 89: #endif
! 90:
! 91: static bool verifyconnect(curl_socket_t sockfd, int *error);
! 92:
! 93: #if defined(__DragonFly__) || defined(HAVE_WINSOCK_H)
! 94: /* DragonFlyBSD and Windows use millisecond units */
! 95: #define KEEPALIVE_FACTOR(x) (x *= 1000)
! 96: #else
! 97: #define KEEPALIVE_FACTOR(x)
! 98: #endif
! 99:
! 100: #if defined(HAVE_WINSOCK2_H) && !defined(SIO_KEEPALIVE_VALS)
! 101: #define SIO_KEEPALIVE_VALS _WSAIOW(IOC_VENDOR,4)
! 102:
! 103: struct tcp_keepalive {
! 104: u_long onoff;
! 105: u_long keepalivetime;
! 106: u_long keepaliveinterval;
! 107: };
! 108: #endif
! 109:
! 110: static void
! 111: tcpkeepalive(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: infof(data, "Failed to set SO_KEEPALIVE on fd %d\n", sockfd);
! 120: }
! 121: else {
! 122: #if defined(SIO_KEEPALIVE_VALS)
! 123: struct tcp_keepalive vals;
! 124: DWORD dummy;
! 125: vals.onoff = 1;
! 126: optval = curlx_sltosi(data->set.tcp_keepidle);
! 127: KEEPALIVE_FACTOR(optval);
! 128: vals.keepalivetime = optval;
! 129: optval = curlx_sltosi(data->set.tcp_keepintvl);
! 130: KEEPALIVE_FACTOR(optval);
! 131: vals.keepaliveinterval = optval;
! 132: if(WSAIoctl(sockfd, SIO_KEEPALIVE_VALS, (LPVOID) &vals, sizeof(vals),
! 133: NULL, 0, &dummy, NULL, NULL) != 0) {
! 134: infof(data, "Failed to set SIO_KEEPALIVE_VALS on fd %d: %d\n",
! 135: (int)sockfd, WSAGetLastError());
! 136: }
! 137: #else
! 138: #ifdef TCP_KEEPIDLE
! 139: optval = curlx_sltosi(data->set.tcp_keepidle);
! 140: KEEPALIVE_FACTOR(optval);
! 141: if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
! 142: (void *)&optval, sizeof(optval)) < 0) {
! 143: infof(data, "Failed to set TCP_KEEPIDLE on fd %d\n", sockfd);
! 144: }
! 145: #endif
! 146: #ifdef TCP_KEEPINTVL
! 147: optval = curlx_sltosi(data->set.tcp_keepintvl);
! 148: KEEPALIVE_FACTOR(optval);
! 149: if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL,
! 150: (void *)&optval, sizeof(optval)) < 0) {
! 151: infof(data, "Failed to set TCP_KEEPINTVL on fd %d\n", sockfd);
! 152: }
! 153: #endif
! 154: #ifdef TCP_KEEPALIVE
! 155: /* Mac OS X style */
! 156: optval = curlx_sltosi(data->set.tcp_keepidle);
! 157: KEEPALIVE_FACTOR(optval);
! 158: if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPALIVE,
! 159: (void *)&optval, sizeof(optval)) < 0) {
! 160: infof(data, "Failed to set TCP_KEEPALIVE on fd %d\n", sockfd);
! 161: }
! 162: #endif
! 163: #endif
! 164: }
! 165: }
! 166:
! 167: static CURLcode
! 168: singleipconnect(struct connectdata *conn,
! 169: const Curl_addrinfo *ai, /* start connecting to this */
! 170: int tempindex); /* 0 or 1 among the temp ones */
! 171:
! 172: /*
! 173: * Curl_timeleft() returns the amount of milliseconds left allowed for the
! 174: * transfer/connection. If the value is 0, there's no timeout (ie there's
! 175: * infinite time left). If the value is negative, the timeout time has already
! 176: * elapsed.
! 177: *
! 178: * The start time is stored in progress.t_startsingle - as set with
! 179: * Curl_pgrsTime(..., TIMER_STARTSINGLE);
! 180: *
! 181: * If 'nowp' is non-NULL, it points to the current time.
! 182: * 'duringconnect' is FALSE if not during a connect, as then of course the
! 183: * connect timeout is not taken into account!
! 184: *
! 185: * @unittest: 1303
! 186: */
! 187: timediff_t Curl_timeleft(struct Curl_easy *data,
! 188: struct curltime *nowp,
! 189: bool duringconnect)
! 190: {
! 191: int timeout_set = 0;
! 192: timediff_t timeout_ms = duringconnect?DEFAULT_CONNECT_TIMEOUT:0;
! 193: struct curltime now;
! 194:
! 195: /* if a timeout is set, use the most restrictive one */
! 196:
! 197: if(data->set.timeout > 0)
! 198: timeout_set |= 1;
! 199: if(duringconnect && (data->set.connecttimeout > 0))
! 200: timeout_set |= 2;
! 201:
! 202: switch(timeout_set) {
! 203: case 1:
! 204: timeout_ms = data->set.timeout;
! 205: break;
! 206: case 2:
! 207: timeout_ms = data->set.connecttimeout;
! 208: break;
! 209: case 3:
! 210: if(data->set.timeout < data->set.connecttimeout)
! 211: timeout_ms = data->set.timeout;
! 212: else
! 213: timeout_ms = data->set.connecttimeout;
! 214: break;
! 215: default:
! 216: /* use the default */
! 217: if(!duringconnect)
! 218: /* if we're not during connect, there's no default timeout so if we're
! 219: at zero we better just return zero and not make it a negative number
! 220: by the math below */
! 221: return 0;
! 222: break;
! 223: }
! 224:
! 225: if(!nowp) {
! 226: now = Curl_now();
! 227: nowp = &now;
! 228: }
! 229:
! 230: /* subtract elapsed time */
! 231: if(duringconnect)
! 232: /* since this most recent connect started */
! 233: timeout_ms -= Curl_timediff(*nowp, data->progress.t_startsingle);
! 234: else
! 235: /* since the entire operation started */
! 236: timeout_ms -= Curl_timediff(*nowp, data->progress.t_startop);
! 237: if(!timeout_ms)
! 238: /* avoid returning 0 as that means no timeout! */
! 239: return -1;
! 240:
! 241: return timeout_ms;
! 242: }
! 243:
! 244: static CURLcode bindlocal(struct connectdata *conn,
! 245: curl_socket_t sockfd, int af, unsigned int scope)
! 246: {
! 247: struct Curl_easy *data = conn->data;
! 248:
! 249: struct Curl_sockaddr_storage sa;
! 250: struct sockaddr *sock = (struct sockaddr *)&sa; /* bind to this address */
! 251: curl_socklen_t sizeof_sa = 0; /* size of the data sock points to */
! 252: struct sockaddr_in *si4 = (struct sockaddr_in *)&sa;
! 253: #ifdef ENABLE_IPV6
! 254: struct sockaddr_in6 *si6 = (struct sockaddr_in6 *)&sa;
! 255: #endif
! 256:
! 257: struct Curl_dns_entry *h = NULL;
! 258: unsigned short port = data->set.localport; /* use this port number, 0 for
! 259: "random" */
! 260: /* how many port numbers to try to bind to, increasing one at a time */
! 261: int portnum = data->set.localportrange;
! 262: const char *dev = data->set.str[STRING_DEVICE];
! 263: int error;
! 264:
! 265: /*************************************************************
! 266: * Select device to bind socket to
! 267: *************************************************************/
! 268: if(!dev && !port)
! 269: /* no local kind of binding was requested */
! 270: return CURLE_OK;
! 271:
! 272: memset(&sa, 0, sizeof(struct Curl_sockaddr_storage));
! 273:
! 274: if(dev && (strlen(dev)<255) ) {
! 275: char myhost[256] = "";
! 276: int done = 0; /* -1 for error, 1 for address found */
! 277: bool is_interface = FALSE;
! 278: bool is_host = FALSE;
! 279: static const char *if_prefix = "if!";
! 280: static const char *host_prefix = "host!";
! 281:
! 282: if(strncmp(if_prefix, dev, strlen(if_prefix)) == 0) {
! 283: dev += strlen(if_prefix);
! 284: is_interface = TRUE;
! 285: }
! 286: else if(strncmp(host_prefix, dev, strlen(host_prefix)) == 0) {
! 287: dev += strlen(host_prefix);
! 288: is_host = TRUE;
! 289: }
! 290:
! 291: /* interface */
! 292: if(!is_host) {
! 293: #ifdef SO_BINDTODEVICE
! 294: /* I am not sure any other OSs than Linux that provide this feature,
! 295: * and at the least I cannot test. --Ben
! 296: *
! 297: * This feature allows one to tightly bind the local socket to a
! 298: * particular interface. This will force even requests to other
! 299: * local interfaces to go out the external interface.
! 300: *
! 301: *
! 302: * Only bind to the interface when specified as interface, not just
! 303: * as a hostname or ip address.
! 304: *
! 305: * interface might be a VRF, eg: vrf-blue, which means it cannot be
! 306: * converted to an IP address and would fail Curl_if2ip. Simply try
! 307: * to use it straight away.
! 308: */
! 309: if(setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE,
! 310: dev, (curl_socklen_t)strlen(dev) + 1) == 0) {
! 311: /* This is typically "errno 1, error: Operation not permitted" if
! 312: * you're not running as root or another suitable privileged
! 313: * user.
! 314: * If it succeeds it means the parameter was a valid interface and
! 315: * not an IP address. Return immediately.
! 316: */
! 317: return CURLE_OK;
! 318: }
! 319: #endif
! 320:
! 321: switch(Curl_if2ip(af, scope, conn->scope_id, dev,
! 322: myhost, sizeof(myhost))) {
! 323: case IF2IP_NOT_FOUND:
! 324: if(is_interface) {
! 325: /* Do not fall back to treating it as a host name */
! 326: failf(data, "Couldn't bind to interface '%s'", dev);
! 327: return CURLE_INTERFACE_FAILED;
! 328: }
! 329: break;
! 330: case IF2IP_AF_NOT_SUPPORTED:
! 331: /* Signal the caller to try another address family if available */
! 332: return CURLE_UNSUPPORTED_PROTOCOL;
! 333: case IF2IP_FOUND:
! 334: is_interface = TRUE;
! 335: /*
! 336: * We now have the numerical IP address in the 'myhost' buffer
! 337: */
! 338: infof(data, "Local Interface %s is ip %s using address family %i\n",
! 339: dev, myhost, af);
! 340: done = 1;
! 341: break;
! 342: }
! 343: }
! 344: if(!is_interface) {
! 345: /*
! 346: * This was not an interface, resolve the name as a host name
! 347: * or IP number
! 348: *
! 349: * Temporarily force name resolution to use only the address type
! 350: * of the connection. The resolve functions should really be changed
! 351: * to take a type parameter instead.
! 352: */
! 353: long ipver = conn->ip_version;
! 354: int rc;
! 355:
! 356: if(af == AF_INET)
! 357: conn->ip_version = CURL_IPRESOLVE_V4;
! 358: #ifdef ENABLE_IPV6
! 359: else if(af == AF_INET6)
! 360: conn->ip_version = CURL_IPRESOLVE_V6;
! 361: #endif
! 362:
! 363: rc = Curl_resolv(conn, dev, 0, FALSE, &h);
! 364: if(rc == CURLRESOLV_PENDING)
! 365: (void)Curl_resolver_wait_resolv(conn, &h);
! 366: conn->ip_version = ipver;
! 367:
! 368: if(h) {
! 369: /* convert the resolved address, sizeof myhost >= INET_ADDRSTRLEN */
! 370: Curl_printable_address(h->addr, myhost, sizeof(myhost));
! 371: infof(data, "Name '%s' family %i resolved to '%s' family %i\n",
! 372: dev, af, myhost, h->addr->ai_family);
! 373: Curl_resolv_unlock(data, h);
! 374: if(af != h->addr->ai_family) {
! 375: /* bad IP version combo, signal the caller to try another address
! 376: family if available */
! 377: return CURLE_UNSUPPORTED_PROTOCOL;
! 378: }
! 379: done = 1;
! 380: }
! 381: else {
! 382: /*
! 383: * provided dev was no interface (or interfaces are not supported
! 384: * e.g. solaris) no ip address and no domain we fail here
! 385: */
! 386: done = -1;
! 387: }
! 388: }
! 389:
! 390: if(done > 0) {
! 391: #ifdef ENABLE_IPV6
! 392: /* IPv6 address */
! 393: if(af == AF_INET6) {
! 394: #ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
! 395: char *scope_ptr = strchr(myhost, '%');
! 396: if(scope_ptr)
! 397: *(scope_ptr++) = 0;
! 398: #endif
! 399: if(Curl_inet_pton(AF_INET6, myhost, &si6->sin6_addr) > 0) {
! 400: si6->sin6_family = AF_INET6;
! 401: si6->sin6_port = htons(port);
! 402: #ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
! 403: if(scope_ptr)
! 404: /* The "myhost" string either comes from Curl_if2ip or from
! 405: Curl_printable_address. The latter returns only numeric scope
! 406: IDs and the former returns none at all. So the scope ID, if
! 407: present, is known to be numeric */
! 408: si6->sin6_scope_id = atoi(scope_ptr);
! 409: #endif
! 410: }
! 411: sizeof_sa = sizeof(struct sockaddr_in6);
! 412: }
! 413: else
! 414: #endif
! 415: /* IPv4 address */
! 416: if((af == AF_INET) &&
! 417: (Curl_inet_pton(AF_INET, myhost, &si4->sin_addr) > 0)) {
! 418: si4->sin_family = AF_INET;
! 419: si4->sin_port = htons(port);
! 420: sizeof_sa = sizeof(struct sockaddr_in);
! 421: }
! 422: }
! 423:
! 424: if(done < 1) {
! 425: /* errorbuf is set false so failf will overwrite any message already in
! 426: the error buffer, so the user receives this error message instead of a
! 427: generic resolve error. */
! 428: data->state.errorbuf = FALSE;
! 429: failf(data, "Couldn't bind to '%s'", dev);
! 430: return CURLE_INTERFACE_FAILED;
! 431: }
! 432: }
! 433: else {
! 434: /* no device was given, prepare sa to match af's needs */
! 435: #ifdef ENABLE_IPV6
! 436: if(af == AF_INET6) {
! 437: si6->sin6_family = AF_INET6;
! 438: si6->sin6_port = htons(port);
! 439: sizeof_sa = sizeof(struct sockaddr_in6);
! 440: }
! 441: else
! 442: #endif
! 443: if(af == AF_INET) {
! 444: si4->sin_family = AF_INET;
! 445: si4->sin_port = htons(port);
! 446: sizeof_sa = sizeof(struct sockaddr_in);
! 447: }
! 448: }
! 449:
! 450: for(;;) {
! 451: if(bind(sockfd, sock, sizeof_sa) >= 0) {
! 452: /* we succeeded to bind */
! 453: struct Curl_sockaddr_storage add;
! 454: curl_socklen_t size = sizeof(add);
! 455: memset(&add, 0, sizeof(struct Curl_sockaddr_storage));
! 456: if(getsockname(sockfd, (struct sockaddr *) &add, &size) < 0) {
! 457: char buffer[STRERROR_LEN];
! 458: data->state.os_errno = error = SOCKERRNO;
! 459: failf(data, "getsockname() failed with errno %d: %s",
! 460: error, Curl_strerror(error, buffer, sizeof(buffer)));
! 461: return CURLE_INTERFACE_FAILED;
! 462: }
! 463: infof(data, "Local port: %hu\n", port);
! 464: conn->bits.bound = TRUE;
! 465: return CURLE_OK;
! 466: }
! 467:
! 468: if(--portnum > 0) {
! 469: infof(data, "Bind to local port %hu failed, trying next\n", port);
! 470: port++; /* try next port */
! 471: /* We re-use/clobber the port variable here below */
! 472: if(sock->sa_family == AF_INET)
! 473: si4->sin_port = ntohs(port);
! 474: #ifdef ENABLE_IPV6
! 475: else
! 476: si6->sin6_port = ntohs(port);
! 477: #endif
! 478: }
! 479: else
! 480: break;
! 481: }
! 482: {
! 483: char buffer[STRERROR_LEN];
! 484: data->state.os_errno = error = SOCKERRNO;
! 485: failf(data, "bind failed with errno %d: %s",
! 486: error, Curl_strerror(error, buffer, sizeof(buffer)));
! 487: }
! 488:
! 489: return CURLE_INTERFACE_FAILED;
! 490: }
! 491:
! 492: /*
! 493: * verifyconnect() returns TRUE if the connect really has happened.
! 494: */
! 495: static bool verifyconnect(curl_socket_t sockfd, int *error)
! 496: {
! 497: bool rc = TRUE;
! 498: #ifdef SO_ERROR
! 499: int err = 0;
! 500: curl_socklen_t errSize = sizeof(err);
! 501:
! 502: #ifdef WIN32
! 503: /*
! 504: * In October 2003 we effectively nullified this function on Windows due to
! 505: * problems with it using all CPU in multi-threaded cases.
! 506: *
! 507: * In May 2004, we bring it back to offer more info back on connect failures.
! 508: * Gisle Vanem could reproduce the former problems with this function, but
! 509: * could avoid them by adding this SleepEx() call below:
! 510: *
! 511: * "I don't have Rational Quantify, but the hint from his post was
! 512: * ntdll::NtRemoveIoCompletion(). So I'd assume the SleepEx (or maybe
! 513: * just Sleep(0) would be enough?) would release whatever
! 514: * mutex/critical-section the ntdll call is waiting on.
! 515: *
! 516: * Someone got to verify this on Win-NT 4.0, 2000."
! 517: */
! 518:
! 519: #ifdef _WIN32_WCE
! 520: Sleep(0);
! 521: #else
! 522: SleepEx(0, FALSE);
! 523: #endif
! 524:
! 525: #endif
! 526:
! 527: if(0 != getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize))
! 528: err = SOCKERRNO;
! 529: #ifdef _WIN32_WCE
! 530: /* Old WinCE versions don't support SO_ERROR */
! 531: if(WSAENOPROTOOPT == err) {
! 532: SET_SOCKERRNO(0);
! 533: err = 0;
! 534: }
! 535: #endif
! 536: #if defined(EBADIOCTL) && defined(__minix)
! 537: /* Minix 3.1.x doesn't support getsockopt on UDP sockets */
! 538: if(EBADIOCTL == err) {
! 539: SET_SOCKERRNO(0);
! 540: err = 0;
! 541: }
! 542: #endif
! 543: if((0 == err) || (EISCONN == err))
! 544: /* we are connected, awesome! */
! 545: rc = TRUE;
! 546: else
! 547: /* This wasn't a successful connect */
! 548: rc = FALSE;
! 549: if(error)
! 550: *error = err;
! 551: #else
! 552: (void)sockfd;
! 553: if(error)
! 554: *error = SOCKERRNO;
! 555: #endif
! 556: return rc;
! 557: }
! 558:
! 559: /* update tempaddr[tempindex] (to the next entry), makes sure to stick
! 560: to the correct family */
! 561: static Curl_addrinfo *ainext(struct connectdata *conn,
! 562: int tempindex,
! 563: bool next) /* use current or next entry */
! 564: {
! 565: Curl_addrinfo *ai = conn->tempaddr[tempindex];
! 566: if(ai && next)
! 567: ai = ai->ai_next;
! 568: while(ai && (ai->ai_family != conn->tempfamily[tempindex]))
! 569: ai = ai->ai_next;
! 570: conn->tempaddr[tempindex] = ai;
! 571: return ai;
! 572: }
! 573:
! 574: /* Used within the multi interface. Try next IP address, return TRUE if no
! 575: more address exists or error */
! 576: static CURLcode trynextip(struct connectdata *conn,
! 577: int sockindex,
! 578: int tempindex)
! 579: {
! 580: CURLcode result = CURLE_COULDNT_CONNECT;
! 581:
! 582: /* First clean up after the failed socket.
! 583: Don't close it yet to ensure that the next IP's socket gets a different
! 584: file descriptor, which can prevent bugs when the curl_multi_socket_action
! 585: interface is used with certain select() replacements such as kqueue. */
! 586: curl_socket_t fd_to_close = conn->tempsock[tempindex];
! 587: conn->tempsock[tempindex] = CURL_SOCKET_BAD;
! 588:
! 589: if(sockindex == FIRSTSOCKET) {
! 590: Curl_addrinfo *ai = conn->tempaddr[tempindex];
! 591:
! 592: while(ai) {
! 593: if(ai) {
! 594: result = singleipconnect(conn, ai, tempindex);
! 595: if(result == CURLE_COULDNT_CONNECT) {
! 596: ai = ainext(conn, tempindex, TRUE);
! 597: continue;
! 598: }
! 599: }
! 600: break;
! 601: }
! 602: }
! 603:
! 604: if(fd_to_close != CURL_SOCKET_BAD)
! 605: Curl_closesocket(conn, fd_to_close);
! 606:
! 607: return result;
! 608: }
! 609:
! 610: /* Copies connection info into the session handle to make it available
! 611: when the session handle is no longer associated with a connection. */
! 612: void Curl_persistconninfo(struct connectdata *conn)
! 613: {
! 614: memcpy(conn->data->info.conn_primary_ip, conn->primary_ip, MAX_IPADR_LEN);
! 615: memcpy(conn->data->info.conn_local_ip, conn->local_ip, MAX_IPADR_LEN);
! 616: conn->data->info.conn_scheme = conn->handler->scheme;
! 617: conn->data->info.conn_protocol = conn->handler->protocol;
! 618: conn->data->info.conn_primary_port = conn->primary_port;
! 619: conn->data->info.conn_local_port = conn->local_port;
! 620: }
! 621:
! 622: /* retrieves ip address and port from a sockaddr structure.
! 623: note it calls Curl_inet_ntop which sets errno on fail, not SOCKERRNO. */
! 624: bool Curl_addr2string(struct sockaddr *sa, curl_socklen_t salen,
! 625: char *addr, long *port)
! 626: {
! 627: struct sockaddr_in *si = NULL;
! 628: #ifdef ENABLE_IPV6
! 629: struct sockaddr_in6 *si6 = NULL;
! 630: #endif
! 631: #if defined(HAVE_SYS_UN_H) && defined(AF_UNIX)
! 632: struct sockaddr_un *su = NULL;
! 633: #else
! 634: (void)salen;
! 635: #endif
! 636:
! 637: switch(sa->sa_family) {
! 638: case AF_INET:
! 639: si = (struct sockaddr_in *)(void *) sa;
! 640: if(Curl_inet_ntop(sa->sa_family, &si->sin_addr,
! 641: addr, MAX_IPADR_LEN)) {
! 642: unsigned short us_port = ntohs(si->sin_port);
! 643: *port = us_port;
! 644: return TRUE;
! 645: }
! 646: break;
! 647: #ifdef ENABLE_IPV6
! 648: case AF_INET6:
! 649: si6 = (struct sockaddr_in6 *)(void *) sa;
! 650: if(Curl_inet_ntop(sa->sa_family, &si6->sin6_addr,
! 651: addr, MAX_IPADR_LEN)) {
! 652: unsigned short us_port = ntohs(si6->sin6_port);
! 653: *port = us_port;
! 654: return TRUE;
! 655: }
! 656: break;
! 657: #endif
! 658: #if defined(HAVE_SYS_UN_H) && defined(AF_UNIX)
! 659: case AF_UNIX:
! 660: if(salen > (curl_socklen_t)sizeof(sa_family_t)) {
! 661: su = (struct sockaddr_un*)sa;
! 662: msnprintf(addr, MAX_IPADR_LEN, "%s", su->sun_path);
! 663: }
! 664: else
! 665: addr[0] = 0; /* socket with no name */
! 666: *port = 0;
! 667: return TRUE;
! 668: #endif
! 669: default:
! 670: break;
! 671: }
! 672:
! 673: addr[0] = '\0';
! 674: *port = 0;
! 675: errno = EAFNOSUPPORT;
! 676: return FALSE;
! 677: }
! 678:
! 679: /* retrieves the start/end point information of a socket of an established
! 680: connection */
! 681: void Curl_updateconninfo(struct connectdata *conn, curl_socket_t sockfd)
! 682: {
! 683: if(conn->transport == TRNSPRT_TCP) {
! 684: #if defined(HAVE_GETPEERNAME) || defined(HAVE_GETSOCKNAME)
! 685: if(!conn->bits.reuse && !conn->bits.tcp_fastopen) {
! 686: struct Curl_easy *data = conn->data;
! 687: char buffer[STRERROR_LEN];
! 688: struct Curl_sockaddr_storage ssrem;
! 689: struct Curl_sockaddr_storage ssloc;
! 690: curl_socklen_t plen;
! 691: curl_socklen_t slen;
! 692: #ifdef HAVE_GETPEERNAME
! 693: plen = sizeof(struct Curl_sockaddr_storage);
! 694: if(getpeername(sockfd, (struct sockaddr*) &ssrem, &plen)) {
! 695: int error = SOCKERRNO;
! 696: failf(data, "getpeername() failed with errno %d: %s",
! 697: error, Curl_strerror(error, buffer, sizeof(buffer)));
! 698: return;
! 699: }
! 700: #endif
! 701: #ifdef HAVE_GETSOCKNAME
! 702: slen = sizeof(struct Curl_sockaddr_storage);
! 703: memset(&ssloc, 0, sizeof(ssloc));
! 704: if(getsockname(sockfd, (struct sockaddr*) &ssloc, &slen)) {
! 705: int error = SOCKERRNO;
! 706: failf(data, "getsockname() failed with errno %d: %s",
! 707: error, Curl_strerror(error, buffer, sizeof(buffer)));
! 708: return;
! 709: }
! 710: #endif
! 711: #ifdef HAVE_GETPEERNAME
! 712: if(!Curl_addr2string((struct sockaddr*)&ssrem, plen,
! 713: conn->primary_ip, &conn->primary_port)) {
! 714: failf(data, "ssrem inet_ntop() failed with errno %d: %s",
! 715: errno, Curl_strerror(errno, buffer, sizeof(buffer)));
! 716: return;
! 717: }
! 718: memcpy(conn->ip_addr_str, conn->primary_ip, MAX_IPADR_LEN);
! 719: #endif
! 720: #ifdef HAVE_GETSOCKNAME
! 721: if(!Curl_addr2string((struct sockaddr*)&ssloc, slen,
! 722: conn->local_ip, &conn->local_port)) {
! 723: failf(data, "ssloc inet_ntop() failed with errno %d: %s",
! 724: errno, Curl_strerror(errno, buffer, sizeof(buffer)));
! 725: return;
! 726: }
! 727: #endif
! 728: }
! 729: #else /* !HAVE_GETSOCKNAME && !HAVE_GETPEERNAME */
! 730: (void)sockfd; /* unused */
! 731: #endif
! 732: } /* end of TCP-only section */
! 733:
! 734: /* persist connection info in session handle */
! 735: Curl_persistconninfo(conn);
! 736: }
! 737:
! 738: /* After a TCP connection to the proxy has been verified, this function does
! 739: the next magic steps. If 'done' isn't set TRUE, it is not done yet and
! 740: must be called again.
! 741:
! 742: Note: this function's sub-functions call failf()
! 743:
! 744: */
! 745: static CURLcode connect_SOCKS(struct connectdata *conn, int sockindex,
! 746: bool *done)
! 747: {
! 748: CURLcode result = CURLE_OK;
! 749:
! 750: if(conn->bits.socksproxy) {
! 751: #ifndef CURL_DISABLE_PROXY
! 752: /* for the secondary socket (FTP), use the "connect to host"
! 753: * but ignore the "connect to port" (use the secondary port)
! 754: */
! 755: const char * const host =
! 756: conn->bits.httpproxy ?
! 757: conn->http_proxy.host.name :
! 758: conn->bits.conn_to_host ?
! 759: conn->conn_to_host.name :
! 760: sockindex == SECONDARYSOCKET ?
! 761: conn->secondaryhostname : conn->host.name;
! 762: const int port =
! 763: conn->bits.httpproxy ? (int)conn->http_proxy.port :
! 764: sockindex == SECONDARYSOCKET ? conn->secondary_port :
! 765: conn->bits.conn_to_port ? conn->conn_to_port :
! 766: conn->remote_port;
! 767: switch(conn->socks_proxy.proxytype) {
! 768: case CURLPROXY_SOCKS5:
! 769: case CURLPROXY_SOCKS5_HOSTNAME:
! 770: result = Curl_SOCKS5(conn->socks_proxy.user, conn->socks_proxy.passwd,
! 771: host, port, sockindex, conn, done);
! 772: break;
! 773:
! 774: case CURLPROXY_SOCKS4:
! 775: case CURLPROXY_SOCKS4A:
! 776: result = Curl_SOCKS4(conn->socks_proxy.user, host, port, sockindex,
! 777: conn, done);
! 778: break;
! 779:
! 780: default:
! 781: failf(conn->data, "unknown proxytype option given");
! 782: result = CURLE_COULDNT_CONNECT;
! 783: } /* switch proxytype */
! 784: #else
! 785: (void)sockindex;
! 786: #endif /* CURL_DISABLE_PROXY */
! 787: }
! 788: else
! 789: *done = TRUE; /* no SOCKS proxy, so consider us connected */
! 790:
! 791: return result;
! 792: }
! 793:
! 794: /*
! 795: * post_SOCKS() is called after a successful connect to the peer, which
! 796: * *could* be a SOCKS proxy
! 797: */
! 798: static void post_SOCKS(struct connectdata *conn,
! 799: int sockindex,
! 800: bool *connected)
! 801: {
! 802: conn->bits.tcpconnect[sockindex] = TRUE;
! 803:
! 804: *connected = TRUE;
! 805: if(sockindex == FIRSTSOCKET)
! 806: Curl_pgrsTime(conn->data, TIMER_CONNECT); /* connect done */
! 807: Curl_updateconninfo(conn, conn->sock[sockindex]);
! 808: Curl_verboseconnect(conn);
! 809: conn->data->info.numconnects++; /* to track the number of connections made */
! 810: }
! 811:
! 812: /*
! 813: * Curl_is_connected() checks if the socket has connected.
! 814: */
! 815:
! 816: CURLcode Curl_is_connected(struct connectdata *conn,
! 817: int sockindex,
! 818: bool *connected)
! 819: {
! 820: struct Curl_easy *data = conn->data;
! 821: CURLcode result = CURLE_OK;
! 822: timediff_t allow;
! 823: int error = 0;
! 824: struct curltime now;
! 825: int rc;
! 826: int i;
! 827:
! 828: DEBUGASSERT(sockindex >= FIRSTSOCKET && sockindex <= SECONDARYSOCKET);
! 829:
! 830: *connected = FALSE; /* a very negative world view is best */
! 831:
! 832: if(conn->bits.tcpconnect[sockindex]) {
! 833: /* we are connected already! */
! 834: *connected = TRUE;
! 835: return CURLE_OK;
! 836: }
! 837:
! 838: now = Curl_now();
! 839:
! 840: /* figure out how long time we have left to connect */
! 841: allow = Curl_timeleft(data, &now, TRUE);
! 842:
! 843: if(allow < 0) {
! 844: /* time-out, bail out, go home */
! 845: failf(data, "Connection time-out");
! 846: return CURLE_OPERATION_TIMEDOUT;
! 847: }
! 848:
! 849: if(SOCKS_STATE(conn->cnnct.state)) {
! 850: /* still doing SOCKS */
! 851: result = connect_SOCKS(conn, sockindex, connected);
! 852: if(!result && *connected)
! 853: post_SOCKS(conn, sockindex, connected);
! 854: return result;
! 855: }
! 856:
! 857: for(i = 0; i<2; i++) {
! 858: const int other = i ^ 1;
! 859: if(conn->tempsock[i] == CURL_SOCKET_BAD)
! 860: continue;
! 861:
! 862: #ifdef ENABLE_QUIC
! 863: if(conn->transport == TRNSPRT_QUIC) {
! 864: result = Curl_quic_is_connected(conn, i, connected);
! 865: if(result) {
! 866: error = SOCKERRNO;
! 867: goto error;
! 868: }
! 869: if(*connected) {
! 870: /* use this socket from now on */
! 871: conn->sock[sockindex] = conn->tempsock[i];
! 872: conn->ip_addr = conn->tempaddr[i];
! 873: conn->tempsock[i] = CURL_SOCKET_BAD;
! 874: post_SOCKS(conn, sockindex, connected);
! 875: connkeep(conn, "HTTP/3 default");
! 876: }
! 877: return result;
! 878: }
! 879: #endif
! 880:
! 881: #ifdef mpeix
! 882: /* Call this function once now, and ignore the results. We do this to
! 883: "clear" the error state on the socket so that we can later read it
! 884: reliably. This is reported necessary on the MPE/iX operating system. */
! 885: (void)verifyconnect(conn->tempsock[i], NULL);
! 886: #endif
! 887:
! 888: /* check socket for connect */
! 889: rc = SOCKET_WRITABLE(conn->tempsock[i], 0);
! 890:
! 891: if(rc == 0) { /* no connection yet */
! 892: error = 0;
! 893: if(Curl_timediff(now, conn->connecttime) >= conn->timeoutms_per_addr) {
! 894: infof(data, "After %" CURL_FORMAT_TIMEDIFF_T
! 895: "ms connect time, move on!\n", conn->timeoutms_per_addr);
! 896: error = ETIMEDOUT;
! 897: }
! 898:
! 899: /* should we try another protocol family? */
! 900: if(i == 0 && !conn->parallel_connect &&
! 901: (Curl_timediff(now, conn->connecttime) >=
! 902: data->set.happy_eyeballs_timeout)) {
! 903: conn->parallel_connect = TRUE; /* starting now */
! 904: trynextip(conn, sockindex, 1);
! 905: }
! 906: }
! 907: else if(rc == CURL_CSELECT_OUT || conn->bits.tcp_fastopen) {
! 908: if(verifyconnect(conn->tempsock[i], &error)) {
! 909: /* we are connected with TCP, awesome! */
! 910:
! 911: /* use this socket from now on */
! 912: conn->sock[sockindex] = conn->tempsock[i];
! 913: conn->ip_addr = conn->tempaddr[i];
! 914: conn->tempsock[i] = CURL_SOCKET_BAD;
! 915: #ifdef ENABLE_IPV6
! 916: conn->bits.ipv6 = (conn->ip_addr->ai_family == AF_INET6)?TRUE:FALSE;
! 917: #endif
! 918:
! 919: /* close the other socket, if open */
! 920: if(conn->tempsock[other] != CURL_SOCKET_BAD) {
! 921: Curl_closesocket(conn, conn->tempsock[other]);
! 922: conn->tempsock[other] = CURL_SOCKET_BAD;
! 923: }
! 924:
! 925: /* see if we need to kick off any SOCKS proxy magic once we
! 926: connected */
! 927: result = connect_SOCKS(conn, sockindex, connected);
! 928: if(result || !*connected)
! 929: return result;
! 930:
! 931: post_SOCKS(conn, sockindex, connected);
! 932:
! 933: return CURLE_OK;
! 934: }
! 935: infof(data, "Connection failed\n");
! 936: }
! 937: else if(rc & CURL_CSELECT_ERR)
! 938: (void)verifyconnect(conn->tempsock[i], &error);
! 939:
! 940: #ifdef ENABLE_QUIC
! 941: error:
! 942: #endif
! 943: /*
! 944: * The connection failed here, we should attempt to connect to the "next
! 945: * address" for the given host. But first remember the latest error.
! 946: */
! 947: if(error) {
! 948: data->state.os_errno = error;
! 949: SET_SOCKERRNO(error);
! 950: if(conn->tempaddr[i]) {
! 951: CURLcode status;
! 952: #ifndef CURL_DISABLE_VERBOSE_STRINGS
! 953: char ipaddress[MAX_IPADR_LEN];
! 954: char buffer[STRERROR_LEN];
! 955: Curl_printable_address(conn->tempaddr[i], ipaddress, MAX_IPADR_LEN);
! 956: #endif
! 957: infof(data, "connect to %s port %ld failed: %s\n",
! 958: ipaddress, conn->port,
! 959: Curl_strerror(error, buffer, sizeof(buffer)));
! 960:
! 961: conn->timeoutms_per_addr = conn->tempaddr[i]->ai_next == NULL ?
! 962: allow : allow / 2;
! 963: ainext(conn, i, TRUE);
! 964: status = trynextip(conn, sockindex, i);
! 965: if((status != CURLE_COULDNT_CONNECT) ||
! 966: conn->tempsock[other] == CURL_SOCKET_BAD)
! 967: /* the last attempt failed and no other sockets remain open */
! 968: result = status;
! 969: }
! 970: }
! 971: }
! 972:
! 973: if(result) {
! 974: /* no more addresses to try */
! 975: const char *hostname;
! 976: char buffer[STRERROR_LEN];
! 977:
! 978: /* if the first address family runs out of addresses to try before
! 979: the happy eyeball timeout, go ahead and try the next family now */
! 980: {
! 981: result = trynextip(conn, sockindex, 1);
! 982: if(!result)
! 983: return result;
! 984: }
! 985:
! 986: if(conn->bits.socksproxy)
! 987: hostname = conn->socks_proxy.host.name;
! 988: else if(conn->bits.httpproxy)
! 989: hostname = conn->http_proxy.host.name;
! 990: else if(conn->bits.conn_to_host)
! 991: hostname = conn->conn_to_host.name;
! 992: else
! 993: hostname = conn->host.name;
! 994:
! 995: failf(data, "Failed to connect to %s port %ld: %s",
! 996: hostname, conn->port,
! 997: Curl_strerror(error, buffer, sizeof(buffer)));
! 998:
! 999: #ifdef WSAETIMEDOUT
! 1000: if(WSAETIMEDOUT == data->state.os_errno)
! 1001: result = CURLE_OPERATION_TIMEDOUT;
! 1002: #elif defined(ETIMEDOUT)
! 1003: if(ETIMEDOUT == data->state.os_errno)
! 1004: result = CURLE_OPERATION_TIMEDOUT;
! 1005: #endif
! 1006: }
! 1007:
! 1008: return result;
! 1009: }
! 1010:
! 1011: static void tcpnodelay(struct connectdata *conn, curl_socket_t sockfd)
! 1012: {
! 1013: #if defined(TCP_NODELAY)
! 1014: curl_socklen_t onoff = (curl_socklen_t) 1;
! 1015: int level = IPPROTO_TCP;
! 1016: #if !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 1017: struct Curl_easy *data = conn->data;
! 1018: char buffer[STRERROR_LEN];
! 1019: #else
! 1020: (void) conn;
! 1021: #endif
! 1022:
! 1023: if(setsockopt(sockfd, level, TCP_NODELAY, (void *)&onoff,
! 1024: sizeof(onoff)) < 0)
! 1025: infof(data, "Could not set TCP_NODELAY: %s\n",
! 1026: Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
! 1027: #else
! 1028: (void)conn;
! 1029: (void)sockfd;
! 1030: #endif
! 1031: }
! 1032:
! 1033: #ifdef SO_NOSIGPIPE
! 1034: /* The preferred method on Mac OS X (10.2 and later) to prevent SIGPIPEs when
! 1035: sending data to a dead peer (instead of relying on the 4th argument to send
! 1036: being MSG_NOSIGNAL). Possibly also existing and in use on other BSD
! 1037: systems? */
! 1038: static void nosigpipe(struct connectdata *conn,
! 1039: curl_socket_t sockfd)
! 1040: {
! 1041: struct Curl_easy *data = conn->data;
! 1042: int onoff = 1;
! 1043: if(setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&onoff,
! 1044: sizeof(onoff)) < 0) {
! 1045: char buffer[STRERROR_LEN];
! 1046: infof(data, "Could not set SO_NOSIGPIPE: %s\n",
! 1047: Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
! 1048: }
! 1049: }
! 1050: #else
! 1051: #define nosigpipe(x,y) Curl_nop_stmt
! 1052: #endif
! 1053:
! 1054: #ifdef USE_WINSOCK
! 1055: /* When you run a program that uses the Windows Sockets API, you may
! 1056: experience slow performance when you copy data to a TCP server.
! 1057:
! 1058: https://support.microsoft.com/kb/823764
! 1059:
! 1060: Work-around: Make the Socket Send Buffer Size Larger Than the Program Send
! 1061: Buffer Size
! 1062:
! 1063: The problem described in this knowledge-base is applied only to pre-Vista
! 1064: Windows. Following function trying to detect OS version and skips
! 1065: SO_SNDBUF adjustment for Windows Vista and above.
! 1066: */
! 1067: #define DETECT_OS_NONE 0
! 1068: #define DETECT_OS_PREVISTA 1
! 1069: #define DETECT_OS_VISTA_OR_LATER 2
! 1070:
! 1071: void Curl_sndbufset(curl_socket_t sockfd)
! 1072: {
! 1073: int val = CURL_MAX_WRITE_SIZE + 32;
! 1074: int curval = 0;
! 1075: int curlen = sizeof(curval);
! 1076:
! 1077: static int detectOsState = DETECT_OS_NONE;
! 1078:
! 1079: if(detectOsState == DETECT_OS_NONE) {
! 1080: if(Curl_verify_windows_version(6, 0, PLATFORM_WINNT,
! 1081: VERSION_GREATER_THAN_EQUAL))
! 1082: detectOsState = DETECT_OS_VISTA_OR_LATER;
! 1083: else
! 1084: detectOsState = DETECT_OS_PREVISTA;
! 1085: }
! 1086:
! 1087: if(detectOsState == DETECT_OS_VISTA_OR_LATER)
! 1088: return;
! 1089:
! 1090: if(getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char *)&curval, &curlen) == 0)
! 1091: if(curval > val)
! 1092: return;
! 1093:
! 1094: setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (const char *)&val, sizeof(val));
! 1095: }
! 1096: #endif
! 1097:
! 1098: /*
! 1099: * singleipconnect()
! 1100: *
! 1101: * Note that even on connect fail it returns CURLE_OK, but with 'sock' set to
! 1102: * CURL_SOCKET_BAD. Other errors will however return proper errors.
! 1103: *
! 1104: * singleipconnect() connects to the given IP only, and it may return without
! 1105: * having connected.
! 1106: */
! 1107: static CURLcode singleipconnect(struct connectdata *conn,
! 1108: const Curl_addrinfo *ai,
! 1109: int tempindex)
! 1110: {
! 1111: struct Curl_sockaddr_ex addr;
! 1112: int rc = -1;
! 1113: int error = 0;
! 1114: bool isconnected = FALSE;
! 1115: struct Curl_easy *data = conn->data;
! 1116: curl_socket_t sockfd;
! 1117: CURLcode result;
! 1118: char ipaddress[MAX_IPADR_LEN];
! 1119: long port;
! 1120: bool is_tcp;
! 1121: #ifdef TCP_FASTOPEN_CONNECT
! 1122: int optval = 1;
! 1123: #endif
! 1124: char buffer[STRERROR_LEN];
! 1125: curl_socket_t *sockp = &conn->tempsock[tempindex];
! 1126: *sockp = CURL_SOCKET_BAD;
! 1127:
! 1128: result = Curl_socket(conn, ai, &addr, &sockfd);
! 1129: if(result)
! 1130: return result;
! 1131:
! 1132: /* store remote address and port used in this connection attempt */
! 1133: if(!Curl_addr2string((struct sockaddr*)&addr.sa_addr, addr.addrlen,
! 1134: ipaddress, &port)) {
! 1135: /* malformed address or bug in inet_ntop, try next address */
! 1136: failf(data, "sa_addr inet_ntop() failed with errno %d: %s",
! 1137: errno, Curl_strerror(errno, buffer, sizeof(buffer)));
! 1138: Curl_closesocket(conn, sockfd);
! 1139: return CURLE_OK;
! 1140: }
! 1141: infof(data, " Trying %s:%ld...\n", ipaddress, port);
! 1142:
! 1143: #ifdef ENABLE_IPV6
! 1144: is_tcp = (addr.family == AF_INET || addr.family == AF_INET6) &&
! 1145: addr.socktype == SOCK_STREAM;
! 1146: #else
! 1147: is_tcp = (addr.family == AF_INET) && addr.socktype == SOCK_STREAM;
! 1148: #endif
! 1149: if(is_tcp && data->set.tcp_nodelay)
! 1150: tcpnodelay(conn, sockfd);
! 1151:
! 1152: nosigpipe(conn, sockfd);
! 1153:
! 1154: Curl_sndbufset(sockfd);
! 1155:
! 1156: if(is_tcp && data->set.tcp_keepalive)
! 1157: tcpkeepalive(data, sockfd);
! 1158:
! 1159: if(data->set.fsockopt) {
! 1160: /* activate callback for setting socket options */
! 1161: Curl_set_in_callback(data, true);
! 1162: error = data->set.fsockopt(data->set.sockopt_client,
! 1163: sockfd,
! 1164: CURLSOCKTYPE_IPCXN);
! 1165: Curl_set_in_callback(data, false);
! 1166:
! 1167: if(error == CURL_SOCKOPT_ALREADY_CONNECTED)
! 1168: isconnected = TRUE;
! 1169: else if(error) {
! 1170: Curl_closesocket(conn, sockfd); /* close the socket and bail out */
! 1171: return CURLE_ABORTED_BY_CALLBACK;
! 1172: }
! 1173: }
! 1174:
! 1175: /* possibly bind the local end to an IP, interface or port */
! 1176: if(addr.family == AF_INET
! 1177: #ifdef ENABLE_IPV6
! 1178: || addr.family == AF_INET6
! 1179: #endif
! 1180: ) {
! 1181: result = bindlocal(conn, sockfd, addr.family,
! 1182: Curl_ipv6_scope((struct sockaddr*)&addr.sa_addr));
! 1183: if(result) {
! 1184: Curl_closesocket(conn, sockfd); /* close socket and bail out */
! 1185: if(result == CURLE_UNSUPPORTED_PROTOCOL) {
! 1186: /* The address family is not supported on this interface.
! 1187: We can continue trying addresses */
! 1188: return CURLE_COULDNT_CONNECT;
! 1189: }
! 1190: return result;
! 1191: }
! 1192: }
! 1193:
! 1194: /* set socket non-blocking */
! 1195: (void)curlx_nonblock(sockfd, TRUE);
! 1196:
! 1197: conn->connecttime = Curl_now();
! 1198: if(conn->num_addr > 1)
! 1199: Curl_expire(data, conn->timeoutms_per_addr, EXPIRE_DNS_PER_NAME);
! 1200:
! 1201: /* Connect TCP and QUIC sockets */
! 1202: if(!isconnected && (conn->transport != TRNSPRT_UDP)) {
! 1203: if(conn->bits.tcp_fastopen) {
! 1204: #if defined(CONNECT_DATA_IDEMPOTENT) /* Darwin */
! 1205: # if defined(HAVE_BUILTIN_AVAILABLE)
! 1206: /* while connectx function is available since macOS 10.11 / iOS 9,
! 1207: it did not have the interface declared correctly until
! 1208: Xcode 9 / macOS SDK 10.13 */
! 1209: if(__builtin_available(macOS 10.11, iOS 9.0, tvOS 9.0, watchOS 2.0, *)) {
! 1210: sa_endpoints_t endpoints;
! 1211: endpoints.sae_srcif = 0;
! 1212: endpoints.sae_srcaddr = NULL;
! 1213: endpoints.sae_srcaddrlen = 0;
! 1214: endpoints.sae_dstaddr = &addr.sa_addr;
! 1215: endpoints.sae_dstaddrlen = addr.addrlen;
! 1216:
! 1217: rc = connectx(sockfd, &endpoints, SAE_ASSOCID_ANY,
! 1218: CONNECT_RESUME_ON_READ_WRITE | CONNECT_DATA_IDEMPOTENT,
! 1219: NULL, 0, NULL, NULL);
! 1220: }
! 1221: else {
! 1222: rc = connect(sockfd, &addr.sa_addr, addr.addrlen);
! 1223: }
! 1224: # else
! 1225: rc = connect(sockfd, &addr.sa_addr, addr.addrlen);
! 1226: # endif /* HAVE_BUILTIN_AVAILABLE */
! 1227: #elif defined(TCP_FASTOPEN_CONNECT) /* Linux >= 4.11 */
! 1228: if(setsockopt(sockfd, IPPROTO_TCP, TCP_FASTOPEN_CONNECT,
! 1229: (void *)&optval, sizeof(optval)) < 0)
! 1230: infof(data, "Failed to enable TCP Fast Open on fd %d\n", sockfd);
! 1231:
! 1232: rc = connect(sockfd, &addr.sa_addr, addr.addrlen);
! 1233: #elif defined(MSG_FASTOPEN) /* old Linux */
! 1234: if(conn->given->flags & PROTOPT_SSL)
! 1235: rc = connect(sockfd, &addr.sa_addr, addr.addrlen);
! 1236: else
! 1237: rc = 0; /* Do nothing */
! 1238: #endif
! 1239: }
! 1240: else {
! 1241: rc = connect(sockfd, &addr.sa_addr, addr.addrlen);
! 1242: }
! 1243:
! 1244: if(-1 == rc)
! 1245: error = SOCKERRNO;
! 1246: #ifdef ENABLE_QUIC
! 1247: else if(conn->transport == TRNSPRT_QUIC) {
! 1248: /* pass in 'sockfd' separately since it hasn't been put into the
! 1249: tempsock array at this point */
! 1250: result = Curl_quic_connect(conn, sockfd, tempindex,
! 1251: &addr.sa_addr, addr.addrlen);
! 1252: if(result)
! 1253: error = SOCKERRNO;
! 1254: }
! 1255: #endif
! 1256: }
! 1257: else {
! 1258: *sockp = sockfd;
! 1259: return CURLE_OK;
! 1260: }
! 1261:
! 1262: if(-1 == rc) {
! 1263: switch(error) {
! 1264: case EINPROGRESS:
! 1265: case EWOULDBLOCK:
! 1266: #if defined(EAGAIN)
! 1267: #if (EAGAIN) != (EWOULDBLOCK)
! 1268: /* On some platforms EAGAIN and EWOULDBLOCK are the
! 1269: * same value, and on others they are different, hence
! 1270: * the odd #if
! 1271: */
! 1272: case EAGAIN:
! 1273: #endif
! 1274: #endif
! 1275: result = CURLE_OK;
! 1276: break;
! 1277:
! 1278: default:
! 1279: /* unknown error, fallthrough and try another address! */
! 1280: infof(data, "Immediate connect fail for %s: %s\n",
! 1281: ipaddress, Curl_strerror(error, buffer, sizeof(buffer)));
! 1282: data->state.os_errno = error;
! 1283:
! 1284: /* connect failed */
! 1285: Curl_closesocket(conn, sockfd);
! 1286: result = CURLE_COULDNT_CONNECT;
! 1287: }
! 1288: }
! 1289:
! 1290: if(!result)
! 1291: *sockp = sockfd;
! 1292:
! 1293: return result;
! 1294: }
! 1295:
! 1296: /*
! 1297: * TCP connect to the given host with timeout, proxy or remote doesn't matter.
! 1298: * There might be more than one IP address to try out. Fill in the passed
! 1299: * pointer with the connected socket.
! 1300: */
! 1301:
! 1302: CURLcode Curl_connecthost(struct connectdata *conn, /* context */
! 1303: const struct Curl_dns_entry *remotehost)
! 1304: {
! 1305: struct Curl_easy *data = conn->data;
! 1306: struct curltime before = Curl_now();
! 1307: CURLcode result = CURLE_COULDNT_CONNECT;
! 1308: int i;
! 1309: timediff_t timeout_ms = Curl_timeleft(data, &before, TRUE);
! 1310:
! 1311: if(timeout_ms < 0) {
! 1312: /* a precaution, no need to continue if time already is up */
! 1313: failf(data, "Connection time-out");
! 1314: return CURLE_OPERATION_TIMEDOUT;
! 1315: }
! 1316:
! 1317: conn->num_addr = Curl_num_addresses(remotehost->addr);
! 1318: conn->tempaddr[0] = conn->tempaddr[1] = remotehost->addr;
! 1319: conn->tempsock[0] = conn->tempsock[1] = CURL_SOCKET_BAD;
! 1320:
! 1321: /* Max time for the next connection attempt */
! 1322: conn->timeoutms_per_addr =
! 1323: conn->tempaddr[0]->ai_next == NULL ? timeout_ms : timeout_ms / 2;
! 1324:
! 1325: conn->tempfamily[0] = conn->tempaddr[0]?
! 1326: conn->tempaddr[0]->ai_family:0;
! 1327: conn->tempfamily[1] = conn->tempfamily[0] == AF_INET6 ?
! 1328: AF_INET : AF_INET6;
! 1329: ainext(conn, 1, FALSE); /* assigns conn->tempaddr[1] accordingly */
! 1330:
! 1331: DEBUGF(infof(data, "family0 == %s, family1 == %s\n",
! 1332: conn->tempfamily[0] == AF_INET ? "v4" : "v6",
! 1333: conn->tempfamily[1] == AF_INET ? "v4" : "v6"));
! 1334:
! 1335: /* get through the list in family order in case of quick failures */
! 1336: for(i = 0; (i < 2) && result; i++) {
! 1337: while(conn->tempaddr[i]) {
! 1338: result = singleipconnect(conn, conn->tempaddr[i], i);
! 1339: if(!result)
! 1340: break;
! 1341: ainext(conn, i, TRUE);
! 1342: }
! 1343: }
! 1344: if(result)
! 1345: return result;
! 1346:
! 1347: Curl_expire(conn->data, data->set.happy_eyeballs_timeout,
! 1348: EXPIRE_HAPPY_EYEBALLS);
! 1349:
! 1350: return CURLE_OK;
! 1351: }
! 1352:
! 1353: struct connfind {
! 1354: struct connectdata *tofind;
! 1355: bool found;
! 1356: };
! 1357:
! 1358: static int conn_is_conn(struct connectdata *conn, void *param)
! 1359: {
! 1360: struct connfind *f = (struct connfind *)param;
! 1361: if(conn == f->tofind) {
! 1362: f->found = TRUE;
! 1363: return 1;
! 1364: }
! 1365: return 0;
! 1366: }
! 1367:
! 1368: /*
! 1369: * Used to extract socket and connectdata struct for the most recent
! 1370: * transfer on the given Curl_easy.
! 1371: *
! 1372: * The returned socket will be CURL_SOCKET_BAD in case of failure!
! 1373: */
! 1374: curl_socket_t Curl_getconnectinfo(struct Curl_easy *data,
! 1375: struct connectdata **connp)
! 1376: {
! 1377: DEBUGASSERT(data);
! 1378:
! 1379: /* this works for an easy handle:
! 1380: * - that has been used for curl_easy_perform()
! 1381: * - that is associated with a multi handle, and whose connection
! 1382: * was detached with CURLOPT_CONNECT_ONLY
! 1383: */
! 1384: if(data->state.lastconnect && (data->multi_easy || data->multi)) {
! 1385: struct connectdata *c = data->state.lastconnect;
! 1386: struct connfind find;
! 1387: find.tofind = data->state.lastconnect;
! 1388: find.found = FALSE;
! 1389:
! 1390: Curl_conncache_foreach(data, data->multi_easy?
! 1391: &data->multi_easy->conn_cache:
! 1392: &data->multi->conn_cache, &find, conn_is_conn);
! 1393:
! 1394: if(!find.found) {
! 1395: data->state.lastconnect = NULL;
! 1396: return CURL_SOCKET_BAD;
! 1397: }
! 1398:
! 1399: if(connp) {
! 1400: /* only store this if the caller cares for it */
! 1401: *connp = c;
! 1402: c->data = data;
! 1403: }
! 1404: return c->sock[FIRSTSOCKET];
! 1405: }
! 1406: else
! 1407: return CURL_SOCKET_BAD;
! 1408: }
! 1409:
! 1410: /*
! 1411: * Check if a connection seems to be alive.
! 1412: */
! 1413: bool Curl_connalive(struct connectdata *conn)
! 1414: {
! 1415: /* First determine if ssl */
! 1416: if(conn->ssl[FIRSTSOCKET].use) {
! 1417: /* use the SSL context */
! 1418: if(!Curl_ssl_check_cxn(conn))
! 1419: return false; /* FIN received */
! 1420: }
! 1421: /* Minix 3.1 doesn't support any flags on recv; just assume socket is OK */
! 1422: #ifdef MSG_PEEK
! 1423: else if(conn->sock[FIRSTSOCKET] == CURL_SOCKET_BAD)
! 1424: return false;
! 1425: else {
! 1426: /* use the socket */
! 1427: char buf;
! 1428: if(recv((RECV_TYPE_ARG1)conn->sock[FIRSTSOCKET], (RECV_TYPE_ARG2)&buf,
! 1429: (RECV_TYPE_ARG3)1, (RECV_TYPE_ARG4)MSG_PEEK) == 0) {
! 1430: return false; /* FIN received */
! 1431: }
! 1432: }
! 1433: #endif
! 1434: return true;
! 1435: }
! 1436:
! 1437: /*
! 1438: * Close a socket.
! 1439: *
! 1440: * 'conn' can be NULL, beware!
! 1441: */
! 1442: int Curl_closesocket(struct connectdata *conn,
! 1443: curl_socket_t sock)
! 1444: {
! 1445: if(conn && conn->fclosesocket) {
! 1446: if((sock == conn->sock[SECONDARYSOCKET]) && conn->sock_accepted)
! 1447: /* if this socket matches the second socket, and that was created with
! 1448: accept, then we MUST NOT call the callback but clear the accepted
! 1449: status */
! 1450: conn->sock_accepted = FALSE;
! 1451: else {
! 1452: int rc;
! 1453: Curl_multi_closed(conn->data, sock);
! 1454: Curl_set_in_callback(conn->data, true);
! 1455: rc = conn->fclosesocket(conn->closesocket_client, sock);
! 1456: Curl_set_in_callback(conn->data, false);
! 1457: return rc;
! 1458: }
! 1459: }
! 1460:
! 1461: if(conn)
! 1462: /* tell the multi-socket code about this */
! 1463: Curl_multi_closed(conn->data, sock);
! 1464:
! 1465: sclose(sock);
! 1466:
! 1467: return 0;
! 1468: }
! 1469:
! 1470: /*
! 1471: * Create a socket based on info from 'conn' and 'ai'.
! 1472: *
! 1473: * 'addr' should be a pointer to the correct struct to get data back, or NULL.
! 1474: * 'sockfd' must be a pointer to a socket descriptor.
! 1475: *
! 1476: * If the open socket callback is set, used that!
! 1477: *
! 1478: */
! 1479: CURLcode Curl_socket(struct connectdata *conn,
! 1480: const Curl_addrinfo *ai,
! 1481: struct Curl_sockaddr_ex *addr,
! 1482: curl_socket_t *sockfd)
! 1483: {
! 1484: struct Curl_easy *data = conn->data;
! 1485: struct Curl_sockaddr_ex dummy;
! 1486:
! 1487: if(!addr)
! 1488: /* if the caller doesn't want info back, use a local temp copy */
! 1489: addr = &dummy;
! 1490:
! 1491: /*
! 1492: * The Curl_sockaddr_ex structure is basically libcurl's external API
! 1493: * curl_sockaddr structure with enough space available to directly hold
! 1494: * any protocol-specific address structures. The variable declared here
! 1495: * will be used to pass / receive data to/from the fopensocket callback
! 1496: * if this has been set, before that, it is initialized from parameters.
! 1497: */
! 1498:
! 1499: addr->family = ai->ai_family;
! 1500: addr->socktype = (conn->transport == TRNSPRT_TCP) ? SOCK_STREAM : SOCK_DGRAM;
! 1501: addr->protocol = conn->transport != TRNSPRT_TCP ? IPPROTO_UDP :
! 1502: ai->ai_protocol;
! 1503: addr->addrlen = ai->ai_addrlen;
! 1504:
! 1505: if(addr->addrlen > sizeof(struct Curl_sockaddr_storage))
! 1506: addr->addrlen = sizeof(struct Curl_sockaddr_storage);
! 1507: memcpy(&addr->sa_addr, ai->ai_addr, addr->addrlen);
! 1508:
! 1509: if(data->set.fopensocket) {
! 1510: /*
! 1511: * If the opensocket callback is set, all the destination address
! 1512: * information is passed to the callback. Depending on this information the
! 1513: * callback may opt to abort the connection, this is indicated returning
! 1514: * CURL_SOCKET_BAD; otherwise it will return a not-connected socket. When
! 1515: * the callback returns a valid socket the destination address information
! 1516: * might have been changed and this 'new' address will actually be used
! 1517: * here to connect.
! 1518: */
! 1519: Curl_set_in_callback(data, true);
! 1520: *sockfd = data->set.fopensocket(data->set.opensocket_client,
! 1521: CURLSOCKTYPE_IPCXN,
! 1522: (struct curl_sockaddr *)addr);
! 1523: Curl_set_in_callback(data, false);
! 1524: }
! 1525: else
! 1526: /* opensocket callback not set, so simply create the socket now */
! 1527: *sockfd = socket(addr->family, addr->socktype, addr->protocol);
! 1528:
! 1529: if(*sockfd == CURL_SOCKET_BAD)
! 1530: /* no socket, no connection */
! 1531: return CURLE_COULDNT_CONNECT;
! 1532:
! 1533: if(conn->transport == TRNSPRT_QUIC) {
! 1534: /* QUIC sockets need to be nonblocking */
! 1535: (void)curlx_nonblock(*sockfd, TRUE);
! 1536: }
! 1537:
! 1538: #if defined(ENABLE_IPV6) && defined(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
! 1539: if(conn->scope_id && (addr->family == AF_INET6)) {
! 1540: struct sockaddr_in6 * const sa6 = (void *)&addr->sa_addr;
! 1541: sa6->sin6_scope_id = conn->scope_id;
! 1542: }
! 1543: #endif
! 1544:
! 1545: return CURLE_OK;
! 1546:
! 1547: }
! 1548:
! 1549: /*
! 1550: * Curl_conncontrol() marks streams or connection for closure.
! 1551: */
! 1552: void Curl_conncontrol(struct connectdata *conn,
! 1553: int ctrl /* see defines in header */
! 1554: #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
! 1555: , const char *reason
! 1556: #endif
! 1557: )
! 1558: {
! 1559: /* close if a connection, or a stream that isn't multiplexed */
! 1560: bool closeit = (ctrl == CONNCTRL_CONNECTION) ||
! 1561: ((ctrl == CONNCTRL_STREAM) && !(conn->handler->flags & PROTOPT_STREAM));
! 1562: if((ctrl == CONNCTRL_STREAM) &&
! 1563: (conn->handler->flags & PROTOPT_STREAM))
! 1564: DEBUGF(infof(conn->data, "Kill stream: %s\n", reason));
! 1565: else if((bit)closeit != conn->bits.close) {
! 1566: DEBUGF(infof(conn->data, "Marked for [%s]: %s\n",
! 1567: closeit?"closure":"keep alive", reason));
! 1568: conn->bits.close = closeit; /* the only place in the source code that
! 1569: should assign this bit */
! 1570: }
! 1571: }
! 1572:
! 1573: /* Data received can be cached at various levels, so check them all here. */
! 1574: bool Curl_conn_data_pending(struct connectdata *conn, int sockindex)
! 1575: {
! 1576: int readable;
! 1577:
! 1578: if(Curl_ssl_data_pending(conn, sockindex) ||
! 1579: Curl_recv_has_postponed_data(conn, sockindex))
! 1580: return true;
! 1581:
! 1582: readable = SOCKET_READABLE(conn->sock[sockindex], 0);
! 1583: return (readable > 0 && (readable & CURL_CSELECT_IN));
! 1584: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to connect.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib