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

#include "L2CapDataController.h"

#include "L2CapEnhancedDataController.h"

#include "L2CapSDUQueue.h"

#include "l2signalmgr.h"

#include "btsockettimer.h"

#include "l2util.h"

#include "L2CapDebugControlInterface.h"

#include "l2constants.h"	

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP_DATA_CONTROLLER);

#endif

using namespace L2CapDataUtils;

// ***** CL2CapBasicDataController Implementation

/*static*/ CL2CapBasicDataController* CL2CapBasicDataController::NewL(TL2CAPPort aLocalCID, TL2CAPPort aRemoteCID, CL2CAPMux& aMuxer, CL2CapSDUQueue& aSDUQueue, TL2CapDataControllerConfig* aConfig)

	{

	LOG_STATIC_FUNC

	// Create the required data controller. 

	CL2CapBasicDataController* controller = NULL;

	switch(aConfig->LinkMode())

		{

		case EL2CAPBasicMode:

			LOG(_L("FEC L2CapBasicDataController Basic Mode"))

			controller = new(ELeave) CL2CapBasicDataController(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig, ETrue);

			break;

		case EL2CAPRetransmissionMode:

			LOG(_L("FEC L2CapBasicDataController Retransmission Mode"))

			controller = new(ELeave) CL2CapDataReTxController(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig);		

			break;

		case EL2CAPFlowControlMode:

			LOG(_L("FEC L2CapBasicDataController Flow Control Mode"))

			controller = new(ELeave) CL2CapDataFlowController(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig);		

			break;

		case EL2CAPStreamingMode:

			LOG(_L("FEC L2CapBasicDataController Streaming Mode"))

			controller = new(ELeave) CL2CapStreamingController(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig);		

			break;

		case EL2CAPEnhancedRetransmissionMode:

			LOG(_L("FEC L2CapBasicDataController Enhnaced Retransmission Mode"))

			controller = CL2CapEnhancedReTxController::NewL(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig);		

			break;

		default:

			Panic(EL2CAPInvalidLinkMode);

			break;

		};

	return controller;

	}

CL2CapBasicDataController::CL2CapBasicDataController(TL2CAPPort aLocalCID, TL2CAPPort aRemoteCID, CL2CAPMux& aMuxer, CL2CapSDUQueue& aSDUQueue, TL2CapDataControllerConfig* aConfig, TBool aIsBasicDataVersion)

 : iSDUQueue(aSDUQueue),

   iMuxer(aMuxer),

   iLocalCID(aLocalCID),

   iRemoteCID(aRemoteCID),

   iConfig(aConfig),

   iIsBasicDataVersion(aIsBasicDataVersion)

	{

	LOG_FUNC

	// Register with the Mux.

	iMuxer.RegisterDataPDUHandler(*this);

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EDataPlanes,

	                             L2capDebugInfo::EAllocated));	

	}

CL2CapBasicDataController::~CL2CapBasicDataController()

	{

	LOG_FUNC

	delete iConfig;

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EDataPlanes,

	                             L2capDebugInfo::EDeleted));	

	}	

HL2CapPDU* CL2CapBasicDataController::GetPdu()

	{

	LOG_FUNC

	HL2CapPDU* pdu = NULL;

	TRAPD(err, pdu = GetPduL());

	if (err != KErrNone)

		{

		// The protocol here is that all leaves propagated up to here cause

		// us to ErrorD() ourselves, which will destruct data plane objects

		// (the data controller, SDU queue and the whole shebang) and error

		// the socket with the leave error code.

		ErrorD(err);

		}

	return pdu;

	}

HL2CapPDU* CL2CapBasicDataController::GetPduL()

	{

	LOG_FUNC

	HL2CapPDU* pduToSend = NULL;

	if((pduToSend = iSDUQueue.GetPDU()) != NULL)

		{

		pduToSend->SetPDUCID(iRemoteCID);

		}

	return pduToSend;

	}

void CL2CapBasicDataController::ProcessFlushTimerExpiry()

	{

	LOG_FUNC

	iMuxer.ProcessFlushTimerExpiry();

	}

void CL2CapBasicDataController::OutgoingPduAvailableOnSduQ()

	{

	LOG_FUNC

	iMuxer.PDUAvailable();

	}

void CL2CapBasicDataController::UpdateConfig(TL2CapDataControllerConfig* aConfig)

	{

	LOG_FUNC

	TBool channelPriorityUpdated = (iConfig->ChannelPriority() != aConfig->ChannelPriority());

	// Delete the existing config, and replace it with the new one.

	delete iConfig;

	iConfig = aConfig;

	if(channelPriorityUpdated)

		{

		iMuxer.ChannelPriorityUpdated(*this);

		}

	}

void CL2CapBasicDataController::UpdateChannelPriority(TUint8 aNewPriority)

	{

	LOG_FUNC

	if(iConfig->ChannelPriority() != aNewPriority)

		{

		iConfig->SetChannelPriority(aNewPriority);

		iMuxer.ChannelPriorityUpdated(*this);

		}

	}

void CL2CapBasicDataController::ErrorD(TInt aError)

	{

	LOG_FUNC

	LOG1(_L("FEC CL2CapBasicDataController::Error %d"), aError)

	iDataPlaneErrored = ETrue;

	iSDUQueue.ErrorD(aError);

	}

void CL2CapBasicDataController::SetIncomingSduQFull(TBool /*aIncomingSduQFull*/)

	{

	LOG_FUNC

	// No action can be taken in basic mode.

	}

TBool CL2CapBasicDataController::DeliverOutgoingDataAndSignalToSduQWhenDone()

	{

	LOG_FUNC

	// We can be deleted right away.

	return ETrue;

	}

void CL2CapBasicDataController::DeregisterFromMuxer()

	{

	LOG_FUNC

	iMuxer.DataChannelRemoved(this);

	}

#ifdef _DEBUG

TInt CL2CapBasicDataController::GetDataPlaneConfig(TL2DataPlaneConfig& conf) const

	{

	LOG_FUNC

	TInt rerr = KErrNone;

	// Populate the debug structure.

	if(iConfig)

		{

		conf.iPriority = iConfig->ChannelPriority();

		conf.iLinkMode = iConfig->LinkMode();

		conf.iTxWindowSize = iConfig->TXWindowSize();

		conf.iMaxTransmit = iConfig->MaxTransmit();

		conf.iRetransmissionTimeout = iConfig->RetransmissionTimeout();

		conf.iMonitorTimeout = iConfig->MonitorTimeout();

		}

	else

		{

		rerr = KErrNotReady;

		}

	return rerr;

	}

#endif

TBool CL2CapBasicDataController::HandleIncomingDataFrame(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	TBool packetDelivered = EFalse;

	TRAPD(err, packetDelivered = HandleIncomingDataFrameL(aDataFrame));

	if (err != KErrNone)

		{

		// The protocol here is that all leaves propagated up to here cause

		// us to ErrorD() ourselves, which will destruct data plane objects

		// (the data controller, SDU queue and the whole shebang) and error

		// the socket with the leave error code.

		ErrorD(err);

		if (aDataFrame.IsEmpty())

			{

			packetDelivered = ETrue;

			}

		// else frame will be offered to other data controllers

		}

	return packetDelivered;

	}

void CL2CapBasicDataController::HandleIncomingIFrameL(RMBufChain& /*aDataFrame*/)

	{

	LOG_FUNC

	Panic(EL2CAPIFrameOrSFrameHandledByBasicController);

	}

void CL2CapBasicDataController::HandleIncomingBFrameL(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	iSDUQueue.PutBFramePDU(aDataFrame);

	}

void CL2CapBasicDataController::HandleIncomingSFrameL(RMBufChain& /*aDataFrame*/)

	{

	LOG_FUNC

	Panic(EL2CAPIFrameOrSFrameHandledByBasicController);

	}

TBool CL2CapBasicDataController::HandleIncomingDataFrameL(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	TBool PDUProcessed = EFalse;

	TInt err = KErrNone;

	if(HL2CapPDU::PDUCID(aDataFrame) == iLocalCID)

		{

		if(iIsBasicDataVersion)

			{

			// This can only be a B-Frame.

			if(HBFramePDU::CheckDecode(aDataFrame) == KErrNone)

			   	{

			   	HandleIncomingBFrameL(aDataFrame);

			   	}

			else

				{

				// Invalid frame.  Drop it.

				aDataFrame.Free();

				LOG(_L("FEC L2CapBasicDataController B-Frame Dropped"))

				}

			}

		else

			{

			if(HIFramePDU::IFrameIdentifier(aDataFrame))

				{

				// This is an I-Frame

				// Check stuff that causes us to drop frames first:

				// - FCS (2.1 Core Spec Addendum 1: 3.3.7 Invalid Frame Detection Algorithm pt. 2)

				// - length field matching the actual payload length (funnily 3.3.7 doesn't say

				//   what to do with it, pt. 7.2.2 Recombination Of L2CAP PDUs mentions it in

				//   passing).

				// Note: the frame is dropped when length is incorrect (instead of disconnecting)

				// because we don't know where FCS is (it's at the end of the packet and we don't

				// know where that is), so have to assume that the length field problem is due to

				// transmission corruption and not the remote misbehaving.

				if (HIFramePDU::CheckPayloadDecode(aDataFrame) != KErrNone ||

					HL2CapPDU::CheckDecode(aDataFrame) != KErrNone)

					{

					aDataFrame.Free();

					LOG(_L("FEC L2CapBasicDataController I-Frame Dropped"))

					}

				else

					{

					// Now check stuff that causes us to disconnect (per CSA1 3.3.7).

					err = HIFramePDU::CheckLengthWithinLimits(aDataFrame, iConfig->IncomingMps());

					if (err != KErrNone)

						{

						LOG(_L("FEC L2CapBasicDataController I-Frame invalid"))

						aDataFrame.Free();

						// This will cause the channel to be closed.

						LEAVEL(err);

						}

					else

						{

						HandleIncomingIFrameL(aDataFrame);

						}

					}

				}

			else

				{

				// S-Frame

				// Check stuff that causes the frame to be dropped first.

				if (HSFramePDU::CheckPayloadDecode(aDataFrame) != KErrNone ||

					HL2CapPDU::CheckDecode(aDataFrame) != KErrNone)

					{

					LOG(_L("FEC L2CapBasicDataController S-Frame Dropped"))

					}

				else

					{

					// Now check stuff that causes us to disconnect (per CSA1 3.3.7).

					err = HSFramePDU::CheckLengthField(aDataFrame);

					if (err != KErrNone)

						{

						LOG(_L("FEC L2CapBasicDataController S-Frame Invalid"))

						aDataFrame.Free();

						// This will cause the channel to be closed.

						LEAVEL(err);

						}

					else

						{

						HandleIncomingSFrameL(aDataFrame);

					  	}

					}

				// Finished with the S-Frame.

				aDataFrame.Free();

				}

			}

		PDUProcessed = ETrue;

		}

	return PDUProcessed;

	}

// Outgoing PDU handler.

TInt CL2CapBasicDataController::HandleOutgoingIFrame(HIFramePDU* /*aIFrame*/)

	{

	LOG_FUNC

	return KErrNone;

	}

TInt CL2CapBasicDataController::HandleOutgoingBFrame(HBFramePDU* /*aBFrame*/)

	{

	LOG_FUNC

	return KErrNone;

	}

TInt CL2CapBasicDataController::HandleOutgoingGFrame(HGFramePDU* /*aGFrame*/)

	{

	LOG_FUNC

	return KErrNone;

	}

TInt CL2CapBasicDataController::HandleOutgoingCFrame(HCFramePDU* /*aCFrame*/)

	{

	LOG_FUNC

	return KErrNone;

	}

TInt CL2CapBasicDataController::HandleOutgoingSFrame(HSFramePDU* /*aSFrame*/)

	{

	LOG_FUNC

	return KErrNone;

	}

// ***** CL2CapDataFlowController Implementation

CL2CapDataFlowController::CL2CapDataFlowController(TL2CAPPort aLocalCID, TL2CAPPort aRemoteCID, CL2CAPMux& aMuxer, CL2CapSDUQueue& aSDUQueue, TL2CapDataControllerConfig* aConfig)

 : CL2CapBasicDataController(aLocalCID, aRemoteCID, aMuxer, aSDUQueue, aConfig, EFalse),

   iPendingSentPDUs(_FOFF(HIFramePDU, iLink)),

   iSentPDUs(_FOFF(HIFramePDU, iLink)),

   iTimerMan(*this),

   iIncomingSduQFull(EFalse)

	{

	LOG_FUNC

	}

CL2CapDataFlowController::~CL2CapDataFlowController()

	{

	LOG_FUNC

	// Some PDUs may hold a reference to this data controller.

	TDblQueIter<HIFramePDU> pendingIter(iPendingSentPDUs);

	TDblQueIter<HIFramePDU> sentIter(iSentPDUs);

	HIFramePDU* pduPtr;

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

		{

		LOG1(_L("Deregistering TxSeq = %d"), pduPtr->TxSeqNumber());

		pduPtr->DeregisterPduOwner();

		}

	// Delete any PDUs that have already been sent.

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

		{

		delete pduPtr;

		}

	// Cancel any outstanding timers.

	iTimerMan.Close();

	}

void CL2CapDataFlowController::ProcessFlushTimerExpiry()

	{

	LOG_FUNC

	iMuxer.ProcessFlushTimerExpiry();

	PDUAvailable();

	if(!iSentPDUs.IsEmpty())

		{

		iNextTxSeq = Mod64(iSentPDUs.Last()->TxSeqNumber() + 1);

		}

	else

		{

		iNextTxSeq = iExpectedAckSeq;

		}

	}

void CL2CapDataFlowController::HandleIncomingIFrameL(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	// Check if flow control is active for incoming data.

	if(iIncomingSduQFull)

		{

		// Check that the PDU sequence number is within the expected range.

		if(!iSenderTxWindowClosed && Mod64(HIFramePDU::TxSeqNumber(aDataFrame) - iLastAckSentRxSeqNum) >= iConfig->PeerTXWindowSize())

			{

			// The number is not in range.  No more I-Frames will be processed

			// until flow control is deactivated.

			iSenderTxWindowClosed = ETrue;

			}

		}

	LOG(_L("FEC CL2CapDataFlowController: HandleIncomingIFrame"))

	LOG1(_L("\tTxSeqNumber = %d"), HIFramePDU::TxSeqNumber(aDataFrame))

	LOG1(_L("\tLastAckSentRxSeqNum = %d"), iLastAckSentRxSeqNum)

	if(!iSenderTxWindowClosed)

		{

		ProcessIFrameL(aDataFrame);

		}

	else

		{

		// Drop the frame.

		aDataFrame.Free();

		LOG(_L("FEC CL2CapDataFlowController: Incoming PDU seq number of I-Frame is not in range!"))

		}

	}

void CL2CapDataFlowController::ProcessIFrameL(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	iExpectedTxSeq = Mod64(iExpectedTxSeq + 1); 

	iExpectedAckSeq = HIFramePDU::ReqSeqNumber(aDataFrame);

	LEAVEIFERRORL(iSDUQueue.PutIFramePDU(aDataFrame));

	// Check if the acknowledged frame(s) has created

	// space in the window.	

	RemoveAckedPDUsFromSentQueue();

	// Only send an ack if incoming data is not currently flow controlled off.

	if(!iIncomingSduQFull)

		{

		// Check if the peer frames need to be acknowledged now.

		// Check the peer TxWindow.  This check is

		// (Number of I-Frames recv since last Ack was sent > (TxWindow - Constant)

		if(Mod64(iExpectedTxSeq - iLastAckSentRxSeqNum) > (iConfig->PeerTXWindowSize() - KTxWinAckThresholdOffset))

			{

			// Send an ack.

			iSendAckToPeer = ETrue;

			}

		else

			{

			// If the timer is not running, start it.

			if(!iTimerMan.IsSendPeerAckTimerRunning())

				{

				if(!iTimerMan.StartSendPeerAckTimer())

					{

					// A timer could not be started.  Send an ack immediately.

					iSendAckToPeer = ETrue;

					}

				}

			}

		}

	// Check if any outbound data can be sent.

	PDUAvailable();

	}

void CL2CapDataFlowController::HandleIncomingSFrameL(RMBufChain& aDataFrame)

	{

	LOG_FUNC

	// Check that the function is RR.  If not this S-Frame is not valid for

	// flow control mode.

	if(HSFramePDU::SupervisoryFunction(aDataFrame) == EReceiverReady)

		{

		iExpectedAckSeq = HSFramePDU::ReqSeqNumber(aDataFrame);

		// Check if the acknowledged frame(s) has created

		// space in the window.	

		RemoveAckedPDUsFromSentQueue();

		PDUAvailable();				

		LOG(_L("FEC CL2CapDataFlowController: Incoming S-Frame: RR"))				

		LOG1(_L("\tiLastAckedFrameNum = %d"),  iExpectedAckSeq)

		}

	}

TInt CL2CapDataFlowController::HandleOutgoingIFrame(HIFramePDU* aIFrame)

	{