diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/TE_EsockTestSteps/src/EsockTestBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/test/TE_EsockTestSteps/src/EsockTestBase.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,2303 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +/** + @file EsockTestBase.cpp +*/ + +#include +#include "EsockTestBase.h" +#include +#include +#include +#include +#include +#include + +#include +#include +#include "ConnectionServer.TestSteps.h" + +#include + + +#ifdef _DEBUG +// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module +// (if it could happen through user error then you should give it an explicit, documented, category + code) +_LIT(KSpecAssert_ESockTestEsckTst, "ESockTestEsckTst"); +#endif + +static const TInt KProtocolInetDummy = 253; + +// Temporary measure to configure the rconnserv stuff before its backported to 9.4 + +using namespace ConnectionServ; + + +namespace ConnectionServ +{ + class RConnectionServ; + class CConnectionServParameterBundle; +} + +class CConnServStatusQuery : public CActive + { +public: + CConnServStatusQuery(ConnectionServ::RConnectionServ* aConnServ); + static CConnServStatusQuery* NewLC( ConnectionServ::RConnectionServ* aConnServ, + const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aStatusBundle); + void ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aStatusBundle); + void RunL(); + void DoCancel(); + + TInt ErrCode() const { return iStatus.Int(); } + +public: + ConnectionServ::RConnectionServ* iConnServ; + }; + + +CConnServStatusQuery::CConnServStatusQuery(RConnectionServ* aConnServ) + : CActive(0), iConnServ(aConnServ) + { + } + +CConnServStatusQuery* CConnServStatusQuery::NewLC( ConnectionServ::RConnectionServ* aConnServ, + const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aStatusBundle) + { + CConnServStatusQuery* inst = new CConnServStatusQuery(aConnServ); + CleanupStack::PushL(inst); + inst->ConstructL(aQueryBundle, aStatusBundle); + return inst; + } + +void CConnServStatusQuery::ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aStatusBundle) + { + iConnServ->AccessPointStatusQuery(aQueryBundle, aStatusBundle, iStatus ); + + // add self to scheduler + CActiveScheduler::Add(this); + SetActive(); + } + + +void CConnServStatusQuery::RunL() + { + CActiveScheduler::Current()->Stop(); + } + +void CConnServStatusQuery::DoCancel() + { + iConnServ->CancelAccessPointStatusQuery(); + } + + + +// +// TMigrateToPreferredCarrierParams - container for parameters for accepting a +// move for mobility +// + +void TMigrateToPreferredCarrierParams::Reset() + { + iName.Set(KNullDesC); + iMobilityApiName.Set(KNullDesC); + } + + +// +// TCompareIntegersParams - parameters for comparing to saved integer values +// +void TCompareIntegersParams::Reset() + { + iValue1.Set(KNullDesC); + iValue2.Set(KNullDesC); + iDifference = 0; + } + +// +//TSocketDataCheckParams - container for parameters for checking data on a socket +void TSocketDataCheckParams::Reset() + { + iSocketCheckName.Set(KNullDesC); + iSocketName.Set(KNullDesC); + iTransformType = ETransformDataNone; + iErrorExpected = EFalse; + } + +// +//TSocketServerNumProtocolsParams - container for parameters for checking the number of procotols on a socket server instance + +void TSocketServerNumProtocolsParams::Reset() + { + iSocketServName.Set(KNullDesC); + iNumberExpected = 0; + iSavedAsName.Set(KNullDesC); + iExpected = EFalse; + iToBeSaved = EFalse; + } + +void TSocketServStartStopProtocolParams::Reset() + { + iSocketServName.Set(KNullDesC); + iAddrFamily = 0; + iProtocol = 0; + iSockType = 0; + } + +// +//TRSocketParams - container for parameters (from an .ini file) +//needed for operations on a sockets + +void TRSocketParams::Reset() + { + iSockServName.Set(KNullDesC); + iConnectionName.Set(KNullDesC); + iSocketName.Set(KNullDesC); + iSubconnectionName.Set(KNullDesC); + + iSocketType = 0; + iProtocol = 0; + iPacketSize = 0; + iNrOfPackets = 0; + iLocalIP.FillZ(); + iRemoteIP.FillZ(); + iShutdownType = (RSocket::TShutdown)0; + + // Payload colouring + iPayloadColouringIsEnabled = EFalse; + iPayloadColour = 0; + } + +void TRSocketGetOptParams::Reset() + { + iSocketName.Set(KNullDesC); + iOptionName = 0; + iOptionLevel = 0; + iExpectedOptionOutputText.Set(KNullDesC); + iTextExpected = EFalse; + iValueExpected = EFalse; + } + +void TRSocketIoctlParams::Reset() + { + iSocketName.Set(KNullDesC); + iIoctlCommand = 0; + iIoctlLevel = 0; + iExpectedIoctlOutput.Set(KNullDesC); + } + +TProtocolDescriptionParams::TProtocolDescriptionParams() + { + Mem::FillZ(this, sizeof(this)); + } + +void TProtocolDescriptionParams::Reset() + { + iValuesGiven.Reset(); + } + +void TProtocolDescriptionParams::TProtocolDescParamsExpected::Reset() + { + iName = EFalse; + iAddrFamily = EFalse; + iProtocol = EFalse; + iSockType = EFalse; + iVersion = EFalse; + iByteOrder = EFalse; + iServiceInfo = EFalse; + iNamingServices = EFalse; + iSecurity = EFalse; + iMessageSize = EFalse; + } + +TBool TProtocolDescriptionParams::MatchesExpected(TProtocolDesc& aProtocolDescription) + { + TBool verdict = ETrue; + + // Default to pass and then just need to find a single one that does not match + if(iValuesGiven.iName && (iValues.iName != aProtocolDescription.iName)) verdict = EFalse; + if(iValuesGiven.iAddrFamily && (iValues.iAddrFamily != aProtocolDescription.iAddrFamily)) verdict = EFalse; + if(iValuesGiven.iProtocol && (iValues.iProtocol != aProtocolDescription.iProtocol)) verdict = EFalse; + if(iValuesGiven.iSockType && (iValues.iSockType != aProtocolDescription.iSockType)) verdict = EFalse; + if(iValuesGiven.iVersion && + ( + iValues.iVersion.iMajor != aProtocolDescription.iVersion.iMajor || + iValues.iVersion.iMinor != aProtocolDescription.iVersion.iMinor || + iValues.iVersion.iBuild != aProtocolDescription.iVersion.iBuild + )) + verdict = EFalse; + if(iValuesGiven.iByteOrder && (iValues.iByteOrder != aProtocolDescription.iByteOrder)) verdict = EFalse; + if(iValuesGiven.iServiceInfo && (iValues.iServiceInfo != aProtocolDescription.iServiceInfo)) verdict = EFalse; + if(iValuesGiven.iNamingServices && (iValues.iNamingServices != aProtocolDescription.iNamingServices)) verdict = EFalse; + if(iValuesGiven.iSecurity && (iValues.iSecurity != aProtocolDescription.iSecurity)) verdict = EFalse; + if(iValuesGiven.iMessageSize && (iValues.iMessageSize != aProtocolDescription.iMessageSize)) verdict = EFalse; + + return verdict; + } + +_LIT(KName, "Name"); +_LIT(KAddrFamily, "AddrFamily"); +_LIT(KProtocol, "Protocol"); +_LIT(KSockType, "SockType"); +_LIT(KVersionMajor, "VersionMajor"); +_LIT(KVersionMinor, "VersionMinor"); +_LIT(KVersionBuild, "VersionBuild"); +_LIT(KByteOrder, "ByteOrder"); +_LIT(KServiceInfo, "ServiceInfo"); +_LIT(KNamingServices, "NamingServices"); +_LIT(KSecurity, "Security"); +_LIT(KMessageSize, "MessageSize"); + +TInt TProtocolDescriptionParams::FetchDescription(TProtocolDescriptionParams& aParams, CTestStep& aTestStep) + { + // Protocol name + TPtrC name; + if (aTestStep.GetStringFromConfig(aTestStep.ConfigSection(), KName, name) == 1) + { + aParams.iValues.iName.Copy(name); + aParams.iValuesGiven.iName = ETrue; + } + + // Address family + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KAddrFamily, (TInt&)aParams.iValues.iAddrFamily) == 1) + { + aParams.iValuesGiven.iAddrFamily = ETrue; + } + + // Protocol + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KProtocol, (TInt&)aParams.iValues.iProtocol) == 1) + { + aParams.iValuesGiven.iProtocol = ETrue; + } + + // Socket type + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KSockType, (TInt&)aParams.iValues.iSockType) == 1) + { + aParams.iValuesGiven.iSockType = ETrue; + } + + // Version + TInt versionMajor; + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMajor, versionMajor) == 1) + { + aParams.iValues.iVersion.iMajor = (TInt8)versionMajor; + + TInt versionMinor; + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMinor, versionMinor) == 1) + { + aParams.iValues.iVersion.iMinor = (TInt8)versionMinor; + + TInt versionBuild; + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionBuild, versionBuild) == 1) + { + aParams.iValues.iVersion.iBuild = (TInt16)versionBuild; + + // Got all the version info + aParams.iValuesGiven.iVersion = ETrue; + } + } + } + + // Byte order + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KByteOrder, (TInt&)aParams.iValues.iByteOrder) == 1) + { + aParams.iValuesGiven.iByteOrder = ETrue; + } + + // Service info + if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KServiceInfo, (TInt&)aParams.iValues.iServiceInfo) == 1) + { + aParams.iValuesGiven.iServiceInfo = ETrue; + } + + // Naming services + if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KNamingServices, (TInt&)aParams.iValues.iNamingServices) == 1) + { + aParams.iValuesGiven.iNamingServices = ETrue; + } + + // Security + if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KSecurity, (TInt&)aParams.iValues.iSecurity) == 1) + { + aParams.iValuesGiven.iSecurity = ETrue; + } + + // Message size + if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KMessageSize, (TInt&)aParams.iValues.iMessageSize) == 1) + { + aParams.iValuesGiven.iMessageSize = ETrue; + } + + return aParams.iValuesGiven.AllExpected() ? KErrNone : KErrNotFound; + } + +TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::NoneExpected() + { + return (!iName && !iAddrFamily && !iProtocol && !iSockType && !iVersion && !iByteOrder && !iServiceInfo && !iNamingServices && !iSecurity && !iMessageSize) ? + ETrue : + EFalse; + } + +TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::AllExpected() + { + return (iName && iAddrFamily && iProtocol && iSockType && iVersion && iByteOrder && iServiceInfo && iNamingServices && iSecurity && iMessageSize) ? + ETrue : + EFalse; + } + +void TSocketProtocolDescriptionParams::Reset() + { + iSocketName.Set(KNullDesC); + iProtocolDescParams.Reset(); + } + +void TSocketServFindProtocolParams::Reset() + { + iSocketServName.Set(KNullDesC); + iProtocolDescParams.Reset(); + } + +void TSocketServGetProtocolInfoParams::Reset() + { + iSocketServName.Set(KNullDesC); + iProtocolIndex = 0; + iProtocolDescParams.Reset(); + } + + +// +//TRConnectionParams - container for parameters (from an .ini file) +//needed for operations on a connections + +void TRConnectionParams::Reset() + { + iSockServName.Set(KNullDesC); + iConnectionName.Set(KNullDesC); + iAttachToConnectionName.Set(KNullDesC); + + iBearer = 0; + iIAP = 0; + iNET = 0; + iSNAP = 0; + + iConnStopType = (RConnection::TConnStopType)0; + iConnAttachType = (RConnection::TConnAttachType)0; + iStartWithOldPreferences = 0; + iStartWithSnapPreferences = 0; + iAsynch = EFalse; + } + +// +//TRSubConnectionParams - container for parameters (from an .ini file) +//needed for operations on a subconnections + +void TRSubConnectionParams::Reset() + { + iSockServName.Set(KNullDesC); + iConnectionName.Set(KNullDesC); + iSubConnectionName.Set(KNullDesC); + iSocketName.Set(KNullDesC); + + iSubConnectionParamsName.Set(KNullDesC); + iSubConnectionEventName.Set(KNullDesC); + + iSubConnType = (RSubConnection::TSubConnType)0; + } + +// +//TEsockTestEventContainer - encapsulates all necessary RConnection +//or RSubConnection event data so that it can be conveniently stored in a map. + +void TEventContainerParams::Reset() + { + iEventName.Set(KNullDesC); + iSubConnectionName.Set(KNullDesC); + iConnectionName.Set(KNullDesC); + iAvailabilityExtName.Set(KNullDesC); + iConnectionManagerExtName.Set(KNullDesC); + iExtensionName.Set(KNullDesC); + iMobilityExtName.Set(KNullDesC); + iAllEvents = EFalse; + iGenericEvents = EFalse; + iEventMask = 0; + iTimeoutMiliSecs = 0; + } + +TEsockTestEventContainer::~TEsockTestEventContainer() + { + iEventNotifBuf.Zero(); + } + +// +// TEsockTestDataMonitoringEventContainer - encapsulates all necessary data monitoring +// event data so that it can be conveniently stored in a map. + +void TDataMonitorEventParams::Reset() + { + iEventName.Copy(KNullDesC); + iConnectionName.Set(KNullDesC); + iSubConnectionName.Set(KNullDesC); + iDataMonitorName.Set(KNullDesC); + + iDelta = 0; + iMinExpectedVolume = 0; + } + +TPtrC& TDataMonitorEventParams::ConnOrSubConnName() + { + if(iConnectionName.Length() > 0) + { + return iConnectionName; + } + else + { + // We return this regardless and consider the default KNullDesC + // to represent an error + return iSubConnectionName; + } + } + +// +//TRSimtsyEventParams - container for parameters (from an .ini file) +void TSimTsyEventParams::Reset() + { + + iConnectionName.Set(KNullDesC); + iSimTsyEventName.Set(KNullDesC); + iEventName.Set(KNullDesC); + iEventKey=0; + iEventIndex=0; + + } + + +// +//CCEsockTestBase + +CCEsockTestBase::~CCEsockTestBase() + { + CleanAll(); + } + +// +//socket server functions library + +TInt CCEsockTestBase::CreateSocketServer(const TDesC& aSockServName) + { + //check if this secket server hasn't been created already + if (iSockServs.Find(aSockServName)!=NULL) + return KErrAlreadyExists; + + RSocketServ* ss = new RSocketServ; + if (ss==NULL) + return KErrNoMemory; + + TInt error = iSockServs.Add(ss,aSockServName); + if (error!=KErrNone) + delete ss; + + + return error; + } + +TInt CCEsockTestBase::ConnectSocketServer(const TDesC& aSockServName) + { + //check if this secket server hasn't been created already + RSocketServ* ss = iSockServs.Find(aSockServName); + if (ss==NULL) + return KErrNotFound; + + return ss->Connect(); + } + +TInt CCEsockTestBase::CloseSocketServer(const TDesC& aSockServName) + { + //check if this secket server hasn't been created already + RSocketServ* ss = iSockServs.Find(aSockServName); + if (ss==NULL) + return KErrNotFound; + + ss->Close(); + return KErrNone; + } + +TInt CCEsockTestBase::SocketServerNumProtocols(TSocketServerNumProtocolsParams& aParams, TInt& aNumProtocols) + { + // Fetch the socket server instance which must already exist + RSocketServ* ss = iSockServs.Find(aParams.iSocketServName); + if (ss == NULL) + return KErrNotFound; + + TInt error = ss->NumProtocols((TUint&)aNumProtocols); + if(error != KErrNone) + { + return error; + } + + if(aParams.iToBeSaved) + { + // If we are saving the value then do so + // If it exists already then update it + TInt* currentValue = NULL; + currentValue = iIntegerValues.Find(aParams.iSavedAsName); + if(currentValue != NULL) + { + *currentValue = aNumProtocols; + return KErrNone; + } + + // Else create the new variable + currentValue = new TInt(aNumProtocols); + if (currentValue == NULL) + return KErrNoMemory; + + error = iIntegerValues.Add(currentValue, aParams.iSavedAsName); + } + + return error; + } + +TInt CCEsockTestBase::SocketServerFindProtocol(TSocketServFindProtocolParams& aParams, TProtocolDesc& aProtocolDescription) + { + // Fetch the socket server instance which must already exist + RSocketServ* ss = iSockServs.Find(aParams.iSocketServName); + if (ss == NULL) + return KErrNotFound; + + return ss->FindProtocol(aParams.iProtocolDescParams.iValues.iName, aProtocolDescription); + } + +TInt CCEsockTestBase::SocketServerGetProtocolInfo(TSocketServGetProtocolInfoParams& aParams, TProtocolDesc& aProtocolDescription) + { + // Fetch the socket server instance which must already exist + RSocketServ* ss = iSockServs.Find(aParams.iSocketServName); + if (ss == NULL) + return KErrNotFound; + + return ss->GetProtocolInfo(aParams.iProtocolIndex, aProtocolDescription); + } + + +TInt CCEsockTestBase::SocketServerStartProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus) + { + // Fetch the socket server instance which must already exist + RSocketServ* ss = iSockServs.Find(aParams.iSocketServName); + if (ss == NULL) + return KErrNotFound; + + // Start the protocol + ss->StartProtocol( + aParams.iAddrFamily, + aParams.iSockType, + aParams.iProtocol, + aStatus); + return KErrNone; + } + + +TInt CCEsockTestBase::SocketServerStopProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus) + { + // Fetch the socket server instance which must already exist + RSocketServ* ss = iSockServs.Find(aParams.iSocketServName); + if (ss == NULL) + return KErrNotFound; + + // Stop the protocol + ss->StopProtocol( + aParams.iAddrFamily, + aParams.iSockType, + aParams.iProtocol, + aStatus); + return KErrNone; + } + + +TInt CCEsockTestBase::__DbgFailNext(const TDesC& aSockServName, TInt aCount) + { + RSocketServ* ss = iSockServs.Find(aSockServName); + if (ss==NULL) + return KErrNotFound; + + return ss->__DbgFailNext(aCount); + } + +TBool CCEsockTestBase::__DbgCheckFailNext(const TDesC& aSockServName) + { + RSocketServ* ss = iSockServs.Find(aSockServName); + if (ss==NULL) + return KErrNotFound; + + return ss->__DbgCheckFailNext(); + } + + +// +//connection server functions library +TInt CCEsockTestBase::CreateConnectionServer(const TDesC& aConnectionServName) + { + if (iConnectionServs.Find(aConnectionServName) != NULL) + return KErrAlreadyExists; + + RConnectionServ* connServ = new RConnectionServ; + if (connServ == NULL) + return KErrNoMemory; + + TInt error = iConnectionServs.Add(connServ, aConnectionServName); + if (error != KErrNone) + delete connServ; + + return error; + } + +TInt CCEsockTestBase::ConnectConnectionServer(const TDesC& aConnectionServName, TUint aTierId) + { + //check if this secket server hasn't been created already + RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName); + if (connServ == NULL) + return KErrNotFound; + + return connServ->Connect(aTierId); + } + +TInt CCEsockTestBase::CloseConnectionServer(const TDesC& aConnectionServName) + { + // Find the connection server we are referring to + RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName); + if (connServ == NULL) + return KErrNotFound; + + connServ->Close(); + return KErrNone; + } + +TInt CCEsockTestBase::ConnectionAccessPointStatusQuery( + const TDesC& aConnectionServName, + const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aResultBundle) + { + RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName); + + if(connServ == NULL) + return KErrNotFound; + + // Need a local active scheduler for the RConnectionServ API + CActiveScheduler* as = new(ELeave) CActiveScheduler; + CleanupStack::PushL(as); + CActiveScheduler::Install(as); + + CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle); + + TRAP_IGNORE(CActiveScheduler::Start()) + + TInt res2 = sq->ErrCode(); + + CleanupStack::PopAndDestroy(sq); + CleanupStack::PopAndDestroy(as); + + return res2; + } + +class CMyTimer : public CTimer + { +public: + static CMyTimer* NewL() + { + CMyTimer* timer = new CMyTimer(); + if(timer) + { + timer->ConstructL(); + CActiveScheduler::Add(timer); + } + return timer; + } + + CMyTimer() : CTimer(EPriorityStandard) + { + } + void RunL() + { + // Simply stop the scheduler as this will force the cancellation we are after + CActiveScheduler::Current()->Stop(); + } + }; + +const TInt KHalfASecondInMicroSeconds = 500000; + +TInt CCEsockTestBase::CancelAccessPointStatusQuery( + const TDesC& aConnectionServName, + const ConnectionServ::CConnectionServParameterBundle& aQueryBundle, + ConnectionServ::CConnectionServParameterBundle& aResultBundle) + { + RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName); + + if(connServ == NULL) + return KErrNotFound; + + // Need a local active scheduler for the RConnectionServ API + CActiveScheduler* as = new(ELeave) CActiveScheduler; + CleanupStack::PushL(as); + CActiveScheduler::Install(as); + + // Create a timer that will complete almost immediately and stop the scheduler + // thereby canceling the query while it is in progress + // This all requires a long running query + CMyTimer* timer = CMyTimer::NewL(); + CleanupStack::PushL(timer); + timer->After(KHalfASecondInMicroSeconds); + + // Create active object to manage the query + CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle); + + // Start the scheduler + TRAP_IGNORE(CActiveScheduler::Start()) + + sq->Cancel(); + timer->Cancel(); + + // Check that the cancel status is what we expected + TInt res2 = sq->ErrCode(); + + CleanupStack::PopAndDestroy(sq); + CleanupStack::PopAndDestroy(timer); + CleanupStack::PopAndDestroy(as); + + return res2; + } + + +// +//socket functions library + +RSocket* CCEsockTestBase::FindSocket(const TDesC& aSocketName) + { + return iSocks.Find(aSocketName); + } + +TInt CCEsockTestBase::CreateSocket(const TDesC& aSocketName) + { + //check if this socket hasn't been created already + if (iSocks.Find(aSocketName)!=NULL) + return KErrAlreadyExists; + + RSocket* s = new RSocket; + if (s==NULL) + return KErrNoMemory; + + TInt error = iSocks.Add(s,aSocketName); + if (error!=KErrNone) + delete s; + + return error; + } + +TInt CCEsockTestBase::OpenSocket(const TRSocketParams& aParams) + { + RSocketServ* ss = iSockServs.Find(aParams.iSockServName); + if (ss==NULL) + return KErrNotFound; + + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + TInt error; + + //try to find the connection (if specified) + if (aParams.iConnectionName.Length()>0) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *c); + } + else if (aParams.iSubconnectionName.Length()>0) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubconnectionName); + if (sc==NULL) + { + return KErrNotFound; + } + error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *sc); + } + else if (aParams.iProtocolName.Length()>0) + { + error = s->Open(*ss,aParams.iProtocolName); + } + else + { + error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol); + } + + + return error; + } + +TInt CCEsockTestBase::BindSocket(const TRSocketParams& /*aParams*/) + { + return KErrNotSupported; + /* + RSocket* s = iSocks.Find(aSockeSParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + TInt error = KErrNone; + if (aSockeSParams.iProtocol==KProtocolInetUdp) + error = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1); + if (error!=KErrNone) + return error; + + //bind to Local address for TCP or UDP + return s->Bind(aSockeSParams.iLocalIP); + */ + } + +TInt CCEsockTestBase::ConnectSocket(TRSocketParams& aParams, TRequestStatus& aRequestStatus) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + { + return KErrNotFound; + } + + TInt err = KErrNone; + + if (aParams.iProtocol==KProtocolInetUdp) + { + err = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1); + if (err != KErrNone) + { + return err; + } + } + + if (!aParams.iLocalIP.IsUnspecified() || !aParams.iLocalIP.IsWildPort()) + { + err = s->Bind(aParams.iLocalIP); + } + + if (err == KErrNone) + { + s->Connect(aParams.iRemoteIP, aRequestStatus); + } + + return err; + } + +TInt CCEsockTestBase::CancelConnectSocket(const TRSocketParams& aParams) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + s->CancelConnect(); + return KErrNone; + } + +void CCEsockTestBase::SendAndReceiveDataL(const TRSocketParams& aParams) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + User::Leave(KErrNotFound); + + TInt recvCount = 0; + TRequestStatus stat; + TBuf8<50> Data; + + //set up buffers + HBufC8* writebuf = HBufC8::NewMaxLC(aParams.iPacketSize); + HBufC8* readbuf = HBufC8::NewMaxLC(aParams.iPacketSize); + + // In the case of armv5, HBufC8 MaxLength is set as 1504 or 1512 + // To sort it out we use TPtr8(TUint8* ,MaxLenghth) constructor + // instead of using + // TPtr8 ptrwritebuf = writebuf->Des(); + // TPtr8 ptrreadbuf = readbuf->Des(); + TPtr8 ptrwritebuf(const_cast(writebuf->Ptr()), aParams.iPacketSize); + TPtr8 ptrreadbuf(const_cast(readbuf->Ptr()), aParams.iPacketSize); + + // NewMaxLC may give a max size bigger than specified. Make sure length and max length are in sync so that + // the Read will complete. For example, NewMaxLC(1500) may give back a buffer 1504 as the max size. if you Write + // then Read on that, it'll write the length (1500) but try to read the max length (1504). this'll never complete + // because we'll only get back as many bytes as we wrote the the echo server. + ptrwritebuf.SetLength(ptrwritebuf.MaxLength()); + ptrreadbuf.SetLength(ptrreadbuf.MaxLength()); + + if (aParams.iProtocol==KProtocolInetTcp) + { + for (TInt i = 0; i < aParams.iNrOfPackets; i++) + { + // initialise data + Data.Format(_L8("TCP-packet:%d helloworld"),i); + ptrwritebuf.Repeat( Data ); + + // write data + s->Write(ptrwritebuf,stat); + User::WaitForRequest(stat); + User::LeaveIfError(stat.Int()); + + // read data + s->Read(ptrreadbuf, stat); + User::WaitForRequest(stat); + User::LeaveIfError(stat.Int()); + + // compare the data + if (ptrwritebuf.Compare(ptrreadbuf) != 0) + User::Leave(KErrGeneral); + + recvCount+=ptrreadbuf.Length(); + } + } + else if (aParams.iProtocol==KProtocolInetUdp || aParams.iProtocol == KProtocolInetDummy) + { + for (TInt i = 0; i < aParams.iNrOfPackets; i++) + { + // initialise data + Data.Format(_L8("UDP-packet:%d helloworld"),i); + ptrwritebuf.Repeat( Data ); + + // If we are colouring the payload then first prefix outgoing payload with command byte to tell the stack so + if(aParams.iPayloadColouringIsEnabled) + { + ptrwritebuf[0] = 0xF9; // KColourDataByLinkTierAccessPointId; TODO_CDG + } + + // write data + s->Send(ptrwritebuf, 0, stat); + User::WaitForRequest(stat); + User::LeaveIfError(stat.Int()); + + // If the returned data will be coloured by the IP stack for test purposes + // then we had better change what we compare it with + if(aParams.iPayloadColouringIsEnabled) + { + ptrwritebuf[0] += static_cast(aParams.iPayloadColour); + } + + s->Recv(ptrreadbuf, 0, stat); + User::WaitForRequest(stat); + User::LeaveIfError(stat.Int()); + + // compare the data + if (ptrwritebuf.Compare(ptrreadbuf) != 0 ) + User::Leave(KErrGeneral); + + recvCount += ptrreadbuf.Length(); + } + } + else + User::Leave(KErrNotFound); + + CleanupStack::PopAndDestroy(2, writebuf); // writebuf and readbuf + + // check the total received (95 per cent is allowable for us) + if (recvCount*aParams.iPacketSize < (0.95*(aParams.iNrOfPackets*aParams.iPacketSize))) + User::Leave(KErrGeneral); + } + +TInt CCEsockTestBase::CloseSocket(const TDesC& aSocketName) + { + RSocket* s = iSocks.Find(aSocketName); + if (s==NULL) + return KErrNotFound; + + s->Close(); + return KErrNone; + } + +TInt CCEsockTestBase::ShutdownSocket(const TRSocketParams& aParams, TRequestStatus& aRequestStatus) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + s->Shutdown(aParams.iShutdownType,aRequestStatus); + return KErrNone; + } + +TInt CCEsockTestBase::IoctlSocket(const TRSocketIoctlParams& aParams, TDes8& aIoctlOutput, TRequestStatus& aRequestStatus) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s == NULL) + return KErrNotFound; + + s->Ioctl(aParams.iIoctlCommand, aRequestStatus, &aIoctlOutput, aParams.iIoctlLevel); + User::WaitForRequest(aRequestStatus); + + return KErrNone; + } + +TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TDes8& aGetOptOutput) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s == NULL) + return KErrNotFound; + + return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput); + } + +TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TInt& aGetOptOutput) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s == NULL) + return KErrNotFound; + + return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput); + } + +TInt CCEsockTestBase::ProtocolDescription( + const TSocketProtocolDescriptionParams& aParams, + TProtocolDesc& aProtocolDescriptionOutput) + { + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s == NULL) + return KErrNotFound; + + return s->Info(aProtocolDescriptionOutput); + } + + +// +//connection functions library + +RConnection* CCEsockTestBase::FindConnection(const TDesC& aConnectionName) + { + return iConns.Find(aConnectionName); + } + +TInt CCEsockTestBase::CreateConnection(const TDesC& aConnectionName) + { + //check if this connection hasn't been created already + if (iConns.Find(aConnectionName)!=NULL) + return KErrAlreadyExists; + + RConnection* c = new RConnection; + if (c==NULL) + return KErrNoMemory; + + TInt error = iConns.Add(c,aConnectionName); + if (error!=KErrNone) + delete c; + + return error; + } + +TInt CCEsockTestBase::OpenConnection(const TRConnectionParams& aParams) + { + RSocketServ* ss = iSockServs.Find(aParams.iSockServName); + if (ss==NULL) + return KErrNotFound; + + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + if(aParams.iConnectionType != -1) + return c->Open(*ss,aParams.iConnectionType); + + return c->Open(*ss); + } + +TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + return c->WaitForIncoming(*sc); + } + +TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams,TRequestStatus& reqStat) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + c->WaitForIncoming(*sc,reqStat); + + return KErrNone; + } + +TInt CCEsockTestBase::AcceptIncomingConnection(const TRSubConnectionParams& aParams) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + sc->Start(); + + return KErrNone; + } + +TInt CCEsockTestBase::AsyncAcceptIncomingConnection(const TRSubConnectionParams& aParams, TRequestStatus& reqStat) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + sc->Start(reqStat); + + return KErrNone; + } + +TInt CCEsockTestBase::RejectIncomingConnection(const TRSubConnectionParams& aParams) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + sc->Stop(); + + return KErrNone; + } + +TInt CCEsockTestBase::CancelIncomingConnection(const TRSubConnectionParams& aParams) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + c->CancelWaitForIncoming(); + + return KErrNone; + } + + +TInt CCEsockTestBase::StartConnection(RConnection& aConn, TConnPref& aPrefs, TRequestStatus* aRequestStatus) + { + if (aRequestStatus) + { + aConn.Start(aPrefs, *aRequestStatus); + } + else + { + return aConn.Start(aPrefs); + } + return KErrNone; + } + +TInt CCEsockTestBase::StartConnection(TRConnectionParams& aParams) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + TRequestStatus* requestStatus = NULL; + if (aParams.iAsynch) + { + requestStatus = new TRequestStatus; + if (requestStatus==NULL) + return KErrNoMemory; + + TInt error = iRequestStatuses.Add(requestStatus, aParams.iConnectionName); + if (error!=KErrNone) + { + delete requestStatus; + return error; + } + } + + TInt error; + if (aParams.iStartWithSnapPreferences) + { + TCommSnapPref prefs; + prefs.SetSnap(aParams.iSNAP); + + error = StartConnection(*c, prefs, requestStatus); + } + else if (aParams.iStartWithOldPreferences) + { + TCommDbConnPref prefs; + prefs.SetBearerSet(aParams.iBearer); + prefs.SetIapId(aParams.iIAP); + error = StartConnection(*c, prefs, requestStatus); + } + else if(aParams.iStartWithConPrefList) + { + TConnPrefList* prefs = TConnPrefList::NewL(); + CleanupStack::PushL(prefs); + TConnAPPref* APPref = TConnAPPref::NewL(aParams.iSNAP); + CleanupStack::PushL(APPref); + TDummyPref* dummyPref = TDummyPref::NewL(aParams.iDummy); + CleanupStack::PushL(dummyPref); + if(aParams.iStartWithDummy) + prefs->AppendL(dummyPref); + + TConnAutoStartPref* autoPref = TConnAutoStartPref::NewL(); + CleanupStack::PushL(autoPref); + if(aParams.iStartAuto) + prefs->AppendL(autoPref); + + prefs->AppendL(APPref); + error = StartConnection(*c, *prefs, requestStatus); + + delete APPref; + delete dummyPref; + delete autoPref; + if (aParams.iStartAuto) + prefs->Remove(0); + if (aParams.iStartWithDummy) + prefs->Remove(0); + prefs->Remove(0); + delete prefs; + + CleanupStack::Pop(4); + } + else + { + if (requestStatus) + { + c->Start(*requestStatus); + } + else + { + error = c->Start(); + } + } + + return error; + } + +TInt CCEsockTestBase::AttachToConnection(const TRConnectionParams& aParams) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + TUint count = 0; + c->EnumerateConnections(count); + + if(count < 1) + return KErrNotFound; + + // + TInt error = KErrNotSupported; + RConnection* atc = iConns.Find(aParams.iAttachToConnectionName); + if (atc!=NULL) + { //Currently this is only for the new attach (TConnProviderInfo) + //If you want to extend this test step for legacy attach (TConnectionInfo), + //you need to add a parameter to recognise which attach it is. + + ESock::XProviderInfoQuerySet* querySet = ESock::XProviderInfoQuerySet::NewL(); + CleanupDeletePushL(querySet); + + // CProviderInfoQuerySet takes ownership of the X-class + ESock::CProviderInfoQuerySet* queryContainer = ESock::CProviderInfoQuerySet::NewL(querySet); + CleanupStack::Pop(querySet); + CleanupStack::PushL(queryContainer); + + error = atc->GetParameters(*queryContainer); + if (error != KErrNone) + return error; + + ESock::XProviderInfoQuerySet& outputQuerySet = queryContainer->DataObject(); + + TPckg pkgConnInfo(outputQuerySet.ConnProviderInfo()); + error = c->Attach(pkgConnInfo, aParams.iConnAttachType); + + CleanupStack::PopAndDestroy(queryContainer); + } + else + { + TConnectionInfo connInfo; + TPckg pkgConnInfo(connInfo); + + TBool found = EFalse; + for(TInt index = 1; index <= count; ++index) + { + error = c->GetConnectionInfo(index, pkgConnInfo); + if(error != KErrNone) + return error; + + if(aParams.iIAP == 0 && aParams.iNET == 0) + { + found = ETrue; + } + else if(aParams.iIAP > 0 && aParams.iNET > 0) + { + found = (aParams.iIAP == connInfo.iIapId && aParams.iNET == connInfo.iNetId) ? ETrue : EFalse; + } + else if(aParams.iIAP > 0) + { + found = aParams.iIAP == connInfo.iIapId ? ETrue : EFalse; + } + else if(aParams.iNET > 0) + { + found = aParams.iNET == connInfo.iNetId ? ETrue : EFalse; + } + + if(found) + break; + } + if(!found) + return KErrNotFound; + + error = c->Attach(pkgConnInfo,aParams.iConnAttachType); + } + + return error; + } + +TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + c->Stop(aParams.iConnStopType); + return KErrNone; + } + +TInt CCEsockTestBase::CloseConnection(const TDesC& aConnectionName) + { + RConnection* c = iConns.Find(aConnectionName); + if (c==NULL) + return KErrNotFound; + + c->Close(); + return KErrNone; + } + +// +//connection events +//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.) + +TInt CCEsockTestBase::RegisterForProgressNotificationEvent(const TEventContainerParams& aParams) + { + TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName); + if (ec==NULL) + { + ec = new TEsockTestEventContainer; + if (ec==NULL) + return KErrNoMemory; + + TInt error = iConnEvents.Add(ec,aParams.iEventName); + if (error!=KErrNone) + { + delete ec; + return error; + } + } + + __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 1)); + RConnection* conn = iConns.Find(aParams.iConnectionName); + if (conn==NULL) + { + return KErrNotFound; + } + + if (aParams.iEventMask == 0) + return KErrArgument; + + conn->ProgressNotification(ec->iProgressBuf, ec->iEventReceived, aParams.iEventMask); + return KErrNone; + } + +TInt CCEsockTestBase::ReceiveProgressNotificationEvent(TNifProgress*&aNifProgress, const TDesC& aEventName, TUint aTimeoutInMiliSec) + { + TEsockTestEventContainer* ec = iConnEvents.Find(aEventName); + if (ec==NULL) + return KErrNotFound; + if (aTimeoutInMiliSec) + { + RTimer timer; + timer.CreateLocal(); + TRequestStatus timerStatus; + timer.After(timerStatus, aTimeoutInMiliSec * 1000); + User::WaitForRequest(ec->iEventReceived, timerStatus); + } + else + { + User::WaitForRequest(ec->iEventReceived); + } + aNifProgress = (ec->iEventReceived.Int()==KErrNone)? &ec->iProgressBuf() : NULL; + return ec->iEventReceived.Int(); + } + + +//mobility extensions +RCommsMobilityApiExt* CCEsockTestBase::FindMobilityExtension(const TDesC& aMobilityExtensionName) + { + return iMobilityExts.Find(aMobilityExtensionName); + } + +TInt CCEsockTestBase::CreateMobilityExtension(const TDesC& aMobilityExtensionName) + { + //check if this extension hasn't been created already + if (iMobilityExts.Find(aMobilityExtensionName)!=NULL) + return KErrAlreadyExists; + + RCommsMobilityApiExt* me = new RCommsMobilityApiExt; + if (me==NULL) + return KErrNoMemory; + + TInt error = iMobilityExts.Add(me,aMobilityExtensionName); + if (error!=KErrNone) + delete me; + + return error; + } + + +// Data monitoring +//---------------- + +RCommsDataMonitoringApiExt* CCEsockTestBase::FindDataMonitoringExtension(const TDataMonitorEventParams& aParams) + { + return iDataMonitoringExts.Find(aParams.iDataMonitorName); + } + + +TEsockTestDataMonitoringResponse* CCEsockTestBase::FindDataMonitoringResponder(const TDataMonitorEventParams& aParams) + { + return iDataMonitoringEvents.Find(aParams.iEventName); + } + +TInt CCEsockTestBase::CreateDataMonitoringExtension(const TDataMonitorEventParams& aParams) + { + if(iDataMonitoringExts.Find(aParams.iDataMonitorName) != NULL) + { + return KErrAlreadyExists; + } + + RCommsDataMonitoringApiExt* ext = new RCommsDataMonitoringApiExt(); + + if(!ext) + { + return KErrNoMemory; + } + + TInt error = iDataMonitoringExts.Add(ext, aParams.iDataMonitorName); + + if (error != KErrNone) + { + delete ext; + } + + return error; + } + +TEsockTestDataMonitoringResponse* CCEsockTestBase::FindOrCreateDataMonitoringResponder(const TDataMonitorEventParams& aParams) + { + TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams); + if(response) + { + return response; + } + + if(NULL == (response = new TEsockTestDataMonitoringResponse())) + { + return NULL; + } + + TInt err = iDataMonitoringEvents.Add(response, aParams.iEventName); + if(err != KErrNone) + { + delete response; + response = NULL; + } + + return response; + } + +TInt CCEsockTestBase::OpenDataMonitoringExtension(const TDataMonitorEventParams& aParams) + { + RCommsSubSession* connOrSubConn = NULL; + + if(aParams.iConnectionName.Length() > 0) + { // Open extension on an RConnection if specified + connOrSubConn = iConns.Find(aParams.iConnectionName); + if(!connOrSubConn) + { + return KErrNotFound; + } + } + else if(aParams.iSubConnectionName.Length() > 0) + { // Otherwise open extension on an RSubConnection + connOrSubConn = iSubConns.Find(aParams.iSubConnectionName); + if(!connOrSubConn) + { + return KErrNotFound; + } + } + else + { // Neither an RConnection or an RSubConnection was specified + return KErrArgument; + } + + RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName); + if(!ext) + { + return KErrNotFound; + } + + return ext->Open(*connOrSubConn); + } + +TInt CCEsockTestBase::CloseDataMonitoringExtension(const TDataMonitorEventParams& aParams) + { + RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName); + if(!ext) + { + return KErrNotFound; + } + + ext->Close(); + + return KErrNone; + } + +TInt CCEsockTestBase::RequestDataTransferred(const TDataMonitorEventParams& aParams, TDes8& aResponseBuf) + { + RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName); + if(!ext) + { + return KErrNotFound; + } + + TRequestStatus status; + ext->RequestDataTransferred(aResponseBuf, status); + User::WaitForRequest(status); + + return KErrNone; + } + +// Find saved stats from a previous DataTransferred request +TDataMonitorStats* CCEsockTestBase::FetchSavedDataMonitorStats(const TDesC& aDataMonitorStatsSavedName) + { + return iSavedDataMonitorStats.Find(aDataMonitorStatsSavedName); + } + +// Save data monitor stats for future reference +TInt CCEsockTestBase::SaveDataMonitorStats(const TDesC& aSavedName, TDataMonitorStats& aStatsToSave) + { + TInt err; + + // Simply add if doesn't already exist + if(iSavedDataMonitorStats.Find(aSavedName) == NULL) + { + err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName); + } + else + { + // Already exists so delete and add in order to replace + iSavedDataMonitorStats.Remove(aSavedName); + err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName); + } + + return err; + } + +TInt CCEsockTestBase::RequestDataReceivedNotification(const TDataMonitorEventParams& aParams) + { + RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams); + if(!ext) + { + return KErrNotFound; + } + + TEsockTestDataMonitoringResponse* response = FindOrCreateDataMonitoringResponder(aParams); + if(!response) + { + return KErrNoMemory; + } + + ext->RequestDataReceivedNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus); + + return KErrNone; + } + +TInt CCEsockTestBase::CancelDataReceivedNotificationRequest(const TDataMonitorEventParams& aParams) + { + RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams); + if(!ext) + { + return KErrNotFound; + } + + TEsockTestDataMonitoringResponse* response = FindOrCreateDataMonitoringResponder(aParams); + if(!response) + { + return KErrNoMemory; + } + + ext->CancelDataReceivedNotificationRequest(); + User::WaitForRequest(response->iStatus); + + // Return the status code from the cancellation + return response->iStatus.Int(); + } + +TInt CCEsockTestBase::ReceiveDataReceivedNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf) + { + TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams); + if(!response) + { + return KErrNotFound; + } + + // Check that its not complete already + if(response->iComplete) + { + return KErrGeneral; + } + + RTimer timer; + timer.CreateLocal(); + + TRequestStatus timerStatus; + timer.After(timerStatus, response->iTimeout * 1000000); + + User::WaitForRequest(response->iStatus, timerStatus); + + TInt result; + if(response->iStatus.Int() != KErrNone) + { + result = KErrTimedOut; + } + else + { + timer.Cancel(); + User::WaitForRequest(timerStatus); + + aResponseBuf = NULL; + if(response->iStatus.Int() == KErrNone) + { + aResponseBuf = &response->iBuffer; + } + result = response->iStatus.Int(); + response->iComplete = ETrue; + } + + timer.Close(); + + return result; + } + +TInt CCEsockTestBase::RequestDataSentNotification(const TDataMonitorEventParams& aParams) + { + // Find the data monitoring extension to start with + RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams); + if(!ext) + { + return KErrNotFound; + } + + // Find the data monitoring responder that goes with it + TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams); + if(!response) + { + return KErrNotFound; + } + + // Make the request on the data monitor + ext->RequestDataSentNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus); + + return KErrNone; + } + +TInt CCEsockTestBase::CancelDataSentNotificationRequest(const TDataMonitorEventParams& aParams) + { + RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams); + if(!ext) + { + return KErrNotFound; + } + + TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams); + if(!response) + { + return KErrNotFound; + } + + ext->CancelDataSentNotificationRequest(); + User::WaitForRequest(response->iStatus); + + // Return the status code from the cancellation + return response->iStatus.Int(); + } + +TInt CCEsockTestBase::ReceiveDataSentNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf) + { + TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams); + if(!response) + { + return KErrNotFound; + } + + // Check that its not complete already + if(response->iComplete) + { + return KErrGeneral; + } + + RTimer timer; + timer.CreateLocal(); + + TRequestStatus timerStatus; + timer.After(timerStatus, response->iTimeout * 1000000); + + User::WaitForRequest(response->iStatus, timerStatus); + + TInt result; + if(response->iStatus.Int() != KErrNone) + { + result = KErrTimedOut; + } + else + { + timer.Cancel(); + User::WaitForRequest(timerStatus); + + aResponseBuf = NULL; + if(response->iStatus.Int() == KErrNone) + { + aResponseBuf = &response->iBuffer; + } + result = response->iStatus.Int(); + response->iComplete = ETrue; + } + + timer.Close(); + + return result; + } + +#if 0 +// +//CommsServer functions library + +TInt CCEsockTestBase::CreateCommsServer(const TDesC& aCommsServerName) + { + //check if this comms server hasn't been created already + if (iCommsServers.Find(aCommsServerName)!=NULL) + return KErrAlreadyExists; + + RConnection* c = new RConnection; + if (c==NULL) + return KErrNoMemory; + + TInt error = iConns.Add(c,aConnectionName); + if (error!=KErrNone) + delete c; + + return error; + } + +TInt CCEsockTestBase::StartCommsServer(const TRCommsServerParams& aParams, TRequestStatus& aRequestStatus) + { + RConnManager* c = iCommsServers.Find(aParams.iCommsServerName); + if (c==NULL) + return KErrNotFound; + + c->Start(prefs,aRequestStatus); + } + else if (aParams.iStartWithOldPreferences) + { + TCommDbConnPref prefs; + prefs.SetBearerSet(aParams.iBearer); + prefs.SetIapId(aParams.iIAP); + c->Start(prefs,aRequestStatus); + } + else + c->Start(aRequestStatus); + + return KErrNone; + } + +TInt CCEsockTestBase::StartConnection(const TRConnectionParams& aParams) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + TInt error; + if (aParams.iStartWithSnapPreferences) + { + TCommSnapPref prefs; + prefs.SetSnap(aParams.iSNAP); + error = c->Start(prefs); + } + else if (aParams.iStartWithOldPreferences) + { + TCommDbConnPref prefs; + prefs.SetBearerSet(aParams.iBearer); + prefs.SetIapId(aParams.iIAP); + error = c->Start(prefs); + } + else + error = c->Start(); + + return error; + } + +TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams) + { + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + c->Stop(aParams.iConnStopType); + return KErrNone; + } +#endif + + +// SubConnections +//--------------- + +RSubConnection* CCEsockTestBase::FindSubConnection(const TDesC& aSubConnectionName) + { + return iSubConns.Find(aSubConnectionName); + } + +TInt CCEsockTestBase::CreateSubConnection(const TDesC& aSubConnectionName) + { + //check if this sub connection hasn't been created already + if (iSubConns.Find(aSubConnectionName)!=NULL) + return KErrAlreadyExists; + + RSubConnection* sc = new RSubConnection; + if (sc==NULL) + return KErrNoMemory; + + TInt error = iSubConns.Add(sc,aSubConnectionName); + if (error!=KErrNone) + delete sc; + + return error; + } + +TInt CCEsockTestBase::OpenSubConnection(const TRSubConnectionParams& aParams) + { + RSocketServ* ss = iSockServs.Find(aParams.iSockServName); + if (ss==NULL) + return KErrNotFound; + + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RConnection* c = iConns.Find(aParams.iConnectionName); + if (c==NULL) + return KErrNotFound; + + return sc->Open(*ss, aParams.iSubConnType, *c); + } + +TInt CCEsockTestBase::CloseSubConnection(const TDesC& aSubConnectionName) + { + RSubConnection* sc = iSubConns.Find(aSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + sc->Close(); + return KErrNone; + } + +TInt CCEsockTestBase::AddSocketToSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + sc->Add(*s,aStatus); + return KErrNone; + } + +TInt CCEsockTestBase::RemoveSocketFromSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RSocket* s = iSocks.Find(aParams.iSocketName); + if (s==NULL) + return KErrNotFound; + + sc->Remove(*s,aStatus); + return KErrNone; + } + +TInt CCEsockTestBase::SetSubConnectionParameters(const TRSubConnectionParams& aParams) + { + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + RSubConParameterBundle* scp = iSubConnParams.Find(aParams.iSubConnectionParamsName); + if (scp==NULL) + return KErrNotFound; + + return sc->SetParameters(*scp); + } + +TInt CCEsockTestBase::GetSubConnectionParameters(const TRSubConnectionParams& aParams) + { + if (iSubConnParams.Find(aParams.iSubConnectionParamsName)!=NULL) + return KErrAlreadyExists; + + RSubConParameterBundle* scp = new RSubConParameterBundle; + if (scp==NULL) + return KErrNoMemory; + + TInt error = iSubConnParams.Add(scp,aParams.iSubConnectionParamsName); + if (error!=KErrNone) + { + delete scp; + return error; + } + + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + return KErrNotFound; + + return sc->GetParameters(*scp); + } + +TInt CCEsockTestBase::CompareIntegerValues(const TCompareIntegersParams& aParams, TInt& aDifference) + { + TInt* value1; + value1 = iIntegerValues.Find(aParams.iValue1); + if(value1 == NULL) + { + return KErrNotFound; + } + + TInt* value2; + value2 = iIntegerValues.Find(aParams.iValue2); + if (value2 == NULL) + { + return KErrNotFound; + } + + // Confirm the values + aDifference = (*value1 - *value2 + aParams.iDifference); + return KErrNone; + } + +TInt CCEsockTestBase::AwaitRequestStatus(const TDesC& aStatusName) + { + TRequestStatus* req = iRequestStatuses.Find(aStatusName); + ASSERT(req); + User::WaitForRequest(*req); + return req->Int(); + } + +// +//subconnection parameters +TInt CCEsockTestBase::CreateRSubConnectionParams(const TDesC& aSubConParamsName) + { + RSubConParameterBundle* scp = new RSubConParameterBundle; + if (scp==NULL) + return KErrNoMemory; + + TInt error = iSubConnParams.Add(scp,aSubConParamsName); + if (error!=KErrNone) + delete scp; + + return error; + } +// SBLP functions + +TInt CCEsockTestBase::CreateTFlowId(const TDesC& aFlowIdName) + { + TFlowId* fid = new TFlowId; + if (fid==NULL) + return KErrNoMemory; + + TInt error = iFlowId.Add(fid,aFlowIdName); + if (error!=KErrNone) + delete fid; + + return error; + + } + +TFlowId* CCEsockTestBase::FindTFlowId(const TDesC& aFlowId) + { + return iFlowId.Find(aFlowId); + } + +TInt CCEsockTestBase::CloseRSubConnectionParams(const TDesC& aSubConParamsName) + { + RSubConParameterBundle* scp = iSubConnParams.Find(aSubConParamsName); + if (scp==NULL) + return KErrNotFound; + + scp->Close(); + return KErrNone; + } + + +RSubConParameterBundle* CCEsockTestBase::FindRSubConnectionParams(const TDesC& aSubConParamsName) + { + return iSubConnParams.Find(aSubConParamsName); + } + +CSubConParameterFamily* CCEsockTestBase::FindRSubConnectionParameterFamily(const TDesC& aSubConParamsName, const TInt aFamilyId) + { + RSubConParameterBundle* bundle = FindRSubConnectionParams(aSubConParamsName); + if (bundle==NULL) + return NULL; + + return bundle->FindFamily(aFamilyId); + } + +// +//subconnection events +//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.) + +TInt CCEsockTestBase::RegisterForRSubConnectionEvent(const TEventContainerParams& aParams) + { + TEsockTestEventContainer* ec = iSubConnEvents.Find(aParams.iEventName); + if (ec==NULL) + { + ec = new TEsockTestEventContainer; + if (ec==NULL) + return KErrNoMemory; + + TInt error = iSubConnEvents.Add(ec,aParams.iEventName); + if (error!=KErrNone) + { + delete ec; + return error; + } + } + + __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 2)); + RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName); + if (sc==NULL) + { + return KErrNotFound; + } + + //check if we should simply register for all event + if (aParams.iAllEvents) + { + sc->EventNotification(static_cast(ec->iEventNotifBuf), EFalse, ec->iEventReceived); + return KErrNone; + } + + //no.. what about only generic ones? + if (aParams.iGenericEvents) + { + sc->EventNotification(static_cast(ec->iEventNotifBuf), ETrue, ec->iEventReceived); + return KErrNone; + } + + //no.. reqister for specific events + if (aParams.iEventMask == 0) + return KErrArgument; + + (ec->iSubconnEventFilter).iEventGroupUid = KSubConnGenericEventsImplUid; + (ec->iSubconnEventFilter).iEventMask = aParams.iEventMask; + sc->EventNotification(static_cast(ec->iEventNotifBuf), &(ec->iSubconnEventFilter), 1, ec->iEventReceived); + return KErrNone; + } + +TInt CCEsockTestBase::ReceiveRSubConnectionEvent(TNotificationEventBuf*& aBufferPtr, const TDesC& aSubConEventName) + { + TEsockTestEventContainer* ec = iSubConnEvents.Find(aSubConEventName); + if (ec==NULL) + return KErrNotFound; + + User::WaitForRequest(ec->iEventReceived); + aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &static_cast(ec->iEventNotifBuf) : NULL; + __ASSERT_DEBUG(aBufferPtr->GroupId(), User::Panic(KSpecAssert_ESockTestEsckTst, 3)); + return ec->iEventReceived.Int(); + } + +// +//mobility notifications +//(each notification request is encapsulated in a "EventContainer" that can easily be stored in a map.) + +TInt CCEsockTestBase::RegisterForMobilityNotification(const TEventContainerParams& aParams) + { + TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName); + if (ec==NULL) + { + ec = new TEsockTestEventContainer; + if (ec==NULL) + return KErrNoMemory; + + TInt error = iConnEvents.Add(ec,aParams.iEventName); + if (error!=KErrNone) + { + delete ec; + return error; + } + } + + RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName); + if (me==NULL) + { + return KErrNotFound; + } + + //reqister + __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 4)); + me->RegisterForMobilityNotification(ec->iEventNotifBuf,ec->iEventReceived); + + return KErrNone; + } + +TInt CCEsockTestBase::ReceiveMobilityNotification(TDesC8*& aBufferPtr, const TEventContainerParams& aParams) + { + TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName); + if (ec==NULL) + return KErrNotFound; + + RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName); + if (me==NULL) + return KErrNotFound; + + if (aParams.iTimeoutMiliSecs!=0) + { + TRequestStatus timeoutStatus; + RTimer timer; + timer.CreateLocal(); + timer.After(timeoutStatus,aParams.iTimeoutMiliSecs*1000); + User::WaitForRequest(ec->iEventReceived,timeoutStatus); + timer.Cancel(); + timer.Close(); + if (ec->iEventReceived==KRequestPending) + { + me->CancelMobilityNotification(); + } + } + else + { + User::WaitForRequest(ec->iEventReceived); + + } + + aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &ec->iEventNotifBuf : NULL; + return ec->iEventReceived.Int(); + } + +// +//cleanup + +void CCEsockTestBase::CleanAll() + { + iSockServs.ResetAndDestroy(); + iSocks.ResetAndDestroy(); + iConns.ResetAndDestroy(); + iSubConns.ResetAndDestroy(); + iConnectionServs.ResetAndDestroy(); + iMobilityExts.ResetAndDestroy(); + iDataMonitoringExts.ResetAndDestroy(); + iDataMonitoringEvents.ResetAndDestroy(); + iNotifWatchers.ResetAndDestroy(); + TInt i = 0; + for (i = 0; i < iSubConnParams.Count(); i++) + { + iSubConnParams[i]->Close(); + } + iSubConnParams.ResetAndDestroy(); + iSubConnEvents.ResetAndDestroy(); + iConnEvents.ResetAndDestroy(); + iFlowId.ResetAndDestroy(); + iIntegerValues.ResetAndDestroy(); + iRequestStatuses.ResetAndDestroy(); + } + +// +//general utils + + +// +// Simtsy Trigger Event functionality + +/** + Instructs the simtsy to complete a given request/notification. The supported commands are given in TEtelRequestType. + The parameter supplied in aNewValue instructs the simtsy what data from the config.txt to use in the completion of the request. + The aNewValue is the index to the entry to be used to complete the request for the current test step section, ie if aNewValue + is 0, iTestNumber is 3, and aEtelCommand is ENetworkQoSChange, the entry will complete any NotifyNetworkQoSChange calls + with data from the first QosNetworkNotification= entry of section [test3] in the config.txt file +*/ + + +TInt CCEsockTestBase::EtelRequestL(TUint aEventKey, TInt aNewValue) + { + // simtsy will listen for any changes to the property, and complete the corresponding request + TInt error = RProperty::Set(KUidPSSimTsyCategory, aEventKey, aNewValue); + + return error; + } + + +// + + + +// +//simtsy functionality + +TInt TSimTsy::Start() + { + //define name of the Phone module to be used for the RTelServer + _LIT(KMtsyName, "SIM"); + TInt res = StartC32(); + if (res!=KErrNone) + return res; + TInt error = iServer.Connect(); + if (error!=KErrNone) + return error; + error = iServer.LoadPhoneModule(KMtsyName); + if (error!=KErrNone) + return error; + error = iPhone.Open(iServer, KPhoneName); + if (error!=KErrNone) + return error; + error = SetTestNumber(0); + return error; + } + + +void TSimTsy::Stop() + { + iPhone.Close(); + iServer.Close(); + } + + +TInt TSimTsy::SetTestNumber(TInt aTestSectionNumber) + { + return RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, aTestSectionNumber); + } + +// +