lib: replace conn [write]sockfd members by index

The `connectdata` members `sockfd` and `writesockfd` needed to by either
CURL_SOCKET_BAD or a copy of one of `conn->sock[2]`. When equal to one,
that index was used to send/recv/poll the proper socket or connection
filter chain.

Replace those with `send_idx` and `recv_idx` which are either -1, 0 or 1
to indicate which socket/filter to send/receive on.

Closes #18179

diff --git a/lib/cfilters.c b/lib/cfilters.c
index e4b630bc8fe4dc187527b26aae77233666190ef3..c3b40b0bc5934aa488b682f19854a5ba5d77dc37 100644 (file)
--- a/lib/cfilters.c
+++ b/lib/cfilters.c
@@ -177,6 +177,10 @@ CURLcode Curl_conn_shutdown(struct Curl_easy *data, int sockindex, bool *done)
   struct curltime now;
 
   DEBUGASSERT(data->conn);
+
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
+
   /* Get the first connected filter that is not shut down already. */
   cf = data->conn->cfilter[sockindex];
   while(cf && (!cf->connected || cf->shutdown))
@@ -477,6 +481,8 @@ CURLcode Curl_conn_connect(struct Curl_easy *data,
 
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
 
   cf = data->conn->cfilter[sockindex];
   if(!cf) {
@@ -568,6 +574,8 @@ out:
 
 bool Curl_conn_is_setup(struct connectdata *conn, int sockindex)
 {
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   return (conn->cfilter[sockindex] != NULL);
 }
 
@@ -575,6 +583,8 @@ bool Curl_conn_is_connected(struct connectdata *conn, int sockindex)
 {
   struct Curl_cfilter *cf;
 
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   cf = conn->cfilter[sockindex];
   return cf && cf->connected;
 }
@@ -583,6 +593,8 @@ bool Curl_conn_is_ip_connected(struct Curl_easy *data, int sockindex)
 {
   struct Curl_cfilter *cf;
 
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   cf = data->conn->cfilter[sockindex];
   while(cf) {
     if(cf->connected)
@@ -607,6 +619,8 @@ static bool cf_is_ssl(struct Curl_cfilter *cf)
 
 bool Curl_conn_is_ssl(struct connectdata *conn, int sockindex)
 {
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   return conn ? cf_is_ssl(conn->cfilter[sockindex]) : FALSE;
 }
 
@@ -614,6 +628,8 @@ bool Curl_conn_get_ssl_info(struct Curl_easy *data,
                             struct connectdata *conn, int sockindex,
                             struct curl_tlssessioninfo *info)
 {
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   if(Curl_conn_is_ssl(conn, sockindex)) {
     struct Curl_cfilter *cf = conn->cfilter[sockindex];
     CURLcode result = cf ? cf->cft->query(cf, data, CF_QUERY_SSL_INFO,
@@ -627,13 +643,20 @@ CURLcode Curl_conn_get_ip_info(struct Curl_easy *data,
                                struct connectdata *conn, int sockindex,
                                bool *is_ipv6, struct ip_quadruple *ipquad)
 {
-  struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
+  struct Curl_cfilter *cf;
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
+  cf = conn ? conn->cfilter[sockindex] : NULL;
   return Curl_conn_cf_get_ip_info(cf, data, is_ipv6, ipquad);
 }
 
 bool Curl_conn_is_multiplex(struct connectdata *conn, int sockindex)
 {
-  struct Curl_cfilter *cf = conn ? conn->cfilter[sockindex] : NULL;
+  struct Curl_cfilter *cf;
+
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
+  cf = conn ? conn->cfilter[sockindex] : NULL;
 
   for(; cf; cf = cf->next) {
     if(cf->cft->flags & CF_TYPE_MULTIPLEX)
@@ -689,6 +712,8 @@ bool Curl_conn_data_pending(struct Curl_easy *data, int sockindex)
   (void)data;
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
 
   cf = data->conn->cfilter[sockindex];
   while(cf && !cf->connected) {
@@ -712,6 +737,8 @@ bool Curl_conn_cf_needs_flush(struct Curl_cfilter *cf,
 
 bool Curl_conn_needs_flush(struct Curl_easy *data, int sockindex)
 {
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return FALSE;
   return Curl_conn_cf_needs_flush(data->conn->cfilter[sockindex], data);
 }
 
@@ -774,8 +801,14 @@ void Curl_conn_get_current_host(struct Curl_easy *data, int sockindex,
 {
   struct Curl_cfilter *cf, *cf_proxy = NULL;
 
-  DEBUGASSERT(data->conn);
-  cf = data->conn->cfilter[sockindex];
+  if(!data->conn) {
+    DEBUGASSERT(0);
+    *phost = "";
+    *pport = -1;
+    return;
+  }
+
+  cf = CONN_SOCK_IDX_VALID(sockindex) ? data->conn->cfilter[sockindex] : NULL;
   /* Find the "lowest" tunneling proxy filter that has not connected yet. */
   while(cf && !cf->connected) {
     if((cf->cft->flags & (CF_TYPE_IP_CONNECT|CF_TYPE_PROXY)) ==
@@ -881,7 +914,8 @@ curl_socket_t Curl_conn_get_socket(struct Curl_easy *data, int sockindex)
 {
   struct Curl_cfilter *cf;
 
-  cf = data->conn ? data->conn->cfilter[sockindex] : NULL;
+  cf = (data->conn && CONN_SOCK_IDX_VALID(sockindex)) ?
+       data->conn->cfilter[sockindex] : NULL;
   /* if the top filter has not connected, ask it (and its sub-filters)
    * for the socket. Otherwise conn->sock[sockindex] should have it.
    */
@@ -893,13 +927,15 @@ curl_socket_t Curl_conn_get_socket(struct Curl_easy *data, int sockindex)
 const struct Curl_sockaddr_ex *
 Curl_conn_get_remote_addr(struct Curl_easy *data, int sockindex)
 {
-  struct Curl_cfilter *cf = data->conn ? data->conn->cfilter[sockindex] : NULL;
+  struct Curl_cfilter *cf =
+    (data->conn && CONN_SOCK_IDX_VALID(sockindex)) ?
+    data->conn->cfilter[sockindex] : NULL;
   return cf ? cf_get_remote_addr(cf, data) : NULL;
 }
 
 void Curl_conn_forget_socket(struct Curl_easy *data, int sockindex)
 {
-  if(data->conn) {
+  if(data->conn && CONN_SOCK_IDX_VALID(sockindex)) {
     struct Curl_cfilter *cf = data->conn->cfilter[sockindex];
     if(cf)
       (void)Curl_conn_cf_cntrl(cf, data, TRUE,
@@ -941,6 +977,8 @@ CURLcode Curl_conn_ev_data_idle(struct Curl_easy *data)
 
 CURLcode Curl_conn_flush(struct Curl_easy *data, int sockindex)
 {
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
   return Curl_conn_cf_cntrl(data->conn->cfilter[sockindex], data, FALSE,
                             CF_CTRL_FLUSH, 0, NULL);
 }
@@ -1010,7 +1048,11 @@ CURLcode Curl_conn_keep_alive(struct Curl_easy *data,
                               struct connectdata *conn,
                               int sockindex)
 {
-  struct Curl_cfilter *cf = conn->cfilter[sockindex];
+  struct Curl_cfilter *cf;
+
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
+  cf = conn->cfilter[sockindex];
   return cf ? cf->cft->keep_alive(cf, data) : CURLE_OK;
 }
 
@@ -1018,10 +1060,14 @@ size_t Curl_conn_get_max_concurrent(struct Curl_easy *data,
                                     struct connectdata *conn,
                                     int sockindex)
 {
+  struct Curl_cfilter *cf;
   CURLcode result;
   int n = -1;
 
-  struct Curl_cfilter *cf = conn->cfilter[sockindex];
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return 0;
+
+  cf = conn->cfilter[sockindex];
   result = cf ? cf->cft->query(cf, data, CF_QUERY_MAX_CONCURRENT,
                                &n, NULL) : CURLE_UNKNOWN_OPTION;
   /* If no filter answered the query, the default is a non-multiplexed
@@ -1034,10 +1080,14 @@ int Curl_conn_get_stream_error(struct Curl_easy *data,
                                struct connectdata *conn,
                                int sockindex)
 {
+  struct Curl_cfilter *cf;
   CURLcode result;
   int n = 0;
 
-  struct Curl_cfilter *cf = conn->cfilter[sockindex];
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return 0;
+
+  cf = conn->cfilter[sockindex];
   result = cf ? cf->cft->query(cf, data, CF_QUERY_STREAM_ERROR,
                                &n, NULL) : CURLE_UNKNOWN_OPTION;
   return (result || n < 0) ? 0 : n;
@@ -1056,6 +1106,8 @@ CURLcode Curl_conn_recv(struct Curl_easy *data, int sockindex,
 {
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
   if(data && data->conn && data->conn->recv[sockindex])
     return data->conn->recv[sockindex](data, sockindex, buf, blen, pnread);
   *pnread = 0;
@@ -1070,7 +1122,9 @@ CURLcode Curl_conn_send(struct Curl_easy *data, int sockindex,
 
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
-  DEBUGASSERT(sockindex >= 0 && sockindex < 2);
+  DEBUGASSERT(CONN_SOCK_IDX_VALID(sockindex));
+  if(!CONN_SOCK_IDX_VALID(sockindex))
+    return CURLE_BAD_FUNCTION_ARGUMENT;
 #ifdef DEBUGBUILD
   if(write_len) {
     /* Allow debug builds to override this logic to force short sends

diff --git a/lib/http.c b/lib/http.c
index 8eb13788516c9c3f5abdf8b55cc1a7258c9df065..d41aefdfaa37d6850ec3530580fd33fdb17bbb8b 100644 (file)
--- a/lib/http.c
+++ b/lib/http.c
@@ -2704,8 +2704,6 @@ CURLcode Curl_http(struct Curl_easy *data, bool *done)
       if(result)
         goto fail;
       info_version = "HTTP/2";
-      /* There is no ALPN here, but the connection is now definitely h2 */
-      conn->httpversion_seen = 20;
     }
     else
       info_version = "HTTP/1.x";

diff --git a/lib/multi.c b/lib/multi.c
index 370cb97d5382f04707ff1fb05bcd4ddfd99faeda..049e71ac7ac58cc41dc8ec0c7911f74697cadac5 100644 (file)
--- a/lib/multi.c
+++ b/lib/multi.c
@@ -940,13 +940,13 @@ static CURLcode mstate_protocol_pollset(struct Curl_easy *data,
 static CURLcode mstate_do_pollset(struct Curl_easy *data,
                                   struct easy_pollset *ps)
 {
-  struct connectdata *conn = data->conn;
   if(data->conn) {
     if(data->conn->handler->doing_pollset)
       return data->conn->handler->doing_pollset(data, ps);
-    else if(conn->sockfd != CURL_SOCKET_BAD) {
+    else if(CONN_SOCK_IDX_VALID(data->conn->send_idx)) {
       /* Default is that we want to send something to the server */
-      return Curl_pollset_add_out(data, ps, conn->sockfd);
+      return Curl_pollset_add_out(
+        data, ps, data->conn->sock[data->conn->send_idx]);
     }
   }
   return CURLE_OK;
@@ -958,9 +958,10 @@ static CURLcode mstate_domore_pollset(struct Curl_easy *data,
   if(data->conn) {
     if(data->conn->handler->domore_pollset)
       return data->conn->handler->domore_pollset(data, ps);
-    else if(data->conn->sockfd != CURL_SOCKET_BAD) {
+    else if(CONN_SOCK_IDX_VALID(data->conn->send_idx)) {
       /* Default is that we want to send something to the server */
-      return Curl_pollset_add_out(data, ps, data->conn->sockfd);
+      return Curl_pollset_add_out(
+        data, ps, data->conn->sock[data->conn->send_idx]);
     }
   }
   return CURLE_OK;
@@ -976,14 +977,15 @@ static CURLcode mstate_perform_pollset(struct Curl_easy *data,
   else {
     /* Default is to obey the data->req.keepon flags for send/recv */
     CURLcode result = CURLE_OK;
-    if(CURL_WANT_RECV(data)) {
-      DEBUGASSERT(data->conn->sockfd != CURL_SOCKET_BAD);
-      result = Curl_pollset_add_in(data, ps, data->conn->sockfd);
+    if(CURL_WANT_RECV(data) && CONN_SOCK_IDX_VALID(data->conn->recv_idx)) {
+      result = Curl_pollset_add_in(
+        data, ps, data->conn->sock[data->conn->recv_idx]);
     }
 
-    if(!result && Curl_req_want_send(data)) {
-      DEBUGASSERT(data->conn->writesockfd != CURL_SOCKET_BAD);
-      result = Curl_pollset_add_out(data, ps, data->conn->writesockfd);
+    if(!result && Curl_req_want_send(data) &&
+       CONN_SOCK_IDX_VALID(data->conn->send_idx)) {
+      result = Curl_pollset_add_out(
+        data, ps, data->conn->sock[data->conn->send_idx]);
     }
     return result;
   }
@@ -2555,8 +2557,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
       /* Only perform the transfer if there is a good socket to work with.
          Having both BAD is a signal to skip immediately to DONE */
-      if((data->conn->sockfd != CURL_SOCKET_BAD) ||
-         (data->conn->writesockfd != CURL_SOCKET_BAD))
+      if(CONN_SOCK_IDX_VALID(data->conn->recv_idx) ||
+         CONN_SOCK_IDX_VALID(data->conn->send_idx))
         multistate(data, MSTATE_PERFORMING);
       else {
 #ifndef CURL_DISABLE_FTP

diff --git a/lib/transfer.c b/lib/transfer.c
index 84e4c5e9275be50d0190a71cc9fedec9b995203a..6ba5d0b30919f1d0dcae8f7daceae01c269a195e 100644 (file)
--- a/lib/transfer.c
+++ b/lib/transfer.c
@@ -162,38 +162,23 @@ bool Curl_meets_timecondition(struct Curl_easy *data, time_t timeofdoc)
 
 static CURLcode xfer_recv_shutdown(struct Curl_easy *data, bool *done)
 {
-  int sockindex;
-
   if(!data || !data->conn)
     return CURLE_FAILED_INIT;
-  if(data->conn->sockfd == CURL_SOCKET_BAD)
-    return CURLE_FAILED_INIT;
-  sockindex = (data->conn->sockfd == data->conn->sock[SECONDARYSOCKET]);
-  return Curl_conn_shutdown(data, sockindex, done);
+  return Curl_conn_shutdown(data, data->conn->recv_idx, done);
 }
 
 static bool xfer_recv_shutdown_started(struct Curl_easy *data)
 {
-  int sockindex;
-
   if(!data || !data->conn)
     return FALSE;
-  if(data->conn->sockfd == CURL_SOCKET_BAD)
-    return FALSE;
-  sockindex = (data->conn->sockfd == data->conn->sock[SECONDARYSOCKET]);
-  return Curl_shutdown_started(data, sockindex);
+  return Curl_shutdown_started(data, data->conn->recv_idx);
 }
 
 CURLcode Curl_xfer_send_shutdown(struct Curl_easy *data, bool *done)
 {
-  int sockindex;
-
   if(!data || !data->conn)
     return CURLE_FAILED_INIT;
-  if(data->conn->writesockfd == CURL_SOCKET_BAD)
-    return CURLE_FAILED_INIT;
-  sockindex = (data->conn->writesockfd == data->conn->sock[SECONDARYSOCKET]);
-  return Curl_conn_shutdown(data, sockindex, done);
+  return Curl_conn_shutdown(data, data->conn->send_idx, done);
 }
 
 /**
@@ -759,19 +744,15 @@ static void xfer_setup(
 
   if(Curl_conn_is_multiplex(conn, FIRSTSOCKET) || want_send) {
     /* when multiplexing, the read/write sockets need to be the same! */
-    conn->sockfd = sockindex == -1 ?
-      ((writesockindex == -1 ? CURL_SOCKET_BAD : conn->sock[writesockindex])) :
-      conn->sock[sockindex];
-    conn->writesockfd = conn->sockfd;
     if(want_send)
       /* special and HTTP-specific */
       writesockindex = FIRSTSOCKET;
+    conn->recv_idx = sockindex;
+    conn->send_idx = writesockindex;
   }
   else {
-    conn->sockfd = sockindex == -1 ?
-      CURL_SOCKET_BAD : conn->sock[sockindex];
-    conn->writesockfd = writesockindex == -1 ?
-      CURL_SOCKET_BAD : conn->sock[writesockindex];
+    conn->recv_idx = sockindex;
+    conn->send_idx = writesockindex;
   }
 
   k->getheader = getheader;
@@ -798,6 +779,8 @@ static void xfer_setup(
       k->keepon |= KEEP_SEND;
   } /* if(k->getheader || !data->req.no_body) */
 
+  CURL_TRC_M(data, "transfer setup: recv_idx=%d, send_idx=%d",
+             conn->recv_idx, conn->send_idx);
 }
 
 void Curl_xfer_setup_nop(struct Curl_easy *data)
@@ -886,18 +869,12 @@ CURLcode Curl_xfer_write_done(struct Curl_easy *data, bool premature)
 
 bool Curl_xfer_needs_flush(struct Curl_easy *data)
 {
-  int sockindex;
-  sockindex = ((data->conn->writesockfd != CURL_SOCKET_BAD) &&
-               (data->conn->writesockfd == data->conn->sock[SECONDARYSOCKET]));
-  return Curl_conn_needs_flush(data, sockindex);
+  return Curl_conn_needs_flush(data, data->conn->send_idx);
 }
 
 CURLcode Curl_xfer_flush(struct Curl_easy *data)
 {
-  int sockindex;
-  sockindex = ((data->conn->writesockfd != CURL_SOCKET_BAD) &&
-               (data->conn->writesockfd == data->conn->sock[SECONDARYSOCKET]));
-  return Curl_conn_flush(data, sockindex);
+  return Curl_conn_flush(data, data->conn->send_idx);
 }
 
 CURLcode Curl_xfer_send(struct Curl_easy *data,
@@ -905,14 +882,12 @@ CURLcode Curl_xfer_send(struct Curl_easy *data,
                         size_t *pnwritten)
 {
   CURLcode result;
-  int sockindex;
 
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
 
-  sockindex = ((data->conn->writesockfd != CURL_SOCKET_BAD) &&
-               (data->conn->writesockfd == data->conn->sock[SECONDARYSOCKET]));
-  result = Curl_conn_send(data, sockindex, buf, blen, eos, pnwritten);
+  result = Curl_conn_send(data, data->conn->send_idx,
+                          buf, blen, eos, pnwritten);
   if(result == CURLE_AGAIN) {
     result = CURLE_OK;
     *pnwritten = 0;
@@ -929,17 +904,13 @@ CURLcode Curl_xfer_recv(struct Curl_easy *data,
                         char *buf, size_t blen,
                         size_t *pnrcvd)
 {
-  int sockindex;
-
   DEBUGASSERT(data);
   DEBUGASSERT(data->conn);
   DEBUGASSERT(data->set.buffer_size > 0);
 
-  sockindex = ((data->conn->sockfd != CURL_SOCKET_BAD) &&
-               (data->conn->sockfd == data->conn->sock[SECONDARYSOCKET]));
   if((size_t)data->set.buffer_size < blen)
     blen = (size_t)data->set.buffer_size;
-  return Curl_conn_recv(data, sockindex, buf, blen, pnrcvd);
+  return Curl_conn_recv(data, data->conn->recv_idx, buf, blen, pnrcvd);
 }
 
 CURLcode Curl_xfer_send_close(struct Curl_easy *data)

diff --git a/lib/url.c b/lib/url.c
index 9cf920ed3a6a4030f9be9352bd5c582b50d5481c..86d744a55498b97488b781505f7e62debee00656 100644 (file)
--- a/lib/url.c
+++ b/lib/url.c
@@ -1397,8 +1397,8 @@ static struct connectdata *allocate_conn(struct Curl_easy *data)
 
   conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD;     /* no file descriptor */
   conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
-  conn->sockfd = CURL_SOCKET_BAD;
-  conn->writesockfd = CURL_SOCKET_BAD;
+  conn->recv_idx = 0; /* default for receiving transfer data */
+  conn->send_idx = 0; /* default for sending transfer data */
   conn->connection_id = -1;    /* no ID */
   conn->remote_port = -1; /* unknown at this point */
 

diff --git a/lib/urldata.h b/lib/urldata.h
index b9cc25b9b03b6fd184c1a2cf121fb27b8025241d..a35512cf7a87625254c9448145f6676c1695b105 100644 (file)
--- a/lib/urldata.h
+++ b/lib/urldata.h
@@ -672,11 +672,18 @@ struct connectdata {
   char *oauth_bearer; /* OAUTH2 bearer, allocated */
   struct curltime created; /* creation time */
   struct curltime lastused; /* when returned to the connection poolas idle */
-  curl_socket_t sock[2]; /* two sockets, the second is used for the data
-                            transfer when doing FTP */
+
+  /* A connection can have one or two sockets and connection filters.
+   * The protocol using the 2nd one is FTP for CONTROL+DATA sockets */
+  curl_socket_t sock[2];
+  struct Curl_cfilter *cfilter[2]; /* connection filters */
   Curl_recv *recv[2];
   Curl_send *send[2];
-  struct Curl_cfilter *cfilter[2]; /* connection filters */
+  int recv_idx;  /* on which socket index to receive, default 0 */
+  int send_idx;  /* on which socket index to send, default 0 */
+
+#define CONN_SOCK_IDX_VALID(i)    (((i) >= 0) && ((i) < 2))
+
   struct {
     struct curltime start[2]; /* when filter shutdown started */
     timediff_t timeout_ms; /* 0 means no timeout */
@@ -698,10 +705,6 @@ struct connectdata {
 
   /**** curl_get() phase fields */
 
-  curl_socket_t sockfd;   /* socket to read from or CURL_SOCKET_BAD */
-  curl_socket_t writesockfd; /* socket to write to, it may be the same we read
-                                from. CURL_SOCKET_BAD disables */
-
 #ifdef HAVE_GSSAPI
   BIT(sec_complete); /* if Kerberos is enabled for this connection */
   unsigned char command_prot; /* enum protection_level */

diff --git a/lib/vssh/libssh.c b/lib/vssh/libssh.c
index d6ce1a65f4aa26dee4904e65b568fa221aa8f1f0..b1d8b7c5913e1523d01c5228afb3887d1ab175c5 100644 (file)
--- a/lib/vssh/libssh.c
+++ b/lib/vssh/libssh.c
@@ -1115,8 +1115,8 @@ static int myssh_in_AUTH_DONE(struct Curl_easy *data,
   /* At this point we have an authenticated ssh session. */
   infof(data, "Authentication complete");
   Curl_pgrsTime(data, TIMER_APPCONNECT);      /* SSH is connected */
-  data->conn->sockfd = data->conn->sock[FIRSTSOCKET];
-  data->conn->writesockfd = CURL_SOCKET_BAD;
+  data->conn->recv_idx = FIRSTSOCKET;
+  data->conn->send_idx = -1;
 
   if(data->conn->handler->protocol == CURLPROTO_SFTP) {
     myssh_to(data, sshc, SSH_SFTP_INIT);
@@ -1254,7 +1254,7 @@ static int myssh_in_UPLOAD_INIT(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_SEND, -1, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->sockfd = data->conn->writesockfd;
+  data->conn->recv_idx = FIRSTSOCKET;
 
   /* store this original bitmask setup to use later on if we cannot
      figure out a "real" bitmask */
@@ -1426,7 +1426,7 @@ static int myssh_in_SFTP_DOWNLOAD_STAT(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_RECV, data->req.size, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->writesockfd = data->conn->sockfd;
+  data->conn->send_idx = 0;
 
   sshc->sftp_recv_state = 0;
   myssh_to(data, sshc, SSH_STOP);
@@ -2243,7 +2243,7 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data,
       Curl_xfer_setup1(data, CURL_XFER_SEND, -1, FALSE);
 
       /* not set by Curl_xfer_setup to preserve keepon bits */
-      conn->sockfd = conn->writesockfd;
+      data->conn->recv_idx = FIRSTSOCKET;
 
       /* store this original bitmask setup to use later on if we cannot
          figure out a "real" bitmask */
@@ -2282,7 +2282,7 @@ static CURLcode myssh_statemach_act(struct Curl_easy *data,
         Curl_xfer_setup1(data, CURL_XFER_RECV, bytecount, FALSE);
 
         /* not set by Curl_xfer_setup to preserve keepon bits */
-        conn->writesockfd = conn->sockfd;
+        conn->send_idx = 0;
 
         myssh_to(data, sshc, SSH_STOP);
         break;

diff --git a/lib/vssh/libssh2.c b/lib/vssh/libssh2.c
index bac362dd5c0a5e9876c2ec486307594ecf5e42f1..b31e3ab6d3e65e6f63aa0b9e5d3f008c782a6115 100644 (file)
--- a/lib/vssh/libssh2.c
+++ b/lib/vssh/libssh2.c
@@ -1202,7 +1202,7 @@ sftp_upload_init(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_SEND, -1, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->sockfd = data->conn->writesockfd;
+  data->conn->recv_idx = FIRSTSOCKET;
 
   /* store this original bitmask setup to use later on if we cannot
      figure out a "real" bitmask */
@@ -1543,7 +1543,7 @@ sftp_download_stat(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_RECV, data->req.size, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->writesockfd = data->conn->sockfd;
+  data->conn->send_idx = 0;
 
   myssh_state(data, sshc, SSH_STOP);
 
@@ -1945,8 +1945,8 @@ static CURLcode ssh_state_auth_done(struct Curl_easy *data,
 
   Curl_pgrsTime(data, TIMER_APPCONNECT); /* SSH is connected */
 
-  conn->sockfd = conn->sock[FIRSTSOCKET];
-  conn->writesockfd = CURL_SOCKET_BAD;
+  data->conn->recv_idx = FIRSTSOCKET;
+  conn->send_idx = -1;
 
   if(conn->handler->protocol == CURLPROTO_SFTP) {
     myssh_state(data, sshc, SSH_SFTP_INIT);
@@ -2463,7 +2463,7 @@ static CURLcode ssh_state_scp_download_init(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_RECV, bytecount, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->writesockfd = data->conn->sockfd;
+  data->conn->send_idx = 0;
 
   myssh_state(data, sshc, SSH_STOP);
   return CURLE_OK;
@@ -2612,7 +2612,7 @@ static CURLcode ssh_state_scp_upload_init(struct Curl_easy *data,
   Curl_xfer_setup1(data, CURL_XFER_SEND, -1, FALSE);
 
   /* not set by Curl_xfer_setup to preserve keepon bits */
-  data->conn->sockfd = data->conn->writesockfd;
+  data->conn->recv_idx = FIRSTSOCKET;
 
   /* store this original bitmask setup to use later on if we cannot
      figure out a "real" bitmask */

diff --git a/lib/vssh/wolfssh.c b/lib/vssh/wolfssh.c
index 15f504a01c5b9f59280d18cf98ac82e7916d01cf..5b198d7568981fd31cf74d3b194f85151820e8ef 100644 (file)
--- a/lib/vssh/wolfssh.c
+++ b/lib/vssh/wolfssh.c
@@ -720,7 +720,7 @@ static CURLcode wssh_statemach_act(struct Curl_easy *data,
       Curl_xfer_setup1(data, CURL_XFER_SEND, -1, FALSE);
 
       /* not set by Curl_xfer_setup to preserve keepon bits */
-      conn->sockfd = conn->writesockfd;
+      data->conn->recv_idx = FIRSTSOCKET;
 
       if(result) {
         wssh_state(data, sshc, SSH_SFTP_CLOSE);
@@ -819,7 +819,7 @@ static CURLcode wssh_statemach_act(struct Curl_easy *data,
       Curl_xfer_setup1(data, CURL_XFER_RECV, data->req.size, FALSE);
 
       /* not set by Curl_xfer_setup to preserve keepon bits */
-      conn->writesockfd = conn->sockfd;
+      conn->send_idx = 0;
 
       if(result) {
         /* this should never occur; the close state should be entered