#include <config.h>

#include <string.h>

#include "lm-debug.h"

#include "lm-internals.h"

#include "lm-misc.h"

#include "lm-ssl.h"

#include "lm-ssl-internals.h"

#include "lm-proxy.h"

#include "lm-socket.h"

#include "lm-sock.h"

#include "lm-error.h"

#define IN_BUFFER_SIZE 1024

#define MIN_PORT 1

#define MAX_PORT 65536

	LmConnection *connection;

	GMainContext *context;

	gchar        *server;

	guint         port;

	gboolean      blocking;

	LmSSL        *ssl;

	LmProxy      *proxy;

	GIOChannel   *io_channel;

	GSource      *watch_in;

	GSource      *watch_err;

	GSource      *watch_hup;

	LmSocketT      fd;

	GSource      *watch_connect;

	gboolean      cancel_open;

	GSource      *watch_out;

	GString      *out_buf;

	LmConnectData *connect_data;

	IncomingDataFunc func;

	gpointer         user_data;

	guint          ref_count;

}; 

static void         socket_free                 (LmSocket      *socket);

static void         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,

					      LmSocket     *socket);

static gboolean socket_hup_event         (GIOChannel   *source,

					      GIOCondition  condition,

					      LmSocket     *socket);

static gboolean

socket_buffered_write_cb (GIOChannel   *source, 

			      GIOCondition  condition,

			      LmSocket     *socket);

	g_free (socket->server);

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

gint

lm_socket_do_write (LmSocket     *socket,

		     const gchar  *buf,

		     gint          len)

		gsize     bytes_written;

			io_status = g_io_channel_write_chars (socket->io_channel, 

							      buf, len, 

static gboolean

socket_in_event (GIOChannel   *source,

		     GIOCondition  condition,

		     LmSocket     *socket)

	gchar     buf[IN_BUFFER_SIZE];

	gsize     bytes_read;

	GIOStatus status;

	if (!socket->io_channel) {

		return FALSE;

	}

	if (socket->ssl) {

		status = _lm_ssl_read (socket->ssl, 

				       buf, IN_BUFFER_SIZE - 1, &bytes_read);

	} else {

		status = g_io_channel_read_chars (socket->io_channel,

						  buf, IN_BUFFER_SIZE - 1,

						  &bytes_read,

						  NULL);

	}

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

		gint reason;

		switch (status) {

		case G_IO_STATUS_EOF:

			reason = LM_DISCONNECT_REASON_HUP;

			break;

		case G_IO_STATUS_AGAIN:

			return TRUE;

			break;

		case G_IO_STATUS_ERROR:

			reason = LM_DISCONNECT_REASON_ERROR;

			break;

		default:

			reason = LM_DISCONNECT_REASON_UNKNOWN;

		}

		_lm_connection_do_close (socket->connection);

		_lm_connection_signal_disconnect (socket->connection, reason);

		return FALSE;

	}

	buf[bytes_read] = '\0';

	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->func) (socket, buf, socket->user_data);

	return TRUE;

}

static gboolean

socket_hup_event (GIOChannel   *source,

		      GIOCondition  condition,

		      LmSocket     *socket)

{

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

		    condition, lm_misc_io_condition_to_str (condition));

	if (!socket->io_channel) {

		return FALSE;

	}

	_lm_connection_do_close (socket->connection);

	_lm_connection_signal_disconnect (socket->connection, 

					  LM_DISCONNECT_REASON_HUP);

	return TRUE;

}

void

_lm_socket_succeeded (LmConnectData *connect_data)

{

	LmSocket     *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");

		return;

	}

	socket->fd = connect_data->fd;

	socket->io_channel = connect_data->io_channel;

	freeaddrinfo (connect_data->resolved_addrs);

	socket->connect_data = NULL;

	g_free (connect_data);

	if (socket->ssl) {

		GError *error = NULL;

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

#ifdef HAVE_GNUTLS

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

		_lm_sock_set_blocking (socket->fd, TRUE);

#endif

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

				    socket->server,

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

			_lm_connection_do_close (socket->connection);

			return;

		}

#ifdef HAVE_GNUTLS

		_lm_sock_set_blocking (socket->fd, FALSE); 

#endif

	}

	socket->watch_in = 

		lm_misc_add_io_watch (socket->context,

				      socket->io_channel,

				      G_IO_IN,

				      (GIOFunc) socket_in_event,

				      socket);

	/* FIXME: if we add these, we don't get ANY

	 * response from the server, this is to do with the way that

	 * windows handles watches, see bug #331214.

	 */

#ifndef G_OS_WIN32

	socket->watch_err = 

		lm_misc_add_io_watch (socket->context,

				      socket->io_channel,

				      G_IO_ERR,

				      (GIOFunc) _lm_connection_error_event,

				      socket);

	socket->watch_hup =

		lm_misc_add_io_watch (socket->context,

				      socket->io_channel,

				      G_IO_HUP,

				      (GIOFunc) socket_hup_event,

				      socket);

#endif

	_lm_connection_socket_result (socket->connection, TRUE);

}

void 

_lm_socket_failed_with_error (LmConnectData *connect_data, int error) 

{

	LmSocket *socket;

	g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

	       "Connection failed: %s (error %d)\n",

	       _lm_sock_get_error_str (error), error);

	socket = connect_data->socket;

	connect_data->current_addr = connect_data->current_addr->ai_next;

	if (socket->watch_connect) {

		g_source_destroy (socket->watch_connect);

		socket->watch_connect = NULL;

	}

	if (connect_data->io_channel != NULL) {

		g_io_channel_unref (connect_data->io_channel);

		/* FIXME: need to check for last unref and close the socket */

	}

	if (connect_data->current_addr == NULL) {

		_lm_connection_socket_result (socket->connection, FALSE);

		freeaddrinfo (connect_data->resolved_addrs);

		socket->connect_data = NULL;

		g_free (connect_data);

	} else {

		/* try to connect to the next host */

		socket_do_connect (connect_data);

	}

}

void 

_lm_socket_failed (LmConnectData *connect_data)

{

	_lm_socket_failed_with_error (connect_data, _lm_sock_get_last_error());

}

static gboolean 

socket_connect_cb (GIOChannel   *source, 

		       GIOCondition  condition,

		       LmConnectData *connect_data) 

{

	LmSocket        *socket;

	struct addrinfo *addr;

	int              err;

	socklen_t        len;

	LmSocketT         fd; 

	socket = connect_data->socket;

	addr = connect_data->current_addr;

	fd = g_io_channel_unix_get_fd (source);

	if (condition == G_IO_ERR) {

		len = sizeof (err);

		_lm_sock_get_error (fd, &err, &len);

		if (!_lm_sock_is_blocking_error (err)) {

			g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

			       "Connection failed.\n");

			_lm_socket_failed_with_error (connect_data, err);

			socket->watch_connect = NULL;

			return FALSE;

	if (_lm_connection_async_connect_waiting (socket->connection)) {

		gint res;

		fd = g_io_channel_unix_get_fd (source);

		res = _lm_sock_connect (fd, addr->ai_addr, (int)addr->ai_addrlen);  

		if (res < 0) {

			err = _lm_sock_get_last_error ();

			if (_lm_sock_is_blocking_success (err)) {

				_lm_connection_set_async_connect_waiting (socket->connection, FALSE);

				g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

				       "Connection success (1).\n");

				_lm_socket_succeeded (connect_data);

			}

			if (_lm_connection_async_connect_waiting (socket->connection) &&

			    !_lm_sock_is_blocking_error (err)) {

				g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

				       "Connection failed.\n");

				_lm_sock_close (connect_data->fd);

				_lm_socket_failed_with_error (connect_data, err);

				socket->watch_connect = NULL;

				return FALSE;

			}

		} 

	} else {		

		/* for blocking sockets, G_IO_OUT means we are connected */