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

/*

 * Copyright (C) 2003-2007 Imendio AB

 *  and/or its subsidiary/subsidiaries. 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/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.h>

#include <gdebug.h>

#include "lm-sock.h"

#include "lm-debug.h"

#include "lm-error.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-socket.h"

#include "lm-sasl.h"

#define IN_BUFFER_SIZE 1024

//#define SRV_LEN 8192

#define SRV_LEN 2048 // check the actual value needed here! - MeCo

typedef struct {

	LmHandlerPriority  priority;

	LmMessageHandler  *handler;

} HandlerData;

struct _LmConnection {

	/* Parameters */

	GMainContext *context;

	gchar        *server;

	gchar        *jid;

	gchar        *effective_jid;

	guint         port;

	gboolean      use_srv;

	LmSocket     *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      async_connect_waiting;

	gboolean      blocking;

	gboolean      cancel_open;

	LmCallback   *auth_cb;

	LmCallback   *disconnect_cb;

	LmMessageQueue *queue;

	LmConnectionState state;

	guint         keep_alive_rate;

	GSource      *keep_alive_source;

	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 (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 void      connection_stream_error         (LmConnection    *connection, 

						  LmMessage       *m);

static gint      connection_handler_compare_func (HandlerData     *a,

						  HandlerData     *b);

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_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        (LmSocket        *socket, 

						  const gchar     *buf,

						  LmConnection    *connection);

static void      connection_socket_closed_cb     (LmSocket        *socket,

						  LmDisconnectReason reason,

						  LmConnection       *connection);

static void      connection_socket_connect_cb    (LmSocket           *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 void

connection_free (LmConnection *connection)

{

	int        i;

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

	}

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

	}

	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_socket_unref (connection->socket);

	}

        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;

	lm_connection_ref (connection);

	lm_verbose("[connection_handle_message]: Inside\n");

	lm_verbose("msg type:[%d]\n", lm_message_get_type (m));

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

	if(id)

		{

		lm_verbose("handlemsg node id: %s\n", id);

		}

	if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM) {

		lm_verbose("[connection_handle_message]: Stream received\n");

		lm_verbose("[connection_handle_message]: calling connection_stream_received \n");

		connection_stream_received (connection, m);

		lm_verbose("[connection_handle_message]: CALLED connection_stream_received \n");

		goto out;

	}

	if ((lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_ERROR) ||

	    (lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_RESULT)) {

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

		lm_verbose("[connection_handle_message]: type is error or result \n");

		if (id) {

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

			if (handler) {

				lm_verbose("[connection_handle_message]: calling the right handler for error/result \n");

				result = _lm_message_handler_handle_message (handler,

									     connection,

									     m);

				lm_verbose("[connection_handle_message]: Called right handler for error/result \n");									     

				g_hash_table_remove (connection->id_handlers,

						    id);

			}

		}

		if (result == LM_HANDLER_RESULT_REMOVE_MESSAGE) {

			lm_verbose("return from connection_handle_message\n");

			goto out;

		}

	}

	lm_verbose("[connection_handle_message]:starting for loop for more handlers\n");

	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;

		lm_verbose("[connection_handle_message]:inside for loop for more handlers with msg type: %d\n", lm_message_get_type (m));

		lm_verbose("[connection_handle_message]:inside for loop with node name: %s\n",lm_message_get_node(m)->name);

		result = _lm_message_handler_handle_message (hd->handler,

							     connection,

							     m);

		lm_verbose("[connection_handle_message]:got result from _lm_message_handler_handle_message as :%d\n",result);

	}

	lm_verbose("[connection_handle_message]:Ended for loop for more handlers\n");

	if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM_ERROR) {

		lm_verbose("[connection_handle_message]:stream error\n");

		connection_stream_error (connection, m);

		goto out;

	}

out:

	lm_verbose("[connection_handle_message]:exiting connection_handle_message\n");

	lm_connection_unref (connection);

	lm_verbose("[connection_handle_message]:after unref of connection\n");

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

	UNUSED_FORMAL_PARAM(parser);

}

static gboolean

connection_send_keep_alive (LmConnection *connection)

{ 

    lm_verbose ("[connection_send_keep_alive]\n");

	if (!connection_send (connection, " ", -1, NULL)) {

		lm_verbose ("Error while sending keep alive package!\n");

	}

	return TRUE;

}

static void

connection_start_keep_alive (LmConnection *connection)

{

	lm_verbose("[connection_start_keep_alive]:Inside ....");

	/* try using TCP keepalives if possible */

	if ((connection->keep_alive_rate > 0) &&

		lm_socket_set_keepalive (connection->socket,

			connection->keep_alive_rate)) {

	lm_verbose("[connection_start_keep_alive]: timer already active\n");

	connection->keep_alive_source =

         lm_misc_add_timeout (connection->context,

                      connection->keep_alive_rate * 1000,

                      (GSourceFunc) connection_send_keep_alive,

                      connection);

		return;

	}

	if (connection->keep_alive_source) {

		lm_verbose("[connection_start_keep_alive]:stopping keep alive timer");

		connection_stop_keep_alive (connection);

	}

	if (connection->keep_alive_rate > 0) {

		connection->keep_alive_source =

			lm_misc_add_timeout (connection->context,

					     connection->keep_alive_rate * 1000,

					     (GSourceFunc) connection_send_keep_alive,

					     connection);

		lm_verbose("[connection_start_keep_alive]: added timer to gsource\n");

	}

lm_verbose("[connection_start_keep_alive]: ...Exiting connection_start_keep_alive....");	 

}

static void

connection_stop_keep_alive (LmConnection *connection)

{

	lm_verbose("[connection_start_keep_alive]:Stopping Keep Alive\n");

	if (connection->keep_alive_source) {

		g_source_destroy (connection->keep_alive_source);

	}

	connection->keep_alive_source = NULL;

}

static gboolean

connection_send (LmConnection  *connection, 

		 const gchar   *str, 

		 gint           len, 

		 GError       **error)

{

	gint b_written;

	if (connection->state < LM_CONNECTION_STATE_OPENING) {

	/*	g_log (LM_LOG_DOMAIN,LM_LOG_LEVEL_NET,

		       "Connection is not open.\n");

		g_set_error (error,

			     LM_ERROR,

			     LM_ERROR_CONNECTION_NOT_OPEN,

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

		lm_verbose("[connection_send]: 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");

	lm_verbose (  "\n[connection_send]: SEND:\n");

	lm_verbose (  "-----------------------------------\n");

	lm_verbose (  "%s\n", str);

	lm_verbose (  "-----------------------------------\n");

	/* Check to see if there already is an output buffer, if so, add to the

	   buffer and return */

	if (lm_socket_output_is_buffered (connection->socket, str, len)) {

		return TRUE;

	}

	b_written = lm_socket_do_write (connection->socket, str, len);

	lm_verbose("[connection_send]: number of bytes written using lm_socket_do_write is : %d\n",b_written);

	if (b_written < 0) {

		lm_verbose("[connection_send]: Since b_written<0 closing the connection\n");

		connection_do_close (connection);

		connection_signal_disconnect (connection, 

		                     LM_DISCONNECT_REASON_ERROR);

		g_set_error (error,

			     LM_ERROR,

			     LM_ERROR_CONNECTION_FAILED,

			     "Server closed the connection");

		return FALSE;

	}

	if (b_written < len) {

		lm_socket_setup_output_buffer (connection->socket, 

						str + b_written, 

						len - b_written);

	}

	return TRUE;

}

static void

connection_message_queue_cb (LmMessageQueue *queue, LmConnection *connection)

{

	LmMessage *m;

	m = lm_message_queue_pop_nth (connection->queue, 0);

	if (m) {

	    lm_verbose("In connection_message_queue_cb\n");

		connection_handle_message (connection, m);

		lm_message_unref (m);

		lm_verbose("After un refing the message\n");

	}

	UNUSED_FORMAL_PARAM(queue);

}

/* Returns directly */

/* Setups all data needed to start the connection attempts */

static gboolean

connection_do_open (LmConnection *connection, GError **error) 

{

	gchar *domain = NULL;

	if (lm_connection_is_open (connection)) {

		g_set_error (error,

			     LM_ERROR,

			     LM_ERROR_CONNECTION_NOT_OPEN,

			     "Connection is already open, call lm_connection_close() first");

		return FALSE;

	}

	if (!connection_get_server_from_jid (connection->jid, &domain)) {

		domain = g_strdup (connection->server);

	}

	lm_verbose ("[connection_do_open]: Connecting to: %s:%d\n", connection->server, connection->port);

	connection->socket = lm_socket_create (connection->context,

					       (IncomingDataFunc) connection_incoming_data,

					       (SocketClosedFunc) connection_socket_closed_cb,

					       (ConnectResultFunc) connection_socket_connect_cb,

					       connection,

					       connection,

					       connection->blocking,

					       connection->server,

					       domain,

					       connection->port,

					       connection->ssl,

					       connection->proxy,

					       error);

	g_free (domain);

    lm_verbose ("[connection_do_open]: after lm_socket_create call in connection_do_open");

	if (!connection->socket) {

		return FALSE;

	}

	lm_message_queue_attach (connection->queue, connection->context);