--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cmmanager/cmmgr/cmmplugins/cmpluginpacketdata/src/cmpluginpacketdata.cpp Tue Aug 31 15:35:44 2010 +0300
@@ -0,0 +1,2894 @@
+/*
+* Copyright (c) 2009-2010 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:
+* Implementation of packetdata Plugin interface.
+*
+*/
+
+
+#include <StringLoader.h>
+#include <featmgr.h>
+#include <centralrepository.h>
+#include <CoreApplicationUIsSDKCRKeys.h>
+
+#include "datamobilitycommsdattypes.h"
+#include "cmpluginpacketdata.h"
+
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmpluginpacketdataTraces.h"
+#endif
+
+using namespace CMManager;
+using namespace CommsDat;
+
+// ================= CONSTANTS =======================
+
+/// Modem bearer names for GPRS/WCDMA access points.
+_LIT( KModemBearerPacketData, "GPRS Modem" );
+_LIT( KDefaultQosDataRecordName, "PRIMARY1" );
+_LIT( KDefaultQosDataRecordNamewithSpace, "PRIMARY1 " );
+
+const TInt KQosRecordIndex = 0;
+
+// ======== MEMBER FUNCTIONS ========
+/**
+* CCmPDCoverageCheck defines the functionality for packetdata service
+* coverage checking.
+*/
+class CCmPDCoverageCheck : public CActive
+ {
+ public:
+ /**
+ * Constructor.
+ */
+ CCmPDCoverageCheck();
+
+ /**
+ * Destructor.
+ */
+ ~CCmPDCoverageCheck();
+
+ /**
+ * Checks if the packet service is available(status is
+ * ERegisteredOnHomeNetwork or ERegisteredRoaming or
+ * ENotRegisteredButAvailable)
+ * @return Return ETrue if the status is one mentioned above.
+ * Otherwise returns EFalse.
+ */
+ TBool IsThereCoverageL();
+
+ protected: // from CActive
+ virtual void DoCancel();
+ virtual void RunL();
+
+ private:
+ /**
+ * Ckecks if the phode mode is offline.
+ * @return Returns ETrue if the phone is in offline mode.
+ * Otherwise returns EFalse.
+ */
+ TBool IsPhoneOfflineL() const;
+
+ private:
+ /** Boolean which has the latest coverage information */
+ TBool iCoverage;
+
+ /** Controller for single scheduling loop */
+ CActiveSchedulerWait iWait;
+
+ /** Handle to telephony server */
+ RTelServer iServer;
+
+ /** Handle to phone(needed for packet service) */
+ RPhone iPhone;
+
+ /** Handle to packet service */
+ RPacketService iService;
+
+ /** Network registration status information */
+ RPacketService::TRegistrationStatus iNwRegStatus;
+ };
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::CCmPDCoverageCheck()
+// ----------------------------------------------------------------------------
+//
+CCmPDCoverageCheck::CCmPDCoverageCheck() : CActive( EPriorityStandard )
+ {
+ OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_ENTRY );
+
+ CActiveScheduler::Add( this );
+
+ OstTraceFunctionExit0( CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::~CCmPDCoverageCheck()
+// ----------------------------------------------------------------------------
+//
+CCmPDCoverageCheck::~CCmPDCoverageCheck()
+ {
+ OstTraceFunctionEntry0( DUP1_CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_ENTRY );
+
+ Cancel();
+
+ iService.Close();
+ iPhone.Close();
+ iServer.Close();
+
+ OstTraceFunctionExit0( DUP1_CCMPDCOVERAGECHECK_CCMPDCOVERAGECHECK_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::DoCancel
+// ----------------------------------------------------------------------------
+//
+void CCmPDCoverageCheck::DoCancel()
+ {
+ OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_DOCANCEL_ENTRY );
+
+ iWait.AsyncStop();
+
+ OstTraceFunctionExit0( CCMPDCOVERAGECHECK_DOCANCEL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::RunL
+// ----------------------------------------------------------------------------
+//
+void CCmPDCoverageCheck::RunL()
+ {
+ OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_RUNL_ENTRY );
+
+ if ( iStatus.Int() == KErrNone )
+ {
+ if ( iNwRegStatus == RPacketService::ERegisteredOnHomeNetwork ||
+ iNwRegStatus == RPacketService::ERegisteredRoaming ||
+ iNwRegStatus == RPacketService::ENotRegisteredButAvailable )
+ {
+ iCoverage = ETrue;
+ }
+ iWait.AsyncStop();
+ }
+ else
+ // something went wrong -> no coverage.
+ {
+ iWait.AsyncStop();
+ }
+
+ OstTraceFunctionExit0( CCMPDCOVERAGECHECK_RUNL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::IsThereCoverageL
+// ----------------------------------------------------------------------------
+//
+TBool CCmPDCoverageCheck::IsThereCoverageL()
+ {
+ OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_ISTHERECOVERAGEL_ENTRY );
+
+ iCoverage = EFalse;
+
+ if ( !IsPhoneOfflineL() )
+ {
+ User::LeaveIfError( iServer.Connect() );
+
+ RTelServer::TPhoneInfo info;
+ User::LeaveIfError( iServer.GetPhoneInfo( 0, info ) );
+
+ User::LeaveIfError( iPhone.Open(iServer, info.iName ) );
+
+ User::LeaveIfError( iService.Open( iPhone ) );
+
+ iService.GetNtwkRegStatus( iStatus, iNwRegStatus );
+ SetActive();
+ iWait.Start();
+
+ User::LeaveIfError( iStatus.Int() );
+ }
+
+ OstTraceFunctionExit0( CCMPDCOVERAGECHECK_ISTHERECOVERAGEL_EXIT );
+ return iCoverage;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPDCoverageCheck::IsPhoneOfflineL
+// ----------------------------------------------------------------------------
+//
+TBool CCmPDCoverageCheck::IsPhoneOfflineL() const
+ {
+ OstTraceFunctionEntry0( CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_ENTRY );
+
+ if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )
+ {
+ CRepository* repository = CRepository::NewLC( KCRUidCoreApplicationUIs );
+ TInt connAllowed( ECoreAppUIsNetworkConnectionAllowed );
+
+ repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );
+ CleanupStack::PopAndDestroy( repository );
+
+ if ( !connAllowed )
+ {
+ OstTraceFunctionExit0( CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_EXIT );
+ return ETrue;
+ }
+ }
+
+ OstTraceFunctionExit0( DUP1_CCMPDCOVERAGECHECK_ISPHONEOFFLINEL_EXIT );
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::NewL
+// ----------------------------------------------------------------------------
+//
+CCmPluginPacketData* CCmPluginPacketData::NewL(
+ TCmPluginInitParam* aInitParam )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_NEWL_ENTRY );
+
+ CCmPluginPacketData* self = new( ELeave ) CCmPluginPacketData( aInitParam, ETrue );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_NEWL_EXIT );
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::~CCmPluginPacketData
+// ----------------------------------------------------------------------------
+//
+CCmPluginPacketData::~CCmPluginPacketData()
+ {
+ OstTraceFunctionEntry1( CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_ENTRY, this );
+
+ ResetBearerRecords();
+
+ OstTraceFunctionExit1( CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_EXIT, this );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CreateInstanceL
+// ----------------------------------------------------------------------------
+//
+CCmPluginBaseEng* CCmPluginPacketData::CreateInstanceL( TCmPluginInitParam& aInitParam ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CREATEINSTANCEL_ENTRY );
+
+ CCmPluginPacketData* self = new( ELeave ) CCmPluginPacketData( &aInitParam, ETrue );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CREATEINSTANCEL_EXIT );
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CCmPluginPacketData
+// ----------------------------------------------------------------------------
+//
+CCmPluginPacketData::CCmPluginPacketData(
+ TCmPluginInitParam* aInitParam,
+ TBool aOutgoing )
+ :
+ CCmPluginBaseEng( aInitParam ),
+ iOutgoing( aOutgoing )
+ {
+ OstTraceFunctionEntry0( DUP1_CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_ENTRY );
+
+ iBearerType = KUidPacketDataBearerType;
+ iBearerRecordId = 0;
+ iBearerRecordName = NULL;
+ iPacketDataQoSRecord = NULL;
+ iBearerPriorityTableId = 0;
+
+ OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_CCMPLUGINPACKETDATA_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::ConstructL
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::ConstructL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CONSTRUCTL_ENTRY );
+
+ // Feature Manager is initialized by the CmmServer, so no need to do it here.
+
+ CCmPluginBaseEng::ConstructL();
+
+ // Get bearer priority table ID.
+ TRAP_IGNORE( iBearerPriorityTableId =
+ CCDGlobalBearerTypePriorizationRecord::TableIdL( iSession ) );
+
+ if ( !iBearerPriorityTableId )
+ {
+ iBearerPriorityTableId =
+ CCDGlobalBearerTypePriorizationRecord::CreateTableL( iSession );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CONSTRUCTL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CanHandleIapIdL()
+// ----------------------------------------------------------------------------
+//
+TBool CCmPluginPacketData::CanHandleIapIdL( TUint32 aIapId ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_ENTRY );
+
+ TBool retVal( EFalse );
+
+ CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );
+
+ CleanupStack::PushL( iapRecord );
+ iapRecord->SetRecordId( aIapId );
+
+ TRAPD( err, iapRecord->LoadL( iSession ));
+
+ if ( !err )
+ {
+ retVal = CanHandleIapIdL( iapRecord );
+ }
+
+ CleanupStack::PopAndDestroy( iapRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_EXIT );
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CanHandleIapIdL()
+// ----------------------------------------------------------------------------
+//
+TBool CCmPluginPacketData::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const
+ {
+ OstTraceFunctionEntry0( DUP1_CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_ENTRY );
+
+ TBool retVal( EFalse );
+
+ if ( ( TPtrC( aIapRecord->iServiceType ) == TPtrC( KCDTypeNameOutgoingWCDMA ) ||
+ TPtrC( aIapRecord->iServiceType ) == TPtrC( KCDTypeNameIncomingWCDMA )) &&
+ TPtrC( aIapRecord->iBearerType ) == TPtrC( KCDTypeNameModemBearer ) )
+ {
+ retVal = ETrue;
+ }
+
+
+ OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_CANHANDLEIAPIDL_EXIT );
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::PreparePluginToLoadRecordsL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::PreparePluginToLoadRecordsL()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::PreparePluginToUpdateRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::PreparePluginToUpdateRecordsL(
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_PREPAREPLUGINTOUPDATERECORDSL_ENTRY );
+
+ //TODO, Add null checks for mandatory specific record pointers.
+
+ CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>(
+ aGenRecordArray[KIapRecordIndex] );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] );
+
+ CheckIfNameModifiedL( iapRecord, serviceRecord );
+
+ CheckDNSServerAddressL( ETrue,
+ serviceRecord->iGPRSIP6NameServer1,
+ serviceRecord->iGPRSIP6NameServer2,
+ serviceRecord->iGPRSIP6DNSAddrFromServer );
+
+ CheckDNSServerAddressL( EFalse,
+ serviceRecord->iGPRSIPNameServer1,
+ serviceRecord->iGPRSIPNameServer2,
+ serviceRecord->iGPRSIPDNSAddrFromServer );
+
+ SetDaemonNameL( aGenRecordArray, aBearerSpecRecordArray );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_PREPAREPLUGINTOUPDATERECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetDaemonNameL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetDaemonNameL(
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETDAEMONNAMEL_ENTRY );
+
+ // Use DHCP if we can.
+ TBool ipfromSrv = GetBearerBoolAttributeL( EPacketDataIPAddrFromServer,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ if ( ipfromSrv )
+ {
+ SetBearerStringAttributeL( ECmConfigDaemonManagerName,
+ KDaemonManagerName,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ SetBearerStringAttributeL( ECmConfigDaemonName,
+ KConfigDaemonName,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ }
+ else
+ {
+ if ( FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )
+ {
+ SetBearerStringAttributeL( ECmConfigDaemonManagerName,
+ KDaemonManagerName,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ SetBearerStringAttributeL( ECmConfigDaemonName,
+ KConfigDaemonName,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ }
+ else
+ {
+ SetBearerStringAttributeL( ECmConfigDaemonManagerName,
+ KNullDesC(),
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ SetBearerStringAttributeL( ECmConfigDaemonName,
+ KNullDesC(),
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ }
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETDAEMONNAMEL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::LoadBearerRecordsL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::LoadBearerRecordsL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_LOADBEARERRECORDSL_ENTRY );
+
+ if ( ServiceRecord().iUmtsR99QoSAndOnTable )
+ {
+ iPacketDataQoSRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+
+ iPacketDataQoSRecord->SetRecordId( ServiceRecord().iUmtsR99QoSAndOnTable );
+ iPacketDataQoSRecord->LoadL( iSession );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_LOADBEARERRECORDSL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::LoadServiceRecordL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::LoadServiceRecordL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_LOADSERVICERECORDL_ENTRY );
+
+ if ( TPtrC( KCDTypeNameOutgoingWCDMA ) == iIapRecord->iServiceType )
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ iOutgoing = ETrue;
+ }
+ else if ( TPtrC( KCDTypeNameIncomingWCDMA ) == iIapRecord->iServiceType )
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdIncomingGprsRecord ) );
+ iOutgoing = EFalse;
+ }
+ else
+ // this IAP service is not supported by this plugin.
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+ iServiceRecord->SetRecordId( iIapRecord->iService );
+ TRAPD( err, iServiceRecord->LoadL( iSession ) );
+ if ( err == KErrNotFound )
+ // record not found -> create a default one
+ {
+ CreateServiceRecordL();
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_LOADSERVICERECORDL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::ServiceRecord()
+// ----------------------------------------------------------------------------
+//
+CCDWCDMAPacketServiceRecord& CCmPluginPacketData::ServiceRecord() const
+ {
+ return *static_cast<CCDWCDMAPacketServiceRecord*>( iServiceRecord );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CreateServiceRecordL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::CreateServiceRecordL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CREATESERVICERECORDL_ENTRY );
+
+ delete iServiceRecord;
+ iServiceRecord = NULL;
+
+ if ( iOutgoing )
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ }
+ else
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdIncomingGprsRecord ) );
+ }
+
+ ServiceRecord().iGPRSAPN.SetL( KNullDesC );
+ ServiceRecord().iGPRSPDPType.SetL( RPacketContext::EPdpTypeIPv4 );
+ ServiceRecord().iGPRSReqPrecedence = 0;
+ ServiceRecord().iGPRSReqDelay = 0;
+ ServiceRecord().iGPRSReqReliability = 0;
+ ServiceRecord().iGPRSReqPeakThroughput = 0;
+ ServiceRecord().iGPRSReqMeanThroughput = 0;
+ ServiceRecord().iGPRSMinPrecedence = 0;
+ ServiceRecord().iGPRSMinDelay = 0;
+ ServiceRecord().iGPRSMinReliability = 0;
+ ServiceRecord().iGPRSMinPeakThroughput = 0;
+ ServiceRecord().iGPRSMinMeanThroughput = 0;
+ ServiceRecord().iGPRSDataCompression = 0;
+ ServiceRecord().iGPRSHeaderCompression = 0;
+ ServiceRecord().iGPRSAnonymousAccess = 0;
+ ServiceRecord().iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv4 );
+ ServiceRecord().iGPRSIfPromptForAuth = EFalse;
+ ServiceRecord().iGPRSIfAuthRetries = 0;
+ ServiceRecord().iGPRSIPGateway.SetL( KUnspecifiedIPv4 );
+ ServiceRecord().iGPRSIPAddrFromServer = ETrue;
+ ServiceRecord().iGPRSIPAddr.SetL( KUnspecifiedIPv4 );
+ ServiceRecord().iGPRSIPDNSAddrFromServer = ETrue;
+ ServiceRecord().iGPRSIPNameServer1.SetL( KUnspecifiedIPv4 );
+ ServiceRecord().iGPRSIPNameServer2.SetL( KUnspecifiedIPv4 );
+ ServiceRecord().iGPRSIP6DNSAddrFromServer = ETrue;
+ ServiceRecord().iGPRSIP6NameServer1.SetL( KDynamicIpv6Address );
+ ServiceRecord().iGPRSIP6NameServer2.SetL( KDynamicIpv6Address );
+ ServiceRecord().iGPRSEnableLCPExtension = EFalse;
+ ServiceRecord().iGPRSDisablePlainTextAuth = ETrue;
+ ServiceRecord().iGPRSAPType = EPacketDataBoth;
+ ServiceRecord().iGPRSQOSWarningTimeOut = TUint32(-1);
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CREATESERVICERECORDL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::ServiceRecordId
+// ----------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::ServiceRecordId() const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SERVICERECORDID_ENTRY );
+
+ return ServiceRecord().RecordId();
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::ServiceRecordIdLC
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::ServiceRecordNameLC( HBufC* &aName )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SERVICERECORDNAMELC_ENTRY );
+
+ if ( iOutgoing )
+ {
+ aName = TPtrC( KCDTypeNameOutgoingWCDMA ).AllocLC();
+ }
+ else
+ {
+ aName = TPtrC( KCDTypeNameIncomingWCDMA ).AllocLC();
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SERVICERECORDNAMELC_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::BearerRecordIdL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::BearerRecordIdL( TUint32& aRecordId )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_BEARERRECORDIDL_ENTRY );
+
+ CMDBRecordSet<CCDModemBearerRecord>* bearerRS =
+ new( ELeave ) CMDBRecordSet<CCDModemBearerRecord>( KCDTIdModemBearerRecord );
+ CleanupStack::PushL( bearerRS );
+
+ CCDModemBearerRecord* bearerRecord = static_cast<CCDModemBearerRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdModemBearerRecord ) );
+
+ CleanupStack::PushL( bearerRecord );
+
+ bearerRecord->iRecordName.SetL( KModemBearerPacketData );
+ bearerRS->iRecords.AppendL( bearerRecord );
+ CleanupStack::Pop( bearerRecord );
+
+ if ( bearerRS->FindL( iSession ) )
+ {
+ bearerRecord = static_cast<CCDModemBearerRecord*>( bearerRS->iRecords[0] );
+ aRecordId = bearerRecord->RecordId();
+ }
+ else
+ // bearer not found -> create dummy values
+ {
+ bearerRecord->SetRecordId( KCDNewRecordRequest );
+ bearerRecord->StoreL( iSession );
+
+ aRecordId = bearerRecord->RecordId();
+ }
+
+ CleanupStack::PopAndDestroy( bearerRS );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_BEARERRECORDIDL_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::BearerRecordNameLC()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::BearerRecordNameLC( HBufC*& aBearerName )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_BEARERRECORDNAMELC_ENTRY );
+
+ aBearerName = TPtrC( KCDTypeNameModemBearer ).AllocLC();
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_BEARERRECORDNAMELC_EXIT );
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::CheckNetworkCoverageL()
+// ----------------------------------------------------------------------------
+//
+TBool CCmPluginPacketData::CheckNetworkCoverageL() const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CHECKNETWORKCOVERAGEL_ENTRY );
+
+ TBool retVal( EFalse );
+
+#ifdef __WINS__
+ retVal = ETrue;
+#else
+ CCmPDCoverageCheck* coverage = new( ELeave ) CCmPDCoverageCheck;
+ CleanupStack::PushL( coverage );
+
+ retVal = coverage->IsThereCoverageL();
+
+ CleanupStack::PopAndDestroy( coverage );
+
+#endif // __WINS
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CHECKNETWORKCOVERAGEL_EXIT );
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CCmPluginPacketData::SetPDPTypeL()
+// ----------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetPDPTypeL(
+ RPacketContext::TProtocolType aPdpType,
+ CCDWCDMAPacketServiceRecord* aServiceRecord )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETPDPTYPEL_ENTRY );
+
+ if ( aPdpType == RPacketContext::EPdpTypeIPv6 )
+ {
+ aServiceRecord->iGPRSPDPType = RPacketContext::EPdpTypeIPv6;
+ aServiceRecord->iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv6 );
+ }
+ else if ( aPdpType == RPacketContext::EPdpTypeIPv4 )
+ {
+ aServiceRecord->iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv4 );
+ aServiceRecord->iGPRSPDPType = RPacketContext::EPdpTypeIPv4;
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETPDPTYPEL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::CreateBearerRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::CreateBearerRecordsL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_CREATEBEARERRECORDSL_ENTRY );
+
+ delete iPacketDataQoSRecord;
+ iPacketDataQoSRecord = NULL;
+
+ iPacketDataQoSRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+
+ iPacketDataQoSRecord->iGPRSReqTrafficClass = RPacketQoS::ETrafficClassUnspecified;
+ iPacketDataQoSRecord->iGPRSMinTrafficClass = RPacketQoS::ETrafficClassUnspecified;
+ iPacketDataQoSRecord->iGPRSReqDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;
+ iPacketDataQoSRecord->iGPRSMinDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;
+ iPacketDataQoSRecord->iGPRSReqDeliverErroneousSDU =
+ RPacketQoS::EErroneousSDUDeliveryUnspecified;
+ iPacketDataQoSRecord->iGPRSMinDeliverErroneousSDU =
+ RPacketQoS::EErroneousSDUDeliveryUnspecified;
+ iPacketDataQoSRecord->iGPRSReqMaxSDUSize = 0;
+ iPacketDataQoSRecord->iGPRSMinAcceptableMaxSDUSize = 0;
+ iPacketDataQoSRecord->iGPRSReqMaxUplinkRate = 0;
+ iPacketDataQoSRecord->iGPRSReqMinUplinkRate = 0;
+ iPacketDataQoSRecord->iGPRSReqMaxDownlinkRate = 0;
+ iPacketDataQoSRecord->iGPRSReqMinDownlinkRate = 0;
+ iPacketDataQoSRecord->iGPRSReqBER = RPacketQoS::EBERUnspecified;
+ iPacketDataQoSRecord->iGPRSMaxBER = RPacketQoS::EBERUnspecified;
+ iPacketDataQoSRecord->iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified;
+ iPacketDataQoSRecord->iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified;
+ iPacketDataQoSRecord->iGPRSReqTrafficHandlingPriority =
+ RPacketQoS::ETrafficPriorityUnspecified;
+ iPacketDataQoSRecord->iGPRSMinTrafficHandlingPriority =
+ RPacketQoS::ETrafficPriorityUnspecified;
+ iPacketDataQoSRecord->iGPRSReqTransferDelay = 0;
+ iPacketDataQoSRecord->iGPRSMaxTransferDelay = 0;
+ iPacketDataQoSRecord->iGPRSReqGuaranteedUplinkRate = 0;
+ iPacketDataQoSRecord->iGPRSMinGuaranteedUplinkRate = 0;
+ iPacketDataQoSRecord->iGPRSReqGuaranteedDownlinkRate = 0;
+ iPacketDataQoSRecord->iGPRSMinGuaranteedDownlinkRate = 0;
+ iPacketDataQoSRecord->iGPRSSignallingIndication = EFalse;
+ iPacketDataQoSRecord->iGPRS_ImCnSignallingIndication = EFalse;
+ iPacketDataQoSRecord->iGPRSSourceStatisticsDescriptor =
+ RPacketQoS::ESourceStatisticsDescriptorUnknown;
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_CREATEBEARERRECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::UpdateServiceRecordL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::UpdateServiceRecordL(
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_UPDATESERVICERECORDL_ENTRY );
+
+ // Delete the original record and create a copy from the parameter.
+ delete iServiceRecord;
+ iServiceRecord = NULL;
+
+ if ( iOutgoing )
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ }
+ else
+ {
+ iServiceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdIncomingGprsRecord ) );
+ }
+
+ CCDWCDMAPacketServiceRecord* origServiceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( iServiceRecord );
+
+ // Client's copy of packet service record.
+ CCDWCDMAPacketServiceRecord* clientServiceRecordCopy =
+ static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] );
+
+ CopyRecordFieldsL( *clientServiceRecordCopy, *origServiceRecord );
+
+ if ( iPacketDataQoSRecord )
+ {
+ origServiceRecord->iUmtsR99QoSAndOnTable = iPacketDataQoSRecord->RecordId();
+ }
+
+ origServiceRecord->SetElementId( clientServiceRecordCopy->ElementId() );
+
+ if ( !origServiceRecord->RecordId() )
+ {
+ origServiceRecord->SetRecordId( KCDNewRecordRequest );
+ origServiceRecord->StoreL( iSession );
+ // Have to be "reloaded" to get possible default values from template records.
+ origServiceRecord->LoadL( iSession );
+
+ // Update received element ID to client's copy too.
+ clientServiceRecordCopy->SetElementId( origServiceRecord->ElementId() );
+ }
+ else
+ {
+ origServiceRecord->ModifyL( iSession );
+ }
+
+ CopyRecordFieldsL( *origServiceRecord, *clientServiceRecordCopy );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_UPDATESERVICERECORDL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::UpdateBearerRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::UpdateBearerRecordsL(
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_UPDATEBEARERRECORDSL_ENTRY );
+
+ CCDUmtsR99QoSAndOnTableRecord* packetDataQoSRecord =
+ static_cast<CCDUmtsR99QoSAndOnTableRecord*>( aBearerSpecRecordArray[KQosRecordIndex] );
+
+ delete iPacketDataQoSRecord;
+ iPacketDataQoSRecord = NULL;
+ iPacketDataQoSRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+ CopyRecordFieldsL( *packetDataQoSRecord, *iPacketDataQoSRecord );
+ iPacketDataQoSRecord->SetElementId( aBearerSpecRecordArray[KQosRecordIndex]->ElementId() );
+
+ if ( !iPacketDataQoSRecord->RecordId() )
+ {
+ iPacketDataQoSRecord->SetRecordId( KCDNewRecordRequest );
+ iPacketDataQoSRecord->StoreL( iSession );
+ iPacketDataQoSRecord->LoadL( iSession );
+ packetDataQoSRecord->SetElementId( iPacketDataQoSRecord->ElementId() );
+
+ // Set service record to point to QoS record.
+ ServiceRecord().iUmtsR99QoSAndOnTable = iPacketDataQoSRecord->RecordId();
+ ServiceRecord().ModifyL( iSession );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );
+ serviceRecord->iUmtsR99QoSAndOnTable = iPacketDataQoSRecord->RecordId();
+ }
+ else
+ {
+ iPacketDataQoSRecord->ModifyL( iSession );
+ }
+
+ CopyRecordFieldsL( *iPacketDataQoSRecord, *packetDataQoSRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_UPDATEBEARERRECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerSpecificRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::GetBearerSpecificRecordsL(
+ RPointerArray<CommsDat::CCDRecordBase>& aRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERSPECIFICRECORDSL_ENTRY );
+
+ if ( !iPacketDataQoSRecord )
+ {
+ // IAP not yet in CommDat.
+ GetDefaultQosRecordL( aRecordArray );
+ }
+ else
+ {
+ CCDUmtsR99QoSAndOnTableRecord* qosRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+ CleanupStack::PushL( qosRecord );
+ CopyRecordFieldsL( *iPacketDataQoSRecord, *qosRecord );
+ qosRecord->SetElementId( iPacketDataQoSRecord->ElementId() );
+ aRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( qosRecord ) );
+ CleanupStack::Pop( qosRecord );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERSPECIFICRECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetDefaultServiceRecordL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::GetDefaultServiceRecordL(
+ RPointerArray<CommsDat::CCDRecordBase>& aRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETDEFAULTSERVICERECORDL_ENTRY );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord( NULL );
+ if ( iOutgoing )
+ {
+ serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ }
+ else
+ {
+ serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ }
+
+ CleanupStack::PushL( serviceRecord );
+ serviceRecord->iGPRSAPN.SetL( KNullDesC );
+ serviceRecord->iGPRSPDPType.SetL( RPacketContext::EPdpTypeIPv4 );
+ serviceRecord->iGPRSReqPrecedence = 0;
+ serviceRecord->iGPRSReqDelay = 0;
+ serviceRecord->iGPRSReqReliability = 0;
+ serviceRecord->iGPRSReqPeakThroughput = 0;
+ serviceRecord->iGPRSReqMeanThroughput = 0;
+ serviceRecord->iGPRSMinPrecedence = 0;
+ serviceRecord->iGPRSMinDelay = 0;
+ serviceRecord->iGPRSMinReliability = 0;
+ serviceRecord->iGPRSMinPeakThroughput = 0;
+ serviceRecord->iGPRSMinMeanThroughput = 0;
+ serviceRecord->iGPRSDataCompression = EFalse;
+ serviceRecord->iGPRSHeaderCompression = EFalse;
+ serviceRecord->iGPRSAnonymousAccess = EFalse;
+ serviceRecord->iGPRSIfNetworks.SetL( KDefIspIfNetworksIPv4 );
+ serviceRecord->iGPRSIfPromptForAuth = EFalse;
+ serviceRecord->iGPRSIfAuthRetries = 0;
+ serviceRecord->iGPRSIPGateway.SetL( KUnspecifiedIPv4 );
+ serviceRecord->iGPRSIPAddrFromServer = ETrue;
+ serviceRecord->iGPRSIPAddr.SetL( KUnspecifiedIPv4 );
+ serviceRecord->iGPRSIPDNSAddrFromServer = ETrue;
+ serviceRecord->iGPRSIPNameServer1.SetL( KUnspecifiedIPv4 );
+ serviceRecord->iGPRSIPNameServer2.SetL( KUnspecifiedIPv4 );
+ serviceRecord->iGPRSIP6DNSAddrFromServer = ETrue;
+ serviceRecord->iGPRSIP6NameServer1.SetL( KDynamicIpv6Address );
+ serviceRecord->iGPRSIP6NameServer2.SetL( KDynamicIpv6Address );
+ serviceRecord->iGPRSEnableLCPExtension = EFalse;
+ serviceRecord->iGPRSDisablePlainTextAuth = ETrue;
+ serviceRecord->iGPRSAPType = EPacketDataBoth;
+ serviceRecord->iGPRSQOSWarningTimeOut = TUint32(-1);
+
+ aRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( serviceRecord ) );
+ CleanupStack::Pop( serviceRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETDEFAULTSERVICERECORDL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetDefaultQosRecordL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::GetDefaultQosRecordL(
+ RPointerArray<CommsDat::CCDRecordBase>& aRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETDEFAULTQOSRECORDL_ENTRY );
+
+ CCDUmtsR99QoSAndOnTableRecord* packetDataQoSRecord =
+ static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+ CleanupStack::PushL( packetDataQoSRecord );
+
+ packetDataQoSRecord->iGPRSReqTrafficClass = RPacketQoS::ETrafficClassUnspecified;
+ packetDataQoSRecord->iGPRSMinTrafficClass = RPacketQoS::ETrafficClassUnspecified;
+ packetDataQoSRecord->iGPRSReqDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;
+ packetDataQoSRecord->iGPRSMinDeliveryOrder = RPacketQoS::EDeliveryOrderUnspecified;
+ packetDataQoSRecord->iGPRSReqDeliverErroneousSDU =
+ RPacketQoS::EErroneousSDUDeliveryUnspecified;
+ packetDataQoSRecord->iGPRSMinDeliverErroneousSDU =
+ RPacketQoS::EErroneousSDUDeliveryUnspecified;
+ packetDataQoSRecord->iGPRSReqMaxSDUSize = 0;
+ packetDataQoSRecord->iGPRSMinAcceptableMaxSDUSize = 0;
+ packetDataQoSRecord->iGPRSReqMaxUplinkRate = 0;
+ packetDataQoSRecord->iGPRSReqMinUplinkRate = 0;
+ packetDataQoSRecord->iGPRSReqMaxDownlinkRate = 0;
+ packetDataQoSRecord->iGPRSReqMinDownlinkRate = 0;
+ packetDataQoSRecord->iGPRSReqBER = RPacketQoS::EBERUnspecified;
+ packetDataQoSRecord->iGPRSMaxBER = RPacketQoS::EBERUnspecified;
+ packetDataQoSRecord->iGPRSReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified;
+ packetDataQoSRecord->iGPRSMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified;
+ packetDataQoSRecord->iGPRSReqTrafficHandlingPriority =
+ RPacketQoS::ETrafficPriorityUnspecified;
+ packetDataQoSRecord->iGPRSMinTrafficHandlingPriority =
+ RPacketQoS::ETrafficPriorityUnspecified;
+ packetDataQoSRecord->iGPRSReqTransferDelay = 0;
+ packetDataQoSRecord->iGPRSMaxTransferDelay = 0;
+ packetDataQoSRecord->iGPRSReqGuaranteedUplinkRate = 0;
+ packetDataQoSRecord->iGPRSMinGuaranteedUplinkRate = 0;
+ packetDataQoSRecord->iGPRSReqGuaranteedDownlinkRate = 0;
+ packetDataQoSRecord->iGPRSMinGuaranteedDownlinkRate = 0;
+ packetDataQoSRecord->iGPRSSignallingIndication = EFalse;
+ packetDataQoSRecord->iGPRS_ImCnSignallingIndication = EFalse;
+ packetDataQoSRecord->iGPRSSourceStatisticsDescriptor =
+ RPacketQoS::ESourceStatisticsDescriptorUnknown;
+
+ aRecordArray.AppendL( static_cast<CommsDat::CCDRecordBase*>( packetDataQoSRecord ) );
+ CleanupStack::Pop( packetDataQoSRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETDEFAULTQOSRECORDL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerIntAttributeL
+// ---------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::GetBearerIntAttributeL(
+ TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERINTATTRIBUTEL_ENTRY );
+
+ TUint32 retVal( 0 );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );
+
+ if ( aAttribute < ECmCommonAttributesEnd ||
+ ( aAttribute > ECmBearerCreationCommonAttributes &&
+ aAttribute < ECmBearerCreationCommonAttributesEnd ) )
+ {
+ switch ( aAttribute )
+ {
+ case ECmBearerType:
+ {
+ retVal = iBearerType;
+ }
+ break;
+ case ECmCommsDBBearerType:
+ {
+ retVal = KCommDbBearerWcdma;
+ }
+ break;
+ case ECmDefaultUiPriority:
+ {
+ retVal = GetDefPriorityL( aAttribute );
+ }
+ break;
+ case ECmDefaultPriority:
+ {
+ retVal = GetDefPriorityL( aAttribute );
+ }
+ break;
+ case ECmExtensionLevel:
+ {
+ retVal = KExtensionBaseLevel;
+ }
+ break;
+ case ECmInvalidAttribute:
+ {
+ // This attribute has been deprecated since Symbian^4.
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ case ECmIFAuthRetries:
+ {
+ retVal = serviceRecord->iGPRSIfAuthRetries;
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrNotFound ); //TODO, check leave code, should it be KErrNotSupported ?
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERINTATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+ if ( aAttribute >= EPacketDataSpecificAttributes &&
+ aAttribute < EPacketDataServiceEnableLLMNR )
+ {
+ retVal = GetServiceIntAttributeL( aAttribute, aGenRecordArray );
+ }
+ else if ( aAttribute >= EGPRSReqTrafficClass &&
+ aAttribute <= EGPRSSourceStatisticsDescriptor )
+ {
+ retVal = GetQosIntAttributeL( aAttribute, aBearerSpecRecordArray );
+ }
+ else
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_GETBEARERINTATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetServiceIntAttributeL
+// ---------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::GetServiceIntAttributeL(
+ TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETSERVICEINTATTRIBUTEL_ENTRY );
+
+ TUint32 retVal( 0 );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EPacketDataPDPType:
+ {
+ retVal = serviceRecord->iGPRSPDPType;
+ }
+ break;
+
+ case EPacketDataReqPrecedence:
+ {
+ retVal = serviceRecord->iGPRSReqPrecedence;
+ }
+ break;
+
+ case EPacketDataReqDelay:
+ {
+ retVal = serviceRecord->iGPRSReqDelay;
+ }
+ break;
+
+ case EPacketDataReliability:
+ {
+ retVal = serviceRecord->iGPRSReqReliability;
+ }
+ break;
+
+ case EPacketDataPeakThroughput:
+ {
+ retVal = serviceRecord->iGPRSReqPeakThroughput;
+ }
+ break;
+
+ case EPacketDataMeanThroughput:
+ {
+ retVal = serviceRecord->iGPRSMinMeanThroughput;
+ }
+ break;
+
+ case EPacketDataMinPrecedence:
+ {
+ retVal = serviceRecord->iGPRSMinPrecedence;
+ }
+ break;
+
+ case EPacketDataMinDelay:
+ {
+ retVal = serviceRecord->iGPRSMinDelay;
+ }
+ break;
+
+ case EPacketDataMinReliability:
+ {
+ retVal = serviceRecord->iGPRSMinReliability;
+ }
+ break;
+
+ case EPacketDataMinPeakThroughput:
+ {
+ retVal = serviceRecord->iGPRSMinPeakThroughput;
+ }
+ break;
+
+ case EPacketDataMinMeanThroughput:
+ {
+ retVal = serviceRecord->iGPRSMinMeanThroughput;
+ }
+ break;
+
+ case EPacketDataIFAuthRetries:
+ {
+ retVal = serviceRecord->iGPRSIfAuthRetries;
+ }
+ break;
+
+ case EPacketDataApType:
+ {
+ retVal = serviceRecord->iGPRSAPType;
+ }
+ break;
+
+ case EPacketDataQoSWarningTimeOut:
+ {
+ retVal = serviceRecord->iGPRSQOSWarningTimeOut;
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETSERVICEINTATTRIBUTEL_EXIT );
+
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetQosIntAttributeL
+// ---------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::GetQosIntAttributeL(
+ TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETQOSINTATTRIBUTEL_ENTRY );
+
+ TUint32 retVal( 0 );
+
+ CCDUmtsR99QoSAndOnTableRecord* qosRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ aBearerSpecRecordArray[KQosRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EGPRSReqTrafficClass:
+ {
+ retVal = qosRecord->iGPRSReqTrafficClass;
+ }
+ break;
+
+ case EGPRSMinTrafficClass:
+ {
+ retVal = qosRecord->iGPRSMinTrafficClass;
+ }
+ break;
+
+ case EGPRSReqDeliveryOrder:
+ {
+ retVal = qosRecord->iGPRSReqDeliveryOrder;
+ }
+ break;
+
+ case GPRSMinDeliveryOrder:
+ {
+ retVal = qosRecord->iGPRSMinDeliveryOrder;
+ }
+ break;
+ case EGPRSReqDeliverErroneousSDU:
+ {
+ retVal = qosRecord->iGPRSReqDeliverErroneousSDU;
+ }
+ break;
+ case EGPRSMinDeliverErroneousSDU:
+ {
+ retVal = qosRecord->iGPRSMinDeliverErroneousSDU;
+ }
+ break;
+ case EGPRSReqMaxSDUSize:
+ {
+ retVal = qosRecord->iGPRSReqMaxSDUSize;
+ }
+ break;
+
+ case EGPRSMinAcceptableMaxSDUSize:
+ {
+ retVal = qosRecord->iGPRSMinAcceptableMaxSDUSize;
+ }
+ break;
+
+ case EGPRSReqMaxUplinkRate:
+ {
+ retVal = qosRecord->iGPRSReqMaxUplinkRate;
+ }
+ break;
+
+ case EGPRSReqMinUplinkRate:
+ {
+ retVal = qosRecord->iGPRSReqMinUplinkRate;
+ }
+ break;
+
+ case EGPRSReqMaxDownlinkRate:
+ {
+ retVal = qosRecord->iGPRSReqMaxDownlinkRate;
+ }
+ break;
+
+ case EGPRSReqMinDownlinkRate:
+ {
+ retVal = qosRecord->iGPRSReqMinDownlinkRate;
+ }
+ break;
+
+ case EGPRSReqBER:
+ {
+ retVal = qosRecord->iGPRSReqBER;
+ }
+ break;
+
+ case EGPRSMaxBER:
+ {
+ retVal = qosRecord->iGPRSMaxBER;
+ }
+ break;
+
+ case EGPRSReqSDUErrorRatio:
+ {
+ retVal = qosRecord->iGPRSReqSDUErrorRatio;
+ }
+ break;
+
+ case EGPRSMaxSDUErrorRatio:
+ {
+ retVal = qosRecord->iGPRSMaxSDUErrorRatio;
+ }
+ break;
+
+ case EGPRSReqTrafficHandlingPriority:
+ {
+ retVal = qosRecord->iGPRSReqTrafficHandlingPriority;
+ }
+ break;
+
+ case EGPRSMinTrafficHandlingPriority:
+ {
+ retVal = qosRecord->iGPRSMinTrafficHandlingPriority;
+ }
+ break;
+
+ case EGPRSReqTransferDelay:
+ {
+ retVal = qosRecord->iGPRSReqTransferDelay;
+ }
+ break;
+
+ case EGPRSMaxTransferDelay:
+ {
+ retVal = qosRecord->iGPRSMaxTransferDelay;
+ }
+ break;
+
+ case EGPRSReqGuaranteedUplinkRate:
+ {
+ retVal = qosRecord->iGPRSReqGuaranteedUplinkRate;
+ }
+ break;
+
+ case EGPRSMinGuaranteedUplinkRate:
+ {
+ retVal = qosRecord->iGPRSMinGuaranteedUplinkRate;
+ }
+ break;
+
+ case EGPRSReqGuaranteedDownlinkRate:
+ {
+ retVal = qosRecord->iGPRSReqGuaranteedDownlinkRate;
+ }
+ break;
+
+ case EGPRSMinGuaranteedDownlinkRate:
+ {
+ retVal = qosRecord->iGPRSMinGuaranteedDownlinkRate;
+ }
+ break;
+
+ case EGPRSSourceStatisticsDescriptor:
+ {
+ retVal = qosRecord->iGPRSSourceStatisticsDescriptor;
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETQOSINTATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerBoolAttributeL
+// ---------------------------------------------------------------------------
+//
+TBool CCmPluginPacketData::GetBearerBoolAttributeL( TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERBOOLATTRIBUTEL_ENTRY );
+
+ TBool retVal( EFalse );
+
+ switch ( aAttribute )
+ {
+ case EPacketDataOutGoing:
+ {
+ retVal = iOutgoing;
+ }
+ break;
+ case ECmCoverage:
+ {
+#ifndef __WINS__
+ CCmPDCoverageCheck* coverage = new( ELeave ) CCmPDCoverageCheck;
+ CleanupStack::PushL( coverage );
+
+ retVal = coverage->IsThereCoverageL();
+
+ CleanupStack::PopAndDestroy( coverage );
+#else
+ retVal = ETrue;
+#endif
+ }
+ break;
+ case ECmDestination:
+ {
+ retVal = EFalse;
+ }
+ break;
+ case ECmBearerHasUi:
+ {
+ retVal = ETrue;
+ }
+ break;
+ case ECmIPv6Supported:
+ {
+ retVal = FeatureManager::FeatureSupported( KFeatureIdIPv6 );
+ }
+ break;
+ case EPacketDataDataCompression:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSDataCompression;
+ }
+ break;
+ case EPacketDataHeaderCompression:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSHeaderCompression;
+ }
+ break;
+ case EPacketDataUseEdge:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSUseEdge;
+ }
+ break;
+ case EPacketDataAnonymousAccess:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSAnonymousAccess;
+ }
+ break;
+ case ECmIFPromptForAuth:
+ case EPacketDataIFPromptForAuth:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSIfPromptForAuth;
+ }
+ break;
+ case ECmIPAddFromServer:
+ case EPacketDataIPAddrFromServer:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSIPAddrFromServer;
+ }
+ break;
+ case ECmIPDNSAddrFromServer:
+ case EPacketDataIPDNSAddrFromServer:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSIPDNSAddrFromServer;
+ }
+ break;
+ case ECmIP6DNSAddrFromServer:
+ case EPacketDataIPIP6DNSAddrFromServer:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSIP6DNSAddrFromServer;
+ }
+ break;
+ case ECmEnableLPCExtension:
+ case EPacketDataEnableLcpExtension:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSEnableLCPExtension;
+ }
+ break;
+ case EPacketDataServiceEnableLLMNR:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iServiceEnableLlmnr;
+ }
+ break;
+ case ECmDisablePlainTextAuth:
+ case EPacketDataDisablePlainTextAuth:
+ {
+ retVal = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] )->iGPRSDisablePlainTextAuth;
+ }
+ break;
+ case EGPRSSignallingIndication:
+ {
+ retVal = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ aBearerSpecRecordArray[KQosRecordIndex] )->iGPRSSignallingIndication;
+ }
+ break;
+ case EGPRS_ImCnSignallingIndication:
+ {
+ retVal = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ aBearerSpecRecordArray[KQosRecordIndex] )->iGPRS_ImCnSignallingIndication;
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERBOOLATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerStringAttributeL
+// ---------------------------------------------------------------------------
+//
+HBufC* CCmPluginPacketData::GetBearerStringAttributeL( TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERSTRINGATTRIBUTEL_ENTRY );
+
+ HBufC* retVal( NULL );
+ if ( ( aAttribute > EPacketDataSpecificAttributes && aAttribute < EGPRSReqTrafficClass ) ||
+ ( aAttribute > ECmCommonAttributesStart && aAttribute < ECmCommonAttributesEnd ) )
+ {
+ retVal = GetServiceStringAttributeL( aAttribute, aGenRecordArray );
+ }
+ else
+ {
+ User::Leave( KErrNotSupported );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERSTRINGATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetServiceStringAttributeL
+// ---------------------------------------------------------------------------
+//
+HBufC* CCmPluginPacketData::GetServiceStringAttributeL(
+ TUint32 aAttribute,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETSERVICESTRINGATTRIBUTEL_ENTRY );
+
+ HBufC* retVal = NULL;
+
+ CCDWCDMAPacketServiceRecord* serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( aGenRecordArray[KServiceRecordIndex] );
+ switch ( aAttribute )
+ {
+ case ECmIFName:
+ case EPacketDataAPName:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSAPN ).AllocL();
+ }
+ break;
+ case EPacketDataPDPAddress:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSPDPAddress ).AllocL();
+ }
+ break;
+ case ECmIFParams:
+ case EPacketDataIFParams:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIfParams ).AllocL();
+ }
+ break;
+ case ECmIFNetworks:
+ case EPacketDataIFNetworks:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIfNetworks ).AllocL();
+ }
+ break;
+ case ECmIFAuthName:
+ case EPacketDataIFAuthName:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIfAuthName ).AllocL();
+ }
+ break;
+ case ECmIFAuthPass:
+ case EPacketDataIFAuthPass:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIfAuthPass ).AllocL();
+ }
+ break;
+ case ECmIPNetmask:
+ case EPacketDataIPNetmask:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPNetMask ).AllocL();
+ }
+ break;
+ case ECmIPGateway:
+ case EPacketDataIPGateway:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPGateway ).AllocL();
+ }
+ break;
+ case ECmIPAddress:
+ case EPacketDataIPAddr:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPAddr ).AllocL();
+ }
+ break;
+ case ECmIPNameServer1:
+ case EPacketDataIPNameServer1:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPNameServer1 ).AllocL();
+ }
+ break;
+ case ECmIPNameServer2:
+ case EPacketDataIPNameServer2:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPNameServer2 ).AllocL();
+ }
+ break;
+ case ECmIP6NameServer1:
+ case EPacketDataIPIP6NameServer1:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIP6NameServer1 ).AllocL();
+ }
+ break;
+ case ECmIP6NameServer2:
+ case EPacketDataIPIP6NameServer2:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIP6NameServer2 ).AllocL();
+ }
+ break;
+ case ECmIPAddrLeaseValidFrom:
+ case EPacketDataIPAddrLeaseValidFrom:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPAddrLeaseValidFrom ).AllocL();
+ }
+ break;
+ case ECmIPAddrLeaseValidTo:
+ case EPacketDataIPAddrLeaseValidTo:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSIPAddrLeaseValidTo ).AllocL();
+ }
+ break;
+ case ECmConfigDaemonManagerName:
+ case EPacketDataConfigDaemonManagerName:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSConfigDaemonManagerName ).AllocL();
+ }
+ break;
+ case ECmConfigDaemonName:
+ case EPacketDataConfigDaemonName:
+ {
+ retVal = TPtrC( serviceRecord->iGPRSConfigDaemonName ).AllocL();
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETSERVICESTRINGATTRIBUTEL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerString8AttributeL
+// ---------------------------------------------------------------------------
+//
+HBufC8* CCmPluginPacketData::GetBearerString8AttributeL( TUint32 /*aAttribute*/,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERSTRING8ATTRIBUTEL_ENTRY );
+
+ User::Leave( KErrNotSupported );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERSTRING8ATTRIBUTEL_EXIT );
+ return NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetBearerIntAttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetBearerIntAttributeL(
+ TUint32 aAttribute,
+ TUint32 aValue,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETBEARERINTATTRIBUTEL_ENTRY );
+
+ if ( aAttribute >= EPacketDataSpecificAttributes && aAttribute < EPacketDataServiceEnableLLMNR )
+ {
+ SetServiceIntAttributeL( aAttribute, aValue, aGenRecordArray );
+ }
+ else if ( aAttribute >= EGPRSReqTrafficClass && aAttribute <= EGPRSSourceStatisticsDescriptor )
+ {
+ SetQosIntAttributeL( aAttribute, aValue, aBearerSpecRecordArray );
+ }
+ else
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETBEARERINTATTRIBUTEL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetServiceIntAttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetServiceIntAttributeL(
+ TUint32 aAttribute,
+ TUint32 aValue,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETSERVICEINTATTRIBUTEL_ENTRY );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EPacketDataPDPType:
+ {
+ SetPDPTypeL( static_cast<RPacketContext::TProtocolType>( aValue ),
+ serviceRecord );
+ }
+ break;
+
+ case EPacketDataReqPrecedence:
+ {
+ serviceRecord->iGPRSReqPrecedence.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataReqDelay:
+ {
+ serviceRecord->iGPRSReqDelay.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataReliability:
+ {
+ serviceRecord->iGPRSReqReliability.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataPeakThroughput:
+ {
+ serviceRecord->iGPRSReqPeakThroughput.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMeanThroughput:
+ {
+ serviceRecord->iGPRSMinMeanThroughput.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMinPrecedence:
+ {
+ serviceRecord->iGPRSMinPrecedence.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMinDelay:
+ {
+ serviceRecord->iGPRSMinDelay.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMinReliability:
+ {
+ serviceRecord->iGPRSMinReliability.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMinPeakThroughput:
+ {
+ serviceRecord->iGPRSMinPeakThroughput.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataMinMeanThroughput:
+ {
+ serviceRecord->iGPRSMinMeanThroughput.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataIFAuthRetries:
+ {
+ serviceRecord->iGPRSIfAuthRetries.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataApType:
+ {
+ serviceRecord->iGPRSAPType.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataQoSWarningTimeOut:
+ {
+ serviceRecord->iGPRSQOSWarningTimeOut.SetL( aValue );
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ }
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETSERVICEINTATTRIBUTEL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetQosIntAttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetQosIntAttributeL(
+ TUint32 aAttribute,
+ TUint32 aValue,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETQOSINTATTRIBUTEL_ENTRY );
+
+ CCDUmtsR99QoSAndOnTableRecord* qosRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ aBearerSpecRecordArray[KQosRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EGPRSReqTrafficClass:
+ {
+ qosRecord->iGPRSReqTrafficClass.SetL(
+ static_cast<RPacketQoS::TTrafficClass>( aValue ) );
+ }
+ break;
+
+ case EGPRSMinTrafficClass:
+ {
+ qosRecord->iGPRSMinTrafficClass.SetL(
+ static_cast<RPacketQoS::TTrafficClass>( aValue ) );
+ }
+ break;
+
+ case EGPRSReqDeliveryOrder:
+ {
+ qosRecord->iGPRSReqDeliveryOrder.SetL(
+ static_cast<RPacketQoS::TDeliveryOrder>( aValue ) );
+ }
+ break;
+
+ case GPRSMinDeliveryOrder:
+ {
+ qosRecord->iGPRSMinDeliveryOrder.SetL(
+ static_cast<RPacketQoS::TDeliveryOrder>( aValue ) );
+ }
+ break;
+ case EGPRSReqDeliverErroneousSDU:
+ {
+ qosRecord->iGPRSReqDeliverErroneousSDU.SetL(
+ static_cast<RPacketQoS::TErroneousSDUDelivery>( aValue ) );
+ }
+ break;
+ case EGPRSMinDeliverErroneousSDU:
+ {
+ qosRecord->iGPRSMinDeliverErroneousSDU.SetL(
+ static_cast<RPacketQoS::TErroneousSDUDelivery>( aValue ) );
+ }
+ break;
+ case EGPRSReqMaxSDUSize:
+ {
+ qosRecord->iGPRSReqMaxSDUSize.SetL( aValue );
+ }
+ break;
+
+ case EGPRSMinAcceptableMaxSDUSize:
+ {
+ qosRecord->iGPRSMinAcceptableMaxSDUSize.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqMaxUplinkRate:
+ {
+ qosRecord->iGPRSReqMaxUplinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqMinUplinkRate:
+ {
+ qosRecord->iGPRSReqMinUplinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqMaxDownlinkRate:
+ {
+ qosRecord->iGPRSReqMaxDownlinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqMinDownlinkRate:
+ {
+ qosRecord->iGPRSReqMinDownlinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqBER:
+ {
+ qosRecord->iGPRSReqBER.SetL(
+ static_cast<RPacketQoS::TBitErrorRatio>( aValue ) );
+ }
+ break;
+
+ case EGPRSMaxBER:
+ {
+ qosRecord->iGPRSMaxBER.SetL(
+ static_cast<RPacketQoS::TBitErrorRatio>( aValue ) );
+ }
+ break;
+
+ case EGPRSReqSDUErrorRatio:
+ {
+ qosRecord->iGPRSReqSDUErrorRatio.SetL(
+ static_cast<RPacketQoS::TSDUErrorRatio>( aValue ) );
+ }
+ break;
+
+ case EGPRSMaxSDUErrorRatio:
+ {
+ qosRecord->iGPRSMaxSDUErrorRatio.SetL(
+ static_cast<RPacketQoS::TSDUErrorRatio>( aValue ) );
+ }
+ break;
+
+ case EGPRSReqTrafficHandlingPriority:
+ {
+ qosRecord->iGPRSReqTrafficHandlingPriority.SetL(
+ static_cast<RPacketQoS::TTrafficHandlingPriority>( aValue ) );
+ }
+ break;
+
+ case EGPRSMinTrafficHandlingPriority:
+ {
+ qosRecord->iGPRSMinTrafficHandlingPriority.SetL(
+ static_cast<RPacketQoS::TTrafficHandlingPriority>( aValue ) );
+ }
+ break;
+
+ case EGPRSReqTransferDelay:
+ {
+ qosRecord->iGPRSReqTransferDelay.SetL( aValue );
+ }
+ break;
+
+ case EGPRSMaxTransferDelay:
+ {
+ qosRecord->iGPRSMaxTransferDelay.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqGuaranteedUplinkRate:
+ {
+ qosRecord->iGPRSReqGuaranteedUplinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSMinGuaranteedUplinkRate:
+ {
+ qosRecord->iGPRSMinGuaranteedUplinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSReqGuaranteedDownlinkRate:
+ {
+ qosRecord->iGPRSReqGuaranteedDownlinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSMinGuaranteedDownlinkRate:
+ {
+ qosRecord->iGPRSMinGuaranteedDownlinkRate.SetL( aValue );
+ }
+ break;
+
+ case EGPRSSourceStatisticsDescriptor:
+ {
+ qosRecord->iGPRSSourceStatisticsDescriptor.SetL(
+ static_cast<RPacketQoS::TSourceStatisticsDescriptor>( aValue ) );
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETQOSINTATTRIBUTEL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetBearerBoolAttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetBearerBoolAttributeL(
+ TUint32 aAttribute,
+ TBool aValue,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETBEARERBOOLATTRIBUTEL_ENTRY );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EPacketDataOutGoing:
+ {
+ iOutgoing = aValue;
+ }
+ break;
+ case EPacketDataDataCompression:
+ {
+ serviceRecord->iGPRSDataCompression.SetL( aValue );
+ }
+ break;
+ case EPacketDataHeaderCompression:
+ {
+ serviceRecord->iGPRSHeaderCompression.SetL( aValue );
+ }
+ break;
+ case EPacketDataUseEdge:
+ {
+ serviceRecord->iGPRSUseEdge.SetL( aValue );
+ }
+ break;
+ case EPacketDataAnonymousAccess:
+ {
+ serviceRecord->iGPRSAnonymousAccess.SetL( aValue );
+ }
+ break;
+ case ECmIFPromptForAuth:
+ case EPacketDataIFPromptForAuth:
+ {
+ serviceRecord->iGPRSIfPromptForAuth.SetL( aValue );
+ }
+ break;
+ case ECmIPAddFromServer:
+ case EPacketDataIPAddrFromServer:
+ {
+ serviceRecord->iGPRSIPAddrFromServer.SetL( aValue );
+ }
+ break;
+ case ECmIPDNSAddrFromServer:
+ case EPacketDataIPDNSAddrFromServer:
+ {
+ serviceRecord->iGPRSIPDNSAddrFromServer.SetL( aValue );
+ }
+ break;
+ case ECmIP6DNSAddrFromServer:
+ case EPacketDataIPIP6DNSAddrFromServer:
+ {
+ serviceRecord->iGPRSIP6DNSAddrFromServer.SetL( aValue );
+ }
+ break;
+ case ECmEnableLPCExtension:
+ case EPacketDataEnableLcpExtension:
+ {
+ serviceRecord->iGPRSEnableLCPExtension.SetL( aValue );
+ }
+ break;
+ case ECmDisablePlainTextAuth:
+ case EPacketDataDisablePlainTextAuth:
+ {
+ serviceRecord->iGPRSDisablePlainTextAuth.SetL( aValue );
+ }
+ break;
+ case EGPRSSignallingIndication:
+ {
+ static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ aBearerSpecRecordArray[KQosRecordIndex] )
+ ->iGPRSSignallingIndication.SetL( aValue );
+ }
+ break;
+ case EGPRS_ImCnSignallingIndication:
+ {
+ static_cast<CCDUmtsR99QoSAndOnTableRecord*>
+ ( aBearerSpecRecordArray[KQosRecordIndex] )
+ ->iGPRS_ImCnSignallingIndication.SetL( aValue );
+ }
+ break;
+ case EPacketDataServiceEnableLLMNR:
+ {
+ serviceRecord->iServiceEnableLlmnr.SetL( aValue );
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrNotFound );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETBEARERBOOLATTRIBUTEL_EXIT );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetBearerStringAttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetBearerStringAttributeL(
+ TUint32 aAttribute,
+ const TDesC16& aValue,
+ RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,
+ RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETBEARERSTRINGATTRIBUTEL_ENTRY );
+
+ CCDWCDMAPacketServiceRecord* serviceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>(
+ aGenRecordArray[KServiceRecordIndex] );
+
+ switch ( aAttribute )
+ {
+ case EPacketDataAPName:
+ {
+ serviceRecord->iGPRSAPN.SetL( aValue );
+ }
+ break;
+
+ case EPacketDataPDPAddress:
+ {
+ serviceRecord->iGPRSPDPAddress.SetL( aValue );
+ }
+ break;
+
+ case ECmIFParams:
+ case EPacketDataIFParams:
+ {
+ serviceRecord->iGPRSIfParams.SetL( aValue );
+ }
+ break;
+
+ case ECmIFNetworks:
+ case EPacketDataIFNetworks:
+ {
+ serviceRecord->iGPRSIfNetworks.SetL( aValue );
+ }
+ break;
+
+ case ECmIFAuthName:
+ case EPacketDataIFAuthName:
+ {
+ serviceRecord->iGPRSIfAuthName.SetL( aValue );
+ }
+ break;
+
+ case ECmIFAuthPass:
+ case EPacketDataIFAuthPass:
+ {
+ serviceRecord->iGPRSIfAuthPass.SetL( aValue );
+ }
+ break;
+
+ case ECmIPNetmask:
+ case EPacketDataIPNetmask:
+ {
+ serviceRecord->iGPRSIPNetMask.SetL( aValue );
+ }
+ break;
+
+ case ECmIPGateway:
+ case EPacketDataIPGateway:
+ {
+ serviceRecord->iGPRSIPGateway.SetL( aValue );
+ }
+ break;
+
+ case ECmIPAddress:
+ case EPacketDataIPAddr:
+ {
+ if ( ( aValue.Compare( KUnspecifiedIPv4 ) == 0 ) ||
+ ( aValue.Compare( KNullDesC ) == 0 ) )
+ {
+ // If unspecified or NULL address is set dynamic
+ // IP must be enabled.
+ SetBearerBoolAttributeL( ECmIPAddFromServer,
+ ETrue,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ }
+ else
+ {
+ // If valid address is set dynamic IP is disabled.
+ SetBearerBoolAttributeL( ECmIPAddFromServer,
+ EFalse,
+ aGenRecordArray,
+ aBearerSpecRecordArray );
+ }
+ serviceRecord->iGPRSIPAddr.SetL( aValue );
+ }
+ break;
+
+ case ECmIPNameServer1:
+ case EPacketDataIPNameServer1:
+ {
+ serviceRecord->iGPRSIPNameServer1.SetL( aValue );
+ }
+ break;
+
+ case ECmIPNameServer2:
+ case EPacketDataIPNameServer2:
+ {
+ serviceRecord->iGPRSIPNameServer2.SetL( aValue );
+ }
+ break;
+
+ case ECmIP6NameServer1:
+ case EPacketDataIPIP6NameServer1:
+ {
+ serviceRecord->iGPRSIP6NameServer1.SetL( aValue );
+ }
+ break;
+
+ case ECmIP6NameServer2:
+ case EPacketDataIPIP6NameServer2:
+ {
+ serviceRecord->iGPRSIP6NameServer2.SetL( aValue );
+ }
+ break;
+
+ case ECmIPAddrLeaseValidFrom:
+ case EPacketDataIPAddrLeaseValidFrom:
+ {
+ serviceRecord->iGPRSIPAddrLeaseValidFrom.SetL( aValue );
+ }
+ break;
+
+ case ECmIPAddrLeaseValidTo:
+ case EPacketDataIPAddrLeaseValidTo:
+ {
+ serviceRecord->iGPRSIPAddrLeaseValidTo.SetL( aValue );
+ }
+ break;
+
+ case ECmConfigDaemonManagerName:
+ case EPacketDataConfigDaemonManagerName:
+ {
+ serviceRecord->iGPRSConfigDaemonManagerName.SetL( aValue );
+ }
+ break;
+
+ case ECmConfigDaemonName:
+ case EPacketDataConfigDaemonName:
+ {
+ serviceRecord->iGPRSConfigDaemonName.SetL( aValue );
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETBEARERSTRINGATTRIBUTEL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::SetBearerString8AttributeL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::SetBearerString8AttributeL(
+ TUint32 /*aAttribute*/,
+ const TDesC8& /*aValue*/,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,
+ RPointerArray<CommsDat::CCDRecordBase>& /*aBearerSpecRecordArray*/ )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_SETBEARERSTRING8ATTRIBUTEL_ENTRY );
+
+ User::Leave( KErrNotSupported );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_SETBEARERSTRING8ATTRIBUTEL_EXIT );
+ return;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerInfoIntL
+// ---------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::GetBearerInfoIntL( TUint32 aAttribute ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERINFOINTL_ENTRY );
+
+ TUint32 retVal( 0 );
+ switch ( aAttribute )
+ {
+ case ECmBearerType:
+ {
+ retVal = iBearerType;
+ }
+ break;
+ case ECmCommsDBBearerType:
+ {
+ retVal = KCommDbBearerWcdma;
+ }
+ break;
+ case ECmDefaultUiPriority:
+ {
+ retVal = GetDefPriorityL( aAttribute );
+ }
+ break;
+ case ECmDefaultPriority:
+ {
+ retVal = GetDefPriorityL( aAttribute );
+ }
+ break;
+ case ECmExtensionLevel:
+ {
+ retVal = KExtensionBaseLevel;
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERINFOINTL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerInfoBoolL
+// ---------------------------------------------------------------------------
+//
+TBool CCmPluginPacketData::GetBearerInfoBoolL( TUint32 aAttribute ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERINFOBOOLL_ENTRY );
+
+ TBool retVal( EFalse );
+ switch ( aAttribute )
+ {
+ case ECmCoverage:
+ {
+#ifndef __WINS__
+ CCmPDCoverageCheck* coverage = new (ELeave) CCmPDCoverageCheck;
+ CleanupStack::PushL( coverage );
+
+ retVal = coverage->IsThereCoverageL();
+
+ CleanupStack::PopAndDestroy( coverage );
+#else
+ retVal = ETrue;
+#endif
+ }
+ break;
+ case ECmDestination:
+ {
+ retVal = EFalse;
+ }
+ break;
+ case ECmBearerHasUi:
+ {
+ retVal = EFalse;
+ }
+ break;
+ case ECmIPv6Supported:
+ {
+ retVal = FeatureManager::FeatureSupported( KFeatureIdIPv6 );
+ }
+ break;
+ case ECmVirtual:
+ {
+ retVal = EFalse;
+ }
+ break;
+
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERINFOBOOLL_EXIT );
+ return retVal;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerInfoStringL
+// ---------------------------------------------------------------------------
+//
+HBufC* CCmPluginPacketData::GetBearerInfoStringL( TUint32 aAttribute ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERINFOSTRINGL_ENTRY );
+
+ HBufC* retVal( NULL );
+ switch ( aAttribute )
+ {
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERINFOSTRINGL_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerInfoString8L
+// ---------------------------------------------------------------------------
+//
+HBufC8* CCmPluginPacketData::GetBearerInfoString8L( TUint32 aAttribute ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERINFOSTRING8L_ENTRY );
+
+ HBufC8* retVal( NULL );
+ switch ( aAttribute )
+ {
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ }
+ break;
+ }
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERINFOSTRING8L_EXIT );
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::PrepareToCopyDataL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::PrepareToCopyDataL( CCmPluginBaseEng* aCopyInstance )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_PREPARETOCOPYDATAL_ENTRY );
+
+ CCmPluginPacketData* plugin = static_cast<CCmPluginPacketData*>( aCopyInstance );
+ plugin->iOutgoing = iOutgoing;
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_PREPARETOCOPYDATAL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::CopyServiceRecordL
+// ---------------------------------------------------------------------------
+//
+CommsDat::CCDRecordBase* CCmPluginPacketData::CopyServiceRecordL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_COPYSERVICERECORDL_ENTRY );
+
+ // New service record to be returned.
+ CCDRecordBase* serviceRecord = NULL;
+ if ( iOutgoing )
+ {
+ serviceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );
+ }
+ else
+ {
+ serviceRecord = static_cast<CCDWCDMAPacketServiceRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdIncomingGprsRecord ) );
+ }
+ CleanupStack::PushL( serviceRecord );
+
+ CCDWCDMAPacketServiceRecord* tempServiceRecordPtrToNew =
+ static_cast<CCDWCDMAPacketServiceRecord*>( serviceRecord );
+
+ // CommsDat version of service record.
+ CCDWCDMAPacketServiceRecord* origServiceRecord =
+ static_cast<CCDWCDMAPacketServiceRecord*>( iServiceRecord );
+
+ if ( !origServiceRecord->iRecordTag.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iRecordTag.SetL(
+ origServiceRecord->iRecordTag );
+ }
+ if ( !origServiceRecord->iRecordName.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iRecordName.SetL(
+ origServiceRecord->iRecordName );
+ }
+
+ if ( !origServiceRecord->iServiceEnableLlmnr.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iServiceEnableLlmnr.SetL(
+ origServiceRecord->iServiceEnableLlmnr );
+ }
+
+ if ( !origServiceRecord->iGPRSAPN.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSAPN.SetL(
+ origServiceRecord->iGPRSAPN );
+ }
+ if ( !origServiceRecord->iGPRSPDPType.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSPDPType.SetL(
+ origServiceRecord->iGPRSPDPType );
+ }
+ if ( !origServiceRecord->iGPRSPDPAddress.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSPDPAddress.SetL(
+ origServiceRecord->iGPRSPDPAddress );
+ }
+ if ( !origServiceRecord->iGPRSReqPrecedence.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSReqPrecedence.SetL(
+ origServiceRecord->iGPRSReqPrecedence );
+ }
+ if ( !origServiceRecord->iGPRSReqDelay.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSReqDelay.SetL(
+ origServiceRecord->iGPRSReqDelay );
+ }
+ if ( !origServiceRecord->iGPRSReqReliability.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSReqReliability.SetL(
+ origServiceRecord->iGPRSReqReliability );
+ }
+ if ( !origServiceRecord->iGPRSReqPeakThroughput.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSReqPeakThroughput.SetL(
+ origServiceRecord->iGPRSReqPeakThroughput );
+ }
+ if ( !origServiceRecord->iGPRSReqMeanThroughput.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSReqMeanThroughput.SetL(
+ origServiceRecord->iGPRSReqMeanThroughput );
+ }
+ if ( !origServiceRecord->iGPRSMinPrecedence.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSMinPrecedence.SetL(
+ origServiceRecord->iGPRSMinPrecedence );
+ }
+ if ( !origServiceRecord->iGPRSMinDelay.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSMinDelay.SetL(
+ origServiceRecord->iGPRSMinDelay );
+ }
+ if ( !origServiceRecord->iGPRSMinReliability.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSMinReliability.SetL(
+ origServiceRecord->iGPRSMinReliability );
+ }
+ if ( !origServiceRecord->iGPRSMinPeakThroughput.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSMinPeakThroughput.SetL(
+ origServiceRecord->iGPRSMinPeakThroughput );
+ }
+ if ( !origServiceRecord->iGPRSMinMeanThroughput.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSMinMeanThroughput.SetL(
+ origServiceRecord->iGPRSMinMeanThroughput );
+ }
+ if ( !origServiceRecord->iGPRSDataCompression.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSDataCompression.SetL(
+ origServiceRecord->iGPRSDataCompression );
+ }
+ if ( !origServiceRecord->iGPRSHeaderCompression.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSHeaderCompression.SetL(
+ origServiceRecord->iGPRSHeaderCompression );
+ }
+ if ( !origServiceRecord->iGPRSUseEdge.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSUseEdge.SetL(
+ origServiceRecord->iGPRSUseEdge );
+ }
+ if ( !origServiceRecord->iGPRSAnonymousAccess.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSAnonymousAccess.SetL(
+ origServiceRecord->iGPRSAnonymousAccess );
+ }
+ if ( !origServiceRecord->iGPRSIfParams.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfParams.SetL(
+ origServiceRecord->iGPRSIfParams );
+ }
+ if ( !origServiceRecord->iGPRSIfNetworks.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfNetworks.SetL(
+ origServiceRecord->iGPRSIfNetworks );
+ }
+ if ( !origServiceRecord->iGPRSIfPromptForAuth.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfPromptForAuth.SetL(
+ origServiceRecord->iGPRSIfPromptForAuth );
+ }
+ if ( !origServiceRecord->iGPRSIfAuthName.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfAuthName.SetL(
+ origServiceRecord->iGPRSIfAuthName );
+ }
+ if ( !origServiceRecord->iGPRSIfAuthPass.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfAuthPass.SetL(
+ origServiceRecord->iGPRSIfAuthPass );
+ }
+ if ( !origServiceRecord->iGPRSIfAuthRetries.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIfAuthRetries.SetL(
+ origServiceRecord->iGPRSIfAuthRetries );
+ }
+ if ( !origServiceRecord->iGPRSIPNetMask.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPNetMask.SetL(
+ origServiceRecord->iGPRSIPNetMask );
+ }
+ if ( !origServiceRecord->iGPRSIPGateway.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPGateway.SetL(
+ origServiceRecord->iGPRSIPGateway );
+ }
+ if ( !origServiceRecord->iGPRSIPAddrFromServer.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPAddrFromServer.SetL(
+ origServiceRecord->iGPRSIPAddrFromServer );
+ }
+ if ( !origServiceRecord->iGPRSIPAddr.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPAddr.SetL(
+ origServiceRecord->iGPRSIPAddr );
+ }
+ if ( !origServiceRecord->iGPRSIPDNSAddrFromServer.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPDNSAddrFromServer.SetL(
+ origServiceRecord->iGPRSIPDNSAddrFromServer );
+ }
+ if ( !origServiceRecord->iGPRSIPNameServer1.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPNameServer1.SetL(
+ origServiceRecord->iGPRSIPNameServer1 );
+ }
+ if ( !origServiceRecord->iGPRSIPNameServer2.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPNameServer2.SetL(
+ origServiceRecord->iGPRSIPNameServer2 );
+ }
+ if ( !origServiceRecord->iGPRSIP6DNSAddrFromServer.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIP6DNSAddrFromServer.SetL(
+ origServiceRecord->iGPRSIP6DNSAddrFromServer );
+ }
+ if ( !origServiceRecord->iGPRSIP6NameServer1.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIP6NameServer1.SetL(
+ origServiceRecord->iGPRSIP6NameServer1 );
+ }
+ if ( !origServiceRecord->iGPRSIP6NameServer2.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIP6NameServer2.SetL(
+ origServiceRecord->iGPRSIP6NameServer2 );
+ }
+ if ( !origServiceRecord->iGPRSIPAddrLeaseValidFrom.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPAddrLeaseValidFrom.SetL(
+ origServiceRecord->iGPRSIPAddrLeaseValidFrom );
+ }
+ if ( !origServiceRecord->iGPRSIPAddrLeaseValidTo.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSIPAddrLeaseValidTo.SetL(
+ origServiceRecord->iGPRSIPAddrLeaseValidTo );
+ }
+ if ( !origServiceRecord->iGPRSConfigDaemonManagerName.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSConfigDaemonManagerName.SetL(
+ origServiceRecord->iGPRSConfigDaemonManagerName );
+ }
+ if ( !origServiceRecord->iGPRSConfigDaemonName.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSConfigDaemonName.SetL(
+ origServiceRecord->iGPRSConfigDaemonName );
+ }
+ if ( !origServiceRecord->iGPRSEnableLCPExtension.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSEnableLCPExtension.SetL(
+ origServiceRecord->iGPRSEnableLCPExtension );
+ }
+ if ( !origServiceRecord->iGPRSDisablePlainTextAuth.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSDisablePlainTextAuth.SetL(
+ origServiceRecord->iGPRSDisablePlainTextAuth );
+ }
+ if ( !origServiceRecord->iGPRSAPType.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSAPType.SetL(
+ origServiceRecord->iGPRSAPType );
+ }
+ if ( !origServiceRecord->iGPRSQOSWarningTimeOut.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSQOSWarningTimeOut.SetL(
+ origServiceRecord->iGPRSQOSWarningTimeOut );
+ }
+ if ( !origServiceRecord->iUmtsR99QoSAndOnTable.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iUmtsR99QoSAndOnTable.SetL(
+ origServiceRecord->iUmtsR99QoSAndOnTable );
+ }
+ if ( !origServiceRecord->iGPRSR5DataCompression.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSR5DataCompression.SetL(
+ origServiceRecord->iGPRSR5DataCompression );
+ }
+ if ( !origServiceRecord->iGPRSR5HeaderCompression.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSR5HeaderCompression.SetL(
+ origServiceRecord->iGPRSR5HeaderCompression );
+ }
+ if ( !origServiceRecord->iGPRSPacketFlowIdentifier.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSPacketFlowIdentifier.SetL(
+ origServiceRecord->iGPRSPacketFlowIdentifier );
+ }
+ if ( !origServiceRecord->iGPRSUmtsGprsRelease.IsNull() )
+ {
+ tempServiceRecordPtrToNew->iGPRSUmtsGprsRelease.SetL(
+ origServiceRecord->iGPRSUmtsGprsRelease );
+ }
+
+ CleanupStack::Pop( serviceRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_COPYSERVICERECORDL_EXIT );
+ return serviceRecord;
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::ResetBearerRecords
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::ResetBearerRecords()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_RESETBEARERRECORDS_ENTRY );
+
+ delete iPacketDataQoSRecord;
+ iPacketDataQoSRecord = NULL;
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_RESETBEARERRECORDS_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::DeleteBearerRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::DeleteBearerRecordsL()
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_DELETEBEARERRECORDSL_ENTRY );
+
+ if ( !TPtrC(iPacketDataQoSRecord->iRecordName).CompareF( KDefaultQosDataRecordName ) ||
+ !TPtrC(iPacketDataQoSRecord->iRecordName).CompareF( KDefaultQosDataRecordNamewithSpace ) )
+ {
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_DELETEBEARERRECORDSL_EXIT );
+ return;
+ }
+
+ iPacketDataQoSRecord->DeleteL( iSession );
+
+ OstTraceFunctionExit0( DUP1_CCMPLUGINPACKETDATA_DELETEBEARERRECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::CopyBearerRecordsL
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::CopyBearerRecordsL( CCmPluginBaseEng* aCopyInstance )
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_COPYBEARERRECORDSL_ENTRY );
+
+ CCmPluginPacketData* plugin = static_cast<CCmPluginPacketData*>( aCopyInstance );
+
+ CCDUmtsR99QoSAndOnTableRecord* qosRecord = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(
+ CCDRecordBase::RecordFactoryL( KCDTIdUmtsR99QoSAndOnTableRecord ) );
+ CleanupStack::PushL( qosRecord );
+ CopyRecordFieldsL( *iPacketDataQoSRecord, *qosRecord );
+ CleanupStack::Pop( qosRecord );
+ plugin->iPacketDataQoSRecord = qosRecord;
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_COPYBEARERRECORDSL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetBearerTableIdsToBeObserved
+// ---------------------------------------------------------------------------
+//
+void CCmPluginPacketData::GetBearerTableIdsToBeObservedL(
+ RArray<TUint32>& aTableIdArray ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETBEARERTABLEIDSTOBEOBSERVEDL_ENTRY );
+
+ aTableIdArray.AppendL( KCDTIdOutgoingGprsRecord );
+ aTableIdArray.AppendL( KCDTIdUmtsR99QoSAndOnTableRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETBEARERTABLEIDSTOBEOBSERVEDL_EXIT );
+ }
+
+// ---------------------------------------------------------------------------
+// CCmPluginPacketData::GetDefPriorityL
+// ---------------------------------------------------------------------------
+//
+TUint32 CCmPluginPacketData::GetDefPriorityL( const TUint32 aAttribute ) const
+ {
+ OstTraceFunctionEntry0( CCMPLUGINPACKETDATA_GETDEFPRIORITYL_ENTRY );
+
+ TUint32 retVal( KDataMobilitySelectionPolicyPriorityWildCard );
+
+ CCDGlobalBearerTypePriorizationRecord* priorityRecord =
+ new( ELeave ) CCDGlobalBearerTypePriorizationRecord( iBearerPriorityTableId );
+ CleanupStack::PushL( priorityRecord );
+
+ priorityRecord->iServiceType.SetL( TPtrC( KCDTypeNameOutgoingWCDMA ) );
+
+ if ( priorityRecord->FindL( iSession ) )
+ {
+ priorityRecord->LoadL( iSession );
+
+ switch ( aAttribute )
+ {
+ case ECmDefaultPriority:
+ {
+ retVal = priorityRecord->iPriority;
+ }
+ break;
+ case ECmDefaultUiPriority:
+ {
+ retVal = priorityRecord->iUIPriority;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy( priorityRecord );
+
+ OstTraceFunctionExit0( CCMPLUGINPACKETDATA_GETDEFPRIORITYL_EXIT );
+ return retVal;
+ }
+
+// End of file