diff -r 000000000000 -r 3553901f7fa8 telephonyprotocols/gprsumtsqosprt/src/parameters.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyprotocols/gprsumtsqosprt/src/parameters.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,840 @@ +// Copyright (c) 2007-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: +// + +#include "parameters.h" +#include "umts_qos_variables.h" +#include "guqos_log.h" +#include "guqos.h" + + +TQoSRequested::TQoSRequested() : iHeaderCompression(0) + { + Reset(); + } + +void TQoSRequested::Reset() + { + iReqTrafficClass = RPacketQoS::ETrafficClassUnspecified; + iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; + iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + iReqMaxSDUSize = 0; // subscribe value + iMinAcceptableMaxSDUSize = 0; // subscribe value + iReqMaxRate.iUplinkRate = 0; + iReqMaxRate.iDownlinkRate = 0; + iMinAcceptableMaxRate.iUplinkRate = 0; + iMinAcceptableMaxRate.iDownlinkRate = 0; + iReqBER = RPacketQoS::EBERUnspecified; + iMaxBER = RPacketQoS::EBERUnspecified; + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + iReqTransferDelay = 0; + iMaxTransferDelay = 0; + iReqGuaranteedRate.iUplinkRate = 0; + iReqGuaranteedRate.iDownlinkRate = 0; + iMinGuaranteedRate.iUplinkRate = 0; + iMinGuaranteedRate.iDownlinkRate = 0; + } + +void TQoSRequested::ClearMinimumParameters() + { + iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; + iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + iMinAcceptableMaxSDUSize = 0; + iMinAcceptableMaxRate.iUplinkRate = 0; + iMinAcceptableMaxRate.iDownlinkRate = 0; + iMaxBER = RPacketQoS::EBERUnspecified; + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + iMaxTransferDelay = 0; + iMinGuaranteedRate.iUplinkRate = 0; + iMinGuaranteedRate.iDownlinkRate = 0; + } + +void TQoSRequested::ParsePolicyData(CExtensionPolicy* extensionPolicy) + { + LOG(Log::Printf(_L("<-------------------------------------------------"))); + LOG(Log::Printf(_L("TQoSRequested::ParsePolicyData - Start Parsing Extensions"))); + + TExtensionQueueIter i(extensionPolicy->Extensions()); + CExtension* extension; + + while ((extension = i++) != NULL) + { + if( (extension->Type() != STATIC_CAST(TUint,KPfqosR5ExtensionUmts)) + && (extension->Type() != STATIC_CAST(TUint,KPfqosExtensionUmts)) + ) + { + LOG(Log::Printf(_L("\tKPfqosExtensionUmts - Extension NOT found"))); + continue; + } + + LOG(Log::Printf(_L("\tKPfqosExtensionUmts - Extension found"))); + + + TVariableQueueIter iter(extension->Queue()); + TVariableBase *var; + + while ((var = iter++) != NULL) + { + switch (var->Type()) + { + + case KPfqosTypeInteger: + { + TIntVariable* tmp = (TIntVariable*) var; + LOG(Log::Printf(_L("\tKPfqosExtensionUmts '%S': %d"), &tmp->Name(), tmp->Value())); + + //lint -e{961} would want terminating 'else' (but we don't) + if (tmp->Name().Compare(KDescDeliveryOfErroneusSduRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EErroneousSDUDeliveryUnspecified: + iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + break; + case RPacketQoS::EErroneousSDUDeliveryRequired: + iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; + break; + case RPacketQoS::EErroneousSDUDeliveryNotRequired: + iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescDeliveryOrderRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EDeliveryOrderUnspecified: + iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + break; + case RPacketQoS::EDeliveryOrderRequired: + iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderRequired; + break; + case RPacketQoS::EDeliveryOrderNotRequired: + iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescErrorRatioRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ESDUErrorRatioUnspecified: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + break; + case RPacketQoS::ESDUErrorRatioOnePerTen: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTen; + break; + case RPacketQoS::ESDUErrorRatioOnePerHundred: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundred; + break; + case RPacketQoS::ESDUErrorRatioSevenPerThousand: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioSevenPerThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerThousand: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerTenThousand: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerHundredThousand: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundredThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerMillion: + iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescGuaBitrateDownlinkRequested)==0) + { + iReqGuaranteedRate.iDownlinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescGuaBitrateUplinkRequested)==0) + { + iReqGuaranteedRate.iUplinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxBitrateDownlinkRequested)==0) + { + iReqMaxRate.iDownlinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxBitrateUplinkRequested)==0) + { + iReqMaxRate.iUplinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxSduSizeRequested)==0) + { + iReqMaxSDUSize = tmp->Value(); + } + else if (tmp->Name().Compare(KDescPriorityRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ETrafficPriorityUnspecified: + iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + break; + case RPacketQoS::ETrafficPriority1: + iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; + break; + case RPacketQoS::ETrafficPriority2: + iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; + break; + case RPacketQoS::ETrafficPriority3: + iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescResidualBerRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EBERUnspecified: + iReqBER = RPacketQoS::EBERUnspecified; + break; + case RPacketQoS::EBERFivePerHundred: + iReqBER = RPacketQoS::EBERFivePerHundred; + break; + case RPacketQoS::EBEROnePerHundred: + iReqBER = RPacketQoS::EBEROnePerHundred; + break; + case RPacketQoS::EBERFivePerThousand: + iReqBER = RPacketQoS::EBERFivePerThousand; + break; + case RPacketQoS::EBERFourPerThousand: + iReqBER = RPacketQoS::EBERFourPerThousand; + break; + case RPacketQoS::EBEROnePerThousand: + iReqBER = RPacketQoS::EBEROnePerThousand; + break; + case RPacketQoS::EBEROnePerTenThousand: + iReqBER = RPacketQoS::EBEROnePerTenThousand; + break; + case RPacketQoS::EBEROnePerHundredThousand: + iReqBER = RPacketQoS::EBEROnePerHundredThousand; + break; + case RPacketQoS::EBEROnePerMillion: + iReqBER = RPacketQoS::EBEROnePerMillion; + break; + case RPacketQoS::EBERSixPerHundredMillion: + iReqBER = RPacketQoS::EBERSixPerHundredMillion; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescTrafficClassRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ETrafficClassUnspecified: + iReqTrafficClass = RPacketQoS::ETrafficClassUnspecified; + break; + case RPacketQoS::ETrafficClassConversational: + iReqTrafficClass = RPacketQoS::ETrafficClassConversational; + break; + case RPacketQoS::ETrafficClassStreaming: + iReqTrafficClass = RPacketQoS::ETrafficClassStreaming; + break; + case RPacketQoS::ETrafficClassInteractive: + iReqTrafficClass = RPacketQoS::ETrafficClassInteractive; + break; + case RPacketQoS::ETrafficClassBackground: + iReqTrafficClass = RPacketQoS::ETrafficClassBackground; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescTransferDelayRequested)==0) + { + iReqTransferDelay = tmp->Value(); + } + // Minimum + else if (tmp->Name().Compare(KDescDeliveryOfErroneusSduMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EErroneousSDUDeliveryUnspecified: + iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + break; + case RPacketQoS::EErroneousSDUDeliveryRequired: + iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; + break; + case RPacketQoS::EErroneousSDUDeliveryNotRequired: + iMinDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescDeliveryOrderMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EDeliveryOrderUnspecified: + iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + break; + case RPacketQoS::EDeliveryOrderRequired: + iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderRequired; + break; + case RPacketQoS::EDeliveryOrderNotRequired: + iMinDeliveryOrderReqd = RPacketQoS::EDeliveryOrderNotRequired; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescErrorRatioMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ESDUErrorRatioUnspecified: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + break; + case RPacketQoS::ESDUErrorRatioOnePerTen: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTen; + break; + case RPacketQoS::ESDUErrorRatioOnePerHundred: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundred; + break; + case RPacketQoS::ESDUErrorRatioSevenPerThousand: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioSevenPerThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerThousand: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerTenThousand: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerHundredThousand: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundredThousand; + break; + case RPacketQoS::ESDUErrorRatioOnePerMillion: + iMaxSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerMillion; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescGuaBitrateDownlinkMinimum)==0) + { + iMinGuaranteedRate.iDownlinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescGuaBitrateUplinkMinimum)==0) + { + iMinGuaranteedRate.iUplinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxBitrateDownlinkMinimum)==0) + { + iMinAcceptableMaxRate.iDownlinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxBitrateUplinkMinimum)==0) + { + iMinAcceptableMaxRate.iUplinkRate = tmp->Value(); + } + else if (tmp->Name().Compare(KDescMaxSduSizeMinimum)==0) + { + iMinAcceptableMaxSDUSize = tmp->Value(); + } + else if (tmp->Name().Compare(KDescPriorityMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ETrafficPriorityUnspecified: + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + break; + case RPacketQoS::ETrafficPriority1: + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; + break; + case RPacketQoS::ETrafficPriority2: + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; + break; + case RPacketQoS::ETrafficPriority3: + iMinTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescResidualBerMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::EBERUnspecified: + iMaxBER = RPacketQoS::EBERUnspecified; + break; + case RPacketQoS::EBERFivePerHundred: + iMaxBER = RPacketQoS::EBERFivePerHundred; + break; + case RPacketQoS::EBEROnePerHundred: + iMaxBER = RPacketQoS::EBEROnePerHundred; + break; + case RPacketQoS::EBERFivePerThousand: + iMaxBER = RPacketQoS::EBERFivePerThousand; + break; + case RPacketQoS::EBERFourPerThousand: + iMaxBER = RPacketQoS::EBERFourPerThousand; + break; + case RPacketQoS::EBEROnePerThousand: + iMaxBER = RPacketQoS::EBEROnePerThousand; + break; + case RPacketQoS::EBEROnePerTenThousand: + iMaxBER = RPacketQoS::EBEROnePerTenThousand; + break; + case RPacketQoS::EBEROnePerHundredThousand: + iMaxBER = RPacketQoS::EBEROnePerHundredThousand; + break; + case RPacketQoS::EBEROnePerMillion: + iMaxBER = RPacketQoS::EBEROnePerMillion; + break; + case RPacketQoS::EBERSixPerHundredMillion: + iMaxBER = RPacketQoS::EBERSixPerHundredMillion; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescTrafficClassMinimum)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ETrafficClassUnspecified: + iMinTrafficClass = RPacketQoS::ETrafficClassUnspecified; + break; + case RPacketQoS::ETrafficClassConversational: + iMinTrafficClass = RPacketQoS::ETrafficClassConversational; + break; + case RPacketQoS::ETrafficClassStreaming: + iMinTrafficClass = RPacketQoS::ETrafficClassStreaming; + break; + case RPacketQoS::ETrafficClassInteractive: + iMinTrafficClass = RPacketQoS::ETrafficClassInteractive; + break; + case RPacketQoS::ETrafficClassBackground: + iMinTrafficClass = RPacketQoS::ETrafficClassBackground; + break; + default: + break; + } + } + else if (tmp->Name().Compare(KDescTransferDelayMinimum)==0) + { + iMaxTransferDelay = tmp->Value(); + } +#ifdef SYMBIAN_NETWORKING_UMTSR5 + else if (tmp->Name().Compare(KDescSignallingIndicatorRequested)==0) + { + iSignallingIndication = tmp->Value(); + } + else if (tmp->Name().Compare(KDescSrcStatDescRequested)==0) + { + TInt value = tmp->Value(); + switch(value) + { + case RPacketQoS::ESourceStatisticsDescriptorUnknown: + iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorUnknown; + break; + case RPacketQoS::ESourceStatisticsDescriptorSpeech: + iSourceStatisticsDescriptor = RPacketQoS::ESourceStatisticsDescriptorSpeech; + break; + default: + break; + } + } +#endif // SYMBIAN_NETWORKING_UMTSR5 + else if (tmp->Name().Compare(KDescHeaderCompression)==0) + { + iHeaderCompression = tmp->Value(); + } + } + break; + + default: + LOG(Log::Printf(_L("\tKPfqosExtensionUmts type=%d '%S': ignored"), (TInt)var->Type(), &var->Name())); + break; + } + } + } + + LOG(Log::Printf(_L("TQoSRequested::ParsePolicyData - End Parsing Extensions"))); + LOG(Log::Printf(_L("PARSED VALUES:"))); + LOG(Log::Printf(_L("\tiReqTrafficClass = %d"), iReqTrafficClass)); + LOG(Log::Printf(_L("\tiReqDeliveryOrderReqd = %d"), iReqDeliveryOrderReqd)); + LOG(Log::Printf(_L("\tiReqDeliverErroneousSDU = %d"), iReqDeliverErroneousSDU)); + LOG(Log::Printf(_L("\tiReqMaxSDUSize = %d"), iReqMaxSDUSize)); + LOG(Log::Printf(_L("\tiReqMaxRate.iUplinkRate = %d"), iReqMaxRate.iUplinkRate)); + LOG(Log::Printf(_L("\tiReqMaxRate.iDownlinkRate = %d"), iReqMaxRate.iDownlinkRate)); + LOG(Log::Printf(_L("\tiReqBER = %d"), iReqBER)); + LOG(Log::Printf(_L("\tiReqSDUErrorRatio = %d"), iReqSDUErrorRatio)); + LOG(Log::Printf(_L("\tiReqTrafficHandlingPriority = %d"),iReqTrafficHandlingPriority)); + LOG(Log::Printf(_L("\tiReqTransferDelay = %d"), iReqTransferDelay)); + LOG(Log::Printf(_L("\tiReqGuaranteedRate.iUplinkRate = %d"),iReqGuaranteedRate.iUplinkRate)); + LOG(Log::Printf(_L("\tiReqGuaranteedRate.iDownlinkRate = %d"),iReqGuaranteedRate.iDownlinkRate)); + LOG(Log::Printf(_L(""))); + LOG(Log::Printf(_L("\tiMinTrafficClass = %d"), iMinTrafficClass)); + LOG(Log::Printf(_L("\tiMinDeliveryOrderReqd = %d"), iMinDeliveryOrderReqd)); + LOG(Log::Printf(_L("\tiMinDeliverErroneousSDU = %d") ,iMinDeliverErroneousSDU)); + LOG(Log::Printf(_L("\tiMinAcceptableMaxSDUSize = %d") ,iMinAcceptableMaxSDUSize)); + LOG(Log::Printf(_L("\tiMinAcceptableMaxRate.iUplinkRate = %d"),iMinAcceptableMaxRate.iUplinkRate)); + LOG(Log::Printf(_L("\tiMinAcceptableMaxRate.iDownlinkRate= %d"),iMinAcceptableMaxRate.iDownlinkRate)); + LOG(Log::Printf(_L("\tiMaxBER = %d"), iMaxBER)); + LOG(Log::Printf(_L("\tiMaxSDUErrorRatio = %d"), iMaxSDUErrorRatio)); + LOG(Log::Printf(_L("\tiMinTrafficHandlingPriority = %d"),iMinTrafficHandlingPriority)); + LOG(Log::Printf(_L("\tiMaxTransferDelay = %d"), iMaxTransferDelay)); + LOG(Log::Printf(_L("\tiMinGuaranteedRate.iUplinkRate = %d"),iMinGuaranteedRate.iUplinkRate)); + LOG(Log::Printf(_L("\tiMinGuaranteedRate.iDownlinkRate = %d"),iMinGuaranteedRate.iDownlinkRate)); +#ifdef SYMBIAN_NETWORKING_UMTSR5 + LOG(Log::Printf(_L("\tiSignallingIndication = %d"),iSignallingIndication)); + LOG(Log::Printf(_L("\tiSourceStatisticsDescriptor = %d"),iSourceStatisticsDescriptor)); +#endif // SYMBIAN_NETWORKING_UMTSR5 + + } + +void ParameterMapper::MapGenericToRel99(const TQoSParameters& aSpec, RPacketQoS::TQoSR99_R4Requested& aGprs) + { + // + // Traffic class + // + if ((aSpec.GetUpLinkDelay() < 250 && aSpec.GetUpLinkDelay() > 0) || + (aSpec.GetDownLinkDelay() < 250 && aSpec.GetDownLinkDelay() > 0)) + aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassConversational; + else if (aSpec.GetUpLinkDelay() >= 250 || aSpec.GetDownLinkDelay() >= 250) + aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassStreaming; + else if ((aSpec.GetUpLinkPriority() >= 0 && aSpec.GetUpLinkPriority() <= 2) || + (aSpec.GetDownLinkPriority() >= 0 && aSpec.GetDownLinkPriority() <= 2)) + aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassInteractive; + else + aGprs.iReqTrafficClass = RPacketQoS::ETrafficClassBackground; + + aGprs.iMinTrafficClass = aGprs.iReqTrafficClass; + + // + // Delivery order + // + aGprs.iReqDeliveryOrderReqd = RPacketQoS::EDeliveryOrderUnspecified; + aGprs.iMinDeliveryOrderReqd = aGprs.iReqDeliveryOrderReqd; + + // + // Delivery of erroneous SDUs + // + aGprs.iReqDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; + aGprs.iMinDeliverErroneousSDU = aGprs.iReqDeliverErroneousSDU; + + // + // Residual BER + // + aGprs.iReqBER = RPacketQoS::EBERUnspecified; + aGprs.iMaxBER = aGprs.iReqBER; + + // + // SDU error ratio + // + aGprs.iReqSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + aGprs.iMaxSDUErrorRatio = aGprs.iReqSDUErrorRatio; + + // + // Traffic handling priority + // + if (aGprs.iReqTrafficClass == RPacketQoS::ETrafficClassInteractive) + { + if (aSpec.GetUpLinkPriority() == 0 || aSpec.GetDownLinkPriority() == 0) + aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; + else if (aSpec.GetUpLinkPriority() == 1 || aSpec.GetDownLinkPriority() == 1) + aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; + else + aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; + } + else + { + aGprs.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + } + + aGprs.iMinTrafficHandlingPriority = aGprs.iReqTrafficHandlingPriority; + + // + // Transfer delay + // + aGprs.iReqTransferDelay = ParameterMapper::Min(aSpec.GetUpLinkDelay(), aSpec.GetDownLinkDelay()); + aGprs.iMaxTransferDelay = aGprs.iReqTransferDelay; + + // + // Maximum SDU size + // + aGprs.iReqMaxSDUSize = aSpec.GetUpLinkMaximumPacketSize(); + aGprs.iMinAcceptableMaxSDUSize = aGprs.iReqMaxSDUSize; + + // + // Maximum bitrate + // + aGprs.iReqMaxRate.iUplinkRate = aSpec.GetUplinkBandwidth(); + aGprs.iReqMaxRate.iDownlinkRate = aSpec.GetDownlinkBandwidth(); + + // + // Guaranteed bitrate + // + aGprs.iReqGuaranteedRate.iUplinkRate = aSpec.GetUplinkBandwidth(); + aGprs.iReqGuaranteedRate.iDownlinkRate = aSpec.GetDownlinkBandwidth(); + } + + +TInt ParameterMapper::CombineParameters(const RPacketQoS::TQoSR99_R4Requested& aGprs, TQoSParameters& aFlowSpec) + { + if (aGprs.iReqGuaranteedRate.iUplinkRate > 0) + aFlowSpec.SetUplinkBandwidth(aGprs.iReqGuaranteedRate.iUplinkRate); + if (aGprs.iReqGuaranteedRate.iDownlinkRate > 0) + aFlowSpec.SetDownlinkBandwidth(aGprs.iReqGuaranteedRate.iDownlinkRate); + + return KErrNone; + } + + +void ParameterMapper::CombineDefault(const TQoSRequested& aDefault, TQoSRequested& aPolicy) + { + if (aPolicy.iReqTrafficClass == RPacketQoS::ETrafficClassUnspecified) + aPolicy.iReqTrafficClass = aDefault.iReqTrafficClass; + if (aPolicy.iMinTrafficClass == RPacketQoS::ETrafficClassUnspecified) + aPolicy.iMinTrafficClass = aDefault.iMinTrafficClass; + if (aPolicy.iReqDeliveryOrderReqd == RPacketQoS::EDeliveryOrderUnspecified) + aPolicy.iReqDeliveryOrderReqd = aDefault.iReqDeliveryOrderReqd; + if (aPolicy.iMinDeliveryOrderReqd == RPacketQoS::EDeliveryOrderUnspecified) + aPolicy.iMinDeliveryOrderReqd = aDefault.iMinDeliveryOrderReqd; + if (aPolicy.iReqDeliverErroneousSDU == RPacketQoS::EErroneousSDUDeliveryUnspecified) + aPolicy.iReqDeliverErroneousSDU = aDefault.iReqDeliverErroneousSDU; + if (aPolicy.iMinDeliverErroneousSDU == RPacketQoS::EErroneousSDUDeliveryUnspecified) + aPolicy.iMinDeliverErroneousSDU = aDefault.iMinDeliverErroneousSDU; + if (aPolicy.iReqMaxSDUSize == 0) + aPolicy.iReqMaxSDUSize = aDefault.iReqMaxSDUSize; + if (aPolicy.iMinAcceptableMaxSDUSize == 0) + aPolicy.iMinAcceptableMaxSDUSize = aDefault.iMinAcceptableMaxSDUSize; + if (aPolicy.iReqMaxRate.iUplinkRate == 0) + aPolicy.iReqMaxRate.iUplinkRate = aDefault.iReqMaxRate.iUplinkRate; + if (aPolicy.iReqMaxRate.iDownlinkRate == 0) + aPolicy.iReqMaxRate.iDownlinkRate = aDefault.iReqMaxRate.iDownlinkRate; + if (aPolicy.iMinAcceptableMaxRate.iUplinkRate == 0) + aPolicy.iMinAcceptableMaxRate.iUplinkRate = aDefault.iMinAcceptableMaxRate.iUplinkRate; + if (aPolicy.iMinAcceptableMaxRate.iDownlinkRate == 0) + aPolicy.iMinAcceptableMaxRate.iDownlinkRate = aDefault.iMinAcceptableMaxRate.iDownlinkRate; + if (aPolicy.iReqBER == RPacketQoS::EBERUnspecified) + aPolicy.iReqBER = aDefault.iReqBER; + if (aPolicy.iMaxBER == RPacketQoS::EBERUnspecified) + aPolicy.iMaxBER = aDefault.iMaxBER; + if (aPolicy.iReqSDUErrorRatio == RPacketQoS::ESDUErrorRatioUnspecified) + aPolicy.iReqSDUErrorRatio = aDefault.iReqSDUErrorRatio; + if (aPolicy.iMaxSDUErrorRatio == RPacketQoS::ESDUErrorRatioUnspecified) + aPolicy.iMaxSDUErrorRatio = aDefault.iMaxSDUErrorRatio; + if (aPolicy.iReqTrafficHandlingPriority == RPacketQoS::ETrafficPriorityUnspecified) + aPolicy.iReqTrafficHandlingPriority = aDefault.iReqTrafficHandlingPriority; + if (aPolicy.iMinTrafficHandlingPriority == RPacketQoS::ETrafficPriorityUnspecified) + aPolicy.iMinTrafficHandlingPriority = aDefault.iMinTrafficHandlingPriority; + if (aPolicy.iReqTransferDelay == 0) + aPolicy.iReqTransferDelay = aDefault.iReqTransferDelay; + if (aPolicy.iMaxTransferDelay == 0) + aPolicy.iMaxTransferDelay = aDefault.iMaxTransferDelay; + if (aPolicy.iReqGuaranteedRate.iUplinkRate == 0) + aPolicy.iReqGuaranteedRate.iUplinkRate = aDefault.iReqGuaranteedRate.iUplinkRate; + if (aPolicy.iReqGuaranteedRate.iDownlinkRate == 0) + aPolicy.iReqGuaranteedRate.iDownlinkRate = aDefault.iReqGuaranteedRate.iDownlinkRate; + if (aPolicy.iMinGuaranteedRate.iUplinkRate == 0) + aPolicy.iMinGuaranteedRate.iUplinkRate = aDefault.iMinGuaranteedRate.iUplinkRate; + if (aPolicy.iMinGuaranteedRate.iDownlinkRate == 0) + aPolicy.iMinGuaranteedRate.iDownlinkRate = aDefault.iMinGuaranteedRate.iDownlinkRate; + } + + +void ParameterMapper::CombineOverride(const TQoSRequested& aOverride, TQoSRequested& aPolicy) + { + if (aOverride.iReqTrafficClass != RPacketQoS::ETrafficClassUnspecified) + aPolicy.iReqTrafficClass = aOverride.iReqTrafficClass; + if (aOverride.iMinTrafficClass != RPacketQoS::ETrafficClassUnspecified) + aPolicy.iMinTrafficClass = aOverride.iMinTrafficClass; + if (aOverride.iReqDeliveryOrderReqd != RPacketQoS::EDeliveryOrderUnspecified) + aPolicy.iReqDeliveryOrderReqd = aOverride.iReqDeliveryOrderReqd; + if (aOverride.iMinDeliveryOrderReqd != RPacketQoS::EDeliveryOrderUnspecified) + aPolicy.iMinDeliveryOrderReqd = aOverride.iMinDeliveryOrderReqd; + if (aOverride.iReqDeliverErroneousSDU != RPacketQoS::EErroneousSDUDeliveryUnspecified) + aPolicy.iReqDeliverErroneousSDU = aOverride.iReqDeliverErroneousSDU; + if (aOverride.iMinDeliverErroneousSDU != RPacketQoS::EErroneousSDUDeliveryUnspecified) + aPolicy.iMinDeliverErroneousSDU = aOverride.iMinDeliverErroneousSDU; + if (aOverride.iReqMaxSDUSize > 0) + aPolicy.iReqMaxSDUSize = aOverride.iReqMaxSDUSize; + if (aOverride.iMinAcceptableMaxSDUSize > 0) + aPolicy.iMinAcceptableMaxSDUSize = aOverride.iMinAcceptableMaxSDUSize; + if (aOverride.iReqMaxRate.iUplinkRate > 0) + aPolicy.iReqMaxRate.iUplinkRate = aOverride.iReqMaxRate.iUplinkRate; + if (aOverride.iReqMaxRate.iDownlinkRate > 0) + aPolicy.iReqMaxRate.iDownlinkRate = aOverride.iReqMaxRate.iDownlinkRate; + if (aOverride.iMinAcceptableMaxRate.iUplinkRate > 0) + aPolicy.iMinAcceptableMaxRate.iUplinkRate = aOverride.iMinAcceptableMaxRate.iUplinkRate; + if (aOverride.iMinAcceptableMaxRate.iDownlinkRate > 0) + aPolicy.iMinAcceptableMaxRate.iDownlinkRate = aOverride.iMinAcceptableMaxRate.iDownlinkRate; + if (aOverride.iReqBER != RPacketQoS::EBERUnspecified) + aPolicy.iReqBER = aOverride.iReqBER; + if (aOverride.iMaxBER != RPacketQoS::EBERUnspecified) + aPolicy.iMaxBER = aOverride.iMaxBER; + if (aOverride.iReqSDUErrorRatio != RPacketQoS::ESDUErrorRatioUnspecified) + aPolicy.iReqSDUErrorRatio = aOverride.iReqSDUErrorRatio; + if (aOverride.iMaxSDUErrorRatio != RPacketQoS::ESDUErrorRatioUnspecified) + aPolicy.iMaxSDUErrorRatio = aOverride.iMaxSDUErrorRatio; + if (aOverride.iReqTrafficHandlingPriority != RPacketQoS::ETrafficPriorityUnspecified) + aPolicy.iReqTrafficHandlingPriority = aOverride.iReqTrafficHandlingPriority; + if (aOverride.iMinTrafficHandlingPriority != RPacketQoS::ETrafficPriorityUnspecified) + aPolicy.iMinTrafficHandlingPriority = aOverride.iMinTrafficHandlingPriority; + if (aOverride.iReqTransferDelay > 0) + aPolicy.iReqTransferDelay = aOverride.iReqTransferDelay; + if (aOverride.iMaxTransferDelay > 0) + aPolicy.iMaxTransferDelay = aOverride.iMaxTransferDelay; + if (aOverride.iReqGuaranteedRate.iUplinkRate > 0) + aPolicy.iReqGuaranteedRate.iUplinkRate = aOverride.iReqGuaranteedRate.iUplinkRate; + if (aOverride.iReqGuaranteedRate.iDownlinkRate > 0) + aPolicy.iReqGuaranteedRate.iDownlinkRate = aOverride.iReqGuaranteedRate.iDownlinkRate; + if (aOverride.iMinGuaranteedRate.iUplinkRate > 0) + aPolicy.iMinGuaranteedRate.iUplinkRate = aOverride.iMinGuaranteedRate.iUplinkRate; + if (aOverride.iMinGuaranteedRate.iDownlinkRate > 0) + aPolicy.iMinGuaranteedRate.iDownlinkRate = aOverride.iMinGuaranteedRate.iDownlinkRate; +#ifdef SYMBIAN_NETWORKING_UMTSR5 + if (aOverride.iSignallingIndication == 0 && aOverride.iReqTrafficClass == RPacketQoS::ETrafficClassInteractive ) + aPolicy.iReqTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; +#endif // SYMBIAN_NETWORKING_UMTSR5 + aPolicy.iHeaderCompression = aOverride.iHeaderCompression; +#ifdef SYMBIAN_NETWORKING_UMTSR5 + aPolicy.iSignallingIndication = aOverride.iSignallingIndication; + aPolicy.iSourceStatisticsDescriptor =aOverride.iSourceStatisticsDescriptor; +#endif // SYMBIAN_NETWORKING_UMTSR5 + } + +// if SBLP presents, this method will return ETrue +TBool RFlowExtensionParams::ParsePolicyDataForSblp( CExtensionPolicy * aExtensionPolicy ) + { + TBool retValue = EFalse; + + TExtensionQueueIter i(aExtensionPolicy->Extensions()); + CExtension* extension; + while ((extension = i++) != NULL) + { + if (extension->Type() != STATIC_CAST(TUint, KPfqosExtensionSBLP)) + continue; + + LOG(Log::Printf(_L(""))); + LOG(Log::Printf(_L("PARSED SBLP VALUES"))); + + // KPfqosExtensionSBLP presents! so return ETrue + retValue = ETrue; + + TVariableQueueIter iter(extension->Queue()); + TVariableBase *var; + + TUint16 mediaComponentNumberCount = 0; + TUint16 ipFlowNumberCount = 0; + RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier flowIdTemp; + + while ((var = iter++) != NULL) + { + switch (var->Type()) + { + case KPfqosTypeInteger: + { + TIntVariable* tmp = (TIntVariable*) var; + //lint -e{961} would want terminating 'else' (but we don't?) + if (tmp->Name().Compare(KDescSblpMediaComponentNumber)==0) + { + TInt value = tmp->Value(); + flowIdTemp.iMediaComponentNumber = static_cast(value); + LOG(Log::Printf(_L("\tMedia component number = %d"),flowIdTemp.iMediaComponentNumber)); + mediaComponentNumberCount++; + } + else if (tmp->Name().Compare(KDescSblpIPFlowNumber)==0) + { + TInt value = tmp->Value(); + flowIdTemp.iIPFlowNumber = static_cast(value); + LOG(Log::Printf(_L("\tIP flow number = %d"),flowIdTemp.iIPFlowNumber)); + ipFlowNumberCount++; + + if(mediaComponentNumberCount == ipFlowNumberCount) + { + iFlowIds.Append(flowIdTemp); + } + } + } + break; + + case KPfqosTypeString: + { + TStringVariable* stringVar = (TStringVariable*) var; + if (stringVar->Name().Compare(KDescSblpMediaAuthorizationToken)==0) + { + //TBuf strValue = stringVar->Value(); + iAuthorizationToken.Copy(stringVar->Value()); + LOG(Log::Printf(_L("\tMAT string = '%S'"), &stringVar->Value())); + } + } + break; + + default: + break; + } + } + } + return retValue; + } + +//lint -e{1927} would like to use initializer list +RFlowExtensionParams::RFlowExtensionParams() + { + } + +RFlowExtensionParams& RFlowExtensionParams::operator=(const RFlowExtensionParams& aFlowExtParam) + { + // NOP, if assigned to self + if (this != &aFlowExtParam) + { + iAuthorizationToken.Copy(aFlowExtParam.iAuthorizationToken); + iFlowIds.Reset(); + for(TInt i=0; i