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

/*

 * Copyright (C) 2003-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.

 */

/**

 * SECTION:lm-connection

 * @Title: LmConnection

 * @Short_description: A client connection to the server

 *

 * An example of how to use Loudmouth with the synchronous API.

 * <informalexample><programlisting>

 * int

 * main (int argc, char **argv)

 * {

 *      LmConnection *connection;

 *      GError       *error = NULL;

 *      gint          i;

 *      LmMessage    *m;

 *

 *      connection = lm_connection_new ("myserver");

 *

 *      if (!lm_connection_open_and_block (connection, &error)) {

 *          g_error ("Failed to open: %s\n", error->message);

 *      }

 *

 *      if (!lm_connection_authenticate_and_block (connection,

 *                                                 "username", "password",

 *                                                 "resource",

 *                                                 &error)) {

 *          g_error ("Failed to authenticate: %s\n", error->message);

 *      }

 *

 *      m = lm_message_new ("recipient", LM_MESSAGE_TYPE_MESSAGE);

 *      lm_message_node_add_child (m->node, "body", "message");

 *

 *      if (!lm_connection_send (connection, m, &error)) {

 *          g_error ("Send failed: %s\n", error->message);

 *      }

 *

 *      lm_message_unref (m);

 *

 *      lm_connection_close (connection, NULL);

 *      lm_connection_unref (connection);

 *

 *      return 0;

 * }

 * </programlisting></informalexample>

 */

#include <config.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

/* Needed on Mac OS X */

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#include <arpa/nameser.h>

#include <resolv.h>

#include <glib-object.h>

#include "lm-data-objects.h"

#include "lm-sock.h"

#include "lm-debug.h"

#include "lm-error.h"

#include "lm-feature-ping.h"

#include "lm-internals.h"

#include "lm-message-queue.h"

#include "lm-misc.h"

#include "lm-ssl-internals.h"

#include "lm-parser.h"

#include "lm-sha.h"

#include "lm-connection.h"

#include "lm-utils.h"

#include "lm-old-socket.h"

#include "lm-sasl.h"

typedef struct {

    LmHandlerPriority  priority;

    LmMessageHandler  *handler;

} HandlerData;

struct _LmConnection {

    /* Parameters */

    GMainContext      *context;

    /* TODO: Clean up this and make some parameter object for server, jid, effective jid etc */

    gchar             *server;

    gchar             *jid;

    gchar             *effective_jid;

    guint              port;

    LmOldSocket       *socket;

    LmSSL             *ssl;

    LmProxy           *proxy;

    LmParser          *parser;

    gchar             *stream_id;

    GHashTable        *id_handlers;

    GSList            *handlers[LM_MESSAGE_TYPE_UNKNOWN];

    /* XMPP1.0 stuff (SASL, resource binding, StartTLS) */

    gboolean           use_sasl;

    LmSASL            *sasl;

    gchar             *resource;

    LmMessageHandler  *features_cb;

    LmMessageHandler  *starttls_cb;

    gboolean           tls_started;

    /* Communication */

    guint              open_id;

    LmCallback        *open_cb;

    gboolean           cancel_open;

    LmCallback        *auth_cb;

    LmCallback        *disconnect_cb;

    LmMessageQueue    *queue;

    LmConnectionState  state;

    /* TODO: Move the rate to use the one in LmFeaturePing instead of keeping the two in sync */

    guint              keep_alive_rate;

    LmFeaturePing     *feature_ping;

    gint               ref_count;

};

typedef enum {

    AUTH_TYPE_PLAIN  = 1,

    AUTH_TYPE_DIGEST = 2,

    AUTH_TYPE_0K     = 4

} AuthType;

#define XMPP_NS_BIND "urn:ietf:params:xml:ns:xmpp-bind"

#define XMPP_NS_SESSION "urn:ietf:params:xml:ns:xmpp-session"

#define XMPP_NS_STARTTLS "urn:ietf:params:xml:ns:xmpp-tls"

static void     connection_free              (LmConnection        *connection);

static void     connection_handle_message    (LmConnection        *connection,

                                              LmMessage           *message);

static void     connection_new_message_cb    (LmParser            *parser,

                                              LmMessage           *message,

                                              LmConnection        *connection);

static gboolean connection_do_open           (LmConnection        *connection,

                                              GError             **error);

void            connection_do_close          (LmConnection        *connection);

static LmMessage *

connection_create_auth_req_msg               (LmAuthParameters    *auth_params);

static LmMessage *

connection_create_auth_msg                   (LmConnection        *connection,

                                              LmAuthParameters    *auth_params,

                                              gint                 auth_type);

static LmHandlerResult

connection_auth_req_reply                    (LmMessageHandler    *handler,

                                              LmConnection        *connection,

                                              LmMessage           *m,

                                              gpointer             user_data);

static int      connection_check_auth_type   (LmMessage           *auth_req_rpl);

static LmHandlerResult

connection_auth_reply                        (LmMessageHandler    *handler,

                                              LmConnection        *connection,

                                              LmMessage           *m,

                                              gpointer             user_data);

static void     connection_stream_received   (LmConnection        *connection,

                                              LmMessage           *m);

static void     connection_stream_error      (LmConnection        *connection,

                                              LmMessage           *m);

static gint

connection_handler_compare_func              (HandlerData         *a,

                                              HandlerData         *b);

static void     connection_start_keep_alive  (LmConnection        *connection);

static void     connection_stop_keep_alive   (LmConnection        *connection);

static gboolean connection_send              (LmConnection        *connection,

                                              const gchar         *str,

                                              gint                 len,

                                              GError             **error);

static void     connection_message_queue_cb  (LmMessageQueue      *queue,

                                              LmConnection        *connection);

static void

connection_signal_disconnect                 (LmConnection        *connection,

                                              LmDisconnectReason   reason);

static void     connection_incoming_data     (LmOldSocket         *socket,

                                              const gchar         *buf,

                                              LmConnection        *connection);

static void     connection_socket_closed_cb  (LmOldSocket            *socket,

                                              LmDisconnectReason   reason,

                                              LmConnection        *connection);

static void

connection_socket_connect_cb                 (LmOldSocket         *socket,

                                              gboolean             result,

                                              LmConnection        *connection);

static gboolean

connection_get_server_from_jid               (const gchar         *jid,

                                              gchar              **server);

static void

connection_send_stream_header                (LmConnection        *connection);

static LmHandlerResult

connection_features_cb                       (LmMessageHandler    *handler,

                                              LmConnection        *connection,

                                              LmMessage           *message,

                                              gpointer             user_data);

static gboolean connection_old_auth          (LmConnection        *connection,

                                              LmAuthParameters    *auth_params,

                                              GError             **errror);

static void

connection_free_handlers (LmConnection *connection)

{

    int i;

    /* Unref handlers */

    for (i = 0; i < LM_MESSAGE_TYPE_UNKNOWN; ++i) {

        GSList *l;

        for (l = connection->handlers[i]; l; l = l->next) {

            HandlerData *hd = (HandlerData *) l->data;

            lm_message_handler_unref (hd->handler);

            g_free (hd);

        }

        g_slist_free (connection->handlers[i]);

    }

}

static void

connection_free (LmConnection *connection)

{

    /* This needs to be run before starting to free internal states.

     * It used to be run after the handlers where freed which lead to a crash

     * when the connection was freed prior to running lm_connection_close.

     */

    if (connection->state >= LM_CONNECTION_STATE_OPENING) {

        connection_do_close (connection);

    }

    g_free (connection->server);

    g_free (connection->jid);

    g_free (connection->effective_jid);

    g_free (connection->stream_id);

    g_free (connection->resource);

    if (connection->sasl) {

        lm_sasl_free (connection->sasl);

    }

    if (connection->parser) {

        lm_parser_free (connection->parser);

    }

    connection_free_handlers (connection);

    g_hash_table_destroy (connection->id_handlers);

    if (connection->open_cb) {

        _lm_utils_free_callback (connection->open_cb);

    }

    if (connection->auth_cb) {

        _lm_utils_free_callback (connection->auth_cb);

    }

    lm_connection_set_disconnect_function (connection, NULL, NULL, NULL);

    if (connection->proxy) {

        lm_proxy_unref (connection->proxy);

    }

    lm_message_queue_unref (connection->queue);

    if (connection->context) {

        g_main_context_unref (connection->context);

    }

    if (connection->socket) {

        lm_old_socket_unref (connection->socket);

    }

    g_slice_free (LmConnection, connection);

}

static LmHandlerResult

connection_run_message_handler (LmConnection *connection, LmMessage *m)

{

    LmMessageHandler *handler;

    const gchar      *id;

    LmHandlerResult   result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    id = lm_message_node_get_attribute (m->node, "id");

    if (!id) {

        return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    }

    handler = g_hash_table_lookup (connection->id_handlers, id);

    if (handler) {

        result = _lm_message_handler_handle_message (handler,

                                                     connection,

                                                     m);

        g_hash_table_remove (connection->id_handlers,

                             id);

    }

    return result;

}

static void

connection_handle_message (LmConnection *connection, LmMessage *m)

{

    GSList          *l;

    LmHandlerResult  result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    lm_connection_ref (connection);

    if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM) {

        connection_stream_received (connection, m);

        goto out;

    }

    result = connection_run_message_handler (connection, m);

    if (result == LM_HANDLER_RESULT_REMOVE_MESSAGE) {

        goto out;

    }

    for (l = connection->handlers[lm_message_get_type (m)];

         l && result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

         l = l->next) {

        HandlerData *hd = (HandlerData *) l->data;

        result = _lm_message_handler_handle_message (hd->handler,

                                                     connection,

                                                     m);

    }

    if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM_ERROR) {

        connection_stream_error (connection, m);

        goto out;

    }

 out:

    lm_connection_unref (connection);

    return;

}

static void

connection_new_message_cb (LmParser     *parser,

                           LmMessage    *m,

                           LmConnection *connection)

{

    const gchar *from;

    lm_message_ref (m);

    from = lm_message_node_get_attribute (m->node, "from");

    if (!from) {

        from = "unknown";

    }

    lm_verbose ("New message with type=\"%s\" from: %s\n",

                _lm_message_type_to_string (lm_message_get_type (m)),

                from);

    lm_message_queue_push_tail (connection->queue, m);

}

static void

connection_ping_timed_out (LmFeaturePing *fp, LmConnection *connection)

{

    connection_do_close (connection);

    connection_signal_disconnect (connection,

                                  LM_DISCONNECT_REASON_PING_TIME_OUT);

}

static void

connection_start_keep_alive (LmConnection *connection)

{

    if (connection->feature_ping) {

        connection_stop_keep_alive (connection);

    }

    connection->feature_ping = g_object_new (LM_TYPE_FEATURE_PING,