diff -r 000000000000 -r 3553901f7fa8 telephonyprotocols/pdplayer/src/PDPConfig.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyprotocols/pdplayer/src/PDPConfig.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,591 @@ +// Copyright (c) 2006-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: +// PDP Config structures for TProvision message. +// +// + +/** + @file + @internalComponent +*/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "PDPProvision.h" + +using namespace ESock; + +#if defined(__CFLOG_ACTIVE) +#define KPDPMCprTag KESockMetaConnectionTag +_LIT8(KPDPMCprSubTag, "pdpmcpr"); +#endif + +const TUint8 KGenericNifChallengeSize = 8; +const TUint KGenericNifIdLength = 1; + +// +// Attribute table for provisioning structure passed to CFProtocol +// +START_ATTRIBUTE_TABLE(CGPRSProvision, CGPRSProvision::EUid, CGPRSProvision::ETypeId) +// No attributes defined, as no serialisation takes place. +END_ATTRIBUTE_TABLE() + +START_ATTRIBUTE_TABLE(CTSYProvision, CGPRSProvision::EUid, CTSYProvision::ETypeId) +// No attributes defined, as no serialisation takes place. +END_ATTRIBUTE_TABLE() + +START_ATTRIBUTE_TABLE(CDefaultPacketQoSProvision, CDefaultPacketQoSProvision::EUid, CDefaultPacketQoSProvision::ETypeId) +// No attributes defined, as no serialisation takes place. +END_ATTRIBUTE_TABLE() + +START_ATTRIBUTE_TABLE(CImsExtProvision, CImsExtProvision::EUid, CImsExtProvision::ETypeId) +// No attributes defined, as no serialisation takes place. +END_ATTRIBUTE_TABLE() + +CGPRSProvision* CGPRSProvision::NewLC(ESock::CCommsDatIapView* aIapView) + { + CGPRSProvision* self = new (ELeave) CGPRSProvision; + CleanupStack::PushL(self); + self->InitialiseConfigL(aIapView); + return self; + } +TInt CGPRSProvision::UmtsGprsRelease() const + { + return iUmtsGprsRelease; + } + +void CGPRSProvision::InitialiseConfigL(ESock::CCommsDatIapView* aIapView) + { + TInt getErr = aIapView->GetInt(KCDTIdUmtsGprsRelease | KCDTIdOutgoingGprsRecord, iUmtsGprsRelease); + + if (getErr == KErrNotFound || getErr == KErrUnknown) + { + // default to GPRS + getErr = KErrNone; + iUmtsGprsRelease = TPacketDataConfigBase::KConfigGPRS; + } + + getErr = InitialiseScratchContext(iUmtsGprsRelease); + //-==================================================== + //LENIENT PROVISION + //-==================================================== + //With some provision parameters (e.g.: pdpAddress), CGPRSProvision + //tries to be lenient as technically they can be supplied by + //someone further in the chain (e.g.: GPRS), if not found in the db. + switch (iUmtsGprsRelease) + { + case TPacketDataConfigBase::KConfigGPRS: + { + RPacketContext::TContextConfigGPRS& contextGPRS = GetScratchContextAs(); + RetrievePdpTypeL(contextGPRS.iPdpType, aIapView); + RetrieveApnNameL(contextGPRS.iAccessPointName, aIapView); + RetrieveIPAndDnsSettingsL(contextGPRS.iPdpAddress, + contextGPRS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, + contextGPRS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, aIapView); + RetrieveAuthenticationInfoL(contextGPRS.iProtocolConfigOption, aIapView); + // GPRS specific + RetrieveGprsCompression(contextGPRS.iPdpCompression, aIapView); + RetrieveGprsAnonymousAccess(contextGPRS.iAnonymousAccessReqd, aIapView); + contextGPRS.iUseEdge = EFalse; + } + break; + case TPacketDataConfigBase::KConfigRel5: + { + // Rel 5 specific + RPacketContext::TContextConfig_R5& contextR5 = GetScratchContextAs(); + RetrieveUmtsCompressionL(contextR5.iPdpHeaderCompression, contextR5.iPdpDataCompression, aIapView); + + RetrievePdpTypeL(contextR5.iPdpType, aIapView); + RetrieveApnNameL(contextR5.iAccessPointName, aIapView); + RetrieveIPAndDnsSettingsL(contextR5.iPdpAddress, + contextR5.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, + contextR5.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, aIapView); + RetrieveAuthenticationInfoL(contextR5.iProtocolConfigOption, aIapView); + contextR5.iUseEdge = EFalse; + + RetrieveUmtsPacketFlowIdentifierL(contextR5.iPFI, aIapView); + } + break; + case TPacketDataConfigBase::KConfigRel99Rel4: + { + RPacketContext::TContextConfigR99_R4& contextUMTS = GetScratchContextAs(); + + RetrievePdpTypeL(contextUMTS.iPdpType, aIapView); + RetrieveApnNameL(contextUMTS.iAccessPointName, aIapView); + RetrieveIPAndDnsSettingsL(contextUMTS.iPdpAddress, + contextUMTS.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, + contextUMTS.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, aIapView); + RetrieveAuthenticationInfoL(contextUMTS.iProtocolConfigOption, aIapView); + contextUMTS.iUseEdge = EFalse; + RetrieveUmtsPacketFlowIdentifierL(contextUMTS.iPFI, aIapView); + } + break; + default: + User::Leave(KErrNotSupported); + } + } + +void CGPRSProvision::RetrieveGprsCompression(TUint& aCompression, ESock::CCommsDatIapView* aIapView) const + { + aCompression = 0; + TBool isCompression = EFalse; + aIapView->GetBool(KCDTIdWCDMADataCompression | KCDTIdOutgoingGprsRecord, isCompression); + if (isCompression) + { + aCompression |= RPacketContext::KPdpDataCompression; + } + + isCompression = EFalse; + aIapView->GetBool(KCDTIdWCDMAHeaderCompression | KCDTIdOutgoingGprsRecord, isCompression); + if (isCompression) + { + aCompression |= RPacketContext::KPdpHeaderCompression; + } + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::InitialiseConfigL() KCDTIdWCDMADataCompression|KCDTIdWCDMAHeaderCompression [%d]"), this, aCompression)); + } + +void CGPRSProvision::RetrieveGprsAnonymousAccess(RPacketContext::TAnonymousAccess& aAnonymous, ESock::CCommsDatIapView* aIapView) const + { + TBool isAnonymous = EFalse; + aIapView->GetBool(KCDTIdWCDMAAnonymousAccess | KCDTIdOutgoingGprsRecord,isAnonymous); + if (isAnonymous) + aAnonymous = RPacketContext::ERequired; + else + aAnonymous = RPacketContext::ENotRequired; + + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::InitialiseConfigL() KCDTIdWCDMAAnonymousAccess [%d]"), this, aAnonymous)); + } + +void CGPRSProvision::RetrieveApnNameL(TDes8& aApnName, ESock::CCommsDatIapView* aIapView) const + { + HBufC* buf = NULL; + TInt getErr; + + if ((getErr = aIapView->GetText(KCDTIdAPN | KCDTIdOutgoingGprsRecord, buf)) == KErrNone) + { + aApnName.Copy(*buf); + delete buf; + } + else if (getErr != KErrNotFound ) + { + User::Leave(getErr); + } + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::InitialiseConfigL() KCDTIdAPN [%S]"), this, &aApnName)); + } + +void CGPRSProvision::RetrievePdpTypeL(RPacketContext::TProtocolType& aPdpType, ESock::CCommsDatIapView* aIapView) const + { + TUint32 pdpType(0); + + aIapView->GetIntL(KCDTIdWCDMPDPType | KCDTIdOutgoingGprsRecord, pdpType); + aPdpType = static_cast(pdpType); + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::InitialiseConfigL() KCDTIdWCDMPDPType=%d"), this, aPdpType)); + } + +void CGPRSProvision::RetrieveAuthenticationInfoL(RPacketContext::TProtocolConfigOptionV2& aProtocolConfigOption, ESock::CCommsDatIapView* aIapView) + { + HBufC* buf = NULL; + TInt getErr; + + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::RetrieveAuthenticationInfoL()"), this)); + + getErr = aIapView->GetText(KCDTIdWCDMAIfAuthName | KCDTIdOutgoingGprsRecord, buf); + if ( getErr == KErrNone ) + { + ASSERT(buf); + aProtocolConfigOption.iAuthInfo.iUsername.Copy(*buf); + delete buf; + buf = NULL; + + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::RetrieveAuthenticationInfoL() KCDTIdWCDMAIfAuthName [%S] "), this, &aProtocolConfigOption.iAuthInfo.iUsername)); + + aProtocolConfigOption.iId = 1; + + TBool isDisableAuth = EFalse; + getErr = aIapView->GetBool(KCDTIdWCDMADisablePlainTextAuth | KCDTIdOutgoingGprsRecord,isDisableAuth); + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::RetrieveAuthenticationInfoL() KCDTIdWCDMADisablePlainTextAuth [%d]"), this, isDisableAuth)); + if (getErr == KErrNone) + { + getErr = aIapView->GetText(KCDTIdWCDMAIfAuthPass | KCDTIdOutgoingGprsRecord, buf); + if ( getErr == KErrNone ) + { + ASSERT(buf); + aProtocolConfigOption.iAuthInfo.iPassword.Copy(*buf); + delete buf; + buf = NULL; + + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CGPRSProvision [this=%08x]::RetrieveAuthenticationInfoL() KCDTIdWCDMAIfAuthPass [%S]"), this, &aProtocolConfigOption.iAuthInfo.iPassword)); + + if (isDisableAuth) //If Disable, CHAP will be used. + { + aProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolCHAP; + CreateChallengeAndResponseForChapL(aProtocolConfigOption); + } + else + { + aProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolPAP; + } + } + else if (getErr == KErrNotFound) + { + if (isDisableAuth) //ERROR: CHAP used without password??? + { + User::Leave(KErrArgument); + } + else //PAP used without password. + { + aProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolPAP; + } + } + else //getErr != KErrNotFound + { + User::Leave(getErr); + } + } + else + { + User::Leave(getErr); + } + } + else if (getErr == KErrNotFound ) //No Authentication Required. + { + aProtocolConfigOption.iAuthInfo.iProtocol = RPacketContext::EProtocolNone; + } + else //getErr != KErrNotFound + { + User::Leave(getErr); + } + } + +void CGPRSProvision::CreateChallengeAndResponseForChapL(RPacketContext::TProtocolConfigOptionV2& aProtocolConfigOption) + { + //Challenge + TTime currentTime; + currentTime.UniversalTime(); + + TInt64 seedValue = currentTime.Int64(); + + TUint8 challenge[KGenericNifChallengeSize] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + TUint8 i=0; + while(i < KGenericNifChallengeSize) + { + challenge[i] = (TUint8)(Math::Rand(seedValue)%256); + aProtocolConfigOption.iChallenge.Append(challenge[i++]); + } + + //Response + TBuf8 message; + message.Append(aProtocolConfigOption.iId); + message.Append(aProtocolConfigOption.iAuthInfo.iPassword); + message.Append(aProtocolConfigOption.iChallenge); + + TInt length = 1 /*iId length */ + aProtocolConfigOption.iAuthInfo.iPassword.Length() + KGenericNifChallengeSize; + + HBufC8* buf = HBufC8::NewL(length); + + CleanupStack::PushL(buf); + + TPtr8 ptr((TUint8*)buf->Des().Ptr(),length); + + ptr.Copy(message); + + CMD5* md5=0; + md5 = CMD5::NewL(); + + CleanupStack::PushL(md5); + + TPtrC8 Response = md5->Hash(ptr); + + aProtocolConfigOption.iResponse.Copy(Response); + + CleanupStack::PopAndDestroy(2); + } + +void CGPRSProvision::RetrieveIPAndDnsSettingsL(TDes8& aPdpAddress, TDes8& aDns1, TDes8& aDns2, ESock::CCommsDatIapView* aIapView) const + { + HBufC* buf = NULL; + + aPdpAddress.SetLength(0); + aDns1.SetLength(0); + aDns2.SetLength(0); + + TBool fromServer; + aIapView->GetBoolL(KCDTIdWCDMAIPAddrFromServer | KCDTIdOutgoingGprsRecord, fromServer); + if (!fromServer) + { + aIapView->GetTextL(KCDTIdWCDMAIPAddr | KCDTIdOutgoingGprsRecord, buf); + aPdpAddress.Copy(*buf); + delete buf; + buf = NULL; + } + + // We can only use IPv4 or IPv6 - we use the first one listed in the IfNetworks field + aIapView->GetTextL(KCDTIdWCDMAIfNetworks | KCDTIdOutgoingGprsRecord, buf); + + TInt pos = buf->Find(_L(",")); + if (pos == KErrNotFound) + { + pos = buf->Length(); + } + + TBufC temp(buf->Mid(0, pos)); + delete buf; + buf = NULL; + _LIT(KIp4, "ip"); + _LIT(KIp6, "ip6"); + if (temp.CompareF(KIp4) == 0) + { + // IPv4 settings + aIapView->GetBoolL(KCDTIdWCDMAIPDNSAddrFromServer | KCDTIdOutgoingGprsRecord, fromServer); + if (!fromServer) + { + aIapView->GetTextL(KCDTIdWCDMAIPNameServer1 | KCDTIdOutgoingGprsRecord, buf); + aDns1.Copy(*buf); + delete buf; + buf = NULL; + aIapView->GetTextL(KCDTIdWCDMAIPNameServer2 | KCDTIdOutgoingGprsRecord, buf); + aDns2.Copy(*buf); + delete buf; + buf = NULL; + } + } + else if (temp.CompareF(KIp6) == 0) + { + // IPv6 settings + aIapView->GetBoolL(KCDTIdWCDMAIP6DNSAddrFromServer | KCDTIdOutgoingGprsRecord, fromServer); + if (!fromServer) + { + aIapView->GetTextL(KCDTIdWCDMAIP6NameServer1 | KCDTIdOutgoingGprsRecord, buf); + aDns1.Copy(*buf); + delete buf; + buf = NULL; + aIapView->GetTextL(KCDTIdWCDMAIP6NameServer2 | KCDTIdOutgoingGprsRecord, buf); + aDns2.Copy(*buf); + delete buf; + buf = NULL; + } + } + else + { + // Anything else is a serious misconfiguration + User::Leave(KErrArgument); + } + } +void CGPRSProvision::RetrieveUmtsCompressionL(RPacketContext::THeaderCompression& aHeaderCompression, RPacketContext::TDataCompression& aDataCompression, ESock::CCommsDatIapView* aIapView) const + { + TUint32 headerComp; + TUint32 dataComp; + TInt err; + + err = aIapView->GetInt(KCDTIdR5DataCompression | KCDTIdOutgoingGprsRecord, headerComp); + if (err == KErrNotFound || err == KErrUnknown) + { + err = KErrNone; + headerComp = RPacketContext::ENoHeaderCompression; + } + User::LeaveIfError(err); + + aHeaderCompression = static_cast(headerComp); + + err = aIapView->GetInt(KCDTIdR5HeaderCompression | KCDTIdOutgoingGprsRecord, dataComp); + if (err == KErrNotFound || err == KErrUnknown) + { + err = KErrNone; + dataComp = RPacketContext::ENoDataCompression; + } + User::LeaveIfError(err); + + aDataCompression = static_cast(dataComp); + } + +void CGPRSProvision::RetrieveUmtsPacketFlowIdentifierL(RPacketContext::TPacketFlowIdentifier& aPfi, ESock::CCommsDatIapView* aIapView) const + { + TUint32 pfi; + TInt err = aIapView->GetInt(KCDTIdPacketFlowIdentifier | KCDTIdOutgoingGprsRecord, pfi); + if (err == KErrNotFound || err == KErrUnknown) + { + err = KErrNone; + pfi = RPacketContext::EBestEffort; + } + User::LeaveIfError(err); + aPfi = static_cast(pfi); + } + + +TInt CGPRSProvision::InitialiseScratchContext(TUint32 aConfigRel) const + { + switch(aConfigRel) + { + case TPacketDataConfigBase::KConfigGPRS: + { + RPacketContext::TContextConfigGPRS tmp; + Mem::Copy(const_cast(iScratchContext.Ptr()), &tmp, sizeof(tmp)); + } + break; + + case TPacketDataConfigBase::KConfigRel99Rel4: + { + RPacketContext::TContextConfigR99_R4 tmp; + Mem::Copy(const_cast(iScratchContext.Ptr()), &tmp, sizeof(tmp)); + } + break; + + case TPacketDataConfigBase::KConfigRel5: + { + RPacketContext::TContextConfig_R5 tmp; + Mem::Copy(const_cast(iScratchContext.Ptr()), &tmp, sizeof(tmp)); + } + break; + default: + return KErrNotSupported; + } + return KErrNone; + } + + +CTSYProvision* CTSYProvision::NewLC(ESock::CCommsDatIapView* aIapView) + { + CTSYProvision* self = new (ELeave) CTSYProvision; + CleanupStack::PushL(self); + self->InitialiseConfigL(aIapView); + return self; + } + +void CTSYProvision::InitialiseConfigL(ESock::CCommsDatIapView* aIapView) + { + HBufC* buf = NULL; + + aIapView->GetTextL(KCDTIdTsyName, buf); + iTsyName.Copy(*buf); + __CFLOG_VAR((KPDPMCprTag, KPDPMCprSubTag, _L8("CTSYProvision [this=%08x]::InitialiseConfigL() KCDTIdTsyName=%s"), this, &iTsyName)); + delete buf; + } + +CDefaultPacketQoSProvision* CDefaultPacketQoSProvision::NewL(ESock::CCommsDatIapView* aIapView) + { + CDefaultPacketQoSProvision* self = new (ELeave) CDefaultPacketQoSProvision; + CleanupStack::PushL(self); + self->InitialiseConfigL(aIapView); + CleanupStack::Pop(self); + return self; + } + + void CDefaultPacketQoSProvision::InitialiseConfigL(ESock::CCommsDatIapView* aIapView) + { + TUint32 data; + + aIapView->GetIntL(KCDTIdWCDMAReqTrafficClass,data); + iParams.iReqTrafficClass = (RPacketQoS::TTrafficClass)data; + + aIapView->GetIntL(KCDTIdWCDMAMinTrafficClass,data); + iParams.iMinTrafficClass = (RPacketQoS::TTrafficClass)data; + + aIapView->GetIntL(KCDTIdWCDMAReqDeliveryOrder,data); + iParams.iReqDeliveryOrderReqd = (RPacketQoS::TDeliveryOrder)data; + + aIapView->GetIntL(KCDTIdWCDMAMinDeliveryOrder,data); + iParams.iMinDeliveryOrderReqd = (RPacketQoS::TDeliveryOrder)data; + + aIapView->GetIntL(KCDTIdWCDMAReqDeliverErroneousSDU,data); + iParams.iReqDeliverErroneousSDU = (RPacketQoS::TErroneousSDUDelivery)data; + + aIapView->GetIntL(KCDTIdWCDMAMinDeliverErroneousSDU,data); + iParams.iMinDeliverErroneousSDU = (RPacketQoS::TErroneousSDUDelivery)data; + + aIapView->GetIntL(KCDTIdWCDMAReqMaxSDUSize,data); + iParams.iReqMaxSDUSize = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAMinAcceptableMaxSDUSize,data); + iParams.iMinAcceptableMaxSDUSize = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqMaxUplinkRate,data); + iParams.iReqMaxRate.iUplinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqMinUplinkRate,data); + iParams.iMinAcceptableMaxRate.iUplinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqMaxDownlinkRate,data); + iParams.iReqMaxRate.iDownlinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqMinDownlinkRate,data); + iParams.iMinAcceptableMaxRate.iDownlinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqBER,data); + iParams.iReqBER = (RPacketQoS::TBitErrorRatio)data; + + aIapView->GetIntL(KCDTIdWCDMAMaxBER,data); + iParams.iMaxBER = (RPacketQoS::TBitErrorRatio)data; + + aIapView->GetIntL(KCDTIdWCDMAReqSDUErrorRatio,data); + iParams.iReqSDUErrorRatio = (RPacketQoS::TSDUErrorRatio)data; + + aIapView->GetIntL(KCDTIdWCDMAMaxSDUErrorRatio,data); + iParams.iMaxSDUErrorRatio = (RPacketQoS::TSDUErrorRatio)data; + + aIapView->GetIntL(KCDTIdWCDMAReqTrafficHandlingPriority,data); + iParams.iReqTrafficHandlingPriority = (RPacketQoS::TTrafficHandlingPriority)data; + + aIapView->GetIntL(KCDTIdWCDMAMinTrafficHandlingPriority,data); + iParams.iMinTrafficHandlingPriority = (RPacketQoS::TTrafficHandlingPriority)data; + + aIapView->GetIntL(KCDTIdWCDMAReqTransferDelay,data); + iParams.iReqTransferDelay = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAMaxTransferDelay,data); + iParams.iMaxTransferDelay = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqGuaranteedUplinkRate,data); + iParams.iReqGuaranteedRate.iUplinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAMinGuaranteedUplinkRate,data); + iParams.iMinGuaranteedRate.iUplinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAReqGuaranteedDownlinkRate,data); + iParams.iReqGuaranteedRate.iDownlinkRate = (TInt)data; + + aIapView->GetIntL(KCDTIdWCDMAMinGuaranteedDownlinkRate,data); + iParams.iMinGuaranteedRate.iDownlinkRate = (TInt)data; + + TBool bdata = EFalse; +#ifdef _DEBUG + TInt debugErr = +#endif + aIapView->GetBool(KCDTIdWCDMASignallingIndication,bdata); + iParams.iSignallingIndication = bdata; + } + +CImsExtProvision* CImsExtProvision::NewLC(ESock::CCommsDatIapView* aIapView) + { + CImsExtProvision* self = new (ELeave) CImsExtProvision; + CleanupStack::PushL(self); + self->InitialiseConfigL(aIapView); + return self; + } + +void CImsExtProvision::InitialiseConfigL(ESock::CCommsDatIapView* aIapView) + { + TBool bdata = EFalse; + aIapView->GetBool(KCDTIdWCDMAImCmSignallingIndication,bdata); + iImsSignalIndicator = bdata; + } + +