/*

* ============================================================================

*  Name        : isogetsearchkeys.c

*  Part of     : isolation server.

*  Version     : %version: 7 %

*

*  Copyright © 2007-2008 Nokia.  All rights reserved.

*  Redistribution and use in source and binary forms, with or without modification, 

*  are permitted provided that the following conditions are met:

*  Redistributions of source code must retain the above copyright notice, this list 

*  of conditions and the following disclaimer.Redistributions in binary form must 

*  reproduce the above copyright notice, this list of conditions and the following 

*  disclaimer in the documentation and/or other materials provided with the distribution.

*  Neither the name of the Nokia Corporation nor the names of its contributors may be used 

*  to endorse or promote products derived from this software without specific prior written 

*  permission.

*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 

*  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 

*  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 

*  SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 

*  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

*  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 

*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 

*  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* ============================================================================

* Template version: 1.0

*/

/*!	\file 

*	Impliments the functions in isosearch.h

*/

/*! \def For malloc

*/

#include <stdlib.h>

/*! \def For string operations

*/

#include <string.h>

/*! \def For search related declarations

*/

#include "isosearch.h"

/*! \def For globalCon

*/

#include "isoservermain.h"

/*! \def For tp_chan_type_search_async

*/

#include "tp-chan-type-search-gen.h"

/*! \def For MSG_PRI_NORMAL

*/

#include "msgqlib.h"

/*! \def For message_hdr_req

*/

#include "isoutils.h"

/*! \def For RESPONSE_QUEUE

*/

#include "msgliterals.h"

#include "isogetsearchkeys.h"

/*!	\struct key_value_struct isoserach.h

*	\brief This struct is used for to form the msg buffer that will be sent to client

*	\var msg As the key/value pairs are read those will be appended to msg

* 	\var len is the no. of bytes appended to msg

*/

struct key_value_struct 

	{

	gchar* msg;

	gint len;		

	};

/*! \typedef struct key_value_struct to key_value_struct

*/	

typedef struct key_value_struct key_value_struct;

/*! \struct get_search_keys_cb_struct isosearch.h

*	\brief This struct bundles multiple(two ?) pointers to be passed

*	to getsearch keys callback

*	\var search_chan which should be closed when search keys are recieved

*	\var hdr_req message header request

*/	

struct get_search_keys_cb_struct 

	{

	TpChan* search_chan;

	message_hdr_req* hdr_req;	

	};

/*! \typedef struct get_search_keys_cb_struct to get_search_keys_cb_struct 

*/		

typedef struct get_search_keys_cb_struct get_search_keys_cb_struct;	

static void getsearchkeys_cb( DBusGProxy *proxy,  gchar *instr,

  gchar **keys, GError *error, gpointer userdata );

/*!	\brief get_search_keys_reply is called as a callback to get_search_keys

*	This function creates a new channel and requests telepathy for the 	

*	search keys

*

*	\param userdata message header request

*

*	\remark calling tp_conn_new_channel results into esock_client 8 panic

*	Instead of calling function tp_conn_new_channel which makes a 

*	a call to tp_conn_request_channel, tp_conn_request_channel_async is 

*	called directly. 

*/	

static void get_search_keys_reply( DBusGProxy *proxy, char *chan_object_path, 

 			GError *error, gpointer user_data )

	{

	TpChan *search_chan = NULL;

	DBusGProxy *search_iface = NULL;

	get_search_keys_cb_struct* chan_struct = NULL;

	message_hdr_resp* hdr_req = ( message_hdr_resp* )user_data;

	UNUSED_FORMAL_PARAM( proxy );

	iso_logger( "in get_search_keys" );

	if ( error )

		{

		send_response_to_client( (message_hdr_req*)hdr_req, error->code, 0 );	

		free ( hdr_req );

		return;			

		}

	//Create new channel for the search

	search_chan = tp_chan_new( globalCon.dbusConn, globalCon.connmgr_bus, chan_object_path, 

	TP_IFACE_CHANNEL_TYPE_CONTACT_SEARCH, TP_CONN_HANDLE_TYPE_NONE, 0 );

	if ( NULL == search_chan ) 

		{

		free ( hdr_req );

		return ;			

		}							

	//Get chan interface					

	search_iface = tp_chan_get_interface( search_chan, 

		TELEPATHY_CHAN_IFACE_CONTACTSEARCH_QUARK );	

	if ( NULL == search_iface ) 

		{

		tp_chan_close_async( DBUS_G_PROXY( search_chan ), 

					search_chan_closed_cb, NULL );

		free ( hdr_req );			

		return ;			

		}

	chan_struct = ( get_search_keys_cb_struct* ) malloc ( 

			sizeof ( get_search_keys_cb_struct ) );

	chan_struct->search_chan = search_chan;

	chan_struct->hdr_req = ( message_hdr_req* ) malloc ( 

							sizeof( message_hdr_req ) );

	if ( NULL == chan_struct->hdr_req ) 

		{

		tp_chan_close_async( DBUS_G_PROXY( search_chan ), 

					search_chan_closed_cb, NULL );

		free ( hdr_req );			

		return ;			

		}							

	//memset( chan_struct->hdr_req, )

	memcpy( chan_struct->hdr_req, hdr_req, sizeof( message_hdr_req ) );

	//Ownership of search_chan and chan_struct->hdr_req, 

	//chan_struct is passed to getsearchkeys_cb

	free ( hdr_req );

	tp_chan_type_search_get_search_keys_async( search_iface, 

				getsearchkeys_cb, chan_struct );		

	iso_logger( "out get_search_keys" );

	}

/*!	\brief Function to get the search keys(fields on which to

*	search ) supported by server

* 	

*	\param hdr_req message header request

*	

*	\return gint MEM_ALLOCATION_ERROR

*/

gint get_search_keys( message_hdr_resp* hdr_req ) 

	{

	message_hdr_resp* hdr_resp = ( message_hdr_resp* ) 

						malloc ( sizeof ( message_hdr_resp ) );

	if ( NULL == hdr_resp )

		{

		return MEM_ALLOCATION_ERROR;		

		}

	memcpy( hdr_resp, hdr_req, sizeof ( message_hdr_resp ) );

	//ownership hdr_resp transfered

	tp_conn_request_channel_async( DBUS_G_PROXY( globalCon.conn ),

	                               TP_IFACE_CHANNEL_TYPE_CONTACT_SEARCH, 

	                               TP_CONN_HANDLE_TYPE_NONE, 0, TRUE,

	                               get_search_keys_reply, (gpointer)hdr_resp ) ;

	return 0;			

	}

/*!	\brief This is a callback to get_search_keys. The search keys

*	are sent to the requested client

*

*	\param proxy unused

*	\param instr instruction on search keys

*	\param keys 2D string array of search keys supported by server

*	\param error Error from server, if any

*	\param userdata get_search_keys_cb_struct 

*/	

static void getsearchkeys_cb( DBusGProxy *proxy,  gchar *instr,

  gchar **keys, GError *error, gpointer userdata )

	{

	get_search_keys_cb_struct * search_struct = ( 

				get_search_keys_cb_struct* )userdata;

	message_hdr_resp hdr_resp;

	gchar* msg = NULL;

	gint i = 0;

	gint len = 0;

	gint pri = MSG_PRI_NORMAL;

	gint result = 0;

	gint timeout = NO_WAIT;

	gint err = 0;

	UNUSED_FORMAL_PARAM( proxy );

	UNUSED_FORMAL_PARAM( instr );

	iso_logger( "in getsearchkeys_cb" );

	tp_chan_close_async( DBUS_G_PROXY( search_struct->search_chan ), 

					search_chan_closed_cb, NULL );

	if ( error ) 

		{

		send_response_to_client( search_struct->hdr_req, error->code, 0 );	

		free ( search_struct->hdr_req );

		free ( search_struct );

		return;

		}

	//Create the response header to be sent to client

	//Copy the message header request

	hdr_resp.hdr_req.message_type = ESearch_Get_Keys;

	hdr_resp.hdr_req.protocol_id = search_struct->hdr_req->protocol_id;

	hdr_resp.hdr_req.request_id = search_struct->hdr_req->request_id;

	hdr_resp.hdr_req.session_id = search_struct->hdr_req->session_id;

	//set continue flag

	hdr_resp.continue_flag = 0;

	hdr_resp.error_type = 0;

	hdr_resp.response = 1;	

	free ( search_struct->hdr_req );

	free ( search_struct );

	//Allocate memory for the message and set memory to '\0'	

	msg = ( gchar* ) malloc ( MAX_PARAM_LEN );

	if ( NULL == msg ) 

		{

		iso_logger( "malloc error @ pairs.msg" );

		return ;			

		}

	memset( msg, '\0', MAX_PARAM_LEN );

	len = 0;

	//Copy the response

	memcpy( msg, &hdr_resp, sizeof ( message_hdr_resp ) );

	len += sizeof( message_hdr_resp );

	iso_logger( "Get search keys : Keys are" );

	while ( keys[i] )

		{

		strcpy( msg + len, keys[i] );

		iso_logger( "Key %d : %s", i, keys[i] );

		len += 	strlen( keys[i] ) + 1;

		i++;

		}

	iso_logger( "Get search keys : Keys End" );

	//End the message with a '\0'

	len++;

	msg[len] = '\0';

	//Send the message to client

	result = MsgQSend( RESPONSE_QUEUE, msg, len, 

						pri, timeout, &err );

	if ( result )

		{

		}

	iso_logger( "out getsearchkeys_cb" );	

	}