// Copyright (c) 2008-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 "L2CapEnhancedDataController.h"

#include "L2CapSDUQueue.h"

#include "l2signalmgr.h"

#include "l2util.h"

#include "L2CapDebugControlInterface.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP_DATA_CONTROLLER);

#endif

using namespace L2CapDataUtils;

CL2CapStreamingController::CL2CapStreamingController(TL2CAPPort aLocalCID,

													 TL2CAPPort aRemoteCID,

													 CL2CAPMux& aMuxer,

													 CL2CapSDUQueue& aSDUQueue,

													 TL2CapDataControllerConfig* aConfig)

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

	{

	LOG_FUNC

	}

CL2CapStreamingController::~CL2CapStreamingController()

	{

	LOG_FUNC

	}

void CL2CapStreamingController::ProcessFlushTimerExpiry()

	{

	LOG_FUNC

	__ASSERT_DEBUG(EFalse, Panic(EL2CAPFlushingNotReallySupported));

	}

HL2CapPDU* CL2CapStreamingController::GetPduL()

	{

	LOG_FUNC

	// This is called from the signal manager.

	HL2CapPDU* pduToSend = NULL;

	pduToSend = iSDUQueue.GetPDU();

	if(pduToSend)

		{

		pduToSend->DeliverOutgoingPDU(*this);

		}

    if (iSDUQueue.HavePDUToSend())

        {

        iMuxer.PDUAvailable();

        }

	return pduToSend;

	}

void CL2CapStreamingController::HandleIncomingIFrameL(RMBufChain& aIFrame)

	{

	LOG_FUNC

	const TUint8 txSeq = HIFramePDU::TxSeqNumber(aIFrame);

	if (txSeq != iExpectedTxSeq)

		{

		// SDU currently being assembled is no good now. Need to tell the SDU Q to flush

		// it, otherwise if we lost the right amount of I-Frames, we would end up assembling

		// an FDU (Frankenstein Data Unit) - half SDU number n, half SDU number n+1.

		// Note that FDUs are still possible if 63 frames are lost. There'se no notion of

		// SDU checksumming in the protocol, so that can't be prevented.

		iSDUQueue.FlushCurrentlyAssembledSdu();

		}

	if (iSDUQueue.IsIncomingQueueFull())

		{

		// Make room for new data. From the spec:

		// "If there is no buffer space for the received I-frame an existing I-frame

		// (i.e. the oldest) shall be discarded (flushed) freeing up buffer space for

		// the new I-frame.	The discarded I-frame shall be marked as missing."

		iSDUQueue.FlushOldestIncomingSdu();

		}

	LEAVEIFERRORL(iSDUQueue.PutIFramePDU(aIFrame));

	iExpectedTxSeq = Mod64(txSeq + 1);

	// SDU Q sucks out the content, so we can free the frame whether it's been consumed or dropped.

	aIFrame.Free();

	}

TInt CL2CapStreamingController::HandleOutgoingIFrame(HIFramePDU* aIFrame)

	{

	LOG_FUNC

	aIFrame->SetPDUCID(iRemoteCID);

	aIFrame->SetTxSeqNumber(iNextTxSeq);

	iNextTxSeq = Mod64(iNextTxSeq + 1);

	// The Control field is zero-ed when the frame is created.

	aIFrame->CalculateAndSetFCS();

	return KErrNone;

	}

void CL2CapStreamingController::HandlePduSendComplete(HL2CapPDU& aPdu)

	{

	LOG_FUNC

	delete &aPdu;

	}

void CL2CapStreamingController::HandlePduSendError(HL2CapPDU& aPdu)

	{

	LOG_FUNC

	delete &aPdu;

	}

RL2CapErtmTimerManager::RL2CapErtmTimerManager(CL2CapEnhancedReTxController& aClient)

 :	RL2CapRetransmissionModeTimerManager(aClient),

 	iLocalBusyDelayTimerRunning(EFalse)

	{

	LOG_FUNC

	}

void RL2CapErtmTimerManager::Close()

	{

	LOG_FUNC

	StopLocalBusyDelayTimer();

	RL2CapRetransmissionModeTimerManager::Close();

	}

void RL2CapErtmTimerManager::StartLocalBusyDelayTimer()

	{

	LOG_FUNC

	// Shouldn't happen, but no big deal if it does.

	__ASSERT_DEBUG(!iLocalBusyDelayTimerRunning, Panic(EL2CAPInvalidDataControllerTimerState));

	if (!iLocalBusyDelayTimerRunning)

		{

		TCallBack cb(LocalBusyDelayTimerExpired, this);

		iLocalBusyDelayTimerEntry.Set(cb);

		// Set the timeout. The value is in Milliseconds.

		BTSocketTimer::Queue((iClient.PeerRetransmissionTimeout() * 1000) / KLocalBusyDelayTimerDenominator,

							 iLocalBusyDelayTimerEntry);

		iLocalBusyDelayTimerRunning = ETrue;

		}

	}

void RL2CapErtmTimerManager::StopLocalBusyDelayTimer()

	{

	LOG_FUNC

	if (iLocalBusyDelayTimerRunning)

		{

		BTSocketTimer::Remove(iLocalBusyDelayTimerEntry);

		iLocalBusyDelayTimerRunning = EFalse;

		}

	}

void RL2CapErtmTimerManager::HandleLocalBusyDelayTimerExpired()

	{

	LOG_FUNC

	iLocalBusyDelayTimerRunning = EFalse;

	static_cast<CL2CapEnhancedReTxController&>(iClient).LocalBusyDelayTimerExpired();

	}

/*static*/ TInt RL2CapErtmTimerManager::LocalBusyDelayTimerExpired(TAny* aTimerMan)

	{

	LOG_STATIC_FUNC

	RL2CapErtmTimerManager* timerMan = reinterpret_cast<RL2CapErtmTimerManager*>(aTimerMan);

	timerMan->HandleLocalBusyDelayTimerExpired();

	return EFalse;

	}

RL2CapErtmUnacknowledgedIFrames::RL2CapErtmUnacknowledgedIFrames()

 :	iFrameList(_FOFF(HIFramePDU, iLink))

	{

	LOG_FUNC

	iFrameIndex.Reset();

	}

void RL2CapErtmUnacknowledgedIFrames::Close()

	{

	LOG_FUNC

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

	TDblQueIter<HIFramePDU> unackedIter(iFrameList);

	HIFramePDU* pdu;

	while((pdu = unackedIter++) != NULL)

		{

		Remove(*pdu);

		if (!pdu->IsAwaitingHciCompletion())

			{

			delete pdu;

			}

		else

			{

			// Will delete itself on HCI completion.

			pdu->DeregisterPduOwner();

			}

		}

	}

CL2CapErtmDataTransmitter* CL2CapErtmDataTransmitter::NewL(CL2CapEnhancedReTxController& aController)

	{

	LOG_STATIC_FUNC

	return new (ELeave) CL2CapErtmDataTransmitter(aController);

	}

CL2CapErtmDataTransmitter::~CL2CapErtmDataTransmitter()

	{

	LOG_FUNC

	iUnackedIFrames.Close();

	}

CL2CapErtmDataTransmitter::CL2CapErtmDataTransmitter(CL2CapEnhancedReTxController& aController)

 :	iController(aController),

	iNextTxSeq(0),

	iExpectedAckSeq(0),

	iRemoteBusy(EFalse),

	iSRejActioned(EFalse),

	iSRejSaveReqSeq(0),

	iWaitAckStatePending(EFalse),

	iInWaitAckState(EFalse)

	{

	LOG_FUNC

	}

void CL2CapErtmDataTransmitter::HandleIncomingIFrame(RMBufChain& aIFrame)

	{

	LOG_FUNC

	LOG2(_L("NextTxSeq=%d, ExpectedAckSeq = %d"), iNextTxSeq, iExpectedAckSeq)

	const TUint8 reqSeq = HIFramePDU::ReqSeqNumber(aIFrame);

	const TBool final = HIFramePDU::FinalBit(aIFrame);

	HandleReqSeqAck(reqSeq);

	if (final)

		{

		HandleFinalAck();

		}

	}

void CL2CapErtmDataTransmitter::HandleIncomingSFrameL(RMBufChain& aSFrame)

	{

	LOG_FUNC

	LOG2(_L("NextTxSeq=%d, ExpectedAckSeq = %d"), iNextTxSeq, iExpectedAckSeq)

	const TUint8 reqSeq = HSFramePDU::ReqSeqNumber(aSFrame);

	const TSupervisoryFunction function = HSFramePDU::SupervisoryFunction(aSFrame);

	const TBool final = HSFramePDU::FinalBit(aSFrame);

	const TBool poll = HSFramePDU::PollBit(aSFrame);

	// An S-Frame [SREJ] with the POLL=0 does NOT acknowledge any I-Frames.

	if (!(function == ESelectiveReject && !poll))

		{

		HandleReqSeqAck(reqSeq);

		}

	else // SREJ [P=0]

		{

		// The remote detected packet loss itself, so restart the retransmission timer -

		// - SREJ -> I-Frame -> RR roundtrip time is too long and would almost always

		// cause it to expire if we didn't (most probably unnecessarily).

		if (TimerMan().IsAckTimerRunning())

			{

			TimerMan().StartAckTimer();

			}

		}

	switch (function)

		{

		case EReceiverNotReady:

			iRemoteBusy = ETrue;

			TimerMan().StopAckTimer();

			if (final && iInWaitAckState)

				{

				iInWaitAckState = EFalse;

				// We'll start retransmitting when we get RR from the peer. 

				}

			break;

		case EReceiverReady:

			if (final)

				{

				HandleFinalAck();

				}

			// iRemoteBusy cleared at the bottom of the function.

			break;

		case EReject:

			// A REJ should be ignored if we're in WAIT_ACK and the Final bit in the

			// frame is 0. We'll receive a Final packet in a while anyway, and that

			// packet is guaranteed to contain the same ReqSeq, because the remote

			// can't acknowledge anything new until we retransmit, and we won't

			// retransmit until we receive the Final ack.

			if (!(iInWaitAckState && !final))

				{

				RetransmitUnackedIFrames();

				TimerMan().StopAckTimer();

				// The timer will be started again when the first retransmitted I-Frame

				// is completed.

				}

			if (final)

				{

				HandleFinalAck();

				}

			// iRemoteBusy cleared at the bottom of the function.

			break;

		case ESelectiveReject:

			HandleIncomingSRejL(aSFrame);

			// iRemoteBusy cleared at the bottom of the function.

			break;

		}

	// Anything other than RNR means remote isn't busy anymore.

	if (iRemoteBusy && function != EReceiverNotReady)

		{

		__ASSERT_DEBUG(!TimerMan().IsAckTimerRunning(), Panic(EL2CAPAckTimerRunningWhenRemoteBusy));

		iRemoteBusy = EFalse;

		if (!iUnackedIFrames.IsEmpty())

			{

			TimerMan().StartAckTimer();

			}

		LOG(_L("Exitted RemoteBusy condition"))

		}

	}

void CL2CapErtmDataTransmitter::HandleIncomingSRejL(RMBufChain& aSRejFrame)

	{

	LOG_FUNC

	const TUint8 reqSeq = HSFramePDU::ReqSeqNumber(aSRejFrame);

	const TSupervisoryFunction function = HSFramePDU::SupervisoryFunction(aSRejFrame);

	const TBool final = HSFramePDU::FinalBit(aSRejFrame);

	const TBool poll = HSFramePDU::PollBit(aSRejFrame);

	HIFramePDU* requestedIFrame = iUnackedIFrames[reqSeq];

	// If the ReqSeq is invalid then it should've been caught earlier.

	__ASSERT_ALWAYS(requestedIFrame != NULL, Panic(EL2CAPSRejReqSeqNotOnUnackedList));

	if (poll)

		{

		// Set the Final bit directly here to make sure it's in the right frame.

		requestedIFrame->SetFinalBit(ETrue);

		SendOrPendL(*requestedIFrame);

		if (iController.IsPollOutstanding())

			{

			iSRejActioned = ETrue;

			iSRejSaveReqSeq = reqSeq;

			// If Poll is set, then Final must be 0, so we don't have to check for it.

			}

		} // Poll = 1

	else

		{

		// If peer is in SREJ_SENT when it receives the Poll, then it needs to respond

		// with an SREJ[F=1]. This SREJ may contain a ReqSeq it has already sent in the

		// previous SREJ[F=0], and we need to guard against this on our side, so that we

		// don't retransmit a packet twice - it could cause the channel to be closed, as

		// the second copy would be outside of peer's receive window and thus invalid.

		TBool duplicateWithFinal = EFalse;

		if (iController.IsPollOutstanding())

			{

			if (final)

				{

				if (iSRejActioned && iSRejSaveReqSeq == reqSeq)

					{

					// Peer has sent us a SREJ F=0 for the same frame before, need to

					// ignore this SREJ.

					duplicateWithFinal = ETrue;

					LOG1(_L("Received a duplicate SREJ with ReqSeq=%d with Final=1, will drop it"),

						 reqSeq)

					}

				if (!iUnackedIFrames.IsEmpty() && !iRemoteBusy)

					{

					TimerMan().StartAckTimer();

					}

				iSRejActioned = EFalse;

				iInWaitAckState = EFalse;

				// Don't go into ERetransmitAllUnackedFrames, even in WAIT_ACK:

				// - an SREJ[P=0,F=1] frame doesn't carry an acking ReqSeq, so we

				//   wouldn't know at which frame we should start the retransmission;

				// - the peer has just SREJed some I-Frames so there's a chance

				//   we're already retransmitting the stuff we timed out on.

				//   If we're not (which is possible if acknowledgments from the

				//   peer have been lost), then we'll need to wait for the

				//   next Retransmission Timeout and then retransmit (unless we

				//   we hit remote being in SREJ_SENT again, rinse-and-repeat then).

				OutgoingQ().SendPendingRetransmitIFramesL();

				}

			else

				{

				iSRejActioned = ETrue;

				iSRejSaveReqSeq = reqSeq;

				}

			} // waiting for final ack

		if (!duplicateWithFinal)

			{

			// Clean the F-bit in case it was set during previous transmission.

			requestedIFrame->SetFinalBit(EFalse);

			SendOrPendL(*requestedIFrame);

			}

		} // Poll bit = 0

	}

void CL2CapErtmDataTransmitter::HciCompletedIFrame(HIFramePDU& aIFrame)

	{

	LOG_FUNC

	if (aIFrame.Acked())

		{

		__ASSERT_DEBUG(iUnackedIFrames[aIFrame.TxSeqNumber()] == NULL,

					   Panic(EL2CAPAckedTxSeqFoundOnUnackedList));

		// This condition will happen extremely rarely or none at all on real hardware.

		// It does happen on the emulator with USB HCTL.

		LOG1(_L("I-Frame %d has been acknowledged before HCI completion"), aIFrame.TxSeqNumber())

		// Frame has been already sent and acked - skip putting it on the Send queue, just delete.

		delete &aIFrame;

		// We'll start the retransmission timer the first time a frame that hasn't been acked is

		// completed (the else branch below). 

		}

	else

		{

		__ASSERT_DEBUG(iUnackedIFrames[aIFrame.TxSeqNumber()] != NULL,

					   Panic(EL2CAPUnackedTxSeqNotFoundOnUnackedList));

		if (!TimerMan().IsAckTimerRunning() && !iRemoteBusy)

			{

			// It's the first frame sent out after a period of silence.

			// ... or it's the first frame of a retransmission.

			// ... or we can has a bug (LOL that's impossible, I coded this myself).

			TimerMan().StartAckTimer();

			}

		}

	}

void CL2CapErtmDataTransmitter::AckTimerExpired()

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iUnackedIFrames.IsEmpty(), Panic(EL2CAPAckTimerExpiryWithoutPDUToSupervise));

	// Signal to GetPdu that we need to enter WAIT_ACK.

	iWaitAckStatePending = ETrue;

	iController.NotifyMuxerOfPdusToSendIfHaveSome();

	}

HIFramePDU* CL2CapErtmDataTransmitter::GetIFrameToSendL()

	{

	LOG_FUNC

	HIFramePDU* pduToSend = NULL;

	// Can't send data in WAIT_ACK.

	// We send data in RemoteBusy until the window fills up, but with the ack timer stopped.

	if (!iInWaitAckState)

		{

		if (iUnackedIFrames[iNextTxSeq] != NULL)

			{

			// Rreceived a REJ or Ack timer expired.

			pduToSend = iUnackedIFrames[iNextTxSeq];

			if (pduToSend->IsAwaitingHciCompletion())

				{

				pduToSend = NULL;

				}

			else

				{

				// In case it was set for the previous transmission. 

				pduToSend->SetFinalBit(EFalse);

				}

			}

		else if (HaveSpaceInOutgoingWindow())

			{

			pduToSend = static_cast<HIFramePDU*>(iController.SDUQueue().GetPDU());

			if (pduToSend != NULL)

				{

				pduToSend->SetTxSeqNumber(iNextTxSeq);

				// It's a new frame that hasn't been sent before, so we need to append it to the

				// unacked list. Once put on the list, it should never get delinked from it until

				// acknowledged, even during retransmissions.

				__ASSERT_DEBUG(iUnackedIFrames[iNextTxSeq] == NULL, Panic(EL2CAPNewTxSeqFoundOnUnackedList));

				iUnackedIFrames.Append(*pduToSend);

				}

			}

		if (pduToSend != NULL)

			{

			iNextTxSeq = Mod64(iNextTxSeq + 1);

			}

		} // state != WAIT_ACK (can transmit data)

	return pduToSend;

	}

TBool CL2CapErtmDataTransmitter::HaveSpaceInOutgoingWindow() const

	{

	LOG_FUNC

	TBool canSend = ETrue;

	if (Mod64(iNextTxSeq - iExpectedAckSeq) >= iController.Config().TXWindowSize())

		{

		canSend = EFalse;

		}

	return canSend;

	}

void CL2CapErtmDataTransmitter::HandleFinalAck()

	{