/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * Copyright (C) 2006-2008 Imendio AB

 * Copyright (C) 2006 Nokia Corporation. All rights reserved.

 * Copyright (C) 2007 Collabora Ltd.

 *

 * This program 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 of the

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

 *

 * This program 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 program; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include <config.h>

#include <string.h>

#include <sys/types.h>

/* Needed on Mac OS X */

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

/* Needed on Mac OS X */

#if HAVE_ARPA_NAMESER_COMPAT_H

#include <arpa/nameser_compat.h>

#endif

#include <arpa/nameser.h>

#include <resolv.h>

#include "lm-debug.h"

#include "lm-error.h"

#include "lm-internals.h"

#include "lm-misc.h"

#include "lm-proxy.h"

#include "lm-resolver.h"

#include "lm-ssl.h"

#include "lm-ssl-internals.h"

#include "lm-sock.h"

#include "lm-old-socket.h"

#ifdef HAVE_ASYNCNS

#include <asyncns.h>

#define freeaddrinfo(x) asyncns_freeaddrinfo(x)

#endif

#define IN_BUFFER_SIZE 1024

#define SRV_LEN 8192

struct _LmOldSocket {

    LmConnection      *connection;

    GMainContext      *context;

    gchar             *domain;

    gchar             *server;

    guint              port;

    gboolean           blocking;

    LmSSL             *ssl;

    gboolean           ssl_started;

    LmProxy           *proxy;

    GIOChannel        *io_channel;

    GSource           *watch_in;

    GSource           *watch_err;

    GSource           *watch_hup;

    LmOldSocketT       fd;

    GSource           *watch_connect;

    gboolean           cancel_open;

    GSource           *watch_out;

    GString           *out_buf;

    LmConnectData     *connect_data;

    IncomingDataFunc   data_func;

    SocketClosedFunc   closed_func;

    ConnectResultFunc  connect_func;

    gpointer           user_data;

    guint              ref_count;

    LmResolver        *resolver;

#ifdef HAVE_ASYNCNS

    GSource           *watch_resolv;

    asyncns_query_t   *resolv_query;

    asyncns_t         *asyncns_ctx;

    GIOChannel        *resolv_channel;

#endif

}; 

static void         socket_free                    (LmOldSocket    *socket);

static gboolean     socket_do_connect              (LmConnectData  *connect_data);

static gboolean     socket_connect_cb              (GIOChannel     *source, 

                                                    GIOCondition    condition,

                                                    LmConnectData  *connect_data);

static gboolean     socket_in_event                (GIOChannel     *source,

                                                    GIOCondition    condition,

                                                    LmOldSocket    *socket);

static gboolean     socket_hup_event               (GIOChannel     *source,

                                                    GIOCondition    condition,

                                                    LmOldSocket    *socket);

static gboolean     socket_error_event             (GIOChannel     *source,

                                                    GIOCondition    condition,

                                                    LmOldSocket    *socket);

static gboolean     socket_buffered_write_cb       (GIOChannel     *source, 

                                                    GIOCondition    condition,

                                                    LmOldSocket    *socket);

static void         socket_close_io_channel        (GIOChannel     *io_channel);

static gboolean     old_socket_output_is_buffered  (LmOldSocket    *socket,

                                                    const gchar    *buffer,

                                                    gint            len);

static void         old_socket_setup_output_buffer (LmOldSocket    *socket,

                                                    const gchar    *buffer,

                                                    gint            len);

static void

socket_free (LmOldSocket *socket)

{

    g_free (socket->server);

    g_free (socket->domain);

    if (socket->ssl) {

        lm_ssl_unref (socket->ssl);

    }

    if (socket->proxy) {

        lm_proxy_unref (socket->proxy);

    }

    if (socket->out_buf) {

        g_string_free (socket->out_buf, TRUE);

    }

    if (socket->resolver) {

        g_object_unref (socket->resolver);

    }

    g_free (socket);

}

static gint

old_socket_do_write (LmOldSocket *socket, const gchar *buf, guint len)

{

    gint b_written;

    if (socket->ssl_started) {

        b_written = _lm_ssl_send (socket->ssl, buf, len);

    } else {

        GIOStatus io_status = G_IO_STATUS_AGAIN;

        gsize     bytes_written;

        while (io_status == G_IO_STATUS_AGAIN) {

            io_status = g_io_channel_write_chars (socket->io_channel, 

                                                  buf, len, 

                                                  &bytes_written,

                                                  NULL);

        }

        b_written = bytes_written;

        if (io_status != G_IO_STATUS_NORMAL) {

            b_written = -1;

        }

    }

    return b_written;

}

gint

lm_old_socket_write (LmOldSocket *socket, const gchar *buf, gint len)

{

    gint b_written;

    if (old_socket_output_is_buffered (socket, buf, len)) {

        return len;

    }

    b_written = old_socket_do_write (socket, buf, len);

    if (b_written < len && b_written != -1) {

        old_socket_setup_output_buffer (socket,

                                        buf + b_written,

                                        len - b_written);

        return len;

    }

    return b_written;

}

static gboolean

socket_read_incoming (LmOldSocket *socket,

                      gchar    *buf,

                      gsize     buf_size,

                      gsize    *bytes_read,

                      gboolean *hangup,

                      gint     *reason)

{

    GIOStatus status;

    *hangup = FALSE;

    if (socket->ssl_started) {

        status = _lm_ssl_read (socket->ssl, 

                               buf, buf_size - 1, bytes_read);

    } else {

        status = g_io_channel_read_chars (socket->io_channel,

                                          buf, buf_size - 1,

                                          bytes_read,

                                          NULL);

    }

    if (status != G_IO_STATUS_NORMAL || *bytes_read < 0) {

        switch (status) {

        case G_IO_STATUS_EOF:

            *reason = LM_DISCONNECT_REASON_HUP;

            break;

        case G_IO_STATUS_AGAIN:

            /* No data readable but we didn't hangup */

            return FALSE;

            break;

        case G_IO_STATUS_ERROR:

            *reason = LM_DISCONNECT_REASON_ERROR;

            break;

        default:

            *reason = LM_DISCONNECT_REASON_UNKNOWN;

        }

        /* Notify connection_in_event that we hangup the connection */

        *hangup = TRUE;

        return FALSE;

    }

    buf[*bytes_read] = '\0';

    /* There is more data to be read */

    return TRUE;

}

static gboolean

socket_in_event (GIOChannel   *source,

                 GIOCondition  condition,

                 LmOldSocket     *socket)

{

    gchar    buf[IN_BUFFER_SIZE];

    gsize    bytes_read = 0;

    gboolean read_anything = FALSE;

    gboolean hangup = 0;

    gint     reason = 0;

    if (!socket->io_channel) {

        return FALSE;

    }

    while ((condition & G_IO_IN) && socket_read_incoming (socket, buf, IN_BUFFER_SIZE, 

                                                          &bytes_read, &hangup, &reason)) {

        g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "\nRECV [%d]:\n", 

               (int)bytes_read);

        g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

               "-----------------------------------\n");

        g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "'%s'\n", buf);

        g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

               "-----------------------------------\n");

        lm_verbose ("Read: %d chars\n", (int)bytes_read);

        (socket->data_func) (socket, buf, socket->user_data);

        read_anything = TRUE;

        condition = g_io_channel_get_buffer_condition (socket->io_channel);

    }

    /* If we have read something, delay the hangup so that the data can be

     * processed. */

    if (hangup && !read_anything) {

        (socket->closed_func) (socket, reason, socket->user_data);

        return FALSE;

    }

    return TRUE;

}

static gboolean

socket_hup_event (GIOChannel   *source,

                  GIOCondition  condition,

                  LmOldSocket     *socket)

{

    lm_verbose ("HUP event: %d->'%s'\n", 

                condition, lm_misc_io_condition_to_str (condition));

    if (!socket->io_channel) {

        return FALSE;

    }

    (socket->closed_func) (socket, LM_DISCONNECT_REASON_HUP, 

                           socket->user_data);

    return TRUE;

}

static gboolean

socket_error_event (GIOChannel   *source,

                    GIOCondition  condition,

                    LmOldSocket     *socket)

{

    lm_verbose ("ERROR event: %d->'%s'\n", 

                condition, lm_misc_io_condition_to_str (condition));

    if (!socket->io_channel) {

        return FALSE;

    }

    (socket->closed_func) (socket, LM_DISCONNECT_REASON_ERROR, 

                           socket->user_data);

    return TRUE;

}

static gboolean

_lm_old_socket_ssl_init (LmOldSocket *socket, gboolean delayed)

{

    GError *error = NULL;

    const gchar *ssl_verify_domain = NULL;

    lm_verbose ("Setting up SSL...\n");

    _lm_ssl_initialize (socket->ssl);

#ifdef HAVE_GNUTLS

    /* GNU TLS requires the socket to be blocking */

    _lm_sock_set_blocking (socket->fd, TRUE);

#endif

    /* If we're using StartTLS, the correct thing is to verify against

     * the domain. If we're using old SSL, we should verify against the

     * hostname. */

    if (delayed)

        ssl_verify_domain = socket->domain;

    else

        ssl_verify_domain = socket->server;

    if (!_lm_ssl_begin (socket->ssl, socket->fd, ssl_verify_domain, &error)) {

        lm_verbose ("Could not begin SSL\n");

        if (error) {

            g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

                   "%s\n", error->message);

            g_error_free (error);

        }

        _lm_sock_shutdown (socket->fd);

        _lm_sock_close (socket->fd);

        if (!delayed && socket->connect_func) {

            (socket->connect_func) (socket, FALSE, socket->user_data);

        }

        return FALSE;

    }

#ifdef HAVE_GNUTLS

    _lm_sock_set_blocking (socket->fd, FALSE); 

#endif

    socket->ssl_started = TRUE;

    return TRUE;

}

gboolean

lm_old_socket_starttls (LmOldSocket *socket)

{

    g_return_val_if_fail (lm_ssl_get_use_starttls (socket->ssl) == TRUE, FALSE);

    return _lm_old_socket_ssl_init (socket, TRUE);

}

void

_lm_old_socket_succeeded (LmConnectData *connect_data)

{

    LmOldSocket *socket;

    socket = connect_data->socket;

    if (socket->watch_connect) {

        g_source_destroy (socket->watch_connect);

        socket->watch_connect = NULL;

    }

    /* Need some way to report error/success */

    if (socket->cancel_open) {

        lm_verbose ("Cancelling connection...\n");

        if (socket->connect_func) {