diff -r 000000000000 -r d0f3a028347a loudmouth/tsrc/src/tstlmBlocks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loudmouth/tsrc/src/tstlmBlocks.cpp Tue Feb 02 01:10:06 2010 +0200 @@ -0,0 +1,14822 @@ +/* +* 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 +#include +#include +#include "tstlm.h" + +#include "loudmouth/loudmouth.h" +#include +#include // for g_stpcpy +#include +#include + +#include + +// 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 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 +//----------------------------------------------------------------------------- +// +static void connection_auth_cb ( LmConnection */*connection*/, + gboolean /*success*/, + gpointer data ) + { + GMainLoop *main_loop = ( GMainLoop * ) data; + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + } + +//----------------------------------------------------------------------------- +// function_name : auth_in_connection_cb +// description : callback function called for lm_connection_open +// Returns : RC_OK if successfull, RC_ERROR otherwise +//----------------------------------------------------------------------------- +static void +auth_in_connection_cb ( LmConnection *connection, + gboolean success, + gpointer *data ) + { + AuthData *auth_data = ( AuthData * ) data; + + if ( !success ) + { + // Connection failed + auth_data->rCode = RC_ERROR; + g_main_loop_quit ( auth_data->main_loop ); + } + + // Extract the username from the JID + gchar *username = get_user_name ( auth_data->connect_data->username ); + + if ( !lm_connection_authenticate ( connection, + username, + auth_data->connect_data->password, + auth_data->connect_data->resource, + NULL, + auth_data->connect_data->msg_data, + NULL, + NULL ) ) + { + auth_data->rCode = RC_ERROR; + g_free ( username ); + g_main_loop_quit ( auth_data->main_loop ); + } + g_free ( username ); + + auth_data->rCode = RC_OK; + g_main_loop_quit ( auth_data->main_loop ); + + } + +//----------------------------------------------------------------------------- +// function_name : auth_from_open_cb +// description : callback function called for lm_connection_authenticate +// Returns : RC_OK if successfull, RC_ERROR otherwise +//----------------------------------------------------------------------------- +static void +auth_from_open_cb ( LmConnection *connection, + gboolean success, + gpointer *data ) + { + AuthData *auth_data = ( AuthData * ) data; + + if ( !success ) + { + // Connection failed + auth_data->rCode = RC_ERROR; + g_main_loop_quit ( auth_data->main_loop ); + } + + // Extract the username from the JID + gchar *username = get_user_name ( auth_data->connect_data->username ); + + if ( !lm_connection_authenticate ( connection, + username, + auth_data->connect_data->password, + auth_data->connect_data->resource, + ( LmResultFunction ) wrong_input_auth_cb, + auth_data , + NULL, + NULL ) ) + { + auth_data->rCode = RC_ERROR; + g_free ( username ); + g_main_loop_quit ( auth_data->main_loop ); + } + g_free ( username ); + + } + + +//-------------------------------------------------------------------------------- +// function_name : handle_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_messages ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* /*message*/, + gpointer user_data ) + { + HandleData *handle_data = ( HandleData * )user_data; + + if ( handle_data ) + { + handle_data->Test_Success = RC_OK; + + g_main_loop_quit ( handle_data->main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//-------------------------------------------------------------------------------- +// function_name : handle_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_100_messages ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* /*message*/, + gpointer user_data ) + { + HandleData *handle_data = ( HandleData * )user_data; + //static int count=0; + handle_data->count++; + GMainLoop *main_loop = ( GMainLoop * )user_data; + //count++; + if(handle_data->count==5) + { + g_main_loop_quit ( handle_data->main_loop ); + // g_main_loop_quit ( main_loop ); + } + //} + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//-------------------------------------------------------------------------------- +// function_name : handle_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_100_presence_notification ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* /*message*/, + gpointer user_data ) + { + HandleData *handle_data = ( HandleData * )user_data; + handle_data->count++; + GMainLoop *main_loop = ( GMainLoop * )user_data; + if(handle_data->count==100) + { + g_main_loop_quit ( handle_data->main_loop ); + + } + + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//-------------------------------------------------------------------------------- +// function_name : connection_close_cb +// description : callback function called when connection is closed +// Returns : RC_OK if called +//-------------------------------------------------------------------------------- +static void +connection_close_cb ( LmConnection */*connection*/, + LmDisconnectReason reason, + gpointer user_data ) + { + HandleData *handle_data = ( HandleData * ) user_data; + + switch ( reason ) + { + case LM_DISCONNECT_REASON_OK: + handle_data->Test_Success = RC_OK; + break; + case LM_DISCONNECT_REASON_PING_TIME_OUT: + /* No break, fall through */ + case LM_DISCONNECT_REASON_HUP: + case LM_DISCONNECT_REASON_ERROR: + case LM_DISCONNECT_REASON_UNKNOWN: + handle_data->Test_Success = RC_ERROR; + break; + default: + handle_data->Test_Success = RC_ERROR; + break; + } + + } + + +//------------------------------------------------------------------------------ +// function_name : GetMessageType +// description : Gets LmMessageType in Type +// Returns : None +//------------------------------------------------------------------------------ +static void +GetMessageType ( LmMessageType MessageType, gchar *Type ) +{ + switch ( MessageType ) + { + case LM_MESSAGE_TYPE_MESSAGE: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_MESSAGE" ); + break; + case LM_MESSAGE_TYPE_PRESENCE: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_MESSAGE" ); + break; + case LM_MESSAGE_TYPE_IQ: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_IQ" ); + break; + case LM_MESSAGE_TYPE_STREAM: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_STREAM" ); + break; + case LM_MESSAGE_TYPE_STREAM_ERROR: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_STREAM_ERROR" ); + break; + case LM_MESSAGE_TYPE_UNKNOWN: + g_stpcpy ( Type, "LM_MESSAGE_TYPE_UNKNOWN" ); + break; + } +} + + +//------------------------------------------------------------------------------ +// function_name : GetMessageSubType +// description : Gets LmMessageSubType in SubType +// Returns : None +//------------------------------------------------------------------------------ +static void +GetMessageSubType ( LmMessageSubType MessageSubType, gchar *SubType ) +{ + switch ( MessageSubType ) + { + case LM_MESSAGE_SUB_TYPE_NOT_SET: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_NOT_SET" ); + break; + case LM_MESSAGE_SUB_TYPE_AVAILABLE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_AVAILABLE" ); + break; + case LM_MESSAGE_SUB_TYPE_NORMAL: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_NORMAL" ); + break; + case LM_MESSAGE_SUB_TYPE_CHAT: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_CHAT" ); + break; + case LM_MESSAGE_SUB_TYPE_GROUPCHAT: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_GROUPCHAT" ); + break; + case LM_MESSAGE_SUB_TYPE_HEADLINE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_HEADLINE" ); + break; + case LM_MESSAGE_SUB_TYPE_UNAVAILABLE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNAVAILABLE" ); + break; + case LM_MESSAGE_SUB_TYPE_PROBE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_PROBE" ); + break; + case LM_MESSAGE_SUB_TYPE_SUBSCRIBE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SUBSCRIBE" ); + break; + case LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE" ); + break; + case LM_MESSAGE_SUB_TYPE_SUBSCRIBED: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SUBSCRIBED" ); + break; + case LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED" ); + break; + case LM_MESSAGE_SUB_TYPE_GET: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_GET" ); + break; + case LM_MESSAGE_SUB_TYPE_SET: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SET" ); + break; + case LM_MESSAGE_SUB_TYPE_RESULT: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_RESULT" ); + break; + case LM_MESSAGE_SUB_TYPE_ERROR: + g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_ERROR" ); + break; + } +} + + +// --------------------------------------------------------------------------- +// jabber_presence_type_from_string: Returns the presence type +// --------------------------------------------------------------------------- +// +static JabberPresenceType +jabber_presence_type_from_string ( const gchar *string ) + { + + if ( string == NULL ) + return XMPP_PRESENCE_TYPE_ONLINE; + + if ( !strcmp ( string, "online" ) ) + return XMPP_PRESENCE_TYPE_ONLINE; + else if ( !strcmp ( string, "chat" ) ) + return XMPP_PRESENCE_TYPE_CHAT; + else if ( !strcmp ( string, "away" ) ) + return XMPP_PRESENCE_TYPE_AWAY; + else if ( !strcmp ( string, "xa" ) ) + return XMPP_PRESENCE_TYPE_XA; + else if ( !strcmp ( string, "dnd" ) ) + return XMPP_PRESENCE_TYPE_DND; + else if ( !strcmp ( string, "invisible" ) ) + return XMPP_PRESENCE_TYPE_INVISIBLE; + else if ( !strcmp ( string, "unavailable" ) ) + return XMPP_PRESENCE_TYPE_UNAVAILABLE; + else + return XMPP_PRESENCE_TYPE_ONLINE; + } + + +// --------------------------------------------------------------------------- +// function_name : ssl_cb +// description : This function is called if something goes wrong +// during the connecting phase. +// Arguements : +// ssl : An LmSSL +// status : The status informing what went wrong +// user_data : User data provided in the callback +// +// Returns : User should return LM_SSL_RESPONSE_CONTINUE if +// connection should proceed. otherwise +// LM_SSL_RESPONSE_STOP. +// --------------------------------------------------------------------------- +// +static LmSSLResponse +ssl_cb ( LmSSL */*ssl*/, LmSSLStatus status, gpointer /*user_data*/ ) + { + + g_print ( "SSL status :%d\n", status ); + + switch ( status ) + { + case LM_SSL_STATUS_NO_CERT_FOUND: + g_printerr ("No certificate found!\n"); + break; + case LM_SSL_STATUS_UNTRUSTED_CERT: + g_printerr ("Certificate is not trusted!\n"); + break; + case LM_SSL_STATUS_CERT_EXPIRED: + g_printerr ("Certificate has expired!\n"); + break; + case LM_SSL_STATUS_CERT_NOT_ACTIVATED: + g_printerr ("Certificate has not been activated!\n"); + break; + case LM_SSL_STATUS_CERT_HOSTNAME_MISMATCH: + g_printerr ("Certificate hostname does not match expected hostname!\n"); + break; + case LM_SSL_STATUS_CERT_FINGERPRINT_MISMATCH: + g_printerr ( "fingerprint error!\n" ); + break; + case LM_SSL_STATUS_GENERIC_ERROR: + g_printerr ("Generic SSL error!\n"); + break; + } + + return LM_SSL_RESPONSE_CONTINUE; + } + + +// --------------------------------------------------------------------------- +// function_name : SetProxy +// description : Sets the connection to use proxy +// Arguements : +// connection : LmConnection +// connect_data : ConnectData +// Returns : None +// --------------------------------------------------------------------------- +// +#ifdef __WINSCW__ +static void +SetProxy ( LmConnection *connection, ProxyData *proxy_data ) + { + LmProxy *proxy = NULL; + + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + lm_proxy_set_server ( proxy, proxy_data->proxy_server ); + lm_proxy_set_port ( proxy, proxy_data->proxy_port ); + lm_connection_set_proxy ( connection, proxy ); + lm_proxy_unref ( proxy ); + } +#endif + +// --------------------------------------------------------------------------- +// function_name : SSLInit +// description : Sets the connection to use SSL +// Arguements : +// connection : LmConnection +// Returns : None +// --------------------------------------------------------------------------- +// +static void +SSLInit ( LmConnection *connection ) + { + LmSSL *ssl = NULL; + + ssl = lm_ssl_new ( NULL, ( LmSSLFunction ) ssl_cb, NULL, NULL ); + lm_connection_set_ssl ( connection, ssl ); + lm_ssl_unref ( ssl ); + lm_connection_set_keep_alive_rate (connection, 30); + } + + +// --------------------------------------------------------------------------- +// function_name : get_user_name +// description : Returns the username from the jid +// Arguements : +// jid : jid +// Returns : username +// --------------------------------------------------------------------------- +// +static gchar * +get_user_name ( const gchar *jid ) + { + const gchar *ch; + + g_return_val_if_fail ( jid != NULL, NULL ); + + ch = strchr ( jid, '@' ); + if ( !ch ) + return ( gchar *) jid; + + return g_strndup ( jid, ch - jid ); + } + +// --------------------------------------------------------------------------- +// jabber_presence_handler_cb: Callback function to handle the presence info +// --------------------------------------------------------------------------- +// +static LmHandlerResult +jabber_presence_handler_cb ( LmMessageHandler * /*handler*/, + LmConnection * /*connection*/, + LmMessage *message, + gpointer user_data ) + { + const gchar *jid; + const gchar *show; + const gchar *status; + + LmMessageNode *node; + JabberPresenceType type; + + if(message != NULL) + { + // Get the JID attribute + jid = lm_message_node_get_attribute ( message->node, "from" ); + + // Get the show attribute + + node = lm_message_node_get_child ( message->node, "show" ); + show = node ? ( node->value ) : "online"; + + // Get the status attribute + node = lm_message_node_get_child ( message->node, "status" ); + status = node ? ( node->value ) : NULL; + + type = jabber_presence_type_from_string ( show ); + } + + + GMainLoop *main_loop = ( GMainLoop * ) user_data; + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + + + + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// Ctstlm::Delete +// Delete here all resources allocated and opened from test methods. +// Called from destructor. +// ----------------------------------------------------------------------------- +// +void Ctstlm::Delete() + { + + } + +// ----------------------------------------------------------------------------- +// Ctstlm::RunMethodL +// Run specified method. Contains also table of test mothods and their names. +// ----------------------------------------------------------------------------- +// +TInt Ctstlm::RunMethodL( + CStifItemParser& aItem ) + { + iLog->Log ( _L ( "In RunMethodL method" ) ); + + + //TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); + //TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles ); + + static TStifFunctionInfo const KFunctions[] = + { + // Copy this line for every implemented function. + // First string is the function name used in TestScripter script file. + // Second is the actual implementation member function. + + // LmConnection + ENTRY( "lm_connection_new", Ctstlm::lm_connection_newL ), + ENTRY( "lm_new_with_context", Ctstlm::lm_new_with_contextL ), + ENTRY( "lm_connection_open", Ctstlm::lm_connection_openL ), + ENTRY( "lm_connection_is_open_WhenConnectionIsClosed", Ctstlm::lm_connection_is_open_WhenConnectionIsClosedL), + ENTRY( "lm_connection_is_authenticated_WhenNot_Authenticated", Ctstlm::lm_is_authenticated_WhenNotAuthenticatedL), + ENTRY( "lm_connection_set_server_withNULL", Ctstlm::lm_connection_set_server_WithNULL), + ENTRY( "lm_connection_set_jid_WithNull", Ctstlm::lm_connection_set_jid_WithNULL), + ENTRY( "lm_connection_set_port_WithNULL", Ctstlm::lm_connection_set_port_WithNULL), + ENTRY( "lm_connection_set_ssl_WithNULL", Ctstlm::lm_connection_set_ssl_WithNULL), + ENTRY( "lm_connection_close", Ctstlm::lm_connection_closeL ), + ENTRY( "lm_connection_closeWhenNotOpen", Ctstlm::lm_connection_closeWhenNotOpenedL ), + ENTRY( "lm_authenticate", Ctstlm::lm_authenticateL ), + ENTRY( "lm_connection_is_open", Ctstlm::lm_connection_is_openL ), + ENTRY( "lm_is_authenticated", Ctstlm::lm_is_authenticatedL ), + ENTRY( "lm_connection_set_get_server", Ctstlm::lm_connection_set_get_serverL ), + ENTRY( "lm_connection_set_get_jid", Ctstlm::lm_connection_set_get_jidL ), + ENTRY( "lm_connection_set_get_port", Ctstlm::lm_connection_set_get_portL ), + ENTRY( "lm_connection_set_get_ssl", Ctstlm::lm_connection_set_get_sslL ), + ENTRY( "lm_connection_set_get_proxy", Ctstlm::lm_connection_set_get_proxyL ), + + ENTRY( "lm_connection_send", Ctstlm::lm_connection_sendL ), + ENTRY( "lm_connection_send400char", Ctstlm::lm_connection_send400charL ), + ENTRY( "lm_connection_send_repeated", Ctstlm::lm_connection_send_repeatedL ), + + ENTRY( "lm_send_with_reply", Ctstlm::lm_send_with_replyL ), + ENTRY( "register_message_handler", Ctstlm::register_message_handlerL ), + ENTRY( "set_disconnect_function", Ctstlm::set_disconnect_functionL ), + ENTRY( "lm_connection_send_raw", Ctstlm::lm_connection_send_rawL ), + ENTRY( "lm_connection_get_state", Ctstlm::lm_connection_get_stateL ), + ENTRY( "lm_connection_ref", Ctstlm::lm_connection_refL ), + ENTRY( "lm_connection_unref", Ctstlm::lm_connection_unrefL ), + + // LmMessage + ENTRY( "lm_message_new", Ctstlm::lm_message_newL ), + ENTRY( "lm_message_new_with_sub_type", Ctstlm::lm_message_new_with_sub_typeL ), + ENTRY( "lm_message_get_type", Ctstlm::lm_message_get_typeL ), + ENTRY( "lm_message_get_sub_type", Ctstlm::lm_message_get_sub_typeL ), + ENTRY( "lm_message_get_node", Ctstlm::lm_message_get_nodeL ), + ENTRY( "lm_message_ref", Ctstlm::lm_message_refL ), + ENTRY( "lm_message_unref", Ctstlm::lm_message_unrefL ), + + // LmMessageHandler + ENTRY( "lm_message_handler_new", Ctstlm::lm_message_handler_newL ), + ENTRY( "lm_message_handler_invalidate", Ctstlm::lm_message_handler_invalidateL ), + ENTRY( "lm_message_handler_is_valid", Ctstlm::lm_message_handler_is_validL ), + ENTRY( "lm_message_handler_ref", Ctstlm::lm_message_handler_refL ), + ENTRY( "lm_message_handler_unref", Ctstlm::lm_message_handler_unrefL ), + + // LmMessageNode + ENTRY( "lm_message_node_set_get_value", Ctstlm::lm_message_node_set_get_valueL ), + ENTRY( "lm_message_node_add_child", Ctstlm::lm_message_node_add_childL ), + ENTRY( "lm_message_node_get_child", Ctstlm::lm_message_node_get_childL ), + ENTRY( "lm_message_node_find_child", Ctstlm::lm_message_node_find_childL ), + + ENTRY( "lm_message_node_set_get_attributes", Ctstlm::lm_message_node_set_get_attributesL ), + + ENTRY( "lm_message_node_set_get_raw_mode", Ctstlm::lm_message_node_set_get_raw_modeL ), + + ENTRY( "lm_message_node_ref", Ctstlm::lm_message_node_refL ), + ENTRY( "lm_message_node_unref", Ctstlm::lm_message_node_unrefL ), + + ENTRY( "lm_message_node_to_string", Ctstlm::lm_message_node_to_stringL ), + + // LmSSL + ENTRY( "lm_ssl_new", Ctstlm::lm_ssl_newL ), + ENTRY( "lm_ssl_is_supported", Ctstlm::lm_ssl_is_supportedL ), + ENTRY( "lm_ssl_get_fingerprint", Ctstlm::lm_ssl_get_fingerprintL ), + ENTRY( "lm_ssl_ref", Ctstlm::lm_ssl_refL ), + ENTRY( "lm_ssl_unref", Ctstlm::lm_ssl_unrefL ), + + // LmProxy + ENTRY( "lm_proxy_new", Ctstlm::lm_proxy_newL ), + ENTRY( "lm_proxy_new_with_server", Ctstlm::lm_proxy_new_with_serverL ), + ENTRY( "lm_proxy_set_get_type", Ctstlm::lm_proxy_set_get_typeL ), + ENTRY( "lm_proxy_set_get_server", Ctstlm::lm_proxy_set_get_serverL ), + ENTRY( "lm_proxy_set_get_port", Ctstlm::lm_proxy_set_get_portL ), + ENTRY( "lm_proxy_set_get_username", Ctstlm::lm_proxy_set_get_usernameL ), + ENTRY( "lm_proxy_set_get_password", Ctstlm::lm_proxy_set_get_passwordL ), + ENTRY( "lm_proxy_ref", Ctstlm::lm_proxy_refL ), + ENTRY( "lm_proxy_unref", Ctstlm::lm_proxy_unrefL ), + + // lm-send-sync example + ENTRY( "lm_send_sync", Ctstlm::lm_send_syncL ), + + // lm contact list fetching code + + ENTRY( "lm_fetching_contactlist", Ctstlm::lm_fetching_contactlist_L ), + ENTRY( "lm_fetching_presence", Ctstlm::lm_fetching_presenceL ), + ENTRY( "lm_subscribe_contact", Ctstlm::lm_subscribe_contact_L ), + ENTRY( "lm_authenticate_unexistjid", Ctstlm::lm_authenticate_WithUnexistingJID ), + ENTRY( "lm_authenticate_badpassword", Ctstlm::lm_authenticate_WithBadPasswordL ), + ENTRY( "lm_authenticate_connectionisnotcreated", Ctstlm::lm_authenticate_WhenConnectionIsNotOpenedL ), + ENTRY( "lm_connection_open_with_bad_server", Ctstlm::lm_connection_open_with_badserverL ), + ENTRY( "lm_connection_send_receive", Ctstlm::lm_connection_send_receiveL ), + ENTRY( "lm_login_test", Ctstlm::lm_login_testL ), + ENTRY( "lm_add_contact", Ctstlm::lm_add_contactL ), + ENTRY( "lm_remove_contact", Ctstlm::lm_remove_contactL ), + ENTRY( "lm_connection_cancel_open", Ctstlm::lm_connection_cancel_openL ), + ENTRY( "lm_connection_get_privacy_lists", Ctstlm::lm_connection_get_privacy_listsL ), + ENTRY( "lm_connection_set_privacy_lists", Ctstlm::lm_connection_set_privacy_listsL ), + ENTRY( "lm_connection_send_image_bytestream_msg", Ctstlm::lm_connection_send_image_bytestream_msgL ), + ENTRY( "lm_connection_send_image_bytestream_iq", Ctstlm::lm_connection_send_image_bytestream_iqL ), + ENTRY( "lm_connection_send_multiple_conn", Ctstlm::lm_connection_send_multiple_connL ), + ENTRY( "lm_connection_block_contact", Ctstlm::lm_connection_block_contactL ), + ENTRY( "lm_connection_unblock_contact", Ctstlm::lm_connection_unblock_contactL ), + ENTRY( "lm_connection_set_active_list", Ctstlm::lm_connection_set_active_listL ), + ENTRY( "lm_connection_set_unexist_active_list", Ctstlm::lm_connection_set_unexist_active_listL ), + ENTRY( "lm_connection_set_decline_active_list", Ctstlm::lm_connection_set_decline_active_listL ), + ENTRY( "lm_connection_get_one_privacy_list", Ctstlm::lm_connection_get_one_privacy_listL ), + ENTRY( "lm_connection_set_one_privacy_list", Ctstlm::lm_connection_set_one_privacy_listL ), + ENTRY( "lm_connection_get_many_privacy_list_from_listname", Ctstlm::lm_connection_get_many_privacy_list_from_listnameL ), + ENTRY( "lm_connection_set_one_unexist_privacy_list", Ctstlm::lm_connection_set_one_unexist_privacy_listL ), + ENTRY( "lm_connection_get_one_unexist_privacy_list", Ctstlm::lm_connection_get_one_unexist_privacy_listL ), + ENTRY( "lm_connection_create_one_privacy_list", Ctstlm::lm_connection_create_one_privacy_listL ), + ENTRY( "lm_service_discovery", Ctstlm::lm_service_discoveryL ), + ENTRY( "lm_service_discovery_connected_resource", Ctstlm::lm_service_discovery_connected_resourceL ), + ENTRY( "lm_simple_communications_blocking", Ctstlm::lm_simple_communications_blockingL ), + ENTRY( "lm_send_im_with_reply", Ctstlm::lm_send_im_with_replyL ), + ENTRY( "lm_receive_any_message", Ctstlm::lm_receive_any_messageL ), + ENTRY( "lm_login_multiple_sessions", Ctstlm::lm_login_multiple_sessionsL ), + ENTRY( "lm_change_own_presence", Ctstlm::lm_change_own_presenceL ), + ENTRY( "lm_login_test_invalid_server", Ctstlm::lm_login_test_invalid_serverL ), + ENTRY( "lm_login_test_invalid_port", Ctstlm::lm_login_test_invalid_portL ), + ENTRY( "lm_memory_leak_test", Ctstlm::lm_memory_leak_testL ), + ENTRY( "lm_nft_updating_presence", Ctstlm::lm_nft_updating_presenceL ), + ENTRY( "lm_nft_presence_notification", Ctstlm::lm_nft_presence_notificationL ), + ENTRY( "lm_nft_send_text_message", Ctstlm::lm_nft_send_text_messageL ), + ENTRY( "lm_nft_open_conversation_with_multiple",Ctstlm::lm_nft_open_conversation_with_multipleL ), + ENTRY( "lm_nft_fetch300_contact", Ctstlm::lm_nft_fetch300_contactL ), + ENTRY( "lm_nft_loginlogoutmultipletime", Ctstlm::lm_nft_loginlogoutmultipletime ), + ENTRY( "lm_nft_receiving100_message_L", Ctstlm::lm_nft_receiving100_message_L ), + + }; + + const TInt count = sizeof( KFunctions ) / + sizeof( TStifFunctionInfo ); + + return RunInternalL( KFunctions, count, aItem ); + + } + + +//---------------------------------------------------------------------------- +// Ctstlm::lm_connection_newL +// Description : Creates a new closed connection. Server can be NULL but must +// be set before calling lm_connection_open() +// Arguements : +// server : The hostname of the server for the connection +// Retrurns : A newly created LmConnection, should be unreffed with +// lm_connection_unref() +//---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_newL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + SET_LOW_MEMORY_TRAP ( NULL ); + + iLog->Log ( _L("In lm_connection_newL" ) ); + + + +__UHEAP_MARK; +__UHEAP_RESET; + + // Read data from the cfg file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + +__UHEAP_FAILNEXT(1); + + //----------------------- + connection = lm_connection_new ( connect_data->server ); + //----------------------- + + // Free the allocated resources + free_data ( connect_data ); + + if ( connection == NULL ) + { + iLog->Log ( _L( "lm_connection_new failed to allocate memory" ) ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); +__UHEAP_MARKEND; + + REMOVE_LOW_MEMORY_TRAP (); + + iLog->Log ( _L( "lm_connection_new test case passed" ) ); + + return KErrNone; + } + + +//---------------------------------------------------------------------------- +// Ctstlm::lm_connection_new_with_context +// Description : Creates a new closed connection running in a certain context +// Arguements : +// server : The hostname of the server for the connection +// context : The context this connection should be running on +// Retrurns : A newly created Lmconnection, should be unreffed with +// lm_connection_unref() +//---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_new_with_contextL ( CStifItemParser& /* aItem */ ) + { + GMainContext *context; + LmConnection *connection = NULL; + + iLog->Log ( _L( "In lm_connection_new_with_contextL" ) ); + + context = g_main_context_new (); + connection = lm_connection_new_with_context ( NULL, context ); + if ( connection == NULL ) + { + iLog->Log ( _L ( "lm_connection_new_with_context failed" ) ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_new_with_context test case passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_open +// Description : An async call to open connection. When the connection is open +// function 'connection_open_cb' is called +// Arguements : +// connection : LmConnection to open +// function : Callback function that will be called when the connection +// is open +// user_data : User data that will be passed to function +// notify : Function for freeing that user_data, can be NULL +// error : location to store error +// Returns : TRUE if everything went fine, FALSE otherwise +// +// Requieres : This test case requires GUI for selecting Access point +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_openL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + GMainLoop *main_loop = NULL; + + iLog->Log ( _L ( "In lm_connection_open" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + //context = g_main_context_new (); + //connection = lm_connection_new_with_context ( connect_data->server, context ); + + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + + // Set proxy for emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set connection to use SSL + SSLInit ( connection ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_open succeded" ) ); + return KErrNone; + + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_close +// Description : A synchronous call to close the connection +// Arguements : +// connection : LmConnection to close +// error : location to store error, or NULL +// Retrurns :TRUE if no errors were detected, otherwise FALSE +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_closeL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + iLog->Log ( _L ( "In lm_connection_close" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + // Set proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + if ( lm_connection_close ( connection, NULL ) == FALSE ) + { + iLog->Log ( _L ( "lm_connection_close failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( "lm_connection_close passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_closeWhenNotOpenedL +// Description : A synchronous call to close the connection +// Arguements : +// connection : LmConnection to close +// error : location to store error, or NULL +// Retrurns :TRUE if no errors were detected, otherwise FALSE +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_closeWhenNotOpenedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + iLog->Log ( _L ( "In lm_connection_close" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + + if ( lm_connection_close ( connection, NULL ) == TRUE ) + { + iLog->Log ( _L ( "lm_connection_close failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( "lm_connection_closeWhenNotOpenedL passed" ) ); + + return KErrNone; + } + + + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_authenticateL +// Description : Tries to authenticate a user against the server +// Arguements : +// connnection : LmConnection to authenticate +// username : Username used to authenticate +// password : Password corresponding to username +// resource : Resource used for this connection +// function : Callback function called when authentication is finished +// user_data : Userdata passed to callback function when called +// notify : Function for freeing user_data, can be NULL +// error : location to store error, or NULL +// Returns : TRUE if no errors were detected, FALSE otherwise +// Requieres : This test case requires GUI for selecting Access point +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_authenticateL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + AuthData *auth_data = NULL; + + iLog->Log ( _L ( "In lm_authenticateL" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + g_free ( auth_data ); + return KErrGeneral; + } + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + auth_data->rCode = RC_ERROR; + connection = lm_connection_new ( auth_data->connect_data->server ); + if ( connection == NULL ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + SSLInit ( connection ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) auth_in_connection_cb, + auth_data, + NULL, + NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode != RC_OK ) + { + iLog->Log ( _L ( "lm_authenticateL failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_free ( auth_data ); + + iLog->Log ( _L ( "lm_authenticateL passed" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_is_open +// Description : Check if connection is currently open or not +// Arguements : +// connection : an LmConnection to check if it is open +// Returns : TRUE if connection is open and FALSE if it is closed +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_is_openL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gboolean NotOpen = FALSE; + + iLog->Log ( _L ( "In lm_connection_is_open" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + SSLInit ( connection ); + + // Check for connection in case of connection not yet opened + if ( !lm_connection_is_open ( connection ) ) + { + iLog->Log ( _L ( "Connection is not open" ) ); + NotOpen = TRUE; + } + + // Check for open connection in case of connection opened + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + if ( !lm_connection_is_open ( connection ) && FALSE == NotOpen ) + { + iLog->Log ( _L ( "lm_connection_is_open failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_is_open passed" ) ); + + return KErrNone; + } +///////////////////////////////////////////////////////// +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_is_open_WhenConnectionIsClosedL +// Description : Check if connection is currently open or not +// Arguements : +// connection : an LmConnection to check if it is open +// Returns : TRUE if connection is open and FALSE if it is closed +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_is_open_WhenConnectionIsClosedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gboolean NotOpen = FALSE; + + iLog->Log ( _L ( "lm_connection_is_open_WhenConnectionIsClosedL" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( " lm_connection_is_open" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + if ( lm_connection_is_open ( connection ) ) + { + iLog->Log ( _L ( "lm_connection_is_open_WhenConnectionIsClosedL failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_is_open_WhenConnectionIsClosedL passed" ) ); + + return KErrNone; + } + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_is_authenticated +// Description : Check if connection is authenticated or not +// Arguements : +// connection : an LmConnection to check +// Returns : TRUE if connection is authenticated, FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_is_authenticatedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gboolean NotAuthenticated = FALSE; + + iLog->Log ( _L ( "In lm_connection_is_authenticated" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the connection to use gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID to be used for connection + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // Open a connection + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + // Check for authentication before the connection is authenticated + if ( !lm_connection_is_authenticated ( connection ) ) + { + iLog->Log ( _L ( "Connection not yet authenticated" ) ); + NotAuthenticated = TRUE; + } + + // Authenticate the connection + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Check for authentication after the connection is authenticated + if ( !lm_connection_is_authenticated ( connection ) && + FALSE == NotAuthenticated ) + { + iLog->Log ( _L ( "lm_connection_is_authenticated failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_is_authenticated passed" ) ); + + return KErrNone; + } + + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_get_server +// Description : Sets the server address for connection to server. Notice that +// connection can't be open while doing this. +// Arguements : +// connection : an LmConnection +// server : Address of the server ( name of the server ) +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_get_serverL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + gchar *ServerName = "ganapati.nokia.com"; + ConnectData *connect_data = NULL; + gchar *NewServerName; + + iLog->Log ( _L ( "In lm_connection_set_server" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( " lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + + + // Set the servers name before the connection + lm_connection_set_server ( connection, ServerName ); + + // Verify the server name + NewServerName = (gchar *)lm_connection_get_server ( connection ); + + if ( strcmp ( NewServerName, ServerName ) != 0 ) + { + iLog->Log ( _L ( "lm_connection_set_server failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Server name modified successfully + iLog->Log ( _L ( "lm_connection_set_server passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm:lm_connection_set_server_WithNULL +// Description : Sets the server address for connection to server. Notice that +// connection can't be open while doing this. +// Arguements : +// connection : an LmConnection +// server : Address of the server ( name of the server ) +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_server_WithNULL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + gchar *ServerName = "\0"; + ConnectData *connect_data = NULL; + gchar *NewServerName; + + iLog->Log ( _L ( "In lm_connection_set_server" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( " lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + + + // Set the servers name before the connection + lm_connection_set_server ( connection, ServerName ); + + // Verify the server name + NewServerName = (gchar *)lm_connection_get_server ( connection ); + + if ( strcmp ( NewServerName, ServerName ) != 0 ) + { + iLog->Log ( _L ( "lm_connection_set_server failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Server name modified successfully + iLog->Log ( _L ( "lm_connection_set_server passed" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_get_jid +// Description : Sets the JID to be used for connection +// Arguements : +// connection : an LmConnection +// jid : JID to be used for connection +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_get_jidL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gchar *Jid = "connect.nokia.com"; + const gchar *GetJid = NULL; + + iLog->Log ( _L ( "In lm_connection_set_jid" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new close connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set new jid + Jid = g_strdup_printf ( "%s@%s", connect_data->username, connect_data->server ); + lm_connection_set_jid ( connection, Jid ); + + + // Verify the Jid + GetJid = lm_connection_get_jid ( connection ); + if ( strcmp ( Jid, GetJid ) != 0 ) + { + iLog->Log ( _L ( "lm_connection_set_jid failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + // Remove a referece on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( "lm_connection_set_jid passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_jid_WithNULL +// Description : Sets the JID to be used for connection +// Arguements : +// connection : an LmConnection +// jid : JID to be used for connection +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_jid_WithNULL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gchar *Jid = "\0"; + const gchar *GetJid = NULL; + + iLog->Log ( _L ( "In lm_connection_set_jid" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new close connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set new jid + Jid = g_strdup_printf ( "%s@%s", connect_data->username, connect_data->server ); + lm_connection_set_jid ( connection, Jid ); + + + // Verify the Jid + GetJid = lm_connection_get_jid ( connection ); + if ( strcmp ( Jid, GetJid ) != 0 ) + { + iLog->Log ( _L ( "lm_connection_set_jid failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + // Remove a referece on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( "lm_connection_set_jid passed" ) ); + + return KErrNone; + } + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_get_port +// Description : Sets the port that connection will be using +// Arguements : +// connection : an LmConnection +// port : server port +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_get_portL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + guint LmPort; + + // Open a new closed connection + connection = lm_connection_new ( NULL ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + return KErrGeneral; + } + + // Sets the port + lm_connection_set_port ( connection, MYPORT ); + + // Get the port + LmPort = lm_connection_get_port ( connection ); + + // Verify the port used by the connection + if ( LmPort != MYPORT ) + { + iLog->Log ( _L ( "lm_connection_set_port failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + // Remove a reference on connection + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_set_port passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_port_WithNULL +// Description : Sets the port that connection will be using +// Arguements : +// connection : an LmConnection +// port : server port +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_port_WithNULL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + guint LmPort; + + // Open a new closed connection + connection = lm_connection_new ( NULL ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + return KErrGeneral; + } + + // Sets the port + lm_connection_set_port ( connection, FAKEPORT ); + + // Get the port + LmPort = lm_connection_get_port ( connection ); + + // Verify the port used by the connection + if ( LmPort != FAKEPORT ) + { + iLog->Log ( _L ( "lm_connection_set_port failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + // Remove a reference on connection + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_set_port passed" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_get_ssl +// Description : Sets SSL struct or unset if ssl is NULL. +// If set connection will use SSL for the connection +// Arguements : +// connection : an LmConnection +// ssl : an LmSSL +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_get_sslL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + LmSSL *ssl = NULL; + + iLog->Log ( _L ( "In lm_connection_set_ssl" ) ); + + if ( lm_ssl_is_supported() ) + { + connection = lm_connection_new ( NULL ); + + ssl = lm_ssl_new ( NULL, NULL, NULL, NULL ); + + lm_connection_set_ssl ( connection, ssl ); + lm_ssl_unref ( ssl ); + + if ( !lm_connection_get_ssl ( connection ) ) + { + iLog->Log ( _L ( "lm_connection_set_ssl failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_set_ssl passed" ) ); + + return KErrNone; + } + + iLog->Log ( _L ( "ssl not supported" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_ssl_WithNULL +// Description : Sets SSL struct or unset if ssl is NULL. +// If set connection will use SSL for the connection +// Arguements : +// connection : an LmConnection +// ssl : an LmSSL +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_ssl_WithNULL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + LmSSL *ssl = NULL; + + iLog->Log ( _L ( "In lm_connection_set_ssl" ) ); + + if ( lm_ssl_is_supported() ) + { + connection = lm_connection_new ( NULL ); + + ssl = lm_ssl_new ( NULL, NULL, NULL, NULL ); + + lm_connection_set_ssl ( connection, ssl ); + lm_ssl_unref ( ssl ); + + if ( !lm_connection_get_ssl ( connection ) ) + { + iLog->Log ( _L ( "lm_connection_set_ssl failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_set_ssl passed" ) ); + + return KErrNone; + } + + iLog->Log ( _L ( "ssl not supported" ) ); + + return KErrNone; + } + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_get_proxy +// Description : Sets the proxy to use for this connection. To unset pass NULL +// Arguements : +// connection : an LmConnection +// proxy : an LmProxy +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_get_proxyL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection; + LmProxy *Proxy; + + iLog->Log ( _L ( "In lm_connection_set_proxy" ) ); + + connection = lm_connection_new ( NULL ); + + Proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + + // Set proxy + lm_connection_set_proxy ( connection, Proxy ); + lm_proxy_unref ( Proxy ); + + // Verify proxy setttings + if ( !lm_connection_get_proxy ( connection ) ) + { + iLog->Log ( _L ( "lm_connection_set_proxy failed" ) ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_set_proxy passed") ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_sendL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_sendL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "In lm_connection_send" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; +} + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_send_with_replyL +// Description : Send a LmMessage which will result in a reply +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// handler : LmMessageHandler that will be used when reply to a message +// arrives +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_send_with_replyL ( CStifItemParser& aItem ) + { + LmConnection *connection; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode *q_node; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_send_with_reply" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the port to gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // Open a connection with the server + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attributes ( q_node, "xmlns", "jabber:iq:auth", NULL ); + lm_message_node_add_child ( q_node, "username", connect_data->username ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Send message to the server + handler = lm_message_handler_new ( handle_messages, main_loop, NULL ); + //we are sending a dummy username request to server and the server should reply with error or not supported message + //we handle this in the handler and quit the mainloop. + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref ( handler ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref ( handler ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_send_with_reply passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::register_message_handlerL +// Description : Registers a LmMessageHandler to handle incoming messages of +// certain type. +// Arguements : +// connection : Connection to register a handle for +// handler : Message handler to register +// type : Message type that handler will handle +// priority : The priority in which to call handler +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::register_message_handlerL ( CStifItemParser& aItem ) + { + LmConnection *connection; + ConnectData *connect_data; + LmMessage *msg; + LmMessageHandler *handler; + HandleData *handle_data; + GMainLoop *main_loop = NULL; + + iLog->Log ( _L ( "In register_message_handlerL" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Create a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + SSLInit ( connection ); + + // Open a connection with the server + main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + handle_data = g_new0 ( HandleData, 1 ); + if ( !handle_data ) + { + iLog->Log ( _L ( "Memory allocation failed for handle_data" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + handle_data->main_loop = main_loop; + handle_data->Test_Success = RC_ERROR; + + // Register a message handler + handler = lm_message_handler_new ( handle_messages, handle_data, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_IQ, + LM_HANDLER_PRIORITY_NORMAL ); + lm_message_handler_unref ( handler ); + + + // Construct a message + msg = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_IQ ); + lm_message_node_add_child ( msg->node, "query", NULL ); + + + //Send message to the server + //Since we are sending dummy query to the recipient, we are expecting + //an error message. This indicates the response was successfully received. + if ( !lm_connection_send ( connection, msg, NULL ) ) + { + iLog->Log ( _L ( "lm_message_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( msg ); + return KErrGeneral; + } + + // Wait for the reply from the server + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + // Free the allocated resources + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( msg ); + + // Verify wheather the callback function called or not + if ( RC_OK != handle_data->Test_Success ) + { + iLog->Log ( _L ( "register_message_handlerL failed" ) ); + g_free ( handle_data ); + return KErrGeneral; + } + + g_free ( handle_data ); + free_data ( connect_data ); + iLog->Log ( _L ( "register_message_handlerL passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::set_disconnect_functionL +// Description : Set the callback that will be called when a connection is +// closed +// Arguements : +// connection : Connection to register disconnect callback for +// function : Function to be called when connection is closed +// user_data : User data passed to a function +// notify : Function to free user_data +// Returns : None +//----------------------------------------------------------------------------- +// +TInt Ctstlm::set_disconnect_functionL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "In set_disconnect_functionL" ) ); + + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Create a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + SSLInit ( connection ); + + + // Open a connection with the server + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + handle_data = g_new0 ( HandleData, 1 ); + if ( !handle_data ) + { + iLog->Log ( _L ( "Memory allocation failed for handle_data" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + return KErrGeneral; + } + handle_data->Test_Success = RC_ERROR; + + // Set a Callback function that will be called when connection is closed + lm_connection_set_disconnect_function ( connection, + connection_close_cb, + handle_data, + NULL ); + + // Close the opened connection + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + + // Check wheather callback function is called or not + if ( RC_OK != handle_data->Test_Success ) + { + iLog->Log ( _L ( "set_disconnect_functionL failed" ) ); + g_free ( handle_data ); + return KErrGeneral; + } + + g_free ( handle_data ); + + iLog->Log ( _L ( "set_disconnect_functionL passed" ) ); + free_data ( connect_data ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_raw +// Description : Asynchronus call to send a raw string. +// Arguements : +// connection : Connection used to send +// str : The string to send, the entire string will be sent +// error : Set if error was detected during sending +// Returns : TRUE if no errors were detected during sending, FALSE +// otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_rawL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + GError *error = NULL; + + iLog->Log ( _L ( "In lm_connection_send_raw" ) ); + + // Read data from the cfg file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Create a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + SSLInit ( connection ); + + // Open a connection with the server + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + // Send a raw message + if ( !lm_connection_send_raw ( connection, + connect_data->msg_data->message, + &error ) ) + { + iLog->Log ( _L ( "lm_connection_send_raw failed: %s"), error->message ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_send_raw passed" ) ); + + return KErrNone; + } + + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_get_state +// Description : Returns the state of the connection +// Arguements : +// connection : Connection to get state +// Returns : The state of the connection +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_get_stateL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmConnectionState state; + + iLog->Log ( _L ( "In lm_connection_get_state" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Create a new closed connection + connection = lm_connection_new ( connect_data->server ); + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + SSLInit ( connection ); + + // Verify the state when the connection is closed + state = lm_connection_get_state ( connection ); + + if ( LM_CONNECTION_STATE_CLOSED != state ) + { + iLog->Log ( _L ( "lm_connection_get_state failed:closed" ) ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Verify the state after opening the connection + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + state = lm_connection_get_state ( connection ); + + if ( LM_CONNECTION_STATE_OPEN != state ) + { + iLog->Log ( _L ( "lm_connection_get_state failed: open" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + state = lm_connection_get_state ( connection ); + + if ( LM_CONNECTION_STATE_AUTHENTICATED != state ) + { + iLog->Log ( _L ( "lm_connection_get_state failed: authenticated" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_connection_get_state passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_ref +// Description : Add a reference on connection +// Arguements : +// connection : Connection to a add a reference to +// Returns : Returns the same connection +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_refL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + + iLog->Log ( _L ("In lm_connection_unref" ) ); + + // Create a new closed connection + connection = lm_connection_new ( NULL ); + + // Add a reference on connection + connection = lm_connection_ref ( connection ); + + // Loudmouth don't have any API to check the ref count on connection + // Therefore lm_connection_ref is considered as passed. + + // Decrement the reference count and free the memory + lm_connection_unref ( connection ); + lm_connection_unref ( connection ); + + iLog->Log ( _L ( "lm_connection_ref passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_unref +// Description : Removes the reference on connection. If there are no +// references to connection, it will be freed and shouldn't +// used again +// Check the total available heap space +// Create a new closed connection, +// Check that available heap space is reduced +// Decrement the reference on connection +// Check the available heap is equal to what it was before +// Arguements : +// connection : Connection to remove reference from +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_unrefL ( CStifItemParser& /*aItem*/ ) + { + LmConnection *connection = NULL; + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_available_before; + TInt heap_available_after; + + iLog->Log ( _L ( "In lm_connection_unref" ) ); +__UHEAP_MARK; + // Get the heap space before creating closed connection + heap_available_before = heap_handle.Available ( largest_free_block ); + + // Create a new closed connection + connection = lm_connection_new ( NULL ); + + // Decrement the reference on connection + lm_connection_unref ( connection ); + + // Get the heap space after freeing memory + heap_available_after = heap_handle.Available ( largest_free_block ); + + if ( heap_available_after != heap_available_before ) + { + iLog->Log ( _L ( "{heap_available_before = %d, heap_available_before = %d}" ), + heap_available_before, heap_available_after ); + iLog->Log ( _L ( "Available memeory is not as expected after free!" ) ); + return KErrGeneral; + } +__UHEAP_MARKEND; + iLog->Log ( _L ( "{ Expected:heap_available_before is equal to heap_available_after }" ) ); + iLog->Log ( _L ( "heap_available_before = %d, heap_available_after = %d" ), + heap_available_before, heap_available_after ); + iLog->Log ( _L ( "lm_connection_unref passed" ) ); + + return KErrNone; + + } + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_new +// Description:Creates a new LmMessage which can be sent with +// lm_connection_send() or lm_connection_send_with_reply(). +// Arguements : +// to : recipient jid +// type : message type +// Returns : a newly created LmMessage +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_newL ( CStifItemParser& aItem ) + { + LmMessage *message; + ConnectData *connect_data = NULL; + LmMessageType MessageType; + gchar Type[256]; + + iLog->Log ( _L ( "\tIn lm_message_new" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "\tread_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Construct a message with a type=LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "\tConstruct a message" ) ); + + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "\tlm_message_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + + // Verify the message type + iLog->Log ( _L ( "\tVerify the message type" ) ); + + MessageType = lm_message_get_type ( message ); + if ( LM_MESSAGE_TYPE_MESSAGE != MessageType ) + { + iLog->Log ( _L( "\tExpected message type: LM_MESSAGE_TYPE_MESSAGE" ) ); + memset ( Type, '\0', sizeof ( Type ) ); + GetMessageType ( MessageType, Type ); + iLog->Log ( _L8 ( "\tActual message type : %s" ), Type ); + + iLog->Log ( _L ( "\tlm_message_get_type failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_message_unref ( message ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_message_new passed" ) ); + + return KErrNone; + + } + + + // --------------------------------------------------------------------------- +// Ctstlm::lm_message_new_with_sub_type +// Description:Creates a new LmMessage with subtype set. +// Arguements : +// to : recipient jid +// type : message type +// sub_type : message sub type +// Returns : a newly created LmMessage +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_new_with_sub_typeL ( CStifItemParser& aItem ) + { + LmMessage *message; + ConnectData *connect_data = NULL; + LmMessageType MessageType; + LmMessageSubType MessageSubType; + gchar Type[256]; + gchar SubType[256]; + + iLog->Log ( _L ( "In lm_message_new_with_sub_type" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "\tread_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Construct a message with type and sub type + message = lm_message_new_with_sub_type ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + if ( !message ) + { + iLog->Log ( _L ( "\tlm_message_new_with_sub_type failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + + // Verify the message type + MessageType = lm_message_get_type ( message ); + if ( LM_MESSAGE_TYPE_IQ != MessageType ) + { + iLog->Log ( _L ( "\tExpected message type: LM_MESSAGE_TYPE_IQ" ) ); + memset ( Type, '\0', sizeof ( Type ) ); + GetMessageType ( MessageType, Type ); + iLog->Log ( _L8 ( "\tActual message type : %s"), Type ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Verify the message sub type + MessageSubType = lm_message_get_sub_type ( message ); + if ( LM_MESSAGE_SUB_TYPE_SET != MessageSubType ) + { + iLog->Log ( _L ( "\tExpected message subtype: LM_MESSAGE_SUB_TYPE_SET" ) ); + memset ( SubType, '\0', sizeof ( SubType ) ); + GetMessageSubType ( MessageSubType, SubType ); + iLog->Log ( _L8 ( "\tActual message subtype : %s" ), SubType ); + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_message_unref ( message ); + + free_data ( connect_data ); + iLog->Log ( _L ( "lm_message_new_with_sub_type passed" ) ); + + return KErrNone; + } + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_get_type +// Description:Fetches the type of the message +// Arguements : +// message : an LmMessage +// Returns : the message type +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_get_typeL ( CStifItemParser& /*aItem*/ ) + { + LmMessage *message = NULL; + LmMessageType MessageType; + gchar Type[256]; + + iLog->Log ( _L ( "In lm_message_get_type" ) ); + memset ( Type, '\0', sizeof ( Type ) ); + + // Construct a message with a type + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_PRESENCE ); + if ( !message ) + { + iLog->Log ( _L ( "\tlm_message_new failed while constructing PRESENCE msg" ) ); + return KErrGeneral; + } + + // Verify the message type=LM_MESSAGE_TYPE_PRESENCE + iLog->Log ( _L ( "\tMessage type verification" ) ); + + MessageType = lm_message_get_type ( message ); + if ( LM_MESSAGE_TYPE_PRESENCE != MessageType ) + { + iLog->Log ( _L ( "\tExpected message type: LM_MESSAGE_TYPE_PRESENCE" ) ) ; + memset ( Type, '\0', sizeof ( Type ) ); + GetMessageType ( MessageType, Type ); + iLog->Log ( _L8 ( "\tActual message type :%s" ), Type ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Construct another message with type=LM_MESSAGE_TYPE_IQ + iLog->Log ( _L ( "\tConstruct a message with another type" ) ); + + lm_message_unref ( message ); + message = NULL; + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_IQ ); + if ( !message ) + { + iLog->Log ( _L ( "\tlm_message_new failed while constructing IQ message " ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Verify the message type + iLog->Log ( _L ( "\tVerify the message type" ) ); + + MessageType = lm_message_get_type ( message ); + if ( LM_MESSAGE_TYPE_IQ != MessageType ) + { + iLog->Log ( _L ( "\tExpected message type: LM_MESSAGE_TYPE_IQ" ) ); + memset ( Type, '\0', sizeof ( Type ) ); + GetMessageType ( MessageType, Type ); + iLog->Log ( _L8 ( "\tActual message type : %s" ), Type ); + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_message_unref ( message ); + + iLog->Log ( _L ( "\tlm_message_get_type passed" ) ); + + return KErrNone; + } + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_get_sub_type +// Description:Fetches the sub type of the message +// Arguements : +// message : an LmMessage +// Returns : the message sub type +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_get_sub_typeL ( CStifItemParser& /*aItem*/ ) + { + LmMessage *message = NULL; + LmMessageSubType MessageSubType; + gchar SubType[256]; + + iLog->Log ( _L ( "In lm_message_get_sub_type" ) ); + + // Construct a message with type and subtype=LM_MESSAGE_SUB_TYPE_SUBSCRIBE + iLog->Log ( _L ( "\tConstruct a message with type & subtype" ) ); + + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_MESSAGE, + LM_MESSAGE_SUB_TYPE_SUBSCRIBE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new_with_sub_type failed for SUBSCRIBE" ) ); + return KErrGeneral; + } + + // Verify message subtype + MessageSubType = lm_message_get_sub_type ( message ); + if ( LM_MESSAGE_SUB_TYPE_SUBSCRIBE != MessageSubType ) + { + iLog->Log ( _L ( "\tExpected MessageSubType: LM_MESSAGE_SUB_TYPE_SUBSCRIBE" ) ); + memset ( SubType, '\0', sizeof ( SubType ) ); + GetMessageSubType ( MessageSubType, SubType ); + iLog->Log ( _L8 ( "\tActual MessageSubType : %s" ), SubType ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Construct another message with subtype=LM_MESSAGE_SUB_TYPE_CHAT + lm_message_unref ( message ); + message = NULL; + + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_MESSAGE, + LM_MESSAGE_SUB_TYPE_CHAT ); + if ( !message ) + { + iLog->Log ( _L ( "\tlm_message_new_with_sub_type failed for CHAT" ) ); + return KErrGeneral; + } + + // Verify message subtype + MessageSubType = lm_message_get_sub_type ( message ); + if ( LM_MESSAGE_SUB_TYPE_CHAT != MessageSubType ) + { + iLog->Log ( _L ( "\tExpected MessageSubType: LM_MESSAGE_SUB_TYPE_CHAT" ) ); + + memset ( SubType, '\0', sizeof ( SubType ) ); + GetMessageSubType ( MessageSubType, SubType ); + iLog->Log ( _L8 ( "\tActual MessageSubType : %s" ), SubType ); + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_message_unref ( message ); + + iLog->Log ( _L ( "\tlm_message_get_sub_type passed" ) ); + + return KErrNone; + } + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_get_node +// Description:Retrives the root node from LmMessage +// Arguements : +// message : an LmMessage +// Returns : an LmMessageNode +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_get_nodeL ( CStifItemParser& /*aItem*/ ) + { + LmMessage *message; + LmMessageNode *Node = NULL; + + iLog->Log ( _L ( "In lm_message_get_node" ) ); + + // Construct a message with type=LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive root node from the message + iLog->Log ( _L ( "Retrive root node from message" ) ); + + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_get_node passed" ) ); + + return KErrNone; + } + + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_ref +// Description:Adds a reference to message +// Arguements : +// message : an LmMessage +// Returns : an message +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_refL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + + iLog->Log ( _L ( "In lm_message_ref" ) ); + + // Construct a message + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Add a reference to message + message = lm_message_ref ( message ); + + // Loudmouth don't have any API to check the ref count on message + // Therefore lm_message_ref is considered as passed. + + // Decrement the reference(2 times) to message and free the memory + lm_message_unref ( message ); + lm_message_unref ( message ); + + iLog->Log ( _L ( "lm_message_ref passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_unref +// Description:Removes a reference from message. When no more references are +// present, the message is freed. +// Check the total available heap space +// Construct a new message by using lm_message_new +// Check that available heap space is reduced +// Decrement the reference from message +// Check the available heap is equal to what it was before +// Arguements : +// message : an LmMessage +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_unrefL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message; + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_available_before; + TInt heap_available_after; + + iLog->Log ( _L ( "In lm_message_unref" ) ); + + // Get the total heap space before constructing a message + iLog->Log ( _L ( "Getting the heap size before message construction" ) ); + heap_available_before = heap_handle.Available ( largest_free_block ); + + // Construct a message + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Decrement the reference from message + iLog->Log ( _L ( "Remove the reference from the message" ) ); + lm_message_unref ( message ); + + // Get the heap space after freeing memory + iLog->Log ( _L ( "Getting the heap size after freeing the memory" ) ); + heap_available_after = heap_handle.Available ( largest_free_block ); + + // Compare the heap size + iLog->Log ( _L ( "Comparing heap size before and after freeing memory" ) ); + + if ( heap_available_after != heap_available_before ) + { + iLog->Log ( _L ( "heap_available_before = %d, heap_available_after = %d" ), + heap_available_before, heap_available_after ); + iLog->Log ( _L ( "Available memory is not as expected after freeing" ) ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Expected: heap_available_before is equal to heap_available_after" ) ); + iLog->Log ( _L ( "heap_available_before = %d, heap_available_after = %d" ), + heap_available_before, heap_available_after ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_handler_new +// Description:Creates a new message handler.This can be set to handle incoming +// messages and when a message of type the handler is registered to +// handle is received function will be called and user_data will be +// passed to it. notify is called when the message handler is freed, +// that way any memory allocated by user_data can be freed. +// Arguements : +// function : a callback +// user_data : user data passed to function +// notify : function called when the message handler is freed +// Returns : a newly created message handler +// +// Note : This test case requires UI mode to select Access point +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_handler_newL ( CStifItemParser& /*aItem*/ ) +{ + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_message_handler_new" ) ); + + // Create a new message handler + handler = lm_message_handler_new ( handle_messages, NULL, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + return KErrGeneral; + } + + // Validate the handler + if ( !lm_message_handler_is_valid ( handler ) ) + { + iLog->Log ( _L ( "message handler is not valid" ) ); + lm_message_handler_unref ( handler ); + return KErrGeneral; + } + + iLog->Log ( _L ( "lm_message_handler_new passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_handler_invalidate +// Description:Invalidates the handler. Useful if you need to cancel a reply +// Arguements : +// handler : an LmMessageHandler +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_handler_invalidateL ( CStifItemParser& /*aItem*/ ) +{ + LmMessageHandler *handler = NULL; + gboolean IsValid; + + iLog->Log ( _L ( "In lm_message_handler_invalidate" ) ); + + // Create a new message handler + iLog->Log ( _L ( "Creat a new message handler" ) ); + + handler = lm_message_handler_new ( handle_messages, NULL, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + return KErrGeneral; + } + + // Invalidate the message handler ( handler->valid = FALSE ) + iLog->Log ( _L ( "Invalidate the handler" ) ); + lm_message_handler_invalidate ( handler ); + + // Check for validity of message handler + iLog->Log ( _L ( "Checking validity of message handler" ) ); + + IsValid = lm_message_handler_is_valid ( handler ); + if ( IsValid ) + { + iLog->Log ( _L ( "lm_message_handler_invalidate failed" ) ); + lm_message_handler_unref ( handler ); + return KErrGeneral; + } + + lm_message_handler_unref ( handler ); + + iLog->Log ( _L ( "lm_message_handler_invalidate passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_handler_is_valid +// Description:Fetches whether the handler is valid or not. +// Arguements : +// handler : an LmMessageHandler +// Returns : TRUE if handler is valid, otherwise FALSE +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_handler_is_validL ( CStifItemParser& /*aItem*/ ) +{ + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_message_handler_is_valid" ) ); + + // Create a new message handler + iLog->Log ( _L ( "Constructing new message handler" ) ); + handler = lm_message_handler_new ( handle_messages, NULL, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + return KErrGeneral; + } + + // Check the validity of the message handler + iLog->Log ( _L ( "Check for validity of message handler" ) ); + if ( !lm_message_handler_is_valid ( handler ) ) + { + iLog->Log ( _L ( "lm_message_handler_is_valid failed" ) ); + lm_message_handler_unref ( handler ); + return KErrGeneral; + } + + // Invalidate the handler ( set handler->valid = FALSE ) + iLog->Log ( _L ( "Invalidate the message handler" ) ); + lm_message_handler_invalidate ( handler ); + + // check for validity of message handler after invalidating + iLog->Log ( _L ( "Check for validity after invalidating" ) ); + + if ( lm_message_handler_is_valid ( handler ) ) + { + iLog->Log ( _L ( "lm_message_handler_is_valid failed" ) ); + lm_message_handler_unref ( handler ); + return KErrGeneral; + } + + lm_message_handler_unref ( handler ); + + iLog->Log ( _L ( "lm_message_handler_is_valid passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_handler_ref +// Description:Adds a reference to handler +// Arguements : +// handler : an LmMessageHandler +// Returns : the message handler +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_handler_refL ( CStifItemParser& /*aItem*/ ) +{ + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_message_handler_ref" ) ); + + // Create a new message handler + iLog->Log ( _L ( "Construct a new message handler" ) ); + + handler = lm_message_handler_new ( handle_messages, NULL, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + return KErrGeneral; + } + + // Loudmouth don't have any API to check reference to handler + // Therefore this test is considered as passed without checking + + iLog->Log ( _L ( "Remove a reference from the message handler" ) ); + lm_message_handler_unref ( handler ); + + iLog->Log ( _L ( "lm_message_handler_ref passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_handler_unref +// Description:Removes a reference from handler. When no more references are +// present, the handler is freed +// Check the total available heap space +// Construct a new message handler +// Check that available heap space is reduced +// Remove reference from the message handler +// Check the available heap is equal to what it was before +// Arguements : +// handler : an LmMessageHandler +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_handler_unrefL ( CStifItemParser& /*aItem*/ ) +{ + LmMessageHandler *handler = NULL; + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_avail_before; + TInt heap_avail_after; + + iLog->Log ( _L ( "Inlm_message_handler_unref" ) ); + + // Get the total heap size before creating new message handler + iLog->Log ( _L ( "Get the heap size before allocating memory" ) ); + heap_avail_before = heap_handle.Available ( largest_free_block ); + + // Create a new message handler + iLog->Log ( _L ( "Construct a new message handler" ) ); + + handler = lm_message_handler_new ( handle_messages, NULL, NULL ); + if ( !handler ) + { + iLog->Log ( _L ( "lm_message_handler_new failed" ) ); + return KErrGeneral; + } + + // Remove a reference from the message handler + iLog->Log ( _L ( "Freeing allocated memory" ) ); + lm_message_handler_unref ( handler ); + + // Get the heap size after removing reference from message handler + iLog->Log ( _L ( "Get the heap size after freeing memory" ) ); + heap_avail_after = heap_handle.Available ( largest_free_block ); + + // Compare the heap size + iLog->Log ( _L ( "Compare the heap size after freeing memory" ) ); + + if ( heap_avail_before != heap_avail_after ) + { + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + iLog->Log ( _L ( "Available memory is not as expected after freeing" ) ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Expected: heap_avail_before is equal to heap_avail_after" ) ); + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + + return KErrNone; +} + + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_set_value +// Description:Sets the value of node. If a prev value is set it will be freed +// Arguements : +// Node : an LmMessageNode +// value : the new value +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_set_get_valueL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + const gchar *SetUsername = "Nokia"; + + iLog->Log ( _L ( "In lm_message_node_get_value" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retriving root node from the message" ) ); + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Set the value of the node + iLog->Log ( _L ( "Set the value of the node" ) ); + lm_message_node_set_value ( Node, SetUsername ); + + // Retrive the value of node + iLog->Log ( _L ( "Retrive the value of the node" ) ); + const gchar *GetUsername = lm_message_node_get_value ( Node ); + + // Verify the result + iLog->Log ( _L ( "Verify value of node" ) ); + if ( strcmp ( SetUsername, GetUsername ) ) + { + iLog->Log ( _L ( "lm_message_set_value failed" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_set_value passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_add_child +// Description:Add a child node with a name and value +// Arguements : +// node : an LmMessageNode +// name : name of the new child +// value : value of the new child +// Returns : the newly created child +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_add_childL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + const gchar *Username = "Nokia"; + + iLog->Log ( _L ( "In lm_message_node_add_child" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from message" ) ); + + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Add a child + iLog->Log ( _L ( "Add a child 'username' to node" ) ); + lm_message_node_add_child ( Node, "username", Username ); + + // Verify the child + iLog->Log ( _L ( "Verify the child" ) ); + if ( !lm_message_node_get_child ( Node, "username" ) ) + { + iLog->Log ( _L ( "lm_message_add_child failed" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Freeing allocated resources" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_add_child passed" ) ); + + return KErrNone; +} + + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_find_child +// Description:Locates a child among all children of node. The entire tree will +// be searched until a child with a name child_name is located. +// Arguements : +// node : an LmMessageNode +// name : name of the child to find +// Returns : located child or NULL if not found +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_find_childL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + const gchar *Username = "Nokia"; + const gchar *Password = "Nokia"; + + iLog->Log ( _L ( "In lm_message_node_find_child" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from the message" ) ); + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Add childrens + iLog->Log ( _L ( "Adding childrens 'username' and 'password'" ) ); + lm_message_node_add_child ( Node, "username", Username ); + lm_message_node_add_child ( Node, "password", Password ); + + // Locate the child 'username' + iLog->Log ( _L ( "Locate the child 'username'" ) ); + if ( !lm_message_node_find_child ( Node, "username" ) ) + { + iLog->Log ( _L ( "lm_message_node_find_child: child 'username' not found" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + // Locate the child 'password' + if ( !lm_message_node_get_child ( Node, "password" ) ) + { + iLog->Log ( _L ( "lm_message_node_find_child: child 'password' not found" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_find_child passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_set_get_attributes +// Description:Sets a list of attributes. The arguements should be names and +// correspoinding values and needs to be ended with NULL. +// Arguements : +// node : an LmMessageNode +// name : first attribute, should be fallowed by string with value +// .. : rest of the name/value pairs +// Returns : None +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_set_get_attributesL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + const gchar *Value = "Nokia"; + + iLog->Log ( _L ( "In lm_message_node_set_attributes" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from the message" ) ); + + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Set attributes + iLog->Log ( _L ("Setting attributes 'username', 'password' and 'xmlns'" ) ); + lm_message_node_set_attributes ( Node, + "username", Value, + "password", Value, + "xmlns", "jabber:iq:register", + NULL ); + + // Verify the attributes set + iLog->Log ( _L (" Verify the attributes" ) ); + + if ( !lm_message_node_get_attribute ( Node, "username" ) ) + { + iLog->Log ( _L ( "lm_message_set_attributes failed for username" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + if ( !lm_message_node_get_attribute ( Node, "password" ) ) + { + iLog->Log ( _L ( "lm_message_set_attributes failed for password" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + if ( !lm_message_node_get_attribute ( Node, "xmlns" ) ) + { + iLog->Log ( _L ( "lm_message_set_attributes failed for xmlns" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_set_attributes passed" ) ); + + return KErrNone; +} + + + + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_set_get_raw_mode +// Description:Checks if the nodes values should be sent as raw mode +// Arguements : +// node : an LmMessageNode +// Returns : TRUE if nodes value should be sent as is +// FALSE if the value will be escaped before sending +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_set_get_raw_modeL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + + iLog->Log ( _L ( "In lm_message_node_set_raw_mode" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from message" ) ); + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Set the raw mode to TRUE + iLog->Log ( _L ( "Set the node to raw mode" ) ); + lm_message_node_set_raw_mode ( Node, TRUE ); + + // Check if the Node is in raw mode or not after setting + iLog->Log ( _L ( "Check for raw mode after setting" ) ); + if ( !lm_message_node_get_raw_mode ( Node ) ) + { + iLog->Log ( _L ( "get_raw_mode returned FALSE after setting raw mode" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + // Set the raw mode to FALSE + iLog->Log ( _L ( "Unset the raw mode" ) ); + lm_message_node_set_raw_mode ( Node, FALSE ); + + // Check for raw mode + iLog->Log ( _L ( "Check for raw mode after unsetting" ) ); + if ( lm_message_node_get_raw_mode ( Node ) ) + { + iLog->Log ( _L ( "get_raw_mode returned TRUE after unsetting" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_set_raw_mode passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_ref +// Description:Adds a reference to node +// Arguements : +// node : an LmMessageNode +// Returns : the node +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_refL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + + iLog->Log ( _L ( "In lm_message_node_ref" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from message" ) ); + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Add a reference to node + lm_message_node_ref ( Node ); + + // Loudmouth dont have any API to check reference on message node + // Therefore lm_message_node_ref is considered as passed without checking + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_ref passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_unref +// Description: Removes a reference from the the node. When no more +// reference are present, the node is freed. When freed +// lm_message_node_unref() will be called on all children. +// Check the size of the heap just to verify whether node +// is freed or not when no more references to the node +// Arguements : +// node : an LmMessageNode +// Returns : Node +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_unrefL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_avail_before; + TInt heap_avail_after; + + iLog->Log ( _L ( "In lm_message_node_unref" ) ); + + // Get the heap size before constructing a message + heap_avail_before = heap_handle.Available ( largest_free_block ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from message" ) ); + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Remove reference from the message + iLog->Log ( _L ( "Remove reference from the message" ) ); + lm_message_unref ( message ); + + // Remove reference from the node + iLog->Log ( _L ( "Remove a reference from the node" ) ); + lm_message_node_unref ( Node ); + + // Get the heap size after removing references + heap_avail_after = heap_handle.Available ( largest_free_block ); + + // Verify the heap size + if ( heap_avail_after != heap_avail_before ) + { + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + iLog->Log ( _L ( "Available memory is not as expected after freeing" ) ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Expected: heap_available_before is equal to heap_available_after" ) ); + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_to_string +// Description:Returns an XML string representing the node. This is what +// is sent over the connection. This is used internally by +// loudmouth and is external for debugging purposes +// Arguements : +// node : an LmMessageNode +// Returns : an XML string representation of node +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_to_stringL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + gchar *XmlString = NULL; + + + iLog->Log ( _L ( "In lm_message_node_to_string" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_PRESENCE + iLog->Log ( _L ( "Construct a message with type=presence" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_PRESENCE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed for type = PRESENCE" ) ); + return KErrGeneral; + } + + // Convert node to XML string + XmlString = lm_message_node_to_string ( message->node ); + + // Check in XML string for stanza + if ( !g_strrstr ( XmlString, "presence" ) ) + { + iLog->Log ( _L ( "XML string doesnt contain stanza" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + lm_message_unref ( message ); + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_IQ ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed for type = IQ" ) ); + return KErrGeneral; + } + + // Convert the message node to XML string + XmlString = lm_message_node_to_string ( message->node ); + + // Check in XML string for stanza + if ( !g_strrstr ( XmlString, "iq" ) ) + { + iLog->Log ( _L ( "XML string doesnt contain stanza" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + iLog->Log ( _L ( "lm_message_node_to_string passed" ) ); + lm_message_unref ( message ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_ssl_new +// Description: Creates a new ssl struct +// Arguements : +// expected_fingerprint : The expected fingerprint. ssl_function will be +// called if there is a mismatch. NULL if you +// are not interested in this check. +// ssl_cb : Callback called to inform the user of a problem +// during setting up the SSL connection and how +// to proceed. +// user_data : Data sent with the callback +// notify : Function to free user_data when the connection +// is finished. +// Returns : A new LmSSL struct +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_ssl_newL ( CStifItemParser& /*aItem*/ ) +{ + LmSSL *ssl = NULL; + + iLog->Log ( _L ( "In lm_ssl_new" ) ); + + ssl = lm_ssl_new ( NULL, ( LmSSLFunction ) ssl_cb, NULL, NULL ); + if ( !ssl ) + { + iLog->Log ( _L ( "lm_ssl_new failed" ) ); + return KErrGeneral; + } + + lm_ssl_unref ( ssl ); + + iLog->Log ( _L ( "lm_ssl_new passed" ) ); + + return KErrNone; +} + +// --------------------------------------------------------------------------- +// Ctstlm::lm_ssl_is_supportedL +// Description: Checks wheather the Loudmouth supports SSL or not. +// Arguements : None +// Returns : TRUE if loudmouth supports SSL, FALSE otherwise +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_ssl_is_supportedL ( CStifItemParser& /*aItem*/ ) +{ + iLog->Log ( _L ( "In lm_ssl_is_supported" ) ); + + if ( !lm_ssl_is_supported() ) + { + iLog->Log ( _L ( "Loudmouth installation doesn't support SSL" ) ); + } + else + { + iLog->Log ( _L ( "Loudmouth supports SSL" ) ); + } + + iLog->Log ( _L ( "lm_ssl_is_supported passed" ) ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_ssl_get_fingerprintL +// Description: Returns the MD5 fingerprint of the remote server's certificate. +// Arguements : +// ssl : An LmSSL +// Returns : A 16-byte array indicating fingerprint or NULL if unknow +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_ssl_get_fingerprintL ( CStifItemParser& /*aItem*/ ) +{ + LmSSL *ssl; + + iLog->Log ( _L ( "In lm_ssl_get_fingerprint" ) ); + + ssl = lm_ssl_new ( "--ssl", ( LmSSLFunction )ssl_cb, NULL, NULL ); + + const gchar *fingerprint = lm_ssl_get_fingerprint ( ssl ); + if ( !fingerprint ) + { + iLog->Log ( _L ( "Not able to get the remote server's certificate" ) ); + } + + iLog->Log ( _L ( "lm_ssl_get_fingerprint passed" ) ); + lm_ssl_unref ( ssl ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_ssl_ref +// Description: Adds a reference to ssl +// Arguements : +// ssl : An LmSSL +// Returns : LmSSL +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_ssl_refL ( CStifItemParser& /*aItem*/ ) +{ + LmSSL *ssl; + + iLog->Log ( _L ( "In lm_ssl_ref" ) ); + + ssl = lm_ssl_new ( NULL, NULL, NULL, NULL ); + if ( !ssl ) + { + iLog->Log ( _L ( "lm_ssl_new failed" ) ); + return KErrGeneral; + } + + // Add a reference to ssl + lm_ssl_ref ( ssl ); + + // Loudmouth don't have any API to get the reference to ssl. + // Therefore this test case is considered as passed without verifying it + lm_ssl_unref ( ssl ); + + iLog->Log ( _L ( "lm_ssl_ref passed" ) ); + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_ssl_unref +// Description: Removes a reference from ssl. +// When no more references are present, ssl is freed. +// Check the heap size to ensure that lm_ssl_unref frees the ssl +// when no more references are present. +// Arguements : +// ssl : An LmSSL +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_ssl_unrefL ( CStifItemParser& /*aItem*/ ) +{ + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_avail_before; + TInt heap_avail_after; + + LmSSL *ssl = NULL; + + iLog->Log ( _L ( "In lm_ssl_unref" ) ); + + // Get the heap size before creating a new ssl + heap_avail_before = heap_handle.Available ( largest_free_block ); + + // Create a new ssl + ssl = lm_ssl_new ( NULL, NULL, NULL, NULL ); + if ( !ssl ) + { + iLog->Log ( _L ( "lm_ssl_new failed" ) ); + return KErrGeneral; + } + + // Remove a reference from the ssl + lm_ssl_unref ( ssl ); + + // Get the heap size after freeing memory + heap_avail_after = heap_handle.Available ( largest_free_block ); + + // Compare the heap size + if ( heap_avail_after != heap_avail_before ) + { + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + iLog->Log ( _L ( "Available memory is not as expected after unref" ) ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Expected: heap_avail_before is equal to heap_avail_after" ) ); + iLog->Log ( _L ( "heap_avail_before = %d, heap_avail_after = %d" ), + heap_avail_before, heap_avail_after ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_new +// Description:Creates a new proxy +// Arguements : +// type : proxy type (LM_PROXY_TYPE_NONE/LM_PROXY_TYPE_HTTP) +// Returns : a newly created proxy +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_newL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + LmProxyType Type; + + iLog->Log ( _L ( "In lm_proxy_new" ) ); + + iLog->Log ( _L ( "Create a new proxy" ) ); + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + // Verify the proxy type + iLog->Log ( _L ( "Proxy type verification" ) ); + + Type = lm_proxy_get_type ( proxy ); + if ( LM_PROXY_TYPE_HTTP != Type ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_new passed" ) ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_new_with_server +// Description:Creates a new proxy +// Arguements : +// type : proxy type (LM_PROXY_TYPE_NONE/LM_PROXY_TYPE_HTTP) +// server : proxy server +// port : proxy server port +// Returns : a newly created proxy +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_new_with_serverL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + guint port = 8000; + const gchar *server = "nokia.com"; + + + iLog->Log ( _L ( "In lm_proxy_new_with_server" ) ); + // Create a new proxy with the server + proxy = lm_proxy_new_with_server ( LM_PROXY_TYPE_HTTP, server, port ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new_with_server failed" ) ); + return KErrGeneral; + } + + // Verify proxy type, server and port + iLog->Log ( _L ( "Verify server, type and port in proxy" ) ); + + if ( LM_PROXY_TYPE_HTTP != lm_proxy_get_type ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_new_with_server failed for proxy type setting" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + if ( strcmp ( server, lm_proxy_get_server ( proxy ) ) ) + { + iLog->Log ( _L ( "lm_proxy_new_with_server failed for server setting" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + if ( port != lm_proxy_get_port ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_new_with_server failed for port setting" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_new_with_server passed" ) ); + + return KErrNone; +} + + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_set_get_type +// Description:Sets the proxy type for proxy to type +// Arguements : +// proxy : an LmProxy +// type : proxy type +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_set_get_typeL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + + iLog->Log ( _L ( "In lm_proxy_set_get_type" ) ); + + // Create a new proxy with type=LM_PROXY_TYPE_NONE + proxy = lm_proxy_new ( LM_PROXY_TYPE_NONE ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Set the proxy type=LM_PROXY_TYPE_HTTP + lm_proxy_set_type ( proxy, LM_PROXY_TYPE_HTTP ); + + // Verify the proxy type for LM_PROXY_TYPE_HTTP + if ( LM_PROXY_TYPE_HTTP != lm_proxy_get_type ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_set_type failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_set_get_type passed" ) ); + + return KErrNone; +} + + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_set_get_server +// Description:Sets the server address for proxy +// Arguements : +// proxy : an LmProxy +// server : address of the proxy server +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_set_get_serverL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + const gchar *server = "nokia.com"; + + iLog->Log ( _L ( "In lm_proxy_get_server" ) ); + + // Create a new proxy with type = LM_PROXY_TYPE_HTTP + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Set the proxy server to "nokia.com" + lm_proxy_set_server ( proxy, server ); + + // Verify the server address in proxy + if ( strcmp ( server, lm_proxy_get_server ( proxy ) ) ) + { + iLog->Log ( _L ( "lm_proxy_set_server failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_set_server passed" ) ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_set_port +// Description:Sets the server port that proxy will be using +// Arguements : +// proxy : an LmProxy +// port : proxy server port +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_set_get_portL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + guint port1 = 80; + guint port2 = 21; + + iLog->Log ( _L ( "In lm_proxy_set_get_port" ) ); + + // Create new proxy + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Set the port = port1 + lm_proxy_set_port ( proxy, port1 ); + + // Verify the port + if ( port1 != lm_proxy_get_port ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_set_port failed for port = %d" ), port1 ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + // Set the port = port2 + lm_proxy_set_port ( proxy, port2 ); + + // Verify the port + if ( port2 != lm_proxy_get_port ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_set_port failed for port = %d" ), port2 ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_set_get_port passed" ) ); + + return KErrNone; +} + + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_set_username +// Description:Sets the username for proxy or NULL to unset +// Arguements : +// proxy : an LmProxy +// username : username +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_set_get_usernameL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + const gchar *user1 = "nokia"; + const gchar *user2 = "linux"; + + iLog->Log ( _L ( "In lm_proxy_set_get_username" ) ); + + // Create a new proxy + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Set the proxy username to "nokia" + lm_proxy_set_username ( proxy, user1 ); + + // Verify the proxy username + if ( strcmp ( user1, lm_proxy_get_username ( proxy ) ) ) + { + iLog->Log ( _L ( "lm_proxy_set_username failed for user1" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + // Set the proxy username to "linux" + lm_proxy_set_username ( proxy, user2); + + // Verify the proxy username + if ( strcmp ( user2, lm_proxy_get_username ( proxy ) ) ) + { + iLog->Log ( _L ( "lm_proxy_set_username failed for user2" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + lm_proxy_unref ( proxy ); + + iLog->Log ( _L ( "lm_proxy_set_get_username passed" ) ); + + return KErrNone; +} + + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_set_password +// Description:Sets the password for proxy +// Arguements : +// proxy : an LmProxy +// Returns : the proxy password +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_set_get_passwordL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + const gchar *password = "nokia"; + + iLog->Log ( _L ( "In lm_proxy_set_get_passrod" ) ); + + // Create a new proxy + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Set the password proxy to "nokia" + lm_proxy_set_password ( proxy, password ); + + // Verify the password + if ( strcmp ( password, lm_proxy_get_password ( proxy ) ) ) + { + iLog->Log ( _L ( "lm_proxy_set_password failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + // Unset the password + lm_proxy_set_password ( proxy, NULL ); + + // Verify the password + if ( lm_proxy_get_password ( proxy ) ) + { + iLog->Log ( _L ( "lm_proxy_set_password failed" ) ); + lm_proxy_unref ( proxy ); + return KErrGeneral; + } + + iLog->Log ( _L ( "lm_proxy_set_password passed" ) ); + lm_proxy_unref ( proxy ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_ref +// Description:Adds a reference to proxy +// Arguements : +// proxy : an LmProxy +// Returns : the proxy +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_refL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + + iLog->Log ( _L ( "In lm_proxy_ref" ) ); + + // Creat a new proxy + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Add a reference to proxy + proxy = lm_proxy_ref ( proxy ); + + // Loudmouth don't provide API for getting reference to the proxy + // Therefore this test case is considered as passed without checking + iLog->Log ( _L ( "lm_proxy_ref passed" ) ); + lm_proxy_unref ( proxy ); + lm_proxy_unref ( proxy ); + + return KErrNone; +} + + +// --------------------------------------------------------------------------- +// Ctstlm::lm_proxy_unref +// Description:Removes a reference from the proxy +// When no more rererences are present proxy is freed +// Check the heap size to ensure that lm_proxy_unref free +// the proxy when no more references are present. +// Arguements : +// proxy : an LmProxy +// Returns : None +// --------------------------------------------------------------------------- +// +TInt Ctstlm::lm_proxy_unrefL ( CStifItemParser& /*aItem*/ ) +{ + LmProxy *proxy = NULL; + + RHeap& heap_handle = User::Heap(); + TInt largest_free_block; + TInt heap_avail_before; + TInt heap_avail_after; + + iLog->Log ( _L ( "In lm_proxy_unref" ) ); + + // Get the heap size before creating a new proxy + heap_avail_before = heap_handle.Available ( largest_free_block ); + + // Create a new proxy + proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP ); + if ( !proxy ) + { + iLog->Log ( _L ( "lm_proxy_new failed" ) ); + return KErrGeneral; + } + + // Remove a reference from the proxy + lm_proxy_unref ( proxy ); + + // Get the heap size + heap_avail_after = heap_handle.Available ( largest_free_block ); + + // Compare the heap size + if ( heap_avail_after != heap_avail_before ) + { + iLog->Log ( _L ( "heap_available_before = %d, heap_available_after = %d" ), + heap_avail_before, heap_avail_after ); + iLog->Log ( _L ( "Available memory is not as expected after freeing" ) ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Expected: heap_available_before is equal to heap_available_after" ) ); + iLog->Log ( _L ( "heap_available_before = %d, heap_available_after = %d" ), + heap_avail_before, heap_avail_after ); + iLog->Log ( _L ( "lm_message_unref passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_send_sync +// Description : Opens a connection with the gtalk server and sends a jabber +// message to the another person +// Requires : This test case requires GUI mode for selecting Access point +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_send_syncL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + LmMessage *message = NULL; + + ConnectData *connect_data = NULL; + + GError *error = NULL; + + iLog->Log ( _L ( "In lm_send_sync" ) ); + + // Read data from the CFG file + iLog->Log ( _L ( "Reading data from the CFG file" ) ); + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "Read data from the CFG file" ) ); + iLog->Log ( _L8 ( "Server name: %s" ), connect_data->server ); + + // Open a new closed connection + iLog->Log ( _L ( "Open a new closed connection" ) ); + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "New closed connection opened" ) ); + + iLog->Log ( _L ( "Setting jid" ) ); + lm_connection_set_jid ( connection, connect_data->username ); + + iLog->Log ( _L ( "Setting gtalks SSL port" ) ); + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Proxy settings for emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set connection to use SSL + iLog->Log ( _L ( "Setting SSL for the connection" ) ); + SSLInit ( connection ); + + iLog->Log ( _L ( "Open a connection with the server" ) ); + //Calling connection open + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + iLog->Log ( _L ( "connection with the server successfull" ) ); + + iLog->Log ( _L ( "Getting the username from the server" ) ); + iLog->Log ( _L8 ( "jid: %s" ), connect_data->username ); + // Get the user from the full JID + gchar *username = get_user_name ( connect_data->username ); + iLog->Log ( _L ( "after extracting from the jid: %s" ), username ); + + + iLog->Log ( _L ( "Authenticating with the server" ) ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + iLog->Log ( _L ( "Authentication done" ) ); + + // Send a message to the server + iLog->Log ( _L8 ( "Create a new message: %s" ), + connect_data->msg_data->recipient ); + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "Add a node" ) ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message ); + + + iLog->Log ( _L ( "Send message to the server" ) ); + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "Message has been sent" ) ); + + iLog->Log ( _L ( "Free the allocated resources" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + iLog->Log ( _L ( "Freed" ) ); + + iLog->Log ( _L ( "lm_send_sync passed" ) ); + + return KErrNone; + } + + //----------------------------------------------------------------------------- +// Ctstlm::lm_is_authenticated_WhenNotAuthenticatedL +// Description : Check if connection is authenticated or not +// Arguements : +// connection : an LmConnection to check +// Returns : TRUE if connection is authenticated, FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_is_authenticated_WhenNotAuthenticatedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + gboolean NotAuthenticated = FALSE; + + iLog->Log ( _L ( "In lm_connection_is_authenticated" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the connection to use gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID to be used for connection + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // Open a connection + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + // Check for authentication after the connection is authenticated + if ( lm_connection_is_authenticated ( connection ) ) + { + iLog->Log ( _L ( "lm_is_authenticated_WhenNotAuthenticatedL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_is_authenticated_WhenNotAuthenticatedL passed" ) ); + + return KErrNone; + } + + + +//-------------------------------------------------------------------------------- +// function_name : handle_fetch_contactlist_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_fetch_contactlist_messages ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + break; + case LM_MESSAGE_SUB_TYPE_ERROR: + //return NULL; + break; + // default: + // g_assert_not_reached (); + // break; + } + + q_node = lm_message_node_get_child (reply->node, "query"); + + if (!q_node) + { + //return NULL; + } + + item_node = lm_message_node_get_child (q_node, "item"); + + while (item_node) + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(item_node,"jid"); + char* friendname; + const char* atstring = "@"; + friendname = strtok((char*)reply_string,atstring ); + item_node = item_node->next; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_fetching_contactlistL +// Description : fetching contact list +// Arguements : +// connection : +// message : +// error : +// Returns : +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_fetching_contactlist_L ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode *q_node; + //LmMessageSubType type; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_fetching_contactlist_L" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + //Open call + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node, + "xmlns", "jabber:iq:roster", + NULL); + // Send message to the server + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_fetching_contactlist_L passed" ) ); + + return KErrNone; + } + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_fetching_presenceL +// Description : fetching contact list +// Arguements : +// connection : +// message : +// error : +// Returns : +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_fetching_presenceL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + //LmMessageNode *q_node; + // LmMessageSubType type; + LmMessageHandler *handler = NULL; + GMainLoop *main_loop = NULL; + + iLog->Log ( _L ( "In lm_fetching_presenceL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + + gboolean result = lm_connection_send ( connection, message, NULL ); + // Close the connection + main_loop = g_main_loop_new ( NULL, FALSE ); + + //------------------------------------------------------------------------ + // + // Register a handler to recieve and update presence information + // + handler = lm_message_handler_new ( + (LmHandleMessageFunction)jabber_presence_handler_cb, + main_loop, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_PRESENCE, + LM_HANDLER_PRIORITY_NORMAL ); + + //------------------------------------------------------------------------ + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + // Remove a reference on message + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + + // Message sending passed + iLog->Log ( _L ( "lm_fetching_presenceL passed" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_subscribe_contact_L +// Description : fetching contact list +// Arguements : +// connection : +// message : +// error : +// Returns : +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_subscribe_contact_L ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + //LmMessageNode *q_node; + //LmMessageSubType type; + + iLog->Log ( _L ( "In lm_subscribe_contact_L" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // Open a connection with the server + GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) connection_open_cb, + main_loop1, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop1 ); + free_data ( connect_data ); + return KErrGeneral; + } + + + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + GMainLoop *main_loop2 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop2,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop2 ); + g_main_loop_unref ( main_loop2 ); + g_free ( username ); + + + gchar *jid = "rakesh.harsha@gmail.com"; + message = lm_message_new (jid, LM_MESSAGE_TYPE_PRESENCE ); + lm_message_node_set_attribute ( message->node, "type", "subscribe" ); + //Send the message + if ( !lm_connection_send ( connection, message, NULL ) ) + { + lm_message_unref ( message ); + return KErrGeneral; + } + + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + // Remove a reference on message + lm_message_unref ( message ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_subscribe_contact_L passed" ) ); + return KErrNone; + } + + + + //----------------------------------------------------------------------------- +// Ctstlm::lm_authenticate_WithUnexistingJID +// Description : Tries to authenticate a user against the server. +// Arguements : +// connection : an LmConnection +// username : Username used to authenticate +// password : Password corresponding to Username +// resource : Resource used for this connection +// error : location to store error, or NULL +// Returns : TRUE if no errors were detected & authentication was +// successful, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_authenticate_WithUnexistingJID ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + //ConnectData *connect_data = NULL; + AuthData *auth_data = NULL; + //GMainLoop *main_loop = NULL; + //GMainContext *context = NULL; + + iLog->Log ( _L ( "In lm_connection_authenticate" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + g_free ( auth_data ); + return KErrGeneral; + } + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + auth_data->rCode = RC_ERROR; + + //connection = lm_connection_new_with_context ( connect_data->server,context ); + connection = lm_connection_new ( auth_data->connect_data->server ); + if ( connection == NULL ) + { + iLog->Log ( _L ( "lm_connection_new_with_context failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + SSLInit ( connection ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) connection_open_cb, + auth_data->main_loop, + NULL, + NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + + // Extract the username from the JID + gchar *username = get_user_name ( auth_data->connect_data->username ); + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + if ( !lm_connection_authenticate ( connection, + username, + auth_data->connect_data->password, + auth_data->connect_data->resource, + ( LmResultFunction ) wrong_input_auth_cb, + auth_data , + NULL, + NULL ) ) + { + auth_data->rCode = RC_ERROR; + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + g_free ( username ); + g_main_loop_unref ( auth_data->main_loop ); + free_data ( auth_data->connect_data ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( username ); + + + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode == RC_ERROR ) + { + iLog->Log ( _L ( "lm_authenticate_WithUnexistingJID failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_free ( auth_data ); + + iLog->Log ( _L ( "lm_authenticate_WithUnexistingJID passed" ) ); + + return KErrNone; +} + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_authenticate_WithBadPasswordL +// Description : Tries to authenticate a user against the server. +// Arguements : +// connection : an LmConnection +// username : Username used to authenticate +// password : Password corresponding to Username +// resource : Resource used for this connection +// error : location to store error, or NULL +// Returns : TRUE if no errors were detected & authentication was +// successful, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_authenticate_WithBadPasswordL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + //ConnectData *connect_data = NULL; + AuthData *auth_data = NULL; + //GMainLoop *main_loop = NULL; + //GMainContext *context = NULL; + + iLog->Log ( _L ( "In lm_connection_authenticate" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + g_free ( auth_data ); + return KErrGeneral; + } + + //context = g_main_context_new (); + //main_loop = g_main_loop_new ( context, FALSE ); + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + //auth_data->connect_data = connect_data; + auth_data->rCode = RC_ERROR; + //auth_data->main_loop = main_loop; + + //connection = lm_connection_new_with_context ( connect_data->server,context ); + connection = lm_connection_new ( auth_data->connect_data->server ); + if ( connection == NULL ) + { + iLog->Log ( _L ( "lm_connection_new_with_context failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + SSLInit ( connection ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) auth_from_open_cb, + auth_data, + NULL, + NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode == RC_ERROR ) + { + iLog->Log ( _L ( "lm_authenticate_WithBadPasswordL failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_free ( auth_data ); + + iLog->Log ( _L ( "lm_authenticate_WithBadPasswordL passed" ) ); + + return KErrNone; +} + + //----------------------------------------------------------------------------- +// Ctstlm::lm_authenticate_WhenConnectionIsNotOpenedL +// Description : Tries to authenticate a user against the server.handles +// a reply to the authentication in callback method +// Arguments : +// connection : an LmConnection +// username : Username used to authenticate +// password : Password corresponding to Username +// resource : Resource used for this connection +// error : location to store error, or NULL +// Returns : TRUE if no errors were detected & authentication was +// successful, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_authenticate_WhenConnectionIsNotOpenedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + + iLog->Log ( _L ( "In lm_authenticate_WhenConnectionIsNotOpenedL" ) ); + + // Read data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( connection == NULL) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + SSLInit ( connection ); + + + + // Get the username from the JID + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server without doing a connection open + if (! lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_open_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_authenticate_WhenConnectionIsNotOpened passed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + //returning kerrnone since we are testing negative scenario and this call is + //expected to return false + return KErrNone; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + + iLog->Log ( _L ( "lm_authenticate_WhenConnectionIsNotOpened when connection is not opened failed since connection must be already open" ) ); + //Returning KErrNone, since the test case could not be tested as the connection must be open + //The control will never come here for the test case :) + return KErrNone; + } + + + //----------------------------------------------------------------------------- +// Ctstlm::lm_connection_open_with_badserver server name +// Description : Tries to authenticate a user against the wrong server. +// Arguements : +// connection : an LmConnection +// username : Username used to authenticate +// password : Password corresponding to Username +// resource : Resource used for this connection +// error : location to store error, or NULL +// Returns : TRUE if no errors were detected & authentication was +// successful, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_open_with_badserverL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + //ConnectData *connect_data = NULL; + AuthData *auth_data = NULL; + //GMainLoop *main_loop = NULL; + //GMainContext *context = NULL; + + iLog->Log ( _L ( "In lm_connection_open_with_badserverL" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + g_free ( auth_data ); + return KErrGeneral; + } + + //context = g_main_context_new (); + //main_loop = g_main_loop_new ( context, FALSE ); + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + //auth_data->connect_data = connect_data; + auth_data->rCode = RC_ERROR; + //auth_data->main_loop = main_loop; + + //connection = lm_connection_new_with_context ( connect_data->server,context ); + connection = lm_connection_new ( auth_data->connect_data->server ); + if ( connection == NULL ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + SSLInit ( connection ); + + if ( !lm_connection_open ( connection, + ( LmResultFunction ) wrong_input_in_open_cb, + auth_data, + NULL, + NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" ) ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( auth_data ); + return KErrGeneral; + } + + + g_main_loop_run ( auth_data->main_loop ); + iLog->Log ( _L ( "main loop exited returned" ) ); + g_main_loop_unref ( auth_data->main_loop ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode == RC_ERROR ) + { + iLog->Log ( _L ( "lm_connection_open_with_badserver failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_free ( auth_data ); + + iLog->Log ( _L ( "lm_connection_open_with_badserver passed" ) ); + + return KErrNone; +} + + +// ---------------------------------------------------------------------------- +// Ctstlm::lm_message_node_get_child +// Description:Fetches the child from node. If child is not found as an +// immediate child of node, NULL is returned +// Arguements : +// node : an LmMessageNode +// name : name of the new child +// value : value of the new child +// Returns : the child node or NULL if child not found +// ---------------------------------------------------------------------------- +// +TInt Ctstlm::lm_message_node_get_childL ( CStifItemParser& /*aItem*/ ) +{ + LmMessage *message = NULL; + LmMessageNode *Node = NULL; + const gchar *Username = "Nokia"; + const gchar *Password = "Nokia"; + + iLog->Log ( _L ( "In lm_message_node_get_child" ) ); + + // Construct a message with type = LM_MESSAGE_TYPE_MESSAGE + iLog->Log ( _L ( "Construct a message" ) ); + + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + if ( !message ) + { + iLog->Log ( _L ( "lm_message_new failed" ) ); + return KErrGeneral; + } + + // Retrive the root node from message + iLog->Log ( _L ( "Retrive the root node from the message" ) ); + + Node = lm_message_get_node ( message ); + if ( !Node ) + { + iLog->Log ( _L ( "lm_message_get_node failed" ) ); + lm_message_unref ( message ); + return KErrGeneral; + } + + // Add childrens + iLog->Log ( _L ( "Adding childrens 'username' and 'password'" ) ); + lm_message_node_add_child ( Node, "username", Username ); + lm_message_node_add_child ( Node, "password", Password ); + + // Verify the childs + iLog->Log ( _L ( "Verify the childs" ) ); + + if ( !lm_message_node_get_child ( Node, "username" ) ) + { + iLog->Log ( _L ( "lm_message_get_child failed" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + if ( !lm_message_node_get_child ( Node, "password" ) ) + { + iLog->Log ( _L ( "lm_message_get_child failed" ) ); + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + return KErrGeneral; + } + + lm_message_unref ( message ); + lm_message_node_unref ( Node ); + + iLog->Log ( _L ( "lm_message_node_get_child passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_receive_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_receive_messages ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* /*message*/, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + + + +//----------------------------------------------------------------------------- +// function_name : connection_auth_cb +// description : callback function set by lm_connection_authenticate +// in lm_connection_sendL() +// Returns : None +//----------------------------------------------------------------------------- +// +static void lm_login_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 ); + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_login_testL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_login_testL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + //ConnectData *connect_data = NULL; + AuthData *auth_data = NULL; + + + iLog->Log ( _L ( "In lm_login_testL" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + // Read a data from the CFG file + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( auth_data->connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( auth_data->connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + auth_data->main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( auth_data->main_loop ); + free_data ( auth_data->connect_data ); + + g_free(auth_data); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( auth_data->main_loop ); + + g_main_loop_unref ( auth_data->main_loop ); + + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( auth_data->connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + auth_data->connect_data->password, + auth_data->connect_data->resource, + ( LmResultFunction ) lm_login_cb, + auth_data,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( username ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( username ); + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode == RC_ERROR ) + { + iLog->Log ( _L ( "lm_login_testL failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + g_free ( auth_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_login_testL passed" ) ); + + return KErrNone; +} + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send400charL +// Description : Asynchronous call to send a message of 400 characters +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send400charL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "In lm_connection_send" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + + gchar* msg = {"sdfsadFsdfsadfsdfsdjfksdjfl;jdsf;jsadfl;jsdvdfggdfg: \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer \ + fjsdljfsldfjsfwerpwerpweripwierweirpiwepriwperiwperipwer"}; + + lm_message_node_add_child ( message->node, "body", + msg ); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + // Remove a reference on message + lm_message_unref ( message ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; + + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_repeatedL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_repeatedL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "In lm_connection_send_repeatedL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_repeatedL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_repeatedL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_repeatedL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_repeatedL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; +} +//-------------------------------------------------------------------------------- +// function_name : handle_add_contact +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_add_contact ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_SET: + { + /* + + + + Servants + + + + */ + q_node = lm_message_node_get_child (reply->node, "query"); + if (q_node) + { + item_node = lm_message_node_get_child (q_node, "item"); + if(item_node) + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(item_node,"jid"); + } + + } + + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + + + */ + //return NULL; + LmMessageNode* error_node=NULL; + LmMessageNode* error_node_child=NULL; + error_node = lm_message_node_get_child (reply->node, "error"); + if(error_node) + { + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + error_node_child = lm_message_node_get_child (error_node, "item-not-found"); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_add_contactL +// Description : Asynchronous call to add a new contact +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_add_contactL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode *q_node,*item_node; + LmMessageHandler* handler = NULL; + + iLog->Log ( _L ( "In lm_add_contactL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /***********fetch contact list********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node,"xmlns", "jabber:iq:roster",NULL); + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + // Send message to the server + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /****send own presence********/ + + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + gboolean result = lm_connection_send ( connection, message, NULL ); + lm_message_unref ( message ); + + /*********Send request to add a contact**********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient ); + //If we specify the name we cannot add the contact, maybe the name has to be unique. + /*lm_message_node_set_attribute ( item_node, "name", "harsh_rakesh" ); + if ( group ) + { + lm_message_node_add_child ( item, "group", group ); + }*/ + + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + // Send subscription request to the server + message = lm_message_new_with_sub_type ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_SUBSCRIBE ); + result = lm_connection_send ( connection, message, NULL ) ; + // Remove a reference on message + lm_message_unref ( message ); + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_add_contactL passed" ) ); + + return KErrNone; +} +//----------------------------------------------------------------------------- +// Ctstlm::lm_remove_contactL +// Description : Asynchronous call to add a new contact +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_remove_contactL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode *q_node,*item_node; + LmMessageHandler* handler = NULL; + TBool result = EFalse; + + iLog->Log ( _L ( "In lm_remove_contactL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /***********fetch contact list********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node,"xmlns", "jabber:iq:roster",NULL); + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + // Send message to the server + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /*********Send request to ADD a contact**********************/ + //If we specify the name we cannot add the contact, maybe the name has to be unique. + /*lm_message_node_set_attribute ( item_node, "name", "harsh_rakesh" ); + if ( group ) + { + lm_message_node_add_child ( item, "group", group ); + } + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient ); + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + // Send subscription request to the server + message = lm_message_new_with_sub_type ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_SUBSCRIBE ); + result = lm_connection_send ( connection, message, NULL ) ; + lm_message_unref ( message ); + + /*********Send request to REMOVE a contact**********************/ + /* + + + + + + */ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient ); + lm_message_node_set_attribute ( item_node, "subscription", "remove" ); + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_remove_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /***********FETCH contact list********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node,"xmlns", "jabber:iq:roster",NULL); + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + // Send message to the server + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /*********Send request to ADD a contact**********************/ + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient); + + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + // Send subscription request to the server + message = lm_message_new_with_sub_type ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_SUBSCRIBE ); + result = lm_connection_send ( connection, message, NULL ) ; + // Remove a reference on message + lm_message_unref ( message ); + + /***********FETCH contact list********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node,"xmlns", "jabber:iq:roster",NULL); + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + // Send message to the server + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /*********Send request to REMOVE a contact**********************/ + /* + + + + + + */ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient ); + lm_message_node_set_attribute ( item_node, "subscription", "remove" ); + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_remove_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /***********FETCH contact list********************/ + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node,"xmlns", "jabber:iq:roster",NULL); + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + // Send message to the server + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + /*********Send request to ADD a contact**********************/ + //If we specify the name we cannot add the contact, maybe the name has to be unique. + /*lm_message_node_set_attribute ( item_node, "name", "harsh_rakesh" ); + if ( group ) + { + lm_message_node_add_child ( item, "group", group ); + } + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + item_node = lm_message_node_add_child ( q_node, "item", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:roster" ); + lm_message_node_set_attribute ( item_node, "jid", connect_data->msg_data->recipient ); + // Send message to the server + handler = lm_message_handler_new ( handle_add_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + // Send subscription request to the server + message = lm_message_new_with_sub_type ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_SUBSCRIBE ); + result = lm_connection_send ( connection, message, NULL ) ; + lm_message_unref ( message ); + + /***********cleanup*****************/ + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_remove_contactL passed" ) ); + + return KErrNone; +} +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_receiveL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send and receive +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_receiveL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessage *messagetoself = NULL; + LmMessageHandler *handler = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "In lm_connection_send" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + //------------------------------------------------------------------------ + //Send own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + + gboolean result = lm_connection_send ( connection, message, NULL ); + + //------------------------------------------------------------------------ + // + // Register a handler to recieve msgs + // + main_loop = g_main_loop_new ( NULL, FALSE ); + handler = lm_message_handler_new ( + (LmHandleMessageFunction)handle_messages, + main_loop, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_MESSAGE, + LM_HANDLER_PRIORITY_FIRST ); + + // Construct a message for sending to self + messagetoself = lm_message_new ( connect_data->username, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, messagetoself, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( messagetoself ); + lm_message_unref ( message ); + g_main_loop_unref ( main_loop ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + return KErrGeneral; + } + // Wait for the message sent to self + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_handler_unref(handler); + // Remove a reference on message + lm_message_unref ( message ); + lm_message_unref ( messagetoself ); + + //------------------------------------------------------------------------ + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; +} + + + +//----------------------------------------------------------------------------- +// funnction_name : connection_open_cancel_cb +// description : callback function called by lm_connection_open +// Returns : None +//----------------------------------------------------------------------------- +// +static void +connection_open_cancel_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 ); + } + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_cancel_openL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_cancel_openL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + + iLog->Log ( _L ( "In lm_connection_cancel_openL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cancel_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + if(!lm_connection_is_open(connection)) + { + lm_connection_cancel_open(connection); + //lm_connection_unref(connection); + } + + //g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_cancel_openL passed" ) ); + + return KErrNone; + } + +//-------------------------------------------------------------------------------- +// function_name : handle_get_privacy_lists +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_get_privacy_lists ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + /* + + + + + + + + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* list_name1,*list_name2,*list_name3,*list_name4; + q_node = lm_message_node_get_child (reply->node, "query"); + item_node = lm_message_node_get_child (q_node, "list"); + list_name1 = lm_message_node_get_attribute(item_node,"name"); + + item_node = lm_message_node_get_child(q_node, "list"); + list_name2 = lm_message_node_get_attribute(item_node,"name"); + + item_node = lm_message_node_get_child (q_node, "active"); + if(item_node!=NULL) + list_name3 = lm_message_node_get_attribute(item_node,"name"); + + item_node = lm_message_node_get_child (q_node, "default"); + if(item_node!=NULL) + list_name4 = lm_message_node_get_attribute(item_node,"name"); + + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + OR + + + + */ + const char* error_type; + q_node = lm_message_node_get_child (reply->node, "query"); + item_node = lm_message_node_get_child (q_node, "error"); + error_type = lm_message_node_get_attribute(item_node,"type"); + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + + if (!q_node) + { + //return NULL; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_get_privacy_listsL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_get_privacy_listsL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_get_privacy_listsL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_get_privacy_listsL passed" ) ); + + return KErrNone; +} + + +//-------------------------------------------------------------------------------- +// function_name : handle_set_privacy_lists +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_set_privacy_lists ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + /* + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + */ + if (q_node) + { + LmMessageNode* error_node = NULL; + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_privacy_listsL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_privacy_listsL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_privacy_listsL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + + + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "deny" ); + lm_message_node_set_attribute ( item_node2, "order", "3" ); + + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "active" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "deny" ); + lm_message_node_set_attribute ( item_node2, "order", "4" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_privacy_listsL passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_send_image_cb +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_send_image_cb ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + SendStreamData *stream_data = ( SendStreamData * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + ... + + + + */ + + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + q_node = lm_message_node_get_child (reply->node, "error"); + if (q_node) + { + const char* error_code; + error_code = lm_message_node_get_attribute(q_node,"code"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + if(item_node==NULL) + { + item_node = lm_message_node_get_child (q_node, "remote-server-timeout"); + } + } + + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( stream_data->main_loop ) + { + g_main_loop_quit ( stream_data->main_loop ); + } + lm_message_unref(stream_data->message); + lm_message_handler_unref(stream_data->handler); + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//-------------------------------------------------------------------------------- +// function_name : handle_send_image_stream_msg_open_cb +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_send_image_stream_msg_open_cb ( LmMessageHandler* /*handler*/, + LmConnection* connection, + LmMessage* reply, + gpointer user_data ) + { + SendStreamData *stream_data = ( SendStreamData * )user_data; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode *item_node1 = NULL; + LmMessageNode *item_node2 = NULL; + LmMessageNode* item_node = NULL; + LmMessage * message = NULL; + LmMessageHandler* handler = NULL; + type = lm_message_get_sub_type (reply); + /* + //success response + + + //error response + + + + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(q_node,"id"); + + /****************************************************/ + // send bytes in message + /* + + + qANQR1DBwU4DX7jmYZnncmUQB/9KuKBddzQH+tZ1ZywKK0yHKnq57kWq+RFtQdCJ + WpdWpR0uQsuJe7+vh3NWn59/gTc5MDlX8dS9p0ovStmNcyLhxVgmqS8ZKhsblVeu + IpQ0JgavABqibJolc3BKrVtVV1igKiX/N7Pi8RtY1K18toaMDhdEfhBRzO/XB0+P + AQhYlRjNacGcslkhXqNjK5Va4tuOAPy2n1Q8UUrHbUd0g+xJ9Bm0G0LZXyvCWyKH + kuNEHFQiLuCY6Iv0myq6iX6tjuHehZlFSh80b5BVV9tNLwNR5Eqz1klxMhoghJOA + + + + + + + */ + message = lm_message_new ( NULL, LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_set_attribute ( message->node, "to", "donna.prima@gmail.com" ); + q_node = lm_message_node_add_child ( message->node, "data", + "qANQR1DBwU4DX7jmYZnncmUQB/9KuKBddzQH+tZ1ZywKK0yHKnq57kWq+RFtQdCJ \ + WpdWpR0uQsuJe7+vh3NWn59/gTc5MDlX8dS9p0ovStmNcyLhxVgmqS8ZKhsblVeu \ + IpQ0JgavABqibJolc3BKrVtVV1igKiX/N7Pi8RtY1K18toaMDhdEfhBRzO/XB0+P \ + AQhYlRjNacGcslkhXqNjK5Va4tuOAPy2n1Q8UUrHbUd0g+xJ9Bm0G0LZXyvCWyKH \ + kuNEHFQiLuCY6Iv0myq6iX6tjuHehZlFSh80b5BVV9tNLwNR5Eqz1klxMhoghJOA" ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/ibb" ); + lm_message_node_set_attribute ( q_node, "sid", "mySID" ); + lm_message_node_set_attribute ( q_node, "seq", "0" ); + + q_node = lm_message_node_add_child ( message->node, "amp", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/amp" ); + item_node1 = lm_message_node_add_child ( q_node, "rule", NULL ); + lm_message_node_set_attribute ( item_node1, "condition", "deliver" ); + lm_message_node_set_attribute ( item_node1, "value", "stored" ); + lm_message_node_set_attribute ( item_node1, "action", "error" ); + item_node2 = lm_message_node_add_child ( q_node, "rule", NULL ); + lm_message_node_set_attribute ( item_node1, "condition", "match-resource" ); + lm_message_node_set_attribute ( item_node1, "value", "exact" ); + lm_message_node_set_attribute ( item_node1, "action", "error" ); + + stream_data->message = message; + + // Send message to the server + handler = lm_message_handler_new ( handle_send_image_cb, stream_data, NULL ); + + stream_data->handler = handler; + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + //lm_connection_close ( connection, NULL ); + //lm_connection_unref ( connection ); + lm_message_unref ( stream_data->message ); + lm_message_handler_unref(stream_data->handler); + if ( stream_data->main_loop) + { + g_main_loop_quit ( stream_data->main_loop ); + } + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + /****************************************************/ + break; + } + + case LM_MESSAGE_SUB_TYPE_ERROR: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + q_node = lm_message_node_get_child (reply->node, "error"); + if (q_node) + { + const char* error_code; + error_code = lm_message_node_get_attribute(q_node,"code"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + } + if ( stream_data->main_loop) + { + g_main_loop_quit ( stream_data->main_loop ); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_image_bytestream_msgL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_image_bytestream_msgL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + SendStreamData* stream_data = NULL; + iLog->Log ( _L ( "In lm_connection_send_imageL" ) ); + + stream_data = g_new0 ( SendStreamData, 1 ); + if (! stream_data ) + { + return KErrGeneral; + } + if ( read_data ( stream_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( stream_data->connect_data ); + g_free ( stream_data ); + return KErrGeneral; + } + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + stream_data->rCode = RC_ERROR; + + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( stream_data->connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( stream_data->connect_data ); + g_free(stream_data); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, stream_data->connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, stream_data->connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + stream_data->main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( stream_data->main_loop ); + free_data ( stream_data->connect_data ); + g_free(stream_data); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + + + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( stream_data->connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + stream_data->connect_data->password, + stream_data->connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + stream_data->main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( stream_data->connect_data ); + g_main_loop_unref ( stream_data->main_loop ); + g_free(stream_data); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + g_free ( username ); + + /**************************************/ + //Opening a byte stream + /* + + + + */ + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + lm_message_node_set_attribute ( message->node, "to", "donna.prima@gmail.com" ); + q_node = lm_message_node_add_child ( message->node, "open", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/ibb" ); + lm_message_node_set_attribute ( q_node, "sid", "mySID" ); + lm_message_node_set_attribute ( q_node, "block-size", "4096" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_send_image_stream_msg_open_cb, stream_data, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( stream_data->connect_data ); + g_main_loop_unref ( stream_data->main_loop ); + g_free(stream_data); + return KErrGeneral; + } + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + /***************************************/ + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send_imageL passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_send_image_iq_cb +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_send_image_iq_cb ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + SendStreamData* stream_data = ( SendStreamData * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + ... + + + + + */ + + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + q_node = lm_message_node_get_child (reply->node, "error"); + if (q_node) + { + const char* error_code; + error_code = lm_message_node_get_attribute(q_node,"code"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + if(item_node==NULL) + { + item_node = lm_message_node_get_child (q_node, "remote-server-timeout"); + } + } + + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( stream_data->main_loop ) + { + g_main_loop_quit ( stream_data->main_loop ); + } + lm_message_unref(stream_data->message); + lm_message_handler_unref(stream_data->handler); + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//-------------------------------------------------------------------------------- +// function_name : handle_send_image_stream_iq_open_cb +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_send_image_stream_iq_open_cb ( LmMessageHandler* /*handler*/, + LmConnection* connection, + LmMessage* reply, + gpointer user_data ) + { + SendStreamData *stream_data = ( SendStreamData * )user_data; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode* item_node = NULL; + LmMessage * message = NULL; + LmMessageHandler* handler = NULL; + type = lm_message_get_sub_type (reply); + /* + //success response + + + //error response + + + + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(q_node,"id"); + + /****************************************************/ + // send bytes in message + /* + + + qANQR1DBwU4DX7jmYZnncmUQB/9KuKBddzQH+tZ1ZywKK0yHKnq57kWq+RFtQdCJ + WpdWpR0uQsuJe7+vh3NWn59/gTc5MDlX8dS9p0ovStmNcyLhxVgmqS8ZKhsblVeu + IpQ0JgavABqibJolc3BKrVtVV1igKiX/N7Pi8RtY1K18toaMDhdEfhBRzO/XB0+P + AQhYlRjNacGcslkhXqNjK5Va4tuOAPy2n1Q8UUrHbUd0g+xJ9Bm0G0LZXyvCWyKH + kuNEHFQiLuCY6Iv0myq6iX6tjuHehZlFSh80b5BVV9tNLwNR5Eqz1klxMhoghJOA + + + */ + message = lm_message_new_with_sub_type( NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET); + lm_message_node_set_attribute ( message->node, "to", "donna.prima@gmail.com" ); + q_node = lm_message_node_add_child ( message->node, "data", + "qANQR1DBwU4DX7jmYZnncmUQB/9KuKBddzQH+tZ1ZywKK0yHKnq57kWq+RFtQdCJ \ + WpdWpR0uQsuJe7+vh3NWn59/gTc5MDlX8dS9p0ovStmNcyLhxVgmqS8ZKhsblVeu \ + IpQ0JgavABqibJolc3BKrVtVV1igKiX/N7Pi8RtY1K18toaMDhdEfhBRzO/XB0+P \ + AQhYlRjNacGcslkhXqNjK5Va4tuOAPy2n1Q8UUrHbUd0g+xJ9Bm0G0LZXyvCWyKH \ + kuNEHFQiLuCY6Iv0myq6iX6tjuHehZlFSh80b5BVV9tNLwNR5Eqz1klxMhoghJOA" ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/ibb" ); + lm_message_node_set_attribute ( q_node, "sid", "mySID" ); + lm_message_node_set_attribute ( q_node, "seq", "0" ); + stream_data->message = message; + + // Send message to the server + handler = lm_message_handler_new ( handle_send_image_iq_cb, stream_data, NULL ); + stream_data->handler = handler; + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + lm_message_unref ( stream_data->message ); + lm_message_handler_unref(stream_data->handler); + if ( stream_data->main_loop) + { + g_main_loop_quit ( stream_data->main_loop ); + } + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + /****************************************************/ + break; + } + + case LM_MESSAGE_SUB_TYPE_ERROR: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + q_node = lm_message_node_get_child (reply->node, "error"); + if (q_node) + { + const char* error_code; + error_code = lm_message_node_get_attribute(q_node,"code"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + } + if ( stream_data->main_loop) + { + g_main_loop_quit ( stream_data->main_loop ); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_image_bytestream_iqL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_image_bytestream_iqL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node= NULL; + LmMessageHandler *handler = NULL; + SendStreamData* stream_data = NULL; + iLog->Log ( _L ( "In lm_connection_send_imageL" ) ); + + stream_data = g_new0 ( SendStreamData, 1 ); + if (! stream_data ) + { + return KErrGeneral; + } + if ( read_data ( stream_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( stream_data->connect_data ); + g_free ( stream_data ); + return KErrGeneral; + } + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + stream_data->rCode = RC_ERROR; + + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( stream_data->connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( stream_data->connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, stream_data->connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, stream_data->connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + stream_data->main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( stream_data->main_loop ); + free_data ( stream_data->connect_data ); + g_free(stream_data); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( stream_data->connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + stream_data->connect_data->password, + stream_data->connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + stream_data->main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( stream_data->connect_data ); + g_main_loop_unref ( stream_data->main_loop ); + g_free(stream_data); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + g_free ( username ); + /**************************************/ + //Opening a byte stream + /* + + + + */ + stream_data->main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + lm_message_node_set_attribute ( message->node, "to", "donna.prima@gmail.com" ); + q_node = lm_message_node_add_child ( message->node, "open", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/ibb" ); + lm_message_node_set_attribute ( q_node, "sid", "mySID" ); + lm_message_node_set_attribute ( q_node, "block-size", "4096" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_send_image_stream_iq_open_cb, stream_data, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( stream_data->connect_data ); + g_free(stream_data); + g_main_loop_unref ( stream_data->main_loop ); + return KErrGeneral; + } + g_main_loop_run ( stream_data->main_loop ); + g_main_loop_unref ( stream_data->main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + /****************************************************/ + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( stream_data->connect_data ); + g_free(stream_data); + // Message sending passed + iLog->Log ( _L ( "lm_connection_send_imageL passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_send_multiple_connL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_send_multiple_connL ( CStifItemParser& aItem ) + { + LmConnection *connection1 = NULL; + LmConnection *connection2 = NULL; + ConnectData *connect_data1 = NULL; + LmMessage *message; + iLog->Log ( _L ( "In lm_connection_send_multiple_connL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data1, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data1 ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection1 = lm_connection_new ( connect_data1->server ); + connection2 = lm_connection_new ( connect_data1->server ); + + + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection1 || !connection2 ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data1 ); + //free_data ( connect_data2 ); + return KErrGeneral; + } + + // Set the gtalk's SSL port and Set the JID + lm_connection_set_port ( connection1, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection1, connect_data1->username ); + + // Set the gtalk's SSL port and Set the JID + lm_connection_set_port ( connection2, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection2, connect_data1->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection1, connect_data1->proxy_data ); + SetProxy ( connection2, connect_data1->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection1 ); + SSLInit ( connection2 ); + /********************************************************/ + //CONNECTION1 + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection1, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection1 ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data1 ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data1->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection1, + username, + connect_data1->password, + connect_data1->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + free_data ( connect_data1 ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /****************************************************/ + //CONNECTION1 MSG + // Construct a message + message = lm_message_new ( connect_data1->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data1->msg_data->message); + // Send message to the server + if ( !lm_connection_send ( connection1, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + lm_connection_unref ( connection2 ); + lm_message_unref ( message ); + free_data ( connect_data1 ); + return KErrGeneral; + } + // Remove a reference on message + lm_message_unref ( message ); + + /***********************************************/ + //CONNECTION2 + main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection2, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + lm_connection_unref ( connection2 ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data1 ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + username = get_user_name ( connect_data1->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection2, + username, + connect_data1->password, + /*connect_data2->resource*/ + "RSC1234", + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + lm_connection_close ( connection2, NULL ); + lm_connection_unref ( connection2 ); + free_data ( connect_data1 ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + /***********************************************/ + // CONNECTION2 MSG + // Construct a message + message = lm_message_new ( connect_data1->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data1->msg_data->message); + // Send message to the server + if ( !lm_connection_send ( connection2, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection2, NULL ); + lm_connection_unref ( connection2 ); + lm_message_unref ( message ); + free_data ( connect_data1); + return KErrGeneral; + } + // Remove a reference on message + lm_message_unref ( message ); + + /**********************************************/ + // Close the connection + lm_connection_close ( connection1, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection1 ); + free_data ( connect_data1 ); + + // Close the connection + lm_connection_close ( connection2, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection2 ); + + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send_multiple_connL passed" ) ); + + return KErrNone; +} +//-------------------------------------------------------------------------------- +// function_name : handle_block_contact +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_block_contact ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + /* + + */ + /* + + + + + + + + + + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + break; + case LM_MESSAGE_SUB_TYPE_ERROR: + //return NULL; + break; + // default: + // g_assert_not_reached (); + // break; + } + + // q_node = lm_message_node_get_child (reply->node, "query"); + + if (!q_node) + { + //return NULL; + } + + //item_node = lm_message_node_get_child (q_node, "id"); + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_block_contactL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_block_contactL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node = NULL; + LmMessageNode* item_node1 = NULL; + LmMessageNode* item_node2 = NULL; + LmMessageNode* item_node3 = NULL; + + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_block_contactL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + /**********************************/ + /* + + + + [] + [] + [] + [] + + + + */ + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "deny" ); + lm_message_node_set_attribute ( item_node2, "order", "1" ); + item_node3 = lm_message_node_add_child ( item_node2, "presence-in", NULL ); + item_node3 = lm_message_node_add_child ( item_node2, "message", NULL ); + + + // Send message to the server + handler = lm_message_handler_new ( handle_block_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + /**********************************/ + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_get_one_privacy_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + /************************************/ + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_block_contactL passed" ) ); + + return KErrNone; +} +//-------------------------------------------------------------------------------- +// function_name : handle_unblock_contact +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_unblock_contact ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node,*item_node; + type = lm_message_get_sub_type (reply); + /* + + */ + /* + + + + + + + + + + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + break; + case LM_MESSAGE_SUB_TYPE_ERROR: + //return NULL; + break; + // default: + // g_assert_not_reached (); + // break; + } + + // q_node = lm_message_node_get_child (reply->node, "query"); + + if (!q_node) + { + //return NULL; + } + + //item_node = lm_message_node_get_child (q_node, "id"); + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_unblock_contactL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_unblock_contactL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node = NULL; + LmMessageNode* item_node1 = NULL; + LmMessageNode* item_node2 = NULL; + LmMessageNode* item_node3 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_unblock_contactL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /**********************************/ + // Construct a message with type=LM_MESSAGE_TYPE_IQ + main_loop = g_main_loop_new ( NULL, FALSE ); + + /* + + + + [] + [] + [] + [] + + + + */ + + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "allow" ); + lm_message_node_set_attribute ( item_node2, "order", "1" ); + item_node3 = lm_message_node_add_child ( item_node2, "presence-in", NULL ); + item_node3 = lm_message_node_add_child ( item_node2, "message", NULL ); + + // Send message to the server + handler = lm_message_handler_new ( handle_unblock_contact, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_connection_unblock_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + /**********************************/ + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_get_one_privacy_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + /************************************/ + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_unblock_contactL passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_set_active_list +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_set_active_list ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *error_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + /* + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* id; + id = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + + */ + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + break; + } + // default: + // g_assert_not_reached (); + // break; + } + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_active_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_active_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_active_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "active", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_active_list, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_active_listL passed" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_unexist_active_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_unexist_active_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_unexist_active_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "active", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "publicunexist" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_active_list, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_unexist_active_listL passed" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_decline_active_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_decline_active_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_decline_active_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "active", NULL ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_active_list, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_connection_set_decline_active_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_decline_active_listL passed" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_get_one_privacy_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_get_one_privacy_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_get_one_privacy_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_get_one_privacy_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_get_one_privacy_listL passed" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_one_privacy_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_one_privacy_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_one_privacy_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "deny" ); + lm_message_node_set_attribute ( item_node2, "order", "3" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_connection_set_one_privacy_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_one_privacy_listL passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_create_one_privacy_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_create_one_privacy_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_create_one_privacy_listL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "publicnewlist" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "allow" ); + lm_message_node_set_attribute ( item_node2, "order", "10" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_connection_create_one_privacy_listL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + /*****************************/ + //Now retrieve all the privacy lists and see if it is created + // Construct a message with type=LM_MESSAGE_TYPE_IQ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + /*******************************/ + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_create_one_privacy_listL passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_get_many_privacy_lists +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_get_many_privacy_lists ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *error_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + + /* */ + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* id; + id = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + */ + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + break; + } + // default: + // g_assert_not_reached (); + // break; + } + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_get_many_privacy_list_from_listnameL +// Description : Asynchronous call to get more than one privacy list details by +// specifying the name. The server should return error, since we +// can only retrieve info of one list at a time +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_get_many_privacy_list_from_listnameL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2, *item_node3 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_get_many_privacy_list_from_listname" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "public" ); + item_node2 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node2, "name", "private" ); + item_node3 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node3, "name", "default" ); + + + // Send message to the server + handler = lm_message_handler_new ( handle_get_many_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_get_many_privacy_list_from_listname failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_get_many_privacy_list_from_listname passed" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_get_one_unexist_privacy_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_get_one_unexist_privacy_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_get_one_unexist_privacy_list" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node, "name", "publicunexist" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_get_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_get_one_unexist_privacy_list failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_get_one_unexist_privacy_list passed" ) ); + return KErrNone; +} + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_connection_set_one_unexist_privacy_listL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_connection_set_one_unexist_privacy_listL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode* q_node, *item_node1, *item_node2 = NULL; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "In lm_connection_set_one_unexist_privacy_list" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + +// Construct a message with type=LM_MESSAGE_TYPE_IQ + /* + + + + + + + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_SET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "jabber:iq:privacy" ); + item_node1 = lm_message_node_add_child ( q_node, "list", NULL ); + lm_message_node_set_attribute ( item_node1, "name", "publicunexist" ); + item_node2 = lm_message_node_add_child ( item_node1, "item", NULL ); + lm_message_node_set_attribute ( item_node2, "type", "jid" ); + lm_message_node_set_attribute ( item_node2, "value", "rakesh_harsh@chat.gizmoproject.com" ); + lm_message_node_set_attribute ( item_node2, "action", "deny" ); + lm_message_node_set_attribute ( item_node2, "order", "3" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_set_privacy_lists, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_connection_set_one_unexist_privacy_list passed" ) ); + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_service_discovery +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_service_discovery ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + /* + + + ... + + ... + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + */ + if (reply->node) + { + LmMessageNode* error_node = NULL; + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + item_node = lm_message_node_get_child (reply->node, "feature-not-implemented"); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_service_discoveryL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_service_discoveryL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode * q_node = NULL; + LmMessageHandler *handler = NULL; + iLog->Log ( _L ( "In lm_service_discoveryL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + /* + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (connect_data->server, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/disco#info" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_service_discovery, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_service_discoveryL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_service_discoveryL passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_service_discovery_connected_resourceL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_service_discovery_connected_resourceL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode * q_node = NULL; + LmMessageHandler *handler = NULL; + iLog->Log ( _L ( "In lm_service_discovery_connected_resourceL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + /* + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type ("testlmnokia@chat.gizmoproject.com/mytest12345rt17", + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "query", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "http://jabber.org/protocol/disco#info" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_service_discovery, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_add_contactL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_service_discovery_connected_resourceL passed" ) ); + + return KErrNone; +} + + +//-------------------------------------------------------------------------------- +// function_name : handle_simple_communications_blocking +// description : callback function to handle messages +// XEP-0191: Simple Communications Blocking +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_simple_communications_blocking ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + /* + + + ... + + ... + + + */ + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* + + + + + + */ + if (reply->node) + { + LmMessageNode* error_node = NULL; + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + item_node = lm_message_node_get_child (error_node, "feature-not-implemented"); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_simple_communications_blockingL +// Description : Asynchronous call to send a message +// XEP-0191: Simple Communications Blocking +// Not implemented by Gizmo +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_simple_communications_blockingL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode * q_node = NULL; + LmMessageHandler *handler = NULL; + iLog->Log ( _L ( "In lm_simple_communications_blockingL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + /* + + + + */ + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, + LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET ); + q_node = lm_message_node_add_child ( message->node, "blocklist", NULL ); + lm_message_node_set_attribute ( q_node, "xmlns", "urn:xmpp:blocking" ); + + // Send message to the server + handler = lm_message_handler_new ( handle_simple_communications_blocking, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply in lm_simple_communications_blockingL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_simple_communications_blockingL passed" ) ); + + return KErrNone; +} +//-------------------------------------------------------------------------------- +// function_name : handle_send_im +// description : callback function to handle messages +// XEP-0191: Simple Communications Blocking +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_send_im ( LmMessageHandler*/* handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + GMainLoop *main_loop = ( GMainLoop * )user_data; + LmMessageSubType type; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + /* //with gizmo + + Hello + + + + + */ + if (reply->node) + { + LmMessageNode* error_node = NULL; + const char* msg_error_type; + msg_error_type = lm_message_node_get_attribute(reply->node,"type"); + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + item_node = lm_message_node_get_child (error_node, "feature-not-implemented"); + if(item_node == NULL) + { + item_node = lm_message_node_get_child (error_node, "service-unavailable"); + } + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + if ( main_loop ) + { + g_main_loop_quit ( main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } +//----------------------------------------------------------------------------- +// Ctstlm::lm_send_im_with_replyL +// Description : Asynchronous call to send a message. Needs a response +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_send_im_with_replyL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageHandler *handler = NULL; + iLog->Log ( _L ( "In lm_send_im_with_replyL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + //------------------------------------------------------------------------ + //Send own presence +// message = lm_message_new_with_sub_type ( NULL, +// LM_MESSAGE_TYPE_PRESENCE, +// LM_MESSAGE_SUB_TYPE_AVAILABLE ); + + // gboolean result = lm_connection_send ( connection, message, NULL ); + // lm_message_unref ( message ); + //------------------------------------------------------------------------ + // + // Register a handler to recieve msgs + // + main_loop = g_main_loop_new ( NULL, FALSE ); + + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_send_im_with_replyL failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + lm_message_handler_unref(handler); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + handler = lm_message_handler_new ( + (LmHandleMessageFunction)handle_send_im, + main_loop, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_IQ, + LM_HANDLER_PRIORITY_FIRST ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + + // Remove a reference on message + lm_message_unref ( message ); + lm_message_handler_unref(handler); + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_send_im_with_replyL passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_receive_any_messageL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send and receive +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_receive_any_messageL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageHandler *handler = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "In lm_receive_any_message" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + //------------------------------------------------------------------------ + //Send own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + + gboolean result = lm_connection_send ( connection, message, NULL ); + + //------------------------------------------------------------------------ + // + // Register a handler to recieve msgs + // + main_loop = g_main_loop_new ( NULL, FALSE ); + handler = lm_message_handler_new ( + (LmHandleMessageFunction)handle_messages, + main_loop, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_MESSAGE, + LM_HANDLER_PRIORITY_FIRST ); + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + //------------------------------------------------------------------------ + lm_message_unref(message); + lm_message_handler_unref(handler); + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; +} + +//-------------------------------------------------------------------------------- +// function_name : handle_multiple_session_messages +// description : callback function to handle messages +// Returns : LmHandlerResult +//-------------------------------------------------------------------------------- +static LmHandlerResult +handle_multiple_session_messages ( LmMessageHandler* /*handler*/, + LmConnection* /*connection*/, + LmMessage* reply, + gpointer user_data ) + { + HandleData *handle_data = ( HandleData * )user_data; + + if ( handle_data ) + { + handle_data->Test_Success = RC_OK; + LmMessageSubType type; + LmMessageNode *q_node = NULL; + LmMessageNode *item_node = NULL; + type = lm_message_get_sub_type (reply); + + switch (type) + { + case LM_MESSAGE_SUB_TYPE_RESULT: + { + const char* reply_string; + reply_string = lm_message_node_get_attribute(reply->node,"id"); + break; + } + case LM_MESSAGE_SUB_TYPE_ERROR: + { + if (q_node) + { + LmMessageNode* error_node = NULL; + error_node = lm_message_node_get_child(reply->node,"error"); + const char* error_code; + error_code = lm_message_node_get_attribute(error_node,"code"); + const char* error_type; + error_type = lm_message_node_get_attribute(error_node,"type"); + item_node = lm_message_node_get_child (q_node, "feature-not-implemented"); + } + break; + } + // default: + // g_assert_not_reached (); + // break; + } + + + g_main_loop_quit ( handle_data->main_loop ); + } + + return LM_HANDLER_RESULT_REMOVE_MESSAGE; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_login_multiple_sessionsL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send and receive +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_login_multiple_sessionsL ( CStifItemParser& aItem ) + { + LmConnection *connection1 = NULL; + LmConnection *connection2 = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageHandler *handler1 = NULL; + LmMessageHandler *handler2 = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "In lm_receive_any_message" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection1 = lm_connection_new ( connect_data->server ); + connection2 = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection1 || !connection2 ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port and Set the JID + lm_connection_set_port ( connection1, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection1, connect_data->username ); + lm_connection_set_port ( connection2, GTALK_SSL_PORT ); + lm_connection_set_jid ( connection2, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection1, connect_data->proxy_data ); + SetProxy ( connection2, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection1 ); + SSLInit ( connection2 ); + /*********************************************************/ + //Login with connection1 + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection1, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection1 ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection1, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + //Send own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + gboolean result = lm_connection_send ( connection1, message, NULL ); + + //Dont unref message here. It will be used to send agn . + //lm_message_unref(message); + + + // Register a handler to recieve msgs + main_loop = g_main_loop_new ( NULL, FALSE ); + handler1 = lm_message_handler_new ( + (LmHandleMessageFunction)handle_multiple_session_messages, + main_loop, + NULL ); + lm_connection_register_message_handler ( connection1, + handler1, + LM_MESSAGE_TYPE_MESSAGE, + LM_HANDLER_PRIORITY_FIRST ); + /*********************************************************/ + //Login with CONNECTION2 + GMainLoop* main_loop1 = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection2, ( LmResultFunction ) connection_open_cb, + main_loop1, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection2 ); + g_main_loop_unref ( main_loop1 ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop1 ); + g_main_loop_unref ( main_loop1 ); + main_loop1 = g_main_loop_new ( NULL, FALSE ); + // Authenticate with the server + if ( !lm_connection_authenticate ( connection2, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection2, NULL ); + lm_connection_unref ( connection2 ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop1 ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + //Send own presence + result = lm_connection_send ( connection2, message, NULL ); + lm_message_unref(message); + /*********************************************************/ + // Conn2 should have logged out. Send message should not work. + // Construct a message +// main_loop1 = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + // Send message to the server + handler2 = lm_message_handler_new ( handle_send_im, main_loop, NULL ); + if ( !lm_connection_send_with_reply ( connection1, message, handler2, NULL ) ) + { + iLog->Log ( _L ( "lm_send_im_with_replyL failed" ) ); + lm_connection_close ( connection1, NULL ); + lm_connection_unref ( connection1 ); + g_main_loop_unref ( main_loop ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_unref(message); + lm_message_handler_unref(handler2); + + /***********************************************************/ + //Run the registered main loop for logout callbacks + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + // Close the connection + lm_connection_close ( connection1, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection1 ); + + // Close the connection + lm_connection_close ( connection2, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection2 ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm::lm_change_own_presenceL +// Description : Changing own presence information +// Arguements : +// connection : +// message : +// error : +// Returns : +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_change_own_presenceL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode *show_node = NULL; + LmMessageNode *status_node = NULL; + LmMessageHandler *handler = NULL; + GMainLoop *main_loop = NULL; + + iLog->Log ( _L ( "In lm_change_own_presenceL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /* + + dnd + Wooing Juliet + Ja dvořím Juliet + + */ + + //publish own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + gboolean result = lm_connection_send ( connection, message, NULL ); + //lm_connection_send_with_reply( + // Remove a reference on message + lm_message_unref ( message ); + + //------------------------------------------------------------------------ + // + // Register a handler to recieve and update presence information + // + main_loop = g_main_loop_new ( NULL, FALSE ); + + handler = lm_message_handler_new ( + (LmHandleMessageFunction)jabber_presence_handler_cb, + main_loop, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_PRESENCE, + LM_HANDLER_PRIORITY_NORMAL ); + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_handler_unref(handler); + //------------------------------------------------------------------------ + + + + //Change presence again + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + lm_message_node_set_attributes ( message->node, "xml:lang", "en", NULL ); + show_node = lm_message_node_add_child ( message->node, "show", "busy" ); + status_node = lm_message_node_add_child ( message->node, "status", "goal goal goal" ); + result = lm_connection_send ( connection, message, NULL ); + // Remove a reference on message + lm_message_unref ( message ); + + //Change presence again + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + lm_message_node_set_attributes ( message->node, "xml:lang", "en", NULL ); + show_node = lm_message_node_add_child ( message->node, "show", "away" ); + status_node = lm_message_node_add_child ( message->node, "status", "imagine a world without nokia!" ); + result = lm_connection_send ( connection, message, NULL ); + // Remove a reference on message + lm_message_unref ( message ); + + //Change presence again + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + lm_message_node_set_attributes ( message->node, "xml:lang", "en", NULL ); + show_node = lm_message_node_add_child ( message->node, "show", "available" ); + status_node = lm_message_node_add_child ( message->node, "status", "there comes a time..." ); + result = lm_connection_send ( connection, message, NULL ); + // Remove a reference on message + lm_message_unref ( message ); + + + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_fetching_presenceL passed" ) ); + + return KErrNone; + } + +//----------------------------------------------------------------------------- +// Ctstlm::lm_login_test_invalid_settingsL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_login_test_invalid_portL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + + iLog->Log ( _L ( "In lm_login_test_invalid_portL" ) ); + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, SSL_INVALID_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop* main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( "lm_login_test_invalid_port: Invalid settings is handled correctly" ) ); + return KErrNone; +} + +//----------------------------------------------------------------------------- +// Ctstlm:: lm_login_test_invalid_serverL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm:: lm_login_test_invalid_serverL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + + + iLog->Log ( _L ( "In lm_login_test_invalid_serverL" ) ); + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, SSL_INVALID_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop* main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + iLog->Log ( _L ( " lm_login_test_invalid_server: Invalid settings is handled correctly" ) ); + return KErrNone; +} + + +//----------------------------------------------------------------------------- +// Ctstlm::lm_memory_leak_testL +// Description : Asynchronous call to send a message +// Arguements : +// connection : an LmConnection used to send message +// message : LmMessage to send +// error : location to store error, or NULL +// Returns : Returns TRUE if no errors were detected while sending, +// FALSE otherwise +//----------------------------------------------------------------------------- +// +TInt Ctstlm::lm_memory_leak_testL ( CStifItemParser& aItem ) + { + LmConnection *connection = NULL; + //ConnectData *connect_data = NULL; + AuthData *auth_data = NULL; + + + iLog->Log ( _L ( "In lm_memory_leak_testL" ) ); + + auth_data = g_new0 ( AuthData, 1 ); + if ( !auth_data ) + { + iLog->Log ( _L ( "memory allocation failed for auth_data" ) ); + return KErrGeneral; + } + + // Read a data from the CFG file + if ( read_data ( auth_data->connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( auth_data->connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( auth_data->connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( auth_data->connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, auth_data->connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, auth_data->connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + auth_data->main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( auth_data->main_loop ); + free_data ( auth_data->connect_data ); + g_free(auth_data); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( auth_data->main_loop ); + + g_main_loop_unref ( auth_data->main_loop ); + + + auth_data->main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( auth_data->connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + auth_data->connect_data->password, + auth_data->connect_data->resource, + ( LmResultFunction ) lm_login_cb, + auth_data,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( username ); + g_free ( auth_data ); + return KErrGeneral; + } + + g_main_loop_run ( auth_data->main_loop ); + g_main_loop_unref ( auth_data->main_loop ); + g_free ( username ); + + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( auth_data->connect_data ); + + if ( auth_data->rCode == RC_ERROR ) + { + iLog->Log ( _L ( "lm_memory_leak_testL failed" ) ); + g_free ( auth_data ); + return KErrGeneral; + } + g_free ( auth_data ); + + + + return KErrNone; +} +// NFT test cases + +TInt Ctstlm::lm_nft_updating_presenceL(CStifItemParser& aItem) + { + + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode *show_node = NULL; + LmMessageNode *status_node = NULL; + LmMessageHandler *handler = NULL; + GMainLoop *main_loop = NULL; + + iLog->Log ( _L ( "In lm_nft_updating_presenceL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /* + + dnd + Wooing Juliet + Ja dvořím Juliet + + */ + + //publish own presence + //updating presence multiple time + for (TInt i =1 ;i<100 ;i++) + { + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + gboolean result = lm_connection_send ( connection, message, NULL ); + //lm_connection_send_with_reply( + // Remove a reference on message + lm_message_unref ( message ); + + //Change presence again + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + lm_message_node_set_attributes ( message->node, "xml:lang", "en", NULL ); + show_node = lm_message_node_add_child ( message->node, "show", "busy" ); + status_node = lm_message_node_add_child ( message->node, "status", "goal goal goal" ); + result = lm_connection_send ( connection, message, NULL ); + // Remove a reference on message + lm_message_unref ( message ); + + } + + + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_nft_updating_presenceL" ) ); + + return KErrNone; + + } + +TInt Ctstlm ::lm_nft_presence_notificationL(CStifItemParser& aItem) + { + + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageNode *show_node = NULL; + LmMessageNode *status_node = NULL; + LmMessageHandler *handler = NULL; + GMainLoop *main_loop = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "lm_nft_presence_notificationL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator +#ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); +#endif + + // Set the connection to use SSL + SSLInit ( connection ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + /* + + dnd + Wooing Juliet + Ja dvořím Juliet + + */ + + //publish own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + gboolean result = lm_connection_send ( connection, message, NULL ); + //lm_connection_send_with_reply( + // Remove a reference on message + lm_message_unref ( message ); + + //------------------------------------------------------------------------ + // + // Register a handler to recieve and update presence information + // + + main_loop = g_main_loop_new ( NULL, FALSE ); + handle_data = g_new0 ( HandleData, 1 ); + handle_data->main_loop=main_loop; + handle_data->count=0; + handler = lm_message_handler_new ( + (LmHandleMessageFunction)handle_100_presence_notification, + handle_data, + NULL ); + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_PRESENCE, + LM_HANDLER_PRIORITY_NORMAL ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + lm_message_handler_unref(handler); + + + + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + // Message sending passed + iLog->Log ( _L ( "lm_nft_presence_notificationL" ) ); + + return KErrNone; + + + } + + TInt Ctstlm::lm_nft_send_text_messageL(CStifItemParser& aItem) + { + + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "In lm_nft_send_text_messageL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<100 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + //free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_nft_send_text_messageL" ) ); + + return KErrNone; + + } + TInt Ctstlm::lm_nft_open_conversation_with_multipleL(CStifItemParser& aItem) + { + + + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "lm_nft_open_conversation_with_multipleL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + // Construct a message + //receipient1 + const char *receipient = "rakesh.harsh@gmail.com"; + message = lm_message_new ( receipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient1 = "rakesh.harsha@gmail.com"; + message = lm_message_new ( receipient1, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient2 = "testlm123@gmail.com"; + message = lm_message_new ( receipient2, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + + const char *receipient3 = "nokiatestlm@gmail.com"; + message = lm_message_new ( receipient3, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient4 = "testui123@gmail.com"; + message = lm_message_new ( receipient4, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient5 = "immeco10@gmail.com"; + message = lm_message_new ( receipient5, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient6 = "immeco11@gmail.com"; + message = lm_message_new ( receipient6, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient7 = "immeco11@gmail.com"; + message = lm_message_new ( receipient7, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient8 = "test.isoserver@gmail.com"; + message = lm_message_new ( receipient8, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient9 = "tele1236@gmail.com"; + message = lm_message_new ( receipient9, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + const char *receipient10 = "meco5555@gmail.com"; + message = lm_message_new ( receipient10, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + for(TInt i =0 ; i<20 ;i++) + { + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + } + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_nft_open_conversation_with_multipleL" ) ); + + return KErrNone; + + } + TInt Ctstlm::lm_nft_fetch300_contactL(CStifItemParser& aItem) + { + + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + LmMessageNode *q_node; + //LmMessageSubType type; + LmMessageHandler *handler = NULL; + + iLog->Log ( _L ( "lm_nft_fetch300_contactL" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + //Open call + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + main_loop = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction )connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + + + // Construct a message + main_loop = g_main_loop_new ( NULL, FALSE ); + message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, + LM_MESSAGE_SUB_TYPE_GET); + q_node = lm_message_node_add_child (message->node, "query", NULL); + lm_message_node_set_attributes (q_node, + "xmlns", "jabber:iq:roster", + NULL); + // Send message to the server + handler = lm_message_handler_new ( handle_fetch_contactlist_messages, main_loop, NULL ); + + if ( !lm_connection_send_with_reply ( connection, message, handler, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send_with_reply failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + return KErrGeneral; + } + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_nft_fetch300_contactL" ) ); + + return KErrNone; + + } + + TInt Ctstlm::lm_nft_loginlogoutmultipletime(CStifItemParser& aItem) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message; + + iLog->Log ( _L ( "lm_nft_loginlogoutmultipletime" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + //second time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + //*main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //*username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//third time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + // gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//fourth time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + // gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//five time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//fifth time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//sixth time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//seventh time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//eight time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//ninth time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_connection_send passed" ) ); + +//tenth time + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + // *main_loop = g_main_loop_new ( NULL, FALSE ); + + iLog->Log ( _L ( "before lm_connection_open" ) ); + + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + + g_main_loop_run ( main_loop ); + + g_main_loop_unref ( main_loop ); + + + // GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + + // Get the username from the JID + //gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop1,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop1 ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop1 ); + + g_main_loop_unref ( main_loop1 ); + + + g_free ( username ); + + // Construct a message + message = lm_message_new ( connect_data->msg_data->recipient, + LM_MESSAGE_TYPE_MESSAGE ); + lm_message_node_add_child ( message->node, "body", + connect_data->msg_data->message); + + // Send message to the server + if ( !lm_connection_send ( connection, message, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_send failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + lm_message_unref ( message ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Close the connection + lm_connection_close ( connection, NULL ); + + // Remove a reference on connection + lm_connection_unref ( connection ); + + // Remove a reference on message + lm_message_unref ( message ); + + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_nft_loginlogoutmultipletime" ) ); + + + return KErrNone; +} + + TInt Ctstlm::lm_nft_receiving100_message_L(CStifItemParser& aItem) + { + LmConnection *connection = NULL; + ConnectData *connect_data = NULL; + LmMessage *message = NULL; + LmMessageHandler *handler = NULL; + HandleData *handle_data = NULL; + + iLog->Log ( _L ( "lm_nft_receiving100_message_L" ) ); + + // Read a data from the CFG file + if ( read_data ( connect_data, aItem ) != RC_OK ) + { + iLog->Log ( _L ( "read_data failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + iLog->Log ( _L ( "after read_data" ) ); + + // Open a new closed connection + connection = lm_connection_new ( connect_data->server ); + iLog->Log ( _L ( "after lm_connection_new " ) ); + if ( !connection ) + { + iLog->Log ( _L ( "lm_connection_new failed" ) ); + free_data ( connect_data ); + return KErrGeneral; + } + + // Set the gtalk's SSL port + lm_connection_set_port ( connection, GTALK_SSL_PORT ); + + // Set the JID + lm_connection_set_jid ( connection, connect_data->username ); + + // Proxy settings for Emulator + #ifdef __WINSCW__ + SetProxy ( connection, connect_data->proxy_data ); + #endif + + // Set the connection to use SSL + SSLInit ( connection ); + + GMainLoop *main_loop = g_main_loop_new ( NULL, FALSE ); + iLog->Log ( _L ( "before lm_connection_open" ) ); + if ( !lm_connection_open ( connection, ( LmResultFunction ) connection_open_cb, + main_loop, NULL, NULL ) ) + { + iLog->Log ( _L ( "lm_connection_open failed" )); + lm_connection_unref ( connection ); + g_main_loop_unref ( main_loop ); + free_data ( connect_data ); + return KErrGeneral; + } + + iLog->Log ( _L ( "after lm_connection_open" ) ); + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + + main_loop = g_main_loop_new ( NULL, FALSE ); + // Get the username from the JID + gchar *username = get_user_name ( connect_data->username ); + + // Authenticate with the server + if ( !lm_connection_authenticate ( connection, + username, + connect_data->password, + connect_data->resource, + ( LmResultFunction ) connection_auth_cb, + main_loop,NULL,NULL ) ) + { + iLog->Log ( _L ( "lm_connection_authenticate failed" ) ); + lm_connection_close ( connection, NULL ); + lm_connection_unref ( connection ); + free_data ( connect_data ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + return KErrGeneral; + } + + g_main_loop_run ( main_loop ); + g_main_loop_unref ( main_loop ); + g_free ( username ); + + //------------------------------------------------------------------------ + //Send own presence + message = lm_message_new_with_sub_type ( NULL, + LM_MESSAGE_TYPE_PRESENCE, + LM_MESSAGE_SUB_TYPE_AVAILABLE ); + + gboolean result = lm_connection_send ( connection, message, NULL ); + // GMainLoop *main_loop1; + + //------------------------------------------------------------------------ + // + // Register a handler to recieve msgs + // + handle_data = g_new0 ( HandleData, 1 ); + GMainLoop *main_loop1 = g_main_loop_new ( NULL, FALSE ); + handle_data->main_loop=main_loop1; + handle_data->count=0; + handler = lm_message_handler_new ( + (LmHandleMessageFunction)handle_100_messages, + handle_data, + NULL ); + + lm_connection_register_message_handler ( connection, + handler, + LM_MESSAGE_TYPE_MESSAGE, + LM_HANDLER_PRIORITY_FIRST ); + + g_main_loop_run ( main_loop1 ); + g_main_loop_unref ( main_loop1 ); + //------------------------------------------------------------------------ + + lm_message_unref(message); + lm_message_handler_unref(handler); + // Close the connection + lm_connection_close ( connection, NULL ); + // Remove a reference on connection + lm_connection_unref ( connection ); + free_data ( connect_data ); + + // Message sending passed + iLog->Log ( _L ( "lm_nft_receiving100_message_L" ) ); + + return KErrNone; +} +// End of File