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

/*

 * Copyright (C) 2003 Mikael Hallendal <micke@imendio.com>

 * Copyright (C) 2003 CodeFactory 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 "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 */

	gchar      *server;

	guint       port;

	gboolean    use_ssl;

	gboolean    is_open;

	gboolean    is_authenticated;

	LmParser   *parser;

	gchar      *stream_id;

	GHashTable *id_handlers;

	GSList     *handlers[LM_MESSAGE_TYPE_UNKNOWN];

	/* Communication */

	GIOChannel *io_channel;

	LmCallback *open_cb;

	LmCallback *close_cb;

	LmCallback *auth_cb;

	LmCallback *register_cb;

	LmCallback *disconnect_cb;

	GQueue     *incoming_messages;

	GSource    *incoming_source;

	gint        ref_count;

};

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 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 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 GSourceFuncs incoming_funcs = {

	connection_incoming_prepare,

	connection_incoming_check,

	connection_incoming_dispatch,

	NULL

};

static void

connection_free (LmConnection *connection)

{

	g_free (connection->server);

	if (connection->io_channel) {

		g_io_channel_unref (connection->io_channel);

	}

	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)

{

	lm_message_ref (m);

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

		    _lm_message_type_to_string (lm_message_get_type (m)),

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

	g_queue_push_tail (connection->incoming_messages, m);

}

static gboolean

connection_do_open (LmConnection *connection, GError **error)

{

	struct hostent     *he;

        struct in_addr     *haddr;

        struct sockaddr_in  saddr;

	gint                fd;

	g_return_val_if_fail (connection != NULL, FALSE);

        he = gethostbyname(connection->server);

        if (he == NULL) {

 		g_set_error (error,

 			     LM_ERROR,                 

 			     LM_ERROR_CONNECTION_OPEN,   

 			     "gethostbyname() failed");

		return FALSE;

        }

        haddr = ((struct in_addr *) (he->h_addr_list)[0]);

        fd = socket(AF_INET, SOCK_STREAM, 0);

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

        memcpy(&saddr.sin_addr, haddr, sizeof(struct in_addr));

        saddr.sin_family = AF_INET;

        saddr.sin_port = htons (connection->port);

        if (connect(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {

 		g_set_error (error,

 			     LM_ERROR,           

 			     LM_ERROR_CONNECTION_OPEN,

 			     "connect() failed");

		close (fd);

		return FALSE;

        }

	connection->io_channel = g_io_channel_unix_new (fd);

	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,

				G_IO_FLAG_NONBLOCK, NULL);

	g_io_add_watch (connection->io_channel,

			G_IO_IN,

			(GIOFunc) connection_in_event,

			connection);

	g_io_add_watch (connection->io_channel, 

			G_IO_ERR,

			(GIOFunc) connection_error_event,

			connection);

	g_io_add_watch (connection->io_channel,

			G_IO_HUP,

			(GIOFunc) connection_hup_event,

			connection);

	connection->is_open = TRUE;

	if (!connection_send (connection,

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

			      error)) {

		return FALSE;

	}

	return TRUE;

}

static void

connection_do_close (LmConnection *connection)

{

	if (connection->io_channel) {

		g_io_channel_unref (connection->io_channel);

	}

	connection->io_channel = NULL;

	connection->is_open = FALSE;

}

static gboolean

connection_in_event (GIOChannel   *source,

		     GIOCondition  condition,

		     LmConnection *connection)

{

	gchar             buf[IN_BUFFER_SIZE];

	gsize             bytes_read;

	if (!connection->io_channel) {

		return FALSE;

	}

	g_io_channel_read_chars (connection->io_channel,

				 buf, IN_BUFFER_SIZE - 1,

				 &bytes_read,

				 NULL);

	buf[bytes_read] = '\0';

	g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "\nRECV:\n");

	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_parser_parse (connection->parser, buf);

	return TRUE;

}

static gboolean

connection_error_event (GIOChannel   *source,

			GIOCondition  condition,

			LmConnection *connection)

{

	lm_verbose ("Error event: %d\n", condition);

	connection_do_close (connection);

	connection_signal_disconnect (connection, LM_DISCONNECT_REASON_ERROR);

	return TRUE;

}

static gboolean

connection_hup_event (GIOChannel   *source,

		      GIOCondition  condition,

		      LmConnection *connection)

{

	lm_verbose ("HUP event\n");

	connection_do_close (connection);

	connection_signal_disconnect (connection, LM_DISCONNECT_REASON_HUP);

	return TRUE;

}

static gboolean

connection_send (LmConnection  *connection, 

		 const gchar   *str, 

		 gint           len, 

		 GError       **error)

{

	gsize             bytes_written;

	if (!lm_connection_is_open (connection)) {

		g_set_error (error,

			     LM_ERROR,

			     LM_ERROR_CONNECTION_NOT_OPEN,

			     "Connection is not open, call lm_connection_open() first");

		return FALSE;

	}

	if (len == -1) {

		len = strlen (str);

	}

	g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "\nSEND:\n");

	g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

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

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

	g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

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

	g_io_channel_write_chars (connection->io_channel, str, len, 

				  &bytes_written, NULL);

	return TRUE;

}

static LmHandlerResult 

connection_auth_reply (LmMessageHandler *handler,

		       LmConnection     *connection,

		       LmMessage        *m,

		       gpointer          user_data)

{

	const gchar *type;

	gboolean     result = TRUE;

	g_return_val_if_fail (connection != NULL, 

			      LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS);

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

	if (strcmp (type, "result") == 0) {

		result = TRUE;

	} 

	else if (strcmp (type, "error") == 0) {

		result = FALSE;

	}

	lm_verbose ("AUTH reply: %d\n", result);

	if (connection->auth_cb && connection->auth_cb->func) {

		LmCallback *cb = connection->auth_cb;

		(* ((LmResultFunction) cb->func)) (connection, 

						   result, cb->user_data);

	}

	_lm_utils_free_callback (connection->auth_cb);

	connection->auth_cb = NULL;

	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static void

connection_stream_received (LmConnection *connection, LmMessage *m)

{

	gboolean result;

	g_return_if_fail (connection != NULL);

	g_return_if_fail (m != NULL);

	connection->stream_id = g_strdup (lm_message_node_get_attribute (m->node,

									 "id"));;

	lm_verbose ("Stream received: %s\n", connection->stream_id);

	/* Check to see if the stream is correctly set up */

	result = TRUE;

	if (connection->open_cb && connection->open_cb->func) {