// 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 <es_prot.h>

#include <bluetooth/hci/aclpacketconsts.h>

#include "L2CapPDU.h"

#include "l2capCommand.h"

#include "l2signalmgr.h"

#include "L2CapDataController.h"

#include "L2CapSDU.h"

#include "L2CapDebugControlInterface.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP_PDU);

#endif

TDataPlaneElementHandle::TDataPlaneElementHandle(MDataPlaneElement* aDataElement, TUint16 aElementID)

	{

	LOG_FUNC

	SetUserLen(sizeof(SDataPlaneElementHandle));

	SDataPlaneElementHandle* handlePtr = reinterpret_cast<SDataPlaneElementHandle*>(UserPtr());

	handlePtr->iDataElement = aDataElement;

	handlePtr->iElementID = aElementID;

	}

MDataPlaneElement& TDataPlaneElementHandle::DataPlaneElement() const

	{

	LOG_FUNC

	SDataPlaneElementHandle* handlePtr = reinterpret_cast<SDataPlaneElementHandle*>(UserPtr());

	return *(handlePtr->iDataElement);

	}

TUint16 TDataPlaneElementHandle::ElementID() const

	{

	LOG_FUNC

	SDataPlaneElementHandle* handlePtr = reinterpret_cast<SDataPlaneElementHandle*>(UserPtr());

	return (handlePtr->iElementID);

	}

//

// Base class for all PDU types.

//

// Disable warning WINS 4355: 'this' : used in base member initializer list

// This will not cause any problems in this usage and is preferable to the use of a

// non-owned pointer.

#pragma warning (disable: 4355)

HL2CapPDU::HL2CapPDU(RMBufChain& aPDUData, TInt aOptimalFragmentSize)

 : iIsFlushed(EFalse),

   iSendingError(EFalse),

   iQueuedForSend(EFalse),

   iAwaitingHciCompletion(EFalse), // first transmission never waits for a previous one to finish

   iElementHandle(this),

   iPduOwner(NULL),

   iOptimalFragmentSize(aOptimalFragmentSize),

   iTotalNumberOfFragments(KNumberOfFragmentsUnknown),

   iFragmentAcksReceived(0)

	{

	LOG_FUNC

	iPDUData.Assign(aPDUData);

	iPDUData.Align(Min(iPDUData.Length(), KMaxPDUHeaderLength));

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EBasePDU,

	                             L2capDebugInfo::EAllocated));

	}

HL2CapPDU::HL2CapPDU(TInt aOptimalFragmentSize)

 : iIsFlushed(EFalse),

   iSendingError(EFalse),

   iQueuedForSend(EFalse),

   iAwaitingHciCompletion(EFalse), // first transmission never waits for a previous one to finish

   iElementHandle(this),

   iPduOwner(NULL),

   iOptimalFragmentSize(aOptimalFragmentSize),

   iTotalNumberOfFragments(KNumberOfFragmentsUnknown),

   iFragmentAcksReceived(0)

	{

	LOG_FUNC

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EBasePDU,

	                             L2capDebugInfo::EAllocated));

	}

#pragma warning (default: 4355)

HL2CapPDU::~HL2CapPDU()

	{

	LOG_FUNC

	iPDUData.Free();

	iLink.Deque();

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EBasePDU,

	                             L2capDebugInfo::EDeleted));

	}

// Static Message Accessors.

/*static*/ TBool HL2CapPDU::AddFragment(RMBufChain& aPDU, RMBufChain& aPDUFragment)

	{

	LOG_STATIC_FUNC

	if(aPDUFragment.First()!= NULL)

		{

		aPDU.Append(aPDUFragment);

		return ((aPDU.Length() - KPDUHeaderLength) >= PDUPayloadLength(aPDU));

		}

	else

		{

		return(EFalse);

		}

	}

/*static*/ TUint16 HL2CapPDU::PDUPayloadLength(const RMBufChain& aPDU)

	{

	LOG_STATIC_FUNC

	__ASSERT_DEBUG(aPDU.First() && (aPDU.First())->Length() >= KPDUHeaderLength,

		           Panic(EL2CapPDUInvalidLength));

	return LittleEndian::Get16((aPDU.First())->Ptr()+KLengthByteOffset);

	}

/*static*/ TUint16 HL2CapPDU::PDUCID(const RMBufChain& aPDU)

	{

	LOG_STATIC_FUNC

	__ASSERT_DEBUG(aPDU.First() && (aPDU.First())->Length() >= KPDUHeaderLength,

		           Panic(EL2CapPDUInvalidLength));

	return LittleEndian::Get16((aPDU.First())->Ptr()+KCIDByteOffset);

	}

void HL2CapPDU::SetPDUPayloadLength(TUint16 aLength)

	{

	LOG_FUNC

	__ASSERT_DEBUG(iPDUData.First() && (iPDUData.First())->Length() >= KPDUHeaderLength,

		           Panic(EL2CapPDUInvalidLength));

	LittleEndian::Put16((iPDUData.First())->Ptr()+KLengthByteOffset, aLength);

	}

void HL2CapPDU::SetPDUCID(TUint16 aCID)

	{

	LOG_FUNC

	__ASSERT_DEBUG(iPDUData.First() && (iPDUData.First())->Length() >= KPDUHeaderLength,

		           Panic(EL2CapPDUInvalidLength));

	LittleEndian::Put16((iPDUData.First())->Ptr()+KCIDByteOffset, aCID);

	}

void HL2CapPDU::WritePDUPayloadLength()

	{

	LOG_FUNC

	SetPDUPayloadLength(static_cast<TUint16>(iPDUData.Length() - KPDUHeaderLength));

	}

/*

 * Function to return the PDU L2CAP overhead.

 */

/*static*/ TInt HL2CapPDU::GetPDUOrFragmentOverhead(TBool aBasicMode)

	{

	LOG_STATIC_FUNC

	if (aBasicMode)

		{

		// Basic mode does not segment into PDUs and therefore has no PDU overhead

		return 0;

		}

	// Non-basic mode overhead

	return KPDUHeaderLength + KControlFieldLength + KFCSFieldLength;

	}

/*

 * Return the payload size of the optimal pdu based on the baseband packet

 * sizes, the negotiated MTU (aMTU) and the size of the buffers on the 

 * controller (aBufSize).

 * SDU length field is taken into account when it get segmented by CL2CapSDU::SegmentSDUIntoPDUs

 */

/*static*/ TInt HL2CapPDU::GetPDUOrFragmentSize(TInt aMTU, TInt aMaxMps, TInt aBufSize, TBool aBasicMode)

	{

	LOG_STATIC_FUNC

	// aBufSize == 0 means that getting the buffer size failed so assume the best

	// case scenario for performance

	TInt bufSize = aBufSize != 0 ? aBufSize : KBBPacketSize[KBaseBandPacketCount - 1];

	// get the overhead size for every l2cap pdu	

	TInt packetOverhead = GetPDUOrFragmentOverhead(aBasicMode);

	// it's possible that the buffer size is so small that when including the packet overhead there is no

	// room for a payload, this is of course no good.

	__ASSERT_ALWAYS((bufSize - packetOverhead) > 0, Panic(EL2CAPACLBufferTooSmall));

	// store the current baseband packet size as we go through the below for loop

	TInt currentPacketSize;

	// iterate backwards through the baseband packet sizes array

	for (TInt index = KBaseBandPacketCount - 1; index >= 0; index--)

		{

		currentPacketSize = KBBPacketSize[index];

		if (aMTU >= (index > 0 ? ((currentPacketSize + KBBPacketSize[index - 1]) / 2) : currentPacketSize))

			{

			if (bufSize >= currentPacketSize)

				{

				// if the current baseband packet size is less than the MTU size and the baseband

				// packet will fit into the controllers buffer then use the baseband packet

				return (aBasicMode ? (currentPacketSize - packetOverhead) : Min(aMaxMps, (currentPacketSize - packetOverhead)));

				}

			else if ((index > 0) && (bufSize >= ((currentPacketSize + KBBPacketSize[index - 1]) / 2)))

				{

				// if the current baseband packet is less than the MTU but the baseband packet

				// won't fit into the controllers buffer see if the buffer size is closer to the

				// current baseband packet than the next size down and if so use the buffer size

				// of the controller

				return (aBasicMode ? (bufSize - packetOverhead) : Min(aMaxMps, (bufSize - packetOverhead)));

				}

			}

		}

	// to get here means that the buffer size of the controller or the MTU is less than the minimum

	// baseband packet size. A small ACL buffer reduces performance as there is a big overhead to data

	// ratio, but we handle that situation anyway.

	return (aBasicMode ? (bufSize - packetOverhead) : Min(aMaxMps, (bufSize - packetOverhead)));

	}

/*static*/ TInt HL2CapPDU::CheckDecode(const RMBufChain& aPDU)

	{

	LOG_STATIC_FUNC

	TInt rerr = KErrNone;

	if(aPDU.Length() != (PDUPayloadLength(aPDU) + KPDUHeaderLength))

		{

		rerr = KErrCorrupt;

		}

	return rerr;

	} 

void HL2CapPDU::AppendPayloadToBuffer(RMBufChain& /*aSDUData*/)

	{

	LOG_FUNC

	Panic(EL2CAPInvalidCallToAppendPayloadToBuffer);

	}

void HL2CapPDU::DeliverOutgoingPDU(MOutgoingPDUHandler& aPDUHandler)

	{

	iAwaitingHciCompletion = ETrue;

	DeliverOutgoingPDUDoubleDispatch(aPDUHandler);

	}

void HL2CapPDU::PDUSendPending(TUint16 aTotalNumberOfFragments)

	{

	LOG_FUNC

	// The fragment sender has completed sending the PDU to the

	// ACL.

	__ASSERT_DEBUG(iTotalNumberOfFragments == KNumberOfFragmentsUnknown, Panic(EL2CAPPDUSendPendingCalledTwice));

	iTotalNumberOfFragments = aTotalNumberOfFragments;

	// In some error conditions the expected number of outstanding fragments might

	// have been reached before this method is called.

	if(iFragmentAcksReceived == iTotalNumberOfFragments)

		{

		PDUSendComplete();

		}

	}

void HL2CapPDU::PDUSendComplete()

	{

	LOG_FUNC

	iAwaitingHciCompletion = EFalse;

	if(!iIsFlushed && iPduOwner)

		{

		iFragmentAcksReceived = 0;

		iTotalNumberOfFragments = KNumberOfFragmentsUnknown;

		if(!iSendingError)

			{

			// Do frame-type specific stuff.

			SendComplete();

			iPduOwner->HandlePduSendComplete(*this);

			}

		else

			{

			iSendingError = EFalse; // in case the owner decides to resend us

			iPduOwner->HandlePduSendError(*this);

			}

		}

	else

		{

		// No references are held to this PDU.  Delete it.

		delete this;

		}

	}

// MDataPlaneElement Interface

void HL2CapPDU::DataElementSent(TUint16 /*aElementID*/)

	{

	LOG_FUNC

	// Check if the PDU has been fully sent to the peer.

	if(++iFragmentAcksReceived == iTotalNumberOfFragments)

		{

		PDUSendComplete();

		}

	}

void HL2CapPDU::DataElementFlushed(TUint16 aElementID)

	{

	LOG_FUNC

	// Check if this PDU has been flushed.

	if(!iIsFlushed)

		{

		iSendingError = ETrue;

		}

	DataElementSent(aElementID);

	}

TUint16 HL2CapPDU::CalcCRC(const RMBufChain& aPDU)

 	{

 	LOG_STATIC_FUNC

  	TUint16 crcValue = 0;

  	TUint8 dataByte;

	TInt i, bufLength;

	TUint16 carryBit, bitCount;

	const RMBuf* bufPtr = aPDU.First();

	TInt fcsLength = aPDU.Length() - KFCSFieldLength;

	TInt byteCount = 0;

	while(bufPtr)

		{

		// Check if this is the last buffer.  If so don't

		// process the FCS bytes.

		bufLength = bufPtr->Length();

	 	for(i=0;i<bufLength;i++)

	  		{

	  		if(byteCount < fcsLength)

	  			{

		  		dataByte = bufPtr->Get(i);

		  		byteCount++;

				for(bitCount=0;bitCount<8;bitCount++)

					{

					carryBit = static_cast<TUint16>(crcValue & 0x8000 ? 1 : 0);

					crcValue <<= 1;

					if ((dataByte & 1) ^ carryBit)

						{

						crcValue ^= 0x8005;

						}

					dataByte >>= 1;

					}

				}

  			}

  		bufPtr = bufPtr->Next();

  		}

	carryBit = 0;

	for(bitCount=0;bitCount<16;bitCount++)

		{

		carryBit = static_cast<TUint16>((carryBit >> 1) | (crcValue & 0x8000));

		crcValue <<= 1;

		}

  	return carryBit;

  	}

void HL2CapPDU::SendComplete()

	{

	LOG_FUNC

	// Nothing to do for most PDUs.

	}

//

// Class used to fragment and send any type of PDU.

// An instance of this class is currently owned by the Mux

//

HFragmentedPDUSender::HFragmentedPDUSender(CL2CAPMux& aMuxer)

 : iPDU(NULL),

   iPDUBuffer(NULL),

   iMuxer(aMuxer),

   iCurrentWriteIndex(0),

   iCurrentFragmentID(0),

   iPDULength(0)

	{

	LOG_FUNC

	}

HFragmentedPDUSender::~HFragmentedPDUSender()

	{

	LOG_FUNC

	delete iPDUBuffer;

	__ASSERT_DEBUG(iPDU == NULL, Panic(EL2CAPFragmentSenderDeletedWhileSending));

	}

TInt HFragmentedPDUSender::FragmentPDU(HL2CapPDU& aPDU)

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	__ASSERT_DEBUG(!iCurrentWriteIndex && !iCurrentFragmentID, Panic(EL2CAPRequestToFragmentWhileBufferContainsData));

	RMBufChain& pduData = aPDU.PDUBuffer();

	if(!iPDUBuffer || iPDUBuffer->Size() < pduData.Length())

		{

		// Increase the size of the buffer.

		delete iPDUBuffer; 

		iPDUBuffer = HBufC8::New(pduData.Length());

		}

	if(iPDUBuffer)

		{

		iPDU = &aPDU;

		iPDULength = pduData.Length();

		// Copy the Buffer into the descriptor

  		TPtr8 ptr = iPDUBuffer->Des();

  		ptr.SetLength(iPDULength);

		pduData.CopyOut(ptr);

		// store the optimal fragment size

		iPDUFragmentSize = aPDU.OptimalFragmentSize();

		}

	else

		{

		rerr = KErrNoMemory;

		}

	return rerr;

	}

HFragmentedPDUSender::TFragmentSenderStatus HFragmentedPDUSender::WriteNextFragment(CServProviderBase& aSender, TInt aACLMTU)

	{

	LOG_FUNC

	// If optimal fragment size not set then this PDU should only have been segmented, not fragmented

	__ASSERT_DEBUG((iPDULength <= aACLMTU) || (iPDUFragmentSize != 0), Panic(EL2CAPUnexpectedFragmentation));

	if (iPDUFragmentSize == 0)

		{

		// For udeb builds we know that this PDU can fit into the ACL buffer so just set the fragment size

		// to be the ACL buffer size to allow logic below to work. For urel builds this can also recover the

		// situation if the debug assert fails above, just not using optimal performance.

		iPDUFragmentSize = aACLMTU;

		}

	// Ensure that the optimal fragment size will fit into the ACL buffer.

	__ASSERT_DEBUG(aACLMTU >= iPDUFragmentSize, Panic(EL2CAPOptimalFragmentSizeTooBigForACLBuffer));

	TFragmentSenderStatus rStatus = EFragmentOK;

	TUint8 flags = iCurrentWriteIndex ? KContinuingHLFragment : KFirstHLFragment;

	TInt fragLength = Min(iPDULength - iCurrentWriteIndex, Min(iPDUFragmentSize, aACLMTU));

	// The 'Write' returns the number of fragments (NOT bytes) 

	// that will be sent. This is typically either 0 or 1.

	TUint fragmentsSent = aSender.Write(iPDUBuffer->Mid(iCurrentWriteIndex, fragLength), flags, &iPDU->ElementHandle()); 

	if(!fragmentsSent)

		{

		rStatus = EFlowControlledOff;

		}

	else

		{

		iCurrentWriteIndex += fragLength;

		iCurrentFragmentID++;

		}

	// Check if the PDU has been fully sent.

	if(iCurrentWriteIndex >= iPDULength)

		{

		rStatus = EFragmentationComplete;

		// Inform the PDU that it has been sent.

		iPDU->PDUSendPending(iCurrentFragmentID);

		// Reset the internal state of this sender.

		Reset();

		}

	return rStatus; 

	}

void HFragmentedPDUSender::Reset()

	{

	LOG_FUNC

	iPDU = NULL;

	iPDULength = iCurrentWriteIndex = 0;

	iCurrentFragmentID = 0;

	iPDUFragmentSize = 0;

	}

void HFragmentedPDUSender::CheckForFlushed()

	{

	LOG_FUNC

	// Check if the PDU currently being sent(if there is one)

	// needs to be flushed.

	if(iPDU)

		{

		if(iPDU->IsPDUFlushed())

			{

			// Inform the PDU that it has been sent.

			iPDU->PDUSendPending(iCurrentFragmentID);

			// Reset the internal state of this sender.

			Reset();

			}

		}

	}

void HFragmentedPDUSender::PDUSenderFailed()

	{

	LOG_FUNC

	if(iPDU)

		{

		// Inform the PDU that it has been sent.

		iPDU->PDUSendPending(iCurrentFragmentID);

		// Reset the internal state of this sender.

		Reset();

		}

	}

//