Sylpheed

/*

 * LibSylph -- E-Mail client library

 * Copyright (C) 1999-2007 Hiroyuki Yamamoto

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include <glib.h>

#include <sys/time.h>

#include <sys/types.h>

#ifdef G_OS_WIN32

#  include <winsock2.h>

#  include <ws2tcpip.h>

#else

#  if HAVE_SYS_WAIT_H

#    include <sys/wait.h>

#  endif

#  include <sys/socket.h>

#  include <sys/un.h>

#  include <netinet/in.h>

#  include <arpa/inet.h>

#  include <resolv.h>

#  include <netdb.h>

#  include <sys/stat.h>

#endif /* G_OS_WIN32 */

#include <unistd.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <fcntl.h>

#include <errno.h>

#include <signal.h>

#include <setjmp.h>

#if HAVE_SYS_SELECT_H

#  include <sys/select.h>

#endif

#include "socket.h"

#if USE_SSL

#  include "ssl.h"

#endif

#include "utils.h"

#define BUFFSIZE        8192

#ifdef G_OS_WIN32

#define SockDesc                SOCKET

#define SOCKET_IS_VALID(s)        ((s) != INVALID_SOCKET)

#else

#define SockDesc                gint

#define SOCKET_IS_VALID(s)        ((s) >= 0)

#define INVALID_SOCKET                (-1)

#endif

typedef gint (*SockAddrFunc)        (GList                *addr_list,

                                 gpointer         data);

typedef struct _SockConnectData        SockConnectData;

typedef struct _SockLookupData        SockLookupData;

typedef struct _SockAddrData        SockAddrData;

typedef struct _SockSource        SockSource;

struct _SockConnectData {

        gint id;

        gchar *hostname;

        gushort port;

        GList *addr_list;

        GList *cur_addr;

        SockLookupData *lookup_data;

        GIOChannel *channel;

        guint io_tag;

        SockConnectFunc func;

        gpointer data;

};

struct _SockLookupData {

        gchar *hostname;

        pid_t child_pid;

        GIOChannel *channel;

        guint io_tag;

        SockAddrFunc func;

        gpointer data;

};

struct _SockAddrData {

        gint family;

        gint socktype;

        gint protocol;

        gint addr_len;

        struct sockaddr *addr;

};

struct _SockSource {

        GSource parent;

        SockInfo *sock;

};

static guint io_timeout = 60;

static GList *sock_connect_data_list = NULL;

static GList *sock_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 SockInfo *sock_find_from_fd        (gint        fd);

static gint sock_connect_with_timeout        (gint                         sock,

                                         const struct sockaddr        *serv_addr,

                                         gint                         addrlen,

                                         guint                         timeout_secs);

#ifndef INET6

static gint sock_connect_by_hostname        (gint                 sock,

                                         const gchar        *hostname,

                                         gushort         port);

#else

static SockDesc sock_connect_by_getaddrinfo        (const gchar        *hostname,

                                                 gushort         port);

#endif

#ifdef G_OS_UNIX

static void sock_address_list_free                (GList                *addr_list);

static gboolean sock_connect_async_cb                (GIOChannel        *source,

                                                 GIOCondition         condition,

                                                 gpointer         data);

static gint sock_connect_async_get_address_info_cb

                                                (GList                *addr_list,

                                                 gpointer         data);

static gint sock_connect_address_list_async        (SockConnectData *conn_data);

static gboolean sock_get_address_info_async_cb        (GIOChannel        *source,

                                                 GIOCondition         condition,

                                                 gpointer         data);

static SockLookupData *sock_get_address_info_async

                                                (const gchar        *hostname,

                                                 gushort         port,

                                                 SockAddrFunc         func,

                                                 gpointer         data);

static gint sock_get_address_info_async_cancel        (SockLookupData        *lookup_data);

#endif /* G_OS_UNIX */

gint sock_init(void)

{

#ifdef G_OS_WIN32

        WSADATA wsadata;

        gint result;

        result = WSAStartup(MAKEWORD(2, 2), &wsadata);

        if (result != NO_ERROR) {

                g_warning("WSAStartup() failed\n");

                return -1;

        }

#endif

        return 0;

}

gint sock_cleanup(void)

{

#ifdef G_OS_WIN32

        WSACleanup();

#endif

        return 0;

}

gint sock_set_io_timeout(guint sec)

{

        io_timeout = sec;

        return 0;

}

gint fd_connect_inet(gushort port)

{

        SockDesc sock;

        struct sockaddr_in addr;

        sock = socket(AF_INET, SOCK_STREAM, 0);

        if (!SOCKET_IS_VALID(sock)) {

#ifdef G_OS_WIN32

                g_warning("fd_connect_inet(): socket() failed: %ld\n",

                          WSAGetLastError());

#else

                perror("fd_connect_inet(): socket");

#endif

                return -1;

        }

        memset(&addr, 0, sizeof(addr));

        addr.sin_family = AF_INET;

        addr.sin_port = htons(port);

        addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

        if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {

                fd_close(sock);

                return -1;

        }

        return sock;

}

gint fd_open_inet(gushort port)

{

        SockDesc sock;

        struct sockaddr_in addr;

        gint val;

        sock = socket(AF_INET, SOCK_STREAM, 0);

        if (!SOCKET_IS_VALID(sock)) {

#ifdef G_OS_WIN32

                g_warning("fd_open_inet(): socket() failed: %ld\n",

                          WSAGetLastError());

#else

                perror("fd_open_inet(): socket");

#endif

                return -1;

        }

        val = 1;

        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val,

                       sizeof(val)) < 0) {

                perror("setsockopt");

                fd_close(sock);

                return -1;

        }

        memset(&addr, 0, sizeof(addr));

        addr.sin_family = AF_INET;

        addr.sin_port = htons(port);

        addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {

                perror("bind");

                fd_close(sock);

                return -1;

        }

        if (listen(sock, 1) < 0) {

                perror("listen");

                fd_close(sock);

                return -1;

        }

        return sock;

}

gint fd_connect_unix(const gchar *path)

{

#ifdef G_OS_UNIX

        gint sock;

        struct sockaddr_un addr;

        sock = socket(PF_UNIX, SOCK_STREAM, 0);

        if (sock < 0) {

                perror("fd_connect_unix(): socket");

                return -1;

        }

        memset(&addr, 0, sizeof(addr));

        addr.sun_family = AF_UNIX;

        strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);

        if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {

                fd_close(sock);

                return -1;

        }

        return sock;

#else

        return -1;

#endif

}

gint fd_open_unix(const gchar *path)

{

#ifdef G_OS_UNIX

        gint sock;

        struct sockaddr_un addr;

        gint val;

        sock = socket(PF_UNIX, SOCK_STREAM, 0);

        if (sock < 0) {

                perror("sock_open_unix(): socket");

                return -1;

        }

        val = 1;

        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {

                perror("setsockopt");

                fd_close(sock);

                return -1;

        }

        memset(&addr, 0, sizeof(addr));

        addr.sun_family = AF_UNIX;

        strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);

        if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {

                perror("bind");

                fd_close(sock);

                return -1;

        }

        if (listen(sock, 1) < 0) {

                perror("listen");

                fd_close(sock);

                return -1;

        }

        return sock;

#else

        return -1;

#endif

}

gint fd_accept(gint sock)

{

        struct sockaddr_in caddr;

        guint caddr_len;

        caddr_len = sizeof(caddr);

        return accept(sock, (struct sockaddr *)&caddr, &caddr_len);

}

static SockInfo *sock_find_from_fd(gint fd)

{

        GList *cur;

        for (cur = sock_list; cur != NULL; cur = cur->next) {

                if (((SockInfo *)cur->data)->sock == fd)

                        return (SockInfo *)cur->data;

        }

        return NULL;

}

static gint set_nonblocking_mode(gint fd, gboolean nonblock)

{

#ifdef G_OS_WIN32

        gulong val = nonblock ? 1 : 0;

        SockInfo *sock;

        if (!nonblock)

                WSAEventSelect(fd, NULL, 0);

        if (ioctlsocket(fd, FIONBIO, &val) == SOCKET_ERROR) {

                g_warning("set_nonblocking_mode(): ioctlsocket() failed: %ld\n",

                          WSAGetLastError());

                return -1;

        }

        sock = sock_find_from_fd(fd);

        if (sock) {

                if (nonblock) {

                        SOCK_SET_FLAGS(sock->flags, SOCK_NONBLOCK);

                } else {

                        SOCK_UNSET_FLAGS(sock->flags, SOCK_NONBLOCK);

                }

        }

        debug_print("set nonblocking mode to %d\n", nonblock);

        return 0;

#else

        gint flags;

        flags = fcntl(fd, F_GETFL, 0);

        if (flags < 0) {

                perror("fcntl");

                return -1;

        }

        if (nonblock)

                flags |= O_NONBLOCK;

        else

                flags &= ~O_NONBLOCK;

        return fcntl(fd, F_SETFL, flags);

#endif

}

gint sock_set_nonblocking_mode(SockInfo *sock, gboolean nonblock)

{

        gint ret;

        g_return_val_if_fail(sock != NULL, -1);

        ret = set_nonblocking_mode(sock->sock, nonblock);

        if (ret == 0) {

                if (nonblock) {

                        SOCK_SET_FLAGS(sock->flags, SOCK_NONBLOCK);

                } else {

                        SOCK_UNSET_FLAGS(sock->flags, SOCK_NONBLOCK);

                }

        }

        return ret;

}

static gboolean is_nonblocking_mode(gint fd)

{

#ifdef G_OS_WIN32

        SockInfo *sock;

        sock = sock_find_from_fd(fd);

        if (sock) {

                return SOCK_IS_NONBLOCK(sock->flags);

        }

        return FALSE;

#else

        gint flags;

        flags = fcntl(fd, F_GETFL, 0);

        if (flags < 0) {

                perror("fcntl");

                return FALSE;

        }

        return ((flags & O_NONBLOCK) != 0);

#endif

}

gboolean sock_is_nonblocking_mode(SockInfo *sock)

{

        g_return_val_if_fail(sock != NULL, FALSE);

#ifdef G_OS_WIN32

        return SOCK_IS_NONBLOCK(sock->flags);

#else

        return is_nonblocking_mode(sock->sock);

#endif

}

gboolean sock_has_read_data(SockInfo *sock)

{

#ifdef G_OS_WIN32

        gulong val;

#if USE_SSL

        if (sock->ssl)

                return TRUE;

#endif

        if (ioctlsocket(sock->sock, FIONREAD, &val) < 0) {

                g_warning("sock_has_read_data(): ioctlsocket() failed: %ld\n",

                          WSAGetLastError());

                return TRUE;

        }

        if (val == 0)

                return FALSE;

        else

                return TRUE;

#else

        return TRUE;

#endif

}

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 USE_SSL

        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;

        return sock->callback(sock, sock->condition, sock->data);

}

static gboolean sock_watch_cb(GIOChannel *source, GIOCondition condition,

                              gpointer data)

{

        SockInfo *sock = (SockInfo *)data;

        if ((condition & sock->condition) == 0)

                return TRUE;

        return sock->callback(sock, 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_SSL

        if (sock->ssl) {

                GSource *source;

                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);

                return g_source_attach(source, NULL);

        }

#endif

        return g_io_add_watch(sock->sock_ch, condition, sock_watch_cb, sock);

}

guint sock_add_watch_poll(SockInfo *sock, GIOCondition condition, SockFunc func,

                          gpointer data)

{

        GSource *source;

        sock->callback = func;

        sock->condition = condition;

        sock->data = data;

        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);

        return g_source_attach(source, NULL);

}

static gint fd_check_io(gint fd, GIOCondition cond)

{

        struct timeval timeout;

        fd_set fds;

        SockInfo *sock;

        sock = sock_find_from_fd(fd);

        if (sock && !SOCK_IS_CHECK_IO(sock->flags))

                return 0;

        timeout.tv_sec  = io_timeout;

        timeout.tv_usec = 0;

        FD_ZERO(&fds);

        FD_SET(fd, &fds);

        if (cond == G_IO_IN) {

                select(fd + 1, &fds, NULL, NULL,

                       io_timeout > 0 ? &timeout : NULL);

        } else {

                select(fd + 1, NULL, &fds, NULL,

                       io_timeout > 0 ? &timeout : NULL);

        }

        if (FD_ISSET(fd, &fds)) {

                return 0;

        } else {

                g_warning("Socket IO timeout\n");

                return -1;

        }

}

#ifdef G_OS_UNIX

static sigjmp_buf jmpenv;

static void timeout_handler(gint sig)

{

        siglongjmp(jmpenv, 1);

}

#endif

static gint sock_connect_with_timeout(gint sock,

                                      const struct sockaddr *serv_addr,

                                      gint addrlen,

                                      guint timeout_secs)

{

        gint ret;

#ifdef G_OS_UNIX

        void (*prev_handler)(gint);

        alarm(0);

        prev_handler = signal(SIGALRM, timeout_handler);

        if (sigsetjmp(jmpenv, 1)) {

                alarm(0);

                signal(SIGALRM, prev_handler);

                errno = ETIMEDOUT;

                return -1;

        }

        alarm(timeout_secs);

#endif

        ret = connect(sock, serv_addr, addrlen);

#ifdef G_OS_UNIX

        alarm(0);

        signal(SIGALRM, prev_handler);

#endif

        return ret;

}

static void resolver_init(void)

{

#ifdef G_OS_UNIX

        static time_t resolv_conf_mtime = 0;

        struct stat s;

        if (g_stat("/etc/resolv.conf", &s) == 0 &&

            s.st_mtime != resolv_conf_mtime) {

                debug_print("Reloading /etc/resolv.conf\n");

                resolv_conf_mtime = s.st_mtime;

                res_init();

        }

#endif

}

struct hostent *my_gethostbyname(const gchar *hostname)

{

        struct hostent *hp;

#ifdef G_OS_UNIX

        void (*prev_handler)(gint);

        alarm(0);

        prev_handler = signal(SIGALRM, timeout_handler);

        if (sigsetjmp(jmpenv, 1)) {

                alarm(0);

                signal(SIGALRM, prev_handler);

                fprintf(stderr, "%s: host lookup timed out.\n", hostname);

                errno = 0;

                return NULL;

        }

        alarm(io_timeout);

#endif

        if ((hp = gethostbyname(hostname)) == NULL) {

#ifdef G_OS_UNIX

                alarm(0);

                signal(SIGALRM, prev_handler);

#endif

                fprintf(stderr, "%s: unknown host.\n", hostname);

                errno = 0;

                return NULL;

        }

#ifdef G_OS_UNIX

        alarm(0);

        signal(SIGALRM, prev_handler);

#endif

        return hp;

}

static void sock_set_buffer_size(gint sock)

{

#ifdef G_OS_WIN32

        gint val;

        guint len = sizeof(val);

#define SOCK_BUFFSIZE        32768

        getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len);

        if (val < SOCK_BUFFSIZE) {

                val = SOCK_BUFFSIZE;

                setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&val, len);

        }

        getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len);

        if (val < SOCK_BUFFSIZE) {

                val = SOCK_BUFFSIZE;

                setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&val, len);

        }

        getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&val, &len);

        debug_print("SO_SNDBUF = %d\n", val);

        getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&val, &len);

        debug_print("SO_RCVBUF = %d\n", val);

#undef SOCK_BUFFSIZE

#endif

}

#ifndef INET6

static gint my_inet_aton(const gchar *hostname, struct in_addr *inp)

{

#if HAVE_INET_ATON

        return inet_aton(hostname, inp);

#else

#if HAVE_INET_ADDR

        guint32 inaddr;

        inaddr = inet_addr(hostname);

        if (inaddr != -1) {

                memcpy(inp, &inaddr, sizeof(inaddr));

                return 1;

        } else

                return 0;

#else

        return 0;

#endif

#endif /* HAVE_INET_ATON */

}

static gint sock_connect_by_hostname(gint sock, const gchar *hostname,

                                     gushort port)

{

        struct hostent *hp;

        struct sockaddr_in ad;

        resolver_init();

        memset(&ad, 0, sizeof(ad));

        ad.sin_family = AF_INET;

        ad.sin_port = htons(port);

        if (!my_inet_aton(hostname, &ad.sin_addr)) {

                if ((hp = my_gethostbyname(hostname)) == NULL) {

                        fprintf(stderr, "%s: unknown host.\n", hostname);

                        errno = 0;

                        return -1;

                }

                if (hp->h_length != 4 && hp->h_length != 8) {

                        fprintf(stderr, "illegal address length received for host %s\n", hostname);

                        errno = 0;

                        return -1;

                }

                memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);

        }

        return sock_connect_with_timeout(sock, (struct sockaddr *)&ad,

                                         sizeof(ad), io_timeout);

}

#else /* INET6 */

#ifdef G_OS_WIN32

/* MinGW defines gai_strerror() in ws2tcpip.h, but it is not implemented. */

#undef gai_strerror

const gchar *gai_strerror(gint errcode)

{

        static gchar str[32];

        g_snprintf(str, sizeof(str), "gai errcode: (%d)", errcode);

        return str;

}

#endif

static SockDesc sock_connect_by_getaddrinfo(const gchar *hostname, gushort port)

{

        SockDesc sock = INVALID_SOCKET;

        gint gai_error;

        struct addrinfo hints, *res, *ai;

        gchar port_str[6];

        resolver_init();

        memset(&hints, 0, sizeof(hints));

        /* hints.ai_flags = AI_CANONNAME; */

        hints.ai_family = AF_UNSPEC;

        hints.ai_socktype = SOCK_STREAM;

        hints.ai_protocol = IPPROTO_TCP;

        /* convert port from integer to string. */

        g_snprintf(port_str, sizeof(port_str), "%d", port);

        if ((gai_error = getaddrinfo(hostname, port_str, &hints, &res)) != 0) {

                fprintf(stderr, "getaddrinfo for %s:%s failed: %s\n",

                        hostname, port_str, gai_strerror(gai_error));

                return INVALID_SOCKET;

        }

        for (ai = res; ai != NULL; ai = ai->ai_next) {

                sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);

                if (!SOCKET_IS_VALID(sock))

                        continue;

                sock_set_buffer_size(sock);

                if (sock_connect_with_timeout

                        (sock, ai->ai_addr, ai->ai_addrlen, io_timeout) == 0)

                        break;

                fd_close(sock);

        }

        if (res != NULL)

                freeaddrinfo(res);

        if (ai == NULL)

                return INVALID_SOCKET;

        return sock;

}

#endif /* !INET6 */

SockInfo *sock_connect(const gchar *hostname, gushort port)

{

        SockDesc sock;

        SockInfo *sockinfo;

#ifdef INET6

        sock = sock_connect_by_getaddrinfo(hostname, port);

        if (!SOCKET_IS_VALID(sock))

                return NULL;

#else

        sock = socket(AF_INET, SOCK_STREAM, 0);

        if (!SOCKET_IS_VALID(sock)) {

#ifdef G_OS_WIN32

                g_warning("socket() failed: %ld\n", WSAGetLastError());

#else

                perror("socket");

#endif /* G_OS_WIN32 */

                return NULL;

        }

        sock_set_buffer_size(sock);

        if (sock_connect_by_hostname(sock, hostname, port) < 0) {

                if (errno != 0) perror("connect");

                fd_close(sock);

                return NULL;

        }

#endif /* INET6 */

        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;

        sockinfo->flags = SOCK_CHECK_IO;

        sock_list = g_list_prepend(sock_list, sockinfo);

        g_usleep(100000);

        return sockinfo;

}

#ifdef G_OS_UNIX

static void sock_address_list_free(GList *addr_list)

{

        GList *cur;

        for (cur = addr_list; cur != NULL; cur = cur->next) {

                SockAddrData *addr_data = (SockAddrData *)cur->data;

                g_free(addr_data->addr);