// 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:

// umtsapi.h - UMTS QoS API

//

#include "umtsextn.h"

#include "qosextn_constants.h"

#include <networking/pfqos.h>

//

// TUmtsQoSParameters

//

//lint -e{1927} would like initializing in initializer list instead of in body.

EXPORT_C TUmtsQoSParameters::TUmtsQoSParameters()

	{

	iTrafficClass = ETrafficClassUnspecified;

	iDeliveryOrder = EDeliveryOrderUnspecified;

	iDeliveryOfErroneusSdu = EErroneousSDUDeliveryUnspecified;

	iResidualBer = EBERUnspecified;

	iErrorRatio = ESDUErrorRatioUnspecified;

	iPriority = ETrafficPriorityUnspecified;

	iTransferDelay = KTransferDelayUnspecified;

	iMaxSduSize = KMaxSDUUnspecified;

	iMaxBitrateUplink = KMaxBitRateUnspecified;

	iMaxBitrateDownlink = KMaxBitRateUnspecified;

	iGuaBitrateUplink = KGrtdBitRateUnspecified;

	iGuaBitrateDownlink = KGrtdBitRateUnspecified;

	}

EXPORT_C TUmtsTrafficClass TUmtsQoSParameters::TrafficClass() const

	{

	return iTrafficClass;

	}

EXPORT_C TUmtsDeliveryOrder TUmtsQoSParameters::DeliveryOrder() const

	{

	return iDeliveryOrder;

	}

EXPORT_C TUmtsErroneousSDUDelivery TUmtsQoSParameters::DeliveryOfErroneusSdu() const

	{

	return iDeliveryOfErroneusSdu;

	}

EXPORT_C TUmtsBitErrorRatio TUmtsQoSParameters::ResidualBer() const

	{

	return iResidualBer;

	}

EXPORT_C TUmtsSDUErrorRatio TUmtsQoSParameters::ErrorRatio() const

	{

	return iErrorRatio;

	}

EXPORT_C TUmtsTrafficHandlingPriority TUmtsQoSParameters::Priority() const

	{

	return iPriority;

	}

EXPORT_C TInt TUmtsQoSParameters::TransferDelay() const

	{

	return iTransferDelay;

	}

EXPORT_C TInt TUmtsQoSParameters::MaxSduSize() const

	{

	return iMaxSduSize;

	}

EXPORT_C TInt TUmtsQoSParameters::MaxBitrateUplink() const

	{

	return iMaxBitrateUplink;

	}

EXPORT_C TInt TUmtsQoSParameters::MaxBitrateDownlink() const

	{

	return iMaxBitrateDownlink;

	}

EXPORT_C TInt TUmtsQoSParameters::GuaranteedBitrateUplink() const

	{

	return iGuaBitrateUplink;

	}

EXPORT_C TInt TUmtsQoSParameters::GuaranteedBitrateDownlink() const

	{

	return iGuaBitrateDownlink;

	}

EXPORT_C TInt TUmtsQoSParameters::SetTrafficClass(TUmtsTrafficClass aTrafficClass)

	{

	iTrafficClass = aTrafficClass;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetDeliveryOrder(TUmtsDeliveryOrder aDeliveryOrder)

	{

	iDeliveryOrder = aDeliveryOrder;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetDeliveryOfErroneusSdu(TUmtsErroneousSDUDelivery aDeliveryOfErroneusSdu)

	{

	iDeliveryOfErroneusSdu = aDeliveryOfErroneusSdu;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetResidualBer(TUmtsBitErrorRatio aResidualBer)

	{

	iResidualBer = aResidualBer;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetErrorRatio(TUmtsSDUErrorRatio aErrorRatio)

	{

	iErrorRatio = aErrorRatio;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetPriority(TUmtsTrafficHandlingPriority aPriority)

	{

	iPriority = aPriority;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetTransferDelay(TUint aTransferDelay)

	{

	if (aTransferDelay > KTransferDelayMax)

		return KErrArgument;

	iTransferDelay = aTransferDelay;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetMaxSduSize(TUint aMaxSduSize)

	{

	if (aMaxSduSize > KMaxSDUMaximum)

		return KErrArgument;

	iMaxSduSize = aMaxSduSize;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetMaxBitrateUplink(TUint aMaxBitrateUplink)

	{

	if (aMaxBitrateUplink > KMaxBitRateMaximum)

		return KErrArgument;

	iMaxBitrateUplink = aMaxBitrateUplink;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetMaxBitrateDownlink(TUint aMaxBitrateDownlink)

	{

	if (aMaxBitrateDownlink > KMaxBitRateMaximum)

		return KErrArgument;

	iMaxBitrateDownlink = aMaxBitrateDownlink;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetGuaranteedBitrateUplink(TUint aGuaBitrateUplink)

	{

	if (aGuaBitrateUplink > KGrtdBitRateMaximum)

		return KErrArgument;

	iGuaBitrateUplink = aGuaBitrateUplink;

	return KErrNone;

	}

EXPORT_C TInt TUmtsQoSParameters::SetGuaranteedBitrateDownlink(TUint aGuaBitrateDownlink)

	{

	if (aGuaBitrateDownlink > KGrtdBitRateMaximum)

		return KErrArgument;

	iGuaBitrateDownlink = aGuaBitrateDownlink;

	return KErrNone;

	}

//

// TNegotiatedUmtsQoSParameters

//

EXPORT_C TNegotiatedUmtsQoSParameters::TNegotiatedUmtsQoSParameters() : iCompression(0), iErrorCode(KErrNone)

	{

	}

EXPORT_C TUint TNegotiatedUmtsQoSParameters::HeaderCompression() const

	{

	return iCompression;

	}

EXPORT_C TInt TNegotiatedUmtsQoSParameters::ErrorCode() const

	{

	return iErrorCode;

	}

// Buffer size

const TUint KUmtsApiBufSize = 8192;

//

// TUmtsQoSPolicy

//

EXPORT_C CUmtsQoSPolicy* CUmtsQoSPolicy::NewL()

	{

	CUmtsQoSPolicy* policy = new (ELeave) CUmtsQoSPolicy();

	CleanupStack::PushL(policy);

	policy->ConstructL();

	CleanupStack::Pop();

	return policy;

	}

CUmtsQoSPolicy::CUmtsQoSPolicy() : iBufPtr(0,0)

	{

	iType = KPfqosExtensionUmts;

	}

void CUmtsQoSPolicy::ConstructL()

	{

	iData = HBufC8::NewL(KUmtsApiBufSize);

	TPtr8 tmp(iData->Des());

	iBufPtr.Set(tmp);

	}

EXPORT_C CUmtsQoSPolicy::~CUmtsQoSPolicy()

	{

	delete iData;

	iData = 0;

	}

static void SetIntValue(pfqos_configblock_int& data, TInt aValue, const TDesC8& aName)

	{

	data.len = sizeof(pfqos_configblock_int)/8;

	data.padding = data.reserved = 0;

	data.type = KPfqosTypeInteger;

	data.value = aValue;

	Mem::FillZ(data.id, KPfqosMaxName);

	Mem::Copy(data.id, aName.Ptr(), aName.Length());

	}

EXPORT_C TDesC8& CUmtsQoSPolicy::Data()

	{

	iBufPtr.SetLength(0);

	const int byte_len = (sizeof(pfqos_configure)+sizeof(pfqos_extension)+sizeof(pfqos_configblock_int)*37);

	pfqos_configure iHeader;

	iHeader.pfqos_configure_len = (TUint16)((byte_len + 7) / 8);

	iHeader.pfqos_ext_type = EPfqosExtExtension;

	iHeader.reserved = 0;

	iHeader.protocol_id = 0;

	iBufPtr.Append((TUint8*)&iHeader, sizeof(pfqos_configure));

	pfqos_extension aExtensionType;

	aExtensionType.pfqos_ext_len = 0;

	aExtensionType.pfqos_ext_type = EPfqosExtExtension;

	aExtensionType.pfqos_extension_type = KPfqosExtensionUmts;

	iBufPtr.Append((TUint8*)&aExtensionType, sizeof(pfqos_extension));

	pfqos_configblock_int iExt;

	// Minimum

	SetIntValue(iExt, iMinimum.iTrafficClass, KDescTrafficClassMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iDeliveryOrder, KDescDeliveryOrderMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iDeliveryOfErroneusSdu, KDescDeliveryOfErroneusSduMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iResidualBer, KDescResidualBerMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iErrorRatio, KDescErrorRatioMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iPriority, KDescPriorityMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iTransferDelay, KDescTransferDelayMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iMaxSduSize, KDescMaxSduSizeMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iMaxBitrateUplink, KDescMaxBitrateUplinkMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iMaxBitrateDownlink, KDescMaxBitrateDownlinkMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iGuaBitrateUplink, KDescGuaBitrateUplinkMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iMinimum.iGuaBitrateDownlink, KDescGuaBitrateDownlinkMinimum);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	// Requested

	SetIntValue(iExt, iRequested.iTrafficClass, KDescTrafficClassRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iDeliveryOrder, KDescDeliveryOrderRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iDeliveryOfErroneusSdu, KDescDeliveryOfErroneusSduRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iResidualBer, KDescResidualBerRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iErrorRatio, KDescErrorRatioRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iPriority, KDescPriorityRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iTransferDelay, KDescTransferDelayRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iMaxSduSize, KDescMaxSduSizeRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iMaxBitrateUplink, KDescMaxBitrateUplinkRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iMaxBitrateDownlink, KDescMaxBitrateDownlinkRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iGuaBitrateUplink, KDescGuaBitrateUplinkRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iRequested.iGuaBitrateDownlink, KDescGuaBitrateDownlinkRequested);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	// Negotiated

	SetIntValue(iExt, iNegotiated.iTrafficClass, KDescTrafficClassNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iDeliveryOrder, KDescDeliveryOrderNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iDeliveryOfErroneusSdu, KDescDeliveryOfErroneusSduNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iResidualBer, KDescResidualBerNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iErrorRatio, KDescErrorRatioNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iPriority, KDescPriorityNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iTransferDelay, KDescTransferDelayNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iMaxSduSize, KDescMaxSduSizeNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iMaxBitrateUplink, KDescMaxBitrateUplinkNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iMaxBitrateDownlink, KDescMaxBitrateDownlinkNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iGuaBitrateUplink, KDescGuaBitrateUplinkNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iNegotiated.iGuaBitrateDownlink, KDescGuaBitrateDownlinkNegotiated);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	SetIntValue(iExt, iCompression, KDescHeaderCompression);

	iBufPtr.Append((TUint8*)&iExt, sizeof(pfqos_configblock_int));

	iBufPtr.AppendFill(0, iHeader.pfqos_configure_len * 8 - byte_len);

	return iBufPtr;

	}

EXPORT_C TInt CUmtsQoSPolicy::ParseMessage(const TDesC8& aData)

	{

	const TUint8 *p = aData.Ptr();

	TInt length = aData.Length();

	//lint --e{826} Not a suspicious conversion, as lint thinks (shut off all of them for this function)

	struct pfqos_configure *ext = (struct pfqos_configure *) p;

	if (length < (TInt)sizeof(pfqos_configure))

		return KErrGeneral;		// EMSGSIZE (impossible message size)

	if (ext->pfqos_configure_len * 8 != length)

		return KErrGeneral;		// EMSGSIZE (incorrect message length)

	if (ext->pfqos_ext_type == EPfqosExtExtension)

		{

		p += sizeof(struct pfqos_configure);

		pfqos_extension *aExtensionType = (pfqos_extension *) p;

		if (aExtensionType->pfqos_extension_type != KPfqosExtensionUmts)

			return KErrGeneral;

		while (length > 0)

			{

			struct pfqos_configblock *block = (struct pfqos_configblock *)(p + sizeof(pfqos_extension));

			int block_len = block->len;

			if (block_len < 1)

				break;

			block_len *= 8;

			if (block_len > length)

				break;

			if (block->type == KPfqosTypeInteger)

				{

				TPtrC8 tmp((TUint8 *)&block->id[0]);

				struct pfqos_configblock_int *block_int = (struct pfqos_configblock_int*) block;

				// Negotiated set

				//lint -e{961} would like terminating 'else' here...

				if (tmp.Compare(_L8("DeliveryOfErroneusSduNegotiated"))==0)

					{

					iNegotiated.iDeliveryOfErroneusSdu = (TUmtsErroneousSDUDelivery)block_int->value;

					}

				else if (tmp.Compare(_L8("DeliveryOrderNegotiated"))==0)

					{

					iNegotiated.iDeliveryOrder = (TUmtsDeliveryOrder)block_int->value;

					}

				else if (tmp.Compare(_L8("ErrorRatioNegotiated"))==0)

					{

					iNegotiated.iErrorRatio = (TUmtsSDUErrorRatio)block_int->value;

					}

				else if (tmp.Compare(_L8("GuaBitrateDownlinkNegotiated"))==0)

					{

					iNegotiated.iGuaBitrateDownlink = block_int->value;

					}

				else if (tmp.Compare(_L8("GuaBitrateUplinkNegotiated"))==0)

					{

					iNegotiated.iGuaBitrateUplink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxBitrateDownlinkNegotiated"))==0)

					{

					iNegotiated.iMaxBitrateDownlink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxBitrateUplinkNegotiated"))==0)

					{

					iNegotiated.iMaxBitrateUplink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxSduSizeNegotiated"))==0)

					{

					iNegotiated.iMaxSduSize = block_int->value;

					}

				else if (tmp.Compare(_L8("PriorityNegotiated"))==0)

					{

					iNegotiated.iPriority = (TUmtsTrafficHandlingPriority)block_int->value;

					}

				else if (tmp.Compare(_L8("ResidualBerNegotiated"))==0)

					{

					iNegotiated.iResidualBer = (TUmtsBitErrorRatio)block_int->value;

					}

				else if (tmp.Compare(_L8("TrafficClassNegotiated"))==0)

					{

					iNegotiated.iTrafficClass = (TUmtsTrafficClass)block_int->value;

					}

				else if (tmp.Compare(_L8("TransferDelayNegotiated"))==0)

					{

					iNegotiated.iTransferDelay = block_int->value;

					}

				// Minimum set

				else if (tmp.Compare(_L8("DeliveryOfErroneusSduMinimum"))==0)

					{

					iMinimum.iDeliveryOfErroneusSdu = (TUmtsErroneousSDUDelivery)block_int->value;

					}

				else if (tmp.Compare(_L8("DeliveryOrderMinimum"))==0)

					{

					iMinimum.iDeliveryOrder = (TUmtsDeliveryOrder)block_int->value;

					}

				else if (tmp.Compare(_L8("ErrorRatioMinimum"))==0)

					{

					iMinimum.iErrorRatio = (TUmtsSDUErrorRatio)block_int->value;

					}

				else if (tmp.Compare(_L8("GuaBitrateDownlinkMinimum"))==0)

					{

					iMinimum.iGuaBitrateDownlink = block_int->value;

					}

				else if (tmp.Compare(_L8("GuaBitrateUplinkMinimum"))==0)

					{

					iMinimum.iGuaBitrateUplink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxBitrateDownlinkMinimum"))==0)

					{

					iMinimum.iMaxBitrateDownlink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxBitrateUplinkMinimum"))==0)

					{

					iMinimum.iMaxBitrateUplink = block_int->value;

					}

				else if (tmp.Compare(_L8("MaxSduSizeMinimum"))==0)

					{

					iMinimum.iMaxSduSize = block_int->value;

					}

				else if (tmp.Compare(_L8("PriorityMinimum"))==0)

					{

					iMinimum.iPriority = (TUmtsTrafficHandlingPriority)block_int->value;

					}

				else if (tmp.Compare(_L8("ResidualBerMinimum"))==0)

					{

					iMinimum.iResidualBer = (TUmtsBitErrorRatio)block_int->value;

					}

				else if (tmp.Compare(_L8("TrafficClassMinimum"))==0)

					{

					iMinimum.iTrafficClass = (TUmtsTrafficClass)block_int->value;

					}

				else if (tmp.Compare(_L8("TransferDelayMinimum"))==0)

					{

					iMinimum.iTransferDelay = block_int->value;

					}