// 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 "L2CapSDUQueue.h"

#include "L2CapDataController.h"
#include "l2util.h"
#include "l2sap.h"

#include "L2CapDebugControlInterface.h"
#include "btsockettimer.h"
#include <es_prot_internal.h>

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_L2CAP_SDU_Q);
#endif

CL2CapSDUQueue* CL2CapSDUQueue::NewLC(CL2CAPConnectionSAP& aL2CapSap,
		                              TL2CAPPort aLocalCID,
		                              TL2CAPPort aRemoteCID,
                                      CL2CAPMux& aMuxer,
	                                  TUint16 aPDUSize,
									  TUint8 aOutboundQueueSize,
                                      TL2CapDataControllerConfig* aConfig,
	                                  TUint16 aFlushTimeout, 
		                              TUint16 aMaxOutgoingMTU,
                               		  TUint16 aMaxIncomingMTU,
                               		  TUint16 aAclBufSize,
                               		  TBool aCanDropSdus)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* self = new(ELeave) CL2CapSDUQueue(aL2CapSap, aOutboundQueueSize, aPDUSize, aFlushTimeout, aMaxOutgoingMTU, aMaxIncomingMTU, aCanDropSdus);
	CleanupStack::PushL(self);
	self->ConstructL(aLocalCID, aRemoteCID, aMuxer, aConfig, aAclBufSize);
	return self;
	}
		                                  
CL2CapSDUQueue* CL2CapSDUQueue::NewL(CL2CAPConnectionSAP& aL2CapSap,
		                             TL2CAPPort aLocalCID,
		                             TL2CAPPort aRemoteCID,
                                     CL2CAPMux& aMuxer,
	                                 TUint16 aPDUSize,
									 TUint8 aOutboundQueueSize,
                                     TL2CapDataControllerConfig* aConfig,
	                                 TUint16 aFlushTimeout, 
		                             TUint16 aMaxOutgoingMTU,
                               		 TUint16 aMaxIncomingMTU,
                               		 TUint16 aAclBufSize,
                               		 TBool aCanDropSdus)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* self = NewLC(aL2CapSap, aLocalCID, aRemoteCID, aMuxer, aPDUSize, aOutboundQueueSize, aConfig, aFlushTimeout,
								 aMaxOutgoingMTU, aMaxIncomingMTU, aAclBufSize, aCanDropSdus);
	CleanupStack::Pop();
	return self;
	}	                                 
 
void CL2CapSDUQueue::ConstructL(TL2CAPPort aLocalCID, TL2CAPPort aRemoteCID, CL2CAPMux& aMuxer, TL2CapDataControllerConfig* aConfig, TUint16 aAclBufSize)
	{
	LOG_FUNC
	iDataController = CL2CapBasicDataController::NewL(aLocalCID, aRemoteCID, aMuxer, *this, aConfig);

	TCallBack canSendCB(CanSendAsyncCallBack, this);
	iCanSendAsyncCallBack = new (ELeave)CAsyncCallBack(canSendCB, EActiveMedPriority);
	TCallBack sdusSentCB(SDUsSentAsyncCallBack, this);
	iSDUSentAsyncCallBack = new (ELeave)CAsyncCallBack(sdusSentCB, EActiveLowPriority);
	TCallBack qClosingCB(QueueClosingAsyncCallBack, this);
	iQueueClosingCallBack = new (ELeave)CAsyncCallBack(qClosingCB, EActiveHighPriority);

	iCurrentPDUSize = HL2CapPDU::GetPDUOrFragmentSize(iMaxOutgoingMTU, iMaximumPDUSize, aAclBufSize, iDataController->IsBasicDataVersion());
	}
	

CL2CapSDUQueue::CL2CapSDUQueue(CL2CAPConnectionSAP& aL2CapSap,
                               TUint8 aOutboundQueueSize,
                               TUint16 aPDUSize,
                               TUint16 aFlushTimeout, 
                               TUint16 aMaxOutgoingMTU,
                               TUint16 aMaxIncomingMTU,
                               TBool aCanDropSdus)
 : iL2CapSap(aL2CapSap),
   iOutboundQueueSize(aOutboundQueueSize),
   iOutgoingSDUs(_FOFF(CL2CapSDU, iLink)),
   iOutgoingPulledSDUs(_FOFF(CL2CapSDU, iLink)),
   iFlushTimeout(aFlushTimeout),
   iCurrentPDUSize(aPDUSize),
   iMaximumPDUSize(aPDUSize),
   iNegotiatedPDUSize(aPDUSize),
   iMaxOutgoingMTU(aMaxOutgoingMTU),
   iMaxIncomingMTU(aMaxIncomingMTU),
   iCanDropSdus(aCanDropSdus)
	{
	LOG_FUNC
	}
	
CL2CapSDUQueue::~CL2CapSDUQueue()
	{
	LOG_FUNC
	TDblQueIter<CL2CapSDU> ogSDUIter(iOutgoingSDUs);
	CL2CapSDU* sduPtr;
	while((sduPtr = ogSDUIter++) != NULL)
		{
		delete sduPtr;
		}

	TDblQueIter<CL2CapSDU> ogPulledSDUIter(iOutgoingPulledSDUs);
	while((sduPtr = ogPulledSDUIter++) != NULL)
		{
		delete sduPtr;
		}

	// Free any incoming SDU's in the list.
	iIncomingSDUs.Free();
	iCurrentIncomingSDU.Free();
	
	// If the outgoing queue has not been closed then the
	// data controller needs to be deregistered. iDataController
	// can be NULL if CL2CapSDUQueue is created and deleted immediately
	if(iDataController)
		{
		iDataController->DeregisterFromMuxer();
		}
		
	delete iDataController;
	delete iCanSendAsyncCallBack;
	delete iSDUSentAsyncCallBack;
	delete iQueueClosingCallBack;
	
	CancelOutgoingQueueClosingTimer();
	}

void CL2CapSDUQueue::ProcessFlushTimerExpiry(CL2CapSDU& aL2CapSDU)
	{
	LOG_FUNC
	CL2CapSDU* sduPtr;
	TBool done = EFalse;
	TBool dataPlaneFlushRequired = EFalse;

	if(!iOutgoingSDUs.IsEmpty())
		{
		// Check the SDU that is first in line to be sent.  It may
		// have already been partially sent in which case it must be
		// flushed.  If it has not been sent at all then just delete it. 
		sduPtr = iOutgoingSDUs.First();
		
		if(sduPtr == &aL2CapSDU)
			{
			// The flushed SDU is first in line to be sent.
			if(sduPtr->IsSDUEmpty())
				{
				// None of the SDU has been pulled yet.
				delete sduPtr;
				L2CAP_DEBUG(UpdateFlushCounters(L2capDebugInfo::ESDUFlushQueuedSDUFlushed));
				}
			else
				{
				// Some of the SDU has been sent.  Remove it from
				// the OG queue so no more is sent.
				sduPtr->iLink.Deque();
				iOutgoingPulledSDUs.AddLast(*sduPtr);
				dataPlaneFlushRequired = ETrue;
				L2CAP_DEBUG(UpdateFlushCounters(L2capDebugInfo::ESDUFlushPartialSentSDUFlushed));
				}
			done = ETrue;
			}

		// If its not the first SDU check the rest of the outbound queue.
		TDblQueIter<CL2CapSDU> ogSDUIter(iOutgoingSDUs);
		// Start from 2nd element in the queue.
		ogSDUIter++;
		
		while(!done && ((sduPtr = ogSDUIter++) != NULL))
			{
			if(sduPtr == &aL2CapSDU)
				{
				// Flushed SDU found.  None of this SDU has been
				// sent yet so it can just be deleted from the
				// outbound queue.
				delete sduPtr;
				done = ETrue;
				L2CAP_DEBUG(UpdateFlushCounters(L2capDebugInfo::ESDUFlushQueuedSDUFlushed));
				}
			}
		}
		
	if(done)
		{
		// The SDU has been found and removed from the outgoing
		// queue.			
		SDURemovedFromOutboundQueue();
		}
	else
		{
		// If the SDU is not found in the outgoing queue it must have already 
		// been sent
		dataPlaneFlushRequired = ETrue;
		L2CAP_DEBUG(UpdateFlushCounters(L2capDebugInfo::ESDUFlushSentSDUFlushed));
		}

	if(iDataController && dataPlaneFlushRequired)
		{
		iDataController->ProcessFlushTimerExpiry();
		}
	}


HL2CapPDU* CL2CapSDUQueue::GetPDU()
	{
	LOG_FUNC
	HL2CapPDU* pduPtr = NULL;
	if(!iOutgoingSDUs.IsEmpty())
		{
		CL2CapSDU* sduPtr = iOutgoingSDUs.First();
		// If the outbound queue is suspended, and this is the start
		// of a new SDU.  Then don't send a PDU.
		if(!(iOutboundQueueSuspended && sduPtr->CurrentPDUIsFirstPDU()))
			{
			TBool lastPDU = sduPtr->GetPDU(pduPtr);
			if(lastPDU)
				{
				sduPtr->iLink.Deque();
				iOutgoingPulledSDUs.AddLast(*sduPtr);
				SDURemovedFromOutboundQueue();
				}
			}
		}
	return pduPtr;
	}
	
void CL2CapSDUQueue::PutBFramePDU(RMBufChain& dataFrame)
	{
	LOG_FUNC
	__ASSERT_ALWAYS(iDataController->IsBasicDataVersion(), 
	                Panic(EL2CapPDUInvalidFrameType));

	// Trim off the PDU header and store the SDU data.
	HBFramePDU::RemoveHeaderBytes(dataFrame);
	iIncomingSDUs.Append(dataFrame);
	iCurrentInboundQueueLength++;
	iL2CapSap.NewData();
	}
	
TInt CL2CapSDUQueue::PutIFramePDU(RMBufChain& aDataFrame)
	{
	LOG_FUNC
	__ASSERT_ALWAYS(iDataController->IsBasicDataVersion() == EFalse, 
	                Panic(EL2CapPDUInvalidFrameType));

	TL2CapSAR sar = HIFramePDU::SAR(aDataFrame);

	if (sar == EStartOfL2CapSDU)
		{
		// SDU length and minimal StartOfSdu I-Frame length as per 2.1 Core Spec Addendum 1:
		// 3.3.7 Invalid Frame Detection Algorithm steps 4a&c.
		TInt err = HIFramePDU::CheckStartSduLength(aDataFrame, iMaxIncomingMTU);
		if (err != KErrNone)
			{
			aDataFrame.Free();
			return err;
			}
		}
	
	if(HIFramePDU::IsStartOfSDU(aDataFrame))
		{
		// TODO: Commented out until RTM and FC are fixed not to call this method
		// once they're notified we're full.
//		__ASSERT_DEBUG(iCurrentInboundQueueLength < KInboundQueueFlowCtrlThreshold,
//					   Panic(EL2CAPPutIFrameCalledWhenSDUQFull));

		if(!iCurrentIncomingSDU.IsEmpty())
			{
			aDataFrame.Free();
			// The previous SDU has not been completed.  Take the
			// required action, and remove the SDU from the queue.
			return HandleIncompleteSDU(iCurrentIncomingSDU);
			}

		// A new SDU needs to be started.
		if(sar == EStartOfL2CapSDU)
			{
			iCurrentIncomingSDULength = HIFramePDU::SDUSize(aDataFrame);
			}
		else
			{
			// Unsegmented PDU.
			iCurrentIncomingSDULength = static_cast<TUint16>(HIFramePDU::PDUPayloadLength(aDataFrame) - (HL2CapPDU::KControlFieldLength + HL2CapPDU::KFCSFieldLength));
			}
			
		HIFramePDU::RemoveHeaderAndFCSBytes(aDataFrame);
		iCurrentIncomingSDU.Assign(aDataFrame);
		}
	else
		{
		HIFramePDU::RemoveHeaderAndFCSBytes(aDataFrame);

		// The existing SDU should not be empty.
		if(iCurrentIncomingSDU.IsEmpty())
			{
			aDataFrame.Free();
			return HandleIncompleteSDU(aDataFrame);
			}
		else
			{
			// Add to the existing SDU.
			iCurrentIncomingSDU.Append(aDataFrame);

			if(sar == EEndOfL2CapSDU)
				{
				// Check the expected length matches the actual length.
				if(iCurrentIncomingSDU.Length() != iCurrentIncomingSDULength)
					{
					return HandleIncompleteSDU(iCurrentIncomingSDU);
					}
				}
			}
		}

	if(iCurrentIncomingSDU.Length() == iCurrentIncomingSDULength)
		{
		// Note: the two lines below should sit next to each other to be atomic wrt.
		// a call to Read(), in whose context we may be executing right now.
		// (Read() frees up space in the queue, calls iDataController->SetIncomingSduQFull,
		// which in turn calls PutIFramePDU for buffered frames).
		iIncomingSDUs.Append(iCurrentIncomingSDU);
		iCurrentInboundQueueLength++;
		
		if(iCurrentInboundQueueLength >= KInboundQueueFlowCtrlThreshold)
			{
			iDataController->SetIncomingSduQFull(ETrue);
			}
			
		// SDU is complete, signal new data.
		iL2CapSap.NewData();		
		}
	else
		{
		if(iCurrentIncomingSDU.Length() > iCurrentIncomingSDULength)	
			{
			// The incoming SDU has exceeded the length.
			return HandleIncompleteSDU(iCurrentIncomingSDU);
			}
		}
	return KErrNone;
	}

TInt CL2CapSDUQueue::Write(RMBufChain& aSDUData)
	{
	LOG_FUNC
	TInt rerr = KErrNone;
	if(aSDUData.Length() <= iMaxOutgoingMTU)
		{
		CL2CapSDU* sduPtr = NULL;

		if(!iOutboundSendingBlocked && 
		   (iCurrentOutboundQueueLength < iOutboundQueueSize))
			{
			TRAP(rerr, sduPtr = CL2CapSDU::NewL(aSDUData, *this, iCurrentPDUSize, iDataController->IsBasicDataVersion(), iFlushTimeout));   

			if(rerr == KErrNone)
				{
				iOutgoingSDUs.AddLast(*sduPtr);
				iCurrentOutboundQueueLength++;
				
				iDataController->OutgoingPduAvailableOnSduQ();
				}
			}
		else
			{
			iOutboundSendingBlocked = ETrue;
			rerr = KErrNotReady;
			}
		}
	else
		{
		// Attempt to send a SDU larger than the negotiated MTU size.
		rerr = KErrTooBig;
		}
		
	return rerr;
	}

void CL2CapSDUQueue::FlushCurrentlyAssembledSdu()
	{
	LOG_FUNC
	iCurrentIncomingSDU.Free();
	iCurrentIncomingSDULength = 0;
	}

void CL2CapSDUQueue::FlushOldestIncomingSdu()
	{
	LOG_FUNC
	if (!iIncomingSDUs.IsEmpty())
		{
		RMBufChain sdu;
		//Check on return value of iIncomingSDUs.Remove() is unnecessary, since we've checked iIncomingSDUs.IsEmpty()
		static_cast<void>(iIncomingSDUs.Remove(sdu));
		sdu.Free();
		iCurrentInboundQueueLength--;
		}
	}

void CL2CapSDUQueue::Read(RMBufChain& readData)
	{
	LOG_FUNC
	if(!iIncomingSDUs.IsEmpty())
		{
		//Check on return value of iIncomingSDUs.Remove() is unnecessary, since we've checked iIncomingSDUs.IsEmpty()
		static_cast<void>(iIncomingSDUs.Remove(readData));
		iCurrentInboundQueueLength--;

		if (iDataController && iCurrentInboundQueueLength < KInboundQueueFlowCtrlThreshold)
			{
			// Note: ERTM will call PutIFramePDU() for each buffered frame, in the context of the
			// call below.
			// Conclusion 1: flow control may be on again when returning from this call.
			// Conclusion 2: this method (Read) and PutIFramePDU need to be reentrant with respect
			// to each other: iIncomingSDUs.Append/Remove and corresponding iCurrentInboundQueueLength++/--
			// need to be "atomic".
			iDataController->SetIncomingSduQFull(EFalse);
			}

		// Check if this is the last SDU in the incoming queue.
		if(iSDUQueuesClosing && iIncomingSDUs.IsEmpty())
			// Note: see comment in CloseSDUQueue for why we don't need to check for incoming data
			// in the data controller.
			{
			iIncomingQueueClosed = ETrue;
			TryToCloseQueue();
			}
		}
	}
					
void CL2CapSDUQueue::CloseSDUQueue(TIncomingSDUQueueCloseAction aIncomingQueueAction, 
	                               TOutgoingSDUQueueCloseAction aOutgoingQueueAction)
	{
	LOG_FUNC
	iSDUQueuesClosing = ETrue;
	if (aIncomingQueueAction == EImmediatelyCloseIncomingQueue ||
		iIncomingSDUs.IsEmpty())
		// ^- note it's the remote's responsibility to only initiate disconnection when
		// all it's outgoing data has been delivered, which on receiveing side means
		// we don't have to check the data controller for pending incoming data -
		// everything that's been acknowledged is always in the SDU Q.
		{
		iIncomingQueueClosed = ETrue;
		}
		
	if (aOutgoingQueueAction == EImmediatelyCloseOutgoingQueue)
		{
		iOutgoingQueueClosed = ETrue;
		}
	else if (iOutgoingSDUs.IsEmpty() &&
			 !iOutgoingQueueClosed)
		//   ^- iDataController may be NULL if the outgoing Q has been closed.
		//   It'll happen if the remote initiates the disconnection, we close the outgoing
		//   Q and delete the data controller but still have unread SDUs in the incoming
		//   Q, and then our application calls Shutdown without reading the SDUs.
		{
		// Some of the data may still be waiting for transmission/acknowledgement
		// in the data controller's outgoing queues. If it's a reliable mode data controller
		// then we need to make sure all data has been delivered.
		iOutgoingQueueClosed = iDataController->DeliverOutgoingDataAndSignalToSduQWhenDone();
		}
	else // draining & have outgoing SDUs
		{
		// Start a guard timer to ensure the shutdown of the outgoing queue.
		StartOutgoingQueueClosingTimer();
		}
		
	TryToCloseQueue();
	}

void CL2CapSDUQueue::DataControllerDeliveredOutgoingData()
	{
	LOG_FUNC
	__ASSERT_DEBUG(iSDUQueuesClosing && iOutgoingSDUs.IsEmpty(),
				   Panic(EL2CAPStrayCallToDataControllerDeliveredOutgoingData));

	// Use the async callback instead of deleting directly - spares us having to inform
	// the data controller that it's been deleted and thus having a special exit path
	// inside it.
	iSDUSentAsyncCallBack->CallBack();
	}

void CL2CapSDUQueue::TryToCloseQueue()
	{
	LOG_FUNC
	// If the outgoing queue is not closed nothing can
	// be done.
	if(iOutgoingQueueClosed)
		{
		// The outgoing queue is closed.  Remove the
		// data controller from the muxer list, it is no longer required.
		CancelOutgoingQueueClosingTimer();

		if(iDataController)
			{
			// If we initiated the Shutdown, then we don't care about incoming data.
			// If the remote initiated the shutdown, then it has delivered the data
			// it wants us to read and it's now in the incoming SDU Q (because everything that
			// we've acknowledged is). In both cases we can delete the data controller now.
			iDataController->DeregisterFromMuxer();
			delete iDataController;
			iDataController = NULL;
			}
			
		// If both queues are closed signal back to the SAP.
		if(iIncomingQueueClosed)
			{
			iQueueClosingCallBack->CallBack();
			}
		}
	}

/*static*/ TInt CL2CapSDUQueue::QueueClosingAsyncCallBack(TAny* aSDUQueue)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* sduQueue = static_cast<CL2CapSDUQueue*>(aSDUQueue);
	sduQueue->SDUQueueClosed();
	return EFalse;
	}
	
void CL2CapSDUQueue::SDUQueueClosed()
	{
	LOG_FUNC
	iL2CapSap.SDUQueueClosed();
	}	

void CL2CapSDUQueue::SDURemovedFromOutboundQueue()
	{
	LOG_FUNC
	iCurrentOutboundQueueLength--;
	
	if(iOutboundSendingBlocked &&
	   (iCurrentOutboundQueueLength < iOutboundQueueSize))
	   	{
		iOutboundSendingBlocked = EFalse;
		iCanSendAsyncCallBack->CallBack();
	   	}

	// Check if any sent SDUs need deleting and if we can close the outgoing queue
	// now (if we're in shutdown at all).
	iSDUSentAsyncCallBack->CallBack();
	}


/*static*/ TInt CL2CapSDUQueue::CanSendAsyncCallBack(TAny* aSDUQueue)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* sduQueue = static_cast<CL2CapSDUQueue*>(aSDUQueue);
	sduQueue->CanSend();
	return EFalse;
	}

void CL2CapSDUQueue::CanSend()
	{
	LOG_FUNC
	iL2CapSap.CanSend();
	}

/*static*/ TInt CL2CapSDUQueue::SDUsSentAsyncCallBack(TAny* aSDUQueue)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* sduQueue = static_cast<CL2CapSDUQueue*>(aSDUQueue);
	sduQueue->SDUsSent();
	return EFalse;
	}
	
void CL2CapSDUQueue::SDUsSent()
	{
	LOG_FUNC
	// Check the pulled SDU queue and remove all fully sent SDU's. 
	CL2CapSDU* sdu = NULL;
	while(!iOutgoingPulledSDUs.IsEmpty())
		{		
		sdu = iOutgoingPulledSDUs.First();
		if(sdu->IsSDUEmpty())
			{
			delete sdu;
			}
		else
			{
			break;
			}
		}

	// If the queue is waiting to close and nothing is left to be done close it.	
	if(iSDUQueuesClosing && iOutgoingSDUs.IsEmpty())
		{
		// Take the data controller's outgoing PDU queues into account.
		// In reliable modes all data needs to be acknowledged by the peer before we can close.
		iOutgoingQueueClosed = iDataController->DeliverOutgoingDataAndSignalToSduQWhenDone();
		TryToCloseQueue();
		}
	}

/*static*/ TInt CL2CapSDUQueue::OutgoingQueueClosingTimerExpired(TAny *aSDUQueue)
	{
	LOG_STATIC_FUNC
	CL2CapSDUQueue* sduQueue = reinterpret_cast<CL2CapSDUQueue*>(aSDUQueue);
	sduQueue->HandleOutgoingQueueClosingTimerExpired();
	return EFalse;
	}

void CL2CapSDUQueue::StartOutgoingQueueClosingTimer()
	{
	LOG_FUNC
	if(!iOutgoingQueueClosingTimerRunning)
		{
		TCallBack cb(OutgoingQueueClosingTimerExpired, this);
		iOutgoingQueueClosingTimer.Set(cb);
		BTSocketTimer::Queue(KOutgoingQueueClosingTimer * KL2ProtocolSecondTimerMultiplier, iOutgoingQueueClosingTimer);
		iOutgoingQueueClosingTimerRunning = ETrue;
		}
	}
	
void CL2CapSDUQueue::CancelOutgoingQueueClosingTimer()
	{
	LOG_FUNC
	if(iOutgoingQueueClosingTimerRunning)
		{
		BTSocketTimer::Remove(iOutgoingQueueClosingTimer);
		iOutgoingQueueClosingTimerRunning = EFalse;
		}	
	}
	
void CL2CapSDUQueue::HandleOutgoingQueueClosingTimerExpired()
	{
	LOG_FUNC
	iOutgoingQueueClosingTimerRunning = EFalse;
	
	// The outgoing queue closing timer has expired.  Force the outgoing
	// queue to close.  Pending data will NOT be sent.
	iOutgoingQueueClosed = ETrue;
	TryToCloseQueue();		
	}

TInt CL2CapSDUQueue::HandleIncompleteSDU(RMBufChain& aIncompleteSDU)
	{
	LOG_FUNC
	// This method is the starting point for reporting errored / incomplete SDU's to
	// the socket.  At present this functionality is not implemented and the buffer
	// is just freed.
	aIncompleteSDU.Free();
	iCurrentIncomingSDULength = 0;

	L2CAP_DEBUG(UpdateFlushCounters(L2capDebugInfo::EIncompleteErroredSDUReceived));

	// This function is always called when SAR bits in the received I-Frame are unexpected.
	// Need to close the connection as per 2.1 Core Spec Addendum 1: 3.3.7 Invalid Frame
	// Detection Algorithm point 4b.
	return iCanDropSdus ? KErrNone : KErrL2CAPIncomingSduSegmentationError;
	}

void CL2CapSDUQueue::ResumeSDUQueue(TL2CapDataControllerConfig* aConfig,
                    				TUint16 aFlushTimeout,
                    				TUint16 aPDUSize,
                    				TUint16 aMaxOutgoingMTU,
                    				TUint16 aMaxIncomingMTU,
                    				TUint16 aAclBufSize)
	{
	LOG_FUNC
	// Update the data controller.
	iDataController->UpdateConfig(aConfig);
	
	// Update internal members.
	iFlushTimeout = aFlushTimeout;
	iMaxOutgoingMTU = aMaxOutgoingMTU;
	iMaxIncomingMTU = aMaxIncomingMTU;	
	iMaximumPDUSize = aPDUSize;
	iNegotiatedPDUSize = aPDUSize;

	TInt err = KErrNone;

	// If the max PDU size has been increased or remained the same
	// none of the existing SDU's need to be modified.
	if(iNegotiatedPDUSize < iCurrentPDUSize)
		{
		// For each completely unsent SDU.  Adjust the PDU size.
		// Check if there are any un-sent SDU's
		CL2CapSDU* sduPtr = NULL;
		if(!iOutgoingSDUs.IsEmpty())
			{
			// The first SDU on the outgoing queue might be partially sent.  If it is
			// it can't be re-segmented.
			TDblQueIter<CL2CapSDU> ogSDUIter(iOutgoingSDUs);
			while((sduPtr = ogSDUIter++) != NULL)
				{
				if(sduPtr->CurrentPDUIsFirstPDU())
					{
					err = sduPtr->ChangeSDUSegmentation(iDataController->IsBasicDataVersion(), iNegotiatedPDUSize);
					if(err != KErrNone)
						{
						ErrorD(err);
						delete sduPtr;
						break;
						}
					}
				}
			}
		}
	if (err == KErrNone)
		{
		iCurrentPDUSize = HL2CapPDU::GetPDUOrFragmentSize(iMaxOutgoingMTU, iMaximumPDUSize, aAclBufSize, iDataController->IsBasicDataVersion());
	
		// Allow the outbound queue to send again, and tell the data
		// plane if SDU's are available.
		iOutboundQueueSuspended = EFalse;
		if(iCurrentOutboundQueueLength)
			{
			iDataController->OutgoingPduAvailableOnSduQ();
			}
		} // ... else we're a zombie.
	}
	
void CL2CapSDUQueue::ErrorD(TInt aErrorCode)
	{
	LOG_FUNC
	// We'll get deleted down the call chain. 
	iL2CapSap.DataPlaneError(aErrorCode, MSocketNotify::TOperationBitmasks(MSocketNotify::EErrorSend | MSocketNotify::EErrorRecv));
	}

void CL2CapSDUQueue::UpdateChannelPriority(TUint8 aNewPriority)
	{
	LOG_FUNC
	if (iDataController)
		{
		iDataController->UpdateChannelPriority(aNewPriority);	
		}
	}

TUint CL2CapSDUQueue::GetOptimalMTUSizeL(TUint aMtuRestriction, TUint16 aAclBufSize)
	{
	LOG_FUNC

	if (!iDataController)
		{
		// Can happen if we're being shut down quickly due to an error and the upper layer
		// still hasn't reacted to that.
		LEAVEL(KErrNotReady);
		}

	// Ensure that the restriction is less then the current MTU.
	if (aMtuRestriction < iMaxOutgoingMTU)
		{
		// We now need to recalculate the optimal PDU size for the restricted MTU as
		// this is used in the calculation of the optimal MTU

		iCurrentPDUSize = HL2CapPDU::GetPDUOrFragmentSize(aMtuRestriction, iMaximumPDUSize,
                                                          aAclBufSize, iDataController->IsBasicDataVersion());
		}
	else
		{
		// can't increase the MTU at this stage so just use the existing MTU
		aMtuRestriction = iMaxOutgoingMTU;
		}

	// If the negotiated MTU minus any overhead will fit into the optimal PDU then that
	// is the optimal MTU. The overhead will differ for basic and non-basic mode, for basic mode
	// we have to consider the SDU overhead as there is no fragment overhead and for non-basic we 
	// consider the PDU overhead only (the additional SDU overhead is taken account of later if 
	// more than one PDU is required for the optimal MTU).
	TUint optimalMTU = aMtuRestriction;

	// Calculate the size of the MTU + any overhead assuming that the MTU is not segmented
	TUint singlePduSize = iDataController->IsBasicDataVersion() ?
						  (aMtuRestriction + CL2CapSDU::GetSDUOverhead(iDataController->IsBasicDataVersion())) : aMtuRestriction;

	// If the unsegmented MTU + overhead can fit into the optimal PDU size then no 
	// further calculation is required
	if(singlePduSize > iCurrentPDUSize)
		{
		// The MTU will need to be segmented / fragmented (depending on L2CAP mode).
		// Calculate an MTU size that will be a factor of the PDU size.
		optimalMTU = aMtuRestriction - ((aMtuRestriction + CL2CapSDU::GetSDUOverhead(iDataController->IsBasicDataVersion())) % iCurrentPDUSize); 
		}

	return optimalMTU;
	}


#ifdef _DEBUG
TInt CL2CapSDUQueue::GetDataPlaneConfig(TL2DataPlaneConfig& conf) const
	{
	LOG_FUNC
	TInt rerr = KErrNone;
	// Populate the debug structure.
	if(iDataController)
		{
		rerr = iDataController->GetDataPlaneConfig(conf);
		if(rerr == KErrNone)
			{
			conf.iOutboundQueueSize = iOutboundQueueSize;
			conf.iFlushTimeout = iFlushTimeout;
			conf.iMaximumPDUSize = iCurrentPDUSize;
			conf.iMaxOutgoingMTU = iMaxOutgoingMTU;
			conf.iMaxIncomingMTU = iMaxIncomingMTU;
			}
		}
	else
		{
		rerr = KErrNotReady;
		}
	return rerr;
	}

void CL2CapSDUQueue::PretendIncomingSduQFull(TBool aIncomingSduQFull)
	{
	LOG_FUNC
	if (iDataController)
		{
		iDataController->SetIncomingSduQFull(aIncomingSduQFull);
		}
	}
#endif
