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

/*

 * Copyright (C) 2006 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/types.h>

/* Needed on Mac OS X */

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

/* Needed on Mac OS X */

#if HAVE_ARPA_NAMESER_COMPAT_H

#include <arpa/nameser_compat.h>

#endif

#include <arpa/nameser.h>

#include <resolv.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"

#ifdef HAVE_ASYNCNS

#include <asyncns.h>

#define freeaddrinfo(x) asyncns_freeaddrinfo(x)

#endif

#define IN_BUFFER_SIZE 1024

#define MIN_PORT 1

#define MAX_PORT 65536

//#define SRV_LEN 8192

#define SRV_LEN 512 // check the actual value needed here! - meco

struct _LmSocket {

	LmConnection *connection;

	GMainContext *context;

	gchar        *domain;

	gchar        *server;

	guint         port;

	gboolean      blocking;

	LmSSL        *ssl;

	gboolean      ssl_started;

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

	SocketClosedFunc closed_func;

	ConnectResultFunc connect_func;

	gpointer         user_data;

	guint          ref_count;

#ifdef HAVE_ASYNCNS

	GSource		*watch_resolv;

	asyncns_query_t *resolv_query;

	asyncns_t	*asyncns_ctx;

	GIOChannel	*resolv_channel;

#endif

}; 

static void         socket_free               (LmSocket       *socket);

static gboolean     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_error_event        (GIOChannel     *source,

					       GIOCondition    condition,

					       LmSocket       *socket);

static gboolean     socket_buffered_write_cb  (GIOChannel     *source, 

					       GIOCondition    condition,

					       LmSocket       *socket);

static gboolean     socket_parse_srv_response (unsigned char  *srv, 

					       int             srv_len, 

					       gchar         **out_server, 

					       guint          *out_port);

static void         socket_close_io_channel   (GIOChannel     *io_channel);

static void

socket_free (LmSocket *socket)

{

	g_free (socket->server);

	g_free (socket->domain);

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

	}

	g_free (socket);

}

gint

lm_socket_do_write (LmSocket *socket, const gchar *buf, gint len)

{

	gint b_written;

	gint err;

	if (socket->ssl_started) {

		b_written = _lm_ssl_send (socket->ssl, buf, len);

	} else {

		GIOStatus io_status = G_IO_STATUS_AGAIN;

		gsize     bytes_written;

		while (io_status == G_IO_STATUS_AGAIN) {

			io_status = g_io_channel_write_chars (socket->io_channel, 

							      buf, len, 

							      &bytes_written,

							      NULL);

		}

		b_written = bytes_written;

		if (io_status != G_IO_STATUS_NORMAL) {

			b_written = -1;

		}

	}

	err = _lm_sock_get_last_error ();

	lm_verbose("[lm_socket_do_write]: socket write last error: %d\n\n",err);

	return b_written;

}

static gboolean

socket_read_incoming (LmSocket *socket,

		      gchar    *buf,

		      gsize     buf_size,

		      gsize    *bytes_read,

		      gboolean *hangup,

		      gint     *reason)

{

	GIOStatus status;

	*hangup = FALSE;

	if (socket->ssl_started) {

		status = _lm_ssl_read (socket->ssl, 

				       buf, buf_size - 1, bytes_read);

	} else {

		status = g_io_channel_read_chars (socket->io_channel,

						  buf, buf_size - 1,

						  bytes_read,

						  NULL);

	}

//added by prima

	if (status != G_IO_STATUS_NORMAL ) {

		switch (status) {

		case G_IO_STATUS_EOF:

			*reason = LM_DISCONNECT_REASON_HUP;

			break;

		case G_IO_STATUS_AGAIN:

			/* No data readable but we didn't hangup */

			return FALSE;

		//	break;

		case G_IO_STATUS_ERROR:

			*reason = LM_DISCONNECT_REASON_ERROR;

			break;

		default:

			*reason = LM_DISCONNECT_REASON_UNKNOWN;

		}

		/* Notify connection_in_event that we hangup the connection */

		*hangup = TRUE;

		return FALSE;

	}

	if(*bytes_read>0)

		{

		buf[*bytes_read] = '\0';	

		return TRUE;

		}	

	/* There is more data to be read */

	return FALSE;

	//return TRUE;

}

static gboolean

socket_in_event (GIOChannel   *source,

		     GIOCondition  condition,

		     LmSocket     *socket)

{

	gchar     buf[IN_BUFFER_SIZE];

	gsize     bytes_read = 0;

	gboolean  read_anything = FALSE;

	gboolean  hangup = 0;

	gint      reason = 0;

	if (!socket->io_channel) {

		lm_verbose ( "[socket_in_event]:Error in io_channel\n");

		return FALSE;

	}

	while (/*(condition & G_IO_IN) && */socket_read_incoming (socket, buf, IN_BUFFER_SIZE, 

				     &bytes_read, &hangup, &reason)) {

		//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 ("\n[socket_in_event]: RECV [%d]:\n", (int)bytes_read);

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

		lm_verbose ("'%s'\n", buf);

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

		lm_verbose ("Read: %d chars\n", (int)bytes_read);

		(socket->data_func) (socket, buf, socket->user_data);

		read_anything = TRUE;

		//condition = g_io_channel_get_buffer_condition (socket->io_channel);

	}

	/* If we have read something, delay the hangup so that the data can be

	 * processed. */

	if (hangup && !read_anything) {

		(socket->closed_func) (socket, reason, socket->user_data);

		lm_verbose ( "[socket_in_event]:Error in hangup && !read_anything\n");

		return FALSE;

	}

lm_verbose ( "[socket_in_event]:Returning TRUE\n");

	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;

	}

	(socket->closed_func) (socket, LM_DISCONNECT_REASON_HUP, 

			       socket->user_data);

	return TRUE;

}

static gboolean

socket_error_event (GIOChannel   *source,

		    GIOCondition  condition,

		    LmSocket     *socket)

{

	gint err =0;

	lm_verbose ("[socket_error_event]: ERROR event: %d->'%s'\n", 

		    condition, lm_misc_io_condition_to_str (condition));

	err = _lm_sock_get_last_error ();

	lm_verbose("[socket_error_event]: socket write last error: %d\n\n",err);

	if (!socket->io_channel) {

		return FALSE;

	}

	(socket->closed_func) (socket, LM_DISCONNECT_REASON_ERROR, 

			       socket->user_data);

	return TRUE;

}

static gboolean

_lm_socket_ssl_init (LmSocket *socket, gboolean delayed)

{

	GError *error = NULL;

	const gchar *ssl_verify_domain = NULL;

	lm_verbose ("[_lm_socket_ssl_init] Setting up SSL...\n");

	_lm_ssl_initialize (socket->ssl);

#ifdef HAVE_GNUTLS

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

	_lm_sock_set_blocking (socket->fd, TRUE);

#endif

	/* If we're using StartTLS, the correct thing is to verify against

	 * the domain. If we're using old SSL, we should verify against the

	 * hostname. */

	if (delayed)

		ssl_verify_domain = socket->domain;

	else

		ssl_verify_domain = socket->server;

	if (!_lm_ssl_begin (socket->ssl, socket->fd, ssl_verify_domain, &error)) {

		lm_verbose ("Could not begin SSL\n");

		if (error) {

			/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,

				"%s\n", error->message);

			*/

			lm_verbose("[_lm_socket_ssl_init]: %s\n", error->message);

				g_error_free (error);

		}

		lm_verbose("\n[_lm_socket_ssl_init]: shutting down the socket");

		_lm_sock_shutdown (socket->fd);

		_lm_sock_close (socket->fd);

		if (!delayed && socket->connect_func) {

			lm_verbose("\n[_lm_socket_ssl_init]: calling the socket connect callback if ssl begin failed");

			(socket->connect_func) (socket, FALSE, socket->user_data);

		}

		return FALSE;

	}

#ifdef HAVE_GNUTLS

	_lm_sock_set_blocking (socket->fd, FALSE); 

#endif

	socket->ssl_started = TRUE;

  return TRUE;

}

gboolean

lm_socket_starttls (LmSocket *socket)

{

	g_return_val_if_fail (lm_ssl_get_use_starttls (socket->ssl) == TRUE, FALSE);

	return _lm_socket_ssl_init (socket, TRUE);

}

void

_lm_socket_succeeded (LmConnectData *connect_data)

{

	LmSocket     *socket;

	socket = connect_data->socket;

	lm_verbose ("\n[_lm_socket_succeeded]:inside.. \n");

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

		if (socket->connect_func) {

			(socket->connect_func) (socket, FALSE, socket->user_data);

		}

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

	/* old-style ssl should be started immediately */

	if (socket->ssl && (lm_ssl_get_use_starttls (socket->ssl) == FALSE)) {

		if (!_lm_socket_ssl_init (socket, FALSE)) {

			return;

		}

	}

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

	if (socket->connect_func) {

		(socket->connect_func) (socket, TRUE, socket->user_data);

	}

}

gboolean 

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

	lm_verbose( "[_lm_socket_failed_with_error]: Connection failed: %s (error %d)\n",_lm_sock_get_error_str (error), error);

	socket = lm_socket_ref (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) {

		socket_close_io_channel (connect_data->io_channel);

	}

	if (connect_data->current_addr == NULL) {

		if (socket->connect_func) {

			(socket->connect_func) (socket, FALSE, socket->user_data);

		}

		lm_verbose("\n\n[_lm_socket_failed_with_error]: connect_data->current_addr ==NULL");

		 /* if the user callback called connection_close(), this is already freed */

		if (socket->connect_data != NULL) {

			freeaddrinfo (connect_data->resolved_addrs);

			socket->connect_data = NULL;

			g_free (connect_data);

		}

	} else {

		/* try to connect to the next host */

		lm_verbose("\n\n[_lm_socket_failed_with_error]: !!!!Trying to connect to the next host after socket connect failed with error\n");

		return socket_do_connect (connect_data);

	}

	lm_socket_unref(socket);

	return FALSE;

}

gboolean 

_lm_socket_failed (LmConnectData *connect_data)

{

	return _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;

	gboolean         result = FALSE;

	socket = lm_socket_ref (connect_data->socket);

	addr = connect_data->current_addr;

	fd = g_io_channel_unix_get_fd (source);

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

	if (condition == G_IO_ERR) {

		len = sizeof (err);

		_lm_sock_get_error (fd, &err, &len);