// Copyright (c) 1997-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:

// MBuf Packet Info Headers 

// 

//

/**

 @file

 @internalComponent

*/

#include <nifmbuf.h>

//

// MBuf Manager Extensions

//

__IMPLEMENT_CLEANUP(RMBufPacketBase, Free)

EXPORT_C RMBufPacketBase::RMBufPacketBase()

/**

Constructor

*/

    {

	iInfo=NULL;

	}

EXPORT_C void RMBufPacketBase::CopyInfoL(RMBufPacketBase& aNewPkt)

/**

Copy the information header

@param aNewPkt the new packet where the header is copied to

*/

	{

	aNewPkt.iInfo = (RMBufPktInfo*)iInfo->CopyL();

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::PeekInfo()

/**

Allows the packet info header to be accessed without unpacking

@return the packet info header

*/

	{

	__ASSERT_DEBUG(iInfo==NULL, MBufExtPanic(EMbExtPanic_PacketHeader));

	__ASSERT_ALWAYS(!IsEmpty(), MBufExtPanic(EMbExtPanic_PacketHeaderEmpty));

	__ASSERT_ALWAYS(First()->Type()==EMBufHeader, MBufExtPanic(EMbExtPanic_PacketHeader));

	return (RMBufPktInfo*)(First()->Ptr());

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::Unpack()

/**

Splits off the info header

@return the packet info header

*/

	{

	__ASSERT_DEBUG(iInfo==NULL, MBufExtPanic(EMbExtPanic_PacketHeader));

	__ASSERT_ALWAYS(!IsEmpty(), MBufExtPanic(EMbExtPanic_PacketHeaderEmpty));

	__ASSERT_ALWAYS(First()->Type()==EMBufHeader, MBufExtPanic(EMbExtPanic_PacketHeader));

	iInfo = (RMBufPktInfo*)(Remove()->Ptr());

	return Info();

	}

EXPORT_C void RMBufPacketBase::Pack()

/**

Combine info header with data ready for queueing

*/

	{

	__ASSERT_ALWAYS(iInfo!=NULL, MBufExtPanic(EMbExtPanic_PacketHeader));

	Prepend(iInfo->MBuf());

	iInfo = NULL;

	}

EXPORT_C void RMBufPacketBase::SetInfo(RMBufPktInfo* aInfo)

/**

Associate an info header with packet

(Also used to disassociate if aInfo==NULL)

@param aInfo the info header

*/

	{

	iInfo = aInfo;

	}

EXPORT_C void RMBufPacketBase::FreeInfo()

/**

Free info header only 

*/

	{

	if (iInfo)

		{

		iInfo->MBuf()->Free();

		iInfo = NULL;

		}

	}

EXPORT_C void RMBufPacketBase::Free()

/**

Delete info and data

*/

	{

	FreeInfo();

	RMBufChain::Free();

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::Info()

/**

Returns pointer to info header

@return the info header

*/

	{

	__ASSERT_ALWAYS(iInfo!=NULL, MBufExtPanic(EMbExtPanic_PacketHeader));

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateL(RMBufQ& aPacket, TInt aLength, TUint aMBufHdrSize)

/**

Create an MBuf chain from an received MBuf Queue

 - used by Interfaces

 - queue in emptied.

@param aPacket the MBuf Queue

@param aLength the chain length

@param aMBufHdrSize the MBuf header size

@return the info header

*/

	{

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	Assign(aPacket);

	iInfo->iLength = aLength==0 ? Length() : aLength;

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateL(TInt aLength, TUint aMBufHdrSize)

/**

Create an empty MBuf chain of required length and header size

 - used by Interfaces

 - refer RMBufChain::AllocL notes regarding the deliberate decision not to provide an overloaded min/max mbuf size variant

@param aLength the chain length

@param aMBufHdrSize the header size

@return the info header

*/

	{

	RMBufChain::AllocL(aLength);	

	CleanupStack::PushL(*this);

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	CleanupStack::Pop();

	iInfo->iLength = aLength;

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateL(const TDesC8 &aDesc, TInt aHdrSize, TUint aMBufHdrSize)

/**

Create a MBuf chain and header for receiving from a descriptor

 - used by SAPs

@param aDesc the buffer which contains the header info

@param aHdrSize the header size 

@param aMBufHdrSize the MBuf header size

@return the info header

*/

	{

	RMBufChain::CreateL(aDesc, aHdrSize);

	CleanupStack::PushL(*this);

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	CleanupStack::Pop();

	iInfo->iLength = aDesc.Length()+aHdrSize;

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateCopyL(const RMBufQ& aPacket, TInt aOffset, TInt aLength, TInt aHdrSize, TUint aMBufHdrSize)

/**

Create a MBuf chain from an received MBuf Queue

 - used by Interfaces

@param aPacket the MBuf Queue

@param aOffset the offset 

@param aLength the length of the data to be copied

@param aHdrSize the header size

@param aMBufHdrSize the MBuf Header Size

@return the info header

*/

	{

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	iInfo->iLength = (aLength==0 ? Length() : aLength) + aHdrSize;

	((RMBufChain&)aPacket).CopyL(*this, aOffset, aLength);

	PrependL(aHdrSize);

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateCopyL(RMBufStreamQ& aStream, TInt aOffset, TInt aLength, TInt aHdrSize, TUint aMBufHdrSize)

/**

Create a MBuf chain by copying data from a stream queue (basically an RMBufQ)

aOffset and aLength specify location in stream queue.

@param aStream the stream queue

@param aOffset the offset

@param aLength the data length

@param aHdrSize the header size

@param aMBufHdrSize the MBuf Header size

@return the info header

*/

	{

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	iInfo->iLength = (aLength==0 ? Length() : aLength) + aHdrSize;

	aStream.CopySegmentL(*this, aOffset, aLength);

	PrependL(aHdrSize);

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::CreateCopyL(const RMBufPktQ& aList, TInt aHdrSize, TUint aMBufHdrSize)

/**

Build a MBuf chain by copying a packet queue list, leaving space on the front

for a header. (Very heavily used in PPP option processing).

This is specially coded rather than using combination of RMBufChain::CopyL

and RMBufChain::AppendL to ensure that the resulting packet is stored efficiently.

- refer RMBufChain::AllocL notes regarding the deliberate decision not to provide an overloaded min/max mbuf size variant

@param aList the packet queue

@param aHdrSize the header size

@param aMBufHdrSize the MBuf Header size

@return the info header

*/

	{

	// min K_MBufSmallSize sized mbuf is a valid assumption, because all headers are assumed to derive from a cell, which in turn is size K_MBufSmallSize

	__ASSERT_ALWAYS(aHdrSize<KMBufSmallSize, MBufExtPanic(EMbExtPanic_HeaderTooBig));

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	RMBufChain i;

	// Get total length of chain needed

	TInt len = 0;

	i = aList.First();

	while (!i.IsEmpty())

		{

		len += i.Length();

		i = i.Next();

		}

	// Allocate the chain

	iInfo->iLength = len+aHdrSize;

	AllocL(iInfo->iLength);

	// Do the copy

	TInt n, n1, n2;

	TUint8* p1, * p2;

	RMBuf* m1, * m2;

	i = aList.First();

	m1 = i.First();

	p1 = m1->Ptr();

	n1 = m1->Length();

	m2 = First();

	p2 = m2->Ptr();

	n2 = m2->Length();

	if (aHdrSize>0)

		{

		if (aHdrSize==KMBufSmallSize) // min K_MBufSmallSize sized mbuf is a valid assumption, because all headers are assumed to derive from a cell, which in turn is size K_MBufSmallSize

			{

			m2 = m2->Next();

			p2 = m2->Ptr();

			n2 = m2->Length();

			}

		else

			{

			p2 += aHdrSize;		

			n2 -= aHdrSize;

			}

		}

	while (len>0)

		{

		n = n1<n2 ? n1 : n2;

		Mem::Copy(p2, p1, n);

		if (n1 -= n, n1==0)

			{

			if (m1 = m1->Next(), m1==NULL)

				{

				i = i.Next();

				m1 = i.First();

				}

			p1 = m1->Ptr();

			n1 = m1->Length();

			}

		else

			p1 += n;

		if (n2 -= n, n2==0)

			{

			m2 = m2->Next();

			p2 = m2->Ptr();

			n2 = m2->Length();

			}

		else

			p2 += n;

		len -= n;

		}

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C void RMBufPacketBase::TrimStart(TInt aOffset)

/**

As RMBufChain::TrimStart, but updates length in info header

@param aOffset the offset 

*/

	{

	RMBufChain::TrimStart(aOffset);

	iInfo->iLength -= aOffset;

	}

EXPORT_C void RMBufPacketBase::TrimEnd(TInt aOffset)

/**

As RMBufChain::TrimEnd, but updates length in info header

@param aOffset the offset

*/

	{

// !BUG! Work around

	if (aOffset==0)

		RMBufChain::Free();

	else

// End work-around

	RMBufChain::TrimEnd(aOffset);

	iInfo->iLength = aOffset;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::NewInfoL(TUint aMBufHdrSize)

/**

Create an info header 

@param aMBufHdrSize the MBuf header size

@return the info header

*/

	{

	iInfo = new (ELeave, aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::NewInfo(TUint aMBufHdrSize)

/**

Create an info header 

@param aMBufHdrSize the MBuf header size

@return the info header

*/

	{

	iInfo = new (aMBufHdrSize-sizeof(RMBufPktInfo)) RMBufPktInfo;

	return (RMBufPktInfo*)iInfo;

	}

EXPORT_C void RMBufPacketBase::CopyPackedL(RMBufChain& aPacket)

/**

Copy an entire packed packet, complete with info header

@param aPacket the packet

*/

	{

	__ASSERT_DEBUG(iInfo==NULL, MBufExtPanic(EMbExtPanic_PacketHeader));

	__ASSERT_ALWAYS(!aPacket.IsEmpty(), MBufExtPanic(EMbExtPanic_PacketHeaderEmpty));

	__ASSERT_ALWAYS(aPacket.First()->Type()==EMBufHeader, MBufExtPanic(EMbExtPanic_PacketHeader));

	RMBuf* m = aPacket.Remove();

	//

	// The following assumes that aPacket.CopyL would actually leave before it makes any change 

	// to aPacket at all. Inspection of CopyL reveals that this is the case.

	//		

	TRAPD(err, aPacket.CopyL(*this));

	//

	// In case CopyL failed, we'd need to restore aPacket, so we'd call Prepend.

	// In case it succedded, we'd still need to call Prepend so that the info block remains the same.

	// Hence we call aPacket.Prepend irrespective of aPacket.CopyL failure.

	//

	aPacket.Prepend(m);

	User::LeaveIfError(err);

	RMBufPktInfo* info = (RMBufPktInfo*)((RMBufPktInfo*)(m->Ptr()))->CopyL();

	Prepend(info->MBuf());

	}

EXPORT_C RMBufPktInfo* RMBufPacketBase::PeekInfoInChain(RMBufChain& aChain)

/**

Allows the packet info header to be accessed while still on a packet queue

@param aChain the chain to be accessed

@return the info header

*/

	{

	__ASSERT_ALWAYS(!aChain.IsEmpty(), MBufExtPanic(EMbExtPanic_PacketHeaderEmpty));

	__ASSERT_ALWAYS(aChain.First()->Type()==EMBufHeader, MBufExtPanic(EMbExtPanic_PacketHeader));

	return (RMBufPktInfo*)(aChain.First()->Ptr());

	}

void MBufExtPanic(TMBufExtPanic aPanic)

/**

extra panic function that causes panic

@param panic code

*/

 	{

	_LIT(mBufExtString,"MBufExt");

	User::Panic(mBufExtString, aPanic);

	}