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

//

#include "pfqoslib.h"

#include "pfqosparser.h"

#include "pfqosliblog.h"

//

// DLL entry point

//

GLDEF_C TInt E32Dll()

	{

	return(KErrNone);

	}

EXPORT_C T_pfqos_msg::T_pfqos_msg(TUint8 aMsgType, TUint32 aSeq)

	{

	pfqos_msg_version = KPfqosMsgV1;

	pfqos_msg_type = aMsgType;

	pfqos_msg_errno = 0;

	pfqos_msg_options = 0;

	pfqos_msg_len = ((sizeof(*this) + 7) / 8);

	pfqos_msg_reserved = 0;

	pfqos_msg_seq = aSeq;

	pfqos_msg_pid = 0;

	}

EXPORT_C T_pfqos_selector::T_pfqos_selector(CSelectorBase* aSelector)

	{

	pfqos_selector_len = ((sizeof(*this) + 7) / 8);

	pfqos_ext_type = EPfqosExtSelector;

	protocol = aSelector->iProtocol;

	uid1 = aSelector->iUid.UidType()[0].iUid;

	uid2 = aSelector->iUid.UidType()[1].iUid;

	uid3 = aSelector->iUid.UidType()[2].iUid;

	iap_id = aSelector->iIapId;

	policy_type = aSelector->iType;

	priority = aSelector->iPriority;

	reserved = 0;

	TPtr8 ptr((TUint8*)name, 0, KMaxName);

	if (ptr.MaxLength() >= aSelector->iName.Length())

		{

		ptr.Copy(aSelector->iName);

		}

	ptr.ZeroTerminate();

	}

EXPORT_C T_pfqos_address::T_pfqos_address(TUint aType, TUint16 aPortMax)

	{

	pfqos_address_len = ((sizeof(*this) + sizeof(TInetAddr) + 

						  sizeof(TInetAddr) + 7) / 8);

	pfqos_ext_type = (TUint8)aType;

	reserved = 0;

	pfqos_port_max = aPortMax;

	}

EXPORT_C T_pfqos_module::T_pfqos_module(TUint aProtocolId, TUint32 aFlags, 

					const TDesC& aName, const TDesC& aPath, TInt aDataLen)

	{

	pfqos_modulespec_len = (TUint16)((sizeof(*this) + aDataLen + 7) / 8);

	pfqos_ext_type = EPfqosExtModulespec;

	protocol_id = aProtocolId;

	flags = aFlags;

	TPtr8 namePtr((TUint8*)name, 0, KMaxName);

	if (namePtr.MaxLength() >= aName.Length())

		{

		namePtr.Copy(aName);

		}

	namePtr.ZeroTerminate();

	TPtr8 pathPtr((TUint8*)path, 0, KMaxFileName);

	if (pathPtr.MaxLength() >= aPath.Length())

		{

		pathPtr.Copy(aPath);

		}

	pathPtr.ZeroTerminate();

	reserved = 0;

	}

//lint -e{1928}

EXPORT_C T_pfqos_flowspec::T_pfqos_flowspec(const TQoSParameters& aParameters)

	{

	pfqos_flowspec_len = ((sizeof(*this) + 7) / 8);

	pfqos_ext_type = EPfqosExtFlowspec;

	uplink_bandwidth = aParameters.GetUplinkBandwidth();

	uplink_maximum_burst_size = aParameters.GetUpLinkMaximumBurstSize();

	uplink_maximum_packet_size = aParameters.GetUpLinkMaximumPacketSize();

	uplink_average_packet_size = aParameters.GetUpLinkAveragePacketSize();

	uplink_delay = aParameters.GetUpLinkDelay();

	uplink_priority = static_cast< TUint16 >(aParameters.GetUpLinkPriority());

	downlink_bandwidth = aParameters.GetDownlinkBandwidth();

	downlink_maximum_burst_size = aParameters.GetDownLinkMaximumBurstSize();

	downlink_maximum_packet_size = aParameters.GetDownLinkMaximumPacketSize();

	downlink_average_packet_size = aParameters.GetDownLinkAveragePacketSize();

	downlink_delay = aParameters.GetDownLinkDelay();

	downlink_priority = static_cast< TUint16 >(aParameters.GetDownLinkPriority());

	// name

	name.FillZ();

	if (name.MaxLength() >= aParameters.GetName().Length())

		{

		name.Copy(aParameters.GetName());

		}

	name.ZeroTerminate();

	flags = aParameters.Flags();

	reserved = 0;

	LOG(Log::Printf(_L("1 pfqos_flowspec_len -- [%d]"),pfqos_flowspec_len));

	}

EXPORT_C T_pfqos_event::T_pfqos_event(TUint8 aType, TUint16 aEventType, 

									  TUint16 aValue)

	{

	pfqos_event_len = ((sizeof(*this) + 7) / 8);

	pfqos_ext_type = aType;

	event_type = aEventType;

	event_value = aValue;

	}

EXPORT_C T_pfqos_channel::T_pfqos_channel(TUint32 aChannelId)

	{

	pfqos_channel_len = ((sizeof(*this) + 7) / 8);

	pfqos_ext_type = EPfqosExtChannel;

	channel_id= aChannelId;

	};

EXPORT_C T_pfqos_configure::T_pfqos_configure(TUint16 aProtocolId)

	{

	pfqos_configure_len = ((sizeof(*this) + 7) / 8);

	pfqos_ext_type = EPfqosExtConfigure;

	protocol_id = aProtocolId;

	reserved = 0;

	}

//

// Internal representation of PfqosMessage

//

EXPORT_C TPfqosBase::TPfqosBase() : iMsg(0)

	{

	}

EXPORT_C TUint TPfqosBase::Length() const

	{

	return iMsg ? sizeof(*iMsg) : 0;

	}

EXPORT_C TInt TPfqosBase::ByteStream(RMBufChain &aPacket, TInt aTotal) const

	{

	if (iMsg)

		{

		struct pfqos_msg base = *iMsg;

		base.pfqos_msg_len = (TUint16)(aTotal / 8);

		aPacket.CopyIn(TPtrC8((TUint8 *)&base, sizeof(base)), 0);

		return Length();

		}

	else

		{

		return 0;

		}

	}

EXPORT_C TPfqosSelector::TPfqosSelector() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosSelector::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosSelector::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TInt TPfqosSelector::GetUid(TCheckedUid& aUid)

	{

	if (!iExt)

		{

		return KErrNotReady;

		}

	TUidType uid_type(TUid::Uid(iExt->uid1), TUid::Uid(iExt->uid2), 

					  TUid::Uid(iExt->uid3));

	aUid.Set(uid_type);

	return KErrNone;

	};

EXPORT_C TPfqosAddress::TPfqosAddress() : iExt(0), iAddr(0), iPrefix(0)

	{

	}

EXPORT_C TUint TPfqosAddress::Length() const

	{

	return iExt ? ((sizeof(*iExt) + sizeof(TInetAddr) + 

		sizeof(TInetAddr) + 7) / 8) * 8 : 0;

	}

EXPORT_C TInt TPfqosAddress::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt && iAddr && iPrefix)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aPacket.CopyIn(TPtrC8((TUint8 *)iAddr, sizeof(*iAddr)), aOffset + 

			sizeof(*iExt));

		aPacket.CopyIn(TPtrC8((TUint8 *)iPrefix, sizeof(*iPrefix)), aOffset + 

			sizeof(*iExt) + sizeof(*iAddr));

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosModule::TPfqosModule() : iExt(0), iData(0,0)

	{

	}

EXPORT_C TUint TPfqosModule::Length() const

	{

	return iExt ? (sizeof(*iExt)+iData.Length()) : iData.Length();

	}

EXPORT_C TInt TPfqosModule::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += sizeof(*iExt);

		}

	if (iData.Length() > 0)

		{

		aPacket.CopyIn(iData, aOffset);

		aOffset += iData.Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosFlowSpec::TPfqosFlowSpec() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosFlowSpec::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosFlowSpec::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosEvent::TPfqosEvent() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosEvent::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosEvent::ByteStream(RMBufChain &aPacket, TInt aOffset) const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosChannel::TPfqosChannel() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosChannel::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosChannel::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosConfigure::TPfqosConfigure() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosConfigure::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosConfigure::ByteStream(RMBufChain &aPacket, TInt aOffset) 

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosConfigFile::TPfqosConfigFile() : iExt(0)

	{

	}

EXPORT_C TUint TPfqosConfigFile::Length() const

	{

	return iExt ? sizeof(*iExt) : 0;

	}

EXPORT_C TInt TPfqosConfigFile::ByteStream(RMBufChain &aPacket, TInt aOffset)

	const

	{

	if (iExt)

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iExt, sizeof(*iExt)), aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C CPfqosPolicyData::CPfqosPolicyData(TInt aType) : iBufPtr(0,0)

	{

	iType = aType;

	iBuf = NULL;

	}

EXPORT_C CPfqosPolicyData::~CPfqosPolicyData()

	{

	delete iBuf;

	}

EXPORT_C void CPfqosPolicyData::ConstructL()

	{

	}

EXPORT_C CPfqosPolicyData* CPfqosPolicyData::NewL(TInt aType)

	{

	CPfqosPolicyData* pfqosPolicyData = new (ELeave) CPfqosPolicyData(aType);

	CleanupStack::PushL(pfqosPolicyData);

	pfqosPolicyData->ConstructL();

	CleanupStack::Pop();

	return pfqosPolicyData;

	}

EXPORT_C CPfqosPolicyData* CPfqosPolicyData::NewL(TInt aType, 

	const TUint8 *aBuf,TInt aLength)

	{

	CPfqosPolicyData* pfqosPolicyData = new (ELeave) CPfqosPolicyData(aType);

	CleanupStack::PushL(pfqosPolicyData);

	pfqosPolicyData->ConstructL();

	pfqosPolicyData->CopyL(aBuf, aLength);

	CleanupStack::Pop();

	return pfqosPolicyData;

	}

EXPORT_C TUint CPfqosPolicyData::Length() const

	{

	return iBufPtr.Length();

	}

EXPORT_C TInt CPfqosPolicyData::Size() const

	{

	return iBufPtr.MaxLength();

	}

EXPORT_C void CPfqosPolicyData::CopyL(const TUint8 *aBuf,TInt aLength)

	{

	if (iBuf)

		{

		delete iBuf;

		iBuf=NULL;

		}

	iBuf = HBufC8::NewL(aLength);

	TPtr8 tmp(iBuf->Des());

	iBufPtr.Set(tmp);

	iBufPtr.Copy(aBuf, aLength);

	}

EXPORT_C TDesC8& CPfqosPolicyData::Data()

	{

	return iBufPtr;

	}

EXPORT_C TInt CPfqosPolicyData::Type()

	{

	return iType;

	}

EXPORT_C TInt CPfqosPolicyData::ByteStream(RMBufChain &aPacket, TInt aOffset)

	const

	{

	if (iBufPtr.Length())

		{

		aPacket.CopyIn(TPtrC8((TUint8 *)iBufPtr.Ptr(), iBufPtr.Length()), 

			aOffset);

		aOffset += Length();

		}

	return aOffset;

	}

EXPORT_C TPfqosMessage::TPfqosMessage() 

	: iError(0),

	  iNumModules(0),

	  iModuleList(_FOFF(TPfqosModule, iNext)),

	  iNumExtensions(0), 

	  iExtensions(_FOFF(CPfqosPolicyData, iNext))

	{

	}

EXPORT_C void TPfqosMessage::Add(TPfqosModule& aModule)

	{

	iNumModules++;

	iModuleList.AddLast(aModule);

	}

EXPORT_C void TPfqosMessage::AddExtension(CPfqosPolicyData& aExtension)

	{

	iNumExtensions++;

	iExtensions.AddLast(aExtension);

	}

//

// Internal representation of PF_QOS message.

//

EXPORT_C TPfqosMessage::TPfqosMessage(const TDesC8& aMsg)

	: iError(KErrArgument),

	  iNumModules(0),

	  iModuleList(_FOFF(TPfqosModule, iNext)),

	  iNumExtensions(0),

	  iExtensions(_FOFF(CPfqosPolicyData, iNext))

	{

	const TUint8 *p = aMsg.Ptr();

	TInt length = aMsg.Length();

	if (length < (TInt)sizeof(pfqos_msg))

		{

		LOG(Log::Printf(_L("length < (TInt)sizeof(pfqos_msg) -- [%d,%d]"),

			length,(TInt)sizeof(pfqos_msg)));

		return;		// EMSGSIZE (impossible message size)

		}

	//

	// Base Message Header

	//lint -e{826}	Typecast below is ok.

	iBase.iMsg = (struct pfqos_msg *)p;

	if (iBase.iMsg->pfqos_msg_version != KPfqosMsgV1)

		{

		LOG(Log::Printf(_L("iBase.iMsg->pfqos_msg_version != KPfqosMsgV1 -- [%d,%d]"),

			iBase.iMsg->pfqos_msg_version,KPfqosMsgV1));

		return;		// EINVAL

		}

	if (iBase.iMsg->pfqos_msg_len * 8 != length)

		{

		LOG(Log::Printf(_L("iBase.iMsg->pfqos_msg_len * 8 != length -- [%d,%d]"),

			iBase.iMsg->pfqos_msg_len * 8,length));

		return;		// EMSGSIZE (incorrect message length)

		}

	if (iBase.iMsg->pfqos_msg_reserved)

		{

		LOG(Log::Printf(_L("iBase.iMsg->pfqos_msg_reserved -- [%d]"),

			iBase.iMsg->pfqos_msg_reserved));

		return;		// EINVAL (unused parts must be zeroed)

		}

	p += sizeof(struct pfqos_msg);

	length -= sizeof(struct pfqos_msg);