Changeset 2050

Timestamp:

05/26/07 16:03:07

Author:

pvanhoof

Message:

Experimental connection recovery

Files:

• trunk/ChangeLog (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/camel-file-utils.c (modified) (3 diffs)
• trunk/libtinymail-camel/camel-lite/camel/camel-file-utils.h (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/camel-stream-buffer.c (modified) (2 diffs)
• trunk/libtinymail-camel/camel-lite/camel/camel-stream-buffer.h (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/camel-stream.c (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/camel-stream.h (modified) (2 diffs)
• trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream-raw.c (modified) (3 diffs)
• trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c (modified) (3 diffs)
• trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream.c (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream.h (modified) (1 diff)
• trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-command.c (modified) (4 diffs)
• trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-folder.c (modified) (2 diffs)
• trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c (modified) (3 diffs)
• trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.h (modified) (1 diff)

trunk/ChangeLog

@@ +1 @@
+2007-05-26  Philip Van Hoof  <pvanhoof@gnome.org>
+
+        * Experimental connection recovery for IMAP
+        * Letting IDLE support cope with connection failures
+
-2007-05-25  Philip Van Hoof  <pvanhoof@gnome.org>
-

trunk/libtinymail-camel/camel-lite/camel/camel-file-utils.c

@@ -501 +501 @@
-                fdmax = fd + 1;
-                tv.tv_sec = 0;
+                tv.tv_usec = 0;
+                nread = -1;
+
+                res = select(fdmax, &rdset, 0, 0, &tv);
+                if (res == -1)
+                        ;
+                else if (res == 0)
+                        errno = ETIMEDOUT;
+                else {
+                        do {
+                                nread = read (fd, buf, n);
+                        } while (0 && (nread == -1 && errno == EINTR));
+                }
+        } while (0 && (nread == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)));
+
+        errnosav = errno;
+        fcntl (fd, F_SETFL, flags);
+        errno = errnosav;
+
+        return nread;
+}
+
+
+
+ssize_t
+camel_read_idle (int fd, char *buf, size_t n)
+{
+        ssize_t nread;
+
+        int errnosav, flags, fdmax;
+        fd_set rdset;
+        
+        flags = fcntl (fd, F_GETFL);
+        fcntl (fd, F_SETFL, flags | O_NONBLOCK);
+        
+        do {
+                struct timeval tv;
+                int res;
+
+                FD_ZERO (&rdset);
+                FD_SET (fd, &rdset);
+                fdmax = fd + 1;
+                tv.tv_sec = 5;
-                tv.tv_usec = 0;
-                nread = -1;
@@ -685 +728 @@
-}
-
+
+ssize_t
+camel_read_socket_idle (int fd, char *buf, size_t n)
+{
+#ifndef G_OS_WIN32
+        return camel_read_idle (fd, buf, n);
+#else
+        ssize_t nread;
+        int cancel_fd;
+        
+        if (camel_operation_cancel_check (NULL)) {
+                errno = EINTR;
+                return -1;
+        }
+        cancel_fd = camel_operation_cancel_fd (NULL);
+
+        if (cancel_fd == -1) {
+                do {
+                        nread = recv (fd, buf, n, 0);
+                } while ((nread == SOCKET_ERROR && WSAGetLastError () == WSAEWOULDBLOCK));
+        } else {
+                int fdmax;
+                fd_set rdset;
+                u_long yes = 1;
+
+                ioctlsocket (fd, FIONBIO, &yes);
+                fdmax = MAX (fd, cancel_fd) + 1;
+                do {
+                        struct timeval tv;
+                        int res;
+
+                        FD_ZERO (&rdset);
+                        FD_SET (fd, &rdset);
+                        FD_SET (cancel_fd, &rdset);
+                        tv.tv_sec = 1;
+                        tv.tv_usec = 0;
+                        nread = -1;
+
+                        res = select(fdmax, &rdset, 0, 0, &tv);
+                        if (res == -1)
+                                ;
+                        else if (res == 0)
+                                errno = ETIMEDOUT;
+                        else if (FD_ISSET (cancel_fd, &rdset)) {
+                                errno = EINTR;
+                                goto failed;
+                        } else {                                
+                                nread = recv (fd, buf, n, 0);
+                        }
+                } while ((nread == -1 && WSAGetLastError () == WSAEWOULDBLOCK));
+        failed:
+                ;
+        }
+        
+        return nread;
+#endif
+}
-ssize_t
-camel_read_socket_nb (int fd, char *buf, size_t n)
@@ -741 +841 @@
-#endif
-}
+
+
-
-/**

trunk/libtinymail-camel/camel-lite/camel/camel-file-utils.h

@@ -74 +74 @@
-ssize_t camel_write (int fd, const char *buf, size_t n);
-
-
+_idle
-ssize_t camel_write_socket (int fd, const char *buf, size_t n);
-
+ssize_t camel_read_socket (int fd, char *buf, size_t n);
-ssize_t camel_read_socket_nb (int fd, char *buf, size_t n);
-

trunk/libtinymail-camel/camel-lite/camel/camel-stream-buffer.c

@@ -430 +430 @@
-
-
+
-int
-tcp_stream_buffer_gets_nb
+stream_buffer_gets_idle
-{
-        register char *outptr, *inptr, *inend, c, *outend;
@@ -454 +455 @@
-                        break;
-
+                bytes_read = camel_stream_read_idle (sbf->stream, (char*)sbf->buf, sbf->size);
+                if (bytes_read == -1) {
+                        if (buf == outptr)
+                                return -1;
+                        else
+                                bytes_read = 0;
+                }
+                sbf->ptr = sbf->buf;
+                sbf->end = sbf->buf + bytes_read;
+                inptr = (char*)sbf->ptr;
+                inend = (char*)sbf->end;
+        } while (bytes_read>0);
+
+        sbf->ptr = (unsigned char*)inptr;
+        *outptr = 0;
+
+        return (int)(outptr - buf);
+}
+
+int
+camel_tcp_stream_buffer_gets_nb (CamelStreamBuffer *sbf, char *buf, unsigned int max)
+{
+        register char *outptr, *inptr, *inend, c, *outend;
+        int bytes_read;
+
+        outptr = buf;
+        inptr = (char*)sbf->ptr;
+        inend = (char*)sbf->end;
+        outend = buf+max-1;     /* room for NUL */
+
+        do {
+                while (inptr<inend && outptr<outend) {
+                        c = *inptr++;
+                        *outptr++ = c;
+                        if (c == '\n') {
+                                *outptr = 0;
+                                sbf->ptr = (unsigned char*) inptr;
+                                return outptr-buf;
+                        }
+                }
+                if (outptr == outend)
+                        break;
+
-                bytes_read = camel_tcp_stream_read_nb ((CamelTcpStream *)sbf->stream, (char*)sbf->buf, sbf->size);
-                if (bytes_read == -1) {

trunk/libtinymail-camel/camel-lite/camel/camel-stream-buffer.h

@@ -96 +96 @@
-char *camel_stream_buffer_read_line (CamelStreamBuffer *sbf);
-int camel_tcp_stream_buffer_gets_nb (CamelStreamBuffer *sbf, char *buf, unsigned int max);
+int camel_stream_buffer_gets_idle (CamelStreamBuffer *sbf, char *buf, unsigned int max);
+
-
-G_END_DECLS

trunk/libtinymail-camel/camel-lite/camel/camel-stream.c

@@ -97 +97 @@
-        
-        return (CS_CLASS (stream)->read) (stream, buffer, n);
+}
+
+ssize_t
+camel_stream_read_idle (CamelStream *stream, char *buffer, size_t n)
+{
+        g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1);
+        g_return_val_if_fail (n == 0 || buffer, -1);
+
+        /* Default impl */
+        if (!CS_CLASS (stream)->read_idle)
+                return (CS_CLASS (stream)->read) (stream, buffer, n);
+
+        return (CS_CLASS (stream)->read_idle) (stream, buffer, n);
-}
-

trunk/libtinymail-camel/camel-lite/camel/camel-stream.h

@@ -57 +57 @@
-        int       (*reset)      (CamelStream *stream);
-
+        ssize_t   (*read_idle)  (CamelStream *stream, char *buffer, size_t n);
+
-} CamelStreamClass;
-
@@ -63 +65 @@
-
-/* public methods */
+ssize_t    camel_stream_read_idle  (CamelStream *stream, char *buffer, size_t n);
+
-ssize_t    camel_stream_read       (CamelStream *stream, char *buffer, size_t n);
-ssize_t    camel_stream_write      (CamelStream *stream, const char *buffer, size_t n);

trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream-raw.c

@@ -66 +66 @@
-static struct sockaddr *stream_get_remote_address (CamelTcpStream *stream, socklen_t *len);
-static ssize_t stream_read_nb (CamelTcpStream *stream, char *buffer, size_t n);
+static ssize_t stream_read_idle (CamelStream *stream, char *buffer, size_t n);
-
-static void signal_swallow( int num )
@@ -85 +86 @@
-
-        /* virtual method overload */
+        camel_stream_class->read_idle = stream_read_idle;
-        camel_stream_class->read = stream_read;
-        camel_stream_class->write = stream_write;
-        camel_stream_class->flush = stream_flush;
-        camel_stream_class->close = stream_close;
-
+
-        camel_tcp_stream_class->read_nb = stream_read_nb;
-        camel_tcp_stream_class->connect = stream_connect;
@@ -263 +265 @@
-}
-
+
+static ssize_t 
+stream_read_idle (CamelStream *stream, char *buffer, size_t n)
+{
+        CamelTcpStreamRaw *raw = CAMEL_TCP_STREAM_RAW (stream);
+        
+        return camel_read_socket_idle (raw->sockfd, buffer, n);
+}
+
-static ssize_t
-stream_read_nb (CamelTcpStream *stream, char *buffer, size_t n)

trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c

@@ -88 +88 @@
-static struct sockaddr *stream_get_remote_address (CamelTcpStream *stream, socklen_t *len);
-static ssize_t stream_read_nb (CamelTcpStream *stream, char *buffer, size_t n);
+static ssize_t stream_read_idle (CamelStream *stream, char *buffer, size_t n);
-
-struct _CamelTcpStreamSSLPrivate {
@@ -110 +111 @@
-        
-        /* virtual method overload */
+        camel_stream_class->read_idle = stream_read_idle;
+
-        camel_stream_class->read = stream_read;
-        camel_stream_class->write = stream_write;
@@ -475 +478 @@
-        return nread;
-}
+
+
+
+static ssize_t 
+stream_read_idle (CamelStream *stream, char *buffer, size_t n)
+{
+        CamelTcpStreamSSL *tcp_stream_ssl = CAMEL_TCP_STREAM_SSL (stream);
+        PRFileDesc *cancel_fd;
+        ssize_t nread;
+        
+        if (camel_operation_cancel_check (NULL)) {
+                errno = EINTR;
+                return -1;
+        }
+        
+        cancel_fd = camel_operation_cancel_prfd (NULL);
+        if (cancel_fd == NULL) {
+                do {
+                        nread = PR_Read (tcp_stream_ssl->priv->sockfd, buffer, n);
+                        if (nread == -1)
+                                set_errno (PR_GetError ());
+                } while (nread == -1 && (PR_GetError () == PR_PENDING_INTERRUPT_ERROR ||
+                                         PR_GetError () == PR_IO_PENDING_ERROR ||
+                                         PR_GetError () == PR_WOULD_BLOCK_ERROR));
+        } else {
+                PRSocketOptionData sockopts;
+                PRPollDesc pollfds[2];
+                gboolean nonblock;
+                int error;
+                
+                /* get O_NONBLOCK options */
+                sockopts.option = PR_SockOpt_Nonblocking;
+                PR_GetSocketOption (tcp_stream_ssl->priv->sockfd, &sockopts);
+                sockopts.option = PR_SockOpt_Nonblocking;
+                nonblock = sockopts.value.non_blocking;
+                sockopts.value.non_blocking = TRUE;
+                PR_SetSocketOption (tcp_stream_ssl->priv->sockfd, &sockopts);
+
+                pollfds[0].fd = tcp_stream_ssl->priv->sockfd;
+                pollfds[0].in_flags = PR_POLL_READ;
+                pollfds[1].fd = cancel_fd;
+                pollfds[1].in_flags = PR_POLL_READ;
+                
+                do {
+                        PRInt32 res;
+
+                        pollfds[0].out_flags = 0;
+                        pollfds[1].out_flags = 0;
+                        nread = -1;
+
+                        res = PR_Poll(pollfds, 2, 5);
+
+                        if (res == -1)
+                                set_errno(PR_GetError());
+                        else if (res == 0) {
+#ifdef ETIMEDOUT
+                                errno = ETIMEDOUT;
+#else
+                                errno = EIO;
+#endif
+                        } else if (pollfds[1].out_flags == PR_POLL_READ) {
+                                errno = EINTR;
+                                goto failed;
+                        } else {
+                                do {
+                                        nread = PR_Read (tcp_stream_ssl->priv->sockfd, buffer, n);
+                                        if (nread == -1)
+                                                set_errno (PR_GetError ());
+                                } while (nread == -1 && PR_GetError () == PR_PENDING_INTERRUPT_ERROR);
+                        }
+                } while (nread == -1 && (PR_GetError () == PR_PENDING_INTERRUPT_ERROR ||
+                                         PR_GetError () == PR_IO_PENDING_ERROR ||
+                                         PR_GetError () == PR_WOULD_BLOCK_ERROR));
+                
+                /* restore O_NONBLOCK options */
+        failed:
+                error = errno;
+                sockopts.option = PR_SockOpt_Nonblocking;
+                sockopts.value.non_blocking = nonblock;
+                PR_SetSocketOption (tcp_stream_ssl->priv->sockfd, &sockopts);
+                errno = error;
+        }
+        
+        return nread;
+}
+
-
-static ssize_t

trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream.c

@@ -91 +91 @@
-}
-
+
+
-static int
-tcp_connect (CamelTcpStream *stream, struct addrinfo *host)

trunk/libtinymail-camel/camel-lite/camel/camel-tcp-stream.h

@@ -108 +108 @@
-        struct sockaddr * (*get_remote_address) (CamelTcpStream *stream, socklen_t *len);
-        ssize_t (*read_nb)   (CamelTcpStream *stream, char *buffer, size_t n);
-        
-} CamelTcpStreamClass;
-

trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-command.c

@@ -61 +61 @@
-                                         const char *fmt, ...);
-
-
+
-
-
@@ -444 +444 @@
-        char *respbuf;
-
-
+_idle
-                return CAMEL_IMAP_RESPONSE_ERROR;
-
@@ -464 +464 @@
-                /* Read the rest of the response. */
-                type = CAMEL_IMAP_RESPONSE_UNTAGGED;
-
+_idle
-                if (!respbuf)
-                        type = CAMEL_IMAP_RESPONSE_ERROR;
@@ -708 +708 @@
-}
-
+
+
+static char *
+imap_read_untagged_idle (CamelImapStore *store, char *line, CamelException *ex)
+{
+        int fulllen, ldigits, nread, n, i, sexp = 0;
+        unsigned int length;
+        GPtrArray *data;
+        GString *str;
+        char *end, *p, *s, *d;
+        
+        p = strrchr (line, '{');
+        if (!p)
+                return line;
+        
+        data = g_ptr_array_new ();
+        fulllen = 0;
+        
+        while (1) {
+                str = g_string_new (line);
+                g_free (line);
+                fulllen += str->len;
+                g_ptr_array_add (data, str);
+                
+                if (!(p = strrchr (str->str, '{')) || p[1] == '-')
+                        break;
+                
+                /* HACK ALERT: We scan the non-literal part of the string, looking for possible s expression braces.
+                   This assumes we're getting s-expressions, which we should be.
+                   This is so if we get a blank line after a literal, in an s-expression, we can keep going, since
+                   we do no other parsing at this level.
+                   TODO: handle quoted strings? */
+                for (s=str->str; s<p; s++) {
+                        if (*s == '(')
+                                sexp++;
+                        else if (*s == ')')
+                                sexp--;
+                }
+                
+                length = strtoul (p + 1, &end, 10);
+                if (*end != '}' || *(end + 1) || end == p + 1 || length >= UINT_MAX - 2)
+                        break;
+                ldigits = end - (p + 1);
+                
+                /* Read the literal */
+                str = g_string_sized_new (length + 2);
+                str->str[0] = '\n';
+                nread = 0;
+                
+                do {
+                        if ((n = camel_stream_read_idle (store->istream, str->str + nread + 1, length - nread)) == -1) {
+                                if (errno == EINTR)
+                                        camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL,
+                                                             _("Operation cancelled"));
+                                else
+                                        camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
+                                                             g_strerror (errno));
+                                camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
+                                g_string_free (str, TRUE);
+                                goto lose;
+                        }
+                        
+                        nread += n;
+                } while (n > 0 && nread < length);
+                
+                if (nread < length) {
+                        camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
+                                             _("Server response ended too soon."));
+                        camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
+                        g_string_free (str, TRUE);
+                        goto lose;
+                }
+                str->str[length + 1] = '\0';
+
+                if (camel_debug("imap")) {
+                        printf("Literal: -->");
+                        fwrite(str->str+1, 1, length, stdout);
+                        printf("<--\n");
+                }
+                
+                /* Fix up the literal, turning CRLFs into LF. Also, if
+                 * we find any embedded NULs, strip them. This is
+                 * dubious, but:
+                 *   - The IMAP grammar says you can't have NULs here
+                 *     anyway, so this will not affect our behavior
+                 *     against any completely correct server.
+                 *   - WU-imapd 12.264 (at least) will cheerily pass
+                 *     NULs along if they are embedded in the message
+                 */
+                
+                s = d = str->str + 1;
+                end = str->str + 1 + length;
+                while (s < end) {
+                        while (s < end && *s == '\0') {
+                                s++;
+                                length--;
+                        }
+                        if (*s == '\r' && *(s + 1) == '\n') {
+                                s++;
+                                length--;
+                        }
+                        *d++ = *s++;
+                }
+                *d = '\0';
+                str->len = length + 1;
+                
+                /* p points to the "{" in the line that starts the
+                 * literal. The length of the CR-less response must be
+                 * less than or equal to the length of the response
+                 * with CRs, therefore overwriting the old value with
+                 * the new value cannot cause an overrun. However, we
+                 * don't want it to be shorter either, because then the
+                 * GString's length would be off...
+                 */
+                sprintf (p, "{%0*u}", ldigits, length);
+                
+                fulllen += str->len;
+                g_ptr_array_add (data, str);
+
+                /* Read the next line. */
+                do {
+                        if (camel_imap_store_readline_idle (store, &line, ex) < 0)
+                                goto lose;
+
+                        /* MAJOR HACK ALERT, gropuwise sometimes sends an extra blank line after literals, check that here
+                           But only do it if we're inside an sexpression */
+                        if (line[0] == 0 && sexp > 0)
+                                g_warning("Server sent empty line after a literal, assuming in error");
+                } while (line[0] == 0 && sexp > 0);
+        }
+        
+        /* Now reassemble the data. */
+        p = line = g_malloc (fulllen + 1);
+        for (i = 0; i < data->len; i++) {
+                str = data->pdata[i];
+                memcpy (p, str->str, str->len);
+                p += str->len;
+                g_string_free (str, TRUE);
+        }
+        *p = '\0';
+        g_ptr_array_free (data, TRUE);
+        return line;
+        
+ lose:
+        for (i = 0; i < data->len; i++)
+                g_string_free (data->pdata[i], TRUE);
+        g_ptr_array_free (data, TRUE);
+        return NULL;
+}
-
-/**

trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-folder.c

@@ -3399 +3399 @@
-
-        g_mutex_lock (store->stream_lock);
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-
-        /* The IDLE command is sent from the client to the server when the
@@ -3435 +3441 @@
-                g_free (resp);
-
+errh:
-        g_mutex_unlock (store->stream_lock);
-

trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.c

@@ -3743 +3743 @@
-
-
+
+/* FIXME: please god, when will the hurting stop? Thus function is so
+   fucking broken it's not even funny. */
-ssize_t
-nl
+idle
-{
-        CamelStreamBuffer *stream;
@@ -3764 +3767 @@
-                return -1;
-
+        g_mutex_lock (store->stream_lock);
-        camel_imap_store_restore_stream_buffer (store);
-
-        if (!store->istream)
-                return -1;
-
-        stream = CAMEL_STREAM_BUFFER (store->istream);
-
-        ba = g_byte_array_new ();
-
+_idle
-                g_byte_array_append (ba, (const guchar*) linebuf, nread);
-                if (linebuf[nread - 1] == '\n')
-                        break;
-        }
+        g_mutex_unlock (store->stream_lock);
-
-        if (nread <= 0) {
@@ -3817 +3818 @@
-
-ssize_t
+camel_imap_store_readline_nl (CamelImapStore *store, char **dest, CamelException *ex)
+{
+        CamelStreamBuffer *stream;
+        char linebuf[1024] = {0};
+        GByteArray *ba;
+        ssize_t nread;
+        
+        g_return_val_if_fail (CAMEL_IS_IMAP_STORE (store), -1);
+        g_return_val_if_fail (dest, -1);
+        
+        *dest = NULL;
+        
+        /* Check for connectedness. Failed (or cancelled) operations will
+         * close the connection. We can't expect a read to have any
+         * meaning if we reconnect, so always set an exception.
+         */
+
+        if (!camel_disco_store_check_online((CamelDiscoStore *)store, ex))
+                return -1;
+
+        camel_imap_store_restore_stream_buffer (store);
+
+        if (!store->istream)
+                return -1;
+
+        stream = CAMEL_STREAM_BUFFER (store->istream);
+
+        ba = g_byte_array_new ();
+        while ((nread = camel_stream_buffer_gets (stream, linebuf, sizeof (linebuf))) > 0) {
+                g_byte_array_append (ba, (const guchar*) linebuf, nread);
+                if (linebuf[nread - 1] == '\n')
+                        break;
+        }
+
+        if (nread <= 0) {
+                if (errno == EINTR)
+                {
+                        CamelException mex = CAMEL_EXCEPTION_INITIALISER;
+                        camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL, _("Operation cancelled"));
+                        camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
+                        camel_service_connect (CAMEL_SERVICE (store), &mex);
+                } else {
+                        camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
+                                              _("Server unexpectedly disconnected: %s"),
+                                              g_strerror (errno));
+                        camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
+                }
+
+                g_byte_array_free (ba, TRUE);
+                return -1;
+        }
+        
+        if (camel_verbose_debug) {
+                fprintf (stderr, "received: ");
+                fwrite (ba->data, 1, ba->len, stderr);
+        }
+        
+        /* camel-imap-command.c:imap_read_untagged expects the CRLFs
+           to be stripped off and be nul-terminated *sigh* */
+        nread = ba->len - 1;
+        ba->data[nread] = '\0';
+        if (ba->data[nread - 1] == '\r') {
+                ba->data[nread - 1] = '\0';
+                nread--;
+        }
+        
+        *dest = (char *) ba->data;
+        g_byte_array_free (ba, FALSE);
+        
+        return nread;
+}
+
+ssize_t
-camel_imap_store_readline_nb (CamelImapStore *store, char **dest, CamelException *ex)
-{

trunk/libtinymail-camel/camel-lite/camel/providers/imap/camel-imap-store.h

@@ -180 +180 @@
-ssize_t camel_imap_store_readline_nb (CamelImapStore *store, char **dest, CamelException *ex);
-ssize_t camel_imap_store_readline (CamelImapStore *store, char **dest, CamelException *ex);
+ssize_t camel_imap_store_readline_idle (CamelImapStore *store, char **dest, CamelException *ex);
-gboolean camel_imap_service_connect (CamelService *service, CamelException *ex);
-