1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   tstlmblocks.cpp

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <StifTestInterface.h>

    25 #include "tstlm.h"

    26 

    27 #include "loudmouth/loudmouth.h"

    28 #include <glib.h>

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

    30 #include <string.h>

    31 #include <stdlib.h>

    32 

    33 #include <glowmem.h>

    34 

    35 // EXTERNAL DATA STRUCTURES

    36 //extern  ?external_data;

    37 

    38 // EXTERNAL FUNCTION PROTOTYPES  

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

    40 

    41 // CONSTANTS

    42 //const ?type ?constant_var = ?constant;

    43 

    44 // MACROS

    45 #define UNEXIST_PORT 0

    46 #define MYPORT 4321

    47 #define HAVE_OPENSSL

    48 #define FAKEPORT NULL

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

    50 

    51 #define GTALK_SSL_PORT 443

    52 #define SSL_INVALID_PORT 999

    53 

    54 // LOCAL CONSTANTS AND MACROS

    55 //const ?type ?constant_var = ?constant;

    56 //#define ?macro_name ?macro_def

    57 

    58 // MODULE DATA STRUCTURES

    59 

    60 typedef enum

    61 {

    62 	RC_OK,

    63 	RC_ERROR

    64 } RC_Code_t;

    65 

    66 typedef struct

    67 {

    68 	gchar *recipient;

    69 	gchar *message;

    70 } MessageData;

    71 

    72 typedef struct

    73 {

    74 	gchar      *proxy_server;

    75 	guint       proxy_port;	

    76 }ProxyData;

    77 

    78 typedef struct

    79 {

    80 	gchar       *server;

    81 	gchar       *username;

    82 	gchar       *password;		

    83 	gchar       *resource;

    84 	MessageData *msg_data;	

    85 #ifdef __WINSCW__

    86     ProxyData   *proxy_data;

    87 #endif

    88 } ConnectData;

    89 

    90 typedef struct

    91 {

    92 	ConnectData *connect_data;

    93 	GMainLoop   *main_loop;

    94 	RC_Code_t   rCode;	

    95 } AuthData;

    96 

    97 typedef struct

    98 {

    99     GMainLoop *main_loop;

   100     RC_Code_t Test_Success;	

   101     int count;

   102 } HandleData;

   103 

   104 typedef struct

   105 {

   106 	ConnectData *connect_data;

   107 	LmMessage* message;

   108 	LmMessageHandler* handler;

   109 	GMainLoop   *main_loop;

   110 	RC_Code_t   rCode;	

   111 } SendStreamData;

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

   113 typedef enum

   114 	{

   115 	XMPP_PRESENCE_TYPE_ONLINE,

   116 	XMPP_PRESENCE_TYPE_CHAT,

   117 	XMPP_PRESENCE_TYPE_AWAY,

   118 	XMPP_PRESENCE_TYPE_XA,

   119 	XMPP_PRESENCE_TYPE_DND,

   120 	XMPP_PRESENCE_TYPE_INVISIBLE,

   121 	XMPP_PRESENCE_TYPE_UNAVAILABLE

   122 	} JabberPresenceType;

   123 

   124 // LOCAL FUNCTION PROTOTYPES

   125 

   126 // Function to read data from the cfg file

   127 static RC_Code_t read_data ( ConnectData*& connect_data, 

   128                              CStifItemParser& aItem );

   129 // Function to free the allocated resources

   130 static void free_data ( ConnectData*& connect_data );

   131 

   132 // Callback function used in lm_connection_open

   133 static void connection_open_cb ( LmConnection *connection, 

   134                                  gboolean     success, 

   135                                  gpointer     data );

   136 

   137 static void wrong_input_in_open_cb ( LmConnection *connection, 

   138                                  gboolean     success, 

   139                                  gpointer     data );                                 

   140 

   141 //Callback function set in lm_connection_authenticate() call

   142 //from lm-connection_send

   143 static void connection_auth_cb ( LmConnection *connection, 

   144                                  gboolean     success, 

   145                                  gpointer     data );

   146 

   147 //Callback from lm_login_test method after auth

   148 static void lm_login_cb ( LmConnection * connection, 

   149                      gboolean  success, 

   150                      gpointer data );

   151 // Callback function called by lm_connection_open in Lm_AuthenticateL

   152 // Will call authenticate method from inside this callback. 

   153 // It uses the correct input data

   154 static void auth_in_connection_cb( LmConnection *connection, 

   155                               gboolean     success, 

   156                               gpointer     *data );

   157                                                                

   158 // Callback function set in auth_from_open_cb for handling 

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

   160 static void wrong_input_auth_cb ( LmConnection *connection, 

   161                                  gboolean     success, 

   162                                  gpointer     data );

   163 // Callback function set by lm_connection_open call.

   164 //written to handle the negative test cases for authenticate

   165 static void auth_from_open_cb ( LmConnection *connection, 

   166                               gboolean     success, 

   167                               gpointer     *data );

   168 // Callback function to handle messages                              

   169 static LmHandlerResult handle_messages ( LmMessageHandler *handler,

   170                                          LmConnection     *conneciton,

   171                                          LmMessage        *message,

   172                                          gpointer         user_data );

   173 static LmHandlerResult handle_100_messages ( LmMessageHandler *handler,

   174                                          LmConnection     *conneciton,

   175                                          LmMessage        *message,

   176                                          gpointer         user_data );

   177 // Callback function called when connection is closed

   178 static void connection_close_cb ( LmConnection       *connection, 

   179                                   LmDisconnectReason reason,

   180                                   gpointer           user_data );

   181                                   

   182 // Callback function called when presence is changed

   183 static void jabber_presence_handler_cb ( LmConnection       *connection, 

   184                                   LmDisconnectReason reason,

   185                                   gpointer           user_data );                                  

   186 static void message_response_cb ( LmConnection       *connection, 

   187                                   LmDisconnectReason reason,

   188                                   gpointer           user_data );                                    

   189                                   

   190 // Get the MessageType in Type

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

   192 // Get MessageSubType in SubType

   193 static void GetMessageSubType ( LmMessageSubType MessageSubType, 

   194                                 gchar *SubType );

   195 

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

   197 static LmSSLResponse ssl_cb ( LmSSL       *ssl, 

   198                               LmSSLStatus status, 

   199                               gpointer    user_data );

   200 

   201 #ifdef __WINSCW__

   202 // Set connection to connect through a proxy

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

   204 #endif

   205 

   206 // Set SSL for connection

   207 static void SSLInit ( LmConnection *connection );

   208 

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

   210 static gchar *get_user_name ( const gchar *jid );

   211 

   212 

   213 static JabberPresenceType

   214 jabber_presence_type_from_string ( const gchar *string );

   215 

   216 

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

   218 

   219 // FORWARD DECLARATIONS

   220 //class ?FORWARD_CLASSNAME;

   221 

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

   223 

   224 //-----------------------------------------------------------------------------

   225 // function_name	: read_data

   226 // description     	: Reads data from the CFG file

   227 // Returns          : None

   228 //-----------------------------------------------------------------------------

   229 //

   230 static RC_Code_t

   231 read_data ( ConnectData*& connect_data, CStifItemParser& aItem )

   232     {

   233 	TPtrC               string;

   234 	TBuf8<KMaxFileName> temp;

   235 	MessageData         *msg_data   = NULL;

   236 	

   237 #ifdef __WINSCW__

   238 	ProxyData           *proxy_data = NULL;

   239 	TInt                proxy_port;

   240 #endif

   241 

   242 	

   243 	connect_data = g_new0 ( ConnectData, 1 );

   244 	if ( !connect_data )

   245 	    {

   246 		return RC_ERROR;

   247 	    }

   248 	    

   249 	msg_data = g_new0 ( MessageData, 1 );

   250 	if ( !msg_data )

   251 	    {

   252 		free_data ( connect_data );

   253 		return RC_ERROR;

   254 	    }

   255 	

   256 	connect_data->msg_data = msg_data;

   257 	

   258 #ifdef __WINSCW__

   259     proxy_data = g_new0 ( ProxyData, 1 );

   260     if ( !proxy_data ) 

   261     	{

   262     	free_data ( connect_data );

   263     	return RC_ERROR;

   264     	}

   265 	connect_data->proxy_data = proxy_data;

   266 #endif

   267 

   268 	// Read server name

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

   270 	    {

   271 		temp.Copy ( string );

   272 		temp.Append ( '\0' );

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

   274 		if ( !connect_data->server )

   275 		    {			

   276 			free_data ( connect_data );

   277 			return RC_ERROR;

   278 		    }

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

   280 	    }

   281 	    

   282 	// Read Username

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

   284 	    {

   285 	    temp.Copy ( string );

   286 	    temp.Append ( '\0' );

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

   288 	    if ( !connect_data->username )

   289 	        {	    	

   290 	    	free_data ( connect_data );

   291 	    	return RC_ERROR;

   292 	        }

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

   294 	    }

   295 	

   296 	// Read Password corresponding to Username

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

   298 	    {

   299 	    temp.Copy ( string );

   300 	    temp.Append ( '\0' );

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

   302 	    if ( !connect_data->password )

   303 	        {	    	

   304 	    	free_data ( connect_data );

   305 	    	return RC_ERROR;

   306 	        }

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

   308 	    }

   309 	

   310 	// Read recipient

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

   312 	    {

   313 	    temp.Copy ( string );

   314 	    temp.Append ( '\0' );

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

   316 	    if ( !msg_data->recipient )

   317 	        {

   318 	    	free_data ( connect_data );

   319 	    	return RC_ERROR;

   320 	        }

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

   322 	    }

   323 	

   324 	// Read Message

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

   326 	    {

   327 	    temp.Copy ( string );

   328 	    temp.Append ( '\0' );	    

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

   330 	    if ( !msg_data->message )

   331 	        {

   332 	    	free_data ( connect_data );

   333 	    	return RC_ERROR;

   334 	        }

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

   336 	    }

   337 	

   338 	// Read resource identifier

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

   340 	    {

   341 	    temp.Copy ( string );

   342 	    temp.Append ( '\0' );

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

   344 	    if ( !connect_data->resource )

   345 	        {

   346 	    	free_data ( connect_data );

   347 	    	return RC_ERROR;

   348 	        }

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

   350 	    }

   351 	 

   352 #ifdef __WINSCW__

   353 	// Read proxy server and proxy port

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

   355     	{

   356     	temp.Copy ( string );

   357     	temp.Append ( '\0' );

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

   359     	if ( !proxy_data->proxy_server )

   360     		{

   361     		free_data ( connect_data );

   362     		return RC_ERROR;

   363     		}

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

   365     	}

   366     	

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

   368     		{

   369     		proxy_data->proxy_port = proxy_port;

   370     		}    	

   371 #endif 

   372 

   373 	return RC_OK;

   374     }

   375 

   376 

   377 //-----------------------------------------------------------------------------

   378 // function_name	: free_data

   379 // description     	: Deallocates all the data

   380 // Returns          : None

   381 //-----------------------------------------------------------------------------

   382 //

   383 static void

   384 free_data ( ConnectData*& connect_data )

   385     {

   386 	if ( connect_data )

   387 	    {

   388 		if ( connect_data->server )

   389 		    {

   390 			g_free ( connect_data->server );

   391 			connect_data->server = NULL;

   392 		    }

   393 		

   394 		if ( connect_data->username )

   395 		    {

   396 			g_free ( connect_data->username );

   397 			connect_data->username = NULL;

   398 		    }

   399 		

   400 		if ( connect_data->password )

   401 		    {

   402 			g_free ( connect_data->password );

   403 			connect_data->password = NULL;

   404 		    }

   405 		

   406 		if ( connect_data->msg_data )

   407 		    {

   408 			if ( connect_data->msg_data->recipient )

   409 			    {

   410 				g_free ( connect_data->msg_data->recipient );

   411 				connect_data->msg_data->recipient = NULL;

   412 			    }

   413 			if ( connect_data->msg_data->message )

   414 			    {

   415 				g_free ( connect_data->msg_data->message );

   416 				connect_data->msg_data->message = NULL;

   417 			    }

   418 			g_free ( connect_data->msg_data );

   419 			connect_data->msg_data = NULL;

   420 		    }		

   421 		

   422 		if ( connect_data->resource )

   423 		    {

   424 			g_free ( connect_data->resource );

   425 			connect_data->resource = NULL;

   426 		    }

   427 		    

   428 	#ifdef __WINSCW__

   429 	    if ( connect_data->proxy_data )

   430 	    	{

   431 	    	if ( connect_data->proxy_data->proxy_server )

   432 	    		{

   433 	    		g_free ( connect_data->proxy_data->proxy_server );

   434 	    		connect_data->proxy_data->proxy_server = NULL;

   435 	    		}

   436 	    	g_free ( connect_data->proxy_data );

   437 	    	connect_data->proxy_data = NULL;	

   438 	    	}

   439 	#endif	     

   440 		g_free ( connect_data );

   441 		connect_data = NULL;    

   442 	    }

   443     }

   444 

   445 

   446 //-----------------------------------------------------------------------------

   447 // funnction_name	: connection_open_cb

   448 // description		: callback function called by lm_connection_open

   449 // Returns			: None

   450 //-----------------------------------------------------------------------------

   451 //

   452 static void

   453 connection_open_cb ( LmConnection *connection, 

   454                      gboolean    success  /*success*/, 

   455                      gpointer data )

   456     {

   457     

   458     gboolean result = success ;

   459     GMainLoop *main_loop = ( GMainLoop * ) data;

   460     

   461 	if ( main_loop )

   462 	    {

   463 		g_main_loop_quit ( main_loop );	

   464 	    }		

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

   466     lm_connection_set_keep_alive_rate (connection, 30);			

   467     }

   468 

   469 

   470 //-----------------------------------------------------------------------------

   471 // funnction_name	: wrong_input_in_open_cb

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

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

   474 // Returns			: None

   475 //-----------------------------------------------------------------------------

   476 //

   477 static void

   478 wrong_input_in_open_cb ( LmConnection */*connection*/, 

   479                      gboolean    success  /*success*/, 

   480                      gpointer data )

   481     {

   482     

   483     gboolean result = success;

   484     AuthData *auth_data = ( AuthData * ) data;

   485     

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

   487     if (result == FALSE)

   488 		{       

   489 		auth_data->rCode = RC_OK;

   490 		}

   491     else 

   492     	{

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

   494        	auth_data->rCode = RC_ERROR;	

   495     	}

   496     g_main_loop_quit ( auth_data->main_loop ); 		

   497     }

   498 //-----------------------------------------------------------------------------

   499 // funnction_name	: wrong_input_auth_cb

   500 // description		: callback function called by lm_connection_open

   501 // Returns			: None

   502 //-----------------------------------------------------------------------------

   503 //

   504 static void

   505 wrong_input_auth_cb ( LmConnection */*connection*/, 

   506                      gboolean  success, 

   507                      gpointer data )

   508     {

   509     gboolean result = success;

   510     AuthData *auth_data = ( AuthData * ) data;

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

   512     if (result == FALSE)

   513 		{       

   514 		auth_data->rCode = RC_OK;

   515 		}

   516     else 

   517     	{

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

   519        	auth_data->rCode = RC_ERROR;	

   520     	}

   521     g_main_loop_quit ( auth_data->main_loop );       		

   522     }

   523     

   524 //-----------------------------------------------------------------------------

   525 // funnction_name	: connection_auth_cb

   526 // description		: callback function set by lm_connection_authenticate

   527 // in lm_connection_sendL()

   528 // Returns			: None

   529 //-----------------------------------------------------------------------------

   530 //

   531 static void connection_auth_cb ( LmConnection */*connection*/, 

   532                      gboolean  /*success*/, 

   533                      gpointer data )

   534     {

   535     GMainLoop *main_loop = ( GMainLoop * ) data;

   536     

   537 	if ( main_loop )

   538 	    {

   539 		g_main_loop_quit ( main_loop );	

   540 	    }	   		

   541     }

   542 

   543 //-----------------------------------------------------------------------------

   544 // function_name	: auth_in_connection_cb

   545 // description		: callback function called for lm_connection_open

   546 // Returns			: RC_OK if successfull, RC_ERROR otherwise

   547 //-----------------------------------------------------------------------------

   548 static void

   549 auth_in_connection_cb ( LmConnection *connection, 

   550                   gboolean success, 

   551                   gpointer *data )

   552     {

   553     AuthData *auth_data = ( AuthData * ) data;

   554          

   555     if ( !success )

   556         {

   557         // Connection failed

   558         auth_data->rCode = RC_ERROR;

   559         g_main_loop_quit ( auth_data->main_loop );    	    

   560         }

   561     

   562     // Extract the username from the JID

   563     gchar *username = get_user_name ( auth_data->connect_data->username );

   564     

   565     if ( !lm_connection_authenticate ( connection, 

   566                                        username,

   567                                        auth_data->connect_data->password,

   568                                        auth_data->connect_data->resource, 

   569                                        NULL, 

   570                                        auth_data->connect_data->msg_data, 

   571                                        NULL, 

   572                                        NULL ) )

   573         {

   574        	auth_data->rCode = RC_ERROR;

   575        	g_free ( username );

   576        	g_main_loop_quit ( auth_data->main_loop );    	    

   577         }

   578     g_free ( username );

   579         

   580     auth_data->rCode = RC_OK;    

   581     g_main_loop_quit ( auth_data->main_loop );    

   582     

   583     }

   584 

   585 //-----------------------------------------------------------------------------

   586 // function_name	: auth_from_open_cb

   587 // description		: callback function called for lm_connection_authenticate

   588 // Returns			: RC_OK if successfull, RC_ERROR otherwise

   589 //-----------------------------------------------------------------------------

   590 static void

   591 auth_from_open_cb ( LmConnection *connection, 

   592                   gboolean success, 

   593                   gpointer *data )

   594     {

   595     AuthData *auth_data = ( AuthData * ) data;

   596          

   597     if ( !success )

   598         {

   599         // Connection failed

   600         auth_data->rCode = RC_ERROR;

   601         g_main_loop_quit ( auth_data->main_loop );    	    

   602         }

   603     

   604     // Extract the username from the JID

   605     gchar *username = get_user_name ( auth_data->connect_data->username );

   606     

   607     if ( !lm_connection_authenticate ( connection, 

   608                                        username,

   609                                        auth_data->connect_data->password,

   610                                        auth_data->connect_data->resource, 

   611                                        ( LmResultFunction ) wrong_input_auth_cb, 

   612                                        auth_data ,  

   613                                        NULL, 

   614                                        NULL ) )

   615         {

   616        	auth_data->rCode = RC_ERROR;

   617        	g_free ( username );

   618        	g_main_loop_quit ( auth_data->main_loop );    	    

   619         }

   620     g_free ( username );

   621     

   622     }

   623 

   624 

   625 //--------------------------------------------------------------------------------

   626 // function_name    : handle_messages

   627 // description      : callback function to handle messages

   628 // Returns          : LmHandlerResult

   629 //--------------------------------------------------------------------------------

   630 static LmHandlerResult

   631 handle_messages ( LmMessageHandler* /*handler*/,

   632                   LmConnection*     /*connection*/,

   633                   LmMessage*        /*message*/,

   634                   gpointer          user_data )

   635     {

   636     HandleData *handle_data = ( HandleData * )user_data;	

   637 	

   638 	if ( handle_data )

   639 		{

   640 		handle_data->Test_Success = RC_OK;

   641 	

   642 	    g_main_loop_quit ( handle_data->main_loop );

   643 		}	

   644 	

   645 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   646     }

   647 

   648 //--------------------------------------------------------------------------------

   649 // function_name    : handle_messages

   650 // description      : callback function to handle messages

   651 // Returns          : LmHandlerResult

   652 //--------------------------------------------------------------------------------

   653 static LmHandlerResult

   654 handle_100_messages ( LmMessageHandler* /*handler*/,

   655                   LmConnection*     /*connection*/,

   656                   LmMessage*        /*message*/,

   657                   gpointer          user_data )

   658     {

   659     HandleData *handle_data = ( HandleData * )user_data;    

   660     //static int count=0;

   661     handle_data->count++;

   662     GMainLoop *main_loop = ( GMainLoop * )user_data;

   663     //count++;

   664     if(handle_data->count==5)

   665             {

   666         g_main_loop_quit ( handle_data->main_loop );

   667         //    g_main_loop_quit ( main_loop );

   668             } 

   669         //} 

   670     

   671     return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   672     }

   673 

   674 //--------------------------------------------------------------------------------

   675 // function_name    : handle_messages

   676 // description      : callback function to handle messages

   677 // Returns          : LmHandlerResult

   678 //--------------------------------------------------------------------------------

   679 static LmHandlerResult

   680 handle_100_presence_notification ( LmMessageHandler* /*handler*/,

   681                   LmConnection*     /*connection*/,

   682                   LmMessage*        /*message*/,

   683                   gpointer          user_data )

   684     {

   685     HandleData *handle_data = ( HandleData * )user_data;    

   686     handle_data->count++;

   687     GMainLoop *main_loop = ( GMainLoop * )user_data;

   688     if(handle_data->count==100)

   689             {

   690         g_main_loop_quit ( handle_data->main_loop );

   691         

   692             } 

   693       

   694     

   695     return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   696     }

   697 

   698 //--------------------------------------------------------------------------------

   699 // function_name	: connection_close_cb

   700 // description		: callback function called when connection is closed

   701 // Returns			: RC_OK if called

   702 //--------------------------------------------------------------------------------

   703 static void

   704 connection_close_cb ( LmConnection       */*connection*/,

   705                       LmDisconnectReason reason,

   706                       gpointer           user_data )

   707     {   

   708     HandleData *handle_data = ( HandleData * ) user_data;

   709     

   710     switch ( reason )

   711         {

   712         case LM_DISCONNECT_REASON_OK:

   713     	    handle_data->Test_Success = RC_OK;

   714     	    break;

   715         case LM_DISCONNECT_REASON_PING_TIME_OUT:

   716         /* No break, fall through */

   717         case LM_DISCONNECT_REASON_HUP:

   718         case LM_DISCONNECT_REASON_ERROR:

   719         case LM_DISCONNECT_REASON_UNKNOWN:

   720             handle_data->Test_Success = RC_ERROR;

   721             break;

   722         default:

   723             handle_data->Test_Success = RC_ERROR;

   724             break;

   725         }

   726 	

   727     }

   728 

   729 

   730 //------------------------------------------------------------------------------

   731 // function_name	: GetMessageType

   732 // description     	: Gets LmMessageType in Type

   733 // Returns          : None

   734 //------------------------------------------------------------------------------

   735 static void

   736 GetMessageType ( LmMessageType MessageType, gchar *Type )

   737 {

   738 	switch ( MessageType )

   739 	    {

   740 		case LM_MESSAGE_TYPE_MESSAGE:		

   741 		    g_stpcpy ( Type, "LM_MESSAGE_TYPE_MESSAGE" );

   742 		    break;

   743 	    case LM_MESSAGE_TYPE_PRESENCE:	        

   744 	        g_stpcpy ( Type, "LM_MESSAGE_TYPE_MESSAGE" );

   745 	        break;	        	    

   746 	    case LM_MESSAGE_TYPE_IQ:	        

   747 	        g_stpcpy ( Type, "LM_MESSAGE_TYPE_IQ" );

   748 	        break;

   749 	    case LM_MESSAGE_TYPE_STREAM:	        

   750 	        g_stpcpy ( Type, "LM_MESSAGE_TYPE_STREAM" );

   751 	        break;

   752 	    case LM_MESSAGE_TYPE_STREAM_ERROR:	        

   753 	        g_stpcpy ( Type, "LM_MESSAGE_TYPE_STREAM_ERROR" );	        

   754 	        break;

   755 	    case LM_MESSAGE_TYPE_UNKNOWN:	        

   756 	        g_stpcpy ( Type, "LM_MESSAGE_TYPE_UNKNOWN" );

   757 	        break;	        

   758 	    }

   759 }

   760 

   761 

   762 //------------------------------------------------------------------------------

   763 // function_name	: GetMessageSubType

   764 // description     	: Gets LmMessageSubType in SubType

   765 // Returns          : None

   766 //------------------------------------------------------------------------------

   767 static void

   768 GetMessageSubType ( LmMessageSubType MessageSubType, gchar *SubType )

   769 {

   770 	switch ( MessageSubType )

   771 	    {

   772 		case LM_MESSAGE_SUB_TYPE_NOT_SET:

   773 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_NOT_SET" );

   774 		    break;

   775 		case LM_MESSAGE_SUB_TYPE_AVAILABLE:

   776 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_AVAILABLE" );

   777 		    break;

   778 		case LM_MESSAGE_SUB_TYPE_NORMAL:

   779 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_NORMAL" );

   780 		    break;

   781 		case LM_MESSAGE_SUB_TYPE_CHAT:

   782 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_CHAT" );

   783 		    break;

   784 		case LM_MESSAGE_SUB_TYPE_GROUPCHAT:

   785 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_GROUPCHAT" );

   786 		    break;

   787 		case LM_MESSAGE_SUB_TYPE_HEADLINE:

   788 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_HEADLINE" );

   789 		    break;

   790 		case LM_MESSAGE_SUB_TYPE_UNAVAILABLE:

   791 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNAVAILABLE" );

   792 		    break;

   793 		case LM_MESSAGE_SUB_TYPE_PROBE:

   794 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_PROBE" );

   795 		    break;

   796 		case LM_MESSAGE_SUB_TYPE_SUBSCRIBE:

   797 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SUBSCRIBE" );

   798 		    break;

   799 		case LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE:

   800 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE" );

   801 		    break;

   802 		case LM_MESSAGE_SUB_TYPE_SUBSCRIBED:

   803 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SUBSCRIBED" );

   804 		    break;

   805 		case LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED:

   806 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED" );

   807 		    break;

   808 		case LM_MESSAGE_SUB_TYPE_GET:

   809 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_GET" );

   810 		    break;

   811 		case LM_MESSAGE_SUB_TYPE_SET:

   812 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_SET" );

   813 		    break;

   814 		case LM_MESSAGE_SUB_TYPE_RESULT:

   815 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_RESULT" );

   816 		    break;

   817 		case LM_MESSAGE_SUB_TYPE_ERROR:

   818 		    g_stpcpy ( SubType, "LM_MESSAGE_SUB_TYPE_ERROR" );

   819 		    break;

   820 	    }

   821 }

   822 

   823 

   824 // ---------------------------------------------------------------------------

   825 // jabber_presence_type_from_string: Returns the presence type

   826 // ---------------------------------------------------------------------------

   827 //	

   828 static JabberPresenceType

   829 jabber_presence_type_from_string ( const gchar *string )

   830 	{

   831 	

   832 	if ( string == NULL )

   833 		return XMPP_PRESENCE_TYPE_ONLINE;

   834 	

   835 	if ( !strcmp ( string, "online" ) )

   836 		return XMPP_PRESENCE_TYPE_ONLINE;	

   837 	else if ( !strcmp ( string, "chat" ) )

   838 		return XMPP_PRESENCE_TYPE_CHAT;

   839 	else if ( !strcmp ( string, "away" ) )

   840 		return XMPP_PRESENCE_TYPE_AWAY;

   841 	else if ( !strcmp ( string, "xa" ) )

   842 		return XMPP_PRESENCE_TYPE_XA;

   843 	else if ( !strcmp ( string, "dnd" ) )

   844 		return XMPP_PRESENCE_TYPE_DND;

   845 	else if ( !strcmp ( string, "invisible" ) )

   846 		return XMPP_PRESENCE_TYPE_INVISIBLE;

   847 	else if ( !strcmp ( string, "unavailable" ) )

   848 		return XMPP_PRESENCE_TYPE_UNAVAILABLE;	

   849 	else

   850 		return XMPP_PRESENCE_TYPE_ONLINE;

   851 	}

   852 

   853 

   854 // ---------------------------------------------------------------------------

   855 // function_name       : ssl_cb

   856 // description         : This function is called if something goes wrong

   857 //                       during the connecting phase.

   858 // Arguements          :

   859 //        ssl          : An LmSSL

   860 //        status       : The status informing what went wrong

   861 //        user_data    : User data provided in the callback

   862 //

   863 // Returns             : User should return LM_SSL_RESPONSE_CONTINUE if 

   864 //                       connection should proceed. otherwise 

   865 //                       LM_SSL_RESPONSE_STOP.

   866 // ---------------------------------------------------------------------------

   867 //

   868 static LmSSLResponse

   869 ssl_cb ( LmSSL */*ssl*/, LmSSLStatus status, gpointer /*user_data*/ )

   870 	{

   871 	

   872 	g_print ( "SSL status :%d\n", status );

   873 	

   874 	switch ( status ) 

   875 	    {

   876 	case LM_SSL_STATUS_NO_CERT_FOUND:

   877        	g_printerr ("No certificate found!\n");

   878        	break;

   879      case LM_SSL_STATUS_UNTRUSTED_CERT:

   880        	g_printerr ("Certificate is not trusted!\n");

   881        	break;

   882  	case LM_SSL_STATUS_CERT_EXPIRED:

   883        	g_printerr ("Certificate has expired!\n");

   884        	break;

   885 	case LM_SSL_STATUS_CERT_NOT_ACTIVATED:

   886        	g_printerr ("Certificate has not been activated!\n");

   887        	break;

   888 	case LM_SSL_STATUS_CERT_HOSTNAME_MISMATCH:

   889        	g_printerr ("Certificate hostname does not match expected hostname!\n");

   890        	break;

   891 	 case LM_SSL_STATUS_CERT_FINGERPRINT_MISMATCH:

   892 	 	g_printerr ( "fingerprint error!\n" );

   893 	 	break;

   894 	 case LM_SSL_STATUS_GENERIC_ERROR:

   895         g_printerr ("Generic SSL error!\n");

   896         break;

   897 	    }

   898 		

   899 	return LM_SSL_RESPONSE_CONTINUE;

   900 	}

   901 

   902 

   903 // ---------------------------------------------------------------------------

   904 // function_name       : SetProxy

   905 // description         : Sets the connection to use proxy

   906 // Arguements          :

   907 //        connection   : LmConnection

   908 //        connect_data : ConnectData

   909 // Returns             : None

   910 // ---------------------------------------------------------------------------

   911 //

   912 #ifdef __WINSCW__

   913 static void 

   914 SetProxy ( LmConnection *connection, ProxyData *proxy_data )

   915 	{

   916 	LmProxy *proxy = NULL;

   917 	

   918 	proxy = lm_proxy_new ( LM_PROXY_TYPE_HTTP );

   919 	lm_proxy_set_server ( proxy, proxy_data->proxy_server );

   920 	lm_proxy_set_port ( proxy, proxy_data->proxy_port );

   921 	lm_connection_set_proxy ( connection, proxy );

   922 	lm_proxy_unref ( proxy );

   923 	}

   924 #endif

   925 

   926 // ---------------------------------------------------------------------------

   927 // function_name       : SSLInit

   928 // description         : Sets the connection to use SSL

   929 // Arguements          :

   930 //        connection   : LmConnection

   931 // Returns             : None

   932 // ---------------------------------------------------------------------------

   933 //

   934 static void 

   935 SSLInit ( LmConnection *connection )

   936 	{

   937 	LmSSL *ssl = NULL;

   938 	

   939 	ssl = lm_ssl_new ( NULL, ( LmSSLFunction ) ssl_cb, NULL, NULL );

   940 	lm_connection_set_ssl ( connection, ssl );

   941 		lm_ssl_unref ( ssl );

   942 	lm_connection_set_keep_alive_rate (connection, 30);

   943 	}

   944 

   945 

   946 // ---------------------------------------------------------------------------

   947 // function_name       : get_user_name 

   948 // description         : Returns the username from the jid

   949 // Arguements          :

   950 //        jid          : jid

   951 // Returns             : username

   952 // ---------------------------------------------------------------------------

   953 //

   954 static gchar *

   955 get_user_name ( const gchar *jid )

   956 	{

   957 	const gchar *ch;

   958 	

   959 	g_return_val_if_fail ( jid != NULL, NULL );

   960 	

   961 	ch = strchr ( jid, '@' );

   962 	if ( !ch )

   963 		return ( gchar *) jid;

   964 	

   965 	return g_strndup ( jid, ch - jid );

   966 	}

   967 

   968 // ---------------------------------------------------------------------------

   969 // jabber_presence_handler_cb: Callback function to handle the presence info

   970 // ---------------------------------------------------------------------------

   971 //

   972 static LmHandlerResult

   973 jabber_presence_handler_cb ( LmMessageHandler * /*handler*/,

   974                               LmConnection     * /*connection*/,

   975                               LmMessage        *message,

   976                               gpointer          user_data )

   977 	{	

   978 	const gchar        *jid;

   979 	const gchar        *show;

   980 	const gchar        *status;		

   981 	

   982 	LmMessageNode      *node;

   983 	JabberPresenceType type;

   984 	

   985 	if(message != NULL)

   986 		{

   987 		// Get the JID attribute

   988 		jid = lm_message_node_get_attribute ( message->node, "from" );

   989 

   990 		// Get the show attribute

   991 		

   992 		node = lm_message_node_get_child ( message->node, "show" );

   993 		show = node ? ( node->value ) : "online";

   994 		

   995 		// Get the status attribute

   996 		node   = lm_message_node_get_child ( message->node, "status" );

   997 		status = node ? ( node->value ) : NULL;

   998 		

   999 		type = jabber_presence_type_from_string ( show );			

  1000 		}

  1001 	

  1002 		

  1003 	GMainLoop *main_loop = ( GMainLoop * ) user_data;  

  1004 	if ( main_loop )

  1005 	    {

  1006 	    g_main_loop_quit ( main_loop );	

  1007 	    }  		

  1008 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  1009 	}

  1010 

  1011 

  1012 

  1013 

  1014 

  1015 // ============================ MEMBER FUNCTIONS ===============================

  1016 

  1017 // -----------------------------------------------------------------------------

  1018 // Ctstlm::Delete

  1019 // Delete here all resources allocated and opened from test methods. 

  1020 // Called from destructor. 

  1021 // -----------------------------------------------------------------------------

  1022 //

  1023 void Ctstlm::Delete() 

  1024     {

  1025 

  1026     }

  1027 

  1028 // -----------------------------------------------------------------------------

  1029 // Ctstlm::RunMethodL

  1030 // Run specified method. Contains also table of test mothods and their names.

  1031 // -----------------------------------------------------------------------------

  1032 //

  1033 TInt Ctstlm::RunMethodL( 

  1034     CStifItemParser& aItem ) 

  1035     {

  1036 	iLog->Log ( _L ( "In RunMethodL method" ) );

  1037 	

  1038 

  1039     //TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 

  1040     //TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles );  

  1041 

  1042     static TStifFunctionInfo const KFunctions[] =

  1043         {  

  1044         // Copy this line for every implemented function.

  1045         // First string is the function name used in TestScripter script file.

  1046         // Second is the actual implementation member function.    

  1047         

  1048         // LmConnection       

  1049         ENTRY( "lm_connection_new", Ctstlm::lm_connection_newL ),

  1050         ENTRY( "lm_new_with_context", Ctstlm::lm_new_with_contextL ),

  1051         ENTRY( "lm_connection_open", Ctstlm::lm_connection_openL ),

  1052         ENTRY( "lm_connection_is_open_WhenConnectionIsClosed", Ctstlm::lm_connection_is_open_WhenConnectionIsClosedL), 

  1053         ENTRY( "lm_connection_is_authenticated_WhenNot_Authenticated", Ctstlm::lm_is_authenticated_WhenNotAuthenticatedL), 

  1054         ENTRY( "lm_connection_set_server_withNULL", Ctstlm::lm_connection_set_server_WithNULL),   

  1055         ENTRY( "lm_connection_set_jid_WithNull", Ctstlm::lm_connection_set_jid_WithNULL),   

  1056         ENTRY( "lm_connection_set_port_WithNULL", Ctstlm::lm_connection_set_port_WithNULL),   

  1057         ENTRY( "lm_connection_set_ssl_WithNULL", Ctstlm::lm_connection_set_ssl_WithNULL),   

  1058         ENTRY( "lm_connection_close", Ctstlm::lm_connection_closeL ),

  1059         ENTRY( "lm_connection_closeWhenNotOpen", Ctstlm::lm_connection_closeWhenNotOpenedL ),

  1060         ENTRY( "lm_authenticate", Ctstlm::lm_authenticateL ),

  1061         ENTRY( "lm_connection_is_open", Ctstlm::lm_connection_is_openL ),

  1062         ENTRY( "lm_is_authenticated", Ctstlm::lm_is_authenticatedL ),

  1063         ENTRY( "lm_connection_set_get_server", Ctstlm::lm_connection_set_get_serverL ),

  1064         ENTRY( "lm_connection_set_get_jid", Ctstlm::lm_connection_set_get_jidL ), 

  1065         ENTRY( "lm_connection_set_get_port", Ctstlm::lm_connection_set_get_portL ),

  1066         ENTRY( "lm_connection_set_get_ssl", Ctstlm::lm_connection_set_get_sslL ),

  1067         ENTRY( "lm_connection_set_get_proxy", Ctstlm::lm_connection_set_get_proxyL ),

  1068         

  1069         ENTRY( "lm_connection_send", Ctstlm::lm_connection_sendL ),

  1070         ENTRY( "lm_connection_send400char", Ctstlm::lm_connection_send400charL ),

  1071         ENTRY( "lm_connection_send_repeated", Ctstlm::lm_connection_send_repeatedL ),       

  1072         

  1073         ENTRY( "lm_send_with_reply", Ctstlm::lm_send_with_replyL ),

  1074         ENTRY( "register_message_handler", Ctstlm::register_message_handlerL ),

  1075         ENTRY( "set_disconnect_function", Ctstlm::set_disconnect_functionL ),

  1076         ENTRY( "lm_connection_send_raw",  Ctstlm::lm_connection_send_rawL ),

  1077         ENTRY( "lm_connection_get_state", Ctstlm::lm_connection_get_stateL ),

  1078         ENTRY( "lm_connection_ref",  Ctstlm::lm_connection_refL ),

  1079         ENTRY( "lm_connection_unref", Ctstlm::lm_connection_unrefL ),

  1080         

  1081         // LmMessage

  1082         ENTRY( "lm_message_new", Ctstlm::lm_message_newL ),

  1083         ENTRY( "lm_message_new_with_sub_type", Ctstlm::lm_message_new_with_sub_typeL ),

  1084         ENTRY( "lm_message_get_type", Ctstlm::lm_message_get_typeL ),

  1085         ENTRY( "lm_message_get_sub_type", Ctstlm::lm_message_get_sub_typeL ),

  1086         ENTRY( "lm_message_get_node", Ctstlm::lm_message_get_nodeL ),

  1087         ENTRY( "lm_message_ref", Ctstlm::lm_message_refL ),

  1088         ENTRY( "lm_message_unref", Ctstlm::lm_message_unrefL ),

  1089         

  1090         // LmMessageHandler

  1091         ENTRY( "lm_message_handler_new", Ctstlm::lm_message_handler_newL ),

  1092         ENTRY( "lm_message_handler_invalidate", Ctstlm::lm_message_handler_invalidateL ),

  1093         ENTRY( "lm_message_handler_is_valid", Ctstlm::lm_message_handler_is_validL ),

  1094         ENTRY( "lm_message_handler_ref", Ctstlm::lm_message_handler_refL ),

  1095         ENTRY( "lm_message_handler_unref", Ctstlm::lm_message_handler_unrefL ),

  1096         

  1097         // LmMessageNode

  1098         ENTRY( "lm_message_node_set_get_value", Ctstlm::lm_message_node_set_get_valueL ),

  1099         ENTRY( "lm_message_node_add_child", Ctstlm::lm_message_node_add_childL ),

  1100         ENTRY( "lm_message_node_get_child", Ctstlm::lm_message_node_get_childL ),

  1101         ENTRY( "lm_message_node_find_child", Ctstlm::lm_message_node_find_childL ),  

  1102         

  1103         ENTRY( "lm_message_node_set_get_attributes", Ctstlm::lm_message_node_set_get_attributesL ),

  1104               

  1105         ENTRY( "lm_message_node_set_get_raw_mode", Ctstlm::lm_message_node_set_get_raw_modeL ),

  1106         

  1107         ENTRY( "lm_message_node_ref", Ctstlm::lm_message_node_refL ),

  1108         ENTRY( "lm_message_node_unref", Ctstlm::lm_message_node_unrefL ),

  1109         

  1110         ENTRY( "lm_message_node_to_string", Ctstlm::lm_message_node_to_stringL ),

  1111         

  1112         // LmSSL

  1113         ENTRY( "lm_ssl_new", Ctstlm::lm_ssl_newL ),

  1114         ENTRY( "lm_ssl_is_supported", Ctstlm::lm_ssl_is_supportedL ),

  1115         ENTRY( "lm_ssl_get_fingerprint", Ctstlm::lm_ssl_get_fingerprintL ),

  1116         ENTRY( "lm_ssl_ref", Ctstlm::lm_ssl_refL ),

  1117         ENTRY( "lm_ssl_unref", Ctstlm::lm_ssl_unrefL ),        

  1118         

  1119         // LmProxy        

  1120         ENTRY( "lm_proxy_new", Ctstlm::lm_proxy_newL ),

  1121         ENTRY( "lm_proxy_new_with_server", Ctstlm::lm_proxy_new_with_serverL ),        

  1122         ENTRY( "lm_proxy_set_get_type", Ctstlm::lm_proxy_set_get_typeL ),        

  1123         ENTRY( "lm_proxy_set_get_server", Ctstlm::lm_proxy_set_get_serverL ),        

  1124         ENTRY( "lm_proxy_set_get_port", Ctstlm::lm_proxy_set_get_portL ),        

  1125         ENTRY( "lm_proxy_set_get_username", Ctstlm::lm_proxy_set_get_usernameL ),        

  1126         ENTRY( "lm_proxy_set_get_password", Ctstlm::lm_proxy_set_get_passwordL ),        

  1127         ENTRY( "lm_proxy_ref", Ctstlm::lm_proxy_refL ),

  1128         ENTRY( "lm_proxy_unref", Ctstlm::lm_proxy_unrefL ),

  1129         

  1130         // lm-send-sync example        

  1131         ENTRY( "lm_send_sync", Ctstlm::lm_send_syncL ),

  1132         

  1133         // lm contact list fetching code

  1134         

  1135         ENTRY( "lm_fetching_contactlist", Ctstlm::lm_fetching_contactlist_L ),