Restoring authorship annotation for <thegeorg@yandex-team.ru>. Commit 1 of 2.

1 files changed, 272 insertions, 272 deletions

diff --git a/contrib/libs/curl/lib/connect.c b/contrib/libs/curl/lib/connect.c
index e65d24d9e9..413ac2c7cd 100644
--- a/contrib/libs/curl/lib/connect.c
+++ b/contrib/libs/curl/lib/connect.c
@@ -5,11 +5,11 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al. 
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
- * are also available at https://curl.se/docs/copyright.html.
+ * are also available at https://curl.se/docs/copyright.html. 
  *
  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  * copies of the Software, and permit persons to whom the Software is
@@ -74,7 +74,7 @@
 #include "warnless.h"
 #include "conncache.h"
 #include "multihandle.h"
-#include "version_win32.h"
+#include "version_win32.h" 
 #include "quic.h"
 #include "socks.h"
 
@@ -161,13 +161,13 @@ tcpkeepalive(struct Curl_easy *data,
 
 static CURLcode
 singleipconnect(struct connectdata *conn,
-                const struct Curl_addrinfo *ai, /* start connecting to this */
-                int tempindex);          /* 0 or 1 among the temp ones */
+                const struct Curl_addrinfo *ai, /* start connecting to this */ 
+                int tempindex);          /* 0 or 1 among the temp ones */ 
 
 /*
  * Curl_timeleft() returns the amount of milliseconds left allowed for the
- * transfer/connection. If the value is 0, there's no timeout (ie there's
- * infinite time left). If the value is negative, the timeout time has already
+ * transfer/connection. If the value is 0, there's no timeout (ie there's 
+ * infinite time left). If the value is negative, the timeout time has already 
  * elapsed.
  *
  * The start time is stored in progress.t_startsingle - as set with
@@ -551,22 +551,22 @@ static bool verifyconnect(curl_socket_t sockfd, int *error)
   return rc;
 }
 
-/* update tempaddr[tempindex] (to the next entry), makes sure to stick
-   to the correct family */
-static struct Curl_addrinfo *ainext(struct connectdata *conn,
-                                    int tempindex,
-                                    bool next) /* use next entry? */
-{
-  struct Curl_addrinfo *ai = conn->tempaddr[tempindex];
-  if(ai && next)
-    ai = ai->ai_next;
-  while(ai && (ai->ai_family != conn->tempfamily[tempindex]))
-    ai = ai->ai_next;
-  conn->tempaddr[tempindex] = ai;
-  return ai;
-}
-
-/* Used within the multi interface. Try next IP address, returns error if no
+/* update tempaddr[tempindex] (to the next entry), makes sure to stick 
+   to the correct family */ 
+static struct Curl_addrinfo *ainext(struct connectdata *conn, 
+                                    int tempindex, 
+                                    bool next) /* use next entry? */ 
+{ 
+  struct Curl_addrinfo *ai = conn->tempaddr[tempindex]; 
+  if(ai && next) 
+    ai = ai->ai_next; 
+  while(ai && (ai->ai_family != conn->tempfamily[tempindex])) 
+    ai = ai->ai_next; 
+  conn->tempaddr[tempindex] = ai; 
+  return ai; 
+} 
+ 
+/* Used within the multi interface. Try next IP address, returns error if no 
    more address exists or error */
 static CURLcode trynextip(struct connectdata *conn,
                           int sockindex,
@@ -582,13 +582,13 @@ static CURLcode trynextip(struct connectdata *conn,
   conn->tempsock[tempindex] = CURL_SOCKET_BAD;
 
   if(sockindex == FIRSTSOCKET) {
-    struct Curl_addrinfo *ai = conn->tempaddr[tempindex];
+    struct Curl_addrinfo *ai = conn->tempaddr[tempindex]; 
 
     while(ai) {
       if(ai) {
         result = singleipconnect(conn, ai, tempindex);
         if(result == CURLE_COULDNT_CONNECT) {
-          ai = ainext(conn, tempindex, TRUE);
+          ai = ainext(conn, tempindex, TRUE); 
           continue;
         }
       }
@@ -652,7 +652,7 @@ bool Curl_addr2string(struct sockaddr *sa, curl_socklen_t salen,
 #endif
 #if defined(HAVE_SYS_UN_H) && defined(AF_UNIX)
     case AF_UNIX:
-      if(salen > (curl_socklen_t)sizeof(sa_family_t)) {
+      if(salen > (curl_socklen_t)sizeof(sa_family_t)) { 
         su = (struct sockaddr_un*)sa;
         msnprintf(addr, MAX_IPADR_LEN, "%s", su->sun_path);
       }
@@ -673,155 +673,155 @@ bool Curl_addr2string(struct sockaddr *sa, curl_socklen_t salen,
 
 /* retrieves the start/end point information of a socket of an established
    connection */
-void Curl_conninfo_remote(struct connectdata *conn, curl_socket_t sockfd)
+void Curl_conninfo_remote(struct connectdata *conn, curl_socket_t sockfd) 
 {
-#ifdef HAVE_GETPEERNAME
-  char buffer[STRERROR_LEN];
-  struct Curl_sockaddr_storage ssrem;
-  curl_socklen_t plen;
-  plen = sizeof(struct Curl_sockaddr_storage);
-  if(getpeername(sockfd, (struct sockaddr*) &ssrem, &plen)) {
-    int error = SOCKERRNO;
-    failf(conn->data, "getpeername() failed with errno %d: %s",
-          error, Curl_strerror(error, buffer, sizeof(buffer)));
+#ifdef HAVE_GETPEERNAME 
+  char buffer[STRERROR_LEN]; 
+  struct Curl_sockaddr_storage ssrem; 
+  curl_socklen_t plen; 
+  plen = sizeof(struct Curl_sockaddr_storage); 
+  if(getpeername(sockfd, (struct sockaddr*) &ssrem, &plen)) { 
+    int error = SOCKERRNO; 
+    failf(conn->data, "getpeername() failed with errno %d: %s", 
+          error, Curl_strerror(error, buffer, sizeof(buffer))); 
     return;
-  }
-  if(!Curl_addr2string((struct sockaddr*)&ssrem, plen,
-                       conn->primary_ip, &conn->primary_port)) {
-    failf(conn->data, "ssrem inet_ntop() failed with errno %d: %s",
-          errno, Curl_strerror(errno, buffer, sizeof(buffer)));
-    return;
-  }
-  memcpy(conn->ip_addr_str, conn->primary_ip, MAX_IPADR_LEN);
-#else
-  (void)conn;
-  (void)sockfd;
-#endif
-}
-
-/* retrieves the start/end point information of a socket of an established
-   connection */
-void Curl_conninfo_local(struct connectdata *conn, curl_socket_t sockfd)
-{
+  } 
+  if(!Curl_addr2string((struct sockaddr*)&ssrem, plen, 
+                       conn->primary_ip, &conn->primary_port)) { 
+    failf(conn->data, "ssrem inet_ntop() failed with errno %d: %s", 
+          errno, Curl_strerror(errno, buffer, sizeof(buffer))); 
+    return; 
+  } 
+  memcpy(conn->ip_addr_str, conn->primary_ip, MAX_IPADR_LEN); 
+#else 
+  (void)conn; 
+  (void)sockfd; 
+#endif 
+} 
+
+/* retrieves the start/end point information of a socket of an established 
+   connection */ 
+void Curl_conninfo_local(struct connectdata *conn, curl_socket_t sockfd) 
+{ 
 #ifdef HAVE_GETSOCKNAME
-  char buffer[STRERROR_LEN];
-  struct Curl_sockaddr_storage ssloc;
-  curl_socklen_t slen;
-  slen = sizeof(struct Curl_sockaddr_storage);
-  memset(&ssloc, 0, sizeof(ssloc));
-  if(getsockname(sockfd, (struct sockaddr*) &ssloc, &slen)) {
-    int error = SOCKERRNO;
-    failf(conn->data, "getsockname() failed with errno %d: %s",
-          error, Curl_strerror(error, buffer, sizeof(buffer)));
-    return;
+  char buffer[STRERROR_LEN]; 
+  struct Curl_sockaddr_storage ssloc; 
+  curl_socklen_t slen; 
+  slen = sizeof(struct Curl_sockaddr_storage); 
+  memset(&ssloc, 0, sizeof(ssloc)); 
+  if(getsockname(sockfd, (struct sockaddr*) &ssloc, &slen)) { 
+    int error = SOCKERRNO; 
+    failf(conn->data, "getsockname() failed with errno %d: %s", 
+          error, Curl_strerror(error, buffer, sizeof(buffer))); 
+    return; 
   }
-  if(!Curl_addr2string((struct sockaddr*)&ssloc, slen,
-                       conn->local_ip, &conn->local_port)) {
-    failf(conn->data, "ssloc inet_ntop() failed with errno %d: %s",
-          errno, Curl_strerror(errno, buffer, sizeof(buffer)));
-    return;
-  }
-#else
-  (void)conn;
-  (void)sockfd;
+  if(!Curl_addr2string((struct sockaddr*)&ssloc, slen, 
+                       conn->local_ip, &conn->local_port)) { 
+    failf(conn->data, "ssloc inet_ntop() failed with errno %d: %s", 
+          errno, Curl_strerror(errno, buffer, sizeof(buffer))); 
+    return; 
+  } 
+#else 
+  (void)conn; 
+  (void)sockfd; 
 #endif
-}
-
-/* retrieves the start/end point information of a socket of an established
-   connection */
-void Curl_updateconninfo(struct connectdata *conn, curl_socket_t sockfd)
-{
-  if(conn->transport == TRNSPRT_TCP) {
-    if(!conn->bits.reuse && !conn->bits.tcp_fastopen) {
-      Curl_conninfo_remote(conn, sockfd);
-      Curl_conninfo_local(conn, sockfd);
-    }
-  } /* end of TCP-only section */
-
+} 
+
+/* retrieves the start/end point information of a socket of an established 
+   connection */ 
+void Curl_updateconninfo(struct connectdata *conn, curl_socket_t sockfd) 
+{ 
+  if(conn->transport == TRNSPRT_TCP) { 
+    if(!conn->bits.reuse && !conn->bits.tcp_fastopen) { 
+      Curl_conninfo_remote(conn, sockfd); 
+      Curl_conninfo_local(conn, sockfd); 
+    } 
+  } /* end of TCP-only section */ 
+ 
   /* persist connection info in session handle */
   Curl_persistconninfo(conn);
 }
 
-/* After a TCP connection to the proxy has been verified, this function does
-   the next magic steps. If 'done' isn't set TRUE, it is not done yet and
-   must be called again.
+/* After a TCP connection to the proxy has been verified, this function does 
+   the next magic steps. If 'done' isn't set TRUE, it is not done yet and 
+   must be called again. 
 
    Note: this function's sub-functions call failf()
 
 */
-static CURLcode connect_SOCKS(struct connectdata *conn, int sockindex,
-                              bool *done)
+static CURLcode connect_SOCKS(struct connectdata *conn, int sockindex, 
+                              bool *done) 
 {
   CURLcode result = CURLE_OK;
-#ifndef CURL_DISABLE_PROXY
-  CURLproxycode pxresult = CURLPX_OK;
+#ifndef CURL_DISABLE_PROXY 
+  CURLproxycode pxresult = CURLPX_OK; 
   if(conn->bits.socksproxy) {
     /* for the secondary socket (FTP), use the "connect to host"
      * but ignore the "connect to port" (use the secondary port)
      */
-    const char * const host =
-      conn->bits.httpproxy ?
-      conn->http_proxy.host.name :
-      conn->bits.conn_to_host ?
-      conn->conn_to_host.name :
-      sockindex == SECONDARYSOCKET ?
-      conn->secondaryhostname : conn->host.name;
-    const int port =
-      conn->bits.httpproxy ? (int)conn->http_proxy.port :
-      sockindex == SECONDARYSOCKET ? conn->secondary_port :
-      conn->bits.conn_to_port ? conn->conn_to_port :
-      conn->remote_port;
+    const char * const host = 
+      conn->bits.httpproxy ? 
+      conn->http_proxy.host.name : 
+      conn->bits.conn_to_host ? 
+      conn->conn_to_host.name : 
+      sockindex == SECONDARYSOCKET ? 
+      conn->secondaryhostname : conn->host.name; 
+    const int port = 
+      conn->bits.httpproxy ? (int)conn->http_proxy.port : 
+      sockindex == SECONDARYSOCKET ? conn->secondary_port : 
+      conn->bits.conn_to_port ? conn->conn_to_port : 
+      conn->remote_port; 
     switch(conn->socks_proxy.proxytype) {
     case CURLPROXY_SOCKS5:
     case CURLPROXY_SOCKS5_HOSTNAME:
-      pxresult = Curl_SOCKS5(conn->socks_proxy.user, conn->socks_proxy.passwd,
-                             host, port, sockindex, conn, done);
+      pxresult = Curl_SOCKS5(conn->socks_proxy.user, conn->socks_proxy.passwd, 
+                             host, port, sockindex, conn, done); 
       break;
 
     case CURLPROXY_SOCKS4:
     case CURLPROXY_SOCKS4A:
-      pxresult = Curl_SOCKS4(conn->socks_proxy.user, host, port, sockindex,
-                             conn, done);
+      pxresult = Curl_SOCKS4(conn->socks_proxy.user, host, port, sockindex, 
+                             conn, done); 
       break;
 
     default:
       failf(conn->data, "unknown proxytype option given");
       result = CURLE_COULDNT_CONNECT;
     } /* switch proxytype */
-    if(pxresult) {
-      result = CURLE_PROXY;
-      conn->data->info.pxcode = pxresult;
-    }
-  }
-  else
+    if(pxresult) { 
+      result = CURLE_PROXY; 
+      conn->data->info.pxcode = pxresult; 
+    } 
+  } 
+  else 
 #else
-    (void)conn;
-    (void)sockindex;
+    (void)conn; 
+    (void)sockindex; 
 #endif /* CURL_DISABLE_PROXY */
-    *done = TRUE; /* no SOCKS proxy, so consider us connected */
+    *done = TRUE; /* no SOCKS proxy, so consider us connected */ 
 
   return result;
 }
 
 /*
- * post_SOCKS() is called after a successful connect to the peer, which
- * *could* be a SOCKS proxy
- */
-static void post_SOCKS(struct connectdata *conn,
-                       int sockindex,
-                       bool *connected)
-{
-  conn->bits.tcpconnect[sockindex] = TRUE;
-
-  *connected = TRUE;
-  if(sockindex == FIRSTSOCKET)
-    Curl_pgrsTime(conn->data, TIMER_CONNECT); /* connect done */
-  Curl_updateconninfo(conn, conn->sock[sockindex]);
-  Curl_verboseconnect(conn);
-  conn->data->info.numconnects++; /* to track the number of connections made */
-}
-
-/*
+ * post_SOCKS() is called after a successful connect to the peer, which 
+ * *could* be a SOCKS proxy 
+ */ 
+static void post_SOCKS(struct connectdata *conn, 
+                       int sockindex, 
+                       bool *connected) 
+{ 
+  conn->bits.tcpconnect[sockindex] = TRUE; 
+ 
+  *connected = TRUE; 
+  if(sockindex == FIRSTSOCKET) 
+    Curl_pgrsTime(conn->data, TIMER_CONNECT); /* connect done */ 
+  Curl_updateconninfo(conn, conn->sock[sockindex]); 
+  Curl_verboseconnect(conn); 
+  conn->data->info.numconnects++; /* to track the number of connections made */ 
+} 
+ 
+/* 
  * Curl_is_connected() checks if the socket has connected.
  */
 
@@ -834,8 +834,8 @@ CURLcode Curl_is_connected(struct connectdata *conn,
   timediff_t allow;
   int error = 0;
   struct curltime now;
-  int rc = 0;
-  unsigned int i;
+  int rc = 0; 
+  unsigned int i; 
 
   DEBUGASSERT(sockindex >= FIRSTSOCKET && sockindex <= SECONDARYSOCKET);
 
@@ -858,62 +858,62 @@ CURLcode Curl_is_connected(struct connectdata *conn,
     return CURLE_OPERATION_TIMEDOUT;
   }
 
-  if(SOCKS_STATE(conn->cnnct.state)) {
-    /* still doing SOCKS */
-    result = connect_SOCKS(conn, sockindex, connected);
-    if(!result && *connected)
-      post_SOCKS(conn, sockindex, connected);
-    return result;
-  }
-
+  if(SOCKS_STATE(conn->cnnct.state)) { 
+    /* still doing SOCKS */ 
+    result = connect_SOCKS(conn, sockindex, connected); 
+    if(!result && *connected) 
+      post_SOCKS(conn, sockindex, connected); 
+    return result; 
+  } 
+ 
   for(i = 0; i<2; i++) {
     const int other = i ^ 1;
     if(conn->tempsock[i] == CURL_SOCKET_BAD)
       continue;
-    error = 0;
+    error = 0; 
 #ifdef ENABLE_QUIC
     if(conn->transport == TRNSPRT_QUIC) {
       result = Curl_quic_is_connected(conn, i, connected);
-      if(!result && *connected) {
+      if(!result && *connected) { 
         /* use this socket from now on */
         conn->sock[sockindex] = conn->tempsock[i];
         conn->ip_addr = conn->tempaddr[i];
         conn->tempsock[i] = CURL_SOCKET_BAD;
-        post_SOCKS(conn, sockindex, connected);
+        post_SOCKS(conn, sockindex, connected); 
         connkeep(conn, "HTTP/3 default");
-        return CURLE_OK;
+        return CURLE_OK; 
       }
-      if(result)
-        error = SOCKERRNO;
+      if(result) 
+        error = SOCKERRNO; 
     }
-    else
+    else 
 #endif
-    {
+    { 
 #ifdef mpeix
-      /* Call this function once now, and ignore the results. We do this to
-         "clear" the error state on the socket so that we can later read it
-         reliably. This is reported necessary on the MPE/iX operating
-         system. */
-      (void)verifyconnect(conn->tempsock[i], NULL);
+      /* Call this function once now, and ignore the results. We do this to 
+         "clear" the error state on the socket so that we can later read it 
+         reliably. This is reported necessary on the MPE/iX operating 
+         system. */ 
+      (void)verifyconnect(conn->tempsock[i], NULL); 
 #endif
 
-      /* check socket for connect */
-      rc = SOCKET_WRITABLE(conn->tempsock[i], 0);
-    }
+      /* check socket for connect */ 
+      rc = SOCKET_WRITABLE(conn->tempsock[i], 0); 
+    } 
 
     if(rc == 0) { /* no connection yet */
-      if(Curl_timediff(now, conn->connecttime) >=
-         conn->timeoutms_per_addr[i]) {
+      if(Curl_timediff(now, conn->connecttime) >= 
+         conn->timeoutms_per_addr[i]) { 
         infof(data, "After %" CURL_FORMAT_TIMEDIFF_T
-              "ms connect time, move on!\n", conn->timeoutms_per_addr[i]);
+              "ms connect time, move on!\n", conn->timeoutms_per_addr[i]); 
         error = ETIMEDOUT;
       }
 
       /* should we try another protocol family? */
-      if(i == 0 && !conn->bits.parallel_connect &&
+      if(i == 0 && !conn->bits.parallel_connect && 
          (Curl_timediff(now, conn->connecttime) >=
           data->set.happy_eyeballs_timeout)) {
-        conn->bits.parallel_connect = TRUE; /* starting now */
+        conn->bits.parallel_connect = TRUE; /* starting now */ 
         trynextip(conn, sockindex, 1);
       }
     }
@@ -935,20 +935,20 @@ CURLcode Curl_is_connected(struct connectdata *conn,
           conn->tempsock[other] = CURL_SOCKET_BAD;
         }
 
-        /* see if we need to kick off any SOCKS proxy magic once we
-           connected */
-        result = connect_SOCKS(conn, sockindex, connected);
-        if(result || !*connected)
+        /* see if we need to kick off any SOCKS proxy magic once we 
+           connected */ 
+        result = connect_SOCKS(conn, sockindex, connected); 
+        if(result || !*connected) 
           return result;
 
-        post_SOCKS(conn, sockindex, connected);
+        post_SOCKS(conn, sockindex, connected); 
 
         return CURLE_OK;
       }
     }
-    else if(rc & CURL_CSELECT_ERR) {
+    else if(rc & CURL_CSELECT_ERR) { 
       (void)verifyconnect(conn->tempsock[i], &error);
-    }
+    } 
 
     /*
      * The connection failed here, we should attempt to connect to the "next
@@ -959,19 +959,19 @@ CURLcode Curl_is_connected(struct connectdata *conn,
       SET_SOCKERRNO(error);
       if(conn->tempaddr[i]) {
         CURLcode status;
-#ifndef CURL_DISABLE_VERBOSE_STRINGS
+#ifndef CURL_DISABLE_VERBOSE_STRINGS 
         char ipaddress[MAX_IPADR_LEN];
         char buffer[STRERROR_LEN];
-        Curl_printable_address(conn->tempaddr[i], ipaddress,
-                               sizeof(ipaddress));
+        Curl_printable_address(conn->tempaddr[i], ipaddress, 
+                               sizeof(ipaddress)); 
         infof(data, "connect to %s port %ld failed: %s\n",
               ipaddress, conn->port,
               Curl_strerror(error, buffer, sizeof(buffer)));
-#endif
+#endif 
 
-        conn->timeoutms_per_addr[i] = conn->tempaddr[i]->ai_next == NULL ?
+        conn->timeoutms_per_addr[i] = conn->tempaddr[i]->ai_next == NULL ? 
           allow : allow / 2;
-        ainext(conn, i, TRUE);
+        ainext(conn, i, TRUE); 
         status = trynextip(conn, sockindex, i);
         if((status != CURLE_COULDNT_CONNECT) ||
            conn->tempsock[other] == CURL_SOCKET_BAD)
@@ -981,48 +981,48 @@ CURLcode Curl_is_connected(struct connectdata *conn,
     }
   }
 
-  if(result &&
-     (conn->tempsock[0] == CURL_SOCKET_BAD) &&
-     (conn->tempsock[1] == CURL_SOCKET_BAD)) {
+  if(result && 
+     (conn->tempsock[0] == CURL_SOCKET_BAD) && 
+     (conn->tempsock[1] == CURL_SOCKET_BAD)) { 
     /* no more addresses to try */
     const char *hostname;
     char buffer[STRERROR_LEN];
 
-    /* if the first address family runs out of addresses to try before the
-       happy eyeball timeout, go ahead and try the next family now */
-    result = trynextip(conn, sockindex, 1);
-    if(!result)
-      return result;
+    /* if the first address family runs out of addresses to try before the 
+       happy eyeball timeout, go ahead and try the next family now */ 
+    result = trynextip(conn, sockindex, 1); 
+    if(!result) 
+      return result; 
 
-#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_PROXY 
     if(conn->bits.socksproxy)
       hostname = conn->socks_proxy.host.name;
     else if(conn->bits.httpproxy)
       hostname = conn->http_proxy.host.name;
     else
-#endif
-      if(conn->bits.conn_to_host)
-        hostname = conn->conn_to_host.name;
-    else
+#endif 
+      if(conn->bits.conn_to_host) 
+        hostname = conn->conn_to_host.name; 
+    else 
       hostname = conn->host.name;
 
     failf(data, "Failed to connect to %s port %ld: %s",
           hostname, conn->port,
           Curl_strerror(error, buffer, sizeof(buffer)));
-
-    Curl_quic_disconnect(conn, 0);
-    Curl_quic_disconnect(conn, 1);
-
-#ifdef WSAETIMEDOUT
-    if(WSAETIMEDOUT == data->state.os_errno)
-      result = CURLE_OPERATION_TIMEDOUT;
-#elif defined(ETIMEDOUT)
-    if(ETIMEDOUT == data->state.os_errno)
-      result = CURLE_OPERATION_TIMEDOUT;
-#endif
+ 
+    Curl_quic_disconnect(conn, 0); 
+    Curl_quic_disconnect(conn, 1); 
+ 
+#ifdef WSAETIMEDOUT 
+    if(WSAETIMEDOUT == data->state.os_errno) 
+      result = CURLE_OPERATION_TIMEDOUT; 
+#elif defined(ETIMEDOUT) 
+    if(ETIMEDOUT == data->state.os_errno) 
+      result = CURLE_OPERATION_TIMEDOUT; 
+#endif 
   }
-  else
-    result = CURLE_OK; /* still trying */
+  else 
+    result = CURLE_OK; /* still trying */ 
 
   return result;
 }
@@ -1030,12 +1030,12 @@ CURLcode Curl_is_connected(struct connectdata *conn,
 static void tcpnodelay(struct connectdata *conn, curl_socket_t sockfd)
 {
 #if defined(TCP_NODELAY)
-  curl_socklen_t onoff = (curl_socklen_t) 1;
-  int level = IPPROTO_TCP;
+  curl_socklen_t onoff = (curl_socklen_t) 1; 
+  int level = IPPROTO_TCP; 
 #if !defined(CURL_DISABLE_VERBOSE_STRINGS)
   struct Curl_easy *data = conn->data;
   char buffer[STRERROR_LEN];
-#else
+#else 
   (void) conn;
 #endif
 
@@ -1096,8 +1096,8 @@ void Curl_sndbufset(curl_socket_t sockfd)
   static int detectOsState = DETECT_OS_NONE;
 
   if(detectOsState == DETECT_OS_NONE) {
-    if(curlx_verify_windows_version(6, 0, PLATFORM_WINNT,
-                                    VERSION_GREATER_THAN_EQUAL))
+    if(curlx_verify_windows_version(6, 0, PLATFORM_WINNT, 
+                                    VERSION_GREATER_THAN_EQUAL)) 
       detectOsState = DETECT_OS_VISTA_OR_LATER;
     else
       detectOsState = DETECT_OS_PREVISTA;
@@ -1124,8 +1124,8 @@ void Curl_sndbufset(curl_socket_t sockfd)
  * having connected.
  */
 static CURLcode singleipconnect(struct connectdata *conn,
-                                const struct Curl_addrinfo *ai,
-                                int tempindex)
+                                const struct Curl_addrinfo *ai, 
+                                int tempindex) 
 {
   struct Curl_sockaddr_ex addr;
   int rc = -1;
@@ -1141,12 +1141,12 @@ static CURLcode singleipconnect(struct connectdata *conn,
   int optval = 1;
 #endif
   char buffer[STRERROR_LEN];
-  curl_socket_t *sockp = &conn->tempsock[tempindex];
+  curl_socket_t *sockp = &conn->tempsock[tempindex]; 
   *sockp = CURL_SOCKET_BAD;
 
   result = Curl_socket(conn, ai, &addr, &sockfd);
   if(result)
-    return result;
+    return result; 
 
   /* store remote address and port used in this connection attempt */
   if(!Curl_addr2string((struct sockaddr*)&addr.sa_addr, addr.addrlen,
@@ -1214,10 +1214,10 @@ static CURLcode singleipconnect(struct connectdata *conn,
   (void)curlx_nonblock(sockfd, TRUE);
 
   conn->connecttime = Curl_now();
-  if(conn->num_addr > 1) {
-    Curl_expire(data, conn->timeoutms_per_addr[0], EXPIRE_DNS_PER_NAME);
-    Curl_expire(data, conn->timeoutms_per_addr[1], EXPIRE_DNS_PER_NAME2);
-  }
+  if(conn->num_addr > 1) { 
+    Curl_expire(data, conn->timeoutms_per_addr[0], EXPIRE_DNS_PER_NAME); 
+    Curl_expire(data, conn->timeoutms_per_addr[1], EXPIRE_DNS_PER_NAME2); 
+  } 
 
   /* Connect TCP and QUIC sockets */
   if(!isconnected && (conn->transport != TRNSPRT_UDP)) {
@@ -1268,7 +1268,7 @@ static CURLcode singleipconnect(struct connectdata *conn,
     else if(conn->transport == TRNSPRT_QUIC) {
       /* pass in 'sockfd' separately since it hasn't been put into the
          tempsock array at this point */
-      result = Curl_quic_connect(conn, sockfd, tempindex,
+      result = Curl_quic_connect(conn, sockfd, tempindex, 
                                  &addr.sa_addr, addr.addrlen);
       if(result)
         error = SOCKERRNO;
@@ -1325,8 +1325,8 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
 {
   struct Curl_easy *data = conn->data;
   CURLcode result = CURLE_COULDNT_CONNECT;
-  int i;
-  timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
+  int i; 
+  timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE); 
 
   if(timeout_ms < 0) {
     /* a precaution, no need to continue if time already is up */
@@ -1335,39 +1335,39 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
   }
 
   conn->num_addr = Curl_num_addresses(remotehost->addr);
-  conn->tempaddr[0] = conn->tempaddr[1] = remotehost->addr;
-  conn->tempsock[0] = conn->tempsock[1] = CURL_SOCKET_BAD;
+  conn->tempaddr[0] = conn->tempaddr[1] = remotehost->addr; 
+  conn->tempsock[0] = conn->tempsock[1] = CURL_SOCKET_BAD; 
 
   /* Max time for the next connection attempt */
-  conn->timeoutms_per_addr[0] =
+  conn->timeoutms_per_addr[0] = 
     conn->tempaddr[0]->ai_next == NULL ? timeout_ms : timeout_ms / 2;
-  conn->timeoutms_per_addr[1] =
-    conn->tempaddr[1]->ai_next == NULL ? timeout_ms : timeout_ms / 2;
-
-  conn->tempfamily[0] = conn->tempaddr[0]?
-    conn->tempaddr[0]->ai_family:0;
-#ifdef ENABLE_IPV6
-  conn->tempfamily[1] = conn->tempfamily[0] == AF_INET6 ?
-    AF_INET : AF_INET6;
-#else
-  conn->tempfamily[1] = AF_UNSPEC;
-#endif
-  ainext(conn, 1, FALSE); /* assigns conn->tempaddr[1] accordingly */
-
-  DEBUGF(infof(data, "family0 == %s, family1 == %s\n",
-               conn->tempfamily[0] == AF_INET ? "v4" : "v6",
-               conn->tempfamily[1] == AF_INET ? "v4" : "v6"));
-
-  /* get through the list in family order in case of quick failures */
-  for(i = 0; (i < 2) && result; i++) {
-    while(conn->tempaddr[i]) {
-      result = singleipconnect(conn, conn->tempaddr[i], i);
-      if(!result)
-        break;
-      ainext(conn, i, TRUE);
-    }
+  conn->timeoutms_per_addr[1] = 
+    conn->tempaddr[1]->ai_next == NULL ? timeout_ms : timeout_ms / 2; 
+
+  conn->tempfamily[0] = conn->tempaddr[0]? 
+    conn->tempaddr[0]->ai_family:0; 
+#ifdef ENABLE_IPV6 
+  conn->tempfamily[1] = conn->tempfamily[0] == AF_INET6 ? 
+    AF_INET : AF_INET6; 
+#else 
+  conn->tempfamily[1] = AF_UNSPEC; 
+#endif 
+  ainext(conn, 1, FALSE); /* assigns conn->tempaddr[1] accordingly */ 
+ 
+  DEBUGF(infof(data, "family0 == %s, family1 == %s\n", 
+               conn->tempfamily[0] == AF_INET ? "v4" : "v6", 
+               conn->tempfamily[1] == AF_INET ? "v4" : "v6")); 
+ 
+  /* get through the list in family order in case of quick failures */ 
+  for(i = 0; (i < 2) && result; i++) { 
+    while(conn->tempaddr[i]) { 
+      result = singleipconnect(conn, conn->tempaddr[i], i); 
+      if(!result) 
+        break; 
+      ainext(conn, i, TRUE); 
+    } 
   }
-  if(result)
+  if(result) 
     return result;
 
   Curl_expire(conn->data, data->set.happy_eyeballs_timeout,
@@ -1377,15 +1377,15 @@ CURLcode Curl_connecthost(struct connectdata *conn,  /* context */
 }
 
 struct connfind {
-  long id_tofind;
-  struct connectdata *found;
+  long id_tofind; 
+  struct connectdata *found; 
 };
 
 static int conn_is_conn(struct connectdata *conn, void *param)
 {
   struct connfind *f = (struct connfind *)param;
-  if(conn->connection_id == f->id_tofind) {
-    f->found = conn;
+  if(conn->connection_id == f->id_tofind) { 
+    f->found = conn; 
     return 1;
   }
   return 0;
@@ -1407,22 +1407,22 @@ curl_socket_t Curl_getconnectinfo(struct Curl_easy *data,
    * - that is associated with a multi handle, and whose connection
    *   was detached with CURLOPT_CONNECT_ONLY
    */
-  if((data->state.lastconnect_id != -1) && (data->multi_easy || data->multi)) {
-    struct connectdata *c;
+  if((data->state.lastconnect_id != -1) && (data->multi_easy || data->multi)) { 
+    struct connectdata *c; 
     struct connfind find;
-    find.id_tofind = data->state.lastconnect_id;
-    find.found = NULL;
+    find.id_tofind = data->state.lastconnect_id; 
+    find.found = NULL; 
 
     Curl_conncache_foreach(data, data->multi_easy?
                            &data->multi_easy->conn_cache:
                            &data->multi->conn_cache, &find, conn_is_conn);
 
     if(!find.found) {
-      data->state.lastconnect_id = -1;
+      data->state.lastconnect_id = -1; 
       return CURL_SOCKET_BAD;
     }
 
-    c = find.found;
+    c = find.found; 
     if(connp) {
       /* only store this if the caller cares for it */
       *connp = c;
@@ -1430,7 +1430,7 @@ curl_socket_t Curl_getconnectinfo(struct Curl_easy *data,
     }
     return c->sock[FIRSTSOCKET];
   }
-  return CURL_SOCKET_BAD;
+  return CURL_SOCKET_BAD; 
 }
 
 /*
@@ -1469,11 +1469,11 @@ int Curl_closesocket(struct connectdata *conn,
                       curl_socket_t sock)
 {
   if(conn && conn->fclosesocket) {
-    if((sock == conn->sock[SECONDARYSOCKET]) && conn->bits.sock_accepted)
+    if((sock == conn->sock[SECONDARYSOCKET]) && conn->bits.sock_accepted) 
       /* if this socket matches the second socket, and that was created with
          accept, then we MUST NOT call the callback but clear the accepted
          status */
-      conn->bits.sock_accepted = FALSE;
+      conn->bits.sock_accepted = FALSE; 
     else {
       int rc;
       Curl_multi_closed(conn->data, sock);
@@ -1503,7 +1503,7 @@ int Curl_closesocket(struct connectdata *conn,
  *
  */
 CURLcode Curl_socket(struct connectdata *conn,
-                     const struct Curl_addrinfo *ai,
+                     const struct Curl_addrinfo *ai, 
                      struct Curl_sockaddr_ex *addr,
                      curl_socket_t *sockfd)
 {
@@ -1556,11 +1556,11 @@ CURLcode Curl_socket(struct connectdata *conn,
     /* no socket, no connection */
     return CURLE_COULDNT_CONNECT;
 
-  if(conn->transport == TRNSPRT_QUIC) {
-    /* QUIC sockets need to be nonblocking */
-    (void)curlx_nonblock(*sockfd, TRUE);
-  }
-
+  if(conn->transport == TRNSPRT_QUIC) { 
+    /* QUIC sockets need to be nonblocking */ 
+    (void)curlx_nonblock(*sockfd, TRUE); 
+  } 
+ 
 #if defined(ENABLE_IPV6) && defined(HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID)
   if(conn->scope_id && (addr->family == AF_INET6)) {
     struct sockaddr_in6 * const sa6 = (void *)&addr->sa_addr;
@@ -1585,7 +1585,7 @@ void Curl_conncontrol(struct connectdata *conn,
   /* close if a connection, or a stream that isn't multiplexed */
   bool closeit = (ctrl == CONNCTRL_CONNECTION) ||
     ((ctrl == CONNCTRL_STREAM) && !(conn->handler->flags & PROTOPT_STREAM));
-  DEBUGASSERT(conn);
+  DEBUGASSERT(conn); 
   if((ctrl == CONNCTRL_STREAM) &&
      (conn->handler->flags & PROTOPT_STREAM))
     DEBUGF(infof(conn->data, "Kill stream: %s\n", reason));
@@ -1601,7 +1601,7 @@ void Curl_conncontrol(struct connectdata *conn,
 bool Curl_conn_data_pending(struct connectdata *conn, int sockindex)
 {
   int readable;
-  DEBUGASSERT(conn);
+  DEBUGASSERT(conn); 
 
   if(Curl_ssl_data_pending(conn, sockindex) ||
      Curl_recv_has_postponed_data(conn, sockindex))