diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/src/CSimPacketService.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simtsy/src/CSimPacketService.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,3931 @@ +// Copyright (c) 2001-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: +// implementattion for CSimPacketService Class +// This file contains the implementation of the Similator TSY Packet Service functionality. +// CSimPacketService class provides a simulated packet-switched connection to a packet +// (GPRS and CDMA) network. +// +// + +/** + @file +*/ + +#include "CSimPacketService.h" +#include "Simlog.h" +#include +#include "CSimPhone.h" +#include "utils.h" +#include "CSimPacketContext.h" +#include "CSimPubSubChange.h" + + +#include "CSimIncomingContextManager.h" + + +_LIT(KApn, "ACME INTERNET PROVIDERS LTD"); +_LIT(KProtocolAddress, "i-MODE GATEWAY"); +_LIT(KUsername, "USER1"); +_LIT(KPassword, "PASSWORD1"); +_LIT(KChallenge, "CHALLENGE1"); +_LIT(KResponse, "RESPONSE1"); +_LIT(KPrimaryDNS, "PRIMARYSERVER1"); +_LIT(KSecondaryDNS, "SECONDARYSERVER1"); + + +// enum for caps +const TUint KPacketServiceCaps=(RPacketService::KCapsSuspendSupported | + RPacketService::KCapsMSClassSupported | + RPacketService::KCapsCDMA2000HighSpeedDataSupported | + RPacketService::KCapsNetworkAvailabilitySupported | + RPacketService::KCapsProtocolPPPSupported | + RPacketService::KCapsHSDPASupported | + RPacketService::KCapsEGPRSSupported | + RPacketService::KCapsHSUPASupported ); + +CSimPacketService* CSimPacketService::NewL(CSimPhone* aPhone) +/** +* Standard two phase constructor +* +* @param aPhone Pointer to the phone object (CSimPhone) +* @return CSimPacketService pointer to the packet service object created. +* @leave Leaves if no memory or object is not created for any reason. +*/ + { + CSimPacketService* simPacket=new(ELeave) CSimPacketService(aPhone); + CleanupStack::PushL(simPacket); + simPacket->ConstructL(); + CleanupStack::Pop(); + return simPacket; + } + +void CSimPacketService::Init() + {} + +CSimPacketService::CSimPacketService(CSimPhone* aPhone) + : iPhone(aPhone), iContextCount(0), iPrimaryContextNameInc(0), + iSecondaryContextNameInc(0), iAttachMode(RPacketService::EAttachWhenNeeded), + iCurrentEvent(EPacketEventNone), iPacketReleaseModeIndex(0), + iPcktTimerBool(EFalse), iCurrentPrimaryContextIndex(0) +/** +* Trivial Constructor. Initialises all the data members +* +* @param aPhone pointer to the phone object that owns this class. +*/ + { + iState=RPacketService::EStatusUnattached; + iMSClass = RPacketService::EMSClassSuspensionRequired; + iNotifyStatusChange.iNotifyPending = EFalse; + iNotifyContextAdded.iNotifyPending = EFalse; + iNotifyChangeOfNtwk.iNotifyPending = EFalse; + iNotifyMSClassChange.iNotifyPending = EFalse; + iNotifyChangeOfReleaseMode.iNotifyPending=EFalse; + iNotifyChangeOfAttachMode.iNotifyPending=EFalse; + iNotifyDynamicCapsChange.iNotifyPending = EFalse; + iNotifyMbmsNetworkStatusChange.iNotifyPending = EFalse; + iNotifyMbmsServAvailChange.iNotifyPending = EFalse; + iSecondaryContext = EFalse; + } + + +void CSimPacketService::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. +* @panic Panics with SIMTSY EInvalidParameterFormatInConfigFile if an additional param data item is in an invalid format +*/ + { + LOGPACKET1("CSimPacketService: Entered ConstructL()"); + + iTimer = CSimTimer::NewL(iPhone); + iPcktRegTimer = CSimTimer::NewL(iPhone); + iNtwkRegTimer = CSimTimer::NewL(iPhone); + iReleaseModeTimer = CSimTimer::NewL(iPhone); + iDynamicCapsTimer = CSimTimer::NewL(iPhone); + iMbmsPcktTimer = CSimTimer::NewL(iPhone); + iMutex.CreateGlobal(KNullDesC, EOwnerProcess); + + iNtwkRegStatusInfo = new(ELeave) CArrayFixFlat(KGranularity); + iPcktRegStatusInfo=new(ELeave) CArrayFixFlat(KGranularity); + iPacketReleaseModeArray=new (ELeave) CArrayFixFlat(KGranularity); + iDynamicCapsArray = new (ELeave) CArrayFixFlat(KGranularity); + iSecondaryContextCountArray = new(ELeave)CArrayFixFlat(KGranularity); + iMbmsBroadcastParamsArray = new(ELeave)CArrayFixFlat(KGranularity); + iMbmsMonitorListParamsArray = new(ELeave)CArrayFixFlat(KGranularity); + iMbmsServicesList = new CArrayPtrFlat(1); + + iNtwkRegStatusChangeProperty = CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimtsyPacketServiceNtwkRegStatusChange, KPSSimtsyPacketServiceNtwkRegStatusChangeKeyType); + iNtwkRegStatusChange = CSimPubSub::NewL(this,iNtwkRegStatusChangeProperty); + iNtwkRegStatusChange->Start(); + + iMbmsActivation = CSimPubSubChange::NewL(this,CSimPubSub::TPubSubProperty(KUidPSSimTsyCategory, KPSSimTsyMbmsService, KPSSimTsyMbmsServiceType)); + + const CTestConfigItem* item=NULL; + TInt ret=KErrNone; + + item=CfgFile()->Item(KAttachPauseDuration); //< Retrieves the attach pause duration number from the config file + if(item) + { + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iAttachPause); + if(ret!=KErrNone) + iAttachPause = KDefaultPauseDuration; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iAttachFail); + if(ret==KErrNotFound) + iAttachFail = KErrNone; + } + + item=CfgFile()->Item(KDetachPauseDuration); //< Retrieves the detach pause duration number from the config file + if(item) + { + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,iDetachPause); + if(ret!=KErrNone) + iDetachPause = KDefaultPauseDuration; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,iDetachFail); + if(ret==KErrNotFound) + iDetachFail = KErrNone; + } + + TInt count=CfgFile()->ItemCount(KPacketRegStatus); //< Retrieves the packet registration info + item=NULL; + TInt i; + for(i=0;iItem(KPacketRegStatus,i); + if(!item) + break; + + TInt time,regState; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,time); + if(ret!=KErrNone) + break; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,regState); + if(ret!=KErrNone) + break; + + TPacketRegStatus status; + status.iDuration=time; + status.iStatus=(RPacketService::TStatus)regState; + TRAP_IGNORE(iPcktRegStatusInfo->AppendL(status)); + } + + iNtwkRegStatusNotificationType = ETimer; + item=CfgFile()->Item(KNetworkRegStatusType); + if(item) + { + TPtrC8 networkRegStatusType; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,networkRegStatusType); + if(ret==KErrNone && networkRegStatusType.Compare(KNotificationTypePublishSubscribe)==0) + { + iNtwkRegStatusNotificationType = EPublishAndSubscribe; + } + } + + count=CfgFile()->ItemCount(KNetworkRegStatus); //< Retrieves the packet registration info + item=NULL; + for(i=0;iItem(KNetworkRegStatus,i); + if(!item) + break; + + TInt time,regState; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,time); + if(ret!=KErrNone) + break; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,regState); + if(ret!=KErrNone) + break; + + TNtwkRegStatus status; + status.iDuration=time; + status.iRegStatus=(RPacketService::TRegistrationStatus)regState; + TRAP_IGNORE(iNtwkRegStatusInfo->AppendL(status)); + } + + if(iPcktRegStatusInfo->Count()!=0) + { + iPcktRegStatIndex=0; + iState=(RPacketService::TStatus)iPcktRegStatusInfo->At(0).iStatus; + iPcktRegTimer->Start(iPcktRegStatusInfo->At(0).iDuration,this,ETimerIdPcktServPacket); + } + + if(iNtwkRegStatusInfo->Count()!=0) + { + iCurrentRegStatus=(RPacketService::TRegistrationStatus)iNtwkRegStatusInfo->At(0).iRegStatus; + if (iNtwkRegStatusNotificationType == ETimer) + { + iNtwkRegStatIndex=0; + iNtwkRegTimer->Start(iNtwkRegStatusInfo->At(0).iDuration,this,ETimerIdPcktServNtwkStatusChange); + } + } + + //< Read in all dynamic capabilities data + count = CfgFile()->ItemCount(KDynamicCaps); + item = NULL; + for (i = 0; i < count; ++i) + { + item = CfgFile()->Item(KDynamicCaps,i); + if (!item) + break; + + TInt duration(0); + TInt dynamicCaps(0); + ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration); + if (ret != KErrNone) + break; + ret = CTestConfig::GetElement(item->Value(),KStdDelimiter,1,dynamicCaps); + if (ret != KErrNone) + break; + + TPacketDynamicCaps dynamicCapsData; + dynamicCapsData.iDuration = duration; + dynamicCapsData.iDynamicCaps = dynamicCaps; + + TRAP_IGNORE(iDynamicCapsArray->AppendL(dynamicCapsData)); + } + + if (iDynamicCapsArray->Count() != 0) + { + iDynamicCapsIndex = 0; + TPacketDynamicCaps initialCaps = iDynamicCapsArray->At(0); + iCurrentDynamicCaps = initialCaps.iDynamicCaps; + iDynamicCapsTimer->Start(initialCaps.iDuration, this, ETimerIdPcktServDynamicCaps); + } + // end of dynamic caps simulation setup + + //< Read in all the data for getting the default GPRS configuration parameters + + item = CfgFile()->Item(KDefaultContextparamGPRS); + if(item) + { + TInt protocolType,pdpCompression, anonymousAccess, useEdge; + TPtrC8 gsnAddress, protocolAddress; + TInt protocol; + TPtrC8 username,password, challenge, response, primaryDNS, secondaryDNS, iMiscBuffer; + TInt id, numAdditionalParams; + + iGPRSDefaultConfig.iProtocolConfigOption.iMiscBuffer.Zero(); + + TPtr8 pcoPtr(const_cast(iGPRSDefaultConfig.iProtocolConfigOption.iMiscBuffer.Ptr()), + RPacketContext::KMiscProtocolBufferLength); + + // Attach TTlv to the buffer + TTlvStruct tlvStruct(pcoPtr,0); + + RPacketContext::TPcoId pcoId; + + TUint itemOffSet = 0; // Used for nested Addional Param items + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,protocolType); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolType = protocolType; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,gsnAddress); + if(ret==KErrNone) + iGPRSDefaultConfig.iGsnAddress.Set(gsnAddress); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,protocolAddress); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolAddress.Set(protocolAddress); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,pdpCompression); + if(ret==KErrNone) + iGPRSDefaultConfig.iPdpCompression = pdpCompression; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,anonymousAccess); + if(ret==KErrNone) + iGPRSDefaultConfig.iAnonymousAccess = anonymousAccess; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,useEdge); + if(ret==KErrNone) + iGPRSDefaultConfig.iUseEdge = useEdge; + + // Protocol configuration and DNS server parameters added + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,protocol); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iAuthProtocol = protocol; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,username); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iUsername.Set(username); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,password); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iPassword.Set(password); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,challenge); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iChallenge.Set(challenge); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,response); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iResponse.Set(response); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,primaryDNS); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iPrimaryDNS.Set(primaryDNS); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,secondaryDNS); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iSecondaryDNS.Set(secondaryDNS); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,id); + if(ret==KErrNone) + iGPRSDefaultConfig.iProtocolConfigOption.iId = id; + + //Get the Additional Params List + //Get the number of items in the Additional Params List + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,numAdditionalParams); + if(ret==KErrNone) + { + TInt nestedItemNumber; + TUint16 digit, format; + const CTestConfigItem* item2; + + for(nestedItemNumber=itemOffSet; nestedItemNumberItem(KDefaultGPRSAdditionalParamItem, nestedItemNumber); + + if(item2) + { + TPtrC8 additionalParamId, additionalParamContent, additionalParamDataFormat; + + // Get ID + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,additionalParamId); + if(ret==KErrNone) + { + if(AsciiToNum(additionalParamId, digit)==KErrNone) + { + pcoId.SetId(digit); + } + } + + // Read AdditionalParamDataFormat field to find out how + // to interpret data in the AdditionalParamData field + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,2,additionalParamDataFormat); + if (ret != KErrNone) + { + // AdditionalParamDataFormat not been specified, + // default to plain ASCII + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",ret,2,&KDefaultGPRSAdditionalParamItem); + format = EConfigDataFormatAscii; + } + else + { + if (AsciiToNum(additionalParamDataFormat, format) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultGPRSAdditionalParamItem); + format = EConfigDataFormatAscii; + } + + // Check that the AdditionalParamDataFormat value + // specified in the config file is a valid one, + // default to ASCII if not. + if (format >= EMaxConfigDataFormat) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultGPRSAdditionalParamItem); + format = EConfigDataFormatAscii; + } + } + + // Get AdditionalParamData + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,additionalParamContent); + if(ret==KErrNone) + { + // Add AdditionalParamData to PCO buffer depending on format + switch (format) + { + case EConfigDataFormatMixedBinaryAndAscii: + { + // Parse the string here + // Will store the parsed data when algorithm has completed + TBuf8 additionalParamDataBuffer; + additionalParamDataBuffer.Copy (additionalParamContent); + + if (ParseMixedBinaryAsciiDataL(additionalParamDataBuffer) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamContent",KErrArgument,1,&KDefaultGPRSAdditionalParamItem); + SimPanic(EInvalidParameterFormatInConfigFile); + } + + TPtr8 paramPtr(const_cast(additionalParamDataBuffer.Ptr()), + additionalParamDataBuffer.Length(), additionalParamDataBuffer.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + } // case EAdditionalParamDataFormatMixedBinaryAndAscii + break; + case EConfigDataFormatAscii: + default: + TPtr8 paramPtr(const_cast(additionalParamContent.Ptr()), + additionalParamContent.Length(), additionalParamContent.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + break; + } // switch (format) + + iGPRSDefaultConfig.iProtocolConfigOption.iMiscBuffer.SetLength(pcoPtr.Length()); + } // if (ret == KErrNone) + } + } + + itemOffSet= itemOffSet + numAdditionalParams;; + } + else + { + LOGPARSERR("ProtocolConfigOption::numAdditionalParams",ret,14,&KDefaultContextparamGPRS); + } + } + + //< Read in all the data for getting the default UMTS configuration parameters + item = CfgFile()->Item(KDefaultContextparamRel99); + if(item) + { + TInt protocolType,useEdge; + TPtrC8 gsnAddress, protocolAddress; + TInt protocol; + TPtrC8 username,password, challenge, response, primaryDNS, secondaryDNS, iMiscBuffer; + TInt id, numAdditionalParams; + + iR99_R4DefaultConfig.iProtocolConfigOption.iMiscBuffer.Zero(); + + TPtr8 pcoPtr(const_cast(iR99_R4DefaultConfig.iProtocolConfigOption.iMiscBuffer.Ptr()), + RPacketContext::KMiscProtocolBufferLength); + + // Attach TTlv to the buffer + TTlvStruct tlvStruct(pcoPtr,0); + + RPacketContext::TPcoId pcoId; + + TUint itemOffSet = 0; // Used for nested Addional Param items + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,protocolType); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolType = protocolType; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,gsnAddress); + if(ret==KErrNone) + iR99_R4DefaultConfig.iGsnAddress.Set(gsnAddress); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,protocolAddress); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolAddress.Set(protocolAddress); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,useEdge); + if(ret==KErrNone) + iR99_R4DefaultConfig.iUseEdge = useEdge; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,protocol); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iAuthProtocol = protocol; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,username); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iUsername.Set(username); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,password); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iPassword.Set(password); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,challenge); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iChallenge.Set(challenge); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,response); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iResponse.Set(response); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,primaryDNS); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iPrimaryDNS.Set(primaryDNS); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,secondaryDNS); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iSecondaryDNS.Set(secondaryDNS); + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,id); + if(ret==KErrNone) + iR99_R4DefaultConfig.iProtocolConfigOption.iId = id; + + //Get the Additional Params List + //Get the number of items in the Additional Params List + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,numAdditionalParams); + if(ret==KErrNone) + { + TInt nestedItemNumber; + TUint16 digit, format; + const CTestConfigItem* item2; + + for(nestedItemNumber=itemOffSet; nestedItemNumberItem(KDefaultAdditionalParamItemRel99, nestedItemNumber); + + if(item2) + { + TPtrC8 additionalParamId, additionalParamContent, additionalParamDataFormat; + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,additionalParamId); + if(ret==KErrNone) + { + if(AsciiToNum(additionalParamId, digit)==KErrNone) + { + pcoId.SetId(digit); + } + } + + // Read AdditionalParamDataFormat field to find out how + // to interpret data in the AdditionalParamData field + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,2,additionalParamDataFormat); + if (ret != KErrNone) + { + // AdditionalParamDataFormat not been specified, + // default to plain ASCII + LOGPARSERR("No AdditionalParamItem::additionalParamDataFormat",ret,2,&KDefaultAdditionalParamItemRel99); + format = EConfigDataFormatAscii; + } + else + { + if (AsciiToNum(additionalParamDataFormat, format) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultAdditionalParamItemRel99); + format = EConfigDataFormatAscii; + } + + // Check that the AdditionalParamDataFormat value + // specified in the config file is a valid one, + // default to ASCII if not. + if (format >= EMaxConfigDataFormat) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultAdditionalParamItemRel99); + format = EConfigDataFormatAscii; + } + } + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,additionalParamContent); + if(ret==KErrNone) + { + // Add AdditionalParamData to PCO buffer depending on format + switch (format) + { + case EConfigDataFormatMixedBinaryAndAscii: + { + // Parse the string here + // Will store the parsed data when algorithm has completed + TBuf8 additionalParamDataBuffer; + additionalParamDataBuffer.Copy (additionalParamContent); + + if (ParseMixedBinaryAsciiDataL(additionalParamDataBuffer) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamContent",KErrArgument,1,&KDefaultAdditionalParamItemRel99); + SimPanic(EInvalidParameterFormatInConfigFile); + } + + TPtr8 paramPtr(const_cast(additionalParamDataBuffer.Ptr()), + additionalParamDataBuffer.Length(), additionalParamDataBuffer.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + } // case EAdditionalParamDataFormatMixedBinaryAndAscii + break; + case EConfigDataFormatAscii: + default: + TPtr8 paramPtr(const_cast(additionalParamContent.Ptr()), + additionalParamContent.Length(), additionalParamContent.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + break; + } // switch (format) + iR99_R4DefaultConfig.iProtocolConfigOption.iMiscBuffer.SetLength(pcoPtr.Length()); + } + } + } + + itemOffSet= itemOffSet + numAdditionalParams;; + } + else + { + LOGPARSERR("ProtocolConfigOption::numAdditionalParams",ret,12,&KDefaultContextparamRel99); + } + + } + + //< Read in all the data for getting the default R5 configuration parameters + item = CfgFile()->Item(KDefaultContextParamRel5); + if(item) + { + TInt protocolType, useEdge, protocol, id; + TInt pdpDataCompression, pdpHeaderCompression, numAdditionalParams; + TPtrC8 gsnAddress, protocolAddress, username, password, challenge; + TPtrC8 response, primaryDNS, secondaryDNS, iMiscBuffer; + + iR5DefaultConfig.iProtocolConfigOption.iMiscBuffer.Zero(); + + TPtr8 pcoPtr(const_cast(iR5DefaultConfig.iProtocolConfigOption.iMiscBuffer.Ptr()), + RPacketContext::KMiscProtocolBufferLength); + + // Attach the TTlv to the buffer + TTlvStruct tlvStruct(pcoPtr,0); + + RPacketContext::TPcoId pcoId; + + TUint itemOffSet = 0; //Used for nested Addional Param items + + //Get the Protocol Type from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,protocolType); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolType = protocolType; + } + + //Get the GGSN Address from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,gsnAddress); + if(ret==KErrNone) + { + iR5DefaultConfig.iGsnAddress.Set(gsnAddress); + } + + //Get the ProtocolAddress from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,protocolAddress); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolAddress.Set(protocolAddress); + } + + //Get the UseEdge config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,useEdge); + if(ret==KErrNone) + { + iR5DefaultConfig.iUseEdge = useEdge; + } + + + //Get the Autorisation Protocol config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,protocol); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iAuthProtocol = protocol; + } + + + //Get the Username config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,username); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iUsername.Set(username); + } + + //Get the psword config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,password); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iPassword.Set(password); + } + + //Get the Challenge config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,challenge); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iChallenge.Set(challenge); + } + + //Get the Response config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,response); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iResponse.Set(response); + } + + //Get the Primary DNS config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,primaryDNS); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iPrimaryDNS.Set(primaryDNS); + } + + //Get the Secondary DNS config param from the config file + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,10,secondaryDNS); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iSecondaryDNS.Set(secondaryDNS); + } + + //Get the ID config param from the config file. + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,11,id); + if(ret==KErrNone) + { + iR5DefaultConfig.iProtocolConfigOption.iId = id; + } + + //Get the PDP Header Compression params + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,12,pdpHeaderCompression); + if(ret==KErrNone) + { + iR5DefaultConfig.iPdpHeaderCompression = pdpHeaderCompression; + } + + //Get the PDP Data compression params + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,13,pdpDataCompression); + if(ret==KErrNone) + { + iR5DefaultConfig.iPdpDataCompression = pdpDataCompression; + } + + + //Get the Additional Params List + //Get the number of items in the Additional Params List + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,14,numAdditionalParams); + if(ret==KErrNone) + { + TInt nestedItemNumber; + TUint16 digit, format; + const CTestConfigItem* item2; + + for(nestedItemNumber=itemOffSet; nestedItemNumberItem(KDefaultAdditionalParamItem, nestedItemNumber); + + if(item2) + { + TPtrC8 additionalParamId, additionalParamContent, additionalParamDataFormat; + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,0,additionalParamId); + if(ret==KErrNone) + { + if(AsciiToNum(additionalParamId, digit)==KErrNone) + { + pcoId.SetId(digit); + } + } + + // Read AdditionalParamDataFormat field to find out how + // to interpret data in the AdditionalParamData field + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,2,additionalParamDataFormat); + if (ret != KErrNone) + { + // AdditionalParamDataFormat not been specified, + // default to plain ASCII + LOGPARSERR("No AdditionalParamItem::additionalParamDataFormat",ret,2,&KDefaultAdditionalParamItem); + format = EConfigDataFormatAscii; + } + else + { + if (AsciiToNum(additionalParamDataFormat, format) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultAdditionalParamItem); + format = EConfigDataFormatAscii; + } + + // Check that the AdditionalParamDataFormat value + // specified in the config file is a valid one, + // default to ASCII if not. + if (format >= EMaxConfigDataFormat) + { + LOGPARSERR("AdditionalParamItem::additionalParamDataFormat",KErrArgument,2,&KDefaultAdditionalParamItem); + format = EConfigDataFormatAscii; + } + } + + ret=CTestConfig::GetElement(item2->Value(),KStdDelimiter,1,additionalParamContent); + if(ret==KErrNone) + { + // Add AdditionalParamData to PCO buffer depending on format + switch (format) + { + case EConfigDataFormatMixedBinaryAndAscii: + { + // Parse the string here + // Will store the parsed data when algorithm has completed + TBuf8 additionalParamDataBuffer; + additionalParamDataBuffer.Copy (additionalParamContent); + + if (ParseMixedBinaryAsciiDataL(additionalParamDataBuffer) != KErrNone) + { + LOGPARSERR("AdditionalParamItem::additionalParamContent",KErrArgument,1,&KDefaultAdditionalParamItem); + SimPanic(EInvalidParameterFormatInConfigFile); + } + + TPtr8 paramPtr(const_cast(additionalParamDataBuffer.Ptr()), + additionalParamDataBuffer.Length(), additionalParamDataBuffer.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + } // case EAdditionalParamDataFormatMixedBinaryAndAscii + break; + case EConfigDataFormatAscii: + default: + TPtr8 paramPtr(const_cast(additionalParamContent.Ptr()), + additionalParamContent.Length(), additionalParamContent.Length()); + tlvStruct.AppendItemL(pcoId, paramPtr); + + break; + } // switch (format) + iR5DefaultConfig.iProtocolConfigOption.iMiscBuffer.SetLength(pcoPtr.Length()); + } + } + } + + itemOffSet= itemOffSet + numAdditionalParams;; + } + } + + count=CfgFile()->ItemCount(KPacketReleaseMode); //< Retrieves the packet registration info + item=NULL; + for(i=0;iItem(KPacketReleaseMode,i); + if(!item) + break; + TInt release,duration; + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,release); + if(ret!=KErrNone) + break; + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,duration); + if(ret!=KErrNone) + break; + + TPacketReleaseMode releaseMode; + releaseMode.iDuration=duration; + releaseMode.iReleaseMode=release; + TRAP_IGNORE(iPacketReleaseModeArray->AppendL(releaseMode)); + } + + item=NULL; + count=CfgFile()->ItemCount(KMBMSBroadCastPacketServiceParams); //< Retrieves the Count of MBMS related information + + for(i=0;iItem(KMBMSBroadCastPacketServiceParams,i); //< Retrieves the MBMS related information + + TInt duration =0; + TInt status =0; + if(!item) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration); + if(ret!=KErrNone) + { + break; + } + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,status); + if(ret!=KErrNone) + { + status = EMbmsSupportUnknown; + } + + TMbmsBroadCastParams mbmsParams; + mbmsParams.iDuration = duration; + mbmsParams.iMbmsNetworkStatus = reinterpret_cast (status); + TRAP_IGNORE(iMbmsBroadcastParamsArray->AppendL(mbmsParams)); + } + + item=NULL; + count=CfgFile()->ItemCount(KMBMSBroadcastMonitorList); //< Retrieves the Count of MBMS related information + + for(i=0;iItem(KMBMSBroadcastMonitorList,i); //< Retrieves the MBMS related information + + TInt duration =0; + TInt mnc=0; + TInt mcc=0; + TInt serviceId=0; + TInt accessBearer=0; + TInt serviceMode=0; + TInt serviceAvailability=0; + TInt entryValid=0; + + if(!item) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,mcc); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,mnc); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,serviceId); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,accessBearer); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,serviceMode); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,serviceAvailability); + if(ret!=KErrNone) + { + break; + } + + ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,entryValid); + if(ret!=KErrNone) + { + entryValid = 0; //default Entry is Invalid + } + TMbmsMonitorListParams mbmsMonitorParams; + + mbmsMonitorParams.iDuration = duration; + mbmsMonitorParams.iMCC = mcc; + mbmsMonitorParams.iMNC = mnc; + mbmsMonitorParams.iServiceId = serviceId; + mbmsMonitorParams.iAccessBearer = reinterpret_cast (accessBearer); + mbmsMonitorParams.iServiceMode = reinterpret_cast (serviceMode); + mbmsMonitorParams.iAvailStatus = reinterpret_cast (serviceAvailability); + mbmsMonitorParams.iIsEntryValid = reinterpret_cast (entryValid); + + TRAP_IGNORE(iMbmsMonitorListParamsArray->AppendL(mbmsMonitorParams)); + + } + + if(iMbmsBroadcastParamsArray->Count()!=0) + { + iMbmsPcktTimer->Start(iMbmsBroadcastParamsArray->At(0).iDuration,this,ETimerIdMbmsPcktService); + } + else if (iMbmsMonitorListParamsArray->Count()!=0) + { + iMbmsPcktTimer->Start(iMbmsMonitorListParamsArray->At(0).iDuration,this,ETimerIdMbmsPcktService); + } + + if(iPacketReleaseModeArray->Count()!=0) + { + iPacketReleaseModeIndex = 0; + iCurrentPacketReleaseMode = iPacketReleaseModeArray->At(0).iReleaseMode; + iReleaseModeTimer->Start(iPacketReleaseModeArray->At(0).iDuration,this,ETimerIdPcktServReleaseMode); + } + iIncomingContextManager = CSimIncomingContextManager::NewL(iPhone, this); + iIncomingContextManager->LoadIncomingContextsL( KDelayIncomingContext() ); + iIncomingContextManager->SetUseTimerOn(); + } + + +CSimPacketService::~CSimPacketService() +/** +* Trivial Destructor +* Closes all CObject type objects and destroys all other objects created in the ConstructL() +* +*/ + { + LOGPACKET1("CSimPacketService: Entered destructor"); + + delete iIncomingContextManager; + + iMutex.Close(); + // delete nifs' contexts + int count = iNifWrappers.Count(); + + for(TInt i = 0; iDelete(0,iPcktRegStatusInfo->Count()); + delete iPcktRegStatusInfo; + } + + if(iNtwkRegStatusInfo != NULL) + { + iNtwkRegStatusInfo->Delete(0,iNtwkRegStatusInfo->Count()); + delete iNtwkRegStatusInfo; + } + + delete iTimer; + + delete iPcktRegTimer; + + delete iNtwkRegTimer; + + delete iReleaseModeTimer; + + delete iDynamicCapsTimer; + + delete iMbmsPcktTimer; + + if (iPacketReleaseModeArray != NULL) + { + iPacketReleaseModeArray->Delete(0,iPacketReleaseModeArray->Count()); + delete iPacketReleaseModeArray; + } + if (iDynamicCapsArray != NULL) + { + iDynamicCapsArray->Delete(0,iDynamicCapsArray->Count()); + delete iDynamicCapsArray; + } + + if (iSecondaryContextCountArray != NULL) + { + iSecondaryContextCountArray->Delete(0,iSecondaryContextCountArray->Count()); + delete iSecondaryContextCountArray; + } + + if(iMbmsBroadcastParamsArray != NULL) + { + iMbmsBroadcastParamsArray->Delete(0,iMbmsBroadcastParamsArray->Count()); + delete iMbmsBroadcastParamsArray; + } + + if(iMbmsMonitorListParamsArray != NULL) + { + iMbmsMonitorListParamsArray->Delete(0,iMbmsMonitorListParamsArray->Count()); + delete iMbmsMonitorListParamsArray; + } + + if(iMbmsServicesList) + { + iMbmsServicesList->ResetAndDestroy(); + } + delete iMbmsServicesList; + + // delete nifs' contexts + count = iMbmsNifWrappers.Count(); + + for(TInt i = 0; iContextName())==KErrNone) + { + iCurrentPrimaryContextIndex = i; + TInt err = packetContext->ReActivate(this,aName); + if(err != KErrNone) + { + User::Leave(err); + return NULL; + } + return packetContext; + } + } + } + + // if the control has reached here, then the context requested is not in the PDP context + // hence lets search in the list of MBMS contexts. + CSimMbmsPacketContext* pcktMbmsContext = NULL; + + counter = iMbmsNifWrappers.Count(); + + for(TInt i=0;iContextName())==KErrNone) + { + TInt err = pcktMbmsContext->ReActivate(this,aName); + if(err != KErrNone) + { + User::Leave(err); + return NULL; + } + return pcktMbmsContext; + } + } + } + + User::Leave(KErrNotFound); + return NULL; + } + +CTelObject* CSimPacketService::OpenNewObjectL(TDes& aNewName) +/** +* Creates a new CSimPacketContext object and returns a pointer to it. +* +* @param aName new name of the object created +* @return CTelObject pointer to the CSimPacketContext object created +* @leave Leaves if out of memory. +*/ + { + // Check whether the context creation is for MBMS of PDP context + + if(aNewName.Compare(_L("MBMS_CONTEXT"))== KErrNone) + { + // Processing for MBMS context creation starts + CSimMbmsPacketContext* pcktMbmsContext = NULL; + + TInt ctr = iMbmsNifWrappers.Count(); + TInt mbmsCnxtCount = 0; + for(TInt i=0;iContextStatus(); + if(tStat != RPacketContext::EStatusDeleted) + { + mbmsCnxtCount++; + } + } + } + if ( mbmsCnxtCount > KMaxMbmsContextSupportedByPhone ) + { + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending = EFalse; + ReqCompleted(iNotifyContextAdded.iNotifyHandle,KErrUmtsMaxNumOfContextExceededByPhone); + } + User::Leave(KErrNoMemory); + return NULL; + } + else if (mbmsCnxtCount > KMaxMbmsContextSupportedByNetwork) + { + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending = EFalse; + ReqCompleted(iNotifyContextAdded.iNotifyHandle,KMaxMbmsContextSupportedByNetwork); + } + User::Leave(KErrNoMemory); + return NULL; + } + + aNewName.AppendNum(++iMbmsContextNameInc); + pcktMbmsContext = CSimMbmsPacketContext::NewL(iPhone, this, aNewName); + CleanupStack::PushL(pcktMbmsContext); + + if(pcktMbmsContext->Open()==KErrNone) + { + TMbmsNifWrapper tMbmsNif; + tMbmsNif.AddContext(pcktMbmsContext); + iMbmsNifWrappers.Append(tMbmsNif); + } + iMbmsContextCount++; + + // Check for a pending line state notification. + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending=EFalse; + *(reinterpret_cast(iNotifyContextAdded.iNotifyData))=pcktMbmsContext->ContextName(); + ReqCompleted(iNotifyContextAdded.iNotifyHandle,KErrNone); + } + + CleanupStack::Pop(pcktMbmsContext); + return pcktMbmsContext; + + + } // End of MBMS Context processing. + + else + { + // Processing for PDP context creation starts + + // if there are more contexts than the maximum allowed, return error code + CSimPacketContext* packetContext = NULL; + + // go through every nif, and from there through every context in nif + TInt counter = iNifWrappers.Count(); + TInt contextCount=0; + + for(TInt i=0; iContextStatus(); + if(tstat != RPacketContext::EStatusDeleted) + contextCount++; + } + } + + if(contextCount >= KMaxContextPoolSize) + { + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending = EFalse; + ReqCompleted(iNotifyContextAdded.iNotifyHandle,KErrNoMemory); + } + User::Leave(KErrNoMemory); + return NULL; + } + + CSimPacketContext* newContext; + + // if this is not a secondary context, give the new context the primary + // context name increment + if (!iSecondaryContext) + { + aNewName.Append(KSimPacketPrimaryContextName); + aNewName.AppendNum(++iPrimaryContextNameInc); + + newContext = CSimPacketContext::NewL(iPhone, this, aNewName); + CleanupStack::PushL(newContext); + if (newContext->Open() == KErrNone) + { + TNifWrapper nif; + nif.AddContext(newContext); + iNifWrappers.Append(nif); + iCurrentPrimaryContextIndex = iNifWrappers.Count() - 1; + } + + // for every primary context, add an element in the array so that a count + // can be kept for each primary's secondary contexts + iSecondaryContextCountArray->AppendL(iCurrentPrimaryContextIndex); + iCurrentPrimaryContextIndex++; + } + else + { + // if this is a secondary context, name it accordingly + // and increment the count of the secondary's primary context + aNewName.Append(KSimPacketSecondaryContextName); + iSecondaryContextCountArray->At(iCurrentPrimaryContextIndex)++; + aNewName.AppendNum(iSecondaryContextCountArray->At(iCurrentPrimaryContextIndex)); + + newContext = CSimPacketContext::NewL(iPhone, this, aNewName); + CleanupStack::PushL(newContext); + + if(newContext->Open()==KErrNone) + { + iNifWrappers[iCurrentPrimaryContextIndex].AddContext(newContext); + iSecondaryContextNameInc++; // keep a global count of number of secondary contexts + } + } + iContextCount++; + + // Check for a pending line state notification. + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending=EFalse; + *(TName*)iNotifyContextAdded.iNotifyData=newContext->ContextName(); + ReqCompleted(iNotifyContextAdded.iNotifyHandle,KErrNone); + } + + // ie assume false until PrepareOpenSecondary() is called again + iSecondaryContext = EFalse; + CleanupStack::Pop(newContext); + return newContext; + } + } + +CTelObject::TReqMode CSimPacketService::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 EPacketAttach: + case EPacketDetach: + case EPacketRejectActivationRequest: + case EPacketSetMSClass: + case EPacketSetAttachMode: + case EPacketSetDefaultContextParams: + case EPacketGetStatus: + case EPacketGetContextInfo: + case EPacketGetNtwkRegStatus: + case EPacketGetMSClass: + case EPacketGetStaticCaps: + case EPacketGetDynamicCaps: + case EPacketGetAttachMode: + case EPacketGetDefaultContextParams: + case EPacketEnumerateContexts: + case EPacketGetCurrentReleaseMode: + case EPacketEnumerateNifs: + case EPacketGetNifInfo: + case EPacketEnumerateContextsInNif: + case EPacketGetContextNameInNif: + case EPacketPrepareOpenSecondary: + case EPacketGetMbmsNetworkServiceStatus: + case EPacketUpdateMbmsMonitorServiceList: + case EPacketGetMbmsMonitoredServicesPhase1: + case EPacketGetMbmsMonitoredServicesPhase2: + case EPacketEnumerateMbmsMonitorServiceList: + case EPacketEnumerateMbmsActiveServiceList: + break; + + case EPacketNotifyContextAdded: + case EPacketNotifyStatusChange: + case EPacketNotifyContextActivationRequested: + case EPacketNotifyChangeOfNtwkRegStatus: + case EPacketNotifyMSClassChange: + case EPacketNotifyDynamicCapsChange: + case EPacketNotifyReleaseModeChange: + case EPacketNotifyAttachModeChange: + case EPacketNotifyMbmsNetworkServiceStatusChange: + case EPacketNotifyMbmsServiceAvailabilityChange: + ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately; + break; + + default: + User::Leave(KErrNotSupported); + break; + } + return ret; + } + +RHandleBase* CSimPacketService::GlobalKernelObjectHandle() +/** +* Implements CSubSessionExtBase virtual method, which provides +* handle of the mutex object to etel server that passes it up to clients. +* @return pointer to synchronisation mutex object +*/ + { + return &iMutex; + } + +TInt CSimPacketService::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 EPacketNotifyContextAdded: + case EPacketNotifyStatusChange: + case EPacketNotifyContextActivationRequested: + case EPacketNotifyChangeOfNtwkRegStatus: + case EPacketNotifyMSClassChange: + case EPacketNotifyDynamicCapsChange: + case EPacketNotifyReleaseModeChange: + case EPacketNotifyAttachModeChange: + case EPacketNotifyMbmsNetworkServiceStatusChange: + case EPacketNotifyMbmsServiceAvailabilityChange: + LOGPACKET1("CSimPacketService: RegisterNotification"); + return KErrNone; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketService: Register error, unknown IPC"); + return KErrNotSupported; + } + } + +TInt CSimPacketService::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 EPacketNotifyContextAdded: + case EPacketNotifyStatusChange: + case EPacketNotifyContextActivationRequested: + case EPacketNotifyChangeOfNtwkRegStatus: + case EPacketNotifyMSClassChange: + case EPacketNotifyDynamicCapsChange: + case EPacketNotifyReleaseModeChange: + case EPacketNotifyAttachModeChange: + case EPacketNotifyMbmsNetworkServiceStatusChange: + case EPacketNotifyMbmsServiceAvailabilityChange: + LOGPACKET1("CSimPacketService: DeregisterNotification"); + return KErrNone; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketService: Deregister error, unknown IPC"); + return KErrNotSupported; + } + } + +TInt CSimPacketService::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 EPacketNotifyStatusChange: + case EPacketNotifyDynamicCapsChange: + case EPacketNotifyMbmsNetworkServiceStatusChange: + LOGPACKET1("CSimPacketService: Registered with 10 slots"); + numberOfSlots=10; + break; + case EPacketNotifyContextAdded: + case EPacketNotifyContextActivationRequested: + case EPacketNotifyChangeOfNtwkRegStatus: + case EPacketNotifyMSClassChange: + case EPacketNotifyReleaseModeChange: + case EPacketNotifyAttachModeChange: + case EPacketNotifyMbmsServiceAvailabilityChange: + LOGPACKET1("CSimPacketService: Registered with 2 slots"); + numberOfSlots=2; + break; + default: + // Unknown or invalid IPC + LOGPACKET1("CSimPacketService: Number of Slots error, unknown IPC"); + User::Leave(KErrNotSupported); + break; + } + return numberOfSlots; + } + + +TInt CSimPacketService::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 +*/ + { + TAny* dataPtr=aPackage.Ptr1(); + TAny* dataPtr2=aPackage.Ptr2(); + + switch (aIpc) + { + case EPacketNotifyContextAdded: + return NotifyContextAdded(aTsyReqHandle, aPackage.Des1u()); + case EPacketGetStatus: + return GetStatus(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TStatus*, dataPtr)); + case EPacketNotifyStatusChange: + return NotifyStatusChange(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TStatus*, dataPtr)); + case EPacketNotifyContextActivationRequested: + return NotifyContextActivationRequested(aTsyReqHandle, + aPackage.Des1n()); + case EPacketEnumerateContexts: + return EnumerateContexts(aTsyReqHandle, + REINTERPRET_CAST(TInt*, dataPtr), + REINTERPRET_CAST(TInt*, dataPtr2)); + case EPacketGetContextInfo: + return GetContextInfo(aTsyReqHandle, + REINTERPRET_CAST(TInt*, dataPtr), + REINTERPRET_CAST(RPacketService::TContextInfo*, dataPtr2)); + case EPacketGetNtwkRegStatus: + return GetNtwkRegStatus(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr)); + case EPacketNotifyChangeOfNtwkRegStatus: + return NotifyChangeOfNtwkRegStatus(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TRegistrationStatus*, dataPtr)); + case EPacketGetMSClass: + return GetMSClass(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr), + REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr2)); + case EPacketSetMSClass: + return SetMSClass(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr)); + case EPacketNotifyMSClassChange: + return NotifyMSClassChange(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TMSClass*, dataPtr)); + case EPacketGetStaticCaps: + return GetStaticCaps(aTsyReqHandle, + REINTERPRET_CAST(TUint*, dataPtr), + REINTERPRET_CAST(RPacketContext::TProtocolType*, dataPtr2)); + case EPacketGetDynamicCaps: + return GetDynamicCaps(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr)); + case EPacketNotifyDynamicCapsChange: + return NotifyDynamicCapsChange(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TDynamicCapsFlags*, dataPtr)); + case EPacketSetAttachMode: + return SetAttachMode(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr)); + case EPacketGetAttachMode: + return GetAttachMode(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr)); + case EPacketNotifyAttachModeChange: + return NotifyAttachModeChange(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TAttachMode*, dataPtr)); + case EPacketAttach: + return Attach(aTsyReqHandle); + case EPacketDetach: + return Detach(aTsyReqHandle); + case EPacketRejectActivationRequest: + return RejectActivationRequest(aTsyReqHandle); + case EPacketSetDefaultContextParams: + return SetDefaultContextParams(aTsyReqHandle, aPackage.Des1n()); + case EPacketGetDefaultContextParams: + return GetDefaultContextParams(aTsyReqHandle, aPackage.Des1n()); + case EPacketGetCurrentReleaseMode: + return GetCurrentReleaseMode(aTsyReqHandle, REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr)); + case EPacketNotifyReleaseModeChange: + return NotifyReleaseModeChange(aTsyReqHandle, + REINTERPRET_CAST(RPacketService::TPacketReleaseMode*, dataPtr)); + case EPacketEnumerateNifs: + return EnumerateNifs(aTsyReqHandle, *(REINTERPRET_CAST(TInt*, dataPtr))); + case EPacketGetNifInfo: + return GetNifInfo(aTsyReqHandle, *REINTERPRET_CAST(TInt*, dataPtr), aPackage.Des2n()); + case EPacketEnumerateContextsInNif: + return EnumerateContextsInNif(aTsyReqHandle, aPackage.Des2u(), *REINTERPRET_CAST(TInt*, dataPtr)); + case EPacketGetContextNameInNif: + return GetContextNameInNif(aTsyReqHandle, aPackage.Des2u(), *REINTERPRET_CAST(TInt*, dataPtr), aPackage.Des2u()); + case EPacketPrepareOpenSecondary: + //return PrepareOpenSecondary(aTsyReqHandle, *REINTERPRET_CAST(TDesC*, dataPtr)); + return PrepareOpenSecondary(aTsyReqHandle, aPackage.Des1u()); + case EPacketGetNifInfoCancel: + return GetNifInfoCancel(aTsyReqHandle); + case EPacketGetMbmsNetworkServiceStatus: + return GetMbmsNetworkServiceStatus(aTsyReqHandle, reinterpret_cast (dataPtr), + reinterpret_cast (dataPtr2)); + case EPacketNotifyMbmsNetworkServiceStatusChange: + return NotifyMbmsNetworkServiceStatusChange(aTsyReqHandle, + reinterpret_cast(dataPtr)); + case EPacketNotifyMbmsServiceAvailabilityChange: + return NotifyMbmsServiceAvailabilityChange(aTsyReqHandle); + case EPacketUpdateMbmsMonitorServiceList: + TInt retValue; + TInt err; + if(dataPtr2) + { + TRAP(err, retValue = UpdateMbmsMonitorServiceListL(aTsyReqHandle, + reinterpret_cast(dataPtr),aPackage.Des2n())); + } + else + { + TRAP(err, retValue = UpdateMbmsMonitorServiceListL(aTsyReqHandle, + reinterpret_cast(dataPtr))); + } + if(err != KErrNone) + { + retValue = err; + } + return retValue; + case EPacketGetMbmsMonitoredServicesPhase1: + return GetMbmsMonitoredServicesListPhase1(aTsyReqHandle, + reinterpret_cast(dataPtr), + reinterpret_cast(dataPtr2)); + case EPacketGetMbmsMonitoredServicesPhase2: + return GetMbmsMonitoredServicesListPhase2(aTsyReqHandle, + reinterpret_cast(dataPtr), aPackage.Des2n()); + case EPacketEnumerateMbmsMonitorServiceList: + return EnumerateMbmsMonitorServiceList(aTsyReqHandle, + reinterpret_cast(dataPtr), + reinterpret_cast(dataPtr2)); + case EPacketEnumerateMbmsActiveServiceList: + return EnumerateMbmsActiveServiceList(aTsyReqHandle, + reinterpret_cast(dataPtr), + reinterpret_cast(dataPtr2)); + default: + return KErrNotSupported; + } + } + +TInt CSimPacketService::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. +* +* This function will be called when a client explicitly cancels +* +* @param aTsyReqHandle The request handle for completing the request +* @param aIpc Ipc representing the request +* @return err KErrNone if request completes ok +*/ + { + LOGPACKET1("CSimPacketService: - CancelService called"); + switch (aIpc) + { + case EPacketNotifyContextAdded: + return NotifyContextAddedCancel(aTsyReqHandle); + case EPacketAttach: + return AttachCancel(aTsyReqHandle); + case EPacketDetach: + return DetachCancel(aTsyReqHandle); + case EPacketNotifyStatusChange: + return NotifyStatusChangeCancel(aTsyReqHandle); + case EPacketNotifyContextActivationRequested: + return NotifyContextActivationRequestedCancel(aTsyReqHandle); + case EPacketRejectActivationRequest: + return RejectActivationRequestCancel(aTsyReqHandle); + case EPacketGetContextInfo: + return GetContextInfoCancel(aTsyReqHandle); + case EPacketNotifyChangeOfNtwkRegStatus: + return NotifyChangeOfNtwkRegStatusCancel(aTsyReqHandle); + case EPacketGetMSClass: + return GetMSClassCancel(aTsyReqHandle); + case EPacketSetMSClass: + return SetMSClassCancel(aTsyReqHandle); + case EPacketNotifyMSClassChange: + return NotifyMSClassChangeCancel(aTsyReqHandle); + case EPacketNotifyDynamicCapsChange: + return NotifyDynamicCapsChangeCancel(aTsyReqHandle); + case EPacketEnumerateContextsCancel: + return EnumerateContextsCancel(aTsyReqHandle); + case EPacketGetCurrentReleaseMode: + return GetCurrentReleaseModeCancel(aTsyReqHandle); + case EPacketNotifyReleaseModeChange: + return NotifyReleaseModeChangeCancel(aTsyReqHandle); + case EPacketEnumerateNifs: + return EnumerateNifsCancel(aTsyReqHandle); + case EPacketGetNifInfo: + return GetNifInfoCancel(aTsyReqHandle); + case EPacketEnumerateContextsInNif: + return EnumerateContextsInNifCancel(aTsyReqHandle); + case EPacketGetContextNameInNif: + return GetContextNameInNifCancel(aTsyReqHandle); + case EPacketNotifyAttachModeChange: + return NotifyAttachModeChangeCancel(aTsyReqHandle); + case EPacketGetMbmsNetworkServiceStatus: + return GetMbmsNetworkServiceStatusCancel(aTsyReqHandle); + case EPacketNotifyMbmsNetworkServiceStatusChange: + return NotifyMbmsNetworkServiceStatusChangeCancel(aTsyReqHandle); + case EPacketNotifyMbmsServiceAvailabilityChange: + return NotifyMbmsServiceAvailabilityChangeCancel(aTsyReqHandle); + case EPacketUpdateMbmsMonitorServiceList: + return UpdateMbmsMonitorServiceListCancel(aTsyReqHandle); + case EPacketGetMbmsMonitoredServicesPhase1: + case EPacketGetMbmsMonitoredServicesPhase2: + return GetMbmsMonitoredServicesListCancel(aTsyReqHandle); + case EPacketEnumerateMbmsMonitorServiceList: + return EnumerateMbmsMonitorServiceListCancel(aTsyReqHandle); + case EPacketEnumerateMbmsActiveServiceList: + return EnumerateMbmsActiveServiceListCancel(aTsyReqHandle); + + default: + return KErrGeneral; + } + } + +TInt CSimPacketService::NotifyContextAdded(const TTsyReqHandle aTsyReqHandle, TDes* aContextId) +/** +* Record a client's interest in being notified when a new context is added to the network. +* 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 aContextId pointer to the packet context data +* @return KErrNone +*/ + { + __ASSERT_ALWAYS(!iNotifyContextAdded.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyContextAdded.iNotifyPending = ETrue; + iNotifyContextAdded.iNotifyHandle = aTsyReqHandle; + iNotifyContextAdded.iNotifyData = aContextId; + return KErrNone; + } + +TInt CSimPacketService::NotifyContextAddedCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when a new context is added. +* 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("CSimPacketService::NotifyContextAddedCancel called"); + if(iNotifyContextAdded.iNotifyPending) + { + iNotifyContextAdded.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::Attach(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to attach to the service network. +* In this TSY, the request is registered then the state machine (ActionEvent) is called +* to handle the request making sure that the class state is updated and the phone is informed. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return TInt KErrnone if request completes ok +*/ + { + LOGPACKET1("CSimPacketService::Attach called"); + iAttachRequestHandle=aTsyReqHandle; + return ActionEvent(EPacketEventAttach); + } + +TInt CSimPacketService::AttachCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancels a clients interest in attaching to a network. +* this can only be achieved if we're not already attached otherwise the request is ignored. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return TInt KErrnone if request completes ok +*/ + { + LOGPACKET1("CSimPacketService::AttachCancel called"); + if((iState == RPacketService::EStatusUnattached) && (iCurrentEvent==EPacketEventAttach)) + { + iTimer->Cancel(); + iCurrentEvent= EPacketEventNone; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +/*** +* This function will detach the packet service and all its contexts from the network +***/ +TInt CSimPacketService::DoDetach() + { + TInt ret=KErrNone; + + switch(iState) + { + case RPacketService::EStatusUnattached: + break; + + case RPacketService::EStatusAttached: + ret=ChangeState(RPacketService::EStatusUnattached); + ReqCompleted(iDetachRequestHandle,ret); + break; + + case RPacketService::EStatusActive: + case RPacketService::EStatusSuspended: + { + TInt totalWrappers = iNifWrappers.Count(); + + // deactivate all contexts in every nif + for(TInt j=0; j < totalWrappers; j++) + { + TInt totalContexts = iNifWrappers[j].NumberOfContexts(); + for(TInt x =0; xAttemptDeactivateImmediately(); + if(ret!=KErrNone) + { + break; + } + } + } + + if(ret==KErrNone) + { + ret=ChangeState(RPacketService::EStatusUnattached); + } + ReqCompleted(iDetachRequestHandle,ret); + } + break; + default: + break; + } + return ret; + } +TInt CSimPacketService::Detach(const TTsyReqHandle aTsyReqHandle) +/** +* Client calls this method to detach from the service network. +* In this TSY, the request is registered then the state machine (ActionEvent) is called +* to handle the request making sure that the class state is updated and the phone is informed. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return TInt KErrnone if request completes ok +*/ + { + LOGPACKET1("CSimPacketService::Detach called"); + iDetachRequestHandle=aTsyReqHandle; + return ActionEvent(EPacketEventDetach); + } + +TInt CSimPacketService::DetachCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancels a clients interest in detaching from the network. +* this can only be achieved if we're not already attached and in the process of detaching +* but not detached yet otherwise the request is ignored. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return TInt KErrnone if request completes ok +*/ + { + LOGPACKET1("CSimPacketService::DetachCancel called"); + if((iState == RPacketService::EStatusAttached) && (iCurrentEvent==EPacketEventDetach)) + { + iTimer->Cancel(); + iCurrentEvent= EPacketEventNone; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::GetStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aStatus) +/** +* Retrieves and returns the status of the Packet service +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aStatus pointer to the status +* @return TInt err KErrNone if ok +*/ + { + LOGPACKET1("CSimPacketService::GetStatus called"); + *aStatus = iState; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TStatus* aStatus) +/** +* Record a client's interest in being notified of the state of the packet network and 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 aStatus pointer to the packet service status +* @return KErrNone +*/ + { + __ASSERT_ALWAYS(!iNotifyStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyStatusChange.iNotifyPending = ETrue; + iNotifyStatusChange.iNotifyHandle = aTsyReqHandle; + iNotifyStatusChange.iNotifyData = aStatus; + return KErrNone; + } + +TInt CSimPacketService::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when the call 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("CSimPacketService::NotifyStatusChangeCancel called"); + if(iNotifyStatusChange.iNotifyPending) + { + iNotifyStatusChange.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + + + +TInt CSimPacketService::NotifyContextActivationRequested(const TTsyReqHandle aTsyReqHandle, TDes8* aContextParameters) +/** +* Record a client's interest in being notified when a context is activated. +* 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. +* +* Hurricane does not support this method +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aStatus pointer to the packet service status +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::NotifyContextActivationRequested called"); + + iConfigData.iTsyReqHandle = aTsyReqHandle; + iConfigData.iData = aContextParameters; + + if ( iIncomingContextManager->IsUseTimerOn() ) + { // Timer use is on, so we can use it. + // 1st time by the reguest for notifictaion, + // 2nd time when do ReqCompleted(aTsyReqHandle,KErrCancel); + + iIncomingContextManager->StartFirstIncomingEvent(); + // When timer is done we have completed the request to activate a PDP. + iIncomingContextManager->SetUseTimerOff(); + } + + return KErrNone; + } + +TInt CSimPacketService::NotifyContextActivationRequestedCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when a context is activated. +* 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("CSimPacketService::NotifyContextActivationRequestedCancel called"); + + iIncomingContextManager->Cancel(); + iIncomingContextManager->SetUseTimerOff(); + + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +TInt CSimPacketService::RejectActivationRequest(const TTsyReqHandle aTsyReqHandle) +/** +* This method is called when a client wishes to reject an Activation request from the network +* This is currently not supported in this version of the simulator tsy. +* +* Hurricane does not support this method +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @return KErrNone +*/ + { + ReqCompleted(aTsyReqHandle, KErrNotSupported); + return KErrNone; + } + +TInt CSimPacketService::RejectActivationRequestCancel(const TTsyReqHandle aTsyReqHandle) +/** +* This method cancels a clients' request in rejecting an activation request. +* The TSY is not supporting this method +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + ReqCompleted(aTsyReqHandle, KErrCancel); + return KErrNone; + } + +TInt CSimPacketService::EnumerateContexts(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed) +/** +* Returns the number of contexts opened on the packet service +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aCount pointer to the number of contexts opened. +* @param aMaxAllowed pointer to the maximum number of contexts that can be opened on the packet service +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::EnumerateContexts called"); + // this should enumerate all primary and secondary contexts + *aCount = iPrimaryContextNameInc + iSecondaryContextNameInc; + *aMaxAllowed = KMaxContextPoolSize; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::EnumerateContextsCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* This method cancels a clients' request in Enmerationg the contexts +* This does nothing as Enumerate context is processed synchronously +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::Enumerate Context Cancel called"); + return KErrNone; + } + +TInt CSimPacketService::GetContextInfo(const TTsyReqHandle aTsyReqHandle, TInt* aIndex,RPacketService::TContextInfo* aInfo) +/** +* Retrieves a specific context info specified by the index variable +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aIndex pointer to the index of the context the info is requested from +* @param aInfo pointer to the context info. +* @return KErrNone if context is found in the list of contexts +*/ + { + LOGPACKET1("CSimPacketService::GetContextInfo called"); + CSimPacketContext* packetContext; + + if((*aIndex >= iContextCount) || (*aIndex < 0)) + ReqCompleted(aTsyReqHandle,KErrArgument); + else { + // this method is used in conjunction with EnumerateContexts() which for Jetstream + // now returns the number of all contexts - not just the number of primary contexts as + // was done in Hurricane. To that end, the index passed as a parameter needs to be translated + // to take into account the nifwrappers array's contexts. + TInt realIndex=*aIndex; + TInt i; + TInt wrappersCount = iNifWrappers.Count(); + for(i = 0; iiName.Copy(packetContext->ContextName()); + aInfo->iStatus = packetContext->ContextStatus(); + ReqCompleted(aTsyReqHandle,KErrNone); + } + return KErrNone; + } + +TInt CSimPacketService::GetContextInfoCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels a clients request for a context info +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + return KErrNone; + } + +TInt CSimPacketService::GetNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus) +/** +* Returns the Network registration status to the client. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aRegistrationStatus pointer to the registration status info requested +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetNtwkRegStatus called"); + *aRegistrationStatus = (RPacketService::TRegistrationStatus)iCurrentRegStatus; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::NotifyChangeOfNtwkRegStatus(const TTsyReqHandle aTsyReqHandle, RPacketService::TRegistrationStatus* aRegistrationStatus) +/** +* Record a client's interest in being notified of a change in the Nk registration status. +* 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 aRegistrationStatus pointer to the Network registration status +* @return KErrNone +*/ + { + if(iNtwkRegStatusInfo->Count()==0) + { + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + + __ASSERT_ALWAYS(!iNotifyChangeOfNtwk.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding)); + iNotifyChangeOfNtwk.iNotifyPending=ETrue; + iNotifyChangeOfNtwk.iNotifyHandle=aTsyReqHandle; + iNotifyChangeOfNtwk.iNotifyData=aRegistrationStatus; + return KErrNone; + } + +TInt CSimPacketService::NotifyChangeOfNtwkRegStatusCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified of a change in the Nk registration status. +* 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("CSimPacketService::NotifyChangeOfNtwkRegStatusCancel called"); + if(iNotifyChangeOfNtwk.iNotifyPending) + { + iNotifyChangeOfNtwk.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::GetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aCurrentClass, RPacketService::TMSClass* aMaxClass) +/** +* Returns the Current MSClass supported by the TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aCurrentClass pointer to the current MSClass +* @param aMaxClass the maximum MSClass this TSY can support +* @return KErrNone +*/ + { + //This version of the Simulator TSY will only support CLASS B i.e EMSClassSuspensionRequired + *aCurrentClass = iMSClass; + *aMaxClass = RPacketService::EMSClassSuspensionRequired; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::GetMSClassCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels a clients request in retrieving the current MSClass supported by the TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + return KErrNone; + } + +TInt CSimPacketService::SetMSClass(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* aClass) +/** +* Sets the MSClass for the TSY. This TSY current support Class B only and cannot be reset. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aClass pointer to the MSClass to set the TSY to support +* @return KErrNone +*/ + { + if(*aClass != RPacketService::EMSClassSuspensionRequired) + ReqCompleted(aTsyReqHandle,KErrNotSupported); + else { + iMSClass = *aClass; + ReqCompleted(aTsyReqHandle,KErrNone); + } + return KErrNone; + } + +TInt CSimPacketService::SetMSClassCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancels a clients interest in setting the MSClass support for the TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + return KErrNone; + } + +TInt CSimPacketService::NotifyMSClassChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TMSClass* /*aNewClass*/) +/** +* Record a client's interest in being notified of a change of MSClass supported. +* 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. +* +* Currently the TSY will only support Class B and thus this method is not supported. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aNewClass pointer to the MSClass to set to +* @return KErrNone +*/ + { + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + +TInt CSimPacketService::NotifyMSClassChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/) +/** +* Cancel a client's interest in being notified of a change of MSClass supported. +* 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 +*/ + { + return KErrNone; + } + +TInt CSimPacketService::GetStaticCaps(const TTsyReqHandle aTsyReqHandle, TUint* aCaps,RPacketContext::TProtocolType* aPdpType) +/** +* Returns the Static capabilities supported by the TSY +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aCaps pointer to the TSY's capability +* @param aPdpType protocol type used by the TSY +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetStaticCaps called"); + *aCaps = KPacketServiceCaps; + *aPdpType = RPacketContext::EPdpTypePPP; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +/** +* Returns the Dynamic capabilities supported by the TSY +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aCaps Pointer to be populated with the dynamic capabilities of the TSY +* @return KErrNone +*/ +TInt CSimPacketService::GetDynamicCaps(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps) + { + LOGPACKET1("CSimPacketService::GetDynamicCaps called"); + + if (iDynamicCapsArray->Count() == 0) + { + ReqCompleted(aTsyReqHandle, KErrNotSupported); + return KErrNone; + } + *aCaps = iCurrentDynamicCaps; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +/** +* Registers a client interest of change in the Dynamic capabilities change. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aCaps Pointer to be populated with the dynamic capabilities of the TSY +* @return KErrNone +*/ +TInt CSimPacketService::NotifyDynamicCapsChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TDynamicCapsFlags* aCaps) + { + LOGPACKET1("CSimPacketService::NotifyDynamicCapsChange called"); + __ASSERT_ALWAYS(!iNotifyDynamicCapsChange.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + if (iDynamicCapsArray->Count() == 0) + { + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNone; + } + + iNotifyDynamicCapsChange.iNotifyPending = ETrue; + iNotifyDynamicCapsChange.iNotifyHandle = aTsyReqHandle; + iNotifyDynamicCapsChange.iNotifyData = aCaps; + return KErrNone; + } + +/** +* Cancels a clients interest in the change of dynamic caps. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ +TInt CSimPacketService::NotifyDynamicCapsChangeCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGPACKET1("CSimPacketService::NotifyDynamicCapsChangeCancel called"); + if( (iNotifyDynamicCapsChange.iNotifyPending) && (aTsyReqHandle == iNotifyDynamicCapsChange.iNotifyHandle)) + { + iNotifyDynamicCapsChange.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +/** +* Timer callback function to simulate a change in the dynamic capabilities of the TSY +*/ +void CSimPacketService::TimerCallBackDynamicCaps() + { + if (++iDynamicCapsIndex >= iDynamicCapsArray->Count()) + { + return; + } + iCurrentDynamicCaps = iDynamicCapsArray->At(iDynamicCapsIndex).iDynamicCaps; + if (iNotifyDynamicCapsChange.iNotifyPending) + { + iNotifyDynamicCapsChange.iNotifyPending = EFalse; + *(TInt*)iNotifyDynamicCapsChange.iNotifyData = iCurrentDynamicCaps; + ReqCompleted(iNotifyDynamicCapsChange.iNotifyHandle,KErrNone); + } + + iDynamicCapsTimer->Start(iDynamicCapsArray->At(iDynamicCapsIndex).iDuration, this, ETimerIdPcktServDynamicCaps); + } + +TInt CSimPacketService::SetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode) +/** +* Sets the attach mode to be used by the tsy. +* Currently The TSY supports EAttachWhenNeeded only. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aMode pointer to the mode to change to +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::SetAttachMode called"); + if(*aMode != RPacketService::EAttachWhenNeeded) + { + ReqCompleted(aTsyReqHandle, KErrNotSupported); + } + else + { + iAttachMode = *aMode; + // Check for a pending attach mode notification. + if(iNotifyChangeOfAttachMode.iNotifyPending) + { + iNotifyChangeOfAttachMode.iNotifyPending=EFalse; + *(RPacketService::TAttachMode*)iNotifyChangeOfAttachMode.iNotifyData = iAttachMode; + ReqCompleted(iNotifyChangeOfAttachMode.iNotifyHandle,KErrNone); + } + ReqCompleted(aTsyReqHandle,KErrNone); + } + return KErrNone; + } + +TInt CSimPacketService::GetAttachMode(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode) +/** +* Retrieves and returns the current attach mode for the TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aMode pointer to the mode to change +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetAttachMode called"); + *aMode = iAttachMode; + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::NotifyAttachModeChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TAttachMode* aMode) +/** +* Set notification request for change of current attach mode +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aMode pointer to the mode to change +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::NotifyAttachModeChange called"); + + __ASSERT_ALWAYS(!iNotifyChangeOfAttachMode.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyChangeOfAttachMode.iNotifyPending=ETrue; + iNotifyChangeOfAttachMode.iNotifyHandle=aTsyReqHandle; + iNotifyChangeOfAttachMode.iNotifyData=aMode; + + return KErrNone; + } + +TInt CSimPacketService::SetDefaultContextParams(const TTsyReqHandle aTsyReqHandle, const TDesC8* aPckg) +/** +* Sets the Default Context Parameters to be used when attaching and activating a context. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aPckg pointer containing the parameters to set to. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::SetDefaultContextParams called"); + + TPckg* configBase = (TPckg*)aPckg; + TPacketDataConfigBase& configBaseV1 = (*configBase)(); + + + // GPRS + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS) + { + iPhone->UpdateNetworkMode(RMobilePhone::ENetworkModeGsm); + TPckg* defaultContextGPRSPckg = (TPckg*)aPckg; + RPacketContext::TContextConfigGPRS& defaultContextGPRSV1 = (*defaultContextGPRSPckg)(); + + TBuf8 accessPointName; + accessPointName.Copy(defaultContextGPRSV1.iAccessPointName); + + TBuf8 dpAddress; + dpAddress.Copy(defaultContextGPRSV1.iPdpAddress); + + TBuf8 password; + password.Copy(defaultContextGPRSV1.iProtocolConfigOption.iAuthInfo.iPassword); + + TBuf8 username; + username.Copy(defaultContextGPRSV1.iProtocolConfigOption.iAuthInfo.iUsername); + + TBuf8 challenge; + challenge.Copy(defaultContextGPRSV1.iProtocolConfigOption.iChallenge); + + TBuf8 response; + response.Copy(defaultContextGPRSV1.iProtocolConfigOption.iResponse); + + TBuf8 primaryDNS; + primaryDNS.Copy(defaultContextGPRSV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns); + + TBuf8 secondaryDNS; + secondaryDNS.Copy(defaultContextGPRSV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns); + + TBuf8 miscBuffer; + miscBuffer.Copy(defaultContextGPRSV1.iProtocolConfigOption.iMiscBuffer); + + if ((defaultContextGPRSV1.iPdpType != iGPRSDefaultConfig.iProtocolType)|| + (iGPRSDefaultConfig.iGsnAddress.Compare(accessPointName) != KErrNone) || + (iGPRSDefaultConfig.iProtocolAddress.Compare(dpAddress) != KErrNone) || + (defaultContextGPRSV1.iPdpCompression != iGPRSDefaultConfig.iPdpCompression) || + (defaultContextGPRSV1.iAnonymousAccessReqd != iGPRSDefaultConfig.iAnonymousAccess) || + (defaultContextGPRSV1.iUseEdge != iGPRSDefaultConfig.iUseEdge) || + (defaultContextGPRSV1.iProtocolConfigOption.iAuthInfo.iProtocol != iGPRSDefaultConfig.iProtocolConfigOption.iAuthProtocol) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iPassword).Compare(password) != KErrNone) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iUsername).Compare(username) != KErrNone) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iChallenge).Compare(challenge) != KErrNone) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iResponse).Compare(response) != KErrNone) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iPrimaryDNS).Compare(primaryDNS) != KErrNone) || + ((iGPRSDefaultConfig.iProtocolConfigOption.iSecondaryDNS).Compare(secondaryDNS) != KErrNone) || + (iGPRSDefaultConfig.iProtocolConfigOption.iId != defaultContextGPRSV1.iProtocolConfigOption.iId)) + ReqCompleted(aTsyReqHandle,KErrArgument); + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + // UMTS + else if (configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4) + { + iPhone->UpdateNetworkMode(RMobilePhone::ENetworkModeGsm); + TPckg* defaultContextR99_R4Pckg = (TPckg*)aPckg; + RPacketContext::TContextConfigR99_R4& defaultContextR99_R4V1 = (*defaultContextR99_R4Pckg)(); + + TBuf8 accessPointName; + accessPointName.Copy(defaultContextR99_R4V1.iAccessPointName); + + TBuf8 dpAddress; + dpAddress.Copy(defaultContextR99_R4V1.iPdpAddress); + + TBuf8 password; + password.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iAuthInfo.iPassword); + + TBuf8 username; + username.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iAuthInfo.iUsername); + + TBuf8 challenge; + challenge.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iChallenge); + + TBuf8 response; + response.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iResponse); + + TBuf8 primaryDNS; + primaryDNS.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns); + + TBuf8 secondaryDNS; + secondaryDNS.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns); + + TBuf8 miscBuffer; + miscBuffer.Copy(defaultContextR99_R4V1.iProtocolConfigOption.iMiscBuffer); + + if ((defaultContextR99_R4V1.iPdpType != iR99_R4DefaultConfig.iProtocolType)|| + (iR99_R4DefaultConfig.iGsnAddress.Compare(accessPointName) != KErrNone) || + (iR99_R4DefaultConfig.iProtocolAddress.Compare(dpAddress) != KErrNone) || + (defaultContextR99_R4V1.iUseEdge != iR99_R4DefaultConfig.iUseEdge) || + (defaultContextR99_R4V1.iProtocolConfigOption.iAuthInfo.iProtocol != iR99_R4DefaultConfig.iProtocolConfigOption.iAuthProtocol) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iPassword).Compare(password) != KErrNone) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iUsername).Compare(username) != KErrNone) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iChallenge).Compare(challenge) != KErrNone) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iResponse).Compare(response) != KErrNone) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iPrimaryDNS).Compare(primaryDNS) != KErrNone) || + ((iR99_R4DefaultConfig.iProtocolConfigOption.iSecondaryDNS.Compare(secondaryDNS) != KErrNone) || + (iR99_R4DefaultConfig.iProtocolConfigOption.iId != defaultContextR99_R4V1.iProtocolConfigOption.iId))) + + ReqCompleted(aTsyReqHandle,KErrArgument); + else + ReqCompleted(aTsyReqHandle,KErrNone); + } + //R5 + else if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5) + { + iPhone->UpdateNetworkMode(RMobilePhone::ENetworkModeGsm); + TPckg* defaultContext_R5Pckg = (TPckg*)aPckg; + RPacketContext::TContextConfig_R5& defaultContextR5 = (*defaultContext_R5Pckg)(); + + TBuf8 accessPointName; + accessPointName.Copy(defaultContextR5.iAccessPointName); + + TBuf8 dpAddress; + dpAddress.Copy(defaultContextR5.iPdpAddress); + + TBuf8 password; + password.Copy(defaultContextR5.iProtocolConfigOption.iAuthInfo.iPassword); + + TBuf8 username; + username.Copy(defaultContextR5.iProtocolConfigOption.iAuthInfo.iUsername); + + TBuf8 challenge; + challenge.Copy(defaultContextR5.iProtocolConfigOption.iChallenge); + + TBuf8 response; + response.Copy(defaultContextR5.iProtocolConfigOption.iResponse); + + TBuf8 primaryDNS; + primaryDNS.Copy(defaultContextR5.iProtocolConfigOption.iDnsAddresses.iPrimaryDns); + + TBuf8 secondaryDNS; + secondaryDNS.Copy(defaultContextR5.iProtocolConfigOption.iDnsAddresses.iSecondaryDns); + + TBuf8 miscBuffer; + miscBuffer.Copy(defaultContextR5.iProtocolConfigOption.iMiscBuffer); + + if ((defaultContextR5.iPdpType != iR5DefaultConfig.iProtocolType)|| + (iR5DefaultConfig.iGsnAddress.Compare(accessPointName) != KErrNone) || + (iR5DefaultConfig.iProtocolAddress.Compare(dpAddress) != KErrNone) || + (defaultContextR5.iUseEdge != iR5DefaultConfig.iUseEdge) || + (defaultContextR5.iProtocolConfigOption.iAuthInfo.iProtocol != iR5DefaultConfig.iProtocolConfigOption.iAuthProtocol) || + ((iR5DefaultConfig.iProtocolConfigOption.iPassword).Compare(password) != KErrNone) || + ((iR5DefaultConfig.iProtocolConfigOption.iUsername).Compare(username) != KErrNone) || + ((iR5DefaultConfig.iProtocolConfigOption.iChallenge).Compare(challenge) != KErrNone) || + ((iR5DefaultConfig.iProtocolConfigOption.iResponse).Compare(response) != KErrNone) || + ((iR5DefaultConfig.iProtocolConfigOption.iPrimaryDNS).Compare(primaryDNS) != KErrNone) || + ((iR5DefaultConfig.iProtocolConfigOption.iSecondaryDNS).Compare(secondaryDNS) != KErrNone) || + (iR5DefaultConfig.iProtocolConfigOption.iId != defaultContextR5.iProtocolConfigOption.iId) || + (iR5DefaultConfig.iPdpHeaderCompression != defaultContextR5.iPdpHeaderCompression) || + (iR5DefaultConfig.iPdpDataCompression != defaultContextR5.iPdpDataCompression)) + { + ReqCompleted(aTsyReqHandle,KErrArgument); + } + else + { + ReqCompleted(aTsyReqHandle,KErrNone); + } + } + else + { + iPhone->UpdateNetworkMode(RMobilePhone::ENetworkModeUnknown); + } + return KErrNone; + } + + +TInt CSimPacketService::GetGPRSDefaultContextParams(const TTsyReqHandle aTsyReqHandle, TDes8* aPckg) +/** +* Returns the Default Context Parameters set by the client. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aPckg pointer containing the parameters to return to client. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetDefaultContextParams called"); + + TPckg* contextConfigGPRSPckg = (TPckg*)aPckg; + RPacketContext::TContextConfigGPRS& contextConfigV1 = (*contextConfigGPRSPckg)(); + + contextConfigV1.iAccessPointName.Copy(KApn); + contextConfigV1.iAnonymousAccessReqd = RPacketContext::ERequired; + contextConfigV1.iPdpAddress.Copy(KProtocolAddress); + contextConfigV1.iPdpCompression = 1; + contextConfigV1.iPdpType = RPacketContext::EPdpTypeIPv6; + + contextConfigV1.iUseEdge = ETrue; + contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername.Copy(KUsername); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword.Copy(KPassword); + contextConfigV1.iProtocolConfigOption.iChallenge.Copy(KChallenge); + contextConfigV1.iProtocolConfigOption.iResponse.Copy(KResponse); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(KPrimaryDNS); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(KSecondaryDNS); + contextConfigV1.iProtocolConfigOption.iId = 1; + contextConfigV1.iProtocolConfigOption.iMiscBuffer.Copy(_L("")); + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::GetDefaultContextParams(const TTsyReqHandle aTsyReqHandle, TDes8* aPckg) +/** +* Returns the Default Context Parameters set by the client. +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aPckg pointer containing the parameters to return to client. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetDefaultContextParams called"); + TPckg* configBase = (TPckg*)aPckg; + TPacketDataConfigBase& configBaseV1 = (*configBase)(); + + // GPRS + if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigGPRS) + { + TPckg* contextConfigGPRSPckg = (TPckg*)aPckg; + RPacketContext::TContextConfigGPRS& contextConfigV1 = (*contextConfigGPRSPckg)(); + + contextConfigV1.iAccessPointName.Copy(iGPRSDefaultConfig.iGsnAddress);// = STATIC_CAST(RPacketContext::TGSNAddress,accessPointName); + contextConfigV1.iAnonymousAccessReqd = STATIC_CAST(RPacketContext::TAnonymousAccess,iGPRSDefaultConfig.iAnonymousAccess); + contextConfigV1.iPdpAddress.Copy(iGPRSDefaultConfig.iProtocolAddress);// = STATIC_CAST(RPacketContext::TProtocolAddress, dpAddress); + contextConfigV1.iPdpCompression = STATIC_CAST(TUint, iGPRSDefaultConfig.iPdpCompression); + contextConfigV1.iPdpType = STATIC_CAST(RPacketContext::TProtocolType, iGPRSDefaultConfig.iProtocolType); + contextConfigV1.iUseEdge = iGPRSDefaultConfig.iUseEdge; + contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = STATIC_CAST(RPacketContext::TAuthProtocol, iGPRSDefaultConfig.iProtocolConfigOption.iAuthProtocol); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iUsername); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iPassword); + contextConfigV1.iProtocolConfigOption.iChallenge.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iChallenge); + contextConfigV1.iProtocolConfigOption.iResponse.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iResponse); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iPrimaryDNS); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iSecondaryDNS); + contextConfigV1.iProtocolConfigOption.iId = STATIC_CAST(TUint8, iGPRSDefaultConfig.iProtocolConfigOption.iId); + contextConfigV1.iProtocolConfigOption.iMiscBuffer.Copy(iGPRSDefaultConfig.iProtocolConfigOption.iMiscBuffer); + ReqCompleted(aTsyReqHandle,KErrNone); + } + // UMTS + else if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel99Rel4) + { + TPckg* contextConfigR99_R4Pckg = (TPckg*)aPckg; + RPacketContext::TContextConfigR99_R4& contextConfigV1 = (*contextConfigR99_R4Pckg)(); + + contextConfigV1.iAccessPointName.Copy(iR99_R4DefaultConfig.iGsnAddress);// = STATIC_CAST(RPacketContext::TGSNAddress,accessPointName); + contextConfigV1.iPdpAddress.Copy(iR99_R4DefaultConfig.iProtocolAddress);// = STATIC_CAST(RPacketContext::TProtocolAddress, dpAddress); + contextConfigV1.iPdpType = STATIC_CAST(RPacketContext::TProtocolType, iR99_R4DefaultConfig.iProtocolType); + contextConfigV1.iUseEdge = iR99_R4DefaultConfig.iUseEdge; + contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = STATIC_CAST(RPacketContext::TAuthProtocol, iR99_R4DefaultConfig.iProtocolConfigOption.iAuthProtocol); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iUsername); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iPassword); + contextConfigV1.iProtocolConfigOption.iChallenge.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iChallenge); + contextConfigV1.iProtocolConfigOption.iResponse.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iResponse); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iPrimaryDNS); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iSecondaryDNS); + contextConfigV1.iProtocolConfigOption.iId = STATIC_CAST(TUint8, iR99_R4DefaultConfig.iProtocolConfigOption.iId); + contextConfigV1.iProtocolConfigOption.iMiscBuffer.Copy(iR99_R4DefaultConfig.iProtocolConfigOption.iMiscBuffer); + ReqCompleted(aTsyReqHandle,KErrNone); + } + + //R5 + else if(configBaseV1.ExtensionId()==TPacketDataConfigBase::KConfigRel5) + { + TPckg* contextConfigR5Pckg = (TPckg*)aPckg; + RPacketContext::TContextConfig_R5& contextConfigV1 = (*contextConfigR5Pckg)(); + + contextConfigV1.iAccessPointName.Copy(iR5DefaultConfig.iGsnAddress); + contextConfigV1.iPdpAddress.Copy(iR5DefaultConfig.iProtocolAddress); + contextConfigV1.iPdpType = static_cast(iR5DefaultConfig.iProtocolType); + contextConfigV1.iUseEdge = iR5DefaultConfig.iUseEdge; + contextConfigV1.iPdpHeaderCompression = + static_cast(iR5DefaultConfig.iPdpHeaderCompression); + contextConfigV1.iPdpDataCompression = + static_cast(iR5DefaultConfig.iPdpDataCompression); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iProtocol = + static_cast(iR5DefaultConfig.iProtocolConfigOption.iAuthProtocol); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iUsername.Copy( + iR5DefaultConfig.iProtocolConfigOption.iUsername); + contextConfigV1.iProtocolConfigOption.iAuthInfo.iPassword.Copy( + iR5DefaultConfig.iProtocolConfigOption.iPassword); + contextConfigV1.iProtocolConfigOption.iChallenge.Copy( + iR5DefaultConfig.iProtocolConfigOption.iChallenge); + contextConfigV1.iProtocolConfigOption.iResponse.Copy( + iR5DefaultConfig.iProtocolConfigOption.iResponse); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iPrimaryDns.Copy( + iR5DefaultConfig.iProtocolConfigOption.iPrimaryDNS); + contextConfigV1.iProtocolConfigOption.iDnsAddresses.iSecondaryDns.Copy( + iR5DefaultConfig.iProtocolConfigOption.iSecondaryDNS); + contextConfigV1.iProtocolConfigOption.iId = + static_cast(iR5DefaultConfig.iProtocolConfigOption.iId); + contextConfigV1.iProtocolConfigOption.iMiscBuffer.Copy( + iR5DefaultConfig.iProtocolConfigOption.iMiscBuffer); + + ReqCompleted(aTsyReqHandle,KErrNone); + } + + return KErrNone; + } + + +void CSimPacketService::TimerCallBack(TInt aId) +/** +* Timer callback function. When the timer goes off, it will call back into this +* function for further processing. +* +* @param aId an id identifying which timer callback is being called +*/ + { + LOGPACKET1(">>CSimPacketService::TimerCallBack"); + + if(aId == ETimerIdPcktServPacket) + { + TimerCallBackPcktRegStatus(); + } + else if (aId== ETimerIdPcktServReleaseMode) + { + TimerCallBackReleaseMode(); + } + else if (aId == ETimerIdPcktServNtwkStatusChange) + { + TimerCallBackNtwkRegStatus(); + } + else if (aId == ETimerIdPcktServStatusSuspend || + aId == ETimerIdPcktServStatusDetach || + aId == ETimerIdPcktServStatusUnattach) + { + TimerCallBackDeactivate(); + } + else if (aId == ETimerIdPcktServDynamicCaps) + { + TimerCallBackDynamicCaps(); + } + else if(aId == ETimerIdContextActivationRequestedChange) + { + + + iIncomingContextManager->NextIncomingEvent(iConfigData.iData); + // Set up for the next incoming PDP if any. + // Note at moment can only handle 1 GPRS incoming. + // There is no support for 2ndary contexts, so can not have 2 incoming (of the same type). + // And at the moment there is no support for any other type thanm GPRS. + + iIncomingContextManager->Cancel(); + // No more timers. + + iIncomingContextManager->SetUseTimerOff(); + ReqCompleted(iConfigData.iTsyReqHandle,KErrNone); + iIncomingContextManager->SetUseTimerOn(); + + } + else if(aId == ETimerIdMbmsPcktService) + { + if(iNotifyMbmsNetworkStatusChange.iNotifyPending) + { + iNotifyMbmsNetworkStatusChange.iNotifyPending = EFalse; + *(static_cast(iNotifyMbmsNetworkStatusChange.iNotifyData))= + iMbmsBroadcastParamsArray->At(iCurrentMbmsParamsIndex).iMbmsNetworkStatus; + ReqCompleted(iNotifyMbmsNetworkStatusChange.iNotifyHandle,KErrNone); + } + + if(iNotifyMbmsServAvailChange.iNotifyPending) + { + iNotifyMbmsServAvailChange.iNotifyPending = EFalse; + ReqCompleted(iNotifyMbmsServAvailChange.iNotifyHandle,KErrNone); + } + + if(iMbmsBroadcastParamsArray->Count() > iCurrentMbmsParamsIndex) + { + iMbmsPcktTimer->Start(iMbmsBroadcastParamsArray->At(iCurrentMbmsParamsIndex).iDuration,this,ETimerIdMbmsPcktService); + } + else if (iMbmsMonitorListParamsArray->Count() > iCurrentMbmsMonitorListIndex) + { + iMbmsPcktTimer->Start(iMbmsMonitorListParamsArray->At(iCurrentMbmsMonitorListIndex).iDuration,this,ETimerIdMbmsPcktService); + } + + } + else + { + TInt ret = ActionEvent(EPacketEventTimeOut); + __ASSERT_ALWAYS(ret==KErrNone,SimPanic(ETimeOutEventActionFailed)); // Note: this is very crude error handling and should be replaced by something rather more elegant. + } + LOGPACKET1("<AttemptDeactivateImmediately(); + } + } +} + +void CSimPacketService::TimerCallBackReleaseMode() +/** +* called when release mode timer callback occurs +*/ + { + if(iPacketReleaseModeArray->Count()<=iPacketReleaseModeIndex) + return; + + iCurrentPacketReleaseMode=iPacketReleaseModeArray->At(iPacketReleaseModeIndex).iReleaseMode; + + // if event is pending complete request + if(iNotifyChangeOfReleaseMode.iNotifyPending) + { + iNotifyChangeOfReleaseMode.iNotifyPending=EFalse; + *(RPacketService::TPacketReleaseMode*)iNotifyChangeOfReleaseMode.iNotifyData=(RPacketService::TPacketReleaseMode)iCurrentPacketReleaseMode; + ReqCompleted(iNotifyChangeOfReleaseMode.iNotifyHandle,KErrNone); + } + + iPacketReleaseModeIndex++; + if (iPacketReleaseModeArray->Count() > (iPacketReleaseModeIndex)) + { + // start timer again + iReleaseModeTimer->Start(iPacketReleaseModeArray->At(iPacketReleaseModeIndex).iDuration,this,ETimerIdPcktServReleaseMode); + } + } + +void CSimPacketService::TimerCallBackPcktRegStatus() +/** +* Timer Call back for the Network Registration status. +* +*/ + { + iState=(RPacketService::TStatus)iPcktRegStatusInfo->At(iPcktRegStatIndex).iStatus; + + if(iNotifyStatusChange.iNotifyPending) + { + iNotifyStatusChange.iNotifyPending=EFalse; + *(RPacketService::TStatus*)iNotifyStatusChange.iNotifyData=(RPacketService::TStatus)iState; + ReqCompleted(iNotifyStatusChange.iNotifyHandle,KErrNone); + } + + // please note that this bool is in case the test code is setting + // iState to another value, in which case the request will not complete + // unless this bool is set and therefore the request will complete + // in ActionEvent() + if (iCurrentEvent != EPacketEventNone) + iPcktTimerBool = ETrue; + + iPcktRegStatIndex++; + if (iPcktRegStatusInfo->Count() > iPcktRegStatIndex) + { + iPcktRegTimer->Start(iPcktRegStatusInfo->At(iPcktRegStatIndex).iDuration,this,ETimerIdPcktServPacket); + } + } + +void CSimPacketService::SimPSEvent(const CSimPubSub::TPubSubProperty aProperty, TInt aStatus) + { + + + if (aProperty == iNtwkRegStatusChangeProperty) + { // The call is for the network. + TInt index = aStatus; + TInt length = iNtwkRegStatusInfo->Count(); + if (index < length) + { + TNtwkRegStatus& ntwkRegStatus = iNtwkRegStatusInfo->At(index); + CompleteNtwkRegStatus(ntwkRegStatus.iRegStatus); + } + } + else if ( iIncomingContextManager->IsForcedIncoming( aProperty ) ) + { // Lets force the completion of the PDP, rather than waiting around + // for a large time to finish. + TInt index = aStatus; + iIncomingContextManager->ForcedIncoming( index, iConfigData.iData ); + iIncomingContextManager->SetUseTimerOff(); + ReqCompleted(iConfigData.iTsyReqHandle,KErrNone); + // Force the change through as if the timer had timed out. + iIncomingContextManager->SetUseTimerOn(); + // May get more timeouts for other primary PDP's. + } + else + { // Error. Some sort of stange request. Hopefully impossible. + LOGPACKET1("CSimPacketService::SimPSEvent property mismatch."); + SimPanic(EFailedToSetProperty); + } + + } + +void CSimPacketService::PubSubCallback(TInt aIndex) + { + + if(aIndex ==0 ) + { + ReqCompleted(iGetMbmsNetworkReqHandle,KErrNone); + } + + else if (aIndex ==1) + { + if(iNotifyMbmsServAvailChange.iNotifyPending) + { + iNotifyMbmsServAvailChange.iNotifyPending = EFalse; + ReqCompleted(iNotifyMbmsServAvailChange.iNotifyHandle,KErrNone); + } + } + + else if(aIndex ==2) + { + if(iUpdateMbmsServiceReqHandle) + { + ReqCompleted(iUpdateMbmsServiceReqHandle,iUpdateMbmsServiceError); + } + } + + else if(aIndex ==3) + { + ReqCompleted(iEnumerateActiveListReqHandle,KErrNone); + } + + else if(aIndex ==4) + { + ReqCompleted(iEnumerateMonitorListReqHandle,KErrNone); + } + + else {} +} + +void CSimPacketService::TimerCallBackNtwkRegStatus() + { + if(iNtwkRegStatusInfo->Count()<=iNtwkRegStatIndex) + return; + + TNtwkRegStatus& ntwkRegStatus = iNtwkRegStatusInfo->At(iNtwkRegStatIndex); + CompleteNtwkRegStatus(ntwkRegStatus.iRegStatus); + + iNtwkRegStatIndex++; + if(iNtwkRegStatusInfo->Count()>iNtwkRegStatIndex) + iNtwkRegTimer->Start(iNtwkRegStatusInfo->At(iNtwkRegStatIndex).iDuration,this,ETimerIdPcktServNtwkStatusChange); + } + +void CSimPacketService::CompleteNtwkRegStatus(RPacketService::TRegistrationStatus aRegistrationStatus) + { + iCurrentRegStatus = aRegistrationStatus; + + if(iNotifyChangeOfNtwk.iNotifyPending) + { + iNotifyChangeOfNtwk.iNotifyPending=EFalse; + *(RPacketService::TRegistrationStatus*)iNotifyChangeOfNtwk.iNotifyData=(RPacketService::TRegistrationStatus)iCurrentRegStatus; + ReqCompleted(iNotifyChangeOfNtwk.iNotifyHandle,KErrNone); + } + + if (//iCurrentRegStatus == RPacketService::ENotRegisteredSearching || + iCurrentRegStatus == RPacketService::ERegistrationDenied || + iCurrentRegStatus == RPacketService::ENotRegisteredButAvailable || + iCurrentRegStatus == RPacketService::ENotRegisteredAndNotAvailable) + { + // deactivate all contexts in every nif + TInt totalWrappers = iNifWrappers.Count(); + for(TInt j=0; j < totalWrappers; j++) + { + TInt totalContexts = iNifWrappers[j].NumberOfContexts(); + for(TInt x =0; xAttemptDeactivateImmediately(); + } + } + } +} + +TInt CSimPacketService::ChangeState(RPacketService::TStatus 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 aState the new state to change to +* @return Error indication if change of state is successful or not +*/ + { + LOGPACKET2(">>CSimPacketService::ChangeState [newState=%d]", aNewState); + if(iState == aNewState) + return KErrNone; + + TInt ret=KErrGeneral; + const TPacketStateChangeValidity* stateChangePnt=KPacketStateChangeValidity; + while(stateChangePnt->iOldState!=KPacketStateTableTerminator) + { + 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 = iPhone->ValidateChangeState(aNewState); + if(ret!=KErrNone) + return ret; + +// Actually change the state. + iState=aNewState; + +// if suspended or unattached take appropriate action + if (iState==RPacketService::EStatusSuspended || iState == RPacketService::EStatusUnattached) + { + // deactivate all contexts in every nif + TInt totalWrappers = iNifWrappers.Count(); + for(TInt j=0; j < totalWrappers; j++) + { + TInt totalContexts = iNifWrappers[j].NumberOfContexts(); + for(TInt x =0; xAttemptDeactivateImmediately(); + if(ret!=KErrNone) + { + break; + } + } + } + } + +// Check for a pending line state notification. + if(iNotifyStatusChange.iNotifyPending) + { + iNotifyStatusChange.iNotifyPending=EFalse; + *(RPacketService::TStatus*)iNotifyStatusChange.iNotifyData=iState; + ReqCompleted(iNotifyStatusChange.iNotifyHandle,KErrNone); + } + + LOGPACKET1("<>CSimPacketService::ActionEvent = [EPacketEventAttach]"); + if(iState==RPacketService::EStatusUnattached) + { + iCurrentEvent=EPacketEventAttach; + iTimer->Start(iAttachPause,this); + } + else + ReqCompleted(iAttachRequestHandle, KErrNone); + break; + + case EPacketEventDetach: + LOGPACKET1(">>CSimPacketService::ActionEvent = [EPacketEventDetach]"); + if(iState !=RPacketService::EStatusUnattached) + { + iCurrentEvent=EPacketEventDetach; + iTimer->Start(iDetachPause,this); + } + else + { + ReqCompleted(iDetachRequestHandle, KErrNone); + } + break; + + case EPacketEventTimeOut: + switch(iCurrentEvent) + { + case EPacketEventNone: + break; + case EPacketEventAttach: + if(iAttachFail != KErrNone) + { + ReqCompleted(iAttachRequestHandle,iAttachFail); + iCurrentEvent=EPacketEventNone; + iAttachFail = KErrNone; + break; + } + if(iState==RPacketService::EStatusUnattached) + { + ret=ChangeState(RPacketService::EStatusAttached); + ReqCompleted(iAttachRequestHandle,ret); + } + else if (iPcktTimerBool) + { + ReqCompleted(iAttachRequestHandle,KErrNone); + iPcktTimerBool= EFalse; + } + iCurrentEvent=EPacketEventNone; + break; + case EPacketEventDetach: + if(iDetachFail != KErrNone) + { + ReqCompleted(iDetachRequestHandle,iDetachFail); + iCurrentEvent=EPacketEventNone; + iDetachFail = KErrNone; + break; + } + ret = DoDetach(); + if (iPcktTimerBool) + { + ReqCompleted(iDetachRequestHandle,KErrNone); + iPcktTimerBool= EFalse; + } + iCurrentEvent=EPacketEventNone; + break; + default: + break; + } + break; + + default: + break; + } + return ret; + } + +const CTestConfigSection* CSimPacketService::CfgFile() +/** +* Return a pointer to the Configuration File Section +* +* @return CTestConfigSection pointer to the configuration file section +*/ + { + return iPhone->CfgFile(); + } + +/** +* check that there is a primary context and that opening a secondary +* is a valid action +**/ +TInt CSimPacketService::PrepareOpenSecondary(const TTsyReqHandle aTsyReqHandle, const TDesC* aOriginalContextName) + { + TInt i = 0; + TInt err = KErrNone; + + for(i = 0; iContextName().Compare(*aOriginalContextName) == KErrNone) + { + iSecondaryContext = ETrue; + iCurrentPrimaryContextIndex = i; + break; + } + } + } + + if (iSecondaryContext == EFalse) + err = KErrNotSupported; + + ReqCompleted(aTsyReqHandle, err); + return err; + } + +TInt CSimPacketService::GetCurrentReleaseMode(const TTsyReqHandle aTsyReqHandle,RPacketService::TPacketReleaseMode* aReleaseMode) +// return current release mode + { + LOGPACKET1("CSimPacketService::GetCurrentReleaseMode called"); + *aReleaseMode = (RPacketService::TPacketReleaseMode)iCurrentPacketReleaseMode; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +TInt CSimPacketService::NotifyReleaseModeChange(const TTsyReqHandle aTsyReqHandle, RPacketService::TPacketReleaseMode* aReleaseMode) + { + // if release mode has changed + if(iPacketReleaseModeArray->Count()==0) + { + ReqCompleted(aTsyReqHandle,KErrNotSupported); + return KErrNotSupported; + } + + __ASSERT_ALWAYS(!iNotifyChangeOfReleaseMode.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding)); + + iNotifyChangeOfReleaseMode.iNotifyPending=ETrue; + iNotifyChangeOfReleaseMode.iNotifyHandle=aTsyReqHandle; + iNotifyChangeOfReleaseMode.iNotifyData=&aReleaseMode; + return KErrNone; + } + +TInt CSimPacketService::EnumerateNifs(const TTsyReqHandle aTsyReqHandle, TInt& aCount) + { +// return number of nifs + aCount = iNifWrappers.Count(); + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +TInt CSimPacketService::GetNifInfo(const TTsyReqHandle aTsyReqHandle, TInt aIndex, TDes8* aNifInfoV2) + { +// get info for nif + TInt range = iNifWrappers.Count()-1; + if (aIndex < 0 || aIndex > range) + { + ReqCompleted(aTsyReqHandle,KErrArgument); + return KErrArgument; + } + + RPacketService::TNifInfoV2Pckg* nifInfoV2Pckg = (RPacketService::TNifInfoV2Pckg*)aNifInfoV2; + RPacketService::TNifInfoV2& nifInfoV2 = (*nifInfoV2Pckg)(); + + // Check that the data structure is supported by the simulated TSY version + TInt err = iPhone->CheckSimTsyVersion(nifInfoV2); + if(err != KErrNone) + { + iPhone->ReqCompleted(aTsyReqHandle, err); + return KErrNone; + } + + nifInfoV2.iContextName.Copy(iNifWrappers[aIndex].GetContext(0)->ContextName()); + nifInfoV2.iContextType = STATIC_CAST(RPacketService::TContextType, iNifWrappers[aIndex].GetContext(0)->ContextType()); + + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + +/*** +* This function takes the name passed in the parameter aExistingContextName and +* returns the number of contexts sharing its Nif. +***/ +TInt CSimPacketService::EnumerateContextsInNif(const TTsyReqHandle aTsyReqHandle, const TDesC* aExistingContextName, TInt& aCount) + { + // find contexts sharing name aExistingContextName, ie primary and secondary as well + TInt number = KErrNotFound; + TInt wrappersCount = iNifWrappers.Count(); + + for(TInt i = 0; iContextName().Compare(*aExistingContextName) == KErrNone) + { + number = iNifWrappers[i].NumberOfContexts(); + break; + } + } + } + + // ie couldn't find context of aExistingContextName + if (number == KErrNotFound) + { + ReqCompleted(aTsyReqHandle, KErrArgument); + return KErrArgument; + } + + // count primary context as well! + aCount = number; + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +TInt CSimPacketService::GetContextNameInNif(const TTsyReqHandle aTsyReqHandle, const TDesC* aExistingContextName, TInt aIndex, TDes* aContextName) + { +// get for context name specified, find nif's context name at index given + // first, check aExistingContextName exists in contexts + TInt number = KErrNotFound; + TInt wrappersCount = iNifWrappers.Count(); + + for(TInt i = 0; iContextName().Compare(*aExistingContextName) == KErrNone) + { + number = i; + break; + } + } + } + + // total no. of contexts with name is number of secondary contexts plus primary, so + // number + 1 + // so range should be within number+1-1 ie number. + if (number == KErrNotFound || aIndex < 0 || aIndex > number) + { + ReqCompleted(aTsyReqHandle, KErrArgument); + return KErrArgument; + } + + *aContextName = iNifWrappers[number].GetContext(aIndex)->ContextName(); + ReqCompleted(aTsyReqHandle, KErrNone); + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::GetCurrentReleaseModeCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::NotifyReleaseModeChangeCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGPACKET1("CSimPacketService::NotifyChangeOfNtwkRegStatusCancel called"); + if(iNotifyChangeOfReleaseMode.iNotifyPending) + { + iNotifyChangeOfReleaseMode.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::EnumerateNifsCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::GetNifInfoCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::EnumerateContextsInNifCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::GetContextNameInNifCancel(const TTsyReqHandle /*aTsyReqHandle*/) + { + return KErrNone; + } + +/** +* Cancel method, returns KErrNone +*/ +TInt CSimPacketService::NotifyAttachModeChangeCancel(const TTsyReqHandle aTsyReqHandle) + { + LOGPACKET1("CSimPacketService::NotifyAttachModeChangeCancel called"); + if(iNotifyChangeOfAttachMode.iNotifyPending) + { + iNotifyChangeOfAttachMode.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::GetMbmsNetworkServiceStatus(const TTsyReqHandle aTsyReqHandle, TBool aAttemptAttach,TMbmsNetworkServiceStatus* aStatus) +/** +* Retrieves and returns the status of the MBMS Packet service +* +* @param aTsyReqHandle Tsy Request handle for the client request +* @param aStatus pointer to the status +* @return TInt err KErrNone if ok +*/ + { + LOGPACKET1("CSimPacketService::GetMbmsNetworkServiceStatus called"); + *aStatus = (iMbmsBroadcastParamsArray->At(iCurrentMbmsParamsIndex).iMbmsNetworkStatus); + if(aAttemptAttach) + { + if(*aStatus == EMbmsSupportUnknown) + { + *aStatus = EMbmsSupported; + } + } + iGetMbmsNetworkReqHandle = aTsyReqHandle; + iCurrentMbmsParamsIndex++; + TInt totCount = iMbmsBroadcastParamsArray->Count(); + if(iCurrentMbmsParamsIndex == totCount) + { + iCurrentMbmsParamsIndex--; + } + return KErrNone; + } + +TInt CSimPacketService::GetMbmsNetworkServiceStatusCancel(const TTsyReqHandle aTsyReqHandle) +/* + * Cancels the GetMBMSNetworkServiceStatus request. + * In fact this is not needed- just to avoid Panic if called, this implementation is done. + */ + { + if(iGetMbmsNetworkReqHandle == aTsyReqHandle) + { + ReqCompleted(iGetMbmsNetworkReqHandle,KErrCancel); + } + else + { + ReqCompleted(iGetMbmsNetworkReqHandle,KErrCorrupt); + } + return KErrNone; + } + +TInt CSimPacketService::NotifyMbmsNetworkServiceStatusChange(const TTsyReqHandle aTsyReqHandle, TMbmsNetworkServiceStatus* aStatus) +/** +* Record a client's interest in being notified of the state of the MBMS packet network and 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 aStatus pointer to the mbms packet service status +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::NotifyMbmsNetworkServiceStatusChange called"); + __ASSERT_ALWAYS(!iNotifyMbmsNetworkStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyMbmsNetworkStatusChange.iNotifyPending = ETrue; + iNotifyMbmsNetworkStatusChange.iNotifyHandle = aTsyReqHandle; + iNotifyMbmsNetworkStatusChange.iNotifyData = aStatus; + return KErrNone; + } + +TInt CSimPacketService::NotifyMbmsNetworkServiceStatusChangeCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when the mbms network 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("CSimPacketService::NotifyMbmsNetworkServiceStatusChangeCancel called"); + if(iNotifyMbmsNetworkStatusChange.iNotifyPending) + { + iNotifyMbmsNetworkStatusChange.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::NotifyMbmsServiceAvailabilityChange(const TTsyReqHandle aTsyReqHandle) +/** +* Record a client's interest in being notified of the service availability of the MBMS packet network. +* 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 +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::NotifyMbmsServiceAvailabilityChange called"); + __ASSERT_ALWAYS(!iNotifyMbmsNetworkStatusChange.iNotifyPending,SimPanic(ENotificationAlreadyPending)); + + iNotifyMbmsServAvailChange.iNotifyPending = ETrue; + iNotifyMbmsServAvailChange.iNotifyHandle = aTsyReqHandle; + (void)iNotifyMbmsServAvailChange.iNotifyData; + return KErrNone; + } + +TInt CSimPacketService::NotifyMbmsServiceAvailabilityChangeCancel(const TTsyReqHandle aTsyReqHandle) +/** +* Cancel a client's interest in being notified when the mbms service availability 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("CSimPacketService::NotifyMbmsServiceAvailabilityChangeCancel called"); + if(iNotifyMbmsServAvailChange.iNotifyPending) + { + iNotifyMbmsServAvailChange.iNotifyPending=EFalse; + ReqCompleted(aTsyReqHandle,KErrCancel); + } + return KErrNone; + } + +TInt CSimPacketService::UpdateMbmsMonitorServiceListL(const TTsyReqHandle aTsyReqHandle,TMbmsAction* aAction, TDes8* aBuffer) +/** +* client's interest in updating the MBMS Service Monitoring list. +* The update action is also passed as the MBMS Action parameter. +* This will update the MBMS Service Monitoring List in TSY. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aAction TMbmsAction to be performed +* @param aBuffer list of TMbmsServiceAvailabilityV1 class passed. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListL called"); + CPcktMbmsMonitoredServiceList* monServList = CPcktMbmsMonitoredServiceList::NewL(); + CleanupStack::PushL(monServList); + + TInt error=KErrNone; + TInt i=0; + TInt j=0; + TInt ii=0; + TInt countAdd=0; + TInt countRem=0; + RPacketService::TMbmsServiceAvailabilityV1 entry; + + switch(*aAction) + { + case SIMTSY_PACKET_MBMS_ADD_ENTRIES: + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListL Action: ADD "); + monServList->RestoreL(*aBuffer); + countAdd = monServList->Enumerate(); + if(countAdd != SIMTSY_PACKET_MBMS_ADD_ENTRIES_COUNT) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + CleanupStack::PopAndDestroy(); // monServList + return KErrNone; + } + for(;iGetEntryL(i)); + if (ret != KErrNone) + { + break; + } + TBool entryFound=EFalse; + + for(ii=0;iiCount();ii++) + { + if((entry.iMbmsServiceMode == iMbmsMonitorListParamsArray->At(ii).iServiceMode) && + (entry.iMbmsAccessBearer == iMbmsMonitorListParamsArray->At(ii).iAccessBearer) && + (entry.iTmgi.GetMCC() == iMbmsMonitorListParamsArray->At(ii).iMCC) && + (entry.iTmgi.GetMNC() == iMbmsMonitorListParamsArray->At(ii).iMNC) && + (entry.iTmgi.GetServiceId() == iMbmsMonitorListParamsArray->At(ii).iServiceId)) + { + entryFound = ETrue; + break; + } + } + + if(!entryFound) + { + error = KErrMbmsImpreciseServiceEntries; + } + + else + { + entry.iMbmsAvailabilityStatus = iMbmsMonitorListParamsArray->At(ii).iAvailStatus ; + } + + } + iMbmsMonitorListCount += i; + if(iMbmsMonitorListCount > KMaxMbmsMonitorContexts) + { + error =KErrNoMemory; + iMbmsMonitorListCount -= i; + } + + ReqCompleted(aTsyReqHandle, error); + CleanupStack::PopAndDestroy(); // monServList + break; + + case SIMTSY_PACKET_MBMS_REM_ENTRIES: + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListL Action: REMOVE "); + monServList->RestoreL(*aBuffer); + countRem = monServList->Enumerate(); + if(countRem != SIMTSY_PACKET_MBMS_REM_ENTRIES_COUNT) + { + ReqCompleted(aTsyReqHandle,KErrCorrupt); + CleanupStack::PopAndDestroy(); // monServList + return KErrNone; + } + + for(;iGetEntryL(i)); + + if (ret != KErrNone) + { + break; + } + + TBool entryFound=EFalse; + + for(ii=0;iiCount();ii++) + { + if((entry.iMbmsServiceMode == iMbmsMonitorListParamsArray->At(ii).iServiceMode) && + (entry.iMbmsAccessBearer == iMbmsMonitorListParamsArray->At(ii).iAccessBearer) && + (entry.iTmgi.GetMCC() == iMbmsMonitorListParamsArray->At(ii).iMCC) && + (entry.iTmgi.GetMNC() == iMbmsMonitorListParamsArray->At(ii).iMNC) && + (entry.iTmgi.GetServiceId() == iMbmsMonitorListParamsArray->At(ii).iServiceId)) + { + entryFound = ETrue; + break; + } + } + + if(!entryFound) + { + j++; + error = KErrMbmsImpreciseServiceEntries; + } + + else + { + entry.iMbmsAvailabilityStatus = iMbmsMonitorListParamsArray->At(ii).iAvailStatus ; + iMbmsMonitorListParamsArray->Delete(ii); + } + + } + if(j == SIMTSY_PACKET_MBMS_REM_ENTRIES_COUNT) + { + error = KErrNotFound; + } + + if(iMbmsMonitorListCount >=j) + { + iMbmsMonitorListCount -= j; + } + + iUpdateMbmsServiceError = error; + iUpdateMbmsServiceReqHandle = aTsyReqHandle; + + CleanupStack::PopAndDestroy(); // monServList + break; + + case SIMTSY_PACKET_MBMS_REM_ALL_ENTRIES: + iMbmsMonitorListCount = 0; + iMbmsMonitorListParamsArray->Delete(0,iMbmsMonitorListParamsArray->Count()); + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListL Action: REMOVE_ALL "); + iUpdateMbmsServiceError = KErrNone; + iUpdateMbmsServiceReqHandle = aTsyReqHandle; + CleanupStack::PopAndDestroy(); // monServList + break; + + default: + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListL Action: Default "); + ReqCompleted(aTsyReqHandle,KErrNotFound); + CleanupStack::PopAndDestroy(); // monServList + break; + } + return KErrNone; + } + +TInt CSimPacketService::UpdateMbmsMonitorServiceListCancel(const TTsyReqHandle aTsyReqHandle) +/** +* client's interest in cancelling the updation MBMS Service Monitoring list. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::UpdateMbmsMonitorServiceListCancel Called "); + ReqCompleted(aTsyReqHandle,KErrCancel); + return KErrNone; + } + +// CHANGES FOR 2 Phase retrieval of MBMS Monitored Services list starts here. + +TInt CSimPacketService::GetMbmsMonitoredServicesListPhase1(const TTsyReqHandle aTsyReqHandle, TClientId* aClient, TInt* aBufSize) +/** +* client's interest in retrieving the MBMS Service Monitoring list. +* This function is the call for the first phase of 2 phase retrieval. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aAction TClientId to be used +* @param aBufSize Size to be allocated for retrieving the actual list in second phase. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetMbmsMonitoredServicesListPhase1 called"); + TInt ret=KErrNone; + TInt leaveCode=KErrNone; + TRAP(leaveCode, ret=ProcessGetMbmsMonitoredServicesListPhase1L(aTsyReqHandle, aClient, aBufSize);); + if (leaveCode != KErrNone) + { + ReqCompleted(aTsyReqHandle,leaveCode); + } + return ret; + } + +TInt CSimPacketService::ProcessGetMbmsMonitoredServicesListPhase1L(const TTsyReqHandle aTsyReqHandle, + TClientId* aClient, + TInt* aBufSize) +/** +* Local function to perform the first phse of the 2 phase retrieval. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aAction TClientId to be used +* @param aBufSize Size to be allocated for retrieving the actual list in second phase. +* @return KErrNone +*/ + { + + LOGPACKET1("CSimPacketService::ProcessGetMbmsMonitoredServicesListPhase1L called"); + CPcktMbmsMonitoredServiceList* list=CPcktMbmsMonitoredServiceList::NewL(); + CleanupStack::PushL(list); + + RPacketService::TMbmsServiceAvailabilityV1 entry; + + for (TInt i=0; i Count(); i++) + { + entry.iMbmsServiceMode = iMbmsMonitorListParamsArray->At(i).iServiceMode; + entry.iMbmsAccessBearer = iMbmsMonitorListParamsArray->At(i).iAccessBearer; + entry.iMbmsAvailabilityStatus = iMbmsMonitorListParamsArray->At(i).iAvailStatus; + entry.iTmgi.SetMCC(iMbmsMonitorListParamsArray->At(i).iMCC); + entry.iTmgi.SetMNC(iMbmsMonitorListParamsArray->At(i).iMNC); + entry.iTmgi.SetServiceId(iMbmsMonitorListParamsArray->At(i).iServiceId); + // Add the entry into the list, at the next empty location + LOGPACKET2("Adding the Entry no. %d to the List",i+1); + list->AddEntryL(entry); + } + + // Store the streamed list and the client ID + CPcktListReadAllAttempt* read=CPcktListReadAllAttempt::NewL(*aClient,aTsyReqHandle); + CleanupStack::PushL(read); + + read->iListBuf = list->StoreLC(); + CleanupStack::Pop(); // pop the CBufBase allocated by StoreLC + + iMbmsServicesList->AppendL(read); + CleanupStack::Pop(); // pop the CPcktListReadAllAttempt + + // return the CBufBase size to client + *aBufSize=(read->iListBuf)->Size(); + + // Complete first phase of list retrieval + ReqCompleted(aTsyReqHandle,KErrNone); + CleanupStack::PopAndDestroy(); // pop&destroy list + + return KErrNone; + } + +TInt CSimPacketService::GetMbmsMonitoredServicesListPhase2(const TTsyReqHandle aTsyReqHandle,TClientId* aClient, TDes8* aBuf) +/** +* client's interest in retrieving the MBMS Service Monitoring list. +* This function is the call for the second phase of 2 phase retrieval. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aAction TClientId to be used +* @param aBuf buffer for the actual list to be populated. +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetMbmsMonitoredServicesListPhase2 called"); + CPcktListReadAllAttempt* read=NULL; + // Find the get MBMS Monitor Service List from this client + for (TInt i=0; iCount(); ++i) + { + read = iMbmsServicesList->At(i); + if ((read->iClient.iSessionHandle==aClient->iSessionHandle) && + (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle)) + { + TPtr8 bufPtr((read->iListBuf)->Ptr(0)); + // Copy the streamed list to the client + aBuf->Copy(bufPtr); + delete read; + + iMbmsServicesList->Delete(i); + ReqCompleted(aTsyReqHandle,KErrNone); + return KErrNone; + } + } + // Should handle error case of not finding the matching client from read all phase 1 + return KErrNotFound; + } + +TInt CSimPacketService::GetMbmsMonitoredServicesListCancel(const TTsyReqHandle aTsyReqHandle) +/** +* client's interest in canceling the retrieval of the MBMS Service Monitoring list. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::GetMbmsMonitoredServicesListCancel called"); + // Remove the read all attempt from iGetMbmsMonitoredServices + + CPcktListReadAllAttempt* read=NULL; + for (TInt i=0; iCount(); ++i) + { + read = iMbmsServicesList->At(i); + if (read->iReqHandle == aTsyReqHandle) + { + delete read; + iMbmsServicesList->Delete(i); + break; + } + } + ReqCompleted(aTsyReqHandle,KErrCancel); + return KErrNone; + } + +TInt CSimPacketService::EnumerateMbmsMonitorServiceList(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed) +/** +* client's interest in retrieving the information regarding the MBMS Monitoring Service list. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aCount count of the MBMS monitoring services in the list +* @param aMaxAllowed maximum MBMS monitoring services allowed +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::EnumerateMbmsMonitorServiceList called"); + *aCount = iMbmsMonitorListCount; + *aMaxAllowed = KMaxMbmsMonitorContexts; + iEnumerateMonitorListReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSimPacketService::EnumerateMbmsMonitorServiceListCancel(const TTsyReqHandle aTsyReqHandle) +/** +* client's interest in canceling the enumeration the MBMS Service Monitoring list. +* This function is just a dummy function. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + if(iEnumerateMonitorListReqHandle == aTsyReqHandle) + { + ReqCompleted(iEnumerateMonitorListReqHandle,KErrCancel); + } + else + { + ReqCompleted(iEnumerateMonitorListReqHandle,KErrCorrupt); + } + return KErrNone; + } + +TInt CSimPacketService::EnumerateMbmsActiveServiceList(const TTsyReqHandle aTsyReqHandle, TInt* aCount, TInt* aMaxAllowed) +/** +* client's interest in retrieving the information regarding the MBMS Active Service list. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @param aCount count of the MBMS active services in the list +* @param aMaxAllowed maximum MBMS active services allowed +* @return KErrNone +*/ + { + LOGPACKET1("CSimPacketService::EnumerateMbmsActiveServiceList called"); + *aCount = iMbmsNifWrappers.Count(); // The NifWrapper contains the list of mbmsContexts that are activated. + *aMaxAllowed = KMaxMbmsActiveContexts; + iEnumerateActiveListReqHandle = aTsyReqHandle; + return KErrNone; + } + +TInt CSimPacketService::EnumerateMbmsActiveServiceListCancel(const TTsyReqHandle aTsyReqHandle) +/** +* client's interest in canceling the enumeration the MBMS Service active list. +* This function is just a dummy function. +* +* @param aTsyReqHandle Tsy Request handle for the client cancel request +* @return KErrNone +*/ + { + if(iEnumerateActiveListReqHandle == aTsyReqHandle) + { + ReqCompleted(iEnumerateActiveListReqHandle,KErrCancel); + } + else + { + ReqCompleted(iEnumerateActiveListReqHandle,KErrCorrupt); + } + return KErrNone; + } + +/** +* A CSimPacketContext object has been destroyed - this method will be called in its +* destructor +*/ +void CSimPacketService::DecrementContextCount() + { + iContextCount--; + } + +/** +* A CSimPacketContext object has been destroyed - this method will be called in its +* destructor +*/ +void CSimPacketService::DecrementMbmsContextCount() + { + iMbmsContextCount--; + } + +