Internal cleanup: KEEP_WRITE and KEEP_READ are now called KEEP_SEND and

KEEP_RECV to better match the general terminology: receive and send is what we
do from the (remote) servers. We read and write from and to the local fs.

diff --git a/lib/easy.c b/lib/easy.c
index 9fa55f3c410e24958fc463f33292c17f52994690..e85bee58c9fe14d03aef51daf158c1e947eb6bc6 100644 (file)
--- a/lib/easy.c
+++ b/lib/easy.c
@@ -766,17 +766,17 @@ CURLcode curl_easy_pause(CURL *curl, int action)
   CURLcode result = CURLE_OK;
 
   /* first switch off both pause bits */
-  int newstate = k->keepon &~ (KEEP_READ_PAUSE| KEEP_WRITE_PAUSE);
+  int newstate = k->keepon &~ (KEEP_RECV_PAUSE| KEEP_SEND_PAUSE);
 
   /* set the new desired pause bits */
-  newstate |= ((action & CURLPAUSE_RECV)?KEEP_READ_PAUSE:0) |
-    ((action & CURLPAUSE_SEND)?KEEP_WRITE_PAUSE:0);
+  newstate |= ((action & CURLPAUSE_RECV)?KEEP_RECV_PAUSE:0) |
+    ((action & CURLPAUSE_SEND)?KEEP_SEND_PAUSE:0);
 
   /* put it back in the keepon */
   k->keepon = newstate;
 
-  if(!(newstate & KEEP_READ_PAUSE) && data->state.tempwrite) {
-    /* we have a buffer for writing that we now seem to be able to deliver since
+  if(!(newstate & KEEP_RECV_PAUSE) && data->state.tempwrite) {
+    /* we have a buffer for sending that we now seem to be able to deliver since
        the receive pausing is lifted! */
 
     /* get the pointer, type and length in local copies since the function may

diff --git a/lib/multi.c b/lib/multi.c
index c5712f619df41c0b98fa772c9b859a6849e33575..75dd0277d1155cd589995a32c5197cd15f1da691 100644 (file)
--- a/lib/multi.c
+++ b/lib/multi.c
@@ -1299,13 +1299,13 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
 
       k = &easy->easy_handle->req;
 
-      if(!(k->keepon & KEEP_READ)) {
-        /* We're done reading */
+      if(!(k->keepon & KEEP_RECV)) {
+        /* We're done receiving */
         easy->easy_conn->readchannel_inuse = FALSE;
       }
 
-      if(!(k->keepon & KEEP_WRITE)) {
-        /* We're done writing */
+      if(!(k->keepon & KEEP_SEND)) {
+        /* We're done sending */
         easy->easy_conn->writechannel_inuse = FALSE;
       }
 

diff --git a/lib/sendf.c b/lib/sendf.c
index 0db35783e880f227741dad11a911e792ae3297b3..0f8ccd33bf9b65ca41b33889deebefd2bb0261bc 100644 (file)
--- a/lib/sendf.c
+++ b/lib/sendf.c
@@ -341,7 +341,7 @@ static CURLcode pausewrite(struct SessionHandle *data,
   data->state.tempwritetype = type;
 
   /* mark the connection as RECV paused */
-  k->keepon |= KEEP_READ_PAUSE;
+  k->keepon |= KEEP_RECV_PAUSE;
 
   DEBUGF(infof(data, "Pausing with %d bytes in buffer for type %02x\n",
                (int)len, type));
@@ -373,7 +373,7 @@ CURLcode Curl_client_write(struct connectdata *conn,
   /* If reading is actually paused, we're forced to append this chunk of data
      to the already held data, but only if it is the same type as otherwise it
      can't work and it'll return error instead. */
-  if(data->req.keepon & KEEP_READ_PAUSE) {
+  if(data->req.keepon & KEEP_RECV_PAUSE) {
     size_t newlen;
     char *newptr;
     if(type != data->state.tempwritetype)

diff --git a/lib/ssh.c b/lib/ssh.c
index d473d14004879769c15820f4a00f61dd4b1cffa5..961d4913977633e27ee614a32b5fd04121cb07a9 100644 (file)
--- a/lib/ssh.c
+++ b/lib/ssh.c
@@ -2102,10 +2102,10 @@ static int ssh_perform_getsock(const struct connectdata *conn,
 
   sock[0] = conn->sock[FIRSTSOCKET];
 
-  if(conn->proto.sshc.waitfor & KEEP_READ)
+  if(conn->proto.sshc.waitfor & KEEP_RECV)
     bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
 
-  if(conn->proto.sshc.waitfor & KEEP_WRITE)
+  if(conn->proto.sshc.waitfor & KEEP_SEND)
     bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
 
   return bitmap;
@@ -2151,8 +2151,8 @@ static void ssh_block2waitfor(struct connectdata *conn, bool block)
   int dir;
   if(block && (dir = libssh2_session_block_directions(sshc->ssh_session))) {
     /* translate the libssh2 define bits into our own bit defines */
-    sshc->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND)?KEEP_READ:0) |
-      ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?KEEP_WRITE:0);
+    sshc->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND)?KEEP_RECV:0) |
+      ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?KEEP_SEND:0);
   }
   else
     /* It didn't block or libssh2 didn't reveal in which direction, put back

diff --git a/lib/transfer.c b/lib/transfer.c
index a513a6d9ba4a768cb9cc98e8220084fb8812fd1d..5b48d9e5e363fbe111d9cf15bf4833b232139753 100644 (file)
--- a/lib/transfer.c
+++ b/lib/transfer.c
@@ -157,7 +157,7 @@ CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp)
   else if(nread == CURL_READFUNC_PAUSE) {
     struct SingleRequest *k = &data->req;
     /* CURL_READFUNC_PAUSE pauses read callbacks that feed socket writes */
-    k->keepon |= KEEP_WRITE_PAUSE; /* mark socket send as paused */
+    k->keepon |= KEEP_SEND_PAUSE; /* mark socket send as paused */
     if(data->req.upload_chunky) {
       /* Back out the preallocation done above */
       data->req.upload_fromhere -= (8 + 2);
@@ -320,7 +320,7 @@ CURLcode Curl_readrewind(struct connectdata *conn)
      about to restart a new transfer and thus we want to avoid inadvertently
      sending more data on the existing connection until the next transfer
      starts */
-  data->req.keepon &= ~KEEP_WRITE;
+  data->req.keepon &= ~KEEP_SEND;
 
   /* We have sent away data. If not using CURLOPT_POSTFIELDS or
      CURLOPT_HTTPPOST, call app to rewind
@@ -465,7 +465,7 @@ static CURLcode readwrite_data(struct SessionHandle *data,
         k->start100 = Curl_tvnow();
     }
 
-    *didwhat |= KEEP_READ;
+    *didwhat |= KEEP_RECV;
     /* indicates data of zero size, i.e. empty file */
     is_empty_data = (bool)((nread == 0) && (k->bodywrites == 0));
 
@@ -477,7 +477,7 @@ static CURLcode readwrite_data(struct SessionHandle *data,
       /* if we receive 0 or less here, the server closed the connection
          and we bail out from this! */
       DEBUGF(infof(data, "nread <= 0, server closed connection, bailing\n"));
-      k->keepon &= ~KEEP_READ;
+      k->keepon &= ~KEEP_RECV;
       break;
     }
 
@@ -517,7 +517,7 @@ static CURLcode readwrite_data(struct SessionHandle *data,
             if(conn->bits.close) {
               /* Abort after the headers if "follow Location" is set
                  and we're set to close anyway. */
-              k->keepon &= ~KEEP_READ;
+              k->keepon &= ~KEEP_RECV;
               *done = TRUE;
               return CURLE_OK;
             }
@@ -610,7 +610,7 @@ static CURLcode readwrite_data(struct SessionHandle *data,
         else if(CHUNKE_STOP == res) {
           size_t dataleft;
           /* we're done reading chunks! */
-          k->keepon &= ~KEEP_READ; /* read no more */
+          k->keepon &= ~KEEP_RECV; /* read no more */
 
           /* There are now possibly N number of bytes at the end of the
              str buffer that weren't written to the client.
@@ -649,7 +649,7 @@ static CURLcode readwrite_data(struct SessionHandle *data,
         if(nread < 0 ) /* this should be unusual */
           nread = 0;
 
-        k->keepon &= ~KEEP_READ; /* we're done reading */
+        k->keepon &= ~KEEP_RECV; /* we're done reading */
       }
 
       k->bytecount += nread;
@@ -721,18 +721,18 @@ static CURLcode readwrite_data(struct SessionHandle *data,
     if(is_empty_data) {
       /* if we received nothing, the server closed the connection and we
          are done */
-      k->keepon &= ~KEEP_READ;
+      k->keepon &= ~KEEP_RECV;
     }
 
   } while(data_pending(conn));
 
-  if(((k->keepon & (KEEP_READ|KEEP_WRITE)) == KEEP_WRITE) &&
+  if(((k->keepon & (KEEP_RECV|KEEP_SEND)) == KEEP_SEND) &&
      conn->bits.close ) {
     /* When we've read the entire thing and the close bit is set, the server
        may now close the connection. If there's now any kind of sending going
        on from our side, we need to stop that immediately. */
     infof(data, "we are done reading and this is set to close, stop send\n");
-    k->keepon &= ~KEEP_WRITE; /* no writing anymore either */
+    k->keepon &= ~KEEP_SEND; /* no writing anymore either */
   }
 
   return CURLE_OK;
@@ -895,7 +895,7 @@ static CURLcode readwrite_http_headers(struct SessionHandle *data,
         /* if we did wait for this do enable write now! */
         if(k->exp100) {
           k->exp100 = EXP100_SEND_DATA;
-          k->keepon |= KEEP_WRITE;
+          k->keepon |= KEEP_SEND;
         }
       }
       else {
@@ -922,7 +922,7 @@ static CURLcode readwrite_http_headers(struct SessionHandle *data,
          * (or prevent them from starting).
          */
         k->exp100 = EXP100_FAILED;
-        k->keepon &= ~KEEP_WRITE;
+        k->keepon &= ~KEEP_SEND;
       }
 
       /*
@@ -975,7 +975,7 @@ static CURLcode readwrite_http_headers(struct SessionHandle *data,
           /* We rewind after a complete send, so thus we continue
              sending now */
           infof(data, "Keep sending data to get tossed away!\n");
-          k->keepon |= KEEP_WRITE;
+          k->keepon |= KEEP_SEND;
         }
       }
 
@@ -1021,7 +1021,7 @@ static CURLcode readwrite_http_headers(struct SessionHandle *data,
 
         if(*stop_reading) {
           /* we make sure that this socket isn't read more now */
-          k->keepon &= ~KEEP_READ;
+          k->keepon &= ~KEEP_RECV;
         }
 
         if(data->set.verbose)
@@ -1463,7 +1463,7 @@ static CURLcode readwrite_upload(struct SessionHandle *data,
   if((k->bytecount == 0) && (k->writebytecount == 0))
     Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 
-  *didwhat |= KEEP_WRITE;
+  *didwhat |= KEEP_SEND;
 
   /*
    * We loop here to do the READ and SEND loop until we run out of
@@ -1488,9 +1488,9 @@ static CURLcode readwrite_upload(struct SessionHandle *data,
              We have sent off the full HTTP 1.1 request, and we shall now
              go into the Expect: 100 state and await such a header */
           k->exp100 = EXP100_AWAITING_CONTINUE; /* wait for the header */
-          k->keepon &= ~KEEP_WRITE;         /* disable writing */
+          k->keepon &= ~KEEP_SEND;         /* disable writing */
           k->start100 = Curl_tvnow();       /* timeout count starts now */
-          *didwhat &= ~KEEP_WRITE;  /* we didn't write anything actually */
+          *didwhat &= ~KEEP_SEND;  /* we didn't write anything actually */
           break;
         }
 
@@ -1512,13 +1512,13 @@ static CURLcode readwrite_upload(struct SessionHandle *data,
       else
         nread = 0; /* we're done uploading/reading */
 
-      if(!nread && (k->keepon & KEEP_WRITE_PAUSE)) {
+      if(!nread && (k->keepon & KEEP_SEND_PAUSE)) {
         /* this is a paused transfer */
         break;
       }
       else if(nread<=0) {
         /* done */
-        k->keepon &= ~KEEP_WRITE; /* we're done writing */
+        k->keepon &= ~KEEP_SEND; /* we're done writing */
 
         if(conn->bits.rewindaftersend) {
           result = Curl_readrewind(conn);
@@ -1614,7 +1614,7 @@ static CURLcode readwrite_upload(struct SessionHandle *data,
 
       if(k->upload_done) {
         /* switch off writing, we're done! */
-        k->keepon &= ~KEEP_WRITE; /* we're done writing */
+        k->keepon &= ~KEEP_SEND; /* we're done writing */
       }
     }
 
@@ -1647,7 +1647,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
   /* only use the proper socket if the *_HOLD bit is not set simultaneously as
      then we are in rate limiting state in that transfer direction */
 
-  if((k->keepon & KEEP_READBITS) == KEEP_READ) {
+  if((k->keepon & KEEP_RECVBITS) == KEEP_RECV) {
     fd_read = conn->sockfd;
 #if defined(USE_LIBSSH2)
     if(conn->protocol & (PROT_SCP|PROT_SFTP))
@@ -1656,7 +1656,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
   } else
     fd_read = CURL_SOCKET_BAD;
 
-  if((k->keepon & KEEP_WRITEBITS) == KEEP_WRITE)
+  if((k->keepon & KEEP_SENDBITS) == KEEP_SEND)
     fd_write = conn->writesockfd;
   else
     fd_write = CURL_SOCKET_BAD;
@@ -1674,7 +1674,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
   /* We go ahead and do a read if we have a readable socket or if
      the stream was rewound (in which case we have data in a
      buffer) */
-  if((k->keepon & KEEP_READ) &&
+  if((k->keepon & KEEP_RECV) &&
      ((select_res & CURL_CSELECT_IN) || conn->bits.stream_was_rewound)) {
 
     result = readwrite_data(data, conn, k, &didwhat, done);
@@ -1683,7 +1683,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
   }
 
   /* If we still have writing to do, we check if we have a writable socket. */
-  if((k->keepon & KEEP_WRITE) && (select_res & CURL_CSELECT_OUT)) {
+  if((k->keepon & KEEP_SEND) && (select_res & CURL_CSELECT_OUT)) {
     /* write */
 
     result = readwrite_upload(data, conn, k, &didwhat);
@@ -1719,7 +1719,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
       if(ms > CURL_TIMEOUT_EXPECT_100) {
         /* we've waited long enough, continue anyway */
         k->exp100 = EXP100_SEND_DATA;
-        k->keepon |= KEEP_WRITE;
+        k->keepon |= KEEP_SEND;
         infof(data, "Done waiting for 100-continue\n");
       }
     }
@@ -1787,8 +1787,8 @@ CURLcode Curl_readwrite(struct connectdata *conn,
   }
 
   /* Now update the "done" boolean we return */
-  *done = (bool)(0 == (k->keepon&(KEEP_READ|KEEP_WRITE|
-                                  KEEP_READ_PAUSE|KEEP_WRITE_PAUSE)));
+  *done = (bool)(0 == (k->keepon&(KEEP_RECV|KEEP_SEND|
+                                  KEEP_RECV_PAUSE|KEEP_SEND_PAUSE)));
 
   return CURLE_OK;
 }
@@ -1817,7 +1817,7 @@ int Curl_single_getsock(const struct connectdata *conn,
     return GETSOCK_BLANK;
 
   /* don't include HOLD and PAUSE connections */
-  if((data->req.keepon & KEEP_READBITS) == KEEP_READ) {
+  if((data->req.keepon & KEEP_RECVBITS) == KEEP_RECV) {
 
     DEBUGASSERT(conn->sockfd != CURL_SOCKET_BAD);
 
@@ -1826,13 +1826,13 @@ int Curl_single_getsock(const struct connectdata *conn,
   }
 
   /* don't include HOLD and PAUSE connections */
-  if((data->req.keepon & KEEP_WRITEBITS) == KEEP_WRITE) {
+  if((data->req.keepon & KEEP_SENDBITS) == KEEP_SEND) {
 
     if((conn->sockfd != conn->writesockfd) ||
-       !(data->req.keepon & KEEP_READ)) {
+       !(data->req.keepon & KEEP_RECV)) {
       /* only if they are not the same socket or we didn't have a readable
          one, we increase index */
-      if(data->req.keepon & KEEP_READ)
+      if(data->req.keepon & KEEP_RECV)
         sockindex++; /* increase index if we need two entries */
 
       DEBUGASSERT(conn->writesockfd != CURL_SOCKET_BAD);
@@ -1887,34 +1887,34 @@ Transfer(struct connectdata *conn)
     /* limit-rate logic: if speed exceeds threshold, then do not include fd in
        select set. The current speed is recalculated in each Curl_readwrite()
        call */
-    if((k->keepon & KEEP_WRITE) &&
+    if((k->keepon & KEEP_SEND) &&
         (!data->set.max_send_speed ||
          (data->progress.ulspeed < data->set.max_send_speed) )) {
       fd_write = conn->writesockfd;
-      k->keepon &= ~KEEP_WRITE_HOLD;
+      k->keepon &= ~KEEP_SEND_HOLD;
     }
     else {
       fd_write = CURL_SOCKET_BAD;
-      if(k->keepon & KEEP_WRITE)
-        k->keepon |= KEEP_WRITE_HOLD; /* hold it */
+      if(k->keepon & KEEP_SEND)
+        k->keepon |= KEEP_SEND_HOLD; /* hold it */
     }
 
-    if((k->keepon & KEEP_READ) &&
+    if((k->keepon & KEEP_RECV) &&
         (!data->set.max_recv_speed ||
          (data->progress.dlspeed < data->set.max_recv_speed)) ) {
       fd_read = conn->sockfd;
-      k->keepon &= ~KEEP_READ_HOLD;
+      k->keepon &= ~KEEP_RECV_HOLD;
     }
     else {
       fd_read = CURL_SOCKET_BAD;
-      if(k->keepon & KEEP_READ)
-        k->keepon |= KEEP_READ_HOLD; /* hold it */
+      if(k->keepon & KEEP_RECV)
+        k->keepon |= KEEP_RECV_HOLD; /* hold it */
     }
 
     /* pause logic. Don't check descriptors for paused connections */
-    if(k->keepon & KEEP_READ_PAUSE)
+    if(k->keepon & KEEP_RECV_PAUSE)
       fd_read = CURL_SOCKET_BAD;
-    if(k->keepon & KEEP_WRITE_PAUSE)
+    if(k->keepon & KEEP_SEND_PAUSE)
       fd_write = CURL_SOCKET_BAD;
 
     /* The *_HOLD and *_PAUSE logic is necessary since even though there might
@@ -2730,7 +2730,7 @@ Curl_setup_transfer(
   if(k->getheader || !data->set.opt_no_body) {
 
     if(conn->sockfd != CURL_SOCKET_BAD) {
-      k->keepon |= KEEP_READ;
+      k->keepon |= KEEP_RECV;
     }
 
     if(conn->writesockfd != CURL_SOCKET_BAD) {
@@ -2756,7 +2756,7 @@ Curl_setup_transfer(
           k->exp100 = EXP100_SENDING_REQUEST;
 
         /* enable the write bit when we're not waiting for continue */
-        k->keepon |= KEEP_WRITE;
+        k->keepon |= KEEP_SEND;
       }
     } /* if(conn->writesockfd != CURL_SOCKET_BAD) */
   } /* if(k->getheader || !data->set.opt_no_body) */

diff --git a/lib/urldata.h b/lib/urldata.h
index dc4f57420b3e9644cd586acfdf17faee3d398946..e686b18ff70ab0587f864864d7ef6b904d120ccc 100644 (file)
--- a/lib/urldata.h
+++ b/lib/urldata.h
@@ -653,17 +653,17 @@ struct hostname {
  */
 
 #define KEEP_NONE  0
-#define KEEP_READ  (1<<0)     /* there is or may be data to read */
-#define KEEP_WRITE (1<<1)     /* there is or may be data to write */
-#define KEEP_READ_HOLD (1<<2) /* when set, no reading should be done but there
+#define KEEP_RECV  (1<<0)     /* there is or may be data to read */
+#define KEEP_SEND (1<<1)     /* there is or may be data to write */
+#define KEEP_RECV_HOLD (1<<2) /* when set, no reading should be done but there
                                  might still be data to read */
-#define KEEP_WRITE_HOLD (1<<3) /* when set, no writing should be done but there
+#define KEEP_SEND_HOLD (1<<3) /* when set, no writing should be done but there
                                   might still be data to write */
-#define KEEP_READ_PAUSE (1<<4) /* reading is paused */
-#define KEEP_WRITE_PAUSE (1<<5) /* writing is paused */
+#define KEEP_RECV_PAUSE (1<<4) /* reading is paused */
+#define KEEP_SEND_PAUSE (1<<5) /* writing is paused */
 
-#define KEEP_READBITS (KEEP_READ | KEEP_READ_HOLD | KEEP_READ_PAUSE)
-#define KEEP_WRITEBITS (KEEP_WRITE | KEEP_WRITE_HOLD | KEEP_WRITE_PAUSE)
+#define KEEP_RECVBITS (KEEP_RECV | KEEP_RECV_HOLD | KEEP_RECV_PAUSE)
+#define KEEP_SENDBITS (KEEP_SEND | KEEP_SEND_HOLD | KEEP_SEND_PAUSE)
 
 
 #ifdef HAVE_LIBZ