SMTP Async I/O:

[citadel.git] / citadel / clientsocket.c

diff --git a/citadel/clientsocket.c b/citadel/clientsocket.c
index 385f25e941381da91d8285cc4239aa5226afd278..572f28f17c1293d324b732e51b11261fbda33a28 100644 (file)
--- a/citadel/clientsocket.c
+++ b/citadel/clientsocket.c
@@ -1,6 +1,4 @@
 /*
- * $Id$
- *
  * This module handles client-side sockets opened by the Citadel server (for
  * the client side of Internet protocols, etc.)   It does _not_ handle client
  * sockets for the Citadel client; for that you must look in ipc_c_tcp.c
@@ -180,6 +178,7 @@ int sock_read_to(int *sock, char *buf, int bytes, int timeout, int keep_reading_
        CitContext *CCC=CC;
        int rc;
 
+       FlushStrBuf(CCC->MigrateBuf);
        rc = socket_read_blob(sock, 
                              CCC->sMigrateBuf, 
                              bytes, 
@@ -203,19 +202,17 @@ int sock_read_to(int *sock, char *buf, int bytes, int timeout, int keep_reading_
 }
 
 
-int CtdlSockGetLine(int *sock, StrBuf *Target)
+int CtdlSockGetLine(int *sock, StrBuf * Target, int nSec)
 {
        CitContext *CCC=CC;
        const char *Error;
        int rc;
 
+       FlushStrBuf(Target);
        rc = StrBufTCP_read_buffered_line_fast(Target, 
                                               CCC->sReadBuf,
                                               &CCC->sPos,
-                                              sock,
-                                              5,
-                                              1,
-                                              &Error);
+                                              sock, nSec, 1, &Error);
        if ((rc < 0) && (Error != NULL))
                CtdlLogPrintf(CTDL_CRIT, 
                              "%s failed: %s\n",
@@ -236,27 +233,20 @@ int sock_getln(int *sock, char *buf, int bufsize)
        CitContext *CCC=CC;
        const char *pCh;
 
-       retval = CtdlSockGetLine(sock, CCC->sMigrateBuf);
+       FlushStrBuf(CCC->sMigrateBuf);
+       retval = CtdlSockGetLine(sock, CCC->sMigrateBuf, 5);
 
        i = StrLength(CCC->sMigrateBuf);
        pCh = ChrPtr(CCC->sMigrateBuf);
-       /* Strip the trailing LF, and the trailing CR if present.
-        */
-       if (bufsize <= i)
-               i = bufsize - 1;
-       while ( (i > 0)
-               && ( (pCh[i - 1]==13)
-                    || ( pCh[i - 1]==10)) ) {
-               i--;
-       }
-       memcpy(buf, pCh, i);
-       buf[i] = 0;
+
+       memcpy(buf, pCh, i + 1);
 
        FlushStrBuf(CCC->sMigrateBuf);
        if (retval < 0) {
                safestrncpy(&buf[i], "000", bufsize - i);
+               i += 3;
        }
-       return(retval >= 0);
+       return i;
 }
 
 
@@ -274,14 +264,43 @@ INLINE int sock_read(int *sock, char *buf, int bytes, int keep_reading_until_ful
  * sock_write() - send binary to server.
  * Returns the number of bytes written, or -1 for error.
  */
-int sock_write(int *sock, const char *buf, int nbytes)
+int sock_write(int *sock, const char *buf, int nbytes) 
+{ return sock_write_timeout(sock, buf, nbytes, 50); }
+int sock_write_timeout(int *sock, const char *buf, int nbytes, int timeout)
 {
+       int nSuccessLess = 0;
        int bytes_written = 0;
        int retval;
-
-       while ((*sock != -1)  && 
-              (bytes_written < nbytes))
+       fd_set rfds;
+        int fdflags;
+       int IsNonBlock;
+       struct timeval tv;
+       int selectresolution = 100;
+
+       fdflags = fcntl(*sock, F_GETFL);
+       IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
+
+       while ((nSuccessLess < timeout) && 
+              (*sock != -1) && 
+              (bytes_written < nbytes)) 
        {
+               if (IsNonBlock){
+                       tv.tv_sec = selectresolution;
+                       tv.tv_usec = 0;
+                       
+                       FD_ZERO(&rfds);
+                       FD_SET(*sock, &rfds);
+                       if (select(*sock + 1, NULL, &rfds, NULL, &tv) == -1) {
+///                            *Error = strerror(errno);
+                               close (*sock);
+                               *sock = -1;
+                               return -1;
+                       }
+               }
+               if (IsNonBlock && !  FD_ISSET(*sock, &rfds)) {
+                       nSuccessLess ++;
+                       continue;
+               }
                retval = write(*sock, &buf[bytes_written],
                               nbytes - bytes_written);
                if (retval < 1) {
@@ -290,28 +309,79 @@ int sock_write(int *sock, const char *buf, int nbytes)
                        return (-1);
                }
                bytes_written = bytes_written + retval;
+               if (IsNonBlock && (bytes_written == nbytes)){
+                       tv.tv_sec = selectresolution;
+                       tv.tv_usec = 0;
+                       
+                       FD_ZERO(&rfds);
+                       FD_SET(*sock, &rfds);
+                       if (select(*sock + 1, NULL, &rfds, NULL, &tv) == -1) {
+///                            *Error = strerror(errno);
+                               close (*sock);
+                               *sock = -1;
+                               return -1;
+                       }
+               }
        }
        return (bytes_written);
 }
 
 
+
+/*
+ * client_getln()   ...   Get a LF-terminated line of text from the client.
+ * (This is implemented in terms of client_read() and could be
+ * justifiably moved out of sysdep.c)
+ */
+int sock_getln_err(int *sock, char *buf, int bufsize, int *rc, int nSec)
+{
+       int i, retval;
+       CitContext *CCC = MyContext();
+       const char *pCh;
+
+       FlushStrBuf(CCC->sMigrateBuf);
+       *rc = retval = CtdlSockGetLine(sock, CCC->sMigrateBuf, nSec);
+
+       i = StrLength(CCC->sMigrateBuf);
+       pCh = ChrPtr(CCC->sMigrateBuf);
+
+       memcpy(buf, pCh, i + 1);
+
+       FlushStrBuf(CCC->sMigrateBuf);
+       if (retval < 0) {
+               safestrncpy(&buf[i], "000", bufsize - i);
+               i += 3;
+       }
+       return i;
+}
+
 /*
  * Multiline version of sock_gets() ... this is a convenience function for
  * client side protocol implementations.  It only returns the first line of
  * a multiline response, discarding the rest.
  */
-int ml_sock_gets(int *sock, char *buf) {
+
+int ml_sock_gets(int *sock, char *buf, int nSec)
+{
+       int rc = 0;
        char bigbuf[1024];
        int g;
 
-       g = sock_getln(sock, buf, SIZ);
-       if (g < 4) return(g);
-       if (buf[3] != '-') return(g);
+       g = sock_getln_err(sock, buf, SIZ, &rc, nSec);
+       if (rc < 0)
+               return rc;
+       if (g < 4)
+               return (g);
+       if (buf[3] != '-')
+               return (g);
 
        do {
-               g = sock_getln(sock, bigbuf, SIZ);
-               if (g < 0) return(g);
-       } while ( (g >= 4) && (bigbuf[3] == '-') );
+               g = sock_getln_err(sock, bigbuf, SIZ, &rc, nSec);
+               if (rc < 0)
+                       return rc;
+               if (g < 0)
+                       return (g);
+       } while ((g >= 4) && (bigbuf[3] == '-'));
 
        return(strlen(buf));
 }