diff -r 8ab6687fb94c -r 3adadc800673 telephonyprotocols/umtsgprsscpr/src/UmtsGprs_subconnProv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyprotocols/umtsgprsscpr/src/UmtsGprs_subconnProv.cpp Fri Jun 11 14:49:29 2010 +0300 @@ -0,0 +1,764 @@ +// Copyright (c) 2005-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: +// Implementation file for the Umts/Gprs SubConnection Provider +// +// + +/** + @file + @internalComponent +*/ + + + +#include +#include "UmtsGprs_subconnProv.h" + +const TInt KQoSMappingBorderDelay = 250; + +#define IN_RANGE_INCLUSIVE(value, left, right) (value >= left && value <= right ) +#define MIN(left, right) (left < right ? left : right) + +//We need to use a cleanup item here becuase CSubConNotificationEvents are not CBase derived. This means that on cleanup, things are not cleaned up as expected +//We therefore need a TCleanupItem to deal with it. +void SubconEventCleanupFunction(TAny* aEvent) + { + CSubConNotificationEvent* ptr = static_cast(aEvent); + delete ptr; + } + +void SubconParamSetCleanupFunction(TAny* aEvent) + { + CSubConParameterSet* ptr = static_cast(aEvent); + delete ptr; + } + +#ifdef SYMBIAN_NETWORKING_UMTSR5 +void CUmtsGprsSubConnProvd::MapQosParamBundleToEtelL(const CSubConParameterBundle& aIn, + RPacketQoS::TQoSR5Requested* aOut) + +#else +// !SYMBIAN_NETWORKING_UMTSR5 + +void CUmtsGprsSubConnProvd::MapQosParamBundleToEtelL(const CSubConParameterBundle& aIn, + RPacketQoS::TQoSR99_R4Requested* aOut) +#endif +// SYMBIAN_NETWORKING_UMTSR5 + { + ASSERT(aOut); + + //Note: There should probably be const and non-const versions of FindFamily. + //There is only non-const, hence casting below. + CSubConParameterFamily* family = const_cast(aIn).FindFamily(KSubConQoSFamily); + if (!family) + { + User::Leave(KErrArgument); + } + + +#ifdef SYMBIAN_NETWORKING_UMTSR5 + // check the UMTS R5 extension first + CSubConQosR5ParamSet* extRequestedR5 = NULL; + CSubConQosR5ParamSet* extAcceptableR5 = NULL; + + extRequestedR5 = static_cast(family->FindExtensionSet( + STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR5ParamsType), CSubConParameterFamily::ERequested)); + + extAcceptableR5 = static_cast(family->FindExtensionSet( + STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR5ParamsType), CSubConParameterFamily::EAcceptable)); + + if (extRequestedR5) + { + MapQosR5ExtensionSetToEtel (*extRequestedR5, extAcceptableR5, aOut); + iParameterRelease = KParameterRel5; + return; + } +#endif + + // No R5 so check the UMTS R99/R4 extension next + CSubConQosR99ParamSet* extRequestedR99 = NULL; + CSubConQosR99ParamSet* extAcceptableR99 = NULL; + extRequestedR99 = static_cast(family->FindExtensionSet( + STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR99ParamsType), CSubConParameterFamily::ERequested)); + + extAcceptableR99 = static_cast(family->FindExtensionSet( + STypeId::CreateSTypeId(KSubCon3GPPExtParamsFactoryUid,KSubConQosR99ParamsType), CSubConParameterFamily::EAcceptable)); + + if (extRequestedR99) + { + MapQosR99ExtensionSetToEtel (*extRequestedR99, extAcceptableR99, aOut); + iParameterRelease = KParameterRel4Rel99; + return; + } + + + // Still nothing specific, try to use the generic params + CSubConQosGenericParamSet* genericRequested = + static_cast(family->GetGenericSet(CSubConParameterFamily::ERequested)); + CSubConQosGenericParamSet* genericAcceptable = + static_cast(family->GetGenericSet(CSubConParameterFamily::EAcceptable)); + + if (genericRequested) + { + MapQosGenericSetToEtel (*genericRequested, genericAcceptable, aOut); + iParameterRelease = KParameterRelGeneric; + return; + } + + // Nothing left that we support + User::Leave(KErrNotSupported); + } + + +/** +Maps given requested and acceptable sets of R99/R4 parameters as defined CSubConQosR99ParamSet +into the Etel format (RPacketQoS::TQoSR99_R4Requested). + +@param aInRequested requested CSubConQosR99ParamSet to be converted +@param aInAcceptable optional acceptable CSubConQosR99ParamSet to be converted +@param aOut RPacketQoS::TQoSR99_R4Requested derived class to be mapped into. +*/ +void CUmtsGprsSubConnProvd::MapQosR99ExtensionSetToEtel(const CSubConQosR99ParamSet& aInRequested, + const CSubConQosR99ParamSet* aInAcceptable, RPacketQoS::TQoSR99_R4Requested* aOut) + { + ASSERT (aOut); + + aOut->iReqTrafficClass = aInRequested.GetTrafficClass(); + aOut->iReqDeliveryOrderReqd = aInRequested.GetDeliveryOrder(); + aOut->iReqDeliverErroneousSDU = aInRequested.GetErroneousSDUDelivery(); + aOut->iReqBER = aInRequested.GetResidualBitErrorRatio(); + aOut->iReqSDUErrorRatio = aInRequested.GetSDUErrorRatio(); + aOut->iReqTrafficHandlingPriority = aInRequested.GetTrafficHandlingPriority(); + aOut->iReqTransferDelay = aInRequested.GetTransferDelay(); + aOut->iReqMaxSDUSize = aInRequested.GetMaxSduSize(); + aOut->iReqMaxRate.iUplinkRate = aInRequested.GetMaxBitrateUplink(); + aOut->iReqMaxRate.iDownlinkRate = aInRequested.GetMaxBitrateDownlink(); + aOut->iReqGuaranteedRate.iUplinkRate = aInRequested.GetGuaBitrateUplink(); + aOut->iReqGuaranteedRate.iDownlinkRate = aInRequested.GetGuaBitrateDownlink(); + + if (!aInAcceptable) + { + // when aInAcceptable is ommitted the minimum is the requested + aInAcceptable = &aInRequested; + } + + aOut->iMinTrafficClass = aInAcceptable->GetTrafficClass(); + aOut->iMinDeliveryOrderReqd = aInAcceptable->GetDeliveryOrder(); + aOut->iMinDeliverErroneousSDU = aInAcceptable->GetErroneousSDUDelivery(); + aOut->iMaxBER = aInAcceptable->GetResidualBitErrorRatio(); + aOut->iMaxSDUErrorRatio = aInAcceptable->GetSDUErrorRatio(); + aOut->iMinTrafficHandlingPriority = aInAcceptable->GetTrafficHandlingPriority(); + aOut->iMaxTransferDelay = aInAcceptable->GetTransferDelay(); + aOut->iMinAcceptableMaxSDUSize = aInAcceptable->GetMaxSduSize(); + aOut->iMinAcceptableMaxRate.iUplinkRate = aInAcceptable->GetMaxBitrateUplink(); + aOut->iMinAcceptableMaxRate.iDownlinkRate = aInAcceptable->GetMaxBitrateDownlink(); + aOut->iMinGuaranteedRate.iUplinkRate = aInAcceptable->GetGuaBitrateUplink(); + aOut->iMinGuaranteedRate.iDownlinkRate = aInAcceptable->GetGuaBitrateDownlink(); + } + + +#ifdef SYMBIAN_NETWORKING_UMTSR5 +/** +Maps given requested and acceptable sets of R5 parameters as defined CSubConQosR5ParamSet +into the Etel format (RPacketQoS::TQoSR5Requested). + + +@param aInRequested requested CSubConQosR5ParamSet to be converted +@param aInAcceptable optional acceptable CSubConQosR5ParamSet to be converted +@param aOut RPacketQoS::TQoSR5Requested derived class to be mapped into. +*/ +void CUmtsGprsSubConnProvd::MapQosR5ExtensionSetToEtel(const CSubConQosR5ParamSet& aInRequested, + const CSubConQosR5ParamSet* aInAcceptable, RPacketQoS::TQoSR5Requested* aOut) + { + MapQosR99ExtensionSetToEtel(aInRequested,aInAcceptable,aOut); + aOut->iSourceStatisticsDescriptor = aInRequested.GetSourceStatisticsDescriptor(); + aOut->iSignallingIndication = aInRequested.GetSignallingIndicator(); + } + + +void CUmtsGprsSubConnProvd::MapQosR99ExtensionSetToEtel(const CSubConQosR99ParamSet& aInRequested, + const CSubConQosR99ParamSet* aInAcceptable, RPacketQoS::TQoSR5Requested* aOut) + { + MapQosR99ExtensionSetToEtel(aInRequested, aInAcceptable, static_cast(aOut)); + aOut->iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorUnknown; + aOut->iSignallingIndication = EFalse; + } + +#endif +// SYMBIAN_NETWORKING_UMTSR5 + +/** +Given a set of generic parameters, the method derives the R99 value for the traffic class. + + +@param aIn requested CSubConQosGenericParamSet to be converted +@return the value of RPacketQoS::TTrafficClass +*/ +RPacketQoS::TTrafficClass CUmtsGprsSubConnProvd::DeriveTrafficClass(const CSubConQosGenericParamSet& aIn ) + { + //----------------------------------- + // Traffic class + //----------------------------------- + if (IN_RANGE_INCLUSIVE(aIn.GetUpLinkDelay(), 0, KQoSMappingBorderDelay-1) || + IN_RANGE_INCLUSIVE(aIn.GetDownLinkDelay(), 0, KQoSMappingBorderDelay-1) ) + { + return RPacketQoS::ETrafficClassConversational; + } + else if (aIn.GetUpLinkDelay() >= KQoSMappingBorderDelay || + aIn.GetDownLinkDelay() >= KQoSMappingBorderDelay ) + { + return RPacketQoS::ETrafficClassStreaming; + } + else if (IN_RANGE_INCLUSIVE(aIn.GetUpLinkPriority(), 1, 3) || + IN_RANGE_INCLUSIVE(aIn.GetDownLinkPriority(), 1, 3)) + { + return RPacketQoS::ETrafficClassInteractive; + } + + return RPacketQoS::ETrafficClassBackground; + } + + +/** +Given a set of generic parameters, the method derives the R99 value for the traffic priority. + + +@param aIn requested CSubConQosGenericParamSet to be converted +@return the value of RPacketQoS::TTrafficHandlingPriority +*/ +RPacketQoS::TTrafficHandlingPriority CUmtsGprsSubConnProvd::DeriveTrafficPriority(const CSubConQosGenericParamSet& aIn ) + { + // + // Traffic handling priority + // + if (aIn.GetUpLinkPriority() == 1 || aIn.GetDownLinkPriority() == 1) + { + return RPacketQoS::ETrafficPriority1; + } + else if (aIn.GetUpLinkPriority() == 2 || aIn.GetDownLinkPriority() == 2) + { + return RPacketQoS::ETrafficPriority2; + } + + return RPacketQoS::ETrafficPriority3; + } + + +/** +Maps given requested and acceptable sets of generic QoS parameters as defined CSubConQosGenericParamSet +into the Etel format (RPacketQoS::TQoSR99_R4Requested). + + +@param aInRequested requested CSubConQosGenericParamSet to be converted +@param aInAcceptable optional acceptable CSubConQosGenericParamSet to be converted +@param aOut RPacketQoS::TQoSR99_R4Requested to be produced. +*/ +void CUmtsGprsSubConnProvd::MapQosGenericSetToEtel(const CSubConQosGenericParamSet& aInRequested, + const CSubConQosGenericParamSet* aInAcceptable, RPacketQoS::TQoSR99_R4Requested* aOut) + { + ASSERT (aOut); + + aOut->iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; + aOut->iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired;; + aOut->iReqBER = RPacketQoS::EBERUnspecified; + aOut->iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + + aOut->iReqTrafficClass = DeriveTrafficClass(aInRequested); + aOut->iReqTrafficHandlingPriority = DeriveTrafficPriority(aInRequested); + aOut->iReqTransferDelay = MIN(aInRequested.GetUpLinkDelay(), aInRequested.GetDownLinkDelay()); + aOut->iReqMaxSDUSize = aInRequested.GetUpLinkMaximumPacketSize(); + aOut->iReqMaxRate.iUplinkRate = aInRequested.GetUplinkBandwidth(); + aOut->iReqMaxRate.iDownlinkRate = aInRequested.GetDownlinkBandwidth(); + aOut->iReqGuaranteedRate.iUplinkRate = aInRequested.GetUplinkBandwidth(); + aOut->iReqGuaranteedRate.iDownlinkRate = aInRequested.GetDownlinkBandwidth(); + + if (!aInAcceptable) + { + // when aInAcceptable is ommitted the minimum is the requested + aInAcceptable = &aInRequested; + } + + aOut->iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; + aOut->iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; + aOut->iMaxBER = RPacketQoS::EBERUnspecified; + aOut->iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + + aOut->iMinTrafficClass = DeriveTrafficClass(*aInAcceptable); + aOut->iMinTrafficHandlingPriority = DeriveTrafficPriority(*aInAcceptable); + aOut->iMaxTransferDelay = MIN(aInAcceptable->GetUpLinkDelay(), aInAcceptable->GetDownLinkDelay()); + aOut->iMinAcceptableMaxSDUSize = aInAcceptable->GetUpLinkMaximumPacketSize(); + aOut->iMinAcceptableMaxRate.iUplinkRate = aInAcceptable->GetUplinkBandwidth(); + aOut->iMinAcceptableMaxRate.iDownlinkRate = aInAcceptable->GetDownlinkBandwidth(); + aOut->iMinGuaranteedRate.iUplinkRate = aInAcceptable->GetUplinkBandwidth(); + aOut->iMinGuaranteedRate.iDownlinkRate = aInAcceptable->GetDownlinkBandwidth(); + } + + + +/** +Maps QoS parameters received from the network via Etel into a CSubConGenEventParamsGranted class +so that it is usable by the RSubConnection API. + +@param aNetworkQoS - A pointer to an Etel TPacketDataConfigBase class containing the +QoS to be mapped into the QoS event. +@param aGranted - A reference to the CSubConGenEventParamsGranted object that should receive the mapped +QoS parameters. +*/ +void CUmtsGprsSubConnProvd::MapQosEtelToGrantedParamsL (TPacketDataConfigBase* aNetworkQoS,CSubConGenEventParamsGranted& aGranted) + { + ASSERT (aNetworkQoS); + + // Always set the generic set + MapQosEtelToGenericSetL ((static_cast(aNetworkQoS)), aGranted); + + + + switch (iParameterRelease) + { +#ifdef SYMBIAN_NETWORKING_UMTSR5 + case KParameterRel5: + // Control client sent us an R5 qos request + MapQosEtelToR5SetL ((static_cast(aNetworkQoS)), aGranted); + break; +#endif +// SYMBIAN_NETWORKING_UMTSR5 + + case KParameterRelInvalid: +#ifdef SYMBIAN_NETWORKING_UMTSR5 + // This will be the case if the client hasn't actually requested a level of QoS yet + // but the network has notified us of a QoS change. We don't know what the client might + // support so return both sets (if the define is set, else just what the code supports) + MapQosEtelToR5SetL ((static_cast(aNetworkQoS)), aGranted); +#endif + MapQosEtelToR99SetL ((static_cast(aNetworkQoS)), aGranted); + break; + + case KParameterRel4Rel99: + // Control client sent us an R4/R99 qos request + MapQosEtelToR99SetL ((static_cast(aNetworkQoS)), aGranted); + break; + + case KParameterRelGeneric: + // Generic set always returned. Done above. + break; + } + } + + +/** +Maps QoS parameters received from the network via Etel into a 3GPP Release R4/R99 set and +sets it in the given event. + +@param aNetworkQoS - A pointer to an Etel RPacketQoS::TQoSR99_R4Requested derived class containing +the QoS to be mapped. +@param aGranted - A reference to the CSubConGenEventParamsGranted object that should receive the +extension QoS parameters. +*/ +void CUmtsGprsSubConnProvd::MapQosEtelToR99SetL (RPacketQoS::TQoSR99_R4Negotiated* aNetworkQoS, + CSubConGenEventParamsGranted& aGranted) + { + ASSERT (aNetworkQoS); + + CSubConQosR99ParamSet* r99Extension = CSubConQosR99ParamSet::NewL (); + CleanupStack::PushL(TCleanupItem(SubconParamSetCleanupFunction,r99Extension)); + r99Extension->SetTrafficClass(aNetworkQoS->iTrafficClass); + r99Extension->SetDeliveryOrder(aNetworkQoS->iDeliveryOrderReqd); + r99Extension->SetErroneousSDUDelivery(aNetworkQoS->iDeliverErroneousSDU); + r99Extension->SetResidualBitErrorRatio(aNetworkQoS->iBER); + r99Extension->SetSDUErrorRatio(aNetworkQoS->iSDUErrorRatio); + r99Extension->SetTrafficHandlingPriority(aNetworkQoS->iTrafficHandlingPriority); + r99Extension->SetTransferDelay(aNetworkQoS->iTransferDelay); + r99Extension->SetMaxSduSize(aNetworkQoS->iMaxSDUSize); + r99Extension->SetMaxBitrateUplink(aNetworkQoS->iMaxRate.iUplinkRate); + r99Extension->SetMaxBitrateDownlink(aNetworkQoS->iMaxRate.iDownlinkRate); + r99Extension->SetGuaBitrateUplink(aNetworkQoS->iGuaranteedRate.iUplinkRate); + r99Extension->SetGuaBitrateDownlink(aNetworkQoS->iGuaranteedRate.iDownlinkRate); + + aGranted.AddExtensionSetL (r99Extension); + CleanupStack::Pop(); //r99Extension + } + +#ifdef SYMBIAN_NETWORKING_UMTSR5 +/** +Maps QoS parameters received from the network via Etel into a 3GPP Release R5 set and +sets it in the given event. + +@param aNetworkQoS - A pointer to an Etel RPacketQoS::TQoSR5Requested derived class containing +the QoS to be mapped. +@param aGranted - A reference to the CSubConGenEventParamsGranted object that should receive the +extension QoS parameters. +*/ +void CUmtsGprsSubConnProvd::MapQosEtelToR5SetL (RPacketQoS::TQoSR5Negotiated* aNetworkQoS, + CSubConGenEventParamsGranted& aGranted) + { + ASSERT (aNetworkQoS); + + CSubConQosR5ParamSet* r5Extension = CSubConQosR5ParamSet::NewL (); + CleanupStack::PushL(TCleanupItem(SubconParamSetCleanupFunction,r5Extension)); + r5Extension->SetTrafficClass(aNetworkQoS->iTrafficClass); + r5Extension->SetDeliveryOrder(aNetworkQoS->iDeliveryOrderReqd); + r5Extension->SetErroneousSDUDelivery(aNetworkQoS->iDeliverErroneousSDU); + r5Extension->SetResidualBitErrorRatio(aNetworkQoS->iBER); + r5Extension->SetSDUErrorRatio(aNetworkQoS->iSDUErrorRatio); + r5Extension->SetTrafficHandlingPriority(aNetworkQoS->iTrafficHandlingPriority); + r5Extension->SetTransferDelay(aNetworkQoS->iTransferDelay); + r5Extension->SetMaxSduSize(aNetworkQoS->iMaxSDUSize); + r5Extension->SetMaxBitrateUplink(aNetworkQoS->iMaxRate.iUplinkRate); + r5Extension->SetMaxBitrateDownlink(aNetworkQoS->iMaxRate.iDownlinkRate); + r5Extension->SetGuaBitrateUplink(aNetworkQoS->iGuaranteedRate.iUplinkRate); + r5Extension->SetGuaBitrateDownlink(aNetworkQoS->iGuaranteedRate.iDownlinkRate); + + r5Extension->SetSourceStatisticsDescriptor(aNetworkQoS->iSourceStatisticsDescriptor); + r5Extension->SetSignallingIndicator(aNetworkQoS->iSignallingIndication); + + aGranted.AddExtensionSetL (r5Extension); + CleanupStack::Pop(); //r5Extension + } + + +#endif +// SYMBIAN_NETWORKING_UMTSR5 + + +/** +Maps QoS parameters received from the network via Etel into a generic set and sets it in the given event. + +@param aNetworkQoS - A pointer to an Etel RPacketQoS::TQoSR99_R4Requested derived class containing the QoS +to be mapped. +@param aFamily - A reference to the CSubConGenEventParamsGranted object that should receive the +generic QoS parameters. +*/ +void CUmtsGprsSubConnProvd::MapQosEtelToGenericSetL (RPacketQoS::TQoSR99_R4Negotiated* aNetworkQoS, + CSubConGenEventParamsGranted& aGranted) + { + ASSERT (aNetworkQoS); + + CSubConQosGenericParamSet* genericQoS = CSubConQosGenericParamSet::NewL (); + + genericQoS->SetDownlinkBandwidth (aNetworkQoS->iGuaranteedRate.iDownlinkRate); + genericQoS->SetUplinkBandwidth (aNetworkQoS->iGuaranteedRate.iUplinkRate); + genericQoS->SetDownLinkDelay (aNetworkQoS->iTransferDelay); + genericQoS->SetUpLinkDelay (aNetworkQoS->iTransferDelay); + genericQoS->SetDownLinkMaximumPacketSize (aNetworkQoS->iMaxSDUSize); + genericQoS->SetUpLinkMaximumPacketSize (aNetworkQoS->iMaxSDUSize); + + switch (aNetworkQoS->iTrafficHandlingPriority) + { + case RPacketQoS::ETrafficPriority1: + genericQoS->SetDownLinkPriority (RPacketQoS::ETrafficPriority1); + genericQoS->SetUpLinkPriority (RPacketQoS::ETrafficPriority1); + break; + + case RPacketQoS::ETrafficPriority2: + genericQoS->SetDownLinkPriority (RPacketQoS::ETrafficPriority2); + genericQoS->SetUpLinkPriority (RPacketQoS::ETrafficPriority2); + break; + + case RPacketQoS::ETrafficPriority3: + genericQoS->SetDownLinkPriority (RPacketQoS::ETrafficPriority3); + genericQoS->SetUpLinkPriority (RPacketQoS::ETrafficPriority3); + break; + + default: + genericQoS->SetDownLinkPriority (RPacketQoS::ETrafficPriorityUnspecified); + genericQoS->SetUpLinkPriority (RPacketQoS::ETrafficPriorityUnspecified); + break; + } + + aGranted.SetGenericSet (genericQoS); + } + + + +CPdpFsmInterface& CUmtsGprsSubConnProvd::GetPdpFsmInterface() + { + return GetDefaultSubConnection().GetPdpFsmInterface(); + } + + +TBool CUmtsGprsSubConnProvd::PdpFsmEvent(TContextId aContextId, TInt aEvent, TInt aParam) + { + if (iCurrentPdpFsmReq) + { + TBool handled(EFalse); + handled = iCurrentPdpFsmReq->PdpFsmEvent(aContextId, aEvent, aParam); + return handled; + } + + // Any events that are not a result of a request that we've made must be forwarded to + // control clients. + + switch(aEvent) + { + case KContextParametersChangeEvent: + // For QoS Changed the event must be processed here, it doesn't occur as a response + // to something we've requested. + __FLOG_2(_L("CUmtsGprsSubConnProvd [this=%08x]:\tPdpFsmEvent(): QoS Params Changed [aParam=%d]"), this, aParam); + TRAP_IGNORE(NotifyParamsChangedL(aParam)); + break; + + case KContextDeleteEvent: + // For network-initiate close of PDP context. + __FLOG_2(_L("CUmtsGprsSubConnProvd [this=%08x]:\tPdpFsmEvent(): Context Delete Event [aParam=%d]"), this, aParam); + TRAP_IGNORE(NotifySubConDownL(aParam)); + break; + + case KContextBlockedEvent: // A PDP context becomes blocked + case KContextUnblockedEvent: // A PDP context becomes unblocked + case KNetworkStatusEvent: // For different network indications + case KContextQoSSetEvent: // Response to KContextQoSSet + case KContextTFTModifiedEvent: // Response to KContextTFTModify + case KPrimaryContextCreated: // Primary context at startup created + case KSecondaryContextCreated: // Secondary context created + case KContextModifyActiveEvent: // Response to KModifyActive + case KGetNegQoSEvent: // Response to KGetNegQoS. ** Used internally by NIF ** + default: + // Do nothing. + break; + } + + // Although we have notified the change of qos to the client application we haven't handled this + // event. We can get here because the network changed the QoS without a request from us, or + // because a secondary context (actually owned by GuQoS) has been promoted to default. + return EFalse; + } + +void CUmtsGprsSubConnProvd::NotifySubConDownL(TInt aError) + { + CSubConGenEventSubConDown* event = CSubConGenEventSubConDown::NewL(); + CleanupStack::PushL(TCleanupItem(SubconEventCleanupFunction, event)); + event->SetError(aError); + NotifyClientEvent(*event); + CleanupStack::PopAndDestroy (); //event + } + + +void CUmtsGprsSubConnProvd::NotifyParamsChangedL(TInt aError) + { + CSubConGenEventParamsChanged* event = CSubConGenEventParamsChanged::NewL(); + CleanupStack::PushL(TCleanupItem(SubconEventCleanupFunction, event)); + event->SetFamily (KSubConQoSFamily); + event->SetError (aError); + +#ifdef SYMBIAN_NETWORKING_UMTSR5 + RPacketQoS::TQoSR5Negotiated negotiatedQoS; +#else + RPacketQoS::TQoSR99_R4Negotiated negotiatedQoS; +#endif + + GetPdpFsmInterface().Get(GetContextId(), negotiatedQoS); + MapQosEtelToGrantedParamsL(&negotiatedQoS, *event); + NotifyClientEvent (*event); + CleanupStack::PopAndDestroy (); //event + } + + +MConnectionDataClient* CUmtsGprsSubConnProvd::DoSelfConnectionDataClient() + { + return this; + } + + +CPdpFsmRequestBase::CPdpFsmRequestBase(CUmtsGprsSubConnProvd& aProvider, MPdpFsmRequestOwner& aOwner) + :iProvider(aProvider), iOwner(aOwner) + { + __FLOG_OPEN(KUmtsGprsLogTag1, KUmtsGprsLogTag2); + } + + +CSubConnectionProviderBase* CUmtsGprsSubConnProvd::DoNextLayer() + { + __FLOG_1(_L("CUmtsGprsSubConnProvd::DoNextLayer [this=%08x] - this is (by design) the last layer"), this); + return NULL; + } + + +//-========================================================= +// +// Ignored overrides. +// +//-========================================================= + + + +/** Convert the given parameter budle to Etel language (r99) and if at the time possible, submit the request SPUDFSM. +@param +*/ +void CUmtsGprsSubConnProvd::DoParametersAboutToBeSetL(CSubConParameterBundle& /*aParameterBundle*/) + { + __FLOG_1(_L("CUmtsGprsSubConnProvd::DoParametersAboutToBeSetL [this=%08x]"), this); + + iParameterRelease = KParameterRelInvalid; + //TODO: implement set qos on secondaries when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + + +CConnDataTransfer& CUmtsGprsSubConnProvd::DoDataTransferL() + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + User::Leave(KErrNotSupported); + return iNextLayer->DataTransferL(); + } + + + +/** +From MConnectionDataClient +*/ +void CUmtsGprsSubConnProvd::Notify(TNotify /*aNotifyType*/, CConnectionProviderBase* /*aConnProvider*/, + TInt /*aError*/, const CConNotificationEvent* /*aConNotificationEvent*/) + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +/** +From MConnectionDataClient +*/ +void CUmtsGprsSubConnProvd::AttachToNext(CSubConnectionProviderBase* /*aSubConnProvider*/) + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +/** +From MConnectionDataClient +*/ +void CUmtsGprsSubConnProvd::ConnectionGoingDown(CConnectionProviderBase& aConnProvider) + { + (void)aConnProvider; + __FLOG_2(_L("CUmtsGprsSubConnProvd [this=%08x]:\tConnectionGoingDown() [aConnProvider=%08x]"), this, &aConnProvider); + iConnectionProvider = NULL; + DeleteMeNow(); + } + +/** +From MConnectionDataClient +*/ +void CUmtsGprsSubConnProvd::ConnectionError(TInt /*aStage*/, TInt /*aError*/) + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +/** +Function called by Connection Provider when a socket is to be added to the QoS Flow ('this') + +@param aDataClient Data Client to add to the QoS Channel +*/ +void CUmtsGprsSubConnProvd::DoDataClientJoiningL(MSubConnectionDataClient& aDataClient) + { + (void)aDataClient; + __FLOG_3(_L("CUmtsGprsSubConnProvd [this=%08x]:\tDoDataClientJoiningL() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient); + //We're not interested in knowing about MSubConnectionDataClient joining this sub-connection + } + +/** +Function called by Connection Provider when a socket is to be removed from the QoS Flow ('this') + +@param aDataClient Data Client to remove from this QoS Channel +*/ +void CUmtsGprsSubConnProvd::DoDataClientLeaving(MSubConnectionDataClient& aDataClient) + { + (void)aDataClient; + __FLOG_3(_L("CUmtsGprsSubConnProvd [this=%08x]:\tDoDataClientLeaving() [iDataClients.Count=%d] [aDataClient=%08x]"), this, iDataClients.Count(), &aDataClient); + aDataClient.LeaveComplete (*this); + } + +/** +Function called by SubConnection Provider when a control client is to join to this the QoS Flow ('this') + +@param aControlClient Control Client to remove from this QoS Channel +*/ +void CUmtsGprsSubConnProvd::DoControlClientJoiningL(MSubConnectionControlClient& aControlClient) + { + (void)aControlClient; + __FLOG_3(_L("CUmtsGprsSubConnProvd [this=%08x]:\tDoControlClientJoiningL() [iControlClients.Count=%d] [aControlClient=%08x]"), this, iControlClients.Count(), &aControlClient); + //We're not interested in knowing about MSubConnectionControlClient joining this sub-connection + } + +/** +Function called by SubConnection Provider when a control client is to be removed from the QoS Flow ('this') + +@param aControlClient Control Client to remove from this QoS Channel +*/ +void CUmtsGprsSubConnProvd::DoControlClientLeaving(MSubConnectionControlClient& aControlClient) + { + (void)aControlClient; + __FLOG_3(_L("CUmtsGprsSubConnProvd [this=%08x]:\tDoControlClientLeaving() [iControlClients.Count=%d] [aControlClient=%08x]"), this, iControlClients.Count(), &aControlClient); + //We're not interested in knowing about MSubConnectionControlClient leaving this sub-connection + } + + +/** +@param +*/ +void CUmtsGprsSubConnProvd::DoSourceAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aSource*/) + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +/** +@param +*/ +void CUmtsGprsSubConnProvd::DoDestinationAddressUpdate(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aDestination*/) + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +void CUmtsGprsSubConnProvd::DoDataClientRouted(MSubConnectionDataClient& /*aDataClient*/, const TSockAddr& /*aSource*/, const TSockAddr& /*aDestination*/, const TDesC8& /*aConnectionInfo*/) +/** + +@param +*/ + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +TInt CUmtsGprsSubConnProvd::DoControl(TUint /*aOptionLevel*/, TUint /*aOptionName*/, TDes8& /*aOption*/) +/** + +@param +*/ + { + __FLOG_1(_L("CUmtsGprsSubConnProvd::DoControl [this=%08x]"), this); + return KErrNotSupported; + } + +void CUmtsGprsSubConnProvd::DoStartL() +/** + +@param +*/ + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + +void CUmtsGprsSubConnProvd::DoStop() +/** + +@param +*/ + { + //TODO: implement when UmtsGprsSCPR enables ECreateNew SubConnection Providers. + } + + +CUmtsGprsSubConnProvd::~CUmtsGprsSubConnProvd () + { + __FLOG_1(_L("~CUmtsGprsSubConnProvd [this=%08x]"), this); + if (iConnectionProvider) + { + iConnectionProvider->Leave(*this); + } + delete iCurrentPdpFsmReq; + __FLOG_CLOSE; + }