// Copyright (c) 2004-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 <bluetooth/logger.h>

#include "btsockettimer.h"

#include "L2CapSDU.h"

#include "L2CapPDU.h"

#include "l2util.h"

#include "L2CapDebugControlInterface.h"

#ifdef _DEBUG

#include "L2CapDebugControlInterface.h"

#endif

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP_SDU);

#endif

CL2CapSDU* CL2CapSDU::NewLC(RMBufChain& aSDUData,

                            ML2CapSDUHandler& aParent,

			                TUint16 aPDUSize,

                            TBool aIsBasicDataVersion,

			                TUint16 aTimerDuration)

	{

	LOG_STATIC_FUNC

	CL2CapSDU* self = new(ELeave) CL2CapSDU(aParent);

	CleanupStack::PushL(self);

	self->ConstructL(aSDUData, aIsBasicDataVersion, aTimerDuration, aPDUSize);

	return self;

	}

CL2CapSDU* CL2CapSDU::NewL(RMBufChain& aSDUData,

		                   ML2CapSDUHandler& aParent,

			               TUint16 aPDUSize,

		                   TBool aIsBasicDataVersion, 

			               TUint16 aTimerDuration)

	{

	LOG_STATIC_FUNC

	CL2CapSDU* self = NewLC(aSDUData, aParent, aPDUSize, aIsBasicDataVersion, aTimerDuration);

	CleanupStack::Pop();

	return self;

	}

CL2CapSDU::CL2CapSDU(ML2CapSDUHandler& aParent)

 : iParent(aParent),

   iPDUs(_FOFF(HL2CapPDU, iLink)),

   iCurrentPDU(iPDUs)

	{

	LOG_FUNC

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::ESDU,

	                             L2capDebugInfo::EAllocated));

	}

void CL2CapSDU::ConstructL(RMBufChain& aSDUData, TBool aIsBasicDataVersion, TUint16 aTimerDuration, TUint16 aPDUSize)

	{

	LOG_FUNC

	LEAVEIFERRORL(SegmentSDUIntoPDUs(aSDUData, aIsBasicDataVersion, aPDUSize));

	// Start the flush timer if required.

	StartFlushTimer(aTimerDuration);

	}

CL2CapSDU::~CL2CapSDU()

	{

	LOG_FUNC

	iLink.Deque();

	iCurrentPDU.SetToFirst();

	HL2CapPDU* pduPtr;

	while(iCurrentPDU)

		{

		pduPtr = iCurrentPDU++;

		pduPtr->iLink.Deque();

		delete pduPtr;

		}

	if(iFlushTimerRunning)

		{

		BTSocketTimer::Remove(iFlushTimerEntry);

		}	

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::ESDU,

	                             L2capDebugInfo::EDeleted));

	}

/*

 * Function to return any additional SDU L2CAP overhead. This is in addition to any PDU

 * overhead as defined by HL2CapPDU::GetPDUOverhead.

 */

/*static*/ TInt CL2CapSDU::GetSDUOverhead(TBool aBasicMode)

	{

	LOG_STATIC_FUNC

	if (aBasicMode)

		{

		return HL2CapPDU::KPDUHeaderLength;

		}

	// Non-basic mode overhead

	return HL2CapPDU::KSDULengthFieldLength;

	}

TInt CL2CapSDU::SegmentSDUIntoPDUs(RMBufChain& aSDUData, TBool aIsBasicDataVersion, TUint16 aPDUPayloadSize)

	{

	LOG_FUNC

	TInt sduLength = aSDUData.Length();

	TInt rerr = KErrNone;

	if(aIsBasicDataVersion)

		{

		// This is basic mode.  The entire SDU should be placed into

		// a B-Frame PDU.

		HBFramePDU* pdu = HBFramePDU::New(aSDUData, aPDUPayloadSize);

		if(pdu)

			{

			iPDUs.AddLast(*pdu);

			L2CAP_DEBUG_PDU(PDUTimer(L2capDebugInfo::EBFrameCreated, pdu));

			}

		else

			{

			rerr = KErrNoMemory;

			}

		}

	else

		{

		// Check if the SDU needs to be segmented.

		if(aPDUPayloadSize >= sduLength)

			{

			HIFramePDU* pdu = HIFramePDU::New(aSDUData, EUnsegmentedL2CapSDU);

			if(pdu)

				{

				iPDUs.AddLast(*pdu);

				L2CAP_DEBUG_PDU(PDUTimer(L2capDebugInfo::EUnsegmentedFrameCreated, pdu));

				}

			else

				{

				rerr = KErrNoMemory;

				}				

			}

		else

			{

			// Work backwards through the SDU segmenting it into PDU's. The first segment will always

			// contain an extra SDU length field so this is taken into account when working out the 

			// size of the last segment below.

			TInt sduPosition = sduLength - ((sduLength + HL2CapPDU::KSDULengthFieldLength) % aPDUPayloadSize);

			// If the PDU size is a factor of the SDU length then start from the

			// SDU length - PDU size.

			if(sduPosition == sduLength)

				{

				sduPosition -= aPDUPayloadSize;

				}

			HIFramePDU* pdu = NULL;

			RMBufChain pduData;

			TRAP(rerr, aSDUData.SplitL(sduPosition, pduData));

			if(rerr == KErrNone)

				{

				pdu = HIFramePDU::New(pduData, EEndOfL2CapSDU);

				if(pdu)

					{

					sduPosition -= aPDUPayloadSize;

					iPDUs.AddFirst(*pdu);

					L2CAP_DEBUG_PDU(PDUTimer(L2capDebugInfo::EIFrameCreated, pdu));

					while(sduPosition > 0)

						{

						__ASSERT_DEBUG(sduPosition >= 0, Panic(EL2CAPSDUPositionNegativeDuringSegmentation));

						TRAP(rerr, aSDUData.SplitL(sduPosition, pduData));

						if(rerr == KErrNone)

							{

							pdu = HIFramePDU::New(pduData, EContinuationOfL2CapSDU);

							if(pdu)

								{

								sduPosition -= aPDUPayloadSize;

								iPDUs.AddFirst(*pdu);

								}

							else

								{

								rerr = KErrNoMemory;

								break;

								}

							}

						else

							{

							break;

							}							

						}

					if(rerr == KErrNone)

						{

						// Create and add the first PDU.

						pdu = HIFramePDU::New(aSDUData, EStartOfL2CapSDU);

						if(pdu)

							{

							pdu->SetSDUSize(static_cast<TUint16>(sduLength));

							iPDUs.AddFirst(*pdu);

							}

						else

							{

							rerr = KErrNoMemory;

							}

						}

					}

				else

					{

					rerr = KErrNoMemory;

					}				

				}

			}

		}

	if(rerr == KErrNone)

		{

		// Set the current PDU pointer to the first PDU.

		iCurrentPDU.SetToFirst();	

		}

	return rerr;

	}

TBool CL2CapSDU::GetPDU(HL2CapPDU*& aReturnedPDU)

	{

	LOG_FUNC

	TBool isLastPDU = EFalse;

	if(!iPDUs.IsEmpty())

		{

		aReturnedPDU = iCurrentPDU++;

		// TODO: this was put in as a fix and is in needed in general, but it also

		// actually hoses up some logic, i.e. CurrentPDUIsFirstPDU will always return

		// true. We either need a separate link for the list of PDUs inside the SDU,

		// or if possible just get rid of iCurrentPDU and have a iFirstPDU flag

		// set to one during initial segmentation.

		// Note - we the iCurrentPDU/iFirstPDU business is actually only used in two cases:

		// 1. to repack current SDU when PDU size has changed on a live connection - currently

		//    unused and unnecessary.

		// 2. on flush timer expiry, to mark already sent packets as flushed and purge the

		//    unsent ones - currently unused, but may get implemented in the future. However

		//    the marking of the packets may be done their current owner, which is a data

		//    controller or the muxer, so again this is unnecessary.

		// Conclusion: refactor to simplify.

		aReturnedPDU->iLink.Deque();

		if(iCurrentPDU == NULL)

			{

			// At the end of the PDU list.

			L2CAP_DEBUG_PDU(PDUTimer(L2capDebugInfo::EGetPDUCalled, aReturnedPDU));

			isLastPDU = ETrue;

			}

		}

	return isLastPDU;

	}

/*static*/ TInt CL2CapSDU::FlushTimerExpired(TAny* aL2CapSDU)

	{

	LOG_STATIC_FUNC

	CL2CapSDU* sdu = reinterpret_cast<CL2CapSDU*>(aL2CapSDU);

	sdu->HandleFlushTimerExpired();

	return EFalse;

	}

void CL2CapSDU::HandleFlushTimerExpired()

	{

	LOG_FUNC

	// Note that the timer is no longer running.

	iFlushTimerRunning = EFalse;

	// Any PDU's that have already been sent need to be

	// informed of the flush.

	TDblQueIter<HL2CapPDU> pduIter(iPDUs);

	TBool done = EFalse;

	HL2CapPDU* pduPtr;

	while((pduPtr = pduIter++) != NULL  && !done)

		{

		if(pduPtr == iCurrentPDU)

			{

			done = ETrue;

			}

		else

			{

			pduPtr->SetPDUFlushed();

			}

		}

	// The remaining PDU's (if any) that have not yet

	// been sent can be deleted. 

	while((pduPtr = iCurrentPDU++) != NULL)

		{

		pduPtr->iLink.Deque();

		delete pduPtr;

		}

	// Inform the SDU queue.

	iParent.ProcessFlushTimerExpiry(*this);

	}

TBool CL2CapSDU::IsSDUEmpty() const

	{

	LOG_FUNC

	return iPDUs.IsEmpty();

	}

TBool CL2CapSDU::CurrentPDUIsFirstPDU()

	{

	LOG_FUNC

	return iPDUs.IsFirst(iCurrentPDU);

	}

void CL2CapSDU::StartFlushTimer(TUint16 aTimerDuration)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iFlushTimerRunning, Panic(EL2CAPAttemptToRestartFlushTimer));

	// Only start the timer if the duration is valid.

	if(aTimerDuration >= TL2CapConfig::EMinDataObsolescenceTimeout && 

	   aTimerDuration != KInfiniteFlush)

		{

		TCallBack cb(FlushTimerExpired, this);

		iFlushTimerEntry.Set(cb);

		// Timer period is a factor of the duration parameter and 0.625ms

		BTSocketTimer::Queue(aTimerDuration*625, iFlushTimerEntry);

		iFlushTimerRunning = ETrue;

		}

	}

TInt CL2CapSDU::ChangeSDUSegmentation(TBool aIsBasicDataVersion, TUint16 aPDUSize)

	{

	LOG_FUNC

	__ASSERT_DEBUG(CurrentPDUIsFirstPDU(), Panic(EL2CAPAttemptToChangeSegmentationForPartiallySentSDU));

	TInt rerr = KErrNone;

	RMBufChain sduData;

	// Get the current SDU data, and delete all current

	// PDU's

	TDblQueIter<HL2CapPDU> iter(iPDUs);

	HL2CapPDU* pduPtr;

	while((pduPtr = iter++) != NULL)

		{

		pduPtr->AppendPayloadToBuffer(sduData);

		pduPtr->iLink.Deque();

		delete pduPtr;

		}

	rerr = SegmentSDUIntoPDUs(sduData, aIsBasicDataVersion, aPDUSize);

	return rerr;

	}

#ifdef _DEBUG

TInt CL2CapSDU::DebugManualFlush()

	{

	LOG_FUNC

	TInt rcode = -1;

	if(!IsSDUEmpty())

		{

		RMBuf* buf = iPDUs.First()->PDUBuffer().First();

		if(buf->Length() > 8)

			{

			rcode = buf->Get(8);

			}

		else

			{

			buf = buf->Next();

			if(buf)

				{

				rcode = buf->Get(0);

				}

			}

		}

	if(iFlushTimerRunning)

		{

		BTSocketTimer::Remove(iFlushTimerEntry);

		}

	HandleFlushTimerExpired();

	return rcode;

	}

#endif