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 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:   isolationserverBlocks.cpp

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // [INCLUDE FILES] - do not remove

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <StifTestInterface.h>

    25 #include "isolationserver.h"

    26 #include  <e32const.h>

    27 

    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 #include "msgliterals.h"

    35 #include "msg_enums.h"

    36 #include <math.h>

    37 #define ONE_K_OPENC_FIX 1020

    38 

    39 typedef enum

    40 {

    41 	RC_OK,

    42 	RC_ERROR

    43 } RC_Code_t;

    44 

    45 

    46 typedef struct

    47 {

    48 	gchar *recipient;

    49 	gchar *message;

    50 } MessageData;

    51 

    52 typedef struct

    53 {

    54 	gchar      *proxy_server;

    55 	gchar      *proxy_port;	

    56 }ProxyData;

    57 

    58 typedef struct

    59 {

    60 	gchar       *server;

    61 	gchar       *username;

    62 	gchar       *password;		

    63 	gchar       *resource;

    64 	MessageData *msg_data;

    65 	gchar       *port;	

    66 

    67     ProxyData   *proxy_data;

    68     gchar       *contact;

    69     gchar		*connmgr_bus;

    70     gchar		*connmgr_path;

    71     gchar		*protocol; 

    72     gchar		*key_given_name;

    73     gchar		*key_middle_name;

    74     gchar		*key_jid;

    75     gchar		*key_full_name;

    76     gchar       *mimetype;

    77     gchar       *image_file_name; 

    78 

    79 } ConnectData;

    80 

    81 

    82 // Function to read data from the cfg file

    83 static RC_Code_t read_data ( ConnectData*& connect_data, 

    84                              CStifItemParser& aItem );

    85                              

    86 // Function to free the allocated resources

    87 static void free_data ( ConnectData*& connect_data );                             

    88 

    89 // EXTERNAL DATA STRUCTURES

    90 //extern  ?external_data;

    91 

    92 // EXTERNAL FUNCTION PROTOTYPES  

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

    94 

    95 // CONSTANTS

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

    97 

    98 // MACROS

    99 //#define ?macro ?macro_def

   100 

   101 // LOCAL CONSTANTS AND MACROS

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

   103 //#define ?macro_name ?macro_def

   104 

   105 // MODULE DATA STRUCTURES

   106 //enum ?declaration

   107 //typedef ?declaration

   108 

   109 // LOCAL FUNCTION PROTOTYPES

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

   111 

   112 // FORWARD DECLARATIONS

   113 //class ?FORWARD_CLASSNAME;

   114 

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

   116 

   117 

   118 

   119 //-----------------------------------------------------------------------------

   120 // function_name	: read_data

   121 // description     	: Reads data from the CFG file

   122 // Returns          : None

   123 //-----------------------------------------------------------------------------

   124 //

   125 static RC_Code_t

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

   127     {

   128 	TPtrC               string;

   129 	TBuf8<KMaxFileName> temp;

   130 	MessageData         *msg_data   = NULL;

   131 	

   132 

   133 	ProxyData           *proxy_data = NULL;

   134 //	TInt                proxy_port;

   135 

   136 

   137 	

   138 	connect_data = g_new0 ( ConnectData, 1 );

   139 	if ( !connect_data )

   140 	    {

   141 		return RC_ERROR;

   142 	    }

   143 	    

   144 	msg_data = g_new0 ( MessageData, 1 );

   145 	if ( !msg_data )

   146 	    {

   147 		free_data ( connect_data );

   148 		return RC_ERROR;

   149 	    }

   150 	

   151 	connect_data->msg_data = msg_data;

   152 	

   153 

   154     proxy_data = g_new0 ( ProxyData, 1 );

   155     if ( !proxy_data ) 

   156     	{

   157     	free_data ( connect_data );

   158     	return RC_ERROR;

   159     	}

   160 	connect_data->proxy_data = proxy_data;

   161 

   162 

   163 	// Read server name

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

   165 	    {

   166 		temp.Copy ( string );

   167 		temp.Append ( '\0' );

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

   169 		if ( !connect_data->server )

   170 		    {			

   171 			free_data ( connect_data );

   172 			return RC_ERROR;

   173 		    }

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

   175 	    }

   176 	    

   177 	// Read Username

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

   179 	    {

   180 	    temp.Copy ( string );

   181 	    temp.Append ( '\0' );

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

   183 	    if ( !connect_data->username )

   184 	        {	    	

   185 	    	free_data ( connect_data );

   186 	    	return RC_ERROR;

   187 	        }

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

   189 	    }

   190 	

   191 	// Read Password corresponding to Username

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

   193 	    {

   194 	    temp.Copy ( string );

   195 	    temp.Append ( '\0' );

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

   197 	    if ( !connect_data->password )

   198 	        {	    	

   199 	    	free_data ( connect_data );

   200 	    	return RC_ERROR;

   201 	        }

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

   203 	    }

   204 	

   205 	// Read recipient

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

   207 	    {

   208 	    temp.Copy ( string );

   209 	    temp.Append ( '\0' );

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

   211 	    if ( !msg_data->recipient )

   212 	        {

   213 	    	free_data ( connect_data );

   214 	    	return RC_ERROR;

   215 	        }

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

   217 	    }

   218 	

   219 	// Read Message

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

   221 	    {

   222 	    temp.Copy ( string );

   223 	    temp.Append ( '\0' );	    

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

   225 	    if ( !msg_data->message )

   226 	        {

   227 	    	free_data ( connect_data );

   228 	    	return RC_ERROR;

   229 	        }

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

   231 	    }

   232 	

   233 	// Read resource identifier

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

   235 	    {

   236 	    temp.Copy ( string );

   237 	    temp.Append ( '\0' );

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

   239 	    if ( !connect_data->resource )

   240 	        {

   241 	    	free_data ( connect_data );

   242 	    	return RC_ERROR;

   243 	        }

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

   245 	    }

   246 	 

   247 

   248 	// Read proxy server and proxy port

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

   250     	{

   251     	temp.Copy ( string );

   252     	temp.Append ( '\0' );

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

   254     	if ( !proxy_data->proxy_server )

   255     		{

   256     		free_data ( connect_data );

   257     		return RC_ERROR;

   258     		}

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

   260     	}

   261     	

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

   263     	{

   264     	temp.Copy ( string );

   265     	temp.Append ( '\0' );

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

   267     	if ( !proxy_data->proxy_port )

   268     		{

   269     		free_data ( connect_data );

   270     		return RC_ERROR;

   271     		}

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

   273     	}

   274     	

   275     	

   276     	

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

   278     		{

   279     		proxy_data->proxy_port = proxy_port;

   280     		}  */  	

   281  

   282 

   283 	// Read POrt address

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

   285 	    {

   286 	    temp.Copy ( string );

   287 	    temp.Append ( '\0' );

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

   289 	    if ( !connect_data->port )

   290 	        {

   291 	    	free_data ( connect_data );

   292 	    	return RC_ERROR;

   293 	        }

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

   295 	    }

   296   

   297   // read Add member

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

   299 	    {

   300 		temp.Copy ( string );

   301 		temp.Append ( '\0' );

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

   303 		if ( !connect_data->contact )

   304 		    {			

   305 			free_data ( connect_data );

   306 			return RC_ERROR;

   307 		    }

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

   309 	    }

   310   

   311    	// read CONNMGR_BUS

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

   313 	    {

   314 		temp.Copy ( string );

   315 		temp.Append ( '\0' );

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

   317 		if ( !connect_data->connmgr_bus )

   318 		    {			

   319 			free_data ( connect_data );

   320 			return RC_ERROR;

   321 		    }

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

   323 	    }

   324 	

   325 	// read CONNMGR_PATH

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

   327 	    {

   328 		temp.Copy ( string );

   329 		temp.Append ( '\0' );

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

   331 		if ( !connect_data->connmgr_path )

   332 		    {			

   333 			free_data ( connect_data );

   334 			return RC_ERROR;

   335 		    }

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

   337 	    }

   338 	    

   339 	// read PROTOCOL

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

   341 	    {

   342 		temp.Copy ( string );

   343 		temp.Append ( '\0' );

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

   345 		if ( !connect_data->protocol )

   346 		    {			

   347 			free_data ( connect_data );

   348 			return RC_ERROR;

   349 		    }

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

   351 	    }	 

   352 	        

   353     

   354 	    // read given Name

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

   356 	    {

   357 		temp.Copy ( string );

   358 		temp.Append ( '\0' );

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

   360 		if ( !connect_data->key_given_name )

   361 		    {			

   362 			free_data ( connect_data );

   363 			return RC_ERROR;

   364 		    }

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

   366 	    }	 

   367 	    

   368 	    // read middle Name

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

   370 	    {

   371 		temp.Copy ( string );

   372 		temp.Append ( '\0' );

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

   374 		if ( !connect_data->key_middle_name )

   375 		    {			

   376 			free_data ( connect_data );

   377 			return RC_ERROR;

   378 		    }

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

   380 	    }	 

   381 	    

   382 	    // read email Name

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

   384 	    {

   385 		temp.Copy ( string );

   386 		temp.Append ( '\0' );

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

   388 		if ( !connect_data->key_jid )

   389 		    {			

   390 			free_data ( connect_data );

   391 			return RC_ERROR;

   392 		    }

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

   394 	    }	 

   395 	    

   396 	    // read full Name

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

   398 	    {

   399 		temp.Copy ( string );

   400 		temp.Append ( '\0' );

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

   402 		if ( !connect_data->key_full_name )

   403 		    {			

   404 			free_data ( connect_data );

   405 			return RC_ERROR;

   406 		    }

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

   408 	    }	 

   409        // read mimetype

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

   411            {

   412            temp.Copy ( string );

   413            temp.Append ( '\0' );

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

   415            if ( !connect_data->mimetype )

   416                {           

   417                free_data ( connect_data );

   418                return RC_ERROR;

   419                }

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

   421            }    

   422        // read image filename

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

   424            {

   425            temp.Copy ( string );

   426            temp.Append ( '\0' );

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

   428            if ( !connect_data->image_file_name )

   429                {           

   430                free_data ( connect_data );

   431                return RC_ERROR;

   432                }

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

   434            }          

   435 	return RC_OK;

   436     }

   437 

   438 

   439 //-----------------------------------------------------------------------------

   440 // function_name	: free_data

   441 // description     	: Deallocates all the data

   442 // Returns          : None

   443 //-----------------------------------------------------------------------------

   444 //

   445 static void

   446 free_data ( ConnectData*& connect_data )

   447     {

   448 	if ( connect_data )

   449 	    {

   450 		if ( connect_data->server )

   451 		    {

   452 			g_free ( connect_data->server );

   453 			connect_data->server = NULL;

   454 		    }

   455 		

   456 		if ( connect_data->username )

   457 		    {

   458 			g_free ( connect_data->username );

   459 			connect_data->username = NULL;

   460 		    }

   461 		

   462 		if ( connect_data->password )

   463 		    {

   464 			g_free ( connect_data->password );

   465 			connect_data->password = NULL;

   466 		    }

   467 		

   468 		if ( connect_data->msg_data )

   469 		    {

   470 			if ( connect_data->msg_data->recipient )

   471 			    {

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

   473 				connect_data->msg_data->recipient = NULL;

   474 			    }

   475 			if ( connect_data->msg_data->message )

   476 			    {

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

   478 				connect_data->msg_data->message = NULL;

   479 			    }

   480 			g_free ( connect_data->msg_data );

   481 			connect_data->msg_data = NULL;

   482 		    }		

   483 		

   484 		if ( connect_data->resource )

   485 		    {

   486 			g_free ( connect_data->resource );

   487 			connect_data->resource = NULL;

   488 		    }

   489 		    

   490 

   491 	    if ( connect_data->proxy_data )

   492 	    	{

   493 	    	if ( connect_data->proxy_data->proxy_server )

   494 	    		{

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

   496 	    		connect_data->proxy_data->proxy_server = NULL;

   497 	    		}

   498 	    	g_free ( connect_data->proxy_data );

   499 	    	connect_data->proxy_data = NULL;	

   500 	    	}

   501 	  

   502 	    if ( connect_data->port )

   503 		    {

   504 			g_free ( connect_data->port );

   505 			connect_data->port = NULL;

   506 		    }  

   507 		    

   508 		    

   509 		if ( connect_data->contact )

   510 		    {

   511 			g_free ( connect_data->contact );

   512 			connect_data->contact = NULL;

   513 		    }

   514 		    

   515 		if ( connect_data->key_given_name )

   516 		    {

   517 			g_free ( connect_data->key_given_name );

   518 			connect_data->key_given_name = NULL;

   519 		    }

   520 		    

   521 		if ( connect_data->key_middle_name )

   522 		    {

   523 			g_free ( connect_data->key_middle_name );

   524 			connect_data->key_middle_name = NULL;

   525 		    }

   526 		    

   527 		if ( connect_data->key_jid )

   528 		    {

   529 			g_free ( connect_data->key_jid );

   530 			connect_data->key_jid = NULL;

   531 		    }

   532 		    

   533 		if ( connect_data->key_full_name )

   534 		    {

   535 			g_free ( connect_data->key_full_name );

   536 			connect_data->key_full_name = NULL;

   537 		    }  

   538 		          

   539 		g_free ( connect_data );

   540 		connect_data = NULL;    

   541 	    }

   542     }

   543     

   544     //-----------------------------------------------------------------------------

   545 // function_name	: running isolation server exe

   546 // description     	: Deallocates all the data

   547 // Returns          : None

   548 //-----------------------------------------------------------------------------

   549   int  run_isoserver()

   550   {

   551   	// running isoserver 

   552     RProcess isosrv_launcher;

   553     TInt lunch_err = 0;

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

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

   556      if ( KErrNone != lunch_err ) 

   557 	    {

   558 		return KErrGeneral;

   559 	    	

   560 	    }

   561 	isosrv_launcher.Resume();

   562 	return KErrNone;

   563   }

   564 

   565 // -----------------------------------------------------------------------------

   566 // ?function_name ?description.

   567 // ?description

   568 // Returns: ?value_1: ?description

   569 //          ?value_n: ?description_line1

   570 //                    ?description_line2

   571 // -----------------------------------------------------------------------------

   572 //

   573 /*

   574 ?type ?function_name(

   575     ?arg_type arg,  // ?description

   576     ?arg_type arg)  // ?description

   577     {

   578 

   579     ?code  // ?comment

   580 

   581     // ?comment

   582     ?code

   583     }

   584 */

   585 

   586 // ============================ MEMBER FUNCTIONS ===============================

   587 

   588 // -----------------------------------------------------------------------------

   589 // Cisolationserver::Delete

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

   591 // Called from destructor. 

   592 // -----------------------------------------------------------------------------

   593 //

   594 void Cisolationserver::Delete() 

   595     {

   596 

   597     }

   598 

   599 // -----------------------------------------------------------------------------

   600 // Cisolationserver::RunMethodL

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

   602 // -----------------------------------------------------------------------------

   603 //

   604 TInt Cisolationserver::RunMethodL( 

   605     CStifItemParser& aItem ) 

   606     {

   607 

   608     static TStifFunctionInfo const KFunctions[] =

   609         {  

   610         

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   687         //ADD NEW ENTRY HERE

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

   689 

   690         };

   691 

   692     const TInt count = sizeof( KFunctions ) / 

   693                         sizeof( TStifFunctionInfo );

   694 

   695     return RunInternalL( KFunctions, count, aItem );

   696 

   697     }

   698     

   699    // -----------------------------------------------------------------------------

   700 // Cisolationserver::Login with correct data

   701 // Example test method function.

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

   703 // -----------------------------------------------------------------------------

   704 //

   705 TInt Cisolationserver::LoginWithCorrectdata( CStifItemParser& aItem )

   706     {

   707   	

   708     ConnectData  *connect_data = NULL;

   709     char smsg[MAX_MSG_SIZE];

   710     char rmsg[MAX_MSG_SIZE];

   711     int index=0;

   712 

   713 	FILE *fp;	

   714 	int timeout = 100;

   715 	int nBytes;

   716     int result = 0;

   717     int err = 0;

   718     int status = 0;

   719     message_hdr_req *msgHdr = NULL;  

   720     message_hdr_resp* msg_struct = NULL;

   721     TInt return_value = 0;

   722         	// Read data from the CFG file

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

   724 		{

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

   726 		free_data ( connect_data );

   727 		return_value = KErrGeneral;

   728 		goto return_code;

   729 		}

   730 	//request formation	

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

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

   733 	//message header use

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

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

   736     msgHdr->message_type = ELogin_Request;

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

   738     index += sizeof( message_hdr_req );

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

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

   741     index += len + 1;

   742     //appending password

   743     len = strlen(connect_data->password );

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

   745     index += len + 1;

   746     //appending server name

   747     len = strlen(connect_data->server );

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

   749     index += len + 1;

   750     //appending resource

   751     len = strlen(connect_data->resource );

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

   753     index += len + 1;

   754     //appending ssl

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

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

   757     //appending server port

   758     len = strlen(connect_data->port );

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

   760     index += len + 1;

   761     // appending IAP id

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

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

   764     //appending connmgr_bus

   765     len = strlen(connect_data->connmgr_bus );

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

   767     index += len + 1;

   768     //appending connmgr_path

   769     len = strlen(connect_data->connmgr_path );

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

   771     index += len + 1;

   772     //appending protocol

   773     len = strlen(connect_data->protocol );

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

   775     index += len + 1;

   776     #ifdef __WINSCW__

   777     //proxy server

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

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

   780     index += len + 1;

   781     //proxy port

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

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

   784     index += len + 1;

   785     #endif

   786      //running isoserver   

   787     run_isoserver(); 

   788     //create message queue for send request

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

   790     //create message queue for response request

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

   792     /* Send Message to queueOne */

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

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

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

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

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

   798     if (status < 0)

   799     {

   800     return_value = KErrGeneral;

   801 	goto return_code;	

   802     }

   803    	if( msg_struct->response != 1)

   804     {

   805     return_value = KErrGeneral;

   806 	goto return_code;

   807     }

   808      // login end

   809     //fetch req..

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

   811     {

   812         

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

   814 	do  {

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

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

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

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

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

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

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

   822 	fclose(fp);	

   823 	

   824     }

   825 

   826 	//fetch end

   827     

   828     // logout test code from server

   829     index=0;

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

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

   832 	

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

   834     

   835     msgHdr->message_type = ELogout_Request;

   836  

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

   838     index += sizeof( message_hdr_req );

   839 

   840 	

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

   842     

   843     do  {

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

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

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

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

   848    

   849     if ( msg_struct->response != 1)

   850     {

   851     return_value = KErrGeneral;

   852 	goto return_code;

   853     }

   854     return_value = KErrNone;

   855 	goto return_code;

   856     //killing isoserver

   857     return_code:

   858     index=0;

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

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

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

   862     msgHdr->message_type = EKill_Process;

   863  

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

   865     index += sizeof( message_hdr_req );

   866 

   867 	

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

   869     free( msg_struct );

   870     return return_value;

   871 

   872     }

   873 

   874 

   875   // -----------------------------------------------------------------------------

   876 // Cisolationserver::Logout from server

   877 // Example test method function.

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

   879 // -----------------------------------------------------------------------------

   880 //

   881 TInt Cisolationserver::LogoutFromServer( CStifItemParser& aItem )

   882     {

   883   	ConnectData  *connect_data = NULL;

   884     char smsg[MAX_MSG_SIZE];

   885     char rmsg[MAX_MSG_SIZE];

   886     int index=0;

   887 

   888 	FILE *fp;	

   889 	int timeout = 100;

   890 	int nBytes;

   891     int result = 0;

   892     int err = 0;

   893     int status = 0;

   894     message_hdr_req *msgHdr = NULL;  

   895     message_hdr_resp* msg_struct = NULL;

   896     TInt return_value = 0;

   897         	// Read data from the CFG file

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

   899 		{

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

   901 		free_data ( connect_data );

   902 		return_value = KErrGeneral;

   903 		goto return_code;

   904 		}

   905 	//request formation	

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

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

   908 	//message header use

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

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

   911     msgHdr->message_type = ELogin_Request;

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

   913     index += sizeof( message_hdr_req );

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

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

   916     index += len + 1;

   917     //appending password

   918     len = strlen(connect_data->password );

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

   920     index += len + 1;

   921     //appending server name

   922     len = strlen(connect_data->server );

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

   924     index += len + 1;

   925     //appending resource

   926     len = strlen(connect_data->resource );

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

   928     index += len + 1;

   929     //appending ssl

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

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

   932     //appending server port

   933     len = strlen(connect_data->port );

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

   935     index += len + 1;

   936     // appending IAP id

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

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

   939     //appending connmgr_bus

   940     len = strlen(connect_data->connmgr_bus );

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

   942     index += len + 1;

   943     //appending connmgr_path

   944     len = strlen(connect_data->connmgr_path );

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

   946     index += len + 1;

   947     //appending protocol

   948     len = strlen(connect_data->protocol );

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

   950     index += len + 1;

   951     #ifdef __WINSCW__

   952     //proxy server

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

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

   955     index += len + 1;

   956     //proxy port

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

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

   959     index += len + 1;

   960     #endif

   961      //running isoserver   

   962     run_isoserver(); 

   963     //create message queue for send request

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

   965     //create message queue for response request

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

   967     /* Send Message to queueOne */

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

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

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

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

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

   973     if (status < 0)

   974     {

   975     return_value = KErrGeneral;

   976 	goto return_code;	

   977     }

   978    	if( msg_struct->response != 1)

   979     {

   980     return_value = KErrGeneral;

   981 	goto return_code;

   982     }

   983      // login end

   984     //fetch req..

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

   986     {

   987         

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

   989 	do  {

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

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

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

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

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

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

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

   997 	fclose(fp);	

   998 	

   999     }

  1000 

  1001 	//fetch end

  1002     

  1003     // logout test code from server

  1004     index=0;

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

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

  1007 	

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

  1009     

  1010     msgHdr->message_type = ELogout_Request;

  1011  

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

  1013     index += sizeof( message_hdr_req );

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

  1015     

  1016     do  {

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

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

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

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

  1021    

  1022     if ( msg_struct->response != 1)

  1023     {

  1024     return_value = KErrGeneral;

  1025 	goto return_code;

  1026     }

  1027     return_value = KErrNone;

  1028 	goto return_code;

  1029     //killing isoserver

  1030     return_code:

  1031     index=0;

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

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

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

  1035     msgHdr->message_type = EKill_Process;

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

  1037     index += sizeof( message_hdr_req );

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

  1039     free( msg_struct );

  1040     return return_value;

  1041 

  1042     }

  1043 

  1044   // -----------------------------------------------------------------------------

  1045 // Cisolationserver::Login with mixed letter user

  1046 // Example test method function.

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

  1048 // -----------------------------------------------------------------------------

  1049 //

  1050 TInt Cisolationserver::LoginWithMixedletterUserId( CStifItemParser& aItem )

  1051     {

  1052   	

  1053     ConnectData  *connect_data = NULL;

  1054     char smsg[MAX_MSG_SIZE];

  1055     char rmsg[MAX_MSG_SIZE];

  1056     int index=0;

  1057 

  1058 	FILE *fp;	

  1059 	int timeout = 100;

  1060 	int nBytes;

  1061     int result = 0;

  1062     int err = 0;

  1063     int status = 0;

  1064     message_hdr_req *msgHdr = NULL;  

  1065     message_hdr_resp* msg_struct = NULL;

  1066     TInt return_value = 0;

  1067         	// Read data from the CFG file

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

  1069 		{

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

  1071 		free_data ( connect_data );

  1072 		return_value = KErrGeneral;

  1073 		goto return_code;

  1074 		}

  1075 	//request formation	

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

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

  1078 	//message header use

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

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

  1081     msgHdr->message_type = ELogin_Request;

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

  1083     index += sizeof( message_hdr_req );

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

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

  1086     index += len + 1;

  1087     //appending password

  1088     len = strlen(connect_data->password );

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

  1090     index += len + 1;

  1091     //appending server name

  1092     len = strlen(connect_data->server );

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

  1094     index += len + 1;

  1095     //appending resource

  1096     len = strlen(connect_data->resource );

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

  1098     index += len + 1;

  1099     //appending ssl

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

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

  1102     //appending server port

  1103     len = strlen(connect_data->port );

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

  1105     index += len + 1;

  1106     // appending IAP id

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

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

  1109     //appending connmgr_bus

  1110     len = strlen(connect_data->connmgr_bus );

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

  1112     index += len + 1;

  1113     //appending connmgr_path

  1114     len = strlen(connect_data->connmgr_path );

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

  1116     index += len + 1;

  1117     //appending protocol

  1118     len = strlen(connect_data->protocol );

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

  1120     index += len + 1;

  1121     #ifdef __WINSCW__

  1122     //proxy server

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

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

  1125     index += len + 1;

  1126     //proxy port

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

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

  1129     index += len + 1;

  1130     #endif

  1131      //running isoserver   

  1132     run_isoserver(); 

  1133     //create message queue for send request

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