1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <bluetooth/logger.h>

    17 #include "btsockettimer.h"

    18 #include "L2CapEnhancedDataController.h"

    19 #include "L2CapSDUQueue.h"

    20 #include "l2signalmgr.h"

    21 #include "l2util.h"

    22 #include "L2CapDebugControlInterface.h"

    23 

    24 #ifdef __FLOG_ACTIVE

    25 _LIT8(KLogComponent, LOG_COMPONENT_L2CAP_DATA_CONTROLLER);

    26 #endif

    27 

    28 using namespace L2CapDataUtils;

    29 

    30 

    31 CL2CapStreamingController::CL2CapStreamingController(TL2CAPPort aLocalCID,

    32 													 TL2CAPPort aRemoteCID,

    33 													 CL2CAPMux& aMuxer,

    34 													 CL2CapSDUQueue& aSDUQueue,

    35 													 TL2CapDataControllerConfig* aConfig)

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

    37 	{

    38 	LOG_FUNC

    39 	}

    40 

    41 CL2CapStreamingController::~CL2CapStreamingController()

    42 	{

    43 	LOG_FUNC

    44 	}

    45 

    46 void CL2CapStreamingController::ProcessFlushTimerExpiry()

    47 	{

    48 	LOG_FUNC

    49 	__ASSERT_DEBUG(EFalse, Panic(EL2CAPFlushingNotReallySupported));

    50 	}

    51 

    52 HL2CapPDU* CL2CapStreamingController::GetPduL()

    53 	{

    54 	LOG_FUNC

    55 	// This is called from the signal manager.

    56 	HL2CapPDU* pduToSend = NULL;

    57 

    58 	pduToSend = iSDUQueue.GetPDU();

    59 

    60 	if(pduToSend)

    61 		{

    62 		pduToSend->DeliverOutgoingPDU(*this);

    63 		}

    64 	

    65     if (iSDUQueue.HavePDUToSend())

    66         {

    67         iMuxer.PDUAvailable();

    68         }

    69 	

    70 	return pduToSend;

    71 	}

    72 

    73 void CL2CapStreamingController::HandleIncomingIFrameL(RMBufChain& aIFrame)

    74 	{

    75 	LOG_FUNC

    76 

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

    78 	

    79 	if (txSeq != iExpectedTxSeq)

    80 		{

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

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

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

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

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

    86 		iSDUQueue.FlushCurrentlyAssembledSdu();

    87 		}

    88 

    89 	if (iSDUQueue.IsIncomingQueueFull())

    90 		{

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

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

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

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

    95 		iSDUQueue.FlushOldestIncomingSdu();

    96 		}

    97 	LEAVEIFERRORL(iSDUQueue.PutIFramePDU(aIFrame));

    98 

    99 	iExpectedTxSeq = Mod64(txSeq + 1);

   100 

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

   102 	aIFrame.Free();

   103 	}

   104 

   105 TInt CL2CapStreamingController::HandleOutgoingIFrame(HIFramePDU* aIFrame)

   106 	{

   107 	LOG_FUNC

   108 	aIFrame->SetPDUCID(iRemoteCID);

   109 	aIFrame->SetTxSeqNumber(iNextTxSeq);

   110 	iNextTxSeq = Mod64(iNextTxSeq + 1);

   111 

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

   113 

   114 	aIFrame->CalculateAndSetFCS();

   115 

   116 	return KErrNone;

   117 	}

   118 

   119 void CL2CapStreamingController::HandlePduSendComplete(HL2CapPDU& aPdu)

   120 	{

   121 	LOG_FUNC

   122 	delete &aPdu;

   123 	}

   124 

   125 void CL2CapStreamingController::HandlePduSendError(HL2CapPDU& aPdu)

   126 	{

   127 	LOG_FUNC

   128 	delete &aPdu;

   129 	}

   130 

   131 

   132 RL2CapErtmTimerManager::RL2CapErtmTimerManager(CL2CapEnhancedReTxController& aClient)

   133  :	RL2CapRetransmissionModeTimerManager(aClient),

   134  	iLocalBusyDelayTimerRunning(EFalse)

   135 	{

   136 	LOG_FUNC

   137 	}

   138 

   139 void RL2CapErtmTimerManager::Close()

   140 	{

   141 	LOG_FUNC

   142 	StopLocalBusyDelayTimer();

   143 	RL2CapRetransmissionModeTimerManager::Close();

   144 	}

   145 

   146 void RL2CapErtmTimerManager::StartLocalBusyDelayTimer()

   147 	{

   148 	LOG_FUNC

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

   150 	__ASSERT_DEBUG(!iLocalBusyDelayTimerRunning, Panic(EL2CAPInvalidDataControllerTimerState));

   151 

   152 	if (!iLocalBusyDelayTimerRunning)

   153 		{

   154 		TCallBack cb(LocalBusyDelayTimerExpired, this);

   155 		iLocalBusyDelayTimerEntry.Set(cb);

   156 	

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

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

   159 							 iLocalBusyDelayTimerEntry);

   160 		iLocalBusyDelayTimerRunning = ETrue;

   161 		}

   162 	}

   163 

   164 void RL2CapErtmTimerManager::StopLocalBusyDelayTimer()

   165 	{

   166 	LOG_FUNC

   167 	if (iLocalBusyDelayTimerRunning)

   168 		{

   169 		BTSocketTimer::Remove(iLocalBusyDelayTimerEntry);

   170 		iLocalBusyDelayTimerRunning = EFalse;

   171 		}

   172 	}

   173 

   174 void RL2CapErtmTimerManager::HandleLocalBusyDelayTimerExpired()

   175 	{

   176 	LOG_FUNC

   177 	iLocalBusyDelayTimerRunning = EFalse;

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

   179 	}

   180 

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

   182 	{

   183 	LOG_STATIC_FUNC

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

   185 	timerMan->HandleLocalBusyDelayTimerExpired();

   186 	return EFalse;

   187 	}

   188 

   189 

   190 

   191 RL2CapErtmUnacknowledgedIFrames::RL2CapErtmUnacknowledgedIFrames()

   192  :	iFrameList(_FOFF(HIFramePDU, iLink))

   193 	{

   194 	LOG_FUNC

   195 	iFrameIndex.Reset();

   196 	}

   197 

   198 void RL2CapErtmUnacknowledgedIFrames::Close()

   199 	{

   200 	LOG_FUNC

   201 

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

   203 	TDblQueIter<HIFramePDU> unackedIter(iFrameList);

   204 	HIFramePDU* pdu;

   205 

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

   207 		{

   208 		Remove(*pdu);

   209 		if (!pdu->IsAwaitingHciCompletion())

   210 			{

   211 			delete pdu;

   212 			}

   213 		else

   214 			{

   215 			// Will delete itself on HCI completion.

   216 			pdu->DeregisterPduOwner();

   217 			}

   218 		}

   219 	}

   220 

   221 

   222 CL2CapErtmDataTransmitter* CL2CapErtmDataTransmitter::NewL(CL2CapEnhancedReTxController& aController)

   223 	{

   224 	LOG_STATIC_FUNC

   225 	return new (ELeave) CL2CapErtmDataTransmitter(aController);

   226 	}

   227 

   228 CL2CapErtmDataTransmitter::~CL2CapErtmDataTransmitter()

   229 	{

   230 	LOG_FUNC

   231 	iUnackedIFrames.Close();

   232 	}

   233 

   234 CL2CapErtmDataTransmitter::CL2CapErtmDataTransmitter(CL2CapEnhancedReTxController& aController)

   235  :	iController(aController),

   236 	iNextTxSeq(0),

   237 	iExpectedAckSeq(0),

   238 	iRemoteBusy(EFalse),

   239 	iSRejActioned(EFalse),

   240 	iSRejSaveReqSeq(0),

   241 	iWaitAckStatePending(EFalse),

   242 	iInWaitAckState(EFalse)

   243 	{

   244 	LOG_FUNC

   245 	}

   246 

   247 void CL2CapErtmDataTransmitter::HandleIncomingIFrame(RMBufChain& aIFrame)

   248 	{

   249 	LOG_FUNC

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

   251 

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

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

   254 

   255 	HandleReqSeqAck(reqSeq);

   256 	if (final)

   257 		{

   258 		HandleFinalAck();

   259 		}

   260 	}

   261 

   262 void CL2CapErtmDataTransmitter::HandleIncomingSFrameL(RMBufChain& aSFrame)

   263 	{

   264 	LOG_FUNC

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

   266 

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

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

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

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

   271 

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

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

   274 		{

   275 		HandleReqSeqAck(reqSeq);

   276 		}

   277 	else // SREJ [P=0]

   278 		{

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

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

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

   282 		if (TimerMan().IsAckTimerRunning())

   283 			{

   284 			TimerMan().StartAckTimer();

   285 			}

   286 		}

   287 

   288 	switch (function)

   289 		{

   290 		case EReceiverNotReady:

   291 			iRemoteBusy = ETrue;

   292 			TimerMan().StopAckTimer();

   293 			if (final && iInWaitAckState)

   294 				{

   295 				iInWaitAckState = EFalse;

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

   297 				}

   298 			break;

   299 	

   300 		case EReceiverReady:

   301 			if (final)

   302 				{

   303 				HandleFinalAck();

   304 				}

   305 			// iRemoteBusy cleared at the bottom of the function.

   306 			break;

   307 	

   308 		case EReject:

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

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

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

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

   313 			// retransmit until we receive the Final ack.

   314 			if (!(iInWaitAckState && !final))

   315 				{

   316 				RetransmitUnackedIFrames();

   317 	

   318 				TimerMan().StopAckTimer();

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

   320 				// is completed.

   321 				}

   322 	

   323 			if (final)

   324 				{

   325 				HandleFinalAck();

   326 				}

   327 			// iRemoteBusy cleared at the bottom of the function.

   328 			break;

   329 			

   330 		case ESelectiveReject:

   331 			HandleIncomingSRejL(aSFrame);

   332 			// iRemoteBusy cleared at the bottom of the function.

   333 			break;

   334 		}

   335 

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

   337 	if (iRemoteBusy && function != EReceiverNotReady)

   338 		{

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

   340 		iRemoteBusy = EFalse;

   341 		if (!iUnackedIFrames.IsEmpty())

   342 			{

   343 			TimerMan().StartAckTimer();

   344 			}

   345 		LOG(_L("Exitted RemoteBusy condition"))

   346 		}

   347 	}

   348 

   349 void CL2CapErtmDataTransmitter::HandleIncomingSRejL(RMBufChain& aSRejFrame)

   350 	{

   351 	LOG_FUNC

   352 

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

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

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

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

   357 

   358 	HIFramePDU* requestedIFrame = iUnackedIFrames[reqSeq];

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

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

   361 

   362 	if (poll)

   363 		{

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

   365 		requestedIFrame->SetFinalBit(ETrue);

   366 		SendOrPendL(*requestedIFrame);

   367 

   368 		if (iController.IsPollOutstanding())

   369 			{

   370 			iSRejActioned = ETrue;

   371 			iSRejSaveReqSeq = reqSeq;

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

   373 			}

   374 		} // Poll = 1

   375 	else

   376 		{

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

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

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

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

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

   382 		TBool duplicateWithFinal = EFalse;

   383 

   384 		if (iController.IsPollOutstanding())

   385 			{

   386 			if (final)

   387 				{

   388 				if (iSRejActioned && iSRejSaveReqSeq == reqSeq)

   389 					{

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

   391 					// ignore this SREJ.

   392 					duplicateWithFinal = ETrue;

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

   394 						 reqSeq)

   395 					}

   396 

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

   398 					{

   399 					TimerMan().StartAckTimer();

   400 					}

   401 

   402 				iSRejActioned = EFalse;

   403 				iInWaitAckState = EFalse;

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

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

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

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

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

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

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

   411 				//   next Retransmission Timeout and then retransmit (unless we

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

   413 				OutgoingQ().SendPendingRetransmitIFramesL();

   414 				}

   415 			else

   416 				{

   417 				iSRejActioned = ETrue;

   418 				iSRejSaveReqSeq = reqSeq;

   419 				}

   420 			} // waiting for final ack

   421 

   422 		if (!duplicateWithFinal)

   423 			{

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

   425 			requestedIFrame->SetFinalBit(EFalse);

   426 			SendOrPendL(*requestedIFrame);

   427 			}

   428 		} // Poll bit = 0

   429 	}

   430 

   431 void CL2CapErtmDataTransmitter::HciCompletedIFrame(HIFramePDU& aIFrame)

   432 	{

   433 	LOG_FUNC

   434 	if (aIFrame.Acked())

   435 		{

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

   437 					   Panic(EL2CAPAckedTxSeqFoundOnUnackedList));

   438 

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

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

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

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

   443 		delete &aIFrame;

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

   445 		// completed (the else branch below). 

   446 		}

   447 	else

   448 		{

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

   450 					   Panic(EL2CAPUnackedTxSeqNotFoundOnUnackedList));

   451 

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

   453 			{

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

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

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

   457 			TimerMan().StartAckTimer();

   458 			}

   459 		}

   460 	}

   461 

   462 void CL2CapErtmDataTransmitter::AckTimerExpired()

   463 	{

   464 	LOG_FUNC

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

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

   467 	iWaitAckStatePending = ETrue;

   468 	iController.NotifyMuxerOfPdusToSendIfHaveSome();

   469 	}

   470 

   471 HIFramePDU* CL2CapErtmDataTransmitter::GetIFrameToSendL()

   472 	{

   473 	LOG_FUNC

   474 	HIFramePDU* pduToSend = NULL;

   475 

   476 	// Can't send data in WAIT_ACK.

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

   478 	if (!iInWaitAckState)

   479 		{

   480 		if (iUnackedIFrames[iNextTxSeq] != NULL)

   481 			{

   482 			// Rreceived a REJ or Ack timer expired.

   483 			pduToSend = iUnackedIFrames[iNextTxSeq];

   484 			if (pduToSend->IsAwaitingHciCompletion())

   485 				{

   486 				pduToSend = NULL;

   487 				}

   488 			else

   489 				{

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

   491 				pduToSend->SetFinalBit(EFalse);

   492 				}

   493 			}

   494 		else if (HaveSpaceInOutgoingWindow())

   495 			{

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

   497 			if (pduToSend != NULL)

   498 				{

   499 				pduToSend->SetTxSeqNumber(iNextTxSeq);

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

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

   502 				// acknowledged, even during retransmissions.

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

   504 				iUnackedIFrames.Append(*pduToSend);

   505 				}

   506 			}

   507 

   508 		if (pduToSend != NULL)

   509 			{

   510 			iNextTxSeq = Mod64(iNextTxSeq + 1);

   511 			}

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

   513 	return pduToSend;

   514 	}

   515 

   516 TBool CL2CapErtmDataTransmitter::HaveSpaceInOutgoingWindow() const

   517 	{

   518 	LOG_FUNC

   519 	TBool canSend = ETrue;

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

   521 		{

   522 		canSend = EFalse;

   523 		}

   524 	return canSend;

   525 	}

   526 

   527 void CL2CapErtmDataTransmitter::HandleFinalAck()

   528 	{

   529 	LOG_FUNC

   530 

   531 	if (iInWaitAckState)

   532 		{

   533 		iInWaitAckState = EFalse;

   534 		RetransmitUnackedIFrames();

   535 		}

   536 

   537 	// Whether it was WAIT_ACK or WAIT_F, Ack timer was stopped because Monitor timer

   538 	// was running.

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

   540 		{

   541 		TimerMan().StartAckTimer();

   542 		}

   543 	}

   544 

   545 void CL2CapErtmDataTransmitter::HandleReqSeqAck(TUint8 aReqSeq)

   546 	{

   547 	LOG_FUNC

   548 

   549 	__ASSERT_DEBUG((aReqSeq == iExpectedAckSeq) || !iUnackedIFrames.IsEmpty(),

   550 				   Panic(EL2CAPUnacknowledgedPdusMissingFromList));

   551 

   552 	// See if any I-Frames have been acknowledged by the peer, slide the send window,

   553 	// send new data if window space is now available, restart ack timer.

   554 

   555 	if (!iUnackedIFrames.IsEmpty() && aReqSeq != iExpectedAckSeq)

   556 		{

   557 		const TBool wasWindowFull = !HaveSpaceInOutgoingWindow();

   558 

   559 		TDblQueIter<HIFramePDU> iter(iUnackedIFrames.Iterator());

   560 		HIFramePDU* pduPtr;

   561 		TBool ackedPDUs = EFalse;

   562 

   563 		__ASSERT_DEBUG(iUnackedIFrames.First()->TxSeqNumber() == iExpectedAckSeq,

   564 					   Panic(EL2CAPOldestUnackedPduTxSeqNotMatchingExpectedAck));

   565 

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

   567 			{

   568 			if (InWindow(pduPtr->TxSeqNumber(), iExpectedAckSeq, Mod64(aReqSeq - 1)))

   569 				{

   570 				iUnackedIFrames.Remove(*pduPtr);

   571 				pduPtr->SetAcked(ETrue);

   572 				ackedPDUs = ETrue;

   573 

   574 				if (!pduPtr->IsAwaitingHciCompletion())

   575 					{

   576 					delete pduPtr;

   577 					}

   578 				else

   579 					{

   580 					LOG1(_L("I-Frame %d has been acknowledged before HCI completion!"),

   581 						 pduPtr->TxSeqNumber())

   582 					// Will delete itself on HCI completion.

   583 					pduPtr->DeregisterPduOwner();

   584 					}

   585 				} // pdu in acked window

   586 			else

   587 				{

   588 				// The queue is sorted chronologically - the head is always the oldest PDU.

   589 				// First PDU outside of the acknowledged window means we can stop the loop.

   590 				break;

   591 				}

   592 			}

   593 

   594 		if (iUnackedIFrames.IsEmpty())

   595 			{

   596 			TimerMan().StopAckTimer();

   597 			}

   598 		else if (ackedPDUs && !iRemoteBusy)

   599 			{

   600 			// This will actually REstart the timer.

   601 			TimerMan().StartAckTimer();

   602 			}

   603 

   604 		iExpectedAckSeq = aReqSeq;

   605 		LOG1(_L("New ExpectedAckSeq=%d"), aReqSeq)

   606 

   607 		if (iController.IsOutgoingDataPathClosing() && iUnackedIFrames.IsEmpty())

   608 			{

   609 			iController.SignalOutgoingDataDeliveredToSduQ();

   610 			}

   611 		}

   612 	}

   613 

   614 void CL2CapErtmDataTransmitter::RetransmitUnackedIFrames()

   615 	{

   616 	LOG_FUNC

   617 	LOG1(_L("Setting NextTxSeq to ExpectedAckSeq = %d"), iExpectedAckSeq)

   618 	iNextTxSeq = iExpectedAckSeq;

   619 	// This is important when exiting WAIT_ACK: forget about all I-Frames SREJ-requested

   620 	// by the peer. We'll retransmit them as part of the whole bunch. And we can't transmit

   621 	// the same frame twice, which would happen had we left these hanging around.

   622 	OutgoingQ().CancelPendingRetransmitIFrames();

   623 	}

   624 

   625 

   626 TL2CapErtmMissingTxSeqs::TL2CapErtmMissingTxSeqs()

   627  :	iNumMissingTxSeqs(0),

   628 	iExpectedRecvIdx(0),

   629 	iResendIdx(0)

   630 	{}

   631 

   632 TBool TL2CapErtmMissingTxSeqs::IsTxSeqOnTheList(TUint8 aTxSeq) const

   633 	{

   634 	TBool found = EFalse;

   635 	for (TInt i = 0; i < iNumMissingTxSeqs && !found; i++)

   636 		{

   637 		if (iMissingTxSeqs[i] == aTxSeq)

   638 			{

   639 			found = ETrue;

   640 			}

   641 		}

   642 	return found;

   643 	}

   644 

   645 TBool TL2CapErtmMissingTxSeqs::ReceivedTxSeq(TUint8 aTxSeq)

   646 	{

   647 	LOG_FUNC

   648 	TBool resendNeeded = EFalse;

   649 	if (iMissingTxSeqs[iExpectedRecvIdx] == aTxSeq)

   650 		{

   651 		// This is the only path possible with the default of max. 1 SREJ at a time.

   652 		iExpectedRecvIdx++;

   653 		}

   654 	else

   655 		{

   656 		// Should only fall here with the experimental KMaxSRejsInFlight > 1

   657 		__ASSERT_DEBUG(KMaxSRejsInFlight > 1, Panic(EL2CAPMultiSRejPathHitWhenNotSoConfigured));

   658 

   659 		LOG1(_L("SREJ resend path hit, TxSeq=%d"), aTxSeq);

   660 #ifdef __FLOG_ACTIVE

   661 		Log();

   662 #endif

   663 		resendNeeded = ETrue;

   664 

   665 		// General idea: reshuffle the array to maintain chronological ordering, in which

   666 		// we expect the requested I-Frames to come through. All I-Frames between iExpectedRecvIdx

   667 		// and the one we're processing now are considered to have been lost and will be

   668 		// re-requested, so we need to move them to the very end of the list.

   669 		//

   670 		// E.g.:

   671 		// 0. Current list is 6 elements (iNumMissingTxSeqs == 6):

   672 		//     32 33 | 20 21 45 46

   673 		//   32 and 33 have been received (iExpectedRecvIdx == 2), we're still waiting for the

   674 		//   rest.

   675 		// 1. 45 comes through, we fall here. We need to move it to right after 33 and increase

   676 		//   iExpectedRecvIdx:

   677 		//     32 33 45 | 20 21 46

   678 		// 2. But the order in the array implied that 20 & 21 were requested before 45 and

   679 		//   haven't come through, so they must have been lost (remote has to respond to SREJs

   680 		//   in order they are sent). Ergo, we need to resend the SREJs for 20 and 21, which in

   681 		//   turn means we're now expecting them after all other frames, so finally:

   682 		//     32 33 45 | 46 20 21

   683 

   684 		// Find the index of the received TxSeq.

   685 		TInt receivedIdx = iExpectedRecvIdx;

   686 		while (iMissingTxSeqs[receivedIdx] != aTxSeq && receivedIdx < iNumMissingTxSeqs)

   687 			{

   688 			receivedIdx++;

   689 			}

   690 

   691 		const TInt numToResend = receivedIdx - iExpectedRecvIdx;

   692 		LOG2(_L("Last received = %d, num SREJs to resend = %d"),

   693 			 (iExpectedRecvIdx > 0 ? iMissingTxSeqs[iExpectedRecvIdx] : -1), numToResend);

   694 

   695 		// To maintain the partitioning of the array we need to move the received

   696 		// TxSeq towards the < iExpectedRecvIdx half, over the to-be-SREJed again TxSeqs.

   697 		// (step 1 in the example)

   698 		while (receivedIdx > iExpectedRecvIdx)

   699 			{

   700 			TUint8 tmp = iMissingTxSeqs[receivedIdx - 1];

   701 			iMissingTxSeqs[receivedIdx - 1] = iMissingTxSeqs[receivedIdx];

   702 			iMissingTxSeqs[receivedIdx] = tmp;

   703 			receivedIdx--;

   704 			}

   705 		iExpectedRecvIdx++;

   706 

   707 		// Now move the TxSeqs to be SREJed again onto the end of the list to maintain correct

   708 		// ordering (step 2 in the example).

   709 		// Note: this could be optimized a bit at least theoretically down to O(1) by

   710 		// copying the TxSeqs to re-SREJ out to a temp array, then moving the ones currently

   711 		// at the end, and then copying the ones from the temp array back in at the end.

   712 		// Note 2: this is the first time I've used bubble sort in my carreer. Honest.

   713 		for (TInt i = 0; i < numToResend; i++)

   714 			{

   715 			for (TInt bubble = iExpectedRecvIdx; bubble < iNumMissingTxSeqs - 1; bubble++)

   716 				{

   717 				TUint8 tmp = iMissingTxSeqs[bubble];

   718 				iMissingTxSeqs[bubble] = iMissingTxSeqs[bubble + 1];

   719 				iMissingTxSeqs[bubble + 1] = tmp;

   720 				}

   721 			}

   722 

   723 		// Store the index of the beginning of the TxSeqs to re-request, they will be pulled

   724 		// in an outer loop until the index reaches iNumMissingTxSeqs.

   725 		iResendIdx = iNumMissingTxSeqs - numToResend;

   726 #ifdef __FLOG_ACTIVE

   727 		Log();

   728 #endif

   729 		}

   730 	return resendNeeded;

   731 	}

   732 

   733 #ifdef __FLOG_ACTIVE

   734 void TL2CapErtmMissingTxSeqs::Log()

   735 	{

   736 	LOG3(_L("ExpectedRecvIdx=%d, ResendIdx=%d, NumMissingTxSeqs=%d"),

   737 		 iExpectedRecvIdx, iResendIdx, iNumMissingTxSeqs);

   738 

   739 	TBuf<256> buf;

   740 	for (TInt i = 0; i < iNumMissingTxSeqs; i++)

   741 		{

   742 		buf.AppendFormat(_L("%d "), iMissingTxSeqs[i]);

   743 		}

   744 	LOG1(_L("%S"), &buf)

   745 	}

   746 #endif

   747 

   748 

   749 TL2CapErtmReceiverStateBase::TL2CapErtmReceiverStateBase(CL2CapErtmDataReceiver& aReceiver)

   750  : iReceiver(aReceiver)

   751 	{

   752 	LOG_FUNC

   753 	}

   754 

   755 void TL2CapErtmReceiverStateBase::EnterL(RMBufChain* /*aIFrame*/)

   756 	{

   757 	LOG_FUNC

   758 	}

   759 

   760 void TL2CapErtmReceiverStateBase::ExitL()

   761 	{

   762 	LOG_FUNC

   763 	}

   764 

   765 TBool TL2CapErtmReceiverStateBase::IsLocalBusySupported() const

   766 	{

   767 	LOG_FUNC

   768 	return EFalse;

   769 	}

   770 

   771 

   772 TL2CapErtmReceiverStateRecv::TL2CapErtmReceiverStateRecv(CL2CapErtmDataReceiver& aReceiver)

   773  : TL2CapErtmReceiverStateBase(aReceiver)

   774 	{

   775 	LOG_FUNC

   776 	}

   777 

   778 void TL2CapErtmReceiverStateRecv::EnterL(RMBufChain* /*aIFrame*/)

   779 	{

   780 	LOG_FUNC

   781 

   782 	if (iReceiver.IsIncomingSduQFull())

   783 		{

   784 		// We may have transitioned from REJ_SENT or SREJ_SENT, which don't allow LocalBusy.

   785 		// We can enter it now.

   786 		iReceiver.TimerMan().StopLocalBusyDelayTimer();

   787 		iReceiver.UpdateLocalBusyStatusL();

   788 		}

   789 

   790 	__ASSERT_DEBUG((iReceiver.IsIncomingSduQFull() && iReceiver.LocalBusy()) ||

   791 				   (!iReceiver.IsIncomingSduQFull() && !iReceiver.LocalBusy()) ||

   792 				   (iReceiver.IsIncomingSduQFull() && iReceiver.TimerMan().IsLocalBusyDelayTimerRunning()) ||

   793 				   (!iReceiver.IsIncomingSduQFull() && !iReceiver.TimerMan().IsLocalBusyDelayTimerRunning()),

   794 				   Panic(EL2CapSduQAndLocalBusyStateInconsistent));

   795 	}

   796 

   797 void TL2CapErtmReceiverStateRecv::HandleIncomingIFrameL(RMBufChain& aIFrame)

   798 	{

   799 	LOG_FUNC

   800 	__ASSERT_DEBUG((iReceiver.IsIncomingSduQFull() && iReceiver.LocalBusy()) ||

   801 				   (!iReceiver.IsIncomingSduQFull() && !iReceiver.LocalBusy()) ||

   802 				   (iReceiver.IsIncomingSduQFull() && iReceiver.TimerMan().IsLocalBusyDelayTimerRunning()) ||

   803 				   (!iReceiver.IsIncomingSduQFull() && !iReceiver.TimerMan().IsLocalBusyDelayTimerRunning()),

   804 				   Panic(EL2CapSduQAndLocalBusyStateInconsistent));

   805 

   806 	__ASSERT_DEBUG(!iReceiver.IsIncomingSduQFull() ||

   807 				   InWindow(iReceiver.TxSeqExpectedBySduQ(), iReceiver.BufferSeq(), iReceiver.ExpectedTxSeq()),

   808 				   Panic(EL2CAPTxSeqExpectedBySduQNotWithinBufferSeqAndExpectedTxSeq));

   809 

   810 	__ASSERT_DEBUG(iReceiver.IsIncomingSduQFull() ||

   811 				   (iReceiver.ExpectedTxSeq() == iReceiver.BufferSeq() &&

   812 					iReceiver.BufferSeq() == iReceiver.TxSeqExpectedBySduQ()),

   813 				   Panic(EL2CAPExpectedTxSeqAndBufferSeqAndTxSeqExpectedBySduQNotEqualWhenIncomingQEmptyAndInRecvState));

   814 

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

   816 

   817 	TBool freeFrame = ETrue;

   818 

   819 	if (iReceiver.ExpectedTxSeq() == txSeq)

   820 		// With-Expected-TxSeq

   821 		{

   822 		iReceiver.IncExpectedTxSeq();

   823 		if (!iReceiver.IsIncomingSduQFull())

   824 			{

   825 			iReceiver.SetBufferSeq(iReceiver.ExpectedTxSeq());

   826 			}

   827 		iReceiver.PassToIncomingQL(aIFrame);

   828 		freeFrame = EFalse;

   829 		}

   830 	else if (!iReceiver.LocalBusy())

   831 		{

   832 		if (iReceiver.IsTxSeqUnexpected(txSeq))

   833 			// With-Unexpected-TxSeq

   834 			{

   835 			if (iReceiver.IsSRejPreferredToRej(iReceiver.ExpectedTxSeq(), txSeq))

   836 				{

   837 				iReceiver.SetStateSRejSentL(aIFrame);

   838 				freeFrame = EFalse;

   839 				}

   840 			else

   841 				{

   842 				if (iReceiver.BufferSeq() == iReceiver.ExpectedTxSeq())

   843 					{

   844 					iReceiver.SetStateRejSentL();

   845 					}

   846 				else

   847 					{

   848 					// BufferSeq != ExpectedTxSeq only when SDU Q is full or in SREJ_SENT.

   849 					__ASSERT_DEBUG(iReceiver.IsIncomingSduQFull(),

   850 								   Panic(EL2CAPBufferSeqNotEqualToExpectedTxSeqWhenInRecvAndSduQNotFull));

   851 

   852 					__ASSERT_DEBUG(iReceiver.TimerMan().IsLocalBusyDelayTimerRunning(),

   853 								   Panic(EL2CAPLocalBusyDelayTimerNotRunningWhenSduQFullButNotInLB));

   854 

   855 					iReceiver.TimerMan().StopLocalBusyDelayTimer();

   856 

   857 					iReceiver.UpdateLocalBusyStatusL();

   858 					}

   859 				}

   860 			} // Unexpected TxSeq

   861 			// else must be duplicate (With-Duplicate-TxSeq), in which case we just drop it

   862 		} // !LocalBusy

   863 	// LocalBusy and !ExpectedTxSeq - drop it - the remote will initiate a retransmission

   864 	// when we exit LocalBusy anyway.

   865 

   866 	if (freeFrame)

   867 		{

   868 		aIFrame.Free();

   869 		}

   870 	}

   871 

   872 void TL2CapErtmReceiverStateRecv::HandlePollL()

   873 	{

   874 	LOG_FUNC

   875 	if (iReceiver.IsIncomingSduQFull())

   876 		{

   877 		// If the Poll is a result of the peer's retransmission timer expiry, then the peer will

   878 		// start retransmitting I-Frames from the sequence number given here by us (our current

   879 		// BufferSeq). Basically, the point of a Poll in WAIT_ACK is the peer asking "what have

   880 		// you received, need to know where to start retransmitting from", and we're supposed

   881 		// to be honest.

   882 		// Otherwise, if our upper layer Read()s and we process buffered I-Frames between now

   883 		// and the moment the first retransmitted packet comes through, we will have moved

   884 		// BufferSeq and render that packet invalid (a duplicate effectively). Therefore we

   885 		// need to drop the buffered I-Frames to prevent duplicates and guarantee that BufferSeq

   886 		// won't move.

   887 		iReceiver.FlushBufferedIncomingIFrames();

   888 

   889 		// Incoming I-Frame buffer empty and state = RECV:

   890 		__ASSERT_DEBUG(// no buffered I-Frames

   891 					   iReceiver.ExpectedTxSeq() == iReceiver.BufferSeq() &&

   892 					   // most recent ReqSeq

   893 					   iReceiver.BufferSeq() == iReceiver.TxSeqExpectedBySduQ(),

   894 					   Panic(EL2CAPExpectedTxSeqAndBufferSeqAndTxSeqExpectedBySduQNotEqualWhenIncomingQEmptyAndInRecvState));

   895 		}

   896 	// Now respond with a data frame or an ack frame with the Final bit set.

   897 	iReceiver.Controller().SendIOrRrOrRnrL(ETrue);

   898 	}

   899 

   900 TBool TL2CapErtmReceiverStateRecv::IsLocalBusySupported() const

   901 	{

   902 	LOG_FUNC

   903 	return ETrue;

   904 	}

   905 

   906 void TL2CapErtmReceiverStateRecv::TxSeqExpectedBySduQChanged(TUint8 aTxSeq)

   907 	{

   908 	LOG_FUNC

   909 	LOG1(_L("Slipping BufferSeq to %d"), aTxSeq)

   910 	iReceiver.SetBufferSeq(aTxSeq);

   911 	__ASSERT_DEBUG(iReceiver.IsIncomingSduQFull() || iReceiver.BufferSeq() == iReceiver.ExpectedTxSeq(),

   912 				   Panic(EL2CAPBufferSeqNotEqualToExpectedTxSeqWhenInRecvAndSduQNotFull));

   913 	}

   914 

   915 

   916 TL2CapErtmReceiverStateRejSent::TL2CapErtmReceiverStateRejSent(CL2CapErtmDataReceiver& aReceiver)

   917  :	TL2CapErtmReceiverStateBase(aReceiver)

   918 	{

   919 	LOG_FUNC

   920 	}

   921 

   922 void TL2CapErtmReceiverStateRejSent::EnterL(RMBufChain* /*aIFrame*/)

   923 	{

   924 	LOG_FUNC

   925 

   926 	// LocalBusy is only allowed in RECV.

   927 	__ASSERT_DEBUG(!iReceiver.LocalBusy(), Panic(EL2CAPInRejSentAndLocalBusy));

   928 

   929 	// Otherwise by sending the REJ we'd acknowledge frames between BufferSeq and ExpectedTxSeq

   930 	// (and if BufferSeq != ExpectedTxSeq and we're not in SREJ_SENT then incoming SDU Q is full

   931 	// and we can not acknowledge anything new).

   932 	__ASSERT_DEBUG(iReceiver.BufferSeq() == iReceiver.ExpectedTxSeq(),

   933 				   Panic(EL2CAPRejSentEnteredWithBufferedFrames));

   934 	

   935 	iReceiver.Controller().OutgoingQ().QueueNonAckingSFrame(*HSFramePDU::NewL(EReject), iReceiver.ExpectedTxSeq());

   936 	}

   937 

   938 void TL2CapErtmReceiverStateRejSent::HandleIncomingIFrameL(RMBufChain& aIFrame)

   939 	{

   940 	LOG_FUNC

   941 

   942 	__ASSERT_DEBUG(iReceiver.TxSeqExpectedBySduQ() == iReceiver.BufferSeq(),

   943 				   Panic(EL2CAPNextTxSeqExpectedBySduQNotEqualToBufferSeqWhenNotInSRejSent));

   944 

   945 	__ASSERT_DEBUG(InWindow(iReceiver.TxSeqExpectedBySduQ(), iReceiver.BufferSeq(), iReceiver.ExpectedTxSeq()),

   946 				   Panic(EL2CAPTxSeqExpectedBySduQNotWithinBufferSeqAndExpectedTxSeq));

   947 

   948 	__ASSERT_DEBUG(!iReceiver.LocalBusy(), Panic(EL2CAPInRejSentAndLocalBusy));

   949 

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

   951 

   952 	if (iReceiver.ExpectedTxSeq() == txSeq)

   953 		// With-Expected-TxSeq

   954 		{

   955 		iReceiver.IncExpectedTxSeq();

   956 		if (!iReceiver.IsIncomingSduQFull())

   957 			{

   958 			iReceiver.SetBufferSeq(iReceiver.ExpectedTxSeq());

   959 			}

   960 

   961 		// Received the missing frame, clear REJ exception condition.

   962 		iReceiver.SetStateRecvL();

   963 

   964 		iReceiver.PassToIncomingQL(aIFrame);

   965 		}

   966 	else

   967 		{

   968 		// else it's a duplicate or unexpected frame:

   969 		// - drop the duplicate as usual,

   970 		// - drop the unexpected frame as we're already in a REJ exception condition

   971 		//   and aren't allowed to send a second REJ until the first one is cleared.

   972 		aIFrame.Free();

   973 		}

   974 	}

   975 

   976 void TL2CapErtmReceiverStateRejSent::HandlePollL()

   977 	{

   978 	LOG_FUNC

   979 	// General-case Poll handling: simply respond with a data frame or an ack frame with

   980 	// the Final bit set.

   981 	iReceiver.Controller().SendIOrRrOrRnrL(ETrue);

   982 	}

   983 

   984 void TL2CapErtmReceiverStateRejSent::TxSeqExpectedBySduQChanged(TUint8 aTxSeq)

   985 	{

   986 	LOG_FUNC

   987 	LOG1(_L("NextConsumedTxSeq moved: slipping BufferSeq to %d"), aTxSeq)

   988 	iReceiver.SetBufferSeq(aTxSeq);

   989 	__ASSERT_DEBUG(iReceiver.IsIncomingSduQFull() || iReceiver.BufferSeq() == iReceiver.ExpectedTxSeq(),

   990 				   Panic(EL2CAPBufferSeqNotEqualToExpectedTxSeqWhenInRecvAndSduQNotFull));

   991 	}

   992 

   993 

   994 TL2CapErtmReceiverStateSRejSent::TL2CapErtmReceiverStateSRejSent(CL2CapErtmDataReceiver& aReceiver)

   995  :	TL2CapErtmReceiverStateBase(aReceiver),

   996  	iGoToRej(EFalse)

   997 	{

   998 	LOG_FUNC

   999 	}

  1000 

  1001 void TL2CapErtmReceiverStateSRejSent::EnterL(RMBufChain* aIFrame)

  1002 	{

  1003 	LOG_FUNC

  1004 

  1005 	__ASSERT_DEBUG(!iReceiver.LocalBusy(), Panic(EL2CAPInSRejSentAndLocalBusy));

  1006 	__ASSERT_DEBUG(iMissingTxSeqs.IsEmpty(), Panic(EL2CAPNormalReceiveStateWhenMissingSRejFramesListIsNotEmpty));

  1007 	__ASSERT_DEBUG(aIFrame != NULL, Panic(EL2CAPDataFrameNotPassedOnEntryToSRejSent));

  1008 

  1009 	iGoToRej = EFalse;

  1010 	SendSRejsUpToReceivedIFrameL(*aIFrame);

  1011 	}

  1012 

  1013 void TL2CapErtmReceiverStateSRejSent::ExitL()

  1014 	{

  1015 	LOG_FUNC

  1016 	TL2CapErtmReceiverStateBase::ExitL();

  1017 	

  1018 	iMissingTxSeqs.Reset();

  1019 

  1020 	// BufferSeq was frozen once SREJ_SENT was entered. Now we can move it forward.

  1021 	if (iReceiver.IsIncomingSduQFull())

  1022 		{

  1023 		// If incoming SDU Q filled up during SREJ_SENT, then we can only move BufferSeq up to

  1024 		// the point at which that happened, not ExpectedTxSeq.

  1025 		iReceiver.SetBufferSeq(iReceiver.TxSeqExpectedBySduQ());

  1026 		}

  1027 	else

  1028 		{

  1029 		// Bring BufferSeq back in sync with ExpectedTxSeq.

  1030 		iReceiver.SetBufferSeq(iReceiver.ExpectedTxSeq());

  1031 		}

  1032 	LOG2(_L("On exit from SREJ_SENT[IsIncomingSduQFull = %d]: slipped BufferSeq to %d"),

  1033 		 iReceiver.IsIncomingSduQFull(), iReceiver.BufferSeq())

  1034 	}

  1035 

  1036 void TL2CapErtmReceiverStateSRejSent::HandleIncomingIFrameL(RMBufChain& aIFrame)

  1037 	{

  1038 	LOG_FUNC

  1039 

  1040 	__ASSERT_DEBUG(InWindow(iReceiver.TxSeqExpectedBySduQ(), iReceiver.BufferSeq(), iReceiver.ExpectedTxSeq()),

  1041 				   Panic(EL2CAPTxSeqExpectedBySduQNotWithinBufferSeqAndExpectedTxSeq));

  1042 

  1043 	__ASSERT_DEBUG(!iReceiver.LocalBusy(), Panic(EL2CAPInSRejSentAndLocalBusy));

  1044 

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

  1046 

  1047 	TBool freeFrame = ETrue;

  1048 	

  1049 	if (iMissingTxSeqs.ExpectedSRejTxSeq() == txSeq)

  1050 		// With-Expected-TxSeq-Srej

  1051 		{

  1052 		LOG1(_L("With-Expected-TxSeq-Srej: TxSeq=%d"), txSeq)

  1053 		iReceiver.PassToIncomingQL(aIFrame);

  1054 		freeFrame = EFalse;

  1055 

  1056 		TBool resendPreviousSRej = iMissingTxSeqs.ReceivedTxSeq(txSeq);

  1057 		__ASSERT_ALWAYS(!resendPreviousSRej, Panic(EL2CAPHaveSRejsToResendEvenThoughReceivedFirstInOrder));

  1058 

  1059 		if (iMissingTxSeqs.AllRequestedFramesReceived())

  1060 			{

  1061 			if (iGoToRej)

  1062 				{

  1063 				if (iReceiver.IsIncomingSduQFull())

  1064 					{

  1065 					// We couldn't have entered LocalBusy in SREJ_SENT, but now we can transition

  1066 					// to RECV with LocalBusy instead of REJ_SENT. The retransmission will be

  1067 					// started when we exit LocalBusy anyway.

  1068 					iReceiver.SetStateRecvL();

  1069 					// We rely on this...

  1070 					__ASSERT_DEBUG(iReceiver.LocalBusy(),

  1071 								   Panic(EL2CAPNotInLocalBusyAfterTransitionToRecvFromSrejSentWithSduQFull));

  1072 					}

  1073 				else

  1074 					{

  1075 					iReceiver.SetStateRejSentL();

  1076 					}

  1077 				}

  1078 			else // !iGoToRej

  1079 				{

  1080 				iReceiver.SetStateRecvL();

  1081 				}

  1082 			} // all SREJed frames received

  1083 		} // With-Expected-TxSeq-Srej

  1084 	else

  1085 		{

  1086 		if (iReceiver.ExpectedTxSeq() == txSeq)

  1087 			{

  1088 			// With-Expected-TxSeq

  1089 			if (!iGoToRej)

  1090 				{

  1091 				LOG1(_L("With-Expected-TxSeq: TxSeq=%d"), txSeq)

  1092 				iReceiver.IncExpectedTxSeq();

  1093 				iReceiver.PassToIncomingQL(aIFrame);

  1094 				freeFrame = EFalse;

  1095 				}

  1096 			}

  1097 		else if (InWindow(txSeq, iReceiver.BufferSeq(), iReceiver.ExpectedTxSeq()))

  1098 			{

  1099 			if (iMissingTxSeqs.IsTxSeqOnTheList(txSeq))

  1100 				// With-Unexpected-TxSeq-Srej

  1101 				{

  1102 				__ASSERT_DEBUG(TL2CapErtmMissingTxSeqs::KMaxSRejsInFlight > 1,

  1103 							   Panic(EL2CAPMultiSRejPathHitWhenNotSoConfigured));

  1104 

  1105 				// Multiple SRej requests have been made and some of the retransmitted I-Frames

  1106 				// were lost again. Send new SREJs for those frames.

  1107 

  1108 				__ASSERT_DEBUG(!iMissingTxSeqs.IsEmpty(), Panic(EL2CAPOldestSRejedFrameNotOnMissingList));

  1109 				LOG2(_L("With-Unexpected-TxSeq-Srej: TxSeq=%d. Expected was=%d"),

  1110 					 txSeq, iMissingTxSeqs.ExpectedSRejTxSeq())

  1111 

  1112 				TBool resendSRej = iMissingTxSeqs.ReceivedTxSeq(txSeq);

  1113 				while (resendSRej)

  1114 					{

  1115 					TUint8 resendTxSeq;

  1116 					resendSRej = iMissingTxSeqs.GetNextTxSeqForResend(resendTxSeq);

  1117 					iReceiver.Controller().OutgoingQ().QueueNonAckingSFrame(*HSFramePDU::NewL(ESelectiveReject), resendTxSeq);

  1118 					LOG1(_L("Resending SREJ for TxSeq=%d"), resendTxSeq)

  1119 					}

  1120 				iReceiver.PassToIncomingQL(aIFrame);

  1121 				freeFrame = EFalse;

  1122 				}

  1123 			else // else must be a duplicate: With-duplicate-TxSeq-Srej

  1124 				{

  1125 				LOG1(_L("With-duplicate-TxSeq-Srej: TxSeq=%d"), txSeq)

  1126 				}

  1127 			}

  1128 		else if (!iGoToRej) // With-Unexpected-TxSeq

  1129 			{

  1130 			LOG1(_L("With-Unexpected-TxSeq: TxSeq=%d."), txSeq)

  1131 			if (iReceiver.IsSRejPreferredToRej(iReceiver.ExpectedTxSeq(), txSeq) &&

  1132 				iMissingTxSeqs.HaveSpaceForNewTxSeqs(Mod64(txSeq - iReceiver.ExpectedTxSeq())))

  1133 				{

  1134 				__ASSERT_DEBUG(TL2CapErtmMissingTxSeqs::KMaxSRejsInFlight > 1,

  1135 							   Panic(EL2CAPMultiSRejPathHitWhenNotSoConfigured));