/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   tstlmblocks.cpp

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "tstlm.h"

#include "loudmouth/loudmouth.h"

#include <glib.h>

#include <glib/gprintf.h>           // for g_stpcpy

#include <string.h>

#include <stdlib.h>

#include <glowmem.h>

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

#define UNEXIST_PORT 0

#define MYPORT 4321

#define HAVE_OPENSSL

#define FAKEPORT NULL

//You need to use 5223 for ssl+sasl and 5222 for non-ssl+sasl connection

#define GTALK_SSL_PORT 443

#define SSL_INVALID_PORT 999

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

typedef enum

{

	RC_OK,

	RC_ERROR

} RC_Code_t;

typedef struct

{

	gchar *recipient;

	gchar *message;

} MessageData;

typedef struct

{

	gchar      *proxy_server;

	guint       proxy_port;	

}ProxyData;

typedef struct

{

	gchar       *server;

	gchar       *username;

	gchar       *password;		

	gchar       *resource;

	MessageData *msg_data;	

#ifdef __WINSCW__

    ProxyData   *proxy_data;

#endif

} ConnectData;

typedef struct

{

	ConnectData *connect_data;

	GMainLoop   *main_loop;

	RC_Code_t   rCode;	

} AuthData;

typedef struct

{

    GMainLoop *main_loop;

    RC_Code_t Test_Success;	

    int count;

} HandleData;

typedef struct

{

	ConnectData *connect_data;

	LmMessage* message;

	LmMessageHandler* handler;

	GMainLoop   *main_loop;

	RC_Code_t   rCode;	

} SendStreamData;

// ======== MODULE DATA STRUCTURES =========

typedef enum

	{

	XMPP_PRESENCE_TYPE_ONLINE,

	XMPP_PRESENCE_TYPE_CHAT,

	XMPP_PRESENCE_TYPE_AWAY,

	XMPP_PRESENCE_TYPE_XA,

	XMPP_PRESENCE_TYPE_DND,

	XMPP_PRESENCE_TYPE_INVISIBLE,

	XMPP_PRESENCE_TYPE_UNAVAILABLE

	} JabberPresenceType;

// LOCAL FUNCTION PROTOTYPES

// Function to read data from the cfg file

static RC_Code_t read_data ( ConnectData*& connect_data, 

                             CStifItemParser& aItem );

// Function to free the allocated resources

static void free_data ( ConnectData*& connect_data );

// Callback function used in lm_connection_open

static void connection_open_cb ( LmConnection *connection, 

                                 gboolean     success, 

                                 gpointer     data );

static void wrong_input_in_open_cb ( LmConnection *connection, 

                                 gboolean     success, 

                                 gpointer     data );                                 

//Callback function set in lm_connection_authenticate() call

//from lm-connection_send

static void connection_auth_cb ( LmConnection *connection, 

                                 gboolean     success, 

                                 gpointer     data );

//Callback from lm_login_test method after auth

static void lm_login_cb ( LmConnection * connection, 

                     gboolean  success, 

                     gpointer data );

// Callback function called by lm_connection_open in Lm_AuthenticateL

// Will call authenticate method from inside this callback. 

// It uses the correct input data

static void auth_in_connection_cb( LmConnection *connection, 

                              gboolean     success, 

                              gpointer     *data );

// Callback function set in auth_from_open_cb for handling 

//wrong input data during authenticate. Written to handle negative test cases.

static void wrong_input_auth_cb ( LmConnection *connection, 

                                 gboolean     success, 

                                 gpointer     data );

// Callback function set by lm_connection_open call.

//written to handle the negative test cases for authenticate

static void auth_from_open_cb ( LmConnection *connection, 

                              gboolean     success, 

                              gpointer     *data );

// Callback function to handle messages                              

static LmHandlerResult handle_messages ( LmMessageHandler *handler,

                                         LmConnection     *conneciton,

                                         LmMessage        *message,

                                         gpointer         user_data );

static LmHandlerResult handle_100_messages ( LmMessageHandler *handler,

                                         LmConnection     *conneciton,

                                         LmMessage        *message,

                                         gpointer         user_data );

// Callback function called when connection is closed

static void connection_close_cb ( LmConnection       *connection, 

                                  LmDisconnectReason reason,

                                  gpointer           user_data );

// Callback function called when presence is changed

static void jabber_presence_handler_cb ( LmConnection       *connection, 

                                  LmDisconnectReason reason,

                                  gpointer           user_data );                                  

static void message_response_cb ( LmConnection       *connection, 

                                  LmDisconnectReason reason,

                                  gpointer           user_data );                                    

// Get the MessageType in Type

static void GetMessageType ( LmMessageType MessageType, gchar *Type );

// Get MessageSubType in SubType

static void GetMessageSubType ( LmMessageSubType MessageSubType, 

                                gchar *SubType );

// Callback function called if something goes wrong during the connection phase

static LmSSLResponse ssl_cb ( LmSSL       *ssl, 

                              LmSSLStatus status, 

                              gpointer    user_data );

#ifdef __WINSCW__

// Set connection to connect through a proxy

static void SetProxy ( LmConnection *connection, ProxyData *connect_data );

#endif

// Set SSL for connection

static void SSLInit ( LmConnection *connection );

// Returns the username from the JID ( username@domainname/resource )

static gchar *get_user_name ( const gchar *jid );

static JabberPresenceType

jabber_presence_type_from_string ( const gchar *string );

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ==============================

//-----------------------------------------------------------------------------

// function_name	: read_data

// description     	: Reads data from the CFG file

// Returns          : None

//-----------------------------------------------------------------------------

//

static RC_Code_t

read_data ( ConnectData*& connect_data, CStifItemParser& aItem )

    {

	TPtrC               string;

	TBuf8<KMaxFileName> temp;

	MessageData         *msg_data   = NULL;

#ifdef __WINSCW__

	ProxyData           *proxy_data = NULL;

	TInt                proxy_port;

#endif

	connect_data = g_new0 ( ConnectData, 1 );

	if ( !connect_data )

	    {

		return RC_ERROR;

	    }

	msg_data = g_new0 ( MessageData, 1 );

	if ( !msg_data )

	    {

		free_data ( connect_data );

		return RC_ERROR;

	    }

	connect_data->msg_data = msg_data;

#ifdef __WINSCW__

    proxy_data = g_new0 ( ProxyData, 1 );

    if ( !proxy_data ) 

    	{

    	free_data ( connect_data );

    	return RC_ERROR;

    	}

	connect_data->proxy_data = proxy_data;

#endif

	// Read server name

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

		temp.Copy ( string );

		temp.Append ( '\0' );

		connect_data->server = g_new0 ( gchar, temp.Length() );

		if ( !connect_data->server )

		    {			

			free_data ( connect_data );

			return RC_ERROR;

		    }

		g_stpcpy ( connect_data->server, ( gchar * ) temp.Ptr() ); 

	    }

	// Read Username

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->username = g_new0 ( gchar, temp.Length() );

	    if ( !connect_data->username )

	        {	    	

	    	free_data ( connect_data );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->username, ( gchar * ) temp.Ptr() );		    

	    }

	// Read Password corresponding to Username

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->password = g_new0 ( gchar, temp.Length () );		    

	    if ( !connect_data->password )

	        {	    	

	    	free_data ( connect_data );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->password, ( gchar *) temp.Ptr() );

	    }

	// Read recipient

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    msg_data->recipient = g_new0 ( gchar, temp.Length() );

	    if ( !msg_data->recipient )

	        {

	    	free_data ( connect_data );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( msg_data->recipient, ( gchar * ) temp.Ptr() );

	    }

	// Read Message

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );	    

	    msg_data->message = g_new0 ( gchar, temp.Length() );

	    if ( !msg_data->message )

	        {

	    	free_data ( connect_data );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( msg_data->message, ( gchar * ) temp.Ptr() );

	    }

	// Read resource identifier

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->resource = g_new0 ( gchar, temp.Length() );

	    if ( !connect_data->resource )

	        {

	    	free_data ( connect_data );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->resource, ( gchar * ) temp.Ptr() );		    

	    }

#ifdef __WINSCW__

	// Read proxy server and proxy port

    if ( aItem.GetNextString ( string ) == KErrNone )

    	{

    	temp.Copy ( string );

    	temp.Append ( '\0' );

    	proxy_data->proxy_server = g_new0 ( gchar, temp.Length() );

    	if ( !proxy_data->proxy_server )

    		{

    		free_data ( connect_data );

    		return RC_ERROR;

    		}

    	g_stpcpy ( proxy_data->proxy_server, ( gchar * ) temp.Ptr() );

    	}

    	if ( aItem.GetNextInt ( proxy_port ) == KErrNone )

    		{

    		proxy_data->proxy_port = proxy_port;

    		}    	

#endif 

	return RC_OK;

    }

//-----------------------------------------------------------------------------

// function_name	: free_data

// description     	: Deallocates all the data

// Returns          : None

//-----------------------------------------------------------------------------

//

static void

free_data ( ConnectData*& connect_data )

    {

	if ( connect_data )

	    {

		if ( connect_data->server )

		    {

			g_free ( connect_data->server );

			connect_data->server = NULL;

		    }

		if ( connect_data->username )

		    {

			g_free ( connect_data->username );

			connect_data->username = NULL;

		    }

		if ( connect_data->password )

		    {

			g_free ( connect_data->password );

			connect_data->password = NULL;

		    }

		if ( connect_data->msg_data )

		    {

			if ( connect_data->msg_data->recipient )

			    {

				g_free ( connect_data->msg_data->recipient );

				connect_data->msg_data->recipient = NULL;

			    }

			if ( connect_data->msg_data->message )

			    {

				g_free ( connect_data->msg_data->message );

				connect_data->msg_data->message = NULL;

			    }

			g_free ( connect_data->msg_data );

			connect_data->msg_data = NULL;

		    }		

		if ( connect_data->resource )

		    {

			g_free ( connect_data->resource );

			connect_data->resource = NULL;

		    }

	#ifdef __WINSCW__

	    if ( connect_data->proxy_data )

	    	{

	    	if ( connect_data->proxy_data->proxy_server )

	    		{

	    		g_free ( connect_data->proxy_data->proxy_server );

	    		connect_data->proxy_data->proxy_server = NULL;

	    		}

	    	g_free ( connect_data->proxy_data );

	    	connect_data->proxy_data = NULL;	

	    	}

	#endif	     

		g_free ( connect_data );

		connect_data = NULL;    

	    }

    }

//-----------------------------------------------------------------------------

// funnction_name	: connection_open_cb

// description		: callback function called by lm_connection_open

// Returns			: None

//-----------------------------------------------------------------------------

//

static void

connection_open_cb ( LmConnection *connection, 

                     gboolean    success  /*success*/, 

                     gpointer data )

    {

    gboolean result = success ;

    GMainLoop *main_loop = ( GMainLoop * ) data;

	if ( main_loop )

	    {

		g_main_loop_quit ( main_loop );	

	    }		

    /* send whitespace to the server every 30 seconds */

    lm_connection_set_keep_alive_rate (connection, 30);			

    }

//-----------------------------------------------------------------------------

// funnction_name	: wrong_input_in_open_cb

// description		: callback function called by lm_connection_open when the wrong

//input like wrong server , user id etc is given

// Returns			: None

//-----------------------------------------------------------------------------

//

static void

wrong_input_in_open_cb ( LmConnection */*connection*/, 

                     gboolean    success  /*success*/, 

                     gpointer data )

    {

    gboolean result = success;

    AuthData *auth_data = ( AuthData * ) data;

     //Result is false when the wrong input parameters were successfully handled.

    if (result == FALSE)

		{       

		auth_data->rCode = RC_OK;

		}

    else 

    	{

    	//Result is true, when the wrong input was not handled successfully.

       	auth_data->rCode = RC_ERROR;	

    	}

    g_main_loop_quit ( auth_data->main_loop ); 		

    }

//-----------------------------------------------------------------------------

// funnction_name	: wrong_input_auth_cb

// description		: callback function called by lm_connection_open

// Returns			: None

//-----------------------------------------------------------------------------

//

static void

wrong_input_auth_cb ( LmConnection */*connection*/, 

                     gboolean  success, 

                     gpointer data )

    {

    gboolean result = success;

    AuthData *auth_data = ( AuthData * ) data;

    //Result is false when the wrong input parameters were successfully handled.

    if (result == FALSE)

		{       

		auth_data->rCode = RC_OK;

		}

    else 

    	{

    	//Result is true, when the wrong input was not handled successfully.

       	auth_data->rCode = RC_ERROR;	

    	}

    g_main_loop_quit ( auth_data->main_loop );       		

    }

//-----------------------------------------------------------------------------

// funnction_name	: connection_auth_cb

// description		: callback function set by lm_connection_authenticate

// in lm_connection_sendL()

// Returns			: None

//-----------------------------------------------------------------------------