// Copyright (c) 1999-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:

// Implements the l2cap Muxer.

// 

//

#include <bluetooth/logger.h>

#include <math.h>

#include <bluetooth/hci/aclpacketconsts.h>

#include <bluetooth/aclsockaddr.h>

#include "l2signalmgr.h"

#include "L2CapPDU.h"

#include "l2capLinkSignalHandler.h"

#include "l2capSAPSignalHandler.h"

#include "L2CapDataController.h"

#include "l2capMuxController.h"

#include "l2capEntityConfig.h"

#include "l2cap.h"

#include "l2util.h"

#include "btconsts.h"

#include "L2CapDebugControlInterface.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

#ifdef _DEBUG

PANICCATEGORY("l2cap");

#endif

CL2CAPMux* CL2CAPMux::NewL(CL2CAPMuxController& aMuxController, const TBTDevAddr& aAddr)

	{

	LOG_STATIC_FUNC

	CL2CAPMux* sig=new (ELeave) CL2CAPMux(aMuxController, aAddr);

	CleanupStack::PushL(sig);

	sig->ConstructL();

	CleanupStack::Pop();

	return sig;

	}

CL2CAPMux::CL2CAPMux(CL2CAPMuxController& aMuxController, const TBTDevAddr& aAddr)

 : iMuxController(aMuxController),

   iLinkState(ELinkNone),

   iRemote(aAddr),

   iIdleTimerActive(EFalse),

   iDataHandlers(_FOFF(CL2CapBasicDataController, iLink)),

   iSapSignalHandlers(_FOFF(CL2CapSAPSignalHandler, iLink)),

   iPDUsWaitingResendQ(_FOFF(HL2CapPDU, iLink)),

   iPDUsWaitingSend(_FOFF(HL2CapPDU, iLink)),

   iTryToSendPriority(CActive::EPriorityHigh),

   iUpdateTryToSendPriority(EFalse),

   iNextCID(KL2CapDynamicCIDStart),

   iQlink(this)

	{

	LOG_FUNC

	TCallBack cb(IdleTimerExpired, this);

	iIdleTimerEntry.Set(cb);

#ifdef _DEBUG

	// Set up the next CID to be one off of the wrap point to

	// check that functionality

	iNextCID = 0xfffe;

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EMuxes,

	                             L2capDebugInfo::EAllocated));

#endif	                             

	}

void CL2CAPMux::ConstructL()

	{

	LOG_FUNC

	iBoundLinkSignalHandler = CL2CapLinkSignalHandler::NewL(this);

	iFragmentSender = new (ELeave) HFragmentedPDUSender(*this);

	TCallBack canSendCallBack(AsyncCallBackForTryToSend, this);

	iAsyncCallBackForTryToSend = new (ELeave)CAsyncCallBack(canSendCallBack, iTryToSendPriority);

	TCallBack idleMuxCallBack(AsyncCallBackForIdleMux, this);

	iAsyncCallBackForIdleMux = new (ELeave)CAsyncCallBack(idleMuxCallBack, CActive::EPriorityHigh);	

	}

//Passive connections call this with a valid SAP 

//Active connections pass NULL into this and one gets created.

void CL2CAPMux::CompleteACLConnect(CServProviderBase* aSAP)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iBoundSAP, Panic(EL2CAPLinkUpWhenNoLinkRequested));

	if (!aSAP)

		{

		TRAPD(err, iBoundSAP = MuxController().Protocol().LowerProtocol()->NewSAPL(KSockBluetoothTypeACL));

		if (err == KErrNone)

			{

			iBoundSAP->SetNotify(this);

			const TBTDevAddr& addr = iRemote;

			TBTSockAddr sockAddr;

			sockAddr.SetBTAddr(addr);

			TInt err = iBoundSAP->SetRemName(sockAddr);

			__ASSERT_ALWAYS(!err, Panic(EL2CAPCouldNotSetBasebandAddress));

			// tell the SAP what data we can handle

			TACLSockAddr aclSock;

			aclSock.SetPort(EACLPortL2CAP);

			err = iBoundSAP->SetLocalName(aclSock);

			iLinkState = ELinkPending;

			iBoundSAP->ActiveOpen();

			}

		}

	else

		{

		iBoundSAP = aSAP;	// we take ownership of this connected SAP

		iBoundSAP->SetNotify(this);

		iBoundSAP->Start();	// and open the passive connection

		ConnectComplete();	// gets BB MTU and configures this Mux

		}

	//Now the Link is up Subscribe for Physical Link Notifications

	MuxController().Protocol().ControlPlane().SubscribePhysicalLink(*this, iRemote);	

	}

CL2CAPMux::~CL2CAPMux()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iDataHandlers.IsEmpty() && iSapSignalHandlers.IsEmpty(),

	               Panic(EL2CAPMuxDeleteWithResourcesStillRegistered));

	iAsyncCallBackForTryToSend->Cancel();

	delete iAsyncCallBackForTryToSend;

	iAsyncCallBackForIdleMux->Cancel();

	delete iAsyncCallBackForIdleMux;

	MuxController().Protocol().ControlPlane().UnsubscribePhysicalLink(*this,iRemote);

	delete iBoundSAP;

	// Remove timer entry if one has been queued.

	CancelIdle();

	iFragmentSender->PDUSenderFailed();

	// Some PDUs may hold a reference to this Mux.

	TDblQueIter<HL2CapPDU> resendIter(iPDUsWaitingResendQ);

	TDblQueIter<HL2CapPDU> sendIter(iPDUsWaitingSend);

	HL2CapPDU* pduPtr;

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

		{

		pduPtr->DeregisterPduOwner();

		}

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

		{

		pduPtr->DeregisterPduOwner();

		}

	iIncomingPDU.Free();

	iMuxControllerLink.Deque();

	delete iBoundLinkSignalHandler;

	delete iFragmentSender;

#ifdef _DEBUG

	L2CAP_DEBUG(ObjectAllocation(L2capDebugInfo::EMuxes,

	                             L2capDebugInfo::EDeleted));

#endif	                             

	}

TInt CL2CAPMux::SetOption(TUint level,TUint name,const TDesC8 &anOption)

	{

	LOG_FUNC

	return iBoundSAP->SetOption(level, name, anOption);

	}

TInt CL2CAPMux::GetOption(TUint level,TUint name,TDes8& anOption) const

	{

	LOG_FUNC

	return iBoundSAP->GetOption(level, name, anOption);

	}

void CL2CAPMux::DetachFromMux(CL2CapSAPSignalHandler& aSAPSigHandler)

	{

	LOG_FUNC

	// Check if this SSH had a Echo Request outstanding.  If it did discard the 

	// response when it arrives.

	iBoundLinkSignalHandler->DeregisterOutstandingEchoRequests(aSAPSigHandler);

	if(Idle())

		{

		LOG(_L("CL2CAPMux: DetatchFromMux -- no current SAPs, queuing idle callback"));

		// The Muxer will be destroyed and

		// the ACL / baseband will be removed by CL2CAPMux::AsyncCallBackForIdleMux()...

		iAsyncCallBackForIdleMux->CallBack();

		}

	else

		{

		LOG(_L("CL2CAPMux: DetatchFromMux -- still have SAPs present or are still sending data"));

		}

	}

TInt CL2CAPMux::MuxIdled()

	{

	LOG_FUNC

	// register we have no intention of sending out for now..

	// if data comes in we may if necessary send data later, in which 

	// case we will reopen our link

	if (iLinkState != ELinkNone)

		{

		LOG(_L("CL2CAPMux: MuxIdled -- iLinkState != ELinkNone"));

		// Don't attempt to send anymore data.

		iBoundLinkSignalHandler->FlushPendingCommands();

		// Shutdown the ACL.

		iBoundSAP->Shutdown(CServProviderBase::EStopOutput); // we might get overtures back in

		iLinkState = ELinkInbound;

		}

	else

		{

		delete this;

		}

	return KErrNone;

	}

TUint8 CL2CAPMux::NextSigId()

	{

	LOG_FUNC

	// 0 is invalid, so don't use it

	++iSigId;

	if (iSigId == 0)

		{

		iSigId = 1;

		}

	LOG1(_L("L2CAP [l2signalmgr.cpp]: Next signalling Id is %d"), iSigId);

	return iSigId;

	}

TBool CL2CAPMux::Idle()

/**

	Test to see if this L2CAP mux is no longer required.

	If there are no SSHs connected to this muxer, shutdown the ACL

**/

	{

	LOG_FUNC

	return (iSapSignalHandlers.IsEmpty() &&

			iLinkState != ELinkPending &&

			!iFragmentSender->IsPDUBeingSent() &&

			!iIdleTimerActive);

	}

void CL2CAPMux::StartIdleTimer()

	{

	LOG_FUNC

	CancelIdle();

	iIdleTimerActive = ETrue;

    BTSocketTimer::Queue(KL2MuxerIdleTimeout * KL2ProtocolSecondTimerMultiplier, iIdleTimerEntry);

	}

TInt CL2CAPMux::AsyncCallBackForIdleMux(TAny *aMuxer)

/**

	Static function called through TCallBack. aMuxer holds the muxer

	that is idle. Ask mux to bring down its own link.

*/

	{

	LOG_STATIC_FUNC

	CL2CAPMux* muxer = static_cast<CL2CAPMux*>(aMuxer);

	if (muxer->Idle())

		{

		// We're (still) idle! Let's disconnect.

		muxer->MuxIdled();

		}

	return EFalse;	 // no more callbacks thanks!

	}

TInt CL2CAPMux::AsyncCallBackForTryToSend(TAny *aMuxer)

/**

	Static function called whenever idle processing can be scheduled.

	This deals with doing async requests to send data over HCI,

	notifications to SSHs 

**/

	{

	LOG_STATIC_FUNC

	CL2CAPMux* muxer = static_cast<CL2CAPMux*>(aMuxer);

	muxer->TryToSend();

	return EFalse;	// Don't call back any more.

	}

// from MSocketNotify

void CL2CAPMux::ConnectComplete()

/**

	The link for this muxer has come up.

	SSHs are notified by the protocol (who notifies us too).

	Set the Idle timer going here, so if no SAP attaches to this

	Mux, it'll just tidy itself up.

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iLinkState != EConnected, Panic(EL2CAPLinkDownConnectComplete));

	// Get the MTU

	TPckgBuf<TInt> buf;

	TInt err;

	err = iBoundSAP->GetOption(KSolBtACL, ELMOutboundACLSize, buf);

	ASSERT_DEBUG(!err);

	iACLMTU = buf();

	err = iBoundSAP->GetOption(KSolBtACL, ELMInboundACLSize, buf);

	ASSERT_DEBUG(!err);

	iACLMRU = buf();

	(void)(err != KErrNone); // keep the compiler happy by taking err as an r-value in urel

	iLinkState = EConnected;

	// Send an Information Request as soon as possible.

	TL2CapEntityInfo info;

	iBoundLinkSignalHandler->PeerEntityConfig().PeerL2CapSupportedFeatures(info);

	TDblQueIter<CL2CapSAPSignalHandler> sapSignalIter(iSapSignalHandlers);

	sapSignalIter.SetToFirst();

	CL2CapSAPSignalHandler* sapPtr;

	while((sapPtr = sapSignalIter++) != NULL)

		{

		sapPtr->LinkUp();

		}

	// No point hanging around if nobody actually connects to us!

	// Mainly useful for incoming connections

	if(Idle())

		{

		StartIdleTimer();

		}

	}

void CL2CAPMux::NewL2CAPData(RMBufChain& aData, TUint8 aFlag)

	{

	LOG_FUNC

	TUint8 l2Flags = static_cast<TUint8>(aFlag>>KPacketPBBCFlagShift & KPacketPBFlagMask);

	LOG1(_L("L2CAP Mux received data with flags, %x"), aFlag);

	switch(l2Flags)

		{

		case KFirstHLFragment:

			// This is the start of a PDU.  If an incoming PDU already exists

			// delete it and start a new one.

			if(!iIncomingPDU.IsEmpty())

				{

				LOG(_L("L2CAP [l2signalmgr.cpp]: Warning: Dropped previous incoming packet - start of next packet received"));

				iIncomingPDU.Free();

				}

			break;

		case KContinuingHLFragment:

			// This is a continuation so an existing PDU should exist.

			// If it doesn't drop this data and wait for the next start of 

			// PDU.

			if(iIncomingPDU.IsEmpty())

				{

				LOG(_L("L2CAP [l2signalmgr.cpp]: Warning: Continuation fragment received and dropped - waiting for start"));

				aData.Free();

				return;

				}

			break;

		default:

			LOG1(_L("L2CAP [l2signalmgr.cpp] Warning: Unexpected ACL packet type received: %d"), aFlag);

			return;

		};

	if(HL2CapPDU::AddFragment(iIncomingPDU, aData))

		{

		// PDU complete.

		PacketComplete();

		__ASSERT_DEBUG(iIncomingPDU.IsEmpty(), Panic(EL2CAPPacketCompleteFailedToConsumeIncomingPDU));

		}

	}

// A full packet is now in the buffer.  Process it

void CL2CAPMux::PacketComplete()

	{

	LOG_FUNC

	TBool packetDelivered = EFalse;

	if(iIncomingPDU.Length() >= HL2CapPDU::KPDUHeaderLength)

		{

		iIncomingPDU.Align(HL2CapPDU::KPDUHeaderLength);

		TUint16 cid = HL2CapPDU::PDUCID(iIncomingPDU);

		switch(cid)

			{

			case KL2CapSignallingCID:

				{

				// This is a signalling packet

				HCFramePDU* cFramePtr = new HCFramePDU(iIncomingPDU, iACLMTU);

				if(cFramePtr)

					{

					cFramePtr->CheckDecode();

					if(cFramePtr->HasCommands())

						{

						// The C-Frame can contain many L2CAP commands.  Not all of

						// the commands will be for a SAP signal handler.  If a

						// command can be processed it will be removed from the

						// C-Frame.  Any remaining commands will be offered to the

						// other SAP signal handlers, then the whole process of

						// offering the commands to the SAP signal handlers is

						// repeated until no more commands can be handled by them,

						// after which the commands are offered to the link signal

						// handler.  Only one command is handled at a time because a

						// Command Reject may delete a SAP signal handler, thereby

						// rendering it ineffective at processing further commands.

						TBool commandsWereHandled;

						TDblQueIter<CL2CapSAPSignalHandler> sapSignalIter(iSapSignalHandlers);

						CL2CapSAPSignalHandler* sshPtr;

						do

							{

							commandsWereHandled = EFalse;

							sapSignalIter.SetToFirst();

							while (!packetDelivered && (sshPtr = sapSignalIter++) != NULL)

								{

								commandsWereHandled |= sshPtr->HandleIncomingCFrame(cFramePtr);

								// If all commands from the C-Frame have been processed then

								// consider the packet delivered.

								packetDelivered = !cFramePtr->HasCommands();

								}

							}

						while (!packetDelivered && commandsWereHandled);

						if (!packetDelivered)

							{

							// Offer the remaining commands to the link signal handler.

							while (iBoundLinkSignalHandler->HandleIncomingCFrame(cFramePtr))

								;

							}

						}

					// Delete the CFrame.

					delete cFramePtr;

					}

				else

					{

					ErrorAllSignalHandlers(KErrNoMemory);

					iIncomingPDU.Free();

					}

				}

				break;

			case KL2CapConnectionlessCID:

				// Connectionless L2CAP is not currently supported.

				iIncomingPDU.Free();

				break;

			default:

				{

				if(cid >= KL2CapDynamicCIDStart)

					{

					// This is a data frame.

					TDblQueIter<CL2CapBasicDataController> dataControllerIter(iDataHandlers);

					CL2CapBasicDataController* dcPrt;

					while((dcPrt = dataControllerIter++) != NULL && !packetDelivered)

						{

						packetDelivered = dcPrt->HandleIncomingDataFrame(iIncomingPDU);

						}

					}

				if(!packetDelivered)

					{

					// This data frame was not for any channel or was using an

					// invalid CID.  Drop it.

					iIncomingPDU.Free();

					}

				}

				break;

			};

		}

	else

		{

		// Invalid PDU length.  Drop it.

		iIncomingPDU.Free();

		}

	}

void CL2CAPMux::ErrorAllSignalHandlers(TInt aError)

	{

	LOG_FUNC

	TDblQueIter<CL2CapSAPSignalHandler> iter(iSapSignalHandlers);

	CL2CapSAPSignalHandler* sapPtr;

	while((sapPtr = iter++) != NULL)

		{

		sapPtr->Error(aError, MSocketNotify::EErrorAllOperations);

		}

	iBoundLinkSignalHandler->Error(aError, MSocketNotify::EErrorAllOperations);

	}

void CL2CAPMux::NewData(TUint aCount)

	{