/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

/*

 * Copyright (C) 2003-2005 Imendio AB

 *

 * 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 <unistd.h>

#include <sys/types.h>

#include <fcntl.h>

#include <errno.h>

#ifndef __WIN32__

  #include <netdb.h>

  #include <sys/socket.h>

  #include <netinet/in.h>

  #include <sys/time.h>

#else

  #include <winsock2.h>

#endif

#include "lm-debug.h"

#include "lm-error.h"

#include "lm-internals.h"

#include "lm-parser.h"

#include "lm-sha.h"

#include "lm-connection.h"

#define IN_BUFFER_SIZE 1024

typedef struct {

	LmHandlerPriority  priority;

	LmMessageHandler  *handler;

} HandlerData;

typedef struct {

	GSource       source;

	LmConnection *connection;

} LmIncomingSource;

struct _LmConnection {

	/* Parameters */

	GMainContext *context;

	gchar        *server;

	gchar        *jid;

	guint         port;

	LmSSL        *ssl;

	LmProxy      *proxy;

	LmParser     *parser;

	gchar        *stream_id;

	GHashTable   *id_handlers;

	GSList       *handlers[LM_MESSAGE_TYPE_UNKNOWN];

	/* Communication */

	GIOChannel   *io_channel;

	guint         io_watch_in;

	guint         io_watch_err;

	guint         io_watch_hup;

	guint         fd;

	guint         io_watch_connect;

	guint         open_id;

	LmCallback   *open_cb;

	gboolean      cancel_open;

	LmCallback   *close_cb;

	LmCallback   *auth_cb;

	LmCallback   *register_cb;

	LmCallback   *disconnect_cb;

	GQueue       *incoming_messages;

	GSource      *incoming_source;

	LmConnectionState state;

	guint         keep_alive_rate;

	guint         keep_alive_id;

	guint         io_watch_out;

	GString      *out_buf;

	gint          ref_count;

};

typedef enum {

	AUTH_TYPE_PLAIN  = 1,

	AUTH_TYPE_DIGEST = 2,

	AUTH_TYPE_0K     = 4

} AuthType;

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

static void     connection_do_close           (LmConnection        *connection);

static gint     connection_do_write          (LmConnection         *connection,

					      const gchar          *buf,

					      gint                  len);

static gboolean connection_in_event          (GIOChannel   *source,

					      GIOCondition  condition,

					      LmConnection *connection);

static gboolean connection_error_event       (GIOChannel   *source,

					      GIOCondition  condition,

					      LmConnection *connection);

static gboolean connection_hup_event         (GIOChannel   *source,

					      GIOCondition  condition,

					      LmConnection *connection);

static gboolean connection_send              (LmConnection         *connection,

					      const gchar          *str,

					      gint                  len,

					      GError               **error);

static LmMessage *     connection_create_auth_req_msg (const gchar *username);

static LmMessage *     connection_create_auth_msg     (LmConnection *connection,

						       const gchar  *username,

						       const gchar  *password,

						       const gchar  *resource,

						       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 gint     connection_handler_compare_func (HandlerData  *a,

						 HandlerData  *b);

static gboolean connection_incoming_prepare  (GSource         *source,

					      gint            *timeout);

static gboolean connection_incoming_check    (GSource         *source);

static gboolean connection_incoming_dispatch (GSource         *source,

					      GSourceFunc      callback,

					      gpointer           user_data);

static GSource * connection_create_source       (LmConnection *connection);

static void      connection_signal_disconnect   (LmConnection *connection,

						 LmDisconnectReason reason);

static void     connection_do_connect           (LmConnectData *connect_data);

static guint    connection_add_watch            (LmConnection  *connection,

						 GIOChannel    *channel,

						 GIOCondition   condition,

						 GIOFunc        func,

						 gpointer       user_data);

static gboolean connection_send_keep_alive      (LmConnection  *connection);

static void     connection_start_keep_alive     (LmConnection  *connection);

static void     connection_stop_keep_alive      (LmConnection  *connection);

static gboolean connection_buffered_write_cb    (GIOChannel    *source, 

						 GIOCondition   condition,

						 LmConnection  *connection);

static gboolean connection_output_is_buffered   (LmConnection  *connection,

						 const gchar   *buffer,

						 gint           len);

static void     connection_setup_output_buffer  (LmConnection  *connection,

						 const gchar   *buffer,

						 gint           len);

static GSourceFuncs incoming_funcs = {

	connection_incoming_prepare,

	connection_incoming_check,

	connection_incoming_dispatch,

	NULL

};

static void

connection_free (LmConnection *connection)

{

	int        i;

	LmMessage *m;

	g_free (connection->server);

	g_free (connection->jid);

	/* 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]);

	}

	g_hash_table_destroy (connection->id_handlers);

	if (connection->state >= LM_CONNECTION_STATE_OPENING) {

		connection_do_close (connection);

	}

	while ((m = g_queue_pop_head (connection->incoming_messages)) != NULL) {

		lm_message_unref (m);

	}

	if (connection->ssl) {

		lm_ssl_unref (connection->ssl);

	}

	g_queue_free (connection->incoming_messages);

        if (connection->context) {

                g_main_context_unref (connection->context);

        }

	if (connection->out_buf) {

		g_string_free (connection->out_buf, TRUE);

	}

        g_free (connection);

}

static void

connection_handle_message (LmConnection *connection, LmMessage *m)

{

	LmMessageHandler *handler;

	GSList           *l;

	const gchar      *id;

	LmHandlerResult   result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

	if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM) {

		connection_stream_received (connection, m);

		return;

	}

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

	if (id) {

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

		}

	}

	if (result == LM_HANDLER_RESULT_REMOVE_MESSAGE) {

		return;

	}

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

	}

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

	g_queue_push_tail (connection->incoming_messages, m);

}

gboolean

_lm_connection_succeeded (LmConnectData *connect_data)

{

	LmConnection *connection;

	LmMessage    *m;

	GIOFlags      flags;

	gchar        *server_from_jid;

	gchar        *ch;

	connection = connect_data->connection;

	if (connection->io_watch_connect != 0) {

		g_source_destroy (g_main_context_find_source_by_id(connection->context,

								   connection->io_watch_connect));

		connection->io_watch_connect = 0;

	}

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

	if (connection->cancel_open) {

		return FALSE;

	}

	connection->fd = connect_data->fd;

	connection->io_channel = connect_data->io_channel;

	freeaddrinfo (connect_data->resolved_addrs);

	/* don't need this anymore */

	g_free(connect_data);

	flags = g_io_channel_get_flags (connection->io_channel);

	/* unset the nonblock flag */

	flags &= ~G_IO_FLAG_NONBLOCK;

	/* unset the nonblocking stuff for some time, because GNUTLS doesn't 

	 * like that */

	g_io_channel_set_flags (connection->io_channel, flags, NULL);

	if (connection->ssl) {

		if (!_lm_ssl_begin (connection->ssl, connection->fd,

				    connection->server,

				    NULL)) {

			shutdown (connection->fd, SHUT_RDWR);

			close (connection->fd);

			connection_do_close (connection);

			return FALSE;

		}

	}

	g_io_channel_set_close_on_unref (connection->io_channel, TRUE);

	g_io_channel_set_encoding (connection->io_channel, NULL, NULL);

	g_io_channel_set_buffered (connection->io_channel, FALSE);

	g_io_channel_set_flags (connection->io_channel,

				flags & G_IO_FLAG_NONBLOCK, NULL);

	connection->io_watch_in = 

		connection_add_watch (connection,

				      connection->io_channel,

				      G_IO_IN,

				      (GIOFunc) connection_in_event,

				      connection);

	connection->io_watch_err = 

		connection_add_watch (connection,

				      connection->io_channel, 

				      G_IO_ERR,

				      (GIOFunc) connection_error_event,

						   connection);

	connection->io_watch_hup = 

		connection_add_watch (connection,

				      connection->io_channel,

				      G_IO_HUP,

				      (GIOFunc) connection_hup_event,

				      connection);

	/* FIXME: Set up according to XMPP 1.0 specification */

	/*        StartTLS and the like */

	if (!connection_send (connection, 

			      "<?xml version='1.0' encoding='UTF-8'?>", -1,

			      NULL)) {

		connection_do_close (connection);

		return FALSE;

	}

	if (connection->jid != NULL && (ch = strchr (connection->jid, '@')) != NULL) {

		server_from_jid = ch + 1;

	} else {

		server_from_jid = connection->server;

	}

	m = lm_message_new (server_from_jid, LM_MESSAGE_TYPE_STREAM);

	lm_message_node_set_attributes (m->node,

					"xmlns:stream", 

					"http://etherx.jabber.org/streams",