1 /*

     2 * Copyright (c) 2002 - 2007 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 "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:  isolationserverBlocks.cpp

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES] - do not remove

    21 #include <e32svr.h>

    22 #include <StifParser.h>

    23 #include <StifTestInterface.h>

    24 #include "isolationserver.h"

    25 #include  <e32const.h>

    26 

    27 #include <glib.h>

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

    29 #include <string.h>

    30 #include <stdlib.h>

    31 

    32 #include <glowmem.h>

    33 #include "msgliterals.h"

    34 #include "msg_enums.h"

    35 #include <math.h>

    36 #define ONE_K_OPENC_FIX 1020

    37 

    38 typedef enum

    39 {

    40 	RC_OK,

    41 	RC_ERROR

    42 } RC_Code_t;

    43 

    44 

    45 typedef struct

    46 {

    47 	gchar *recipient;

    48 	gchar *message;

    49 } MessageData;

    50 

    51 typedef struct

    52 {

    53 	gchar      *proxy_server;

    54 	gchar      *proxy_port;	

    55 }ProxyData;

    56 

    57 typedef struct

    58 {

    59 	gchar       *server;

    60 	gchar       *username;

    61 	gchar       *password;		

    62 	gchar       *resource;

    63 	MessageData *msg_data;

    64 	gchar       *port;	

    65 

    66     ProxyData   *proxy_data;

    67     gchar       *contact;

    68     gchar		*connmgr_bus;

    69     gchar		*connmgr_path;

    70     gchar		*protocol; 

    71     gchar		*key_given_name;

    72     gchar		*key_middle_name;

    73     gchar		*key_jid;

    74     gchar		*key_full_name;

    75     gchar       *mimetype;

    76     gchar       *image_file_name; 

    77 

    78 } ConnectData;

    79 

    80 

    81 // Function to read data from the cfg file

    82 static RC_Code_t read_data ( ConnectData*& connect_data, 

    83                              CStifItemParser& aItem );

    84                              

    85 // Function to free the allocated resources

    86 static void free_data ( ConnectData*& connect_data );                             

    87 

    88 // EXTERNAL DATA STRUCTURES

    89 //extern  ?external_data;

    90 

    91 // EXTERNAL FUNCTION PROTOTYPES  

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

    93 

    94 // CONSTANTS

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

    96 

    97 // MACROS

    98 //#define ?macro ?macro_def

    99 

   100 // LOCAL CONSTANTS AND MACROS

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

   102 //#define ?macro_name ?macro_def

   103 

   104 // MODULE DATA STRUCTURES

   105 //enum ?declaration

   106 //typedef ?declaration

   107 

   108 // LOCAL FUNCTION PROTOTYPES

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

   110 

   111 // FORWARD DECLARATIONS

   112 //class ?FORWARD_CLASSNAME;

   113 

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

   115 

   116 

   117 

   118 //-----------------------------------------------------------------------------

   119 // function_name	: read_data

   120 // description     	: Reads data from the CFG file

   121 // Returns          : None

   122 //-----------------------------------------------------------------------------

   123 //

   124 static RC_Code_t

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

   126     {

   127 	TPtrC               string;

   128 	TBuf8<KMaxFileName> temp;

   129 	MessageData         *msg_data   = NULL;

   130 	

   131 

   132 	ProxyData           *proxy_data = NULL;

   133 //	TInt                proxy_port;

   134 

   135 

   136 	

   137 	connect_data = g_new0 ( ConnectData, 1 );

   138 	if ( !connect_data )

   139 	    {

   140 		return RC_ERROR;

   141 	    }

   142 	    

   143 	msg_data = g_new0 ( MessageData, 1 );

   144 	if ( !msg_data )

   145 	    {

   146 		free_data ( connect_data );

   147 		return RC_ERROR;

   148 	    }

   149 	

   150 	connect_data->msg_data = msg_data;

   151 	

   152 

   153     proxy_data = g_new0 ( ProxyData, 1 );

   154     if ( !proxy_data ) 

   155     	{

   156     	free_data ( connect_data );

   157     	return RC_ERROR;

   158     	}

   159 	connect_data->proxy_data = proxy_data;

   160 

   161 

   162 	// Read server name

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

   164 	    {

   165 		temp.Copy ( string );

   166 		temp.Append ( '\0' );

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

   168 		if ( !connect_data->server )

   169 		    {			

   170 			free_data ( connect_data );

   171 			return RC_ERROR;

   172 		    }

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

   174 	    }

   175 	    

   176 	// Read Username

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

   178 	    {

   179 	    temp.Copy ( string );

   180 	    temp.Append ( '\0' );

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

   182 	    if ( !connect_data->username )

   183 	        {	    	

   184 	    	free_data ( connect_data );

   185 	    	return RC_ERROR;

   186 	        }

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

   188 	    }

   189 	

   190 	// Read Password corresponding to Username

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

   192 	    {

   193 	    temp.Copy ( string );

   194 	    temp.Append ( '\0' );

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

   196 	    if ( !connect_data->password )

   197 	        {	    	

   198 	    	free_data ( connect_data );

   199 	    	return RC_ERROR;

   200 	        }

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

   202 	    }

   203 	

   204 	// Read recipient

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

   206 	    {

   207 	    temp.Copy ( string );

   208 	    temp.Append ( '\0' );

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

   210 	    if ( !msg_data->recipient )

   211 	        {

   212 	    	free_data ( connect_data );

   213 	    	return RC_ERROR;

   214 	        }

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

   216 	    }

   217 	

   218 	// Read Message

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

   220 	    {

   221 	    temp.Copy ( string );

   222 	    temp.Append ( '\0' );	    

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

   224 	    if ( !msg_data->message )

   225 	        {

   226 	    	free_data ( connect_data );

   227 	    	return RC_ERROR;

   228 	        }

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

   230 	    }

   231 	

   232 	// Read resource identifier

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

   234 	    {

   235 	    temp.Copy ( string );

   236 	    temp.Append ( '\0' );

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

   238 	    if ( !connect_data->resource )

   239 	        {

   240 	    	free_data ( connect_data );

   241 	    	return RC_ERROR;

   242 	        }

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

   244 	    }

   245 	 

   246 

   247 	// Read proxy server and proxy port

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

   249     	{

   250     	temp.Copy ( string );

   251     	temp.Append ( '\0' );

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

   253     	if ( !proxy_data->proxy_server )

   254     		{

   255     		free_data ( connect_data );

   256     		return RC_ERROR;

   257     		}

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

   259     	}

   260     	

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

   262     	{

   263     	temp.Copy ( string );

   264     	temp.Append ( '\0' );

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

   266     	if ( !proxy_data->proxy_port )

   267     		{

   268     		free_data ( connect_data );

   269     		return RC_ERROR;

   270     		}

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

   272     	}

   273     	

   274     	

   275     	

   276     /*	if ( aItem.GetNextString ( proxy_port ) == KErrNone )

   277     		{

   278     		proxy_data->proxy_port = proxy_port;

   279     		}  */  	

   280  

   281 

   282 	// Read POrt address

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

   284 	    {

   285 	    temp.Copy ( string );

   286 	    temp.Append ( '\0' );

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

   288 	    if ( !connect_data->port )

   289 	        {

   290 	    	free_data ( connect_data );

   291 	    	return RC_ERROR;

   292 	        }

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

   294 	    }

   295   

   296   // read Add member

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

   298 	    {

   299 		temp.Copy ( string );

   300 		temp.Append ( '\0' );

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

   302 		if ( !connect_data->contact )

   303 		    {			

   304 			free_data ( connect_data );

   305 			return RC_ERROR;

   306 		    }

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

   308 	    }

   309   

   310    	// read CONNMGR_BUS

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

   312 	    {

   313 		temp.Copy ( string );

   314 		temp.Append ( '\0' );

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

   316 		if ( !connect_data->connmgr_bus )

   317 		    {			

   318 			free_data ( connect_data );

   319 			return RC_ERROR;

   320 		    }

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

   322 	    }

   323 	

   324 	// read CONNMGR_PATH

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

   326 	    {

   327 		temp.Copy ( string );

   328 		temp.Append ( '\0' );

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

   330 		if ( !connect_data->connmgr_path )

   331 		    {			

   332 			free_data ( connect_data );

   333 			return RC_ERROR;

   334 		    }

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

   336 	    }

   337 	    

   338 	// read PROTOCOL

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

   340 	    {

   341 		temp.Copy ( string );

   342 		temp.Append ( '\0' );

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

   344 		if ( !connect_data->protocol )

   345 		    {			

   346 			free_data ( connect_data );

   347 			return RC_ERROR;

   348 		    }

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

   350 	    }	 

   351 	        

   352     

   353 	    // read given Name

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

   355 	    {

   356 		temp.Copy ( string );

   357 		temp.Append ( '\0' );

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

   359 		if ( !connect_data->key_given_name )

   360 		    {			

   361 			free_data ( connect_data );

   362 			return RC_ERROR;

   363 		    }

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

   365 	    }	 

   366 	    

   367 	    // read middle Name

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

   369 	    {

   370 		temp.Copy ( string );

   371 		temp.Append ( '\0' );

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

   373 		if ( !connect_data->key_middle_name )

   374 		    {			

   375 			free_data ( connect_data );

   376 			return RC_ERROR;

   377 		    }

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

   379 	    }	 

   380 	    

   381 	    // read email Name

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

   383 	    {

   384 		temp.Copy ( string );

   385 		temp.Append ( '\0' );

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

   387 		if ( !connect_data->key_jid )

   388 		    {			

   389 			free_data ( connect_data );

   390 			return RC_ERROR;

   391 		    }

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

   393 	    }	 

   394 	    

   395 	    // read full Name

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

   397 	    {

   398 		temp.Copy ( string );

   399 		temp.Append ( '\0' );

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

   401 		if ( !connect_data->key_full_name )

   402 		    {			

   403 			free_data ( connect_data );

   404 			return RC_ERROR;

   405 		    }

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

   407 	    }	 

   408        // read mimetype

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

   410            {

   411            temp.Copy ( string );

   412            temp.Append ( '\0' );

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

   414            if ( !connect_data->mimetype )

   415                {           

   416                free_data ( connect_data );

   417                return RC_ERROR;

   418                }

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

   420            }    

   421        // read image filename

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

   423            {

   424            temp.Copy ( string );

   425            temp.Append ( '\0' );

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

   427            if ( !connect_data->image_file_name )

   428                {           

   429                free_data ( connect_data );

   430                return RC_ERROR;

   431                }

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

   433            }          

   434 	return RC_OK;

   435     }

   436 

   437 

   438 //-----------------------------------------------------------------------------

   439 // function_name	: free_data

   440 // description     	: Deallocates all the data

   441 // Returns          : None

   442 //-----------------------------------------------------------------------------

   443 //

   444 static void

   445 free_data ( ConnectData*& connect_data )

   446     {

   447 	if ( connect_data )

   448 	    {

   449 		if ( connect_data->server )

   450 		    {

   451 			g_free ( connect_data->server );

   452 			connect_data->server = NULL;

   453 		    }

   454 		

   455 		if ( connect_data->username )

   456 		    {

   457 			g_free ( connect_data->username );

   458 			connect_data->username = NULL;

   459 		    }

   460 		

   461 		if ( connect_data->password )

   462 		    {

   463 			g_free ( connect_data->password );

   464 			connect_data->password = NULL;

   465 		    }

   466 		

   467 		if ( connect_data->msg_data )

   468 		    {

   469 			if ( connect_data->msg_data->recipient )

   470 			    {

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

   472 				connect_data->msg_data->recipient = NULL;

   473 			    }

   474 			if ( connect_data->msg_data->message )

   475 			    {

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

   477 				connect_data->msg_data->message = NULL;

   478 			    }

   479 			g_free ( connect_data->msg_data );

   480 			connect_data->msg_data = NULL;

   481 		    }		

   482 		

   483 		if ( connect_data->resource )

   484 		    {

   485 			g_free ( connect_data->resource );

   486 			connect_data->resource = NULL;

   487 		    }

   488 		    

   489 

   490 	    if ( connect_data->proxy_data )

   491 	    	{

   492 	    	if ( connect_data->proxy_data->proxy_server )

   493 	    		{

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

   495 	    		connect_data->proxy_data->proxy_server = NULL;

   496 	    		}

   497 	    	g_free ( connect_data->proxy_data );

   498 	    	connect_data->proxy_data = NULL;	

   499 	    	}

   500 	  

   501 	    if ( connect_data->port )

   502 		    {

   503 			g_free ( connect_data->port );

   504 			connect_data->port = NULL;

   505 		    }  

   506 		    

   507 		    

   508 		if ( connect_data->contact )

   509 		    {

   510 			g_free ( connect_data->contact );

   511 			connect_data->contact = NULL;

   512 		    }

   513 		    

   514 		if ( connect_data->key_given_name )

   515 		    {

   516 			g_free ( connect_data->key_given_name );

   517 			connect_data->key_given_name = NULL;

   518 		    }

   519 		    

   520 		if ( connect_data->key_middle_name )

   521 		    {

   522 			g_free ( connect_data->key_middle_name );

   523 			connect_data->key_middle_name = NULL;

   524 		    }

   525 		    

   526 		if ( connect_data->key_jid )

   527 		    {

   528 			g_free ( connect_data->key_jid );

   529 			connect_data->key_jid = NULL;

   530 		    }

   531 		    

   532 		if ( connect_data->key_full_name )

   533 		    {

   534 			g_free ( connect_data->key_full_name );

   535 			connect_data->key_full_name = NULL;

   536 		    }  

   537 		          

   538 		g_free ( connect_data );

   539 		connect_data = NULL;    

   540 	    }

   541     }

   542     

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

   544 // function_name	: running isolation server exe

   545 // description     	: Deallocates all the data

   546 // Returns          : None

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

   548   int  run_isoserver()

   549   {

   550   	// running isoserver 

   551     RProcess isosrv_launcher;

   552     TInt lunch_err = 0;

   553     _LIT(KProcess, "isoserver.exe");

   554     lunch_err = isosrv_launcher.Create( KProcess, KNullDesC );

   555      if ( KErrNone != lunch_err ) 

   556 	    {

   557 		return KErrGeneral;

   558 	    	

   559 	    }

   560 	isosrv_launcher.Resume();

   561 	return KErrNone;

   562   }

   563 

   564 // -----------------------------------------------------------------------------

   565 // ?function_name ?description.

   566 // ?description

   567 // Returns: ?value_1: ?description

   568 //          ?value_n: ?description_line1

   569 //                    ?description_line2

   570 // -----------------------------------------------------------------------------

   571 //

   572 /*

   573 ?type ?function_name(

   574     ?arg_type arg,  // ?description

   575     ?arg_type arg)  // ?description

   576     {

   577 

   578     ?code  // ?comment

   579 

   580     // ?comment

   581     ?code

   582     }

   583 */

   584 

   585 // ============================ MEMBER FUNCTIONS ===============================

   586 

   587 // -----------------------------------------------------------------------------

   588 // Cisolationserver::Delete

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

   590 // Called from destructor. 

   591 // -----------------------------------------------------------------------------

   592 //

   593 void Cisolationserver::Delete() 

   594     {

   595 

   596     }

   597 

   598 // -----------------------------------------------------------------------------

   599 // Cisolationserver::RunMethodL

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

   601 // -----------------------------------------------------------------------------

   602 //

   603 TInt Cisolationserver::RunMethodL( 

   604     CStifItemParser& aItem ) 

   605     {

   606 

   607     static TStifFunctionInfo const KFunctions[] =

   608         {  

   609         

   610         ENTRY( "SecondSearch", Cisolationserver::SecondSearch), 

   611         ENTRY( "SearchAndAddContact", Cisolationserver::SearchAndAddContact ),

   612         ENTRY( "LoginWithCorrectData", Cisolationserver::LoginWithCorrectdata ),

   613         ENTRY( "LoginWithWrongPassword", Cisolationserver::LoginWithWrongPassword ),

   614         ENTRY( "LoginWithUnexistUserId", Cisolationserver::LoginWithUnexistUserId),

   615         ENTRY( "LoginWithUnexistServer", Cisolationserver::LoginWithUnexistServer),

   616         ENTRY( "LoginWithMixedLetterUserId", Cisolationserver::LoginWithMixedletterUserId),

   617         ENTRY( "LoginWithMaximumLenghtUserId", Cisolationserver::LoginWithMaximumLengthUserId),

   618         ENTRY( "LoginWithMinimumLenghtUserId", Cisolationserver::LoginWithMinimumLengthUserId),

   619         ENTRY( "LogoutFromServer", Cisolationserver::LogoutFromServer),

   620         ENTRY( "LoginWithBlankUserId", Cisolationserver::LoginWithBlankUserId),

   621         ENTRY( "LoginLogOutWithReapitiveSession", Cisolationserver::LoginLogOutWithReapitiveSession),

   622         ENTRY( "LoginWithCoreectUserIDWithSpace", Cisolationserver::LoginWithCoreectUserIDWithSpace),

   623         ENTRY( "LoginWithInvalidPortAddress", Cisolationserver::LoginWithInvalidPortAddress),

   624         ENTRY( "LoginWithMissingSettings", Cisolationserver::LoginWithMissingSettings),

   625         ENTRY( "LoginWhenTGAndDDAreNotRunning", Cisolationserver::LoginWhenTGAndDDAreNotRunning),

   626         ENTRY( "SendMessageToCorrectUserID", Cisolationserver::SendMessageToCorrectUserID),

   627         ENTRY( "SendMaxLenMessageToCorrectUserID", Cisolationserver::SendMaxLenMessageToCorrectUserID),

   628         ENTRY( "SendTextMessageUnExistUserID", Cisolationserver::SendTextMessageUnExistUserID),

   629         ENTRY( "SendTextMessageWithSpecialCharacter", Cisolationserver::SendTextMessageWithSpecialCharacter),

   630         ENTRY( "SendMessageWithBlankUserID", Cisolationserver::SendMessageWithBlankUserID),

   631         ENTRY( "SendSmilyToCorrectUserID", Cisolationserver::SendSmilyToCorrectUserID),

   632         ENTRY( "SendBlankMessageToUserID", Cisolationserver::SendBlankMessageToUserID),

   633         ENTRY( "SendMessageToOfflineContact", Cisolationserver::SendMessageToOfflineContact),

   634         ENTRY( "SendContinuousltReapitiveMessage", Cisolationserver::SendContinuousltReapitiveMessage),

   635         ENTRY( "SendTextMessageToBlockedUser", Cisolationserver::SendTextMessageToBlockedUser),

   636         ENTRY( "SendTextMessageToUserIdWhoIsBlockedSender", Cisolationserver::SendTextMessageToUserIdWhoIsBlockedSender),

   637         ENTRY( "SendLongTextMessageToUserId", Cisolationserver::SendLongTextMessageToUserId),

   638         ENTRY( "SendTextMessageUserWhoIsNotAddedInContactList", Cisolationserver::SendTextMessageUserWhoIsNotAddedInContactList),

   639         ENTRY( "MessageReceiveFromUser", Cisolationserver::MessageReceiveFromUser),

   640         ENTRY( "AddExistingContact", Cisolationserver::AddExistingContact),

   641         ENTRY( "ClientSendBlankUserIdForADD", Cisolationserver::ClientSendBlankUserIdForADD),

   642         ENTRY( "AddContactWhichIsAlreadyAdded", Cisolationserver::AddContactWhichIsAlreadyAdded),

   643         ENTRY( "AddExistingContactWIthSpace", Cisolationserver::AddExistingContactWIthSpace),

   644         ENTRY( "AddUnexistingUserID", Cisolationserver::AddUnexistingUserID),

   645         ENTRY( "AddExistingContactWIthMixedLetter", Cisolationserver::AddExistingContactWIthMixedLetter),

   646         ENTRY( "AddInvalidContactWIthSpecialLetter", Cisolationserver::AddInvalidContactWIthSpecialLetter),

   647         ENTRY( "DeleteExistingContact", Cisolationserver::DeleteExistingContact),

   648         ENTRY( "ClientSendBlankUserIdForDELETE", Cisolationserver::ClientSendBlankUserIdForDELETE),

   649         ENTRY( "DeleteContactWhichIsAlreadyDeleted", Cisolationserver::DeleteContactWhichIsAlreadyDeleted),

   650         ENTRY( "DeleteExistingContactWIthSpace", Cisolationserver::DeleteExistingContactWIthSpace),

   651         ENTRY( "DeleteUnexistingUserID", Cisolationserver::DeleteUnexistingUserID),

   652         ENTRY( "DeleteExistingContactWIthMixedLetter", Cisolationserver::DeleteExistingContactWIthMixedLetter),

   653         ENTRY( "DeleteInvalidContactWIthSpecialLetter", Cisolationserver::DeleteInvalidContactWIthSpecialLetter),

   654         ENTRY( "FetchContatcs", Cisolationserver::FetchContatcs),

   655         ENTRY( "AddContatcs", Cisolationserver::AddContatcs),

   656         ENTRY( "UpdatePresenceWithAway", Cisolationserver::UpdatePresenceWithAway),

   657         ENTRY( "UpdatePresenceWithDnd", Cisolationserver::UpdatePresenceWithDnd),

   658         ENTRY( "UpdatePresenceWithAvailable", Cisolationserver::UpdatePresenceWithAvailable),

   659         ENTRY( "UpdatePresenceMultipleTimeInSameSession", Cisolationserver::UpdatePresenceMultipleTimeInSameSession),

   660         ENTRY( "UpdateOnlyStatusText", Cisolationserver::UpdateOnlyStatusText),

   661         ENTRY( "UpdateOnlyUserAvailability", Cisolationserver::UpdateOnlyUserAvailability),

   662         ENTRY( "UpdateOwnPresenceWithBlankData", Cisolationserver::UpdateOwnPresenceWithBlankData),

   663         ENTRY( "UpdateStatusTextWithMaxLen", Cisolationserver::UpdateStatusTextWithMaxLen),

   664         ENTRY( "UpdateStatusTextWithSpecialCharacter", Cisolationserver::UpdateStatusTextWithSpecialCharacter),

   665         ENTRY( "HandelingPresenceNotification", Cisolationserver::HandelingPresenceNotification),

   666         ENTRY( "SearchKeyValue", Cisolationserver::SearchKeyValue),

   667         ENTRY( "SearchKeyValueWithResult", Cisolationserver::SearchKeyValueWithResult ),

   668         ENTRY( "SearchKeyValueInvalidParam", Cisolationserver::SearchKeyValueInvalidParam ),

   669         ENTRY( "SearchForLargeNoOfResult", Cisolationserver::SearchForLargeNoOfResult ),

   670         ENTRY( "SearchKeyValueInvalidParam2", Cisolationserver::SearchKeyValueInvalidParam2 ),

   671         ENTRY( "SearchKeyValueInvalidHashValues", Cisolationserver::SearchKeyValueInvalidHashValues ),

   672         ENTRY( "SearchKeyValueBlank", Cisolationserver::SearchKeyValueBlank ),

   673         ENTRY( "SearchKeyValueSpecialChar", Cisolationserver::SearchKeyValueSpecialChar ),

   674         ENTRY( "SearchKeyValueLargeString", Cisolationserver::SearchKeyValueLargeString ),

   675         ENTRY( "AcceptAddRequestFromUser", Cisolationserver::AcceptAddRequestFromUser ),

   676         ENTRY( "RejectAddRequestFromUser", Cisolationserver::RejectAddRequestFromUser ),

   677         ENTRY( "SendAcceptRequestWithoutReceivingAddrequest", Cisolationserver::SendAcceptRequestWithoutReceivingAddrequest ),

   678         ENTRY( "SendRejectRequestWithoutReceivingAddrequest", Cisolationserver::SendRejectRequestWithoutReceivingAddrequest ),

   679         ENTRY( "SendAcceptRequestWithoutAnyUserID", Cisolationserver::SendAcceptRequestWithoutAnyUserID ),

   680         ENTRY( "SendRejectRequestWithoutAnyUserID", Cisolationserver::SendRejectRequestWithoutAnyUserID ),

   681         ENTRY( "LogoutWhileUserIsNotLoggedIn", Cisolationserver::LogoutWhileUserIsNotLoggedIn),

   682         ENTRY( "GetKeysAndSearch", Cisolationserver::GetKeysAndSearch),

   683         ENTRY( "SetOwnAvatar", Cisolationserver::SetOwnAvatar),

   684         ENTRY( "ClearOwnAvatar", Cisolationserver::ClearOwnAvatar),

   685         ENTRY( "FetchCachedContacts", Cisolationserver::FetchCachedContacts),

   686         //ADD NEW ENTRY HERE

   687         // [test cases entries] - Do not remove

   688 

   689         };

   690 

   691     const TInt count = sizeof( KFunctions ) / 

   692                         sizeof( TStifFunctionInfo );

   693 

   694     return RunInternalL( KFunctions, count, aItem );

   695 

   696     }

   697     

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

   699 // Cisolationserver::Login with correct data

   700 // Example test method function.

   701 // (other items were commented in a header).

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

   703 //

   704 TInt Cisolationserver::LoginWithCorrectdata( CStifItemParser& aItem )

   705     {

   706   	

   707     ConnectData  *connect_data = NULL;

   708     char smsg[MAX_MSG_SIZE];

   709     char rmsg[MAX_MSG_SIZE];

   710     int index=0;

   711 

   712 	FILE *fp;	

   713 	int timeout = 100;

   714 	int nBytes;

   715     int result = 0;

   716     int err = 0;

   717     int status = 0;

   718     message_hdr_req *msgHdr = NULL;  

   719     message_hdr_resp* msg_struct = NULL;

   720     TInt return_value = 0;

   721         	// Read data from the CFG file

   722 	if ( read_data ( connect_data, aItem ) != RC_OK )

   723 		{

   724 		iLog->Log ( _L ( "read_data failed" ) );

   725 		free_data ( connect_data );

   726 		return_value = KErrGeneral;

   727 		goto return_code;

   728 		}

   729 	//request formation	

   730 	memset( smsg, '\0', MAX_MSG_SIZE );

   731 	memset( rmsg, '\0', MAX_MSG_SIZE );

   732 	//message header use

   733 	msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

   734     memset( msgHdr, '\0', sizeof( message_hdr_req ) );

   735     msgHdr->message_type = ELogin_Request;

   736     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

   737     index += sizeof( message_hdr_req );

   738     int len = strlen(connect_data->username);

   739     strcpy( smsg + index, connect_data->username );

   740     index += len + 1;

   741     //appending password

   742     len = strlen(connect_data->password );

   743     strcpy( smsg + index, connect_data->password );

   744     index += len + 1;

   745     //appending server name

   746     len = strlen(connect_data->server );

   747     strcpy( smsg + index, connect_data->server );

   748     index += len + 1;

   749     //appending resource

   750     len = strlen(connect_data->resource );

   751     strcpy( smsg + index, connect_data->resource );

   752     index += len + 1;

   753     //appending ssl

   754     smsg[index++]= '1';

   755     smsg[index++]= '\0';

   756     //appending server port

   757     len = strlen(connect_data->port );

   758     strcpy( smsg + index, connect_data->port );

   759     index += len + 1;

   760     // appending IAP id

   761     smsg[index++]= '1';

   762     smsg[index++]= '\0';

   763     //appending connmgr_bus

   764     len = strlen(connect_data->connmgr_bus );

   765     strcpy( smsg + index, connect_data->connmgr_bus );

   766     index += len + 1;

   767     //appending connmgr_path

   768     len = strlen(connect_data->connmgr_path );

   769     strcpy( smsg + index, connect_data->connmgr_path );

   770     index += len + 1;

   771     //appending protocol

   772     len = strlen(connect_data->protocol );

   773     strcpy( smsg + index, connect_data->protocol );

   774     index += len + 1;

   775     #ifdef __WINSCW__

   776     //proxy server

   777     len = strlen(connect_data->proxy_data->proxy_server );

   778     strcpy( smsg + index, connect_data->proxy_data->proxy_server );

   779     index += len + 1;

   780     //proxy port

   781     len = strlen(connect_data->proxy_data->proxy_port );

   782     strcpy( smsg + index, connect_data->proxy_data->proxy_port );

   783     index += len + 1;

   784     #endif

   785      //running isoserver   

   786     run_isoserver(); 

   787     //create message queue for send request

   788     result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

   789     //create message queue for response request

   790     result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

   791     /* Send Message to queueOne */

   792 	result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

   793     status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, timeout, &err); 

   794     msg_struct = ( message_hdr_resp* ) malloc( sizeof( message_hdr_resp ) );

   795 	memset( msg_struct, '\0', sizeof( message_hdr_resp ) );

   796 	memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );

   797     if (status < 0)

   798     {

   799     return_value = KErrGeneral;

   800 	goto return_code;	

   801     }

   802    	if( msg_struct->response != 1)

   803     {

   804     return_value = KErrGeneral;

   805 	goto return_code;

   806     }

   807      // login end

   808     //fetch req..

   809     for (int i= 0 ;i<3 ;i++)

   810     {

   811         

   812     fp = fopen("c:\\fetch_contact.txt","a");

   813 	do  {

   814 		status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, 2000, &err); 

   815 		memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );	

   816 		fwrite(rmsg,1,status,fp);

   817 		memset( rmsg, '\0', MAX_MSG_SIZE );

   818 		} while (!((msg_struct->hdr_req.message_type==ECurrent_Member_Contacts) 

   819 		          ||(msg_struct->hdr_req.message_type==ELocal_Pending_Contacts) 

   820 		          ||(msg_struct->hdr_req.message_type==ERemote_Pending_Contacts))&& 0 == msg_struct->continue_flag);

   821 	fclose(fp);	

   822 	

   823     }

   824 

   825 	//fetch end

   826     

   827     // logout test code from server

   828     index=0;

   829     memset( smsg, '\0', MAX_MSG_SIZE );

   830 	memset( rmsg, '\0', MAX_MSG_SIZE );

   831 	

   832 	memset( msgHdr, '\0', sizeof( message_hdr_req ) );

   833     

   834     msgHdr->message_type = ELogout_Request;

   835  

   836     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

   837     index += sizeof( message_hdr_req );

   838 

   839 	

   840 	 result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

   841     

   842     do  {

   843 		status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, 2000, &err);

   844 		memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );	

   845 	    memset( rmsg, '\0', MAX_MSG_SIZE );

   846 		} while (msg_struct->hdr_req.message_type!=ELogout_Request);

   847    

   848     if ( msg_struct->response != 1)

   849     {

   850     return_value = KErrGeneral;

   851 	goto return_code;

   852     }

   853     return_value = KErrNone;

   854 	goto return_code;

   855     //killing isoserver

   856     return_code:

   857     index=0;

   858     memset( smsg, '\0', MAX_MSG_SIZE );

   859 	memset( rmsg, '\0', MAX_MSG_SIZE );

   860 	memset( msgHdr, '\0', sizeof( message_hdr_req ) );

   861     msgHdr->message_type = EKill_Process;

   862  

   863     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

   864     index += sizeof( message_hdr_req );

   865 

   866 	

   867 	result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

   868     free( msg_struct );

   869     return return_value;

   870 

   871     }

   872 

   873 

   874   // -----------------------------------------------------------------------------

   875 // Cisolationserver::Logout from server

   876 // Example test method function.

   877 // (other items were commented in a header).

   878 // -----------------------------------------------------------------------------

   879 //

   880 TInt Cisolationserver::LogoutFromServer( CStifItemParser& aItem )

   881     {

   882   	ConnectData  *connect_data = NULL;

   883     char smsg[MAX_MSG_SIZE];

   884     char rmsg[MAX_MSG_SIZE];

   885     int index=0;

   886 

   887 	FILE *fp;	

   888 	int timeout = 100;

   889 	int nBytes;

   890     int result = 0;

   891     int err = 0;

   892     int status = 0;

   893     message_hdr_req *msgHdr = NULL;  

   894     message_hdr_resp* msg_struct = NULL;

   895     TInt return_value = 0;

   896         	// Read data from the CFG file

   897 	if ( read_data ( connect_data, aItem ) != RC_OK )

   898 		{

   899 		iLog->Log ( _L ( "read_data failed" ) );

   900 		free_data ( connect_data );

   901 		return_value = KErrGeneral;

   902 		goto return_code;

   903 		}

   904 	//request formation	

   905 	memset( smsg, '\0', MAX_MSG_SIZE );

   906 	memset( rmsg, '\0', MAX_MSG_SIZE );

   907 	//message header use

   908 	msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

   909     memset( msgHdr, '\0', sizeof( message_hdr_req ) );

   910     msgHdr->message_type = ELogin_Request;

   911     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

   912     index += sizeof( message_hdr_req );

   913     int len = strlen(connect_data->username);

   914     strcpy( smsg + index, connect_data->username );

   915     index += len + 1;

   916     //appending password

   917     len = strlen(connect_data->password );

   918     strcpy( smsg + index, connect_data->password );

   919     index += len + 1;

   920     //appending server name

   921     len = strlen(connect_data->server );

   922     strcpy( smsg + index, connect_data->server );

   923     index += len + 1;

   924     //appending resource

   925     len = strlen(connect_data->resource );

   926     strcpy( smsg + index, connect_data->resource );

   927     index += len + 1;

   928     //appending ssl

   929     smsg[index++]= '1';

   930     smsg[index++]= '\0';

   931     //appending server port

   932     len = strlen(connect_data->port );

   933     strcpy( smsg + index, connect_data->port );

   934     index += len + 1;

   935     // appending IAP id

   936     smsg[index++]= '1';

   937     smsg[index++]= '\0';

   938     //appending connmgr_bus

   939     len = strlen(connect_data->connmgr_bus );

   940     strcpy( smsg + index, connect_data->connmgr_bus );

   941     index += len + 1;

   942     //appending connmgr_path

   943     len = strlen(connect_data->connmgr_path );

   944     strcpy( smsg + index, connect_data->connmgr_path );

   945     index += len + 1;

   946     //appending protocol

   947     len = strlen(connect_data->protocol );

   948     strcpy( smsg + index, connect_data->protocol );

   949     index += len + 1;

   950     #ifdef __WINSCW__

   951     //proxy server

   952     len = strlen(connect_data->proxy_data->proxy_server );

   953     strcpy( smsg + index, connect_data->proxy_data->proxy_server );

   954     index += len + 1;

   955     //proxy port

   956     len = strlen(connect_data->proxy_data->proxy_port );

   957     strcpy( smsg + index, connect_data->proxy_data->proxy_port );

   958     index += len + 1;

   959     #endif

   960      //running isoserver   

   961     run_isoserver(); 

   962     //create message queue for send request

   963     result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

   964     //create message queue for response request

   965     result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

   966     /* Send Message to queueOne */

   967 	result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

   968     status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, timeout, &err); 

   969     msg_struct = ( message_hdr_resp* ) malloc( sizeof( message_hdr_resp ) );

   970 	memset( msg_struct, '\0', sizeof( message_hdr_resp ) );

   971 	memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );

   972     if (status < 0)

   973     {

   974     return_value = KErrGeneral;

   975 	goto return_code;	

   976     }

   977    	if( msg_struct->response != 1)

   978     {

   979     return_value = KErrGeneral;

   980 	goto return_code;

   981     }

   982      // login end

   983     //fetch req..

   984     for (int i= 0 ;i<3 ;i++)

   985     {

   986         

   987     fp = fopen("c:\\fetch_contact.txt","a");

   988 	do  {

   989 		status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, 2000, &err); 

   990 		memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );	

   991 		fwrite(rmsg,1,status,fp);

   992 		memset( rmsg, '\0', MAX_MSG_SIZE );

   993 		} while (!((msg_struct->hdr_req.message_type==ECurrent_Member_Contacts) 

   994 		          ||(msg_struct->hdr_req.message_type==ELocal_Pending_Contacts) 

   995 		          ||(msg_struct->hdr_req.message_type==ERemote_Pending_Contacts))&& 0 == msg_struct->continue_flag);

   996 	fclose(fp);	

   997 	

   998     }

   999 

  1000 	//fetch end

  1001     

  1002     // logout test code from server

  1003     index=0;

  1004     memset( smsg, '\0', MAX_MSG_SIZE );

  1005 	memset( rmsg, '\0', MAX_MSG_SIZE );

  1006 	

  1007 	memset( msgHdr, '\0', sizeof( message_hdr_req ) );

  1008     

  1009     msgHdr->message_type = ELogout_Request;

  1010  

  1011     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

  1012     index += sizeof( message_hdr_req );

  1013 	 result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err);

  1014     

  1015     do  {

  1016 		status = MsgQReceive(RESPONSE_QUEUE, rmsg, MAX_MSG_SIZE, 2000, &err);

  1017 		memcpy( msg_struct, rmsg, sizeof( message_hdr_resp ) );	

  1018 	    memset( rmsg, '\0', MAX_MSG_SIZE );

  1019 		} while (msg_struct->hdr_req.message_type!=ELogout_Request);

  1020    

  1021     if ( msg_struct->response != 1)

  1022     {

  1023     return_value = KErrGeneral;

  1024 	goto return_code;

  1025     }

  1026     return_value = KErrNone;

  1027 	goto return_code;

  1028     //killing isoserver

  1029     return_code:

  1030     index=0;

  1031     memset( smsg, '\0', MAX_MSG_SIZE );

  1032 	memset( rmsg, '\0', MAX_MSG_SIZE );

  1033 	memset( msgHdr, '\0', sizeof( message_hdr_req ) );

  1034     msgHdr->message_type = EKill_Process;

  1035     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

  1036     index += sizeof( message_hdr_req );

  1037 	result = MsgQSend(REQUEST_QUEUE, smsg, index, MSG_PRI_NORMAL, timeout, &err); 

  1038     free( msg_struct );

  1039     return return_value;

  1040 

  1041     }

  1042 

  1043   // -----------------------------------------------------------------------------

  1044 // Cisolationserver::Login with mixed letter user

  1045 // Example test method function.

  1046 // (other items were commented in a header).

  1047 // -----------------------------------------------------------------------------

  1048 //

  1049 TInt Cisolationserver::LoginWithMixedletterUserId( CStifItemParser& aItem )

  1050     {

  1051   	

  1052     ConnectData  *connect_data = NULL;

  1053     char smsg[MAX_MSG_SIZE];

  1054     char rmsg[MAX_MSG_SIZE];

  1055     int index=0;

  1056 

  1057 	FILE *fp;	

  1058 	int timeout = 100;

  1059 	int nBytes;

  1060     int result = 0;

  1061     int err = 0;

  1062     int status = 0;

  1063     message_hdr_req *msgHdr = NULL;  

  1064     message_hdr_resp* msg_struct = NULL;

  1065     TInt return_value = 0;

  1066         	// Read data from the CFG file

  1067 	if ( read_data ( connect_data, aItem ) != RC_OK )

  1068 		{

  1069 		iLog->Log ( _L ( "read_data failed" ) );

  1070 		free_data ( connect_data );

  1071 		return_value = KErrGeneral;

  1072 		goto return_code;

  1073 		}

  1074 	//request formation	

  1075 	memset( smsg, '\0', MAX_MSG_SIZE );

  1076 	memset( rmsg, '\0', MAX_MSG_SIZE );

  1077 	//message header use

  1078 	msgHdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

  1079     memset( msgHdr, '\0', sizeof( message_hdr_req ) );

  1080     msgHdr->message_type = ELogin_Request;

  1081     memcpy( smsg, msgHdr, sizeof( message_hdr_req ) );

  1082     index += sizeof( message_hdr_req );

  1083     int len = strlen(connect_data->username);

  1084     strcpy( smsg + index, connect_data->username );

  1085     index += len + 1;

  1086     //appending password

  1087     len = strlen(connect_data->password );

  1088     strcpy( smsg + index, connect_data->password );

  1089     index += len + 1;

  1090     //appending server name

  1091     len = strlen(connect_data->server );

  1092     strcpy( smsg + index, connect_data->server );

  1093     index += len + 1;

  1094     //appending resource

  1095     len = strlen(connect_data->resource );

  1096     strcpy( smsg + index, connect_data->resource );

  1097     index += len + 1;

  1098     //appending ssl

  1099     smsg[index++]= '1';

  1100     smsg[index++]= '\0';

  1101     //appending server port

  1102     len = strlen(connect_data->port );

  1103     strcpy( smsg + index, connect_data->port );

  1104     index += len + 1;

  1105     // appending IAP id

  1106     smsg[index++]= '1';

  1107     smsg[index++]= '\0';

  1108     //appending connmgr_bus

  1109     len = strlen(connect_data->connmgr_bus );

  1110     strcpy( smsg + index, connect_data->connmgr_bus );

  1111     index += len + 1;

  1112     //appending connmgr_path

  1113     len = strlen(connect_data->connmgr_path );

  1114     strcpy( smsg + index, connect_data->connmgr_path );

  1115     index += len + 1;

  1116     //appending protocol

  1117     len = strlen(connect_data->protocol );

  1118     strcpy( smsg + index, connect_data->protocol );

  1119     index += len + 1;

  1120     #ifdef __WINSCW__

  1121     //proxy server

  1122     len = strlen(connect_data->proxy_data->proxy_server );

  1123     strcpy( smsg + index, connect_data->proxy_data->proxy_server );

  1124     index += len + 1;

  1125     //proxy port

  1126     len = strlen(connect_data->proxy_data->proxy_port );

  1127     strcpy( smsg + index, connect_data->proxy_data->proxy_port );

  1128     index += len + 1;

  1129     #endif

  1130      //running isoserver   

  1131     run_isoserver(); 

  1132     //create message queue for send request

  1133     result = MsgQCreate(REQUEST_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);

  1134     //create message queue for response request

  1135     result = MsgQCreate(RESPONSE_QUEUE, MAX_MSG_Q_SIZE , MSG_Q_FIFO, &err);