diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/src/CSimPacketContext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simtsy/src/CSimPacketContext.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,3639 @@ +// Copyright (c) 2002-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: +// This file contains the implementation of the Similator TSY Packet Context functionality. +// +// + +/** + @file +*/ + +#include "Simlog.h" +#include "CSimPhone.h" +#include "CSimPacketContext.h" +#include "CSimPacketService.h" +#include "CSimPacketQoS.h" +#include "utils.h" + +#include "CSimContextHelper.h" + +const TInt KUnsetInteger = 0; + +CPcktListReadAllAttempt* CPcktListReadAllAttempt::NewL(TClientId& aId, TTsyReqHandle aReqHandle) +/** + * Standard two phase constructor. + * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read. + * @param aReqHandle The TSY request handle of the client request associated with a two phase read. + * @return CPcktListReadAllAttempt* The newly created object. + */ + { + CPcktListReadAllAttempt* read=new(ELeave) CPcktListReadAllAttempt(aId, aReqHandle); + CleanupStack::PushL(read); + read->ConstructL(); + CleanupStack::Pop(); + return read; + } + +CPcktListReadAllAttempt::CPcktListReadAllAttempt(TClientId& aId, TTsyReqHandle aReqHandle) + : iReqHandle(aReqHandle) +/** + * Trivial first phase constructor. + * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read. + * @param aReqHandle The TSY request handle of the client request associated with a two phase read. + */ + { + iClient.iSessionHandle=aId.iSessionHandle; + iClient.iSubSessionHandle=aId.iSubSessionHandle; + } + +void CPcktListReadAllAttempt::ConstructL() +/** + * Trivial second phase constructor. + */ + { + User::LeaveIfError(iListBuf!=NULL); + } + +CPcktListReadAllAttempt::~CPcktListReadAllAttempt() +/** + * Trivial destructor. + */ + { + delete iListBuf; + } + + +CSimPacketContext* CSimPacketContext::NewL(CSimPhone* aPhone, CSimPacketService* aPacketService, const TDesC& aContextName) +/** +* Standard two phase constructor +* +* @param aPacketService Pointer to the Packet Service object (CSimPacketService) +* @param aContextName name for this packet context +* @return CSimPacketContext pointer to the packet context object created. +* @leave Leaves if no memory or object is not created for any reason. +*/ + { + CSimPacketContext* packetContext = new(ELeave) CSimPacketContext(aPhone, aPacketService, aContextName); + CleanupStack::PushL(packetContext); + packetContext->ConstructL(); + CleanupStack::Pop(); + return packetContext; + } + +void CSimPacketContext::Init() + {} + +CSimPacketContext::CSimPacketContext(CSimPhone* aPhone, CSimPacketService* aPacketService, const TName& aContextName) + : iPhone(aPhone), iDeleted(EFalse),iIsActive(EFalse),iPacketService(aPacketService),iContextName(aContextName), + iTFTCreated(EFalse), iNumTFTsCreated(-1), iNumFiltersAdded(0), + iContextConfigParamsIndex(0), iCommPortLoaned(EFalse),iQoSObjectCount(0), + iNotifyContextConfigChangeArray(NULL), iSetConfigData(NULL), iSetConfigCallCount(0), iTFTChangeBool(0), + iNotifyContextStatusChangeIndex(0),iState(RPacketContext::EStatusInactive) + +/** +* Trivial Constructor. Initialises all the data members +* +* @param aPacketService Pointer to the Packet Service object (CSimPacketService) +* @param aContextName name for this packet context +*/ + { + iNotifyStatusChange.iNotifyPending = EFalse; + iNotifyConfigGPRS.iNotifyPending= EFalse; + iNotifyConfigR99.iNotifyPending= EFalse; + iNotifyConfigR5.iNotifyPending= EFalse; + } + +void CSimPacketContext::ConstructL() +/** +* Second phase of the 2-phase constructor. +* Constructs all the member data and retrieves all the data from the config file specific to this class. +* +* @leave Leaves no memory or any data member does not construct for any reason. +*/ + { + LOGPACKET1("CSimPacketContext: Entered constructor"); + + iSetConfigData = new (ELeave) CArrayFixFlat(1); + iNotifyContextConfigChangeArray = new (ELeave) CArrayFixFlat(1); + iContextConfigParams = new (ELeave) CArrayFixFlat(KNumberofConfigs); + iAuthorizationTokenResponse = new (ELeave) CArrayFixFlat(KNumberofConfigs); + iMediaAuthorization = new (ELeave) CArrayFixFlat(KNumberofConfigs); + + iNtRas = CSimNtRas::NewL(iPhone); + iTimer = CSimTimer::NewL(iPhone); + iNotifyContextStatusChangeTimer = CSimTimer::NewL(iPhone); + iSetConfigTimer = CSimTimer::NewL(iPhone); + iInitContextTimer = CSimTimer::NewL(iPhone); + iCreateTftTimer = CSimTimer::NewL(iPhone); + iNotifyContextConfigChangeTimer= CSimTimer::NewL(iPhone); + iContextStatusChange = CSimPubSubChange::NewL(this, CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimtsyPacketContextStatusChange, KPSSimtsyPacketContextStatusChangeKeyType)); + + LOGPACKET1("Starting to Load and Parse Packet Context the Config File"); + + GetCommSetupSettingsL(); + GetContextConfigParamSettingsL(KSetContextConfigGPRS()); + GetContextConfigParamSettingsL(KSetContextConfigRel99()); + GetContextConfigParamSettingsL(KSetContextConfigRel5()); + GetActivateSettings(); + GetSetConfigSettings(); + GetPacketFilterSettings(); + GetContextConfigRel99SettingsL(); + ConstructPacketFiltersL(); + GetContextStatusChangeSettingsL(); + GetContextConfigChangeSettingsL(); + + TInt nestedItemNumber; // used for nested loop + const CTestConfigItem* item2; // used for nested items + + TUint count = CfgFile()->ItemCount(KAuthorizationToken); + + TUint itemPosition = 0; + TUint itemOffSet = 0; + for(TInt i=0;iItem(KAuthorizationToken,i); + if(!item) + break; + + RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = RPacketContext::CTFTMediaAuthorizationV3::NewL(); + CleanupStack::PushL(mediaAuthorization); + TAuthorizationTokenResponse authorizationTokenResponse; + TPtrC8 authorizationToken; + TInt desiredResponse; + TInt numberOfFlowIds; + + TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,authorizationToken); + + if(ret!=KErrNone) + { + LOGPARSERR("CTFTMediaAuthorizationV3::authorizationToken",ret,0,&KAuthorizationToken); + CleanupStack::PopAndDestroy(mediaAuthorization); + continue; + } + else + { + mediaAuthorization->iAuthorizationToken.Copy(authorizationToken); // Set up for media authorization + authorizationTokenResponse.iAuthorizationToken.Copy(authorizationToken); // Set up for token response + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,desiredResponse); + + if(ret!=KErrNone || desiredResponse > 0) + { + LOGPARSERR("desiredResponse",ret,1,&KAuthorizationToken); + CleanupStack::PopAndDestroy(mediaAuthorization); + continue; + } + else + { + authorizationTokenResponse.iResponse = desiredResponse; + } + + iAuthorizationTokenResponse->AppendL(authorizationTokenResponse); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,numberOfFlowIds); + + for(nestedItemNumber=itemPosition+itemOffSet;nestedItemNumberItem(KFlowIdentifier,nestedItemNumber); + + if(!item2) + break; + + RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier iFlowIdentifier; + TInt mediaComponentNumber; + TInt IPFlowNumber; + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,mediaComponentNumber); + + if(ret!=KErrNone || mediaComponentNumber < 0) + { + LOGPARSERR("CTFTMediaAuthorizationV3::mediaComponentNumber",ret,0,&KFlowIdentifier); + continue; + } + else + { + iFlowIdentifier.iMediaComponentNumber = mediaComponentNumber; + } + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,IPFlowNumber); + + if(ret!=KErrNone || IPFlowNumber < 0) + { + LOGPARSERR("CTFTMediaAuthorizationV3::IPFlowNumber",ret,1,&KFlowIdentifier); + continue; + } + else + { + iFlowIdentifier.iIPFlowNumber = IPFlowNumber; + } + + mediaAuthorization->iFlowIds.Append(iFlowIdentifier); + } + itemOffSet+=numberOfFlowIds; + iMediaAuthorization->AppendL(*mediaAuthorization); // Add completed media authorization to array + CleanupStack::Pop(mediaAuthorization); + } + + LOGPACKET1("...Finished parsing Packet Context config parameters..."); + } + +void CSimPacketContext::GetCommSetupSettingsL() + { + iCommSetupArray = new (ELeave) CArrayFixFlat(KNumberofConfigs); + + TInt count = CfgFile()->ItemCount(KCommSetup); + if(count==0) + { + TCommSetupItem comm; + + comm.iCsyName.Copy(KDefaultCsyName); + comm.iPortName.Copy(KDefaultPortName); + comm.iConfig.iRate=KDefaultCommPortRate; + comm.iConfig.iHandshake=KDefaultHandshake; + comm.iContextName=KDefaultSetting; + comm.iCommReset = EFalse; + comm.iNumInitializeFailures = 0; + comm.iErrorCode = KErrNone; + comm.iDelay = 0; + iCommSetupArray->AppendL(comm); + } + + for(TInt i=0;iItem(KCommSetup,i); + + if(item) + { + TCommSetupItem comm; + TPtrC8 portName,csyName,contextName; + TInt commReset, numInitializeFailures, errorCode, delay; + + TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,csyName); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::csyName",ret,0,&KCommSetup); + comm.iCsyName.Copy(KDefaultCsyName); + } + else + comm.iCsyName.Copy(csyName); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,portName); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::portName",ret,1,&KCommSetup); + comm.iPortName.Copy(KDefaultPortName); + } + else + comm.iPortName.Copy(portName); + + TInt dataRate,handshake; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,dataRate); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::dataRate",ret,2,&KCommSetup); + comm.iConfig.iRate=KDefaultCommPortRate; + } + else + comm.iConfig.iRate=(TBps)dataRate; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,handshake); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::handShake",ret,3,&KCommSetup); + comm.iConfig.iHandshake=KDefaultHandshake; + } + else + comm.iConfig.iHandshake=(TUint)handshake; + + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,contextName); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::contextName",ret,4,&KCommSetup); + comm.iContextName=KDefaultSetting; + } + else + comm.iContextName.Copy(contextName); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,commReset); + if(ret!=KErrNone) + { + LOGPARSERR("CommSetUp::commReset",ret,5,&KCommSetup); + comm.iCommReset=EFalse; + } + else + comm.iCommReset = commReset; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,numInitializeFailures); + if(ret!=KErrNone) + { + comm.iNumInitializeFailures = 0; + } + else + comm.iNumInitializeFailures = numInitializeFailures; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,errorCode); + if(ret!=KErrNone) + { + comm.iErrorCode = KErrNone; + } + else + comm.iErrorCode = errorCode; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,delay); + if(ret!=KErrNone) + { + comm.iDelay = 0; + } + else + comm.iDelay = delay; + + iCommSetupArray->AppendL(comm); + } + } + } + + + +void CSimPacketContext::GetContextConfigParamSettingsL(TPtrC8 aTag) + { + CSimContextHelper::GetContextConfigParamSettingsL( CfgFile(), aTag, iContextConfigParams ); + } + + +void CSimPacketContext::GetActivateSettings() + { + TInt ret; + const CTestConfigItem* item=CfgFile()->Item(KActivatePauseDuration); //< Find the Activate data item + if(item) + { //< then retrieve the activation pause + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iActivatePause); + if(ret!=KErrNone) + iActivatePause = KDefaultPauseDuration; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iActivateFail); + if(ret==KErrNotFound) + iActivateFail = KErrNone; + } + + item=CfgFile()->Item(KDeactivatePauseDuration); //< Find the Deactivate data item + if(item) + { //< then retrieve the deactivation pause + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iDeactivatePause); + if(ret!=KErrNone) + iDeactivatePause = KDefaultPauseDuration; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iDeactivateFail); + if(ret==KErrNotFound) + iDeactivateFail = KErrNone; + } + + item=CfgFile()->Item(KDeletePauseDuration); //< Find the Delete data item + if(item) + { //< then retrieve the delete pause + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iDeletePause); + if(ret!=KErrNone) + iDeletePause = KDefaultPauseDuration; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iDeleteFail); + if(ret==KErrNotFound) + iDeleteFail = KErrNone; + } + } + +void CSimPacketContext::GetSetConfigSettings() + { + iSetConfigDelay = 0; + const CTestConfigItem* item=iPacketService->CfgFile()->Item(KSetConfigDelay); + if(item) + { + TInt delay = 0; + TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,delay); + + if(ret != KErrNone || delay < 0) + { + LOGPARSERR("SetConfigDelay",ret,0,&KSetConfigDelay); + } + else + { + iSetConfigDelay = delay; + } + } + + item=iPacketService->CfgFile()->Item(KSetConfigFail); // Set the SetConfigFail struct + if(item) + { + TPtrC8 contextName, numberOfTimes, failErrorCode; + TInt32 digit = 0; + TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::contextName",ret,0,&KSetConfigFail); + } + else + { + iSetConfigFail.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::numberOfTimes",ret,1,&KSetConfigFail); + } + else + { + if(AsciiToNum(numberOfTimes, digit)==KErrNone) + iSetConfigFail.iNumberOfTimes = digit; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,failErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::failErrorCode",ret,2,&KSetConfigFail); + } + else + { + if(AsciiToNum(failErrorCode, digit)==KErrNone) + iSetConfigFail.iFailErrorCode = digit; + } + } + } + +void CSimPacketContext::GetContextConfigChangeSettingsL() + { + TNotifyContextConfigChangeData configChangeData; + + TUint count = CfgFile()->ItemCount(KNotifyContextConfigChange); + TInt index; + for(index = 0; index < count; index++) + { + const CTestConfigItem *item = + CfgFile()->Item(KNotifyContextConfigChange,index); + + if(!item) + { + break; + } + + //Get the Notify Context Config Change Delay value + TInt ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0, + configChangeData.iDelay); + if(ret!=KErrNone) + { + LOGPARSERR("NotifyContextConfigChange::delay",ret,0,&KNotifyContextConfigChange); + continue; + } + + //Get the Notify Context Config Change, config index value + ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,1, + configChangeData.iNewContextConfigIndex); + if(ret!=KErrNone) + { + LOGPARSERR("NotifyContextConfigChange::NewContextConfigIndex", + ret,0,&KNotifyContextConfigChange); + continue; + } + + iNotifyContextConfigChangeArray->AppendL(configChangeData); + } + } + +void CSimPacketContext::GetPacketFilterSettings() + { + TInt ret; + const CTestConfigItem* item=iPacketService->CfgFile()->Item(KDeleteTftFail); + if(item) + { + TPtrC8 contextName, numberOfTimes, failErrorCode; + TInt32 digit = 0; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::contextName",ret,0,&KDeleteTftFail); + } + else + { + iDeleteTftFail.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::numberOfTimes",ret,1,&KDeleteTftFail); + } + else + { + if(AsciiToNum(numberOfTimes, digit)==KErrNone) + iDeleteTftFail.iNumberOfTimes = digit; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,failErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::failErrorCode",ret,2,&KDeleteTftFail); + } + else + { + if(AsciiToNum(failErrorCode, digit)==KErrNone) + iDeleteTftFail.iFailErrorCode = digit; + } + } + + item=iPacketService->CfgFile()->Item(KCreateTftConfig); + if(item) + { + TPtrC8 contextName, numberOfTimes, failErrorCode; + TInt32 digit = 0; + TInt delay = 0; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::contextName",ret,0,&KCreateTftConfig); + } + else + { + iCreateTftConfig.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::numberOfTimes",ret,1,&KCreateTftConfig); + } + else + { + if(AsciiToNum(numberOfTimes, digit)==KErrNone) + iCreateTftConfig.iNumberOfFailures = digit; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,failErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::failErrorCode",ret,2,&KCreateTftConfig); + } + else + { + if(AsciiToNum(failErrorCode, digit)==KErrNone) + iCreateTftConfig.iFailErrorCode = digit; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,delay); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::failErrorCode",ret,3,&KCreateTftConfig); + } + else + { + iCreateTftConfig.iDelay = delay; + } + } + + item=iPacketService->CfgFile()->Item(KAddPacketFilter); + if(item) + { + TPtrC8 contextName, numberOfTimes, failErrorCode; + TInt32 digit = 0; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::contextName",ret,0,&KAddPacketFilter); + } + else + { + iAddPacketFilter.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,numberOfTimes); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::numberOfTimes",ret,1,&KAddPacketFilter); + } + else + { + if(AsciiToNum(numberOfTimes, digit)==KErrNone) + iAddPacketFilter.iNumberOfTimes = digit; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,failErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("SetConfigFail::failErrorCode",ret,2,&KAddPacketFilter); + } + else + { + if(AsciiToNum(failErrorCode, digit)==KErrNone) + iAddPacketFilter.iFailErrorCode = digit; + } + + } + } + +void CSimPacketContext::GetContextConfigRel99SettingsL() + { + iContextConfigsRel99 = new(ELeave) CArrayFixFlat(KNumberofConfigs); + + TInt count = CfgFile()->ItemCount(KContextConfigRel99); // set up the Rel 99 context configuration parameters + for(TInt i=0;iItem(KContextConfigRel99,i); + if(!item) + break; + + TPtrC8 contextName; + TInt activatePause, activateErrorCode, aDeactivatePause, deactivateErrorCode, deletionPause; + TInt deletionErrorCode; + TBool connectToNtRas; + TRel99ContextConfig contextConfigRel99; + + TInt ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::contextName",ret,0,KContextConfigRel99); + } + else + { + contextConfigRel99.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,activatePause); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::activatePause",ret,1,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iActivatePause = activatePause; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,activateErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::activateErrorCode",ret,2,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iActivateErrorCode = activateErrorCode; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,aDeactivatePause); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::deactivatePause",ret,3,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iDeactivatePause = aDeactivatePause; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,deactivateErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::deactivateErrorCode",ret,4,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iDeactivateErrorCode = deactivateErrorCode; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,deletionPause); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::deletetionPause",ret,5,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iDeletionPause = deletionPause; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6, deletionErrorCode); + if(ret!=KErrNone) + { + LOGPARSERR("ContextConfigRel99::deletionErrorCode",ret,6,&KContextConfigRel99); + continue; + } + else + contextConfigRel99.iDeletionErrorCode = deletionErrorCode; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7, connectToNtRas); + if(ret!=KErrNone) + { + contextConfigRel99.iConnectToNtRas = ETrue; + } + else + contextConfigRel99.iConnectToNtRas = connectToNtRas; + + iContextConfigsRel99->AppendL(contextConfigRel99); + } + } + +/** + Retrieves the (aIndex+1)th packet context status with the current context's context name + ie. if aIndex is 0, the 1st context status entry is returned and if aIndex is 1, the 2nd is returned + */ +TNotifyContextStatusChange& CSimPacketContext::GetContextStatusChangeAt(TInt aIndex) + { + TInt count = 0; + for (TInt i = 0; i < iNotifyContextStatusChangeArray->Count(); i++) + { + if (iContextName.Compare(iNotifyContextStatusChangeArray->At(i).iContextName) == 0) + { + if (count == aIndex) + { + return iNotifyContextStatusChangeArray->At(i); + } + else + { + count++; + } + } + } + return iNotifyContextStatusChangeArray->At(0); + } + +/** + Retrieves the number of context status changes entries configured for the current packet context + */ +TInt CSimPacketContext::GetContextStatusChangeCount() + { + TInt count = 0; + for (TInt i = 0; i < iNotifyContextStatusChangeArray->Count(); i++) + { + if (iContextName.Compare(iNotifyContextStatusChangeArray->At(i).iContextName) == 0) + { + count++; + } + } + return count; + } + +void CSimPacketContext::GetContextStatusChangeSettingsL() + { + TPtrC8 contextStatusChangeType; + TInt ret; + + iNotifyContextStatusChangeArray = new (ELeave) CArrayFixFlat(KNumberofConfigs); + + // default to using timer to drive context status changes + iNotifyContextStatusChangeType = ETimer; + const CTestConfigItem* item = CfgFile()->Item(KNotifyContextStatusChangeType); + if (item) + { + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextStatusChangeType); + if(ret==KErrNone && contextStatusChangeType.Compare(KNotificationTypePublishSubscribe)==0) + iNotifyContextStatusChangeType = EPublishAndSubscribe; + } + + TInt count = CfgFile()->ItemCount(KNotifyContextStatusChange); + + for(TInt i=0;iItem(KNotifyContextStatusChange,i); + if(!item) + break; + + TNotifyContextStatusChange notifyContextStatusChange; + TPtrC8 contextName; + TInt duration, contextStatus; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,contextName); + + if(ret!=KErrNone) + { + LOGPARSERR("NotifyContextStatusChange::contextName",ret,0,&KNotifyContextStatusChange); + continue; + } + else + { + notifyContextStatusChange.iContextName.Copy(contextName); + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration); + if(ret!=KErrNone) + { + LOGPARSERR("NotifyContextStatusChange::duration",ret,1,&KNotifyContextStatusChange); + continue; + } + else + notifyContextStatusChange.iDuration = duration; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,contextStatus); + if(ret!=KErrNone) + { + LOGPARSERR("NotifyContextStatusChange::duration",ret,2,&KNotifyContextStatusChange); + continue; + } + else + notifyContextStatusChange.iStatus = (RPacketContext::TContextStatus)contextStatus; + + iNotifyContextStatusChangeArray->AppendL(notifyContextStatusChange); + + if(GetContextStatusChangeCount() != 0) + { + iCurrentNotifyContextStatusChange=(RPacketContext::TContextStatus)GetContextStatusChangeAt(0).iStatus; + if (iNotifyContextStatusChangeType == ETimer) + { + iNotifyContextStatusChangeIndex=0; + iNotifyContextStatusChangeTimer->Start(GetContextStatusChangeAt(0).iDuration,this,ETimerIdPcktContextStatusChange); + } + } + } + } + +void CSimPacketContext::ConstructPacketFiltersL() + { + iPacketFilterInfoArray = new (ELeave) CArrayFixFlat(KNumberofConfigs); + + const CTestConfigItem* item; + TInt count, ret; + count = CfgFile()->ItemCount(KPacketFilterInfo); + + for(TInt i=0;iItem(KPacketFilterInfo,i); + if(!item) + break; + + TPtrC8 srcAddr, srcAddrSubnetMask; + TInt id, evaluationPrecedenceIndex, protocolNumberOrNextHeader; + TInt srcPortMin, srcPortMax, destPortMin, destPortMax, ipSecSPI, toSorTrafficClass; + TInt flowLabel, filterType; + TPacketFilterV3 packetFilter; + + // Check that the data structure is supported by the simulated TSY version + if(iPhone->iSimTsyVersion < 3) // same version as TPacketFilterVx + { + (void)User::Leave(KErrNotSupported); + } + + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,id); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::id",ret,0,&KPacketFilterInfo); + continue; + } + else + { + packetFilter.iId= id; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,evaluationPrecedenceIndex); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::evaluationPrecedenceIndex",ret,1,&KPacketFilterInfo); + continue; + } + else + { + packetFilter.iEvaluationPrecedenceIndex= evaluationPrecedenceIndex; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,srcAddr); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::srcAddr",ret,2,&KPacketFilterInfo); + continue; + } + else + { + TUint8 digit=0; + TPtrC8 address; + + ret=CTestConfig::GetElement(srcAddr,'.',0, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[0] = digit; + else + packetFilter.iSrcAddr[0] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',1, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[1] = digit; + else + packetFilter.iSrcAddr[1] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',2, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[2] = digit; + else + packetFilter.iSrcAddr[2] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',3, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[3] = digit; + else + packetFilter.iSrcAddr[3] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',4, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[4] = digit; + else + packetFilter.iSrcAddr[4] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',5, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[5] = digit; + else + packetFilter.iSrcAddr[5] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',6, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[6] = digit; + else + packetFilter.iSrcAddr[6] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',7, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[7] = digit; + else + packetFilter.iSrcAddr[7] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',8, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[8] = digit; + else + packetFilter.iSrcAddr[8] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',9, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[9] = digit; + else + packetFilter.iSrcAddr[9] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',10, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[10] = digit; + else + packetFilter.iSrcAddr[10] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',11, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[11] = digit; + else + packetFilter.iSrcAddr[11] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',12, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[12] = digit; + else + packetFilter.iSrcAddr[12] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',13, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[13] = digit; + else + packetFilter.iSrcAddr[13] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',14, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[14] = digit; + else + packetFilter.iSrcAddr[14] = 0; + ret=CTestConfig::GetElement(srcAddr,'.',15, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddr[15] = digit; + else + packetFilter.iSrcAddr[15] = 0; + + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,srcAddrSubnetMask); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::srcAddrSubnetMask",ret,3,&KPacketFilterInfo); + continue; + } + else + { + TUint8 digit=0; + TPtrC8 address; + + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',0, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[0] = digit; + else + packetFilter.iSrcAddrSubnetMask[0] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',1, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[1] = digit; + else + packetFilter.iSrcAddrSubnetMask[1] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',2, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[2] = digit; + else + packetFilter.iSrcAddrSubnetMask[2] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',3, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[3] = digit; + else + packetFilter.iSrcAddrSubnetMask[3] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',4, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[4] = digit; + else + packetFilter.iSrcAddrSubnetMask[4] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',5, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[5] = digit; + else + packetFilter.iSrcAddrSubnetMask[5] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',6, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[6] = digit; + else + packetFilter.iSrcAddrSubnetMask[6] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',7, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[7] = digit; + else + packetFilter.iSrcAddrSubnetMask[7] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',8, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[8] = digit; + else + packetFilter.iSrcAddrSubnetMask[8] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',9, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[9] = digit; + else + packetFilter.iSrcAddrSubnetMask[9] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',10, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[10] = digit; + else + packetFilter.iSrcAddrSubnetMask[10] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',11, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[11] = digit; + else + packetFilter.iSrcAddrSubnetMask[11] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',12, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[12] = digit; + else + packetFilter.iSrcAddrSubnetMask[12] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',13, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[13] = digit; + else + packetFilter.iSrcAddrSubnetMask[13] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',14, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[14] = digit; + else + packetFilter.iSrcAddrSubnetMask[14] = 0; + ret=CTestConfig::GetElement(srcAddrSubnetMask,'.',15, address); + if((AsciiToNum(address, digit)==KErrNone) + && (ret == KErrNone)) + packetFilter.iSrcAddrSubnetMask[15] = digit; + else + packetFilter.iSrcAddrSubnetMask[15] = 0; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,protocolNumberOrNextHeader); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::protocolNumberOrNextNumber",ret,4,&KPacketFilterInfo); + packetFilter.iProtocolNumberOrNextHeader = KUnsetInteger; + } + else + { + packetFilter.iProtocolNumberOrNextHeader= protocolNumberOrNextHeader; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,srcPortMin); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::srcPortMin",ret,5,&KPacketFilterInfo); + packetFilter.iSrcPortMin = KUnsetInteger; + } + else + { + packetFilter.iSrcPortMin= srcPortMin; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,srcPortMax); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::srcPortMax",ret,6,&KPacketFilterInfo); + packetFilter.iSrcPortMax = KUnsetInteger; + } + else + { + packetFilter.iSrcPortMax= srcPortMax; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,destPortMin); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::destPortMin",ret,7,&KPacketFilterInfo); + packetFilter.iDestPortMin = KUnsetInteger; + } + else + { + packetFilter.iDestPortMin= destPortMin; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,destPortMax); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::srcPortMax",ret,8,&KPacketFilterInfo); + packetFilter.iDestPortMax = KUnsetInteger; + } + else + { + packetFilter.iDestPortMax= destPortMax; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,ipSecSPI); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::ipSecSPI",ret,9,&KPacketFilterInfo); + packetFilter.iIPSecSPI = KUnsetInteger; + } + else + { + packetFilter.iIPSecSPI= ipSecSPI; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,toSorTrafficClass); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::toSorTrafficClass",ret,10,&KPacketFilterInfo); + continue; + } + else + { + packetFilter.iTOSorTrafficClass = (TUint16)toSorTrafficClass; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,flowLabel); + + if(ret!=KErrNone) + { + LOGPARSERR("PacketFilterInfo::flowLabel",ret,11,&KPacketFilterInfo); + packetFilter.iFlowLabel = KUnsetInteger; + } + else + { + packetFilter.iFlowLabel = flowLabel; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,filterType); + + if(ret!=KErrNone) + { + if(ret == KErrNotFound) + { + LOGCONFIG1("CONFIGURATION FILE PARSING - PacketFilterInfo::TPacketFilterV2 info encountered"); + packetFilter.iFilterType = RPacketContext::EPacketFilterTypeUnknown; + } + else + { + LOGPARSERR("PacketFilterInfo::filterType",ret,12,&KPacketFilterInfo); + continue; + } + } + else + { + packetFilter.iFilterType = static_cast(filterType); + } + + packetFilter.iAdded = EFalse; + TRAP_IGNORE(iPacketFilterInfoArray->AppendL(packetFilter)); + } + } + +CSimPacketContext::~CSimPacketContext() +/** +* Trivial Destructor +* Closes all CObject type objects and destroys all other objects created in the ConstructL() +* +*/ + { + LOGPACKET1("CSimPacketContext: Entered destructor"); + + if (iContextConfigParams != NULL) + { + iContextConfigParams->Delete(0, iContextConfigParams->Count()); + delete iContextConfigParams; + } + if (iContextConfigsRel99 != NULL) + { + iContextConfigsRel99->Delete(0,iContextConfigsRel99->Count()); + delete iContextConfigsRel99; + } + if (iCommSetupArray != NULL) + { + iCommSetupArray->Delete(0, iCommSetupArray->Count()); + delete iCommSetupArray; + } + if (iNtRas != NULL) + delete iNtRas; + + if (iTimer != NULL) + delete iTimer; + + if (iSetConfigTimer != NULL) + delete iSetConfigTimer; + + if (iInitContextTimer != NULL) + delete iInitContextTimer; + + if (iCreateTftTimer != NULL) + delete iCreateTftTimer; + + if (iNotifyContextStatusChangeTimer != NULL) + delete iNotifyContextStatusChangeTimer; + + if (iNotifyContextConfigChangeTimer != NULL) + delete iNotifyContextConfigChangeTimer; + + if (iPacketFilterInfoArray != NULL) + { + iPacketFilterInfoArray->Delete(0, iPacketFilterInfoArray->Count()); + delete iPacketFilterInfoArray; + } + if (iNotifyContextStatusChangeArray != NULL) + { + iNotifyContextStatusChangeArray->Delete(0, iNotifyContextStatusChangeArray->Count()); + delete iNotifyContextStatusChangeArray; + } + iPacketService->DecrementContextCount(); + + if (iAuthorizationTokenResponse != NULL) + { + iAuthorizationTokenResponse->Delete(0, iAuthorizationTokenResponse->Count()); + delete iAuthorizationTokenResponse; + } + + if (iMediaAuthorization != NULL) + { + for(TUint i=0; iCount(); i++) + { + if (iMediaAuthorization->At(i).iFlowIds.Count() > 0) + { + iMediaAuthorization->At(i).iFlowIds.Reset(); + } + } + iMediaAuthorization->Delete(0, iMediaAuthorization->Count()); + delete iMediaAuthorization; + } + + delete iContextStatusChange; + + if(iSetConfigData !=NULL ) + { + iSetConfigData->Delete(0, iSetConfigData->Count()); + delete iSetConfigData; + } + + if(iNotifyContextConfigChangeArray !=NULL) + { + iNotifyContextConfigChangeArray->Delete(0,iNotifyContextConfigChangeArray->Count()); + delete iNotifyContextConfigChangeArray; + } +} + +CTelObject* CSimPacketContext::OpenNewObjectByNameL(const TDesC& aName) +/** +* Returns a pointer to an existing QoS object identified by name. +* This is not support and if called will leave. +* +* @param aName name of the QoS object to be opened +* @return CTelObject will return null and leave +* @leave Leaves with KErrNotSupported if the name is not as expected. +*/ + { + if (aName.Compare(iQoSName) == KErrNone) + { + return iPacketqos; + } + + User::Leave(KErrNotSupported); + return NULL; + } + + +CTelObject* CSimPacketContext::OpenNewObjectL(TDes& aNewName) +/** +* Creates a new CSimPacketQoS object and returns a pointer to it. +* +* @param aNewName new name of the object created +* @return CTelObject pointer to the CSimPacketQos object created +* @leave Leaves if out of memory. +*/ + { + aNewName.Append(KSimPacketQosName); + aNewName.AppendNum(++iQoSObjectCount); + iQoSName.Copy(aNewName); + iPacketqos = CSimPacketQoS::NewL(iPhone, this); + return iPacketqos; + } + +CTelObject::TReqMode CSimPacketContext::ReqModeL(const TInt aIpc) +/** +* ReqModeL is called from the server's CTelObject::ReqAnalyserL +* in order to check the type of request it has. +* +* +* @param aIpc the ipc number that identifies the client request +* @return CTelObject::TReqMode The request mode to be used for this request +* @leave Leaves if not supported by this tsy +*/ + { + CTelObject::TReqMode ret=0; + switch (aIpc) + { + case EPacketContextSetConfig: + case EPacketContextActivate: + case EPacketContextDeactivate: + case EPacketContextDelete: + case EPacketContextLoanCommPort: + case EPacketContextRecoverCommPort: + case EPacketContextGetConfig: + case EPacketContextGetStatus: + case EPacketContextGetDataVolumeTransferred: + case EPacketContextGetLastErrorCause: + case EPacketContextInitialiseContext: + case EPacketContextEnumeratePacketFilters: + case EPacketContextGetPacketFilterInfo: + case EPacketContextAddPacketFilter: + case EPacketContextRemovePacketFilter: + case EPacketContextModifyActiveContext: + case EPacketContextGetProfileName: + case EPacketContextGetDNSInfo: + case EPacketAddMediaAuthorization: + case EPacketRemoveMediaAuthorization: + case EPacketContextCreateNewTFT: + case EPacketContextDeleteTFT: + break; + + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + case EPacketContextNotifyDataTransferred: + ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately; + break; + + default: + User::Leave(KErrNotSupported); + break; + } + + return ret; + } + +TInt CSimPacketContext::GetProfileName(const TTsyReqHandle aTsyReqHandle, TName* aQoSProfile) + { +/** +* This synchronous method allows a client to retrieve the name +* of the QoS profile. The profile name is passed back in the aQoSProfile parameter +*/ + aQoSProfile->Copy(iQoSName); + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketContext::RegisterNotification(const TInt aIpc) +/** +* RegisterNotification is called when the server recognises that this notification +* is being posted for the first time on this sub-session object. +* +* It enables the TSY to "turn on" any regular notification messages that it may receive +* from the phone +* +* @param aIpc the ipc number that identifies the client request +* @return err KErrNone if fine +*/ + { + switch (aIpc) + { + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + case EPacketContextNotifyDataTransferred: + return KErrNone; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketContext: Register error, unknown IPC"); + return KErrNotSupported; + } + } + +TInt CSimPacketContext::DeregisterNotification(const TInt aIpc) +/** +* DeregisterNotification is called when the server recognises that this notification +* will not be posted again because the last client to have a handle on this sub-session +* object has just closed the handle. +* +* It enables the TSY to "turn off" any regular notification messages that it may +* receive from the phone +* +* @param aIpc the ipc number that identifies the client request +* @return err KErrNone if fine +*/ + { + switch (aIpc) + { + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + case EPacketContextNotifyDataTransferred: + LOGPACKET1("CSimPacketContext: DeregisterNotification"); + return KErrNone; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketContext: Deregister error, unknown IPC"); + return KErrNotSupported; + } + } + +TInt CSimPacketContext::NumberOfSlotsL(const TInt aIpc) +/** +* NumberOfSlotsL is called by the server when it is registering a new notification +* It enables the TSY to tell the server how many buffer slots to allocate for +* "repost immediately" notifications that may trigger before clients collect them +* +* @param aIpc the ipc number that identifies the client request +* @return err KErrNone if fine +*/ + { + TInt numberOfSlots=1; + switch (aIpc) + { + case EPacketContextNotifyConfigChanged: + case EPacketContextNotifyStatusChange: + case EPacketContextNotifyDataTransferred: + LOGPACKET1("CGprsDGprsTsy: Registered with 5 slots"); + numberOfSlots=5; + break; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketContext: Number of Slots error, unknown IPC"); + User::Leave(KErrNotSupported); + break; + } + return numberOfSlots; + } + + +TInt CSimPacketContext::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc, + const TDataPackage& aPackage) +/** +* ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request +* for the TSY to process. +* A request handle, request type and request data are passed to the TSY +* +* @param aTsyReqHandle The request handle for completing the request +* @param aIpc Ipc representing the request +* @param aPackage any data associated with the request +* @return err KErrNone if request completes ok +*/ + { + //< if this context has been deleted then the client can not do anything with it + //< if the client wants to use this class, the client must open a new object by + //< name with the name for this context and this will reactivate the context. + if(iDeleted && (aIpc != EPacketContextGetStatus)) + { + ReqCompleted(aTsyReqHandle,KErrNotReady); + return KErrNone; + } + + TAny* dataPtr=aPackage.Ptr1(); + TAny* dataPtr2=aPackage.Ptr2(); + + switch (aIpc) + { + case EPacketContextSetConfig: + { + if (iSetConfigCallCount <= iSetConfigFail.iNumberOfTimes + || iSetConfigFail.iNumberOfTimes==0) + { + if (iSetConfigDelay > 0) + { + TSetConfigData setConfigData; + setConfigData.iTsyReqHandle = aTsyReqHandle; + setConfigData.iData = aPackage.Des1n(); + + TRAPD(ret, iSetConfigData->AppendL(setConfigData) ); + if (ret != KErrNone) + { + LOGPACKET1("CSimPacketContext::ExtFunc AppendL call fail"); + return ret; + } + + iSetConfigTimer->Start(iSetConfigDelay,this,ETimerIdPcktContextSetConfig); + } + else + { + SetConfig(aTsyReqHandle, aPackage.Des1n()); + } + iSetConfigCallCount++; + return KErrNone; + } + else + { + iSetConfigCallCount=0; + iSetConfigFail.iNumberOfTimes = 0; + + ReqCompleted(aTsyReqHandle, iSetConfigFail.iFailErrorCode); + return KErrNone; // if SetConfig() has been called the number of times allowed in SetConfigFail, fail request + } + } + case EPacketContextGetProfileName: + return GetProfileName(aTsyReqHandle, REINTERPRET_CAST(TName*,dataPtr)); + case EPacketContextSetConfigCancel: + return SetConfigCancel(aTsyReqHandle); + case EPacketContextGetConfig: + return GetConfig(aTsyReqHandle, aPackage.Des1n()); + case EPacketContextGetConfigCancel: + return GetConfigCancel(aTsyReqHandle); + case EPacketContextNotifyConfigChanged: + return NotifyConfigChanged(aTsyReqHandle, aPackage.Des1n()); + case EPacketContextNotifyConfigChangedCancel: + return NotifyConfigChangedCancel(aTsyReqHandle); + case EPacketContextActivate: + { //< Ensures that theres only one context active as only one active context is + //(dataPtr)); + case EPacketRemoveMediaAuthorizationCancel: + return GetRemoveMediaAuthorizationCancel(aTsyReqHandle); + case EPacketContextCreateNewTFT: + return CreateNewTFT(aTsyReqHandle, REINTERPRET_CAST(TInt*, dataPtr)); + case EPacketContextCreateNewTFTCancel: + return CreateNewTFTCancel(aTsyReqHandle); + case EPacketContextDeleteTFT: + return DeleteTFT(aTsyReqHandle); + case EPacketContextDeleteTFTCancel: + return DeleteTFTCancel(aTsyReqHandle); + default: + return KErrNotSupported; + } + } + +TInt CSimPacketContext::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle) +/** +* CancelService is called by the server when it is "cleaning-up" any still outstanding +* asynchronous requests before closing a client's sub-session. +* This will happen if a client closes its R-class handle without cancelling outstanding asynchronous requests. +* +* @param aTsyReqHandle The request handle for completing the request +* @param aIpc Ipc representing the request +* @return err KErrNone if request completes ok +*/ + { + LOGPACKET1("CSimPacketContext: - CancelService called"); + switch (aIpc) + { + case EPacketContextSetConfig: + return SetConfigCancel(aTsyReqHandle); + case EPacketContextGetConfig: + return GetConfigCancel(aTsyReqHandle); + case EPacketContextNotifyConfigChanged: + return NotifyConfigChangedCancel(aTsyReqHandle); + case EPacketContextActivate: + return ActivateCancel(aTsyReqHandle); + case EPacketContextDeactivate: + return DeactivateCancel(aTsyReqHandle); + case EPacketContextDelete: + return DeleteCancel(aTsyReqHandle); + case EPacketContextLoanCommPort: + return LoanCommPortCancel(aTsyReqHandle); + case EPacketContextRecoverCommPort: + return RecoverCommPortCancel(aTsyReqHandle); + case EPacketContextNotifyStatusChange: + return NotifyStatusChangeCancel(aTsyReqHandle); + case EPacketContextNotifyDataTransferred: + return NotifyDataTransferredCancel(aTsyReqHandle); + case EPacketContextInitialiseContext: + return InitialiseContextCancel(aTsyReqHandle); + case EPacketContextEnumeratePacketFilters: + return EnumeratePacketFiltersCancel(aTsyReqHandle); + case EPacketContextGetPacketFilterInfo: + return GetPacketFilterInfoCancel(aTsyReqHandle); + case EPacketContextAddPacketFilter: + return AddPacketFilterCancel(aTsyReqHandle); + case EPacketContextRemovePacketFilter: + return RemovePacketFilterCancel(aTsyReqHandle); + case EPacketContextModifyActiveContext: + return ModifyActiveContextCancel(aTsyReqHandle); + case EPacketContextGetDNSInfo: + return GetDnsInfoCancel(aTsyReqHandle); + case EPacketAddMediaAuthorization: + return GetAddMediaAuthorizationCancel(aTsyReqHandle); + case EPacketRemoveMediaAuthorization: + return GetRemoveMediaAuthorizationCancel(aTsyReqHandle); + case EPacketContextCreateNewTFT: + return CreateNewTFTCancel(aTsyReqHandle); + case EPacketContextDeleteTFT: + return DeleteTFTCancel(aTsyReqHandle); + default: + return KErrGeneral; + } + } + +TInt CSimPacketContext::TSetConfigData::Find(CArrayFixFlat* aSetConfigArray, TTsyReqHandle aTsyReqHandle, TInt& aIndex) + { + for (TInt i = 0; i < aSetConfigArray->Count(); i++) + { + if (aSetConfigArray->At(i).iTsyReqHandle == aTsyReqHandle) + { + aIndex = i; + return KErrNone; + } + } + aIndex = -1; + return KErrNotFound; + } + +TInt CSimPacketContext::SetConfig(const TTsyReqHandle aTsyReqHandle,const TDesC8* aConfig) +/** +* Sets the configuration +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aConfig pointer containing the parameters to set to. +* @return KErrNone + +*/ + { + LOGPACKET1("CSimPacketContext::SetConfig called"); + + TPckg* configBase = (TPckg*)aConfig; + TPacketDataConfigBase& configBaseV1 = (*configBase)(); + + TInt err = KErrGeneral; + + //Extract the config params to be set + TContextConfigParam contextConfigToSet; + + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS) + { + TPckg* configParam = (TPckg*)aConfig; + RPacketContext::TContextConfigGPRS& contextConfigV1 = (*configParam)(); + + CSimContextHelper::SetTContextConfigParamFromTContextConfigGPRS( contextConfigToSet, contextConfigV1 ); + } + + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4) + { + TPckg* configParam = (TPckg*)aConfig; + RPacketContext::TContextConfigR99_R4& contextConfigV1 = (*configParam)(); + + CSimContextHelper::SetTContextConfigParamFromTContextConfigR99_R4( contextConfigToSet, contextConfigV1 ); + } + + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5) + { + TPckg* configParam = (TPckg*)aConfig; + RPacketContext::TContextConfig_R5& contextConfigV1 = (*configParam)(); + + CSimContextHelper::SetTContextConfigParamFromTContextConfig_R5( contextConfigToSet, contextConfigV1 ); + } + + // Check the context config params to be set with the pre-defined + // list of allowed config params + if((configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS)|| + configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4|| + configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5) + { + + TInt index; + for(index=0; index < iContextConfigParams->Count(); index++) + { + TContextConfigParam thisConfig = iContextConfigParams->At(index); + + if ( !CSimContextHelper::EqualTContextConfigParam(contextConfigToSet, thisConfig ) ) + { + err = KErrCorrupt; + } + else + { + err = KErrNone; + iContextConfigParamsIndex = index; + + //Check for and complete any pending notifications + if(iNotifyConfigGPRS.iNotifyPending) + { + iNotifyConfigGPRS.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfigGPRS*)iNotifyConfigGPRS.iNotifyData); + ReqCompleted(iNotifyConfigGPRS.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR99.iNotifyPending) + { + iNotifyConfigR99.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfigR99_R4*)iNotifyConfigR99.iNotifyData); + ReqCompleted(iNotifyConfigR99.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR5.iNotifyPending) + { + iNotifyConfigR5.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfig_R5*)iNotifyConfigR5.iNotifyData); + ReqCompleted(iNotifyConfigR5.iNotifyHandle,KErrNone); + } + break; + } + }//end for loop + ReqCompleted(aTsyReqHandle,err); + }//end if((configBaseV1.... + + else + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + } + + return KErrNone; + } + +TInt CSimPacketContext::SetConfigCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancels the Setconfig request. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return err KErrNone +*/ + { + TInt index = 0; + if (TSetConfigData::Find(iSetConfigData, aTsyReqHandle, index) == KErrNone) + { + iSetConfigData->Delete(index); + } + if (iSetConfigData->Count() == 0) + iSetConfigTimer->Cancel(); + + ReqCompleted(aTsyReqHandle, KErrCancel); + + return KErrNone; + } + +TInt CSimPacketContext::GetConfig(const TTsyReqHandle aTsyReqHandle,TDes8* aConfig) +/** +* Retrieves and returns the configuration +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aConfig pointer to the data to retrieve +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::GetConfig called"); + TPckg* configBase = (TPckg*)aConfig; + TPacketDataConfigBase& configBaseV1 = (*configBase)(); + + // GPRS configuration + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS) + { + TContextConfigParam config = iContextConfigParams->At(iContextConfigParamsIndex); + + TPckg* contextConfigGPRSPckg = (TPckg*)aConfig; + RPacketContext::TContextConfigGPRS& contextConfigV1 = (*contextConfigGPRSPckg)(); + + CSimContextHelper::ConvertConfigParams(config, contextConfigV1); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + + // R99/R4 configuration + else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4) + { + TContextConfigParam config = iContextConfigParams->At(iContextConfigParamsIndex); + + TPckg* configRel99Pckg = (TPckg*)aConfig; + RPacketContext::TContextConfigR99_R4& configRel99 = (*configRel99Pckg)(); + + CSimContextHelper::ConvertConfigParams(config, configRel99); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + + // R5 configuration + else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5) + { + TContextConfigParam config = iContextConfigParams->At(iContextConfigParamsIndex); + + TPckg* configRel5Pckg = (TPckg*)aConfig; + RPacketContext::TContextConfig_R5& configRel5 = (*configRel5Pckg)(); + + CSimContextHelper::ConvertConfigParams(config, configRel5); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + return KErrNone; + } + +TInt CSimPacketContext::GetConfigCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels the Getconfig request. This method will do nothing in this version of SimTSY. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return err KErrNone +*/ + { + return KErrNone; + } + +TInt CSimPacketContext::NotifyConfigChanged(const TTsyReqHandle aTsyReqHandle, TDes8* aConfig) +/** +* Records a client interest in being notified of a change in the Context Configuration. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aConfig pointer to the context config to store the config info when the config changes. +* @return KErrNone +*/ + { + TPckg* configBase = (TPckg*)aConfig; + TPacketDataConfigBase& configBaseV1 = (*configBase)(); + + if(configBaseV1.ExtensionId() == TPacketDataConfigBase::KConfigGPRS) + { + __ASSERT_ALWAYS(!iNotifyConfigGPRS.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyConfigGPRS.iNotifyPending = ETrue; + iNotifyConfigGPRS.iNotifyHandle = aTsyReqHandle; + iNotifyConfigGPRS.iNotifyData = &configBaseV1; + } + else if(configBaseV1.ExtensionId() == TPacketDataConfigBase::KConfigRel99Rel4) + { + __ASSERT_ALWAYS(!iNotifyConfigR99.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyConfigR99.iNotifyPending = ETrue; + iNotifyConfigR99.iNotifyHandle = aTsyReqHandle; + iNotifyConfigR99.iNotifyData = &configBaseV1; + } + else if(configBaseV1.ExtensionId() == TPacketDataConfigBase::KConfigRel5) + { + __ASSERT_ALWAYS(!iNotifyConfigR5.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyConfigR5.iNotifyPending = ETrue; + iNotifyConfigR5.iNotifyHandle = aTsyReqHandle; + iNotifyConfigR5.iNotifyData = &configBaseV1; + } + + return KErrNone; + } + +TInt CSimPacketContext::NotifyConfigChangedCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when the context configuration changes +* This is acheived simply by resetting the flag that indicates a notification is pending. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::NotifyConfigChangedCancel called"); + if(iNotifyConfigGPRS.iNotifyPending && + iNotifyConfigGPRS.iNotifyHandle == aTsyReqHandle) + { + iNotifyConfigGPRS.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + else if(iNotifyConfigR99.iNotifyPending && + iNotifyConfigR99.iNotifyHandle == aTsyReqHandle) + { + iNotifyConfigR99.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + else if(iNotifyConfigR5.iNotifyPending && + iNotifyConfigR5.iNotifyHandle == aTsyReqHandle) + { + iNotifyConfigR5.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + + return KErrNone; + } + +TInt CSimPacketContext::AttemptDeactivateImmediately() +/** +* Called when client wishes to Detach when there is an active context. +* This will deactivate the context immediately from the network. +* +* @return KErrNone if deactivated successfully. +*/ + { + if((iState==RPacketContext::EStatusActive) || (iState==RPacketContext::EStatusActivating)) + { + iCurrentEvent=EContextEventDeactivate; + TInt ret = ChangeState(RPacketContext::EStatusDeactivating); + if(ret!=KErrNone) + return ret; + return ChangeState(RPacketContext::EStatusInactive); + } + return KErrNone; + } + +TInt CSimPacketContext::ReActivate(CSimPacketService* aPacketService, const TName& aContextName) +/** +* This method is called by the packet Service to Re-Initialise a Deleted context. +* If the context is deleted then the client cannot retrieve any +* infomation or use the context in any way. +* In order for the client to use the context again, the client must +* open an object by name passing +* the name of this context as a pararemter. +* +* @param aPacketService pointer to the parent class CSimPacketService. +* @param aContextName Must be the same name as the name for this context. +* @return KErrNone if no problem in re-initialising this context. +*/ + { + if(iContextName.Compare(aContextName) != KErrNone) + { + return KErrBadName; + } + + iPacketService = aPacketService; + + if(iDeleted) + { + + TInt ret = ChangeState(RPacketContext::EStatusInactive); + if (ret != KErrNone) + { + return ret; + } + + iDeleted = EFalse; + iContextConfigParamsIndex = 0; + iNotifyStatusChange.iNotifyPending = EFalse; + iNotifyConfigGPRS.iNotifyPending = EFalse; + iNotifyConfigR99.iNotifyPending = EFalse; + iNotifyConfigR5.iNotifyPending = EFalse; + + } + return KErrNone; + } + +TInt CSimPacketContext::DoDeactivate() +/** +* This method is called when timer events for deactivate context has completed. +* It will then try to terminate the NTRas Connection. +* +* @return KErrNone +*/ + { + iNotifyContextConfigChangeTimer->Cancel(); + iNtRas->Terminate(); + return KErrNone; + } + +TInt CSimPacketContext::Deactivate(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try to Deactivate an active context. +* In this method, we'll store the TsyReqHandle for later completion then call ActionEvent +* state machine to handle the event which will kick off a timer. +* The Actual Deactivation will take place in the DoDeactivate method. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::Deactivate called"); + iDeactivateRequestHandle = aTsyReqHandle; + TInt ret; + ret = ActionEvent(EContextEventDeactivate,KErrNone); + return ret; + } + +TInt CSimPacketContext::DeactivateCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try and cancel a Deactivate request. +* This will only complete successfully if and only if the Deactivate request has not completed. +* i.e. if we haven't already deactivated the context. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::DeactivateCancel called"); + if(((iState == RPacketContext::EStatusInactive) || (iState == RPacketContext::EStatusDeactivating)) && + (iCurrentEvent==EContextEventDeactivate)) + { + iTimer->Cancel(); + iCurrentEvent= EContextEventNone; + TInt ret = ChangeState(RPacketContext::EStatusActive); + if(ret!= KErrNone) + ReqCompleted(aTsyReqHandle,ret); + ReqCompleted(aTsyReqHandle,KErrCancel); + } + + return KErrNone; + } + +TInt CSimPacketContext::DoActivate() +/** +* This method is called when timer events for Activate context has completed. +* It will then try to Set up the NtRas Connection and open a port for client use. +* +* @return KErrNone +*/ + { + TCommConfigV01 commConfig; + TCommSetupItem item = FindCommSettings(); + + if (iPacketqos) + { + iPacketqos->ClearChangeQoSPending(); + } + commConfig.iRate=item.iConfig.iRate; + commConfig.iDataBits=EData8; + commConfig.iStopBits=EStop1; + commConfig.iHandshake=item.iConfig.iHandshake; + iCommReset=item.iCommReset; + TInt ras = iNtRas->Connect(item.iCsyName,item.iPortName,commConfig,this); + + TContextConfigParam thisConfig = iContextConfigParams->At(iContextConfigParamsIndex); + + // Check for and complete any pending notifications + if(iNotifyConfigGPRS.iNotifyPending) + { + iNotifyConfigGPRS.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfigGPRS*)iNotifyConfigGPRS.iNotifyData); + ReqCompleted(iNotifyConfigGPRS.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR99.iNotifyPending) + { + iNotifyConfigR99.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfigR99_R4*)iNotifyConfigR99.iNotifyData); + ReqCompleted(iNotifyConfigR99.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR5.iNotifyPending) + { + iNotifyConfigR5.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(thisConfig, *(RPacketContext::TContextConfig_R5*)iNotifyConfigR5.iNotifyData); + ReqCompleted(iNotifyConfigR5.iNotifyHandle,KErrNone); + } + + // start the timer for the simulated network-side context parameter changes + if(iNotifyContextConfigChangeArray->Count() > 0) + { + TInt delay = (iNotifyContextConfigChangeArray->At(0)).iDelay; + iNotifyContextConfigChangeTimer->Start(delay,this,ETimerIdPcktContextConfigChange); + } + + return ras; + } + + +TInt CSimPacketContext::Activate(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try to Activate a context. +* In this method, we'll store the TsyReqHandle for later completion then call ActionEvent +* state machine to handle the event which will kick off a timer. +* The Actual Activation will take place in the DoActivate method. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return KErrNone +*/ + { + iActivateRequestHandle = aTsyReqHandle; + TInt ret; + ret = ActionEvent(EContextEventActivate,KErrNone); + return ret; + } + + +TInt CSimPacketContext::ActivateCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try and cancel an Activate request. +* This will only complete successfully if and only if the Activate request has not completed. +* i.e. if we haven't already activated the context. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::ActivateCancel called"); + if(((iState == RPacketContext::EStatusInactive) || (iState == RPacketContext::EStatusActivating)) && + (iCurrentEvent==EContextEventActivate)) + { + iTimer->Cancel(); + iCurrentEvent= EContextEventNone; + TInt ret = ChangeState(RPacketContext::EStatusInactive); + if(ret!= KErrNone) + ReqCompleted(aTsyReqHandle,ret); + else + ReqCompleted(aTsyReqHandle,KErrCancel); + } + else if (iState == RPacketContext::EStatusDeleted) + { + ReqCompleted(aTsyReqHandle,KErrCancel); + } + + return KErrNone; + } + +TInt CSimPacketContext::DoDelete() +/** +* This method is called when timer events for Delete context has completed. +* It will then try to Terminate the NtRas Connection and then set the context as deleted. +* Once the context is deleted then the client cannot retrieve any information about the context +* or use the context. calling ReActivateContext will reinstate this context. +* +* @return KErrNone +*/ + { + iDeleted = ETrue; + iNtRas->Terminate(); + iQoSObjectCount--; + return KErrNone; + } + + +TInt CSimPacketContext::Delete(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try to Delete this context. +* In this method, we'll store the TsyReqHandle for later completion then call ActionEvent +* state machine to handle the event which will kick off a timer. +* The Actual Delete will take place in the DoDelete method. +* +* This request will only succeed if the context already exist (had been created) and also not +* previously deleted. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::Delete called"); + iDeleteRequestHandle = aTsyReqHandle; + TInt ret; + ret = ActionEvent(EContextEventDelete,KErrNone); + return ret; + } + +TInt CSimPacketContext::DeleteCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to try and cancel a Delete context request. +* This will only complete successfully if and only if the Delete request has not completed. +* i.e. if we haven't already Deleted the context. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::DeleteCancel called"); + if((iState == RPacketContext::EStatusInactive) && (iCurrentEvent==EContextEventDelete)) + { + iTimer->Cancel(); + iCurrentEvent= EContextEventNone; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketContext::LoanCommPort(const TTsyReqHandle aTsyReqHandle,RCall::TCommPort* aDataPort) +/** +* The method will return to the client the port it has opened previously in the Activate method +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aDataPort Pointer to the port and csy name for the opened port. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::LoanCommPort called"); + + if(iState != RPacketContext::EStatusActive) + { + ReqCompleted(aTsyReqHandle, KErrEtelCallNotActive); + return KErrNone; + } + if (iCommPortLoaned) + { + ReqCompleted(aTsyReqHandle, KErrEtelPortAlreadyLoaned); + return KErrNone; + } + + TCommSetupItem item = FindCommSettings(); + aDataPort->iCsy.Copy(item.iCsyName); + aDataPort->iPort.Copy(item.iPortName); + iCommPortLoaned = ETrue; + ReqCompleted(aTsyReqHandle,KErrNone); + + return KErrNone; + } + +TInt CSimPacketContext::LoanCommPortCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels a client loan port request. This method will do nothing. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::LoanCommPortCancel called"); + return KErrNone; + } + +TInt CSimPacketContext::RecoverCommPort(const TTsyReqHandle aTsyReqHandle) +/** +* In this method we'll try and terminate the NtRas connection and reover the port. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::RecoverCommPort called"); + if (!iCommPortLoaned) + { + ReqCompleted(aTsyReqHandle, KErrEtelPortNotLoanedToClient); + return KErrNone; + } + iNtRas->Terminate(); + iCommPortLoaned = EFalse; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketContext::RecoverCommPortCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Attempt to cancel a RecoverCommPort request. This method does nothing +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::RecoverCommPortCancel called"); + return KErrNone; + } + +TInt CSimPacketContext::GetStatus(const TTsyReqHandle aTsyReqHandle,RPacketContext::TContextStatus* aContextStatus) +/** +* Retrieves and returns the current status of the Packet context in the aContextStatus parameter. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aContextStatus pointer to the status of the packet context. +* @return KerrNone +*/ + { + LOGPACKET1("CSimPacketContext::GetStatus called"); + *aContextStatus = iState; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketContext::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle,RPacketContext::TContextStatus* aContextStatus) +/** +* Record a client's interest in being notified of the state of the packet contexts. +* First check that there isn't already a notification pending (the ETel Server should protect +* against this) and then record the information necessary to complete the request later, when +* the status does actually change. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aContextStatus pointer to the packet context status +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::NotifyStatusChange called"); + __ASSERT_ALWAYS(!iNotifyStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + iNotifyStatusChange.iNotifyPending = ETrue; + iNotifyStatusChange.iNotifyHandle = aTsyReqHandle; + iNotifyStatusChange.iNotifyData = aContextStatus; + return KErrNone; + } + + + +TInt CSimPacketContext::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when the packet context status changes. +* This is acheived simply by resetting the flag that indicates a notification is pending. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::NotifyStatusChangeCancel called"); + if(iNotifyStatusChange.iNotifyPending) + { + iNotifyStatusChange.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketContext::GetDataVolumeTransferred(const TTsyReqHandle aTsyReqHandle,RPacketContext::TDataVolume* /*aVolume*/) +/** +* Retrieves and returns the to the client the amount of data sent over the serial port. +* This method is not supported and will request complete with KErrNotSupported +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aVolume pointer to the volume of data trasferred so far. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketContext::GetDataVolumeTransferred called"); + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + +TInt CSimPacketContext::NotifyDataTransferred(const TTsyReqHandle aTsyReqHandle, RPacketContext::TDataVolume* /*aVolume*/, RPacketContext::TNotifyDataTransferredRequest* /*aData*/) +/** +* Notifies the client when data is sent or received over the comm port +* This method is not supported in this version of the TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aVolume pointer to the volume of data trasferred so far. +* @param aData indicates to the client whether the data was sent or received. +* @return KErrNone +*/ + { + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + +TInt CSimPacketContext::NotifyDataTransferredCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels the NotifyDataTransferred request +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KerrNone +*/ + { + LOGPACKET1("CSimPacketContext::NotifyDataTransferredCancel called"); + return KErrNone; + } + +TInt CSimPacketContext::GetLastErrorCause(const TTsyReqHandle aTsyReqHandle,TInt* /*aError*/) +/** +* This method is not supported in this TSY +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aError pointer to the last error cause +* @return KerrNone +*/ + { + LOGPACKET1("CSimPacketContext::GetLastErrorCause called"); + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + +void CSimPacketContext::TimerCallBack(TInt aId) +/** +* Timer callback function. When the timer goes off, it will call back into this +* function for further processing. +*/ + { + TInt newIndex = KErrNotFound; + + switch(aId) + { + case ETimerIdPcktContextStatusChange: + TimerCallBackNotifyContextStatusChange(); + break; + case ETimerIdPcktContextSetConfig: + SetConfig(iSetConfigData->At(0).iTsyReqHandle, iSetConfigData->At(0).iData); + iSetConfigData->Delete(0); + if (iSetConfigData->Count() != 0) + iSetConfigTimer->Start(iSetConfigDelay,this,ETimerIdPcktContextSetConfig); + break; + case ETimerIdPcktContextConfigChange: + //Check the validity of the new context config param index before applying it + newIndex = (iNotifyContextConfigChangeArray->At(0)).iNewContextConfigIndex; + if(newIndex <= iContextConfigParams->Count() - 1) + { + //Change the context config param index to point to the new context configuration + iContextConfigParamsIndex = newIndex; + + // Check for and complete any pending notifications + if(iNotifyConfigGPRS.iNotifyPending) + { + iNotifyConfigGPRS.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(iContextConfigParams->At(iContextConfigParamsIndex), + *(RPacketContext::TContextConfigGPRS*)iNotifyConfigGPRS.iNotifyData); + ReqCompleted(iNotifyConfigGPRS.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR99.iNotifyPending) + { + iNotifyConfigR99.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(iContextConfigParams->At(iContextConfigParamsIndex), + *(RPacketContext::TContextConfigR99_R4*)iNotifyConfigR99.iNotifyData); + ReqCompleted(iNotifyConfigR99.iNotifyHandle,KErrNone); + } + + if(iNotifyConfigR5.iNotifyPending) + { + iNotifyConfigR5.iNotifyPending=EFalse; + CSimContextHelper::ConvertConfigParams(iContextConfigParams->At(iContextConfigParamsIndex), + *(RPacketContext::TContextConfig_R5*)iNotifyConfigR5.iNotifyData); + ReqCompleted(iNotifyConfigR5.iNotifyHandle,KErrNone); + } + } + + else + { + LOGMISC1(">>CSimPacketContext.cpp: Invalid new context config param index"); + } + + //Delete the current NotifyContextConfigChange item and set the next one if possible + iNotifyContextConfigChangeArray->Delete(0); + + if(iNotifyContextConfigChangeArray->Count() > 0) + { + TInt delay = (iNotifyContextConfigChangeArray->At(0)).iDelay; + iNotifyContextConfigChangeTimer->Start(delay,this, ETimerIdPcktContextConfigChange); + } + break; + + case ETimerIdPcktContextInitContext: + DoInitialiseContext(); + break; + case ETimerIdPcktContextCreateTft: + DoCreateNewTFT(); + break; + default: + { + LOGPACKET1(">>CSimPacketContext::TimerCallBack"); + TInt ret=ActionEvent(EContextEventTimeOut,KErrNone); + __ASSERT_ALWAYS(ret==KErrNone,SimPanic(ETimeOutEventActionFailed)); // Note: this is very crude error handling and should be replaced by something rather more elegant. + LOGPACKET1("<Count(); + if (aIndex < length) + { + TNotifyContextStatusChange& statusChange = iNotifyContextStatusChangeArray->At(aIndex); + if (statusChange.iContextName.Compare(iContextName) == 0) + { + CompleteContextStatusChange(statusChange.iStatus); + } + } + } + +/** +* This is for the NotifyContextStatusChange timer callback +*/ +void CSimPacketContext::TimerCallBackNotifyContextStatusChange() + { + if(GetContextStatusChangeCount() <= iNotifyContextStatusChangeIndex) + { + // the index is out of bounds + return; + } + TNotifyContextStatusChange& statusChange = GetContextStatusChangeAt(iNotifyContextStatusChangeIndex); + + CompleteContextStatusChange(statusChange.iStatus); + + iNotifyContextStatusChangeIndex++; + if (GetContextStatusChangeCount() > iNotifyContextStatusChangeIndex) + { + // start timer again + iNotifyContextStatusChangeTimer->Start(GetContextStatusChangeAt(iNotifyContextStatusChangeIndex).iDuration,this,ETimerIdPcktContextStatusChange); + } + } + +void CSimPacketContext::CompleteContextStatusChange(RPacketContext::TContextStatus& aStatus) + { + iCurrentNotifyContextStatusChange = aStatus; + + ChangeState(iCurrentNotifyContextStatusChange); + if (RPacketContext::EStatusDeleted == iCurrentNotifyContextStatusChange) + { + DoDelete(); + } + } + +void CSimPacketContext::NTRasCallBack(TInt aStatus) +/** + * NTRas callback function. This function will be called when the NTRAS + * Server has responded. + * + * @param aStatus Standard error value, indicating the success or failure of the NTRAS + * connection. + */ + { + __ASSERT_ALWAYS(ActionEvent(EContextEventNtRas,aStatus) == KErrNone,SimPanic(EGeneral)); + if(iCommReset) + iNtRas->Terminate(); + } + +RPacketService::TStatus CSimPacketContext::ConvertToPacketServiceStatus(RPacketContext::TContextStatus aNewState) +/** +* Converts Packet Context Status (RPacketContext::TContextStatus) to +* Packet Service Status (RPacketService::TStatus) +* +* @param aNewState the Context status to convert to packet service status +* @return RPacketService::TStatus The packet service status conversion +*/ + { + RPacketService::TStatus serviceStatus; + switch (aNewState) + { + case RPacketContext::EStatusInactive: + case RPacketContext::EStatusActivating: + case RPacketContext::EStatusDeleted: + serviceStatus = RPacketService::EStatusAttached; + break; + case RPacketContext::EStatusActive: + case RPacketContext::EStatusDeactivating: + serviceStatus = RPacketService::EStatusActive; + break; + case RPacketContext::EStatusSuspended: + serviceStatus = RPacketService::EStatusSuspended; + break; + default: + serviceStatus = RPacketService::EStatusUnattached; + break; + } + return serviceStatus; + } + + +TInt CSimPacketContext::ChangeState(RPacketContext::TContextStatus aNewState) +/** +* Attempt to change state. +* First validate that the requested state change is ok. If it is then proceed to change +* the state and complete any pending state change notification. +* +* @param aNewState the new state to change to +* @return Error indication if change of state is successful or not +*/ + { + LOGPACKET2(">>CSimPacketContext::ChangeState [newState=%d]", aNewState); + __ASSERT_ALWAYS(aNewState!=RPacketContext::EStatusUnknown,SimPanic(ECallStatusUnknownIllegal)); + + if(iState==aNewState) + return KErrNone; + + TInt ret=KErrGeneral; + const struct TContextStateChangeValidity* stateChangePnt=KContextStateChangeValidity; + while(stateChangePnt->iOldState!=KContextStateTableTerminator) + { + if((stateChangePnt->iOldState==iState) && (stateChangePnt->iNewState==aNewState)) + { + ret=stateChangePnt->iError; + break; + } + stateChangePnt++; + } + + if(ret!=KErrNone) + return ret; + +//Request permission from the phone to change the state of the packet connection + ret = iPacketService->ChangeState(ConvertToPacketServiceStatus(aNewState)); + if(ret!=KErrNone) + return ret; + +// Actually change the state. + iState=aNewState; + +// Check for a pending line state notification. + if(iNotifyStatusChange.iNotifyPending) + { + iNotifyStatusChange.iNotifyPending=EFalse; + *(RPacketContext::TContextStatus*)iNotifyStatusChange.iNotifyData=iState; + ReqCompleted(iNotifyStatusChange.iNotifyHandle,KErrNone); + } + + + LOGPACKET1("<Count(); + for(i = 0; iAt(i).iContextName)==0) + { + found = ETrue; + break; + } + } + + switch(aEvent) + { + case EContextEventActivate: + LOGPACKET1(">>CSimPacketContext::ActionEvent = [EContextEventActivate]"); + if(iState==RPacketContext::EStatusInactive) + { + iCurrentEvent=EContextEventActivate; + ret = ChangeState(RPacketContext::EStatusActivating); + if(ret!=KErrNone) + ReqCompleted(iActivateRequestHandle,ret); + else + { + if(!found) + iTimer->Start(iActivatePause,this); + else + iTimer->Start(iContextConfigsRel99->At(i).iActivatePause,this); + } + } + else + ReqCompleted(iActivateRequestHandle, KErrGprsActivationRejected); + break; + + case EContextEventDeactivate: + LOGPACKET1(">>CSimPacketContext::ActionEvent = [EContextEventDeactivate]"); + if(iState==RPacketContext::EStatusActive) + { + iCurrentEvent=EContextEventDeactivate; + ret = ChangeState(RPacketContext::EStatusDeactivating); + if(ret!=KErrNone) + ReqCompleted(iDeactivateRequestHandle,ret); + else + { + if (!found) + iTimer->Start(iDeactivatePause,this); + else + iTimer->Start(iContextConfigsRel99->At(i).iDeactivatePause,this); + } + } + else + ReqCompleted(iDeactivateRequestHandle, KErrNone); + break; + + case EContextEventDelete: + LOGPACKET1(">>CSimPacketContext::ActionEvent = [EContextEventDelete]"); + if(iState==RPacketContext::EStatusInactive) + { + iCurrentEvent=EContextEventDelete; + + if (!found) + iTimer->Start(iDeletePause,this); + else + iTimer->Start(iContextConfigsRel99->At(i).iDeletionPause,this); + } + else + ReqCompleted(iDeleteRequestHandle, KErrInUse); + break; + + case EContextEventNtRas: + if((iState==RPacketContext::EStatusActivating) && (iCurrentEvent==EContextEventNtRas)) + { + if(aStatus!=KErrNone) + { + ReqCompleted(iActivateRequestHandle,aStatus); + ret=ChangeState(RPacketContext::EStatusInactive); + __ASSERT_ALWAYS(ret==KErrNone,SimPanic(EIllegalStateInconsistancy)); + return KErrNone; + } + else + { + ret=ChangeState(RPacketContext::EStatusActive); + ReqCompleted(iActivateRequestHandle,ret); + iIsActive = ETrue; + return KErrNone; + } + } + iCurrentEvent=EContextEventNone; + break; + + case EContextEventTimeOut: + LOGPACKET1(">>CSimPacketContext::ActionEvent = [EContextEventTimeOut]"); + switch(iCurrentEvent) + { + case EContextEventNone: + break; + case EContextEventActivate: + if(iState==RPacketContext::EStatusActivating) + { + TInt activateValue; + if (found) + activateValue = iContextConfigsRel99->At(i).iActivateErrorCode; + else + activateValue = iActivateFail; + + if(activateValue != KErrNone) + { + ReqCompleted(iActivateRequestHandle,activateValue); + ret=ChangeState(RPacketContext::EStatusInactive); + iCurrentEvent=EContextEventNone; + activateValue = KErrNone; + + if (found) + iContextConfigsRel99->At(i).iActivateErrorCode = activateValue; + else + iActivateFail = activateValue; + break; + } + else + { + if (found) + { + if (iContextConfigsRel99->At(i).iConnectToNtRas) + { + ret = DoActivate(); + if (ret == KErrNone) + iCurrentEvent=EContextEventNtRas; + else + iCurrentEvent=EContextEventNone; + } + else + { + iCurrentEvent=EContextEventNone; + ReqCompleted(iActivateRequestHandle,activateValue); + ret=ChangeState(RPacketContext::EStatusActive); + iIsActive = ETrue; + } + } + else + { + ret = DoActivate(); + if (ret == KErrNone) + iCurrentEvent=EContextEventNtRas; + else + iCurrentEvent=EContextEventNone; + } + } + } + break; + case EContextEventDeactivate: + TInt deActivateValue; + if (found) + deActivateValue = iContextConfigsRel99->At(i).iDeactivateErrorCode; + else + deActivateValue = iDeactivateFail; + + if(iState==RPacketContext::EStatusDeactivating) + { + if(deActivateValue != KErrNone) + { + ReqCompleted(iDeactivateRequestHandle,deActivateValue); + ret=ChangeState(RPacketContext::EStatusActive); + deActivateValue = KErrNone; + + if (found) + iContextConfigsRel99->At(i).iDeactivateErrorCode = deActivateValue; + else + iDeactivateFail = deActivateValue; + break; + } + else { + ret=ChangeState(RPacketContext::EStatusInactive); + if(ret==KErrNone) + { + ret = DoDeactivate(); + if(ret==KErrNone) + { + ReqCompleted(iDeactivateRequestHandle,deActivateValue); + iIsActive=EFalse; + } + else + ReqCompleted(iDeactivateRequestHandle,ret); + } + else + ReqCompleted(iDeactivateRequestHandle,ret); + } + } + iCurrentEvent=EContextEventNone; + break; + case EContextEventDelete: + TInt deleteValue; + if (found) + deleteValue = iContextConfigsRel99->At(i).iDeletionErrorCode; + else + deleteValue = iDeleteFail; + + if(iState==RPacketContext::EStatusInactive) + { + if(deleteValue != KErrNone) + { + ReqCompleted(iDeleteRequestHandle,deleteValue); + deleteValue = KErrNone; + if (found) + iContextConfigsRel99->At(i).iDeletionErrorCode = deleteValue; + else + iDeleteFail = deleteValue; + break; + } + else { + ret=ChangeState(RPacketContext::EStatusDeleted); + if(ret==KErrNone) + { + ret = DoDelete(); + if(ret==KErrNone) + ReqCompleted(iDeleteRequestHandle,deleteValue); + else + ReqCompleted(iDeleteRequestHandle,ret); + } + else + ReqCompleted(iDeleteRequestHandle,ret); + } + } + iCurrentEvent=EContextEventNone; + break; + default: //in case of EContextEventTimeOut + break; + } + break; + + default: + break; + } + return ret; + } + +const CTestConfigSection* CSimPacketContext::CfgFile() +/** +* Return a pointer to the Configuration File Section +* +* @return CTestConfigSection pointer to the configuration file section +*/ + { + return iPacketService->CfgFile(); + } + +TInt CSimPacketContext::ModifyActiveContext(const TTsyReqHandle aTsyReqHandle) + { + if (iState==RPacketContext::EStatusInactive) + { + ReqCompleted(aTsyReqHandle, KErrNotReady); + return KErrNone; + } + + // check if QoS profile has changed or TFTs have changed + if (iPacketqos != NULL) + { + if (iPacketqos->PerformProfileChange() == KErrNone || iTFTChangeBool) + { + iTFTChangeBool = EFalse; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + else + { + ReqCompleted(aTsyReqHandle, KErrNotReady); + return KErrNone; + } + } + else if (iTFTChangeBool) + { + iTFTChangeBool = EFalse; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + else + { + ReqCompleted(aTsyReqHandle, KErrNotReady); + return KErrNone; + } + } + +/** +* This function enumerates the number of packet filters +*/ +TInt CSimPacketContext::EnumeratePacketFilters(const TTsyReqHandle aTsyReqHandle, TInt& aCount) + { + aCount = iNumFiltersAdded; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +/** +* This function returns info regarding the packet filter specified by the index passed - +* used in conjunction with EnumeratePacketFilters() +*/ +TInt CSimPacketContext::GetPacketFilterInfoL(const TTsyReqHandle aTsyReqHandle, TInt aIndex, TDes8* aPacketFilterInfo) + { + // if index is invalid, return error code + if (aIndex < 0 || aIndex > (iNumFiltersAdded -1)) + { + ReqCompleted(aTsyReqHandle, KErrArgument); + return KErrNone; + } + else + { + TInt ii; + TInt addedFilterCount = -1; + + //find the requested filter + for(ii = 0; ii < iPacketFilterInfoArray->Count(); ii++) + { + if(iPacketFilterInfoArray->At(ii).iAdded) + { + addedFilterCount++; + + //when the filter is found write the data to the client + if(addedFilterCount == aIndex) + { + TPacketFilterV3 theFilter = iPacketFilterInfoArray->At(ii); + + // Check that the data structure is supported by the simulated TSY version + TInt err = KErrNone; + if(iPhone->iSimTsyVersion < 3) // same version as TPacketFilterVx + { + (void)User::Leave(KErrNotSupported); + } + + RPacketContext::TPacketFilterV2Pckg* clientFilterPckg = + (RPacketContext::TPacketFilterV2Pckg*)aPacketFilterInfo; + RPacketContext::TPacketFilterV2& clientFilter = (*clientFilterPckg)(); + + // Check that the data structure is supported by the simulated TSY version + err = iPhone->CheckSimTsyVersion(clientFilter); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + if(clientFilter.ExtensionId()==KETelExtPcktV2) + { + clientFilter.iDestPortMax = theFilter.iDestPortMax; + clientFilter.iDestPortMin = theFilter.iDestPortMin; + clientFilter.iEvaluationPrecedenceIndex = theFilter.iEvaluationPrecedenceIndex; + clientFilter.iFlowLabel = theFilter.iFlowLabel; + clientFilter.iId = theFilter.iId; + clientFilter.iIPSecSPI = theFilter.iIPSecSPI; + clientFilter.iProtocolNumberOrNextHeader = theFilter.iProtocolNumberOrNextHeader; + clientFilter.iSrcPortMax = theFilter.iSrcPortMax; + clientFilter.iSrcPortMin = theFilter.iSrcPortMin; + clientFilter.iTOSorTrafficClass = theFilter.iTOSorTrafficClass; + + TInt xx; + for(xx = 0; xxCheckSimTsyVersion(clientFilterV3); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + RPacketContext::TPacketFilterV3 filterV3(theFilter.iFilterType); + + // Check that the data structure is supported by the simulated TSY version + err = iPhone->CheckSimTsyVersion(filterV3); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + filterV3.iId = theFilter.iId; + filterV3.iEvaluationPrecedenceIndex = theFilter.iEvaluationPrecedenceIndex; + filterV3.SetTOSorTrafficClass(theFilter.iTOSorTrafficClass); + + TInt yy; + for(yy = 0; yyAt(ii).iAdded) + else + { + continue; + } + + }//end for loop + //filter was not found + ReqCompleted(aTsyReqHandle, KErrCorrupt); + return KErrNone; + }//end else + } + +/** +* Create TFT +*/ +TInt CSimPacketContext::CreateNewTFT(const TTsyReqHandle aTsyReqHandle, const TInt* aSize) + { + if (iCreateTftConfig.iNumberOfFailures > 0) + { + iCreateTftConfig.iNumberOfFailures--; + ReqCompleted(aTsyReqHandle, iCreateTftConfig.iFailErrorCode); + return KErrNone; + } + iCreateTftTimer->Start(iCreateTftConfig.iDelay, this, ETimerIdPcktContextCreateTft); + iCreateTftData.iTsyReqHandle = aTsyReqHandle; + iCreateTftData.iSize = *aSize; + return KErrNone; + } + +TInt CSimPacketContext::DoCreateNewTFT() + { + iTFTCreated = ETrue; + iNumTFTsCreated = iCreateTftData.iSize; + iTFTChangeBool = ETrue; + for (TInt i = 0; i < iPacketFilterInfoArray->Count(); i++) + { + iPacketFilterInfoArray->At(i).iAdded = EFalse; + } + iNumFiltersAdded = 0; + ReqCompleted(iCreateTftData.iTsyReqHandle, KErrNone); + return KErrNone; + } + +/** +* Delete TFT +*/ +TInt CSimPacketContext::DeleteTFT(const TTsyReqHandle aTsyReqHandle) + { + if (iDeleteTftFail.iNumberOfTimes > 0) + { + iDeleteTftFail.iNumberOfTimes--; + ReqCompleted(aTsyReqHandle, iDeleteTftFail.iFailErrorCode); + return KErrNone; + } + iTFTCreated = EFalse; + iNumTFTsCreated = -1; + iTFTChangeBool = ETrue; + for (TInt i = 0; i < iPacketFilterInfoArray->Count(); i++) + { + iPacketFilterInfoArray->At(i).iAdded = EFalse; + } + iNumFiltersAdded = 0; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +/** +* This method adds the packet filter to the array if it is not already there +*/ +TInt CSimPacketContext::AddPacketFilter(const TTsyReqHandle aTsyReqHandle, const TDesC8* aPacketFilterInfo) + { + if (iAddPacketFilter.iNumberOfTimes > 0) + { + iAddPacketFilter.iNumberOfTimes--; + ReqCompleted(aTsyReqHandle, iAddPacketFilter.iFailErrorCode); + return KErrNone; + } + + TPckg* packetFilter = (TPckg*)aPacketFilterInfo; + RPacketContext::TPacketFilterV2& packetFilterBase = (*packetFilter)(); + + // Check that the data structure is supported by the simulated TSY version + TInt err = iPhone->CheckSimTsyVersion(packetFilterBase); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + TBool found = EFalse; + + TInt ii; + for(ii = 0; iiCount(); ii++) + { + TPacketFilterV3& configFilter = iPacketFilterInfoArray->At(ii); + const TInt KReservedPortZero = 0; + + if((configFilter.iId == packetFilterBase.iId) && + (configFilter.iEvaluationPrecedenceIndex == packetFilterBase.iEvaluationPrecedenceIndex) && + (configFilter.iProtocolNumberOrNextHeader == packetFilterBase.iProtocolNumberOrNextHeader) && + (configFilter.iSrcPortMin == packetFilterBase.iSrcPortMin) && + (configFilter.iSrcPortMax == packetFilterBase.iSrcPortMax) && + ((configFilter.iDestPortMin == KReservedPortZero) || (configFilter.iDestPortMin == packetFilterBase.iDestPortMin)) && + ((configFilter.iDestPortMax == KReservedPortZero) || (configFilter.iDestPortMax == packetFilterBase.iDestPortMax)) && + (configFilter.iIPSecSPI == packetFilterBase.iIPSecSPI) && + (configFilter.iTOSorTrafficClass == packetFilterBase.iTOSorTrafficClass) && + (configFilter.iFlowLabel == packetFilterBase.iFlowLabel)) + { + TInt xx; + for(xx = 0; xx= KMaxNumberOfTftFilters ) + { + ReqCompleted(aTsyReqHandle, KErrOverflow); + return KErrNone; + } + iTFTChangeBool = ETrue; + configFilter.iAdded = ETrue; + iNumFiltersAdded++ ; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + } + } + ReqCompleted(aTsyReqHandle, KErrGeneral); + return KErrNone; + } + +/** +* This function removes the packet filter from the array if the packet filter is found in the array +*/ +TInt CSimPacketContext::RemovePacketFilter(const TTsyReqHandle aTsyReqHandle, TInt aId) + { + TInt total= iPacketFilterInfoArray->Count(); + TBool found = EFalse; + + for (TInt i = 0; iAt(i).iId == aId) && + (iPacketFilterInfoArray->At(i).iAdded)) + { + iPacketFilterInfoArray->At(i).iAdded = EFalse; + iNumFiltersAdded-- ; + ReqCompleted(aTsyReqHandle, KErrNone); + found = ETrue; + iTFTChangeBool = ETrue; + break; + } + } + + if (!found) + { + ReqCompleted(aTsyReqHandle, KErrArgument); + return KErrNone; + } + return KErrNone; + } + +/** +* This function initialises the context +*/ +TInt CSimPacketContext::InitialiseContext(const TTsyReqHandle aTsyReqHandle, TDes8* aDataChannelV2Pckg) + { + TCommSetupItem item = FindCommSettings(); + if (item.iNumInitializeFailures != 0) + { + item.iNumInitializeFailures--; + ReqCompleted(aTsyReqHandle, item.iErrorCode); + } + else + { + iInitContextData.iTsyReqHandle = aTsyReqHandle; + iInitContextData.iChannel = aDataChannelV2Pckg; + iInitContextTimer->Start(item.iDelay, this, ETimerIdPcktContextInitContext); + } + return KErrNone; + } + +TInt CSimPacketContext::DoInitialiseContext() + { + RPacketContext::TDataChannelV2Pckg* channel = (RPacketContext::TDataChannelV2Pckg*)iInitContextData.iChannel; + RPacketContext::TDataChannelV2& channelV2 = (*channel)(); + + // Check that the data structure is supported by the simulated TSY version + TInt err = iPhone->CheckSimTsyVersion(channelV2); + if(err != KErrNone) + { + ReqCompleted(iInitContextData.iTsyReqHandle, err); + return KErrNone; + } + + TCommSetupItem item = FindCommSettings(); + channelV2.iPort = item.iPortName; + channelV2.iCsy = item.iCsyName; + channelV2.iChannelId = item.iPortName; + + ReqCompleted(iInitContextData.iTsyReqHandle, KErrNone); + + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::EnumeratePacketFiltersCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::GetPacketFilterInfoCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::AddPacketFilterCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::CreateNewTFTCancel(const TTsyReqHandle aTsyReqHandle) + { + iCreateTftTimer->Cancel(); + + ReqCompleted(aTsyReqHandle, KErrCancel); + + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::DeleteTFTCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::RemovePacketFilterCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::ModifyActiveContextCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketContext::InitialiseContextCancel(const TTsyReqHandle aTsyReqHandle) + { + iInitContextTimer->Cancel(); + + ReqCompleted(aTsyReqHandle, KErrCancel); + + return KErrNone; + } + +CSimPacketContext::TCommSetupItem CSimPacketContext::FindCommSettings() + { + TInt count=iCommSetupArray->Count(); + TCommSetupItem def; + + //Do a default initialization. + def.iCsyName.Copy(KDefaultCsyName); + def.iPortName.Copy(KDefaultPortName); + def.iConfig.iRate=KDefaultCommPortRate; + def.iConfig.iHandshake=KDefaultHandshake; + def.iContextName=KDefaultSetting; + def.iCommReset = EFalse; + def.iNumInitializeFailures = 0; + def.iErrorCode = KErrNone; + def.iDelay = 0; + + for(TInt i=0; iAt(i); + if(comm.iContextName.Compare(iContextName)==KErrNone) + return comm; + if(comm.iContextName.Compare(KDefaultSetting)==KErrNone) + def=comm; + } + return def; + } + +TName CSimPacketContext::ContextName() const + { + return iContextName; + } + +TInt CSimPacketContext::GetDnsInfo(const TTsyReqHandle aTsyReqHandle, const TDesC8* aDnsInfo) + { +/** + * GetDnsInfo method to extract DNS server names from context + * + * @param aStatus TRequestStatus object with which error code is returned + * @param aDnsInfo packaged TDnsInfoV2 object passed as TDes8 + * + * GetDNSInfo() is needed when the client uses dynamic IPv4 PDP addresses. + * After the context is activated the client needs to know the actual primary + * and secondary DNS addresses to use when sending packet data. As the network + * may have supplied these addresses there is a need for an API method to get + * these addresses from the TSY. + */ + RPacketContext::TTDnsInfoV2Pckg* dnsInfoV2Pckg = (RPacketContext::TTDnsInfoV2Pckg*)aDnsInfo; + RPacketContext::TDnsInfoV2& dnsInfoV2 = (*dnsInfoV2Pckg)(); + + // Check that the data structure is supported by the simulated TSY version + TInt err = iPhone->CheckSimTsyVersion(dnsInfoV2); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + TContextConfigParam config = iContextConfigParams->At(iContextConfigParamsIndex); + + dnsInfoV2.iPrimaryDns.Copy(config.iProtocolConfigOption.iPrimaryDNS); + dnsInfoV2.iSecondaryDns.Copy(config.iProtocolConfigOption.iSecondaryDNS); + + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketContext::GetDnsInfoCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** + * GetDnsInfoCancel - Cancels an asynchronous GetDnsInfo method. + */ + { + return KErrNone; + } + +TInt CSimPacketContext::GetAddMediaAuthorization(const TTsyReqHandle aTsyReqHandle, TDes8* aBuffer) +/** + * GetAddMediaAuthorization method to verify provided media authorization and return desired result + * + * @param aTsyReqHandle The request handle for completing the request + * @param aBuffer Packaged CTFTMediaAuthorizationV3 object passed as TDes8 + * + * GetAddMediaAuthorization() checks the provided media authorization against a predefined authorization + * set up from the configuration file. If the authorization is valid the function will return the desired + * response, also set up from the configuration file. If there is a mismatch between authorizations, KErrCorrupt + * returned. + */ + { + TBool validMediaAuthorization = TRUE; + RPacketContext::CTFTMediaAuthorizationV3* mediaAuthV3 = NULL; + + // Check that the data structure is supported by the simulated TSY version + TInt err = iPhone->CheckSimTsyVersion(*mediaAuthV3); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + TRAPD(ret, mediaAuthV3 = RPacketContext::CTFTMediaAuthorizationV3::NewL()); + if (ret != KErrNone) + { + LOGPACKET1("CSimPacketContext::GetAddMediaAuthorization NewL call fail"); + return ret; + } + + TRAP(ret, mediaAuthV3->InternalizeL(*aBuffer) ); + if (ret != KErrNone) + { + delete mediaAuthV3; + LOGPACKET1("CSimPacketContext::GetAddMediaAuthorization InternalizeL call fail"); + return ret; + } + + for (TUint i=0; iCount(); i++) + { + if (!(mediaAuthV3->iAuthorizationToken).Compare(iAuthorizationTokenResponse->At(i).iAuthorizationToken)) + { + for (TUint j=0; jAt(i).iFlowIds.Count(); j++) + { + if ((mediaAuthV3->iFlowIds[j].iMediaComponentNumber != iMediaAuthorization->At(i).iFlowIds[j].iMediaComponentNumber) || + (mediaAuthV3->iFlowIds[j].iIPFlowNumber != iMediaAuthorization->At(i).iFlowIds[j].iIPFlowNumber)) + { + validMediaAuthorization = FALSE; + } + } + if (validMediaAuthorization) + { + ReqCompleted(aTsyReqHandle,iAuthorizationTokenResponse->At(i).iResponse); + delete mediaAuthV3; + return KErrNone; + } + } + } + + // No match found, respond with corrupted + ReqCompleted(aTsyReqHandle,KErrCorrupt); + delete mediaAuthV3; + + return KErrNone; + } + +TInt CSimPacketContext::GetRemoveMediaAuthorization(const TTsyReqHandle aTsyReqHandle, RPacketContext::TAuthorizationToken* aAuthorizationToken) +/** + * GetRemoveMediaAuthorization method to verify provided media authorization and return desired result + * + * @param aTsyReqHandle The request handle for completing the request + * @param aAuthorizationToken Authorization token to be checked + * + * GetRemoveMediaAuthorization() checks the provided authorization token against predefined tokens and responses + * from config file. If a match is found the associated desired response is returned, otherwise KErrCorrupt is reported. + */ + { + for (TUint i=0; iCount(); i++) + { + if (!((*aAuthorizationToken).Compare(iAuthorizationTokenResponse->At(i).iAuthorizationToken))) + { + ReqCompleted(aTsyReqHandle,iAuthorizationTokenResponse->At(i).iResponse); + return KErrNone; + } + } + + // No match found, respond with corrupted + ReqCompleted(aTsyReqHandle,KErrCorrupt); + return KErrNone; + } + +TInt CSimPacketContext::GetAddMediaAuthorizationCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancel method, returns KErrNone +*/ + { + return KErrNone; + } + +TInt CSimPacketContext::GetRemoveMediaAuthorizationCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancel method, returns KErrNone +*/ + { + return KErrNone; + } + +