Fix SSL receive; Fix clipboard menu hotkeys

[claws.git] / src / common / socket.c

diff --git a/src/common/socket.c b/src/common/socket.c
index a843d5f4cd87e1a83df994824d145785cd6421de..9b1b6208b5e607ec88898e0aaff812ef16b111d6 100644 (file)
--- a/src/common/socket.c
+++ b/src/common/socket.c
@@ -61,6 +61,7 @@ typedef gint (*SockAddrFunc)  (GList          *addr_list,
 typedef struct _SockConnectData        SockConnectData;
 typedef struct _SockLookupData SockLookupData;
 typedef struct _SockAddrData   SockAddrData;
+typedef struct _SockSource     SockSource;
 
 struct _SockConnectData {
        gint id;
@@ -92,10 +93,29 @@ struct _SockAddrData {
        struct sockaddr *addr;
 };
 
+struct _SockSource {
+       GSource parent;
+       SockInfo *sock;
+};
+
 static guint io_timeout = 60;
 
 static GList *sock_connect_data_list = NULL;
 
+static gboolean sock_prepare           (GSource        *source,
+                                        gint           *timeout);
+static gboolean sock_check             (GSource        *source);
+static gboolean sock_dispatch          (GSource        *source,
+                                        GSourceFunc     callback,
+                                        gpointer        user_data);
+
+GSourceFuncs sock_watch_funcs = {
+       sock_prepare,
+       sock_check,
+       sock_dispatch,
+       NULL
+};
+
 static gint sock_connect_with_timeout  (gint                    sock,
                                         const struct sockaddr  *serv_addr,
                                         gint                    addrlen,
@@ -230,7 +250,6 @@ gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)
        return set_nonblocking_mode(sock->sock, nonblock);
 }
 
-
 static gboolean is_nonblocking_mode(gint fd)
 {
        gint flags;
@@ -251,6 +270,95 @@ gboolean sock_is_nonblocking_mode(SockInfo *sock)
        return is_nonblocking_mode(sock->sock);
 }
 
+
+static gboolean sock_prepare(GSource *source, gint *timeout)
+{
+       *timeout = 1;
+       return FALSE;
+}
+
+static gboolean sock_check(GSource *source)
+{
+       SockInfo *sock = ((SockSource *)source)->sock;
+       struct timeval timeout = {0, 0};
+       fd_set fds;
+       GIOCondition condition = sock->condition;
+
+       if (!sock || !sock->sock)
+               return FALSE;
+
+#if USE_OPENSSL
+       if (sock->ssl) {
+               if (condition & G_IO_IN) {
+                       if (SSL_pending(sock->ssl) > 0)
+                               return TRUE;
+                       if (SSL_want_write(sock->ssl))
+                               condition |= G_IO_OUT;
+               }
+
+               if (condition & G_IO_OUT) {
+                       if (SSL_want_read(sock->ssl))
+                               condition |= G_IO_IN;
+               }
+       }
+#endif
+
+       FD_ZERO(&fds);
+       FD_SET(sock->sock, &fds);
+
+       select(sock->sock + 1,
+              (condition & G_IO_IN)  ? &fds : NULL,
+              (condition & G_IO_OUT) ? &fds : NULL,
+              NULL, &timeout);
+
+       return FD_ISSET(sock->sock, &fds) != 0;
+}
+
+static gboolean sock_dispatch(GSource *source, GSourceFunc callback,
+                             gpointer user_data)
+{
+       SockInfo *sock = ((SockSource *)source)->sock;
+
+       if (!sock || !sock->callback || !sock->data)
+               return FALSE;
+
+       return sock->callback(sock, sock->condition, sock->data);
+}
+
+static gboolean sock_watch_cb(GIOChannel *source, GIOCondition condition,
+                             gpointer data)
+{
+       SockInfo *sock = (SockInfo *)data;
+
+       if (!sock || !sock->callback || !sock->data) {
+               return FALSE;
+       }
+       return sock->callback(sock, condition, sock->data);
+}
+
+guint sock_add_watch(SockInfo *sock, GIOCondition condition, SockFunc func,
+                    gpointer data)
+{
+       sock->callback = func;
+       sock->condition = condition;
+       sock->data = data;
+
+#if USE_OPENSSL
+       if (sock->ssl)
+       {
+               GSource *source = g_source_new(&sock_watch_funcs,
+                                              sizeof(SockSource));
+               ((SockSource *) source)->sock = sock;
+               g_source_set_priority(source, G_PRIORITY_DEFAULT);
+               g_source_set_can_recurse(source, FALSE);
+               sock->g_source = g_source_attach(source, NULL);
+               return g_source_attach(source, NULL);
+       }
+#endif
+
+       return g_io_add_watch(sock->sock_ch, condition, sock_watch_cb, sock);
+}
+
 static gint fd_check_io(gint fd, GIOCondition cond)
 {
        struct timeval timeout;
@@ -537,6 +645,7 @@ static gboolean sock_connect_async_cb(GIOChannel *source,
 
        sockinfo = g_new0(SockInfo, 1);
        sockinfo->sock = fd;
+       sockinfo->sock_ch = g_io_channel_unix_new(fd);
        sockinfo->hostname = g_strdup(conn_data->hostname);
        sockinfo->port = conn_data->port;
        sockinfo->state = CONN_ESTABLISHED;
@@ -893,6 +1002,7 @@ static SockInfo *sockinfo_from_fd(const gchar *hostname,
 
        sockinfo = g_new0(SockInfo, 1);
        sockinfo->sock = sock;
+       sockinfo->sock_ch = g_io_channel_unix_new(sock);
        sockinfo->hostname = g_strdup(hostname);
        sockinfo->port = port;
        sockinfo->state = CONN_ESTABLISHED;
@@ -925,7 +1035,20 @@ gint fd_read(gint fd, gchar *buf, gint len)
 #if USE_OPENSSL
 gint ssl_read(SSL *ssl, gchar *buf, gint len)
 {
-       return SSL_read(ssl, buf, len);
+       gint ret;
+
+       ret = SSL_read(ssl, buf, len);
+
+       switch (SSL_get_error(ssl, ret)) {
+       case SSL_ERROR_NONE:
+               return ret;
+       case SSL_ERROR_WANT_READ:
+       case SSL_ERROR_WANT_WRITE:
+               errno = EAGAIN;
+               return -1;
+       default:
+               return -1;
+       }
 }
 #endif
 
@@ -958,7 +1081,20 @@ gint fd_write(gint fd, const gchar *buf, gint len)
 #if USE_OPENSSL
 gint ssl_write(SSL *ssl, const gchar *buf, gint len)
 {
-       return SSL_write(ssl, buf, len);
+       gint ret;
+
+       ret = SSL_write(ssl, buf, len);
+
+       switch (SSL_get_error(ssl, ret)) {
+       case SSL_ERROR_NONE:
+               return ret;
+       case SSL_ERROR_WANT_READ:
+       case SSL_ERROR_WANT_WRITE:
+               errno = EAGAIN;
+               return -1;
+       default:
+               return -1;
+       }
 }
 #endif
 
@@ -1007,7 +1143,7 @@ gint ssl_write_all(SSL *ssl, const gchar *buf, gint len)
        gint n, wrlen = 0;
 
        while (len) {
-               n = SSL_write(ssl, buf, len);
+               n = ssl_write(ssl, buf, len);
                if (n <= 0)
                        return -1;
                len -= n;
@@ -1076,11 +1212,11 @@ gint ssl_gets(SSL *ssl, gchar *buf, gint len)
        if (--len < 1)
                return -1;
        do {
-               if ((n = SSL_peek(ssl, bp, len)) <= 0)
+               if ((n = ssl_peek(ssl, bp, len)) <= 0)
                        return -1;
                if ((newline = memchr(bp, '\n', n)) != NULL)
                        n = newline - bp + 1;
-               if ((n = SSL_read(ssl, bp, n)) < 0)
+               if ((n = ssl_read(ssl, bp, n)) < 0)
                        return -1;
                bp += n;
                len -= n;
@@ -1186,13 +1322,33 @@ gint sock_puts(SockInfo *sock, const gchar *buf)
 }
 
 /* peek at the socket data without actually reading it */
+#if USE_OPENSSL
+gint ssl_peek(SSL *ssl, gchar *buf, gint len)
+{
+       gint ret;
+
+       ret = SSL_peek(ssl, buf, len);
+
+       switch (SSL_get_error(ssl, ret)) {
+       case SSL_ERROR_NONE:
+               return ret;
+       case SSL_ERROR_WANT_READ:
+       case SSL_ERROR_WANT_WRITE:
+               errno = EAGAIN;
+               return -1;
+       default:
+               return -1;
+       }
+}
+#endif
+
 gint sock_peek(SockInfo *sock, gchar *buf, gint len)
 {
        g_return_val_if_fail(sock != NULL, -1);
 
 #if USE_OPENSSL
        if (sock->ssl)
-               return SSL_peek(sock->ssl, buf, len);
+               return ssl_peek(sock->ssl, buf, len);
 #endif
        return fd_recv(sock->sock, buf, len, MSG_PEEK);
 }
@@ -1204,9 +1360,15 @@ gint sock_close(SockInfo *sock)
        if (!sock)
                return 0;
 
+       if (sock->sock_ch)
+               g_io_channel_unref(sock->sock_ch);
+
 #if USE_OPENSSL
        if (sock->ssl)
                ssl_done_socket(sock);
+       if (sock->g_source != 0)
+               g_source_remove(sock->g_source);
+       sock->g_source = 0;
 #endif
        ret = fd_close(sock->sock); 
        g_free(sock->hostname);