/**

  * GMyth Library

  *

  * @file gmyth/gmyth_socket.c

  * 

  * @brief <p> MythTV socket implementation, according to the MythTV Project

  * (www.mythtv.org). 

  * 

  * This component provides basic socket functionalities to interact with

  * the Mythtv backend.

  * <p>

  *

  * Copyright (C) 2006 INdT - Instituto Nokia de Tecnologia.

  * @author Rosfran Lins Borges <rosfran.borges@indt.org.br> 

  *

  *//*

  * 

  * 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 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

  */

 #ifdef HAVE_CONFIG_H

 #  include "config.h"

 #endif

 #include <glib.h> 

 #include <glib/gprintf.h>

 #include <arpa/inet.h>

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <netdb.h>

 #include <net/if.h>

 #include <errno.h>

 #include <stdlib.h>

 #include <unistd.h>

 #include <netinet/in.h>

 #include <fcntl.h>

 #include <signal.h>

 #if defined(HAVE_IFADDRS_H)

 	#include <ifaddrs.h>

 #else

 	#include <sys/ioctl.h>

 #endif

 #include "gmyth_socket.h"

 #include "gmyth_stringlist.h"

 #include "gmyth_context.h"

 #include "gmyth_uri.h"

 #define BUFLEN 				        			512

 #define MYTH_SEPARATOR 			    		"[]:[]"

 #define MYTH_PROTOCOL_FIELD_SIZE		8

 /* max number of iterations */

 #define MYTHTV_MAX_VERSION_CHECKS		40

 static GStaticMutex mutex = G_STATIC_MUTEX_INIT;

 static void gmyth_socket_class_init          (GMythSocketClass *klass);

 static void gmyth_socket_init                (GMythSocket *object);

 static void gmyth_socket_dispose  (GObject *object);

 static void gmyth_socket_finalize (GObject *object);

 G_DEFINE_TYPE(GMythSocket, gmyth_socket, G_TYPE_OBJECT)

 static void

 gmyth_socket_class_init (GMythSocketClass *klass)

 {

     GObjectClass *gobject_class;

     gobject_class = (GObjectClass *) klass;

     gobject_class->dispose  = gmyth_socket_dispose;

     gobject_class->finalize = gmyth_socket_finalize;	

 }

 static void

 gmyth_socket_init (GMythSocket *gmyth_socket)

 {

 }

 /** Gets the some important address translation info, from the client socket

  * that will open a connection.

  * 

  * @return gint that represents the error number from getaddrinfo(). 

  */

 static gint

 gmyth_socket_toaddrinfo( gchar *addr, gint port, struct addrinfo **addrInfo )

 {

     struct addrinfo hints;

     gchar *portStr = g_strnfill( 32, ' ' );

     gint errorn = EADDRNOTAVAIL;

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

     hints.ai_family = AF_INET;

     hints.ai_socktype = SOCK_STREAM;

     /* hints.ai_flags = AI_NUMERICHOST; */

     if ( port != -1 )	

 		sprintf(portStr, "%d", port);

     else

 		portStr = NULL;

     g_debug( "[%s] Address: %s, port: %s\n", __FUNCTION__, addr, portStr );

     if ( ( errorn = getaddrinfo(addr, portStr, &hints, addrInfo) ) != 0 ) {

 		g_printerr( "[%s] Socket ERROR: %s\n", __FUNCTION__, gai_strerror(errorn) );

     }

     return errorn;

 }

 static gint

 gmyth_socket_find_match_address_uri( GMythURI* uri, gchar *address ) {

         if ( g_ascii_strcasecmp( gmyth_uri_gethost( uri ), address ) == 0 ) {

                 //g_printerr( "Found URI: %s !!!\n", rui_uri_getvalue(uri) );

                 return 0;

         } else {

                 return -1;

         }

 }

 #if defined(HAVE_IFADDRS_H)

 /** Gets the list of all local network interfaces.

  * 

  * @param current_connections	A list with all the network interfaces are valid, 

  * 		to be applied just like a filter.

  * @return List with all the local net interfaces. 

  */

 static GList *

 gmyth_socket_get_local_addrs( GList *current_connections ) {

 	GList *local_addrs = NULL;

 	struct ifaddrs *ifaddr;	

 	struct ifaddrs *i;

 	gchar addr[NI_MAXHOST+1];

 	gchar *ifname;

 	gint ifIdx;

 	if (getifaddrs(&ifaddr) != 0)

 	{

 		g_printerr("No addresses for interfaces!\n");

 		return NULL;

 	}

 	for ( i = ifaddr; i != NULL; i = i->ifa_next ) {

 		if (!(i->ifa_flags & IFF_UP))

 			continue;

 		if (i->ifa_flags & IFF_LOOPBACK)

 			continue;

 		if ( getnameinfo(i->ifa_addr, sizeof(struct sockaddr), addr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0 ) {

 			ifname = i->ifa_name;

 			ifIdx = if_nametoindex(ifname);

 			/* g_debug( "[%s] Interface name: %s, index: %d, address: %s\n", __FUNCTION__, ifname, ifIdx, addr ); */

 			if ( current_connections == NULL || ( current_connections != NULL && 

 					g_list_find_custom( current_connections, (gchar *)addr, 

 						(GCompareFunc)gmyth_socket_find_match_address_uri ) == NULL ) )

 				local_addrs = g_list_append( local_addrs, g_strdup( addr ) );

 		}

 	} /* iterates over network interfaces */

 	freeifaddrs(ifaddr);

 	return local_addrs;

 }

 #else

 static const char *PATH_PROC_NET_DEV = "/proc/net/dev";

 /** Gets the list of all local network interfaces (using the /proc/net/dev directory).

  * 

  * @param current_connections	A list with all the network interfaces are valid, 

  * 		to be applied just like a filter.

  * @return List with all the local net interfaces. 

  */

 static GList *

 gmyth_socket_get_local_addrs( GList *current_connections )

 {

 	GList *local_addrs = NULL;

 	FILE *fd;

 	gint s;

 	gchar buffer[256+1];

 	gchar ifaddr[20+1];

 	gchar *ifname;

 	gchar *sep;

 	s = socket(AF_INET, SOCK_DGRAM, 0);

 	if (s < 0)

 		return 0;

 	fd = fopen(PATH_PROC_NET_DEV, "r");

 	fgets(buffer, sizeof(buffer)-1, fd);

 	fgets(buffer, sizeof(buffer)-1, fd);

 	while (!feof(fd)) {

 		ifname = buffer;

 		sep;

 		if (fgets(buffer, sizeof(buffer)-1, fd) == NULL)

 			break;

 		sep = strrchr(buffer, ':');

 		if (sep)

 			*sep = 0;

 		while (*ifname == ' ')

 			ifname++;

 		struct ifreq req;

 		strcpy(req.ifr_name, ifname);

 		if (ioctl(s, SIOCGIFFLAGS, &req) < 0)

 			continue;

 		if (!(req.ifr_flags & IFF_UP))

 			continue;

 		if (req.ifr_flags & IFF_LOOPBACK)

 			continue;

 		if (ioctl(s, SIOCGIFADDR, &req) < 0)

 			continue;

 		g_strlcpy( ifaddr, inet_ntoa(((struct sockaddr_in*)&req.ifr_addr)->sin_addr), sizeof(struct ifaddr)-1 );

 		local_addrs = g_list_append( local_addrs, g_strdup( ifaddr ) );

 		g_debug( "[%s] ( from the /proc/net/dev) Interface name: %s, address: %s\n", __FUNCTION__, 

 								ifname, ifaddr );

 	}

 	fclose(fd);

 	close(s);

 	return local_addrs;

 }

 #endif

 /**

  * Get only the local addresses from the primary interface

  */

 static gchar *

 gmyth_socket_get_primary_addr()

 {

 	gchar *if_eth0 = g_new0( gchar, sizeof(struct ifaddr)-1 );

 	GList *if_tmp = NULL;

 	GList *interfs = gmyth_socket_get_local_addrs( NULL );

 	if ( interfs != NULL && ( g_list_length( interfs ) > 0 ) ) 

 	{

 		/* get the first occurrence (primary interface) */

 		if_tmp = g_list_first( interfs );

 		if ( if_tmp != NULL )

 			g_strlcpy( if_eth0, g_strdup( (gchar *)if_tmp->data ), sizeof(struct ifaddr)-1 );

 	}

 	if ( interfs != NULL )

 		g_list_free( interfs );

 	return if_eth0;

 }

 /** This function retrieves the local hostname of the 

  * client machine.

  *

  * @return GString* get local hostname.

  */

 GString *

 gmyth_socket_get_local_hostname( )

 {

     GString *str = g_string_sized_new( 1024 );

     gchar *localhostname = g_strnfill( 1024, ' ' );

     gchar *localaddr = g_strdup( "127.0.0.1" );

     gboolean found_addr = FALSE;

     struct addrinfo* addr_info_data = NULL, *addr_info0 = NULL;

     struct sockaddr_in* sa = NULL;

     gethostname(localhostname, 1024);

     gint err = gmyth_socket_toaddrinfo( localhostname, -1,  &addr_info_data );

     if ( err == EADDRNOTAVAIL )

     {

     	g_warning( "[%s] Address (%s) not available. (reason = %d)\n", __FUNCTION__, localhostname, err );

     	return str;

     }

     g_static_mutex_lock( &mutex );    	

     addr_info0 = addr_info_data;

     while( addr_info0 != NULL && addr_info0->ai_addr != NULL && 

 	    ( sa = (struct sockaddr_in*)addr_info0->ai_addr ) != NULL && !found_addr ) {

     	localaddr = inet_ntoa( sa->sin_addr );

 	    if ( localaddr != NULL && ( g_strrstr( localaddr, "127" ) == NULL ) ) {

 	        str = g_string_assign( str, g_strdup( localaddr ) );

 	        found_addr = TRUE;

 	        break;

 	    }

 	    addr_info0 = addr_info0->ai_next;

     };

     if ( found_addr == FALSE ) {

       gchar *prim_addr = gmyth_socket_get_primary_addr();

     	if ( prim_addr != NULL ) {

 			    g_warning("[%s] Could not determine the local alphanumerical hostname. Setting to %s\n",

     				__FUNCTION__, prim_addr );

 	        str = g_string_assign( str, g_strdup( prim_addr ) );

 	        g_free( prim_addr );

     	} else {

 					str = g_string_assign( str, g_strdup( localhostname ) );

     	}

     }

     g_static_mutex_unlock( &mutex );

     if (localhostname!=NULL)

 	g_free( localhostname );

     return str;

 }

 static void

 gmyth_socket_dispose  (GObject *object)

 {

     GMythSocket *gmyth_socket = GMYTH_SOCKET(object);

     gmyth_socket_close_connection (gmyth_socket);

     /* disconnect socket */

     G_OBJECT_CLASS (gmyth_socket_parent_class)->dispose (object);

 }

 static void

 gmyth_socket_finalize (GObject *object)

 {

     g_signal_handlers_destroy (object);

     G_OBJECT_CLASS (gmyth_socket_parent_class)->finalize (object);

 }

 /** Creates a new instance of GMythSocket.

  * 

  * @return a new instance of GMythSocket.

  */

 GMythSocket*

 gmyth_socket_new ()

 {

     GMythSocket *gmyth_socket = GMYTH_SOCKET (g_object_new(GMYTH_SOCKET_TYPE, NULL));

     gmyth_socket->sd_io_ch = NULL;

     gmyth_socket->hostname = g_strdup("");

     gmyth_socket->port = 6543;

     gmyth_socket->mythtv_version = MYTHTV_VERSION_DEFAULT;

     return gmyth_socket;

 }

 /** Try to open an asynchronous connection to the MythTV backend.

  * 

  * @param fd 			Socket descriptor.

  * @param remote 	Remote address.

  * @param len 		Newly created socket length field.

  * @param timeout	Timeval argument with the time interval to timeout before closing.

  * @param err			Error message number.

  * @return Any numerical value below 0, if an error had been found.

  */

 static gint 

 gmyth_socket_try_connect ( gint fd, struct sockaddr *remote, gint len,

                struct timeval *timeout, gint *err)

 {

 	  gint saveflags, ret, back_err;

 	  fd_set fd_w;

 	  saveflags = fcntl( fd, F_GETFL, 0 );

 	  if( saveflags < 0 ) {

 	    g_warning( "[%s] Problems when getting socket flags on fcntl.\n", __FUNCTION__ );

 	    *err=errno;

 	    return -1;

 	  }

 	  /* Set non blocking */

 	  if( fcntl( fd, F_SETFL, saveflags | O_NONBLOCK ) < 0) {

 	  	g_warning( "[%s] Problems when setting non-blocking using fcntl.\n", __FUNCTION__ );

 	    *err=errno;

 	    return -1;

 	  }

 	  /* This will return immediately */

 	  *err= connect ( fd, remote, len );

 		back_err=errno;

 		/* restore flags */

 	  if( fcntl( fd, F_SETFL, saveflags ) < 0) {

 	    g_warning( "[%s] Problems when trying to restore flags with fcntl.\n", __FUNCTION__ );

 	    *err=errno;

 	    return -1;

 	  }

 	  /* return unless the connection was successful or the connect is

 	     still in progress. */

 	  if( *err < 0 && back_err != EINPROGRESS) {

 	    g_warning( "[%s] Connection unsucessfully (it is not in progress).\n", __FUNCTION__ );

 	    *err = errno;

 	    return -1;

 	  }

 	  FD_ZERO( &fd_w );

 	  FD_SET( fd, &fd_w );

 	  *err = select( FD_SETSIZE, NULL, &fd_w, NULL, timeout);

 	  if ( *err < 0 ) {

 	    g_warning( "[%s] Connection unsucessfull (timed out).\n", __FUNCTION__ );

 	    *err=errno;

 	    return -1;

 	  }

 	  /* 0 means it timeout out & no fds changed */

 	  if(*err==0) {

 	    close(fd);

 	    *err=ETIMEDOUT;

 	    return -1;

 	  }

 	  /* Get the return code from the connect */

 	  len = sizeof( ret );

 	  *err=getsockopt( fd, SOL_SOCKET, SO_ERROR, &ret, &len );

 	  if( *err < 0 ) {

 	    g_warning( "[%s] Connection usnsucessfull.\n", __FUNCTION__ );

 	    *err=errno;

 	    return -1;

 	  }

 	  /* ret=0 means success, otherwise it contains the errno */

 	  if (ret) {

 	    *err=ret;

 	    return -1;

 	  }

 	  *err=0;

 	  return 0;

 }

 /** Connects to the backend.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @param hostname The backend hostname or IP address.

  * @param port The backend port.

  * @return TRUE if success, FALSE if error.

  */

 gboolean

 gmyth_socket_connect (GMythSocket *gmyth_socket,

 	gchar *hostname, gint port)

 {

     struct addrinfo *addr_info_data = NULL, *addr_info0 = NULL;

     gint ret_code = -1;

     gint errno;

     gboolean ret = TRUE;

     if ( hostname == NULL )

 		g_printerr ( "[%s] Invalid hostname parameter!\n", __FUNCTION__ );

     errno = gmyth_socket_toaddrinfo( hostname, port, &addr_info_data );

     g_return_val_if_fail( addr_info_data != NULL, FALSE );

     /* store hostname and port number */

     gmyth_socket->hostname = g_strdup( hostname );

     gmyth_socket->port = port;

     for ( addr_info0 = addr_info_data; addr_info0; addr_info0 = addr_info_data->ai_next ) {

 	struct sockaddr_in *sa = (struct sockaddr_in*)addr_info0->ai_addr;

 	/* init socket descriptor */

 	gmyth_socket->sd = socket( addr_info0->ai_family, addr_info0->ai_socktype,

 				     addr_info0->ai_protocol );

 	if ( gmyth_socket->sd < 0 )

 	    continue;

 	g_debug( "[%s] hostname = %s, sock_fd = %d, addr = %s, addr_len = %d, \

 		ai_family = %d, ai_protocol = %d\n",

 		__FUNCTION__, hostname, gmyth_socket->sd, inet_ntoa( sa->sin_addr ),

 		addr_info0->ai_addrlen, addr_info0->ai_family, addr_info0->ai_protocol );

 	struct timeval *timeout = g_new0( struct timeval, 1 );

 	/* using 40 seconds timeout */

 	timeout->tv_sec = 40;

 	timeout->tv_usec = 0;

 	if ( gmyth_socket_try_connect( gmyth_socket->sd, (struct sockaddr *)addr_info0->ai_addr,

 			addr_info0->ai_addrlen, timeout, &ret_code ) < 0 )

 	{

 	    g_printerr( "[%s] Error connecting to backend!\n", __FUNCTION__ );

 	    if ( ret_code == ETIMEDOUT )

 		g_printerr( "[%s]\tBackend host unreachable!\n", __FUNCTION__ );

 	    g_printerr( "ERROR: %s\n", gai_strerror(ret_code) );

 	    continue;

 	}

 	/* only will be reached if none of the error above occurred */

 	break;

     }

     gmyth_socket->sd_io_ch = g_io_channel_unix_new( gmyth_socket->sd );

     ret = ( ret_code == 0 ) ? TRUE : FALSE ;

     return ret;

 }

 /** Gets the GIOChannel associated to the given GMythSocket.

  * 

  * @param gmyth_socket The GMythSocket instance.

  */

 GIOChannel *

 gmyth_socket_get_io_channel( GMythSocket *gmyth_socket )

 {

     g_return_val_if_fail( gmyth_socket != NULL, NULL );

     return gmyth_socket->sd_io_ch;

 }

 /** Verifies if the socket is able to read.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @return TRUE if the socket is able to read, FALSE if not.

  */

 gboolean

 gmyth_socket_is_able_to_read( GMythSocket *gmyth_socket )

 {

     gboolean ret = TRUE;

     /* verify if the input (read) buffer is ready to receive data */

     GIOCondition io_cond = g_io_channel_get_buffer_condition( gmyth_socket->sd_io_ch );

     if ( ( io_cond & G_IO_IN ) == 0 ) {

 	g_warning ("[%s] IO channel is not able to send data!\n", __FUNCTION__);

 	ret = FALSE;

     }

     return ret;

 }

 /** Verifies if the socket is able to write.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @return TRUE if the socket is able to write, FALSE if not.

  */

 gboolean

 gmyth_socket_is_able_to_write( GMythSocket *gmyth_socket )

 {

     gboolean ret = TRUE;

     /* verify if the input (read) buffer is ready to receive data */

     GIOCondition io_cond = g_io_channel_get_buffer_condition( gmyth_socket->sd_io_ch );

     if ( ( ( io_cond & G_IO_OUT ) == 0 ) || ( ( io_cond & G_IO_HUP ) == 0 ) ) {

 	g_warning ("[%s] IO channel is not able to send data!\n", __FUNCTION__);

 	ret = FALSE;

     }

     return ret;

 }

 /** Sends a command to the backend.

  * 

  * @param gmyth_socket the GMythSocket instance.

  * @param command The string command to be sent.

  */

 gboolean

 gmyth_socket_send_command(GMythSocket *gmyth_socket, GString *command) 

 {

     gboolean ret = TRUE;

     GIOStatus io_status = G_IO_STATUS_NORMAL;

     //GIOCondition io_cond;

     GError* error = NULL;

     gchar *buffer = NULL;

     gsize bytes_written = 0;

     if( command == NULL || ( command->len <= 0 ) || command->str == NULL ) {

 		g_warning ("[%s] Invalid NULL command parameter!\n", __FUNCTION__);

 		ret = FALSE;

 		goto done;

     }

     g_static_mutex_lock( &mutex );

     g_print ("[%s] Sending command to backend: %s\n", __FUNCTION__, command->str);

     /*

        io_cond = g_io_channel_get_buffer_condition( gmyth_socket->sd_io_ch );

        if ( ( io_cond & G_IO_IN ) == 0 ) {

        g_warning ("[%s] IO channel is not able to send data!\n", __FUNCTION__);

        ret = FALSE;

        goto done;

        }

        */

     buffer = g_strnfill( BUFLEN, ' ' );

     snprintf( buffer, MYTH_PROTOCOL_FIELD_SIZE+1, "%-8d", command->len);

     g_print( "[%s] buffer = [%s]\n", __FUNCTION__, buffer  );

     command = g_string_prepend(command, buffer);

     g_print( "[%s] command = [%s]\n", __FUNCTION__, command->str  );

     /* write bytes to socket */    

     io_status = g_io_channel_write_chars( gmyth_socket->sd_io_ch, command->str, 

 	    command->len, &bytes_written, &error );

     if( (io_status == G_IO_STATUS_ERROR) || ( bytes_written <= 0 ) ) {

 		g_warning ("[%s] Error while writing to socket", __FUNCTION__);

 		ret = FALSE;

     } else if ( bytes_written < command->len ) {

 		g_warning ("[%s] Not all data was written socket", __FUNCTION__);

 		ret = FALSE;

     }

     io_status = g_io_channel_flush( gmyth_socket->sd_io_ch, &error );

     if ( ( bytes_written != command->len ) || ( io_status == G_IO_STATUS_ERROR ) )

     {

 		g_warning ("[%s] Some problem occurred when sending data to the socket\n", __FUNCTION__);

 		ret = TRUE;

     }

     g_static_mutex_unlock( &mutex );

 done:

     if ( error != NULL ) {

 		g_printerr( "[%s] Error found reading data from IO channel: (%d, %s)\n", __FUNCTION__, error->code, error->message );

 		ret = FALSE;

 		g_error_free( error );

     }

     if ( buffer!= NULL )

 		g_free( buffer );

     return ret;

 }

 /** Starts Mythtv protocol level connection. Checks Mythtv protocol version

  * supported by the backend and send the "ANN" command.

  * 

  * @param gmyth_socket the GMythSocket instance.

  * @param hostname_backend The backend hostname or IP address.

  * @param port The backend port to connect.

  * @param blocking_client A flag to choose between blocking and non-blocking 

  * backend connection.

  */

 gboolean

 gmyth_socket_connect_to_backend (GMythSocket *gmyth_socket, 

 	gchar *hostname_backend, int port, gboolean blocking_client)

 {

     if (!gmyth_socket_connect (gmyth_socket, hostname_backend, port)) {

 		g_warning ("[%s] Could not open socket to backend machine", __FUNCTION__);

 		return FALSE;

     }

     if ( gmyth_socket_check_protocol_version (gmyth_socket) ) {

 	GString *result;

 	GString *base_str = g_string_new("");

 	GString *hostname = NULL;

 	hostname = gmyth_socket_get_local_hostname();

 	g_string_printf(base_str, "ANN %s %s 0", 

 		(blocking_client ? "Playback" : "Monitor"),

 		hostname->str);

 	g_debug ("[%s] Connection command sent to backend: %s", __FUNCTION__, base_str->str);

 	gmyth_socket_send_command (gmyth_socket, base_str);

 	result = gmyth_socket_receive_response(gmyth_socket);

 	if (result != NULL) {

 	    g_debug ("[%s] Response received from backend: %s", __FUNCTION__, result->str);

 	    g_string_free (result, TRUE);

 	}

 	g_string_free (hostname, TRUE);

 	g_string_free (base_str, TRUE);

 	return TRUE;

     } else {

 	g_warning ("[%s] GMythSocket could not connect to the backend", __FUNCTION__);	

 	return FALSE;

     }

 }

 /** Closes the socket connection to the backend.

  * 

  * @param gmyth_socket The GMythSocket instance.

  */

 void

 gmyth_socket_close_connection (GMythSocket *gmyth_socket)

 {

     close (gmyth_socket->sd);	

 }

 /** Try the MythTV version numbers, and get the version returned by

  * the possible REJECT message, in order to contruct a new

  * MythTV version request.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @param mythtv_version The Mythtv protocol version to be tested

  * 

  * @return The actual MythTV the client is connected to.

  */

 gint

 gmyth_socket_check_protocol_version_number (GMythSocket *gmyth_socket, gint mythtv_version)

 {

     GString *response;

     GString *payload;

     gchar *new_version = g_strdup("");

     gboolean res = TRUE;

     gint mythtv_new_version = MYTHTV_CANNOT_NEGOTIATE_VERSION;

     guint max_iterations = MYTHTV_MAX_VERSION_CHECKS;

 try_new_version:

     payload = g_string_new ("MYTH_PROTO_VERSION");

     g_string_append_printf( payload, " %d", mythtv_version );

     gmyth_socket_send_command(gmyth_socket, payload);

     response = gmyth_socket_receive_response(gmyth_socket);

     if (response == NULL) {

 		g_warning ("[%s] Check protocol version error! Not answered!", __FUNCTION__);

 		res = FALSE;	

 		goto done;

     }

     res = g_str_has_prefix (response->str, "ACCEPT");

     if (!res) {

 		g_warning ("[%s] Protocol version request error: %s", __FUNCTION__, response->str);

 	/* get the version number returned by the REJECT message */

 	if ( ( res = g_str_has_prefix (response->str, "REJECT") ) == TRUE ) {

 	    new_version = g_strrstr( response->str, "]" );

 	    if (new_version!=NULL) {

 		++new_version; /* skip ']' character */

 		if ( new_version != NULL ) {

 		    g_print( "[%s] got MythTV version = %s.\n", __FUNCTION__, new_version );

 		    mythtv_version = (gint)g_ascii_strtoull( g_strdup( new_version ), NULL, 10 );

 		    /* do reconnection to the socket (socket is closed if the MythTV version was wrong) */

 		    gmyth_socket_connect( gmyth_socket, gmyth_socket->hostname, gmyth_socket->port );

 		    /* g_free( new_version ); */

 		    if ( --max_iterations > 0 ) 

 		    	goto try_new_version;

 		    else

 		    	goto done;

 		}

 	    }

 	}

     }

     /* change the return value to a valid one */

     if ( res ) {

     	mythtv_new_version = mythtv_version;

     	gmyth_socket->mythtv_version = mythtv_new_version;

     }

 done:

     if ( payload != NULL )

 		g_string_free (payload, TRUE);

     if ( response != NULL )

 		g_string_free (response, TRUE);

     return mythtv_new_version;

 }

 /** Verifies if the Mythtv backend supported the GMyth supported version.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @return TRUE if supports, FALSE if not.

  */

 gboolean

 gmyth_socket_check_protocol_version (GMythSocket *gmyth_socket)

 {

     return ( ( gmyth_socket->mythtv_version = 

     		gmyth_socket_check_protocol_version_number ( gmyth_socket, 

     							MYTHTV_VERSION_DEFAULT ) ) != MYTHTV_CANNOT_NEGOTIATE_VERSION );

 }

 /** Returns the Mythtv backend supported version.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @return The actual MythTV version number.

  */

 gint

 gmyth_socket_get_protocol_version (GMythSocket *gmyth_socket) 

 {

 	return gmyth_socket->mythtv_version;

 }

 /** Receives a backend answer after a gmyth_socket_send_command_call ().

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @return The response received, or NULL if error or nothing was received.

  */

 GString*

 gmyth_socket_receive_response(GMythSocket *gmyth_socket)

 {

     GIOStatus io_status = G_IO_STATUS_NORMAL;

     GError* error = NULL;

     gchar *buffer = NULL;

     GString *str = NULL;

     gsize bytes_read = 0;

     gint  len = 0;

     GIOCondition io_cond;

     g_return_val_if_fail( gmyth_socket != NULL, NULL );

     /* verify if the input (read) buffer is ready to receive data */

     buffer = g_strnfill( BUFLEN, ' ' );

     g_static_mutex_lock( &mutex );

     io_status = g_io_channel_read_chars( gmyth_socket->sd_io_ch, buffer, MYTH_PROTOCOL_FIELD_SIZE, &bytes_read, &error );

     /* verify if the input (read) buffer is ready to receive data */

     io_cond = g_io_channel_get_buffer_condition( gmyth_socket->sd_io_ch );

     g_print ( "[%s] Bytes read = %d\n", __FUNCTION__, bytes_read );

     if( (io_status == G_IO_STATUS_ERROR) || (bytes_read <= 0) ) {

 		g_warning ("[%s] Error in mythprotocol response from backend\n", __FUNCTION__);

 		str = NULL;

 		//return NULL;

     } else {

 		io_status = g_io_channel_flush( gmyth_socket->sd_io_ch, &error );

 		/* verify if the input (read) buffer is ready to receive data */

 		io_cond = g_io_channel_get_buffer_condition( gmyth_socket->sd_io_ch );

 		if ( ( io_cond & G_IO_IN ) != 0 ) {

 		    snprintf( buffer, MYTH_PROTOCOL_FIELD_SIZE+1, "%-8s", g_strdup(buffer));

 		    g_print( "[%s] buffer = [%s]\n", __FUNCTION__, buffer  );

 		    /* removes trailing whitespace */

 		    buffer = g_strstrip( buffer );

 		    len = (gint)g_ascii_strtoull ( buffer, NULL, 10 );  

 		    bytes_read = 0;

 		    io_status = g_io_channel_read_chars( gmyth_socket->sd_io_ch, buffer, len, &bytes_read, &error );

 		    buffer[bytes_read] = '\0';

 		}

     }  

     g_static_mutex_unlock( &mutex );

     g_debug ("[%s] Response received from backend: {%s}\n", __FUNCTION__, buffer);

     if ( ( bytes_read != len ) || ( io_status == G_IO_STATUS_ERROR ) )

 		str = NULL;

     else

 		str = g_string_new( buffer );

     if ( buffer != NULL )

 		g_free( buffer );

     if ( error != NULL ) {

 		g_printerr( "[%s] Error found receiving response from the IO channel: (%d, %s)\n", __FUNCTION__, error->code, error->message );

 		str = NULL;

 		g_error_free( error );

     }

     return str;

 }

 /** Format a Mythtv command from the str_list entries and send it to backend.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @param str_list The string list to form the command

  * @return TRUE if command was sent, FALSE if any error happens.

  */

 gboolean

 gmyth_socket_write_stringlist(GMythSocket *gmyth_socket, GMythStringList* str_list)

 {

     GList *tmp_list;

     GPtrArray *ptr_array;

     gchar *str_array;

     g_static_mutex_lock( &mutex );

     ptr_array = g_ptr_array_sized_new(g_list_length(str_list->glist));

     g_print( "[%s] Number of parameters = %d\n", __FUNCTION__, g_list_length(str_list->glist) );    

     // FIXME: change this implementation!

     tmp_list = str_list->glist;

     for(; tmp_list; tmp_list = tmp_list->next) {

 	if ( tmp_list->data != NULL )

 	    g_ptr_array_add(ptr_array, ((GString*)tmp_list->data)->str);

     }

     g_ptr_array_add(ptr_array, NULL); // g_str_joinv() needs a NULL terminated string

     str_array = g_strjoinv (MYTH_SEPARATOR, (gchar **) (ptr_array->pdata));

     g_static_mutex_unlock( &mutex );

     g_print( "[%s]\t\tSending the String list = %s\n", __FUNCTION__, str_array );

     // Sends message to backend	

     // TODO: implement looping to send remaining data, and add timeout testing!

     gmyth_socket_send_command(gmyth_socket, g_string_new(str_array));

     g_free (str_array);

     g_ptr_array_free (ptr_array, TRUE);

     return TRUE;

 }

 /* Receives a backend command response and split it into the given string list.

  * 

  * @param gmyth_socket The GMythSocket instance.

  * @param str_list the string list to be filled.

  * @return The number of received strings.

  */

 gint

 gmyth_socket_read_stringlist (GMythSocket *gmyth_socket, GMythStringList* str_list)

 {

     GString *response;

     gchar **str_array;

     gint i;

     response = gmyth_socket_receive_response(gmyth_socket);

     g_static_mutex_lock( &mutex );

     gmyth_string_list_clear_all (str_list);	

     str_array = g_strsplit (response->str, MYTH_SEPARATOR, -1);

     for (i=0; i< g_strv_length (str_array); i++) {

 	gmyth_string_list_append_string (str_list, g_string_new (str_array[i]));

     }

     g_static_mutex_unlock( &mutex );

     g_string_free (response, TRUE);

     g_strfreev (str_array);

     return gmyth_string_list_length (str_list);

 }

 /** Formats a Mythtv protocol command based on str_list and sends it to

  * the connected backend. The backend response is overwritten into str_list.

  *

  * @param gmyth_socket The GMythSocket instance.

  * @param str_list The string list to be sent, and on which the answer 

  * will be written.

  * @return TRUE if command was sent and an answer was received, FALSE if any

  * error happens.

  */

 gint

 gmyth_socket_sendreceive_stringlist (GMythSocket *gmyth_socket, GMythStringList *str_list)

 {

     gmyth_socket_write_stringlist (gmyth_socket, str_list);

     return gmyth_socket_read_stringlist (gmyth_socket, str_list);

 }