1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file EsockTestBase.cpp

    18 */

    19 

    20 #include <e32debug.h>

    21 #include "EsockTestBase.h"

    22 #include <e32std.h>

    23 #include <commdbconnpref.h>

    24 #include <cs_subconevents.h>

    25 #include <es_prot.h>

    26 #include <comms-infras/esock_params.h>

    27 #include <dummynif_params.h>

    28 

    29 #include <comms-infras/es_parameterbundle.h>

    30 #include <comms-infras/provinfoqueryset.h>

    31 #include "ConnectionServer.TestSteps.h"

    32 

    33 #include <dummynifvar.h>

    34 

    35 

    36 #ifdef _DEBUG

    37 // Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

    38 // (if it could happen through user error then you should give it an explicit, documented, category + code)

    39 _LIT(KSpecAssert_ESockTestEsckTst, "ESockTestEsckTst");

    40 #endif

    41 

    42 static const TInt KProtocolInetDummy = 253;

    43 

    44 // Temporary measure to configure the rconnserv stuff before its backported to 9.4

    45 

    46 using namespace ConnectionServ;

    47 

    48 

    49 namespace ConnectionServ

    50 {

    51 	class RConnectionServ;

    52 	class CConnectionServParameterBundle;

    53 }

    54 

    55 class CConnServStatusQuery : public CActive

    56 	{

    57 public:

    58 	CConnServStatusQuery(ConnectionServ::RConnectionServ* aConnServ);

    59 	static CConnServStatusQuery* NewLC(	ConnectionServ::RConnectionServ* aConnServ,

    60 							const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

    61 							ConnectionServ::CConnectionServParameterBundle& aStatusBundle);

    62 	void ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

    63 					ConnectionServ::CConnectionServParameterBundle& aStatusBundle);

    64 	void RunL();

    65 	void DoCancel();

    66 

    67 	TInt ErrCode() const { return iStatus.Int(); }

    68 

    69 public:	

    70 	ConnectionServ::RConnectionServ* iConnServ;

    71 	};

    72 

    73 

    74 CConnServStatusQuery::CConnServStatusQuery(RConnectionServ* aConnServ)

    75 	: CActive(0), iConnServ(aConnServ)

    76 		{

    77 		}

    78 

    79 CConnServStatusQuery* CConnServStatusQuery::NewLC(	ConnectionServ::RConnectionServ* aConnServ,

    80 									const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

    81 									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)

    82 	{

    83 	CConnServStatusQuery* inst = new CConnServStatusQuery(aConnServ);

    84 	CleanupStack::PushL(inst);

    85 	inst->ConstructL(aQueryBundle, aStatusBundle);

    86 	return inst;

    87 	}

    88 

    89 void CConnServStatusQuery::ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

    90 									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)

    91 	{

    92 	iConnServ->AccessPointStatusQuery(aQueryBundle, aStatusBundle, iStatus );

    93 

    94 	// add self to scheduler

    95 	CActiveScheduler::Add(this);

    96 	SetActive();

    97 	}

    98 	

    99 

   100 void CConnServStatusQuery::RunL()

   101 	{

   102 	CActiveScheduler::Current()->Stop();

   103 	}

   104 

   105 void CConnServStatusQuery::DoCancel()

   106 	{

   107 	iConnServ->CancelAccessPointStatusQuery();

   108 	}

   109 	

   110 	

   111 

   112 //

   113 // TMigrateToPreferredCarrierParams - container for parameters for accepting a 

   114 // move for mobility

   115 //

   116 

   117 void TMigrateToPreferredCarrierParams::Reset()

   118 	{

   119 	iName.Set(KNullDesC);

   120 	iMobilityApiName.Set(KNullDesC);

   121 	}

   122 

   123 

   124 //

   125 // TCompareIntegersParams - parameters for comparing to saved integer values

   126 //

   127 void TCompareIntegersParams::Reset()

   128 	{

   129 	iValue1.Set(KNullDesC);

   130 	iValue2.Set(KNullDesC);

   131     iDifference = 0;

   132 	}

   133 

   134 //

   135 //TSocketDataCheckParams - container for parameters for checking data on a socket

   136 void TSocketDataCheckParams::Reset()

   137 	{

   138 	iSocketCheckName.Set(KNullDesC);

   139     iSocketName.Set(KNullDesC);

   140     iTransformType = ETransformDataNone;

   141     iErrorExpected = EFalse;

   142 	}

   143 	

   144 //

   145 //TSocketServerNumProtocolsParams - container for parameters for checking the number of procotols on a socket server instance

   146 

   147 void TSocketServerNumProtocolsParams::Reset()

   148 	{

   149 	iSocketServName.Set(KNullDesC);

   150 	iNumberExpected = 0;

   151 	iSavedAsName.Set(KNullDesC);

   152 	iExpected = EFalse;

   153 	iToBeSaved = EFalse;

   154 	}

   155 

   156 void TSocketServStartStopProtocolParams::Reset()

   157 	{

   158 	iSocketServName.Set(KNullDesC);

   159 	iAddrFamily = 0;

   160 	iProtocol = 0;

   161 	iSockType = 0;

   162 	}

   163 

   164 //

   165 //TRSocketParams - container for parameters (from an .ini file)

   166 //needed for operations on a sockets

   167 

   168 void TRSocketParams::Reset()

   169     {

   170     iSockServName.Set(KNullDesC);

   171     iConnectionName.Set(KNullDesC);

   172     iSocketName.Set(KNullDesC);

   173     iSubconnectionName.Set(KNullDesC);

   174 

   175     iSocketType = 0;

   176    	iProtocol = 0;

   177 	iPacketSize = 0;

   178 	iNrOfPackets = 0;

   179 	iLocalIP.FillZ();

   180    	iRemoteIP.FillZ();

   181    	iShutdownType = (RSocket::TShutdown)0;

   182 

   183     // Payload colouring

   184     iPayloadColouringIsEnabled = EFalse;

   185     iPayloadColour = 0;

   186     }

   187 

   188 void TRSocketGetOptParams::Reset()

   189 	{

   190     iSocketName.Set(KNullDesC);

   191 	iOptionName = 0;

   192 	iOptionLevel = 0;

   193 	iExpectedOptionOutputText.Set(KNullDesC);

   194 	iTextExpected = EFalse;

   195 	iValueExpected = EFalse;

   196 	}

   197 

   198 void TRSocketIoctlParams::Reset()

   199 	{

   200     iSocketName.Set(KNullDesC);

   201 	iIoctlCommand = 0;

   202 	iIoctlLevel = 0;

   203 	iExpectedIoctlOutput.Set(KNullDesC);

   204 	}

   205 

   206 TProtocolDescriptionParams::TProtocolDescriptionParams()

   207 	{

   208 	Mem::FillZ(this, sizeof(this));

   209 	}

   210 

   211 void TProtocolDescriptionParams::Reset()

   212 	{

   213 	iValuesGiven.Reset();

   214 	}

   215 

   216 void TProtocolDescriptionParams::TProtocolDescParamsExpected::Reset()

   217 	{

   218 	iName = EFalse;

   219 	iAddrFamily = EFalse;

   220 	iProtocol = EFalse;

   221 	iSockType = EFalse;

   222 	iVersion = EFalse;

   223 	iByteOrder = EFalse;

   224 	iServiceInfo = EFalse;

   225 	iNamingServices = EFalse;

   226 	iSecurity = EFalse;

   227 	iMessageSize = EFalse;

   228 	}

   229 

   230 TBool TProtocolDescriptionParams::MatchesExpected(TProtocolDesc& aProtocolDescription)

   231 	{

   232 	TBool verdict = ETrue;

   233 	

   234 	// Default to pass and then just need to find a single one that does not match

   235 	if(iValuesGiven.iName && (iValues.iName != aProtocolDescription.iName)) verdict = EFalse;

   236 	if(iValuesGiven.iAddrFamily && (iValues.iAddrFamily != aProtocolDescription.iAddrFamily)) verdict = EFalse;

   237 	if(iValuesGiven.iProtocol && (iValues.iProtocol != aProtocolDescription.iProtocol)) verdict = EFalse;

   238 	if(iValuesGiven.iSockType && (iValues.iSockType != aProtocolDescription.iSockType)) verdict = EFalse;

   239 	if(iValuesGiven.iVersion &&

   240 		(

   241 			iValues.iVersion.iMajor != aProtocolDescription.iVersion.iMajor ||

   242 			iValues.iVersion.iMinor != aProtocolDescription.iVersion.iMinor ||

   243 			iValues.iVersion.iBuild != aProtocolDescription.iVersion.iBuild

   244 		))

   245 		verdict = EFalse;

   246 	if(iValuesGiven.iByteOrder && (iValues.iByteOrder != aProtocolDescription.iByteOrder)) verdict = EFalse;

   247 	if(iValuesGiven.iServiceInfo && (iValues.iServiceInfo != aProtocolDescription.iServiceInfo)) verdict = EFalse;

   248 	if(iValuesGiven.iNamingServices && (iValues.iNamingServices != aProtocolDescription.iNamingServices)) verdict = EFalse;

   249 	if(iValuesGiven.iSecurity && (iValues.iSecurity != aProtocolDescription.iSecurity)) verdict = EFalse;

   250 	if(iValuesGiven.iMessageSize && (iValues.iMessageSize != aProtocolDescription.iMessageSize)) verdict = EFalse;

   251 

   252 	return verdict;		

   253 	}

   254 

   255 _LIT(KName, "Name");

   256 _LIT(KAddrFamily, "AddrFamily");

   257 _LIT(KProtocol, "Protocol");

   258 _LIT(KSockType, "SockType");

   259 _LIT(KVersionMajor, "VersionMajor");

   260 _LIT(KVersionMinor, "VersionMinor");

   261 _LIT(KVersionBuild, "VersionBuild");

   262 _LIT(KByteOrder, "ByteOrder");

   263 _LIT(KServiceInfo, "ServiceInfo");

   264 _LIT(KNamingServices, "NamingServices");

   265 _LIT(KSecurity, "Security");

   266 _LIT(KMessageSize, "MessageSize");

   267 

   268 TInt TProtocolDescriptionParams::FetchDescription(TProtocolDescriptionParams& aParams, CTestStep& aTestStep)

   269 	{

   270     // Protocol name

   271     TPtrC name;

   272 	if (aTestStep.GetStringFromConfig(aTestStep.ConfigSection(), KName, name) == 1)

   273         {

   274 		aParams.iValues.iName.Copy(name);

   275 		aParams.iValuesGiven.iName = ETrue;

   276         }

   277 

   278 	// Address family

   279 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KAddrFamily, (TInt&)aParams.iValues.iAddrFamily) == 1)

   280         {

   281 		aParams.iValuesGiven.iAddrFamily = ETrue;

   282         }

   283 

   284 	// Protocol

   285 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KProtocol, (TInt&)aParams.iValues.iProtocol) == 1)

   286         {

   287 		aParams.iValuesGiven.iProtocol = ETrue;

   288         }

   289 

   290 	// Socket type

   291 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KSockType, (TInt&)aParams.iValues.iSockType) == 1)

   292         {

   293 		aParams.iValuesGiven.iSockType = ETrue;

   294         }

   295 

   296 	// Version

   297 	TInt versionMajor;

   298 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMajor, versionMajor) == 1)

   299         {

   300 		aParams.iValues.iVersion.iMajor = (TInt8)versionMajor;

   301 

   302 		TInt versionMinor;

   303 		if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMinor, versionMinor) == 1)

   304 			{

   305 			aParams.iValues.iVersion.iMinor = (TInt8)versionMinor;

   306 

   307 			TInt versionBuild;

   308 			if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionBuild, versionBuild) == 1)

   309 				{

   310 				aParams.iValues.iVersion.iBuild = (TInt16)versionBuild;

   311 

   312 				// Got all the version info

   313 				aParams.iValuesGiven.iVersion = ETrue;

   314 				}

   315 			}

   316         }

   317 

   318 	// Byte order

   319 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KByteOrder, (TInt&)aParams.iValues.iByteOrder) == 1)

   320         {

   321 		aParams.iValuesGiven.iByteOrder = ETrue;

   322         }

   323 

   324 	// Service info

   325 	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KServiceInfo, (TInt&)aParams.iValues.iServiceInfo) == 1)

   326         {

   327 		aParams.iValuesGiven.iServiceInfo = ETrue;

   328         }

   329 

   330 	// Naming services

   331 	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KNamingServices, (TInt&)aParams.iValues.iNamingServices) == 1)

   332         {

   333 		aParams.iValuesGiven.iNamingServices = ETrue;

   334         }

   335 

   336 	// Security

   337 	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KSecurity, (TInt&)aParams.iValues.iSecurity) == 1)

   338         {

   339 		aParams.iValuesGiven.iSecurity = ETrue;

   340         }

   341 

   342 	// Message size

   343 	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KMessageSize, (TInt&)aParams.iValues.iMessageSize) == 1)

   344         {

   345 		aParams.iValuesGiven.iMessageSize = ETrue;

   346         }

   347 

   348 	return aParams.iValuesGiven.AllExpected() ? KErrNone : KErrNotFound;

   349 	}

   350 

   351 TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::NoneExpected()

   352 	{

   353 	return (!iName && !iAddrFamily && !iProtocol && !iSockType && !iVersion && !iByteOrder && !iServiceInfo && !iNamingServices && !iSecurity && !iMessageSize) ?

   354 		ETrue :

   355 		EFalse;

   356 	}

   357 	

   358 TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::AllExpected()

   359 	{

   360 	return (iName && iAddrFamily && iProtocol && iSockType && iVersion && iByteOrder && iServiceInfo && iNamingServices && iSecurity && iMessageSize) ?

   361 		ETrue :

   362 		EFalse;

   363 	}

   364 

   365 void TSocketProtocolDescriptionParams::Reset()

   366 	{

   367 	iSocketName.Set(KNullDesC);

   368 	iProtocolDescParams.Reset();

   369 	}

   370 

   371 void TSocketServFindProtocolParams::Reset()

   372 	{

   373 	iSocketServName.Set(KNullDesC);

   374 	iProtocolDescParams.Reset();

   375 	}

   376 

   377 void TSocketServGetProtocolInfoParams::Reset()

   378 	{

   379 	iSocketServName.Set(KNullDesC);

   380 	iProtocolIndex = 0;

   381 	iProtocolDescParams.Reset();

   382 	}

   383 

   384 

   385 //

   386 //TRConnectionParams - container for parameters (from an .ini file)

   387 //needed for operations on a connections

   388 

   389 void TRConnectionParams::Reset()

   390     {

   391     iSockServName.Set(KNullDesC);

   392     iConnectionName.Set(KNullDesC);

   393     iAttachToConnectionName.Set(KNullDesC);

   394 

   395 	iBearer = 0;

   396 	iIAP = 0;

   397 	iNET = 0;

   398 	iSNAP = 0;

   399 

   400     iConnStopType = (RConnection::TConnStopType)0;

   401     iConnAttachType = (RConnection::TConnAttachType)0;

   402     iStartWithOldPreferences = 0;

   403     iStartWithSnapPreferences = 0;

   404     iAsynch = EFalse;

   405     }

   406 

   407 //

   408 //TRSubConnectionParams - container for parameters (from an .ini file)

   409 //needed for operations on a subconnections

   410 

   411 void TRSubConnectionParams::Reset()

   412     {

   413     iSockServName.Set(KNullDesC);

   414 	iConnectionName.Set(KNullDesC);

   415 	iSubConnectionName.Set(KNullDesC);

   416 	iSocketName.Set(KNullDesC);

   417 

   418 	iSubConnectionParamsName.Set(KNullDesC);

   419 	iSubConnectionEventName.Set(KNullDesC);

   420 

   421     iSubConnType = (RSubConnection::TSubConnType)0;

   422     }

   423 

   424 //

   425 //TEsockTestEventContainer - encapsulates all necessary RConnection

   426 //or RSubConnection event data so that it can be conveniently stored in a map.

   427 

   428 void TEventContainerParams::Reset()

   429     {

   430     iEventName.Set(KNullDesC);

   431 	iSubConnectionName.Set(KNullDesC);

   432 	iConnectionName.Set(KNullDesC);

   433 	iAvailabilityExtName.Set(KNullDesC);

   434 	iConnectionManagerExtName.Set(KNullDesC);

   435 	iExtensionName.Set(KNullDesC);

   436 	iMobilityExtName.Set(KNullDesC);

   437 	iAllEvents = EFalse;

   438 	iGenericEvents = EFalse;

   439 	iEventMask = 0;

   440 	iTimeoutMiliSecs = 0;

   441     }

   442 

   443 TEsockTestEventContainer::~TEsockTestEventContainer()

   444     {

   445     iEventNotifBuf.Zero();

   446     }

   447 

   448 //

   449 // TEsockTestDataMonitoringEventContainer - encapsulates all necessary data monitoring

   450 // event data so that it can be conveniently stored in a map.    

   451 

   452 void TDataMonitorEventParams::Reset()

   453 	{

   454 	iEventName.Copy(KNullDesC);

   455 	iConnectionName.Set(KNullDesC);

   456 	iSubConnectionName.Set(KNullDesC);

   457 	iDataMonitorName.Set(KNullDesC);

   458 	

   459 	iDelta = 0;

   460 	iMinExpectedVolume = 0;

   461 	}

   462 

   463 TPtrC& TDataMonitorEventParams::ConnOrSubConnName()

   464 	{

   465 	if(iConnectionName.Length() > 0)

   466 		{

   467 		return iConnectionName;

   468 		}

   469 	else 

   470 		{

   471 		// We return this regardless and consider the default KNullDesC

   472 		// to represent an error

   473 		return iSubConnectionName;

   474 		}

   475 	}

   476 

   477 //

   478 //TRSimtsyEventParams - container for parameters (from an .ini file)

   479 void TSimTsyEventParams::Reset()

   480     {

   481 

   482 	iConnectionName.Set(KNullDesC);

   483 	iSimTsyEventName.Set(KNullDesC);

   484 	iEventName.Set(KNullDesC);

   485 	iEventKey=0;

   486 	iEventIndex=0;

   487 

   488     }

   489 

   490 

   491 //

   492 //CCEsockTestBase

   493 

   494 CCEsockTestBase::~CCEsockTestBase()

   495 	{

   496 	CleanAll();

   497 	}

   498 

   499 //

   500 //socket server functions library

   501 

   502 TInt CCEsockTestBase::CreateSocketServer(const TDesC& aSockServName)

   503 	{

   504     //check if this secket server hasn't been created already

   505     if (iSockServs.Find(aSockServName)!=NULL)

   506     	return KErrAlreadyExists;

   507 

   508     RSocketServ* ss = new RSocketServ;

   509     if (ss==NULL)

   510     	return KErrNoMemory;

   511 

   512 	TInt error = iSockServs.Add(ss,aSockServName);

   513 	if (error!=KErrNone)

   514 		delete ss;

   515 

   516 

   517 	return error;

   518 	}

   519 

   520 TInt CCEsockTestBase::ConnectSocketServer(const TDesC& aSockServName)

   521 	{

   522     //check if this secket server hasn't been created already

   523     RSocketServ* ss = iSockServs.Find(aSockServName);

   524     if (ss==NULL)

   525     	return KErrNotFound;

   526 

   527 	return ss->Connect();

   528 	}

   529 

   530 TInt CCEsockTestBase::CloseSocketServer(const TDesC& aSockServName)

   531 	{

   532     //check if this secket server hasn't been created already

   533     RSocketServ* ss = iSockServs.Find(aSockServName);

   534     if (ss==NULL)

   535     	return KErrNotFound;

   536 

   537 	ss->Close();

   538 	return KErrNone;

   539 	}

   540 

   541 TInt CCEsockTestBase::SocketServerNumProtocols(TSocketServerNumProtocolsParams& aParams, TInt& aNumProtocols)

   542 	{

   543     // Fetch the socket server instance which must already exist

   544     RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);

   545     if (ss == NULL)

   546     	return KErrNotFound;

   547 

   548 	TInt error = ss->NumProtocols((TUint&)aNumProtocols);

   549 	if(error != KErrNone)

   550 		{

   551 		return error;

   552 		}

   553 	

   554 	if(aParams.iToBeSaved)

   555 		{

   556 		// If we are saving the value then do so

   557 		// If it exists already then update it

   558 		TInt* currentValue = NULL;

   559 		currentValue = iIntegerValues.Find(aParams.iSavedAsName);

   560 		if(currentValue != NULL)

   561 			{

   562 			*currentValue = aNumProtocols;

   563 			return KErrNone;

   564 			}

   565 

   566 		// Else create the new variable

   567 		currentValue = new TInt(aNumProtocols);

   568 		if (currentValue == NULL)

   569 			return KErrNoMemory;

   570 

   571 		error = iIntegerValues.Add(currentValue, aParams.iSavedAsName);

   572 		}

   573 

   574 	return error;

   575 	}

   576 

   577 TInt CCEsockTestBase::SocketServerFindProtocol(TSocketServFindProtocolParams& aParams, TProtocolDesc& aProtocolDescription)

   578 	{

   579     // Fetch the socket server instance which must already exist

   580     RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);

   581     if (ss == NULL)

   582     	return KErrNotFound;

   583 

   584 	return ss->FindProtocol(aParams.iProtocolDescParams.iValues.iName, aProtocolDescription);

   585 	}

   586 

   587 TInt CCEsockTestBase::SocketServerGetProtocolInfo(TSocketServGetProtocolInfoParams& aParams, TProtocolDesc& aProtocolDescription)

   588 	{

   589     // Fetch the socket server instance which must already exist

   590     RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);

   591     if (ss == NULL)

   592     	return KErrNotFound;

   593 

   594 	return ss->GetProtocolInfo(aParams.iProtocolIndex, aProtocolDescription);

   595 	}

   596 

   597 

   598 TInt CCEsockTestBase::SocketServerStartProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)

   599 	{

   600     // Fetch the socket server instance which must already exist

   601     RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);

   602     if (ss == NULL)

   603     	return KErrNotFound;

   604 

   605 	// Start the protocol

   606 	ss->StartProtocol(

   607 		aParams.iAddrFamily,

   608 		aParams.iSockType,

   609 		aParams.iProtocol,

   610 		aStatus);

   611 	return KErrNone;	

   612 	}

   613 

   614 

   615 TInt CCEsockTestBase::SocketServerStopProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)

   616 	{

   617     // Fetch the socket server instance which must already exist

   618     RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);

   619     if (ss == NULL)

   620     	return KErrNotFound;

   621 

   622 	// Stop the protocol

   623 	ss->StopProtocol(

   624 		aParams.iAddrFamily,

   625 		aParams.iSockType,

   626 		aParams.iProtocol,

   627 		aStatus);

   628 	return KErrNone;	

   629 	}

   630 

   631 

   632 TInt CCEsockTestBase::__DbgFailNext(const TDesC& aSockServName, TInt aCount)

   633 	{

   634 	RSocketServ* ss = iSockServs.Find(aSockServName);

   635     if (ss==NULL)

   636 		return KErrNotFound;

   637 

   638 	return ss->__DbgFailNext(aCount);

   639 	}	

   640 

   641 TBool CCEsockTestBase::__DbgCheckFailNext(const TDesC& aSockServName)

   642     {

   643 	RSocketServ* ss = iSockServs.Find(aSockServName);

   644     if (ss==NULL)

   645 		return KErrNotFound;

   646 

   647 	return ss->__DbgCheckFailNext();

   648     }

   649 

   650 

   651 //

   652 //connection server functions library

   653 TInt CCEsockTestBase::CreateConnectionServer(const TDesC& aConnectionServName)

   654 	{

   655     if (iConnectionServs.Find(aConnectionServName) != NULL)

   656     	return KErrAlreadyExists;

   657 

   658     RConnectionServ* connServ = new RConnectionServ;

   659     if (connServ == NULL)

   660     	return KErrNoMemory;

   661 

   662 	TInt error = iConnectionServs.Add(connServ, aConnectionServName);

   663 	if (error != KErrNone)

   664 		delete connServ;

   665 

   666 	return error;

   667 	}

   668 

   669 TInt CCEsockTestBase::ConnectConnectionServer(const TDesC& aConnectionServName, TUint aTierId)

   670 	{

   671     //check if this secket server hasn't been created already

   672     RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

   673     if (connServ == NULL)

   674     	return KErrNotFound;

   675 

   676 	return connServ->Connect(aTierId);

   677 	}

   678 

   679 TInt CCEsockTestBase::CloseConnectionServer(const TDesC& aConnectionServName)

   680 	{

   681     // Find the connection server we are referring to

   682     RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

   683     if (connServ == NULL)

   684     	return KErrNotFound;

   685 

   686 	connServ->Close();

   687 	return KErrNone;

   688 	}

   689 

   690 TInt CCEsockTestBase::ConnectionAccessPointStatusQuery(

   691 		const TDesC& aConnectionServName,

   692 		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

   693 		ConnectionServ::CConnectionServParameterBundle& aResultBundle)

   694 	{

   695 	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

   696 

   697 	if(connServ == NULL)

   698 		return KErrNotFound;

   699 		

   700 	// Need a local active scheduler for the RConnectionServ API

   701 	CActiveScheduler* as = new(ELeave) CActiveScheduler;

   702 	CleanupStack::PushL(as);

   703 	CActiveScheduler::Install(as);

   704 

   705 	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);

   706 

   707 	TRAP_IGNORE(CActiveScheduler::Start())

   708 

   709 	TInt res2 = sq->ErrCode();

   710 

   711 	CleanupStack::PopAndDestroy(sq);	

   712 	CleanupStack::PopAndDestroy(as);

   713 

   714 	return res2;

   715 	}

   716 

   717 class CMyTimer : public CTimer

   718 	{

   719 public:

   720 	static CMyTimer* NewL()

   721 		{

   722 		CMyTimer* timer = new CMyTimer();

   723 		if(timer)

   724 			{

   725 			timer->ConstructL();

   726 			CActiveScheduler::Add(timer);

   727 			}

   728 		return timer;

   729 		}

   730 		

   731 	CMyTimer() : CTimer(EPriorityStandard)

   732 		{

   733 		}

   734 	void RunL()

   735 		{

   736 		// Simply stop the scheduler as this will force the cancellation we are after

   737 		CActiveScheduler::Current()->Stop();		

   738 		}

   739 	};

   740 

   741 const TInt KHalfASecondInMicroSeconds = 500000;

   742 

   743 TInt CCEsockTestBase::CancelAccessPointStatusQuery(

   744 		const TDesC& aConnectionServName,

   745 		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,

   746 		ConnectionServ::CConnectionServParameterBundle& aResultBundle)

   747 	{

   748 	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);

   749 

   750 	if(connServ == NULL)

   751 		return KErrNotFound;

   752 		

   753 	// Need a local active scheduler for the RConnectionServ API

   754 	CActiveScheduler* as = new(ELeave) CActiveScheduler;

   755 	CleanupStack::PushL(as);

   756 	CActiveScheduler::Install(as);

   757 

   758 	// Create a timer that will complete almost immediately and stop the scheduler

   759 	// thereby canceling the query while it is in progress

   760 	// This all requires a long running query

   761 	CMyTimer* timer = CMyTimer::NewL();

   762 	CleanupStack::PushL(timer);

   763 	timer->After(KHalfASecondInMicroSeconds);

   764 	

   765 	// Create active object to manage the query

   766 	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);

   767 	

   768 	// Start the scheduler

   769 	TRAP_IGNORE(CActiveScheduler::Start())

   770 

   771 	sq->Cancel();

   772 	timer->Cancel();

   773 

   774 	// Check that the cancel status is what we expected

   775 	TInt res2 = sq->ErrCode();

   776 

   777 	CleanupStack::PopAndDestroy(sq);

   778 	CleanupStack::PopAndDestroy(timer);

   779 	CleanupStack::PopAndDestroy(as);

   780 	

   781 	return res2;

   782 	}

   783 

   784 

   785 //

   786 //socket functions library

   787 

   788 RSocket* CCEsockTestBase::FindSocket(const TDesC& aSocketName)

   789     {

   790     return iSocks.Find(aSocketName);

   791     }

   792 

   793 TInt CCEsockTestBase::CreateSocket(const TDesC& aSocketName)

   794 	{

   795     //check if this socket hasn't been created already

   796     if (iSocks.Find(aSocketName)!=NULL)

   797     	return KErrAlreadyExists;

   798 

   799     RSocket* s = new RSocket;

   800     if (s==NULL)

   801     	return KErrNoMemory;

   802 

   803 	TInt error = iSocks.Add(s,aSocketName);

   804 	if (error!=KErrNone)

   805 		delete s;

   806 

   807 	return error;

   808 	}

   809 

   810 TInt CCEsockTestBase::OpenSocket(const TRSocketParams& aParams)

   811 	{

   812     RSocketServ* ss = iSockServs.Find(aParams.iSockServName);

   813     if (ss==NULL)

   814 		return KErrNotFound;

   815 

   816     RSocket* s = iSocks.Find(aParams.iSocketName);

   817 	if (s==NULL)

   818 		return KErrNotFound;

   819 

   820     TInt error;

   821 

   822     //try to find the connection (if specified)

   823     if (aParams.iConnectionName.Length()>0)

   824     	{

   825 		RConnection* c = iConns.Find(aParams.iConnectionName);

   826 		if (c==NULL)

   827 			return KErrNotFound;

   828 		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *c);

   829 		}

   830 	else if (aParams.iSubconnectionName.Length()>0)

   831     	{

   832 		RSubConnection* sc = iSubConns.Find(aParams.iSubconnectionName);

   833 		if (sc==NULL)

   834 			{

   835 			return KErrNotFound;

   836 			}

   837 		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *sc);

   838 		}

   839 	else if (aParams.iProtocolName.Length()>0)

   840 		{

   841 		error = s->Open(*ss,aParams.iProtocolName);

   842 		}

   843 	else

   844 		{

   845 		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol);

   846 		}

   847 

   848 

   849 	return error;

   850 	}

   851 

   852 TInt CCEsockTestBase::BindSocket(const TRSocketParams& /*aParams*/)

   853 	{

   854     return KErrNotSupported;

   855     /*

   856     RSocket* s = iSocks.Find(aSockeSParams.iSocketName);

   857 	if (s==NULL)

   858 		return KErrNotFound;

   859 

   860 	TInt error = KErrNone;

   861 	if (aSockeSParams.iProtocol==KProtocolInetUdp)

   862 	    error = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);

   863 	if (error!=KErrNone)

   864 		return error;

   865 

   866 	//bind to Local address for TCP or UDP

   867 	return s->Bind(aSockeSParams.iLocalIP);

   868 	*/

   869 	}

   870 

   871 TInt CCEsockTestBase::ConnectSocket(TRSocketParams& aParams, TRequestStatus& aRequestStatus)

   872 	{

   873     RSocket* s = iSocks.Find(aParams.iSocketName);

   874 	if (s==NULL)

   875 	    {

   876 		return KErrNotFound;

   877 	    }

   878 

   879     TInt err = KErrNone;

   880 

   881     if (aParams.iProtocol==KProtocolInetUdp)

   882         {

   883         err = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);

   884         if (err != KErrNone)

   885             {

   886             return err;

   887             }

   888         }

   889 

   890     if (!aParams.iLocalIP.IsUnspecified() || !aParams.iLocalIP.IsWildPort())

   891         {

   892         err = s->Bind(aParams.iLocalIP);

   893         }

   894 

   895     if (err == KErrNone)

   896         {

   897         s->Connect(aParams.iRemoteIP, aRequestStatus);

   898         }

   899 

   900     return err;

   901 	}

   902 

   903 TInt CCEsockTestBase::CancelConnectSocket(const TRSocketParams& aParams)

   904 	{

   905     RSocket* s = iSocks.Find(aParams.iSocketName);

   906 	if (s==NULL)

   907 		return KErrNotFound;

   908 

   909     s->CancelConnect();

   910     return KErrNone;

   911 	}

   912 

   913 void CCEsockTestBase::SendAndReceiveDataL(const TRSocketParams& aParams)

   914 	{

   915     RSocket* s = iSocks.Find(aParams.iSocketName);

   916 	if (s==NULL)

   917 		User::Leave(KErrNotFound);

   918 

   919 	TInt recvCount = 0;

   920 	TRequestStatus stat;

   921 	TBuf8<50> Data;

   922 

   923 	//set up buffers

   924 	HBufC8* writebuf = HBufC8::NewMaxLC(aParams.iPacketSize);

   925 	HBufC8* readbuf  = HBufC8::NewMaxLC(aParams.iPacketSize);

   926 	

   927 	// In the case of armv5, HBufC8 MaxLength is set as 1504 or 1512

   928 	// To sort it out we use TPtr8(TUint8* ,MaxLenghth) constructor

   929 	// instead of using

   930 	// TPtr8 ptrwritebuf = writebuf->Des();

   931 	// TPtr8 ptrreadbuf = readbuf->Des();

   932 	TPtr8 ptrwritebuf(const_cast<TUint8*>(writebuf->Ptr()), aParams.iPacketSize);

   933 	TPtr8 ptrreadbuf(const_cast<TUint8*>(readbuf->Ptr()), aParams.iPacketSize);

   934 	

   935 	// NewMaxLC may give a max size bigger than specified. Make sure length and max length are in sync so that

   936 	// the Read will complete. For example, NewMaxLC(1500) may give back a buffer 1504 as the max size. if you Write

   937 	// then Read on that, it'll write the length (1500) but try to read the max length (1504). this'll never complete

   938 	// because we'll only get back as many bytes as we wrote the the echo server.

   939 	ptrwritebuf.SetLength(ptrwritebuf.MaxLength());

   940 	ptrreadbuf.SetLength(ptrreadbuf.MaxLength());

   941 

   942     if (aParams.iProtocol==KProtocolInetTcp)

   943         {

   944    		for (TInt i = 0; i < aParams.iNrOfPackets; i++)

   945     		{

   946 	    	// initialise data

   947 		    Data.Format(_L8("TCP-packet:%d helloworld"),i);

   948 		    ptrwritebuf.Repeat( Data );

   949 

   950 		    // write data

   951 		    s->Write(ptrwritebuf,stat);

   952 		    User::WaitForRequest(stat);

   953 		    User::LeaveIfError(stat.Int());

   954 

   955 		    // read data

   956 		    s->Read(ptrreadbuf, stat);

   957 		    User::WaitForRequest(stat);

   958 			User::LeaveIfError(stat.Int());

   959 

   960 		    // compare the data

   961 		    if (ptrwritebuf.Compare(ptrreadbuf) != 0)

   962 		    	User::Leave(KErrGeneral);

   963 

   964 		    recvCount+=ptrreadbuf.Length();

   965 	    	}

   966 		}

   967 	else if (aParams.iProtocol==KProtocolInetUdp || aParams.iProtocol == KProtocolInetDummy)

   968 		{

   969         for (TInt i = 0; i < aParams.iNrOfPackets; i++)

   970 		    {

   971 		    // initialise data

   972 		    Data.Format(_L8("UDP-packet:%d helloworld"),i);

   973 		    ptrwritebuf.Repeat( Data );

   974 

   975 		    // If we are colouring the payload then first prefix outgoing payload with command byte to tell the stack so

   976 		    if(aParams.iPayloadColouringIsEnabled)

   977 		    	{

   978 				ptrwritebuf[0] = 0xF9; // KColourDataByLinkTierAccessPointId; TODO_CDG

   979 				}

   980 		    

   981 		    // write data

   982 		    s->Send(ptrwritebuf, 0, stat);

   983 		    User::WaitForRequest(stat);

   984 		    User::LeaveIfError(stat.Int());

   985 

   986 		    // If the returned data will be coloured by the IP stack for test purposes

   987 		    // then we had better change what we compare it with

   988 		    if(aParams.iPayloadColouringIsEnabled)

   989 		    	{

   990 		    	ptrwritebuf[0] += static_cast<TUint8>(aParams.iPayloadColour);

   991 				}

   992 		    

   993 		    s->Recv(ptrreadbuf, 0, stat);

   994 		    User::WaitForRequest(stat);

   995 		    User::LeaveIfError(stat.Int());

   996 

   997 		    // compare the data

   998 		    if (ptrwritebuf.Compare(ptrreadbuf) != 0 )

   999 		    	User::Leave(KErrGeneral);

  1000 

  1001 		    recvCount += ptrreadbuf.Length();

  1002 		    }

  1003 		}

  1004 	else

  1005         User::Leave(KErrNotFound);

  1006 

  1007     CleanupStack::PopAndDestroy(2, writebuf);	//	writebuf and readbuf

  1008 

  1009 	// check the total received (95 per cent is allowable for us)

  1010 	if (recvCount*aParams.iPacketSize < (0.95*(aParams.iNrOfPackets*aParams.iPacketSize)))

  1011 		User::Leave(KErrGeneral);

  1012 	}

  1013 

  1014 TInt CCEsockTestBase::CloseSocket(const TDesC& aSocketName)

  1015 	{

  1016     RSocket* s = iSocks.Find(aSocketName);

  1017 	if (s==NULL)

  1018 		return KErrNotFound;

  1019 

  1020 	s->Close();

  1021     return KErrNone;

  1022 	}

  1023 

  1024 TInt CCEsockTestBase::ShutdownSocket(const TRSocketParams& aParams, TRequestStatus& aRequestStatus)

  1025 	{

  1026     RSocket* s = iSocks.Find(aParams.iSocketName);

  1027 	if (s==NULL)

  1028 		return KErrNotFound;

  1029 

  1030 	s->Shutdown(aParams.iShutdownType,aRequestStatus);

  1031     return KErrNone;

  1032 	}

  1033 

  1034 TInt CCEsockTestBase::IoctlSocket(const TRSocketIoctlParams& aParams, TDes8& aIoctlOutput, TRequestStatus& aRequestStatus)

  1035 	{

  1036     RSocket* s = iSocks.Find(aParams.iSocketName);

  1037 	if (s == NULL)

  1038 		return KErrNotFound;

  1039 

  1040 	s->Ioctl(aParams.iIoctlCommand, aRequestStatus, &aIoctlOutput, aParams.iIoctlLevel);

  1041 	User::WaitForRequest(aRequestStatus);

  1042 

  1043     return KErrNone;

  1044 	}

  1045 

  1046 TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TDes8& aGetOptOutput)

  1047 	{

  1048     RSocket* s = iSocks.Find(aParams.iSocketName);

  1049 	if (s == NULL)

  1050 		return KErrNotFound;

  1051 

  1052 	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);

  1053 	}

  1054 

  1055 TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TInt& aGetOptOutput)

  1056 	{

  1057     RSocket* s = iSocks.Find(aParams.iSocketName);

  1058 	if (s == NULL)

  1059 		return KErrNotFound;

  1060 

  1061 	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);

  1062 	}

  1063 

  1064 TInt CCEsockTestBase::ProtocolDescription(

  1065 	const TSocketProtocolDescriptionParams& aParams,

  1066 	TProtocolDesc& aProtocolDescriptionOutput)

  1067 	{

  1068     RSocket* s = iSocks.Find(aParams.iSocketName);

  1069 	if (s == NULL)

  1070 		return KErrNotFound;

  1071 

  1072 	return s->Info(aProtocolDescriptionOutput);

  1073 	}

  1074 

  1075 

  1076 //

  1077 //connection functions library

  1078 

  1079 RConnection* CCEsockTestBase::FindConnection(const TDesC& aConnectionName)

  1080     {

  1081     return iConns.Find(aConnectionName);

  1082     }

  1083 

  1084 TInt CCEsockTestBase::CreateConnection(const TDesC& aConnectionName)

  1085 	{

  1086     //check if this connection hasn't been created already

  1087     if (iConns.Find(aConnectionName)!=NULL)

  1088     	return KErrAlreadyExists;

  1089 

  1090     RConnection* c = new RConnection;

  1091     if (c==NULL)

  1092     	return KErrNoMemory;

  1093 

  1094 	TInt error = iConns.Add(c,aConnectionName);

  1095 	if (error!=KErrNone)

  1096 		delete c;

  1097 

  1098 	return error;

  1099 	}

  1100 

  1101 TInt CCEsockTestBase::OpenConnection(const TRConnectionParams& aParams)

  1102 	{

  1103     RSocketServ* ss = iSockServs.Find(aParams.iSockServName);

  1104     if (ss==NULL)

  1105 		return KErrNotFound;

  1106 

  1107     RConnection* c = iConns.Find(aParams.iConnectionName);

  1108 	if (c==NULL)

  1109 		return KErrNotFound;

  1110 

  1111 	if(aParams.iConnectionType != -1)

  1112 	   return c->Open(*ss,aParams.iConnectionType);

  1113 

  1114 	return c->Open(*ss);

  1115 	}

  1116 

  1117 TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams)

  1118 	{

  1119     RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);

  1120 	if (sc==NULL)

  1121 		return KErrNotFound;

  1122 

  1123 	RConnection* c = iConns.Find(aParams.iConnectionName);

  1124 	if (c==NULL)

  1125 		return KErrNotFound;

  1126 

  1127 	return c->WaitForIncoming(*sc);

  1128 	}

  1129 

  1130 TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams,TRequestStatus& reqStat)

  1131 	{

  1132     RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);

  1133 	if (sc==NULL)

  1134 		return KErrNotFound;