Changeset 3643

Timestamp:

05/06/08 17:35:11

Author:

jdapena

Message:

* libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c:

• • • • Protect PR_Reads and writes to avoid calls to PR_Close before
        

one of them. Should avoid some crashes and bad memory
accesses.

Files:

• releases/modest/diablo/ChangeLog (modified) (1 diff)
• releases/modest/diablo/libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c (modified) (14 diffs)

releases/modest/diablo/ChangeLog

@@ +1 @@
+2008-05-06  Jose Dapena Paz  <jdapena@igalia.com>
+
+        * libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c:
+        Protect PR_Reads and writes to avoid calls to PR_Close before one of
+        them. Should avoid some crashes and bad memory accesses.
+
-2008-04-30  Sergio Villar Senin  <svillar@igalia.com>
-

releases/modest/diablo/libtinymail-camel/camel-lite/camel/camel-tcp-stream-ssl.c

@@ -87 +87 @@
-static int stream_gettimeout (CamelTcpStream *stream);
-
+static gboolean begin_read (CamelTcpStreamSSL *stream);
+static void end_read (CamelTcpStreamSSL *stream);
+static gint ssl_close (CamelTcpStreamSSL *stream);
+
-
-struct _CamelTcpStreamSSLPrivate {
@@ -97 +101 @@
-        gboolean accepted;
-        CamelService *service;
+        guint reads;
+        GMutex *reads_lock;
+        gboolean scheduled_close;
-};
-
+/*
+ * This method is used for making sure we don't close the ssl socket
+ * before all the scheduled reads are finished. It also rejects read
+ * if we have a pending close.
+ *
+ * The return value is FALSE when we didn't accept the request to begin
+ * a read operation. In this case we shouldn't call end_read.
+ */
+static inline gboolean
+begin_read (CamelTcpStreamSSL *stream)
+{
+        gboolean retval = TRUE;
+
+        g_mutex_lock (stream->priv->reads_lock);
+        if (stream->priv->scheduled_close) {
+                retval = FALSE;
+        } else {
+                stream->priv->reads ++;
+                camel_object_ref (stream);
+        }
+        g_mutex_unlock (stream->priv->reads_lock);
+        return retval;
+}
+
+/*
+ * This ends a read request started succesfully in begin_read. Then, if that
+ * method returns FALSE, we shouldn't call this.
+ *
+ * It checks if there's a close call delayed because of reads pending. It it's
+ * so, then it closes the socket and sets the sock reference to NULL.
+ */
+static inline void
+end_read (CamelTcpStreamSSL *stream)
+{
+        gboolean close;
+        g_mutex_lock (stream->priv->reads_lock);
+        stream->priv->reads --;
+        close =  ((stream->priv->reads == 0) && (stream->priv->scheduled_close));
+        g_mutex_unlock (stream->priv->reads_lock);
+        if (close) {
+                PR_Shutdown (stream->priv->sockfd, PR_SHUTDOWN_BOTH);
+                PR_Close (stream->priv->sockfd);
+                stream->priv->sockfd = NULL;
+        }
+        camel_object_unref (stream);
+}
+
+
+/*
+ * Closes the stream ssl socket, in case there are no reads pending, or sets
+ * this as requested.
+ */
+static gint
+ssl_close (CamelTcpStreamSSL *stream)
+{
+        gboolean close;
+        g_mutex_lock (stream->priv->reads_lock);
+        close = ((stream->priv->reads == 0) && (stream->priv->sockfd != NULL));
+        if (stream->priv->sockfd != NULL)
+                stream->priv->scheduled_close = TRUE;
+        g_mutex_unlock (stream->priv->reads_lock);
+        if (close) {
+                PR_Shutdown (stream->priv->sockfd, PR_SHUTDOWN_BOTH);
+                if (PR_Close (stream->priv->sockfd) == PR_FAILURE) {
+                        stream->priv->sockfd = NULL;
+                        return -1;
+                }
+                stream->priv->sockfd = NULL;
+        }
+        return 0;
+}
-
-static void 
@@ -145 +223 @@
-
-        stream->priv = g_new0 (struct _CamelTcpStreamSSLPrivate, 1);
+        stream->priv->reads_lock = g_mutex_new ();
-}
-
@@ -153 +232 @@
-
-        if (stream->priv->sockfd != NULL) {
-
-
+
-        }
-
-        if (stream->priv->session)
-                camel_object_unref(stream->priv->session);
+
+        g_mutex_free (stream->priv->reads_lock);
-
-        g_free (stream->priv->expected_host);
@@ -221 +301 @@
-                NSS_InitReadWrite (str);
-                has_init = TRUE;
+                g_free (str);
-        }
-
@@ -362 +443 @@
-                }
-
+                g_mutex_lock (ssl->priv->reads_lock);
-                ssl->priv->sockfd = fd;
+                ssl->priv->scheduled_close = FALSE;
+                ssl->priv->reads = 0;
+                g_mutex_unlock (ssl->priv->reads_lock);
-
-                if (SSL_ResetHandshake (fd, FALSE) == SECFailure) {
@@ -425 +510 @@
-                         do {
-                                nread = -1;
-
-
+
+
+
+
+
-                                if (nread == -1)
-                                        set_errno (PR_GetError ());
@@ -491 +579 @@
-                        } else {
-                                do {
-
-
-
+
+
+
+
+
+
+
-                                } while (nread == -1 && PR_GetError () == PR_PENDING_INTERRUPT_ERROR);
-                        }
@@ -548 +640 @@
-                        } else {
-                                do {
-
-
-
+
+
+
+
+
+
+
-                                } while (nread == -1 && PR_GetError () == PR_PENDING_INTERRUPT_ERROR);
-                        }
@@ -619 +715 @@
-                        } else {
-                                do {
-
-
-
+
+
+
+
+
+
+
-                                } while (w == -1 && PR_GetError () == PR_PENDING_INTERRUPT_ERROR);
-
@@ -681 +781 @@
-                        } else {
-                                do {
-
-
-
+
+
+
+
+
+
+
-                                } while (w == -1 && PR_GetError () == PR_PENDING_INTERRUPT_ERROR);
-
@@ -724 +828 @@
-        }
-
-
-
-
+
-
-        ((CamelTcpStreamSSL *)stream)->priv->sockfd = NULL;
@@ -1389 +1491 @@
-                        PR_Shutdown (fd, PR_SHUTDOWN_BOTH);
-                        PR_Close (fd);
-                        ssl->priv->sockfd = NULL;
-                        errno = errnosave;
-
@@ -1398 +1499 @@
-        }
-
+        g_mutex_lock (ssl->priv->reads_lock);
+        ssl->priv->reads = 0;
+        ssl->priv->scheduled_close = FALSE;
-        ssl->priv->sockfd = fd;
+        g_mutex_unlock (ssl->priv->reads_lock);
-
-        return 0;