// 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:

// This implements the CL2CAPProtocol object that is the contact point from

// BT PRT to the L2cap stack

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include <bluetooth/aclsockaddr.h>

#include "l2cap.h"

#include "l2sapstates.h"

#include "l2util.h"

#include "linkmgr.h"

#include "l2capSAPSignalHandler.h"

#include "l2sap.h"

#ifdef _DEBUG

#include "L2CapDebugControlInterface.h"

#endif

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);

#endif

// Construction & Initialisation

CL2CAPProtocol::CL2CAPProtocol(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

 : CBluetoothProtocolBase(aSecMan, aControlPlane, aCodMan)

	{

	LOG_FUNC

	TCallBack cb(TryToClose, this);

	iIdleTimerEntry.Set(cb);

	}

CL2CAPProtocol::~CL2CAPProtocol()

	{

	LOG_FUNC

	RemoveIdleTimerEntry();

	delete iStateFactory;

	delete iSigStateFactory;

	if(LowerProtocol())

		{

		LowerProtocol()->Close();

		}

	// Delete the Mux controller.

	delete iMuxController;

#ifdef _DEBUG

	SBtTls* tls = static_cast<SBtTls*>(Dll::Tls());

	CDebugControlInterface* ptr = tls->iDebugCtrlIF;

	delete ptr;

	tls->iDebugCtrlIF = NULL;

#endif

#ifdef __FLOG_ACTIVE

	CLOSE_LOGGER

#endif

	}

CL2CAPProtocol* CL2CAPProtocol::NewL(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)

	{

#ifdef __FLOG_ACTIVE

	CONNECT_LOGGER

#endif

	LOG_STATIC_FUNC

	CL2CAPProtocol* prot = new (ELeave) CL2CAPProtocol(aSecMan, aControlPlane, aCodMan);

	CleanupStack::PushL(prot);

	prot->ConstructL();

	CleanupStack::Pop();

	return prot;

	}

void CL2CAPProtocol::ConstructL()

	{

	LOG_FUNC

	iMuxController = new (ELeave) CL2CAPMuxController(*this);	

	}

void CL2CAPProtocol::InitL(TDesC& /*aTag*/)

/**

	Pre-binding initialise.

	Allocate any objects we need here.

	The socket ensures that this function will only be called once per

	object of this class, regardless of how long it hangs around.

**/

	{

	LOG_FUNC

	// Init 

	__ASSERT_DEBUG(!iClosePending, Panic(EL2CAPProtocolOpenedAfterClose));

	__ASSERT_DEBUG(!iIdleEntryQueued, Panic(EL2CAPProtocolOpenedAfterClose));

	__ASSERT_DEBUG(!iStateFactory, Panic(EL2CAPProtocolOpenedAfterClose));

	__ASSERT_DEBUG(!iSigStateFactory, Panic(EL2CAPProtocolOpenedAfterClose));

	// Create all the things we need now

	LOG(_L("L2CAP : Initialising states"));

	iStateFactory=CL2CAPSAPStateFactory::NewL();

	iSigStateFactory=CL2CAPSignalStateFactory::NewL();

	LOG(_L("L2CAP : Initialising complete"));

#ifdef _DEBUG

	SBtTls* tls = static_cast<SBtTls*>(Dll::Tls());

	tls->iDebugCtrlIF = CDebugControlInterface::NewL();

#endif

	}

void CL2CAPProtocol::StartL()

/**

	Binding complete.

	Startup call from socket.  Do nothing

**/

	{

	LOG_FUNC

	}

// From higher protocol

void CL2CAPProtocol::BindL(CProtocolBase* /*aProtocol*/, TUint /*aId*/)

	{

	// Could register the protocol that's bound to us

	LOG_FUNC

	}

void CL2CAPProtocol::BindToL(CProtocolBase* aProtocol)

	{

	LOG_FUNC

#ifdef _DEBUG

	TServerProtocolDesc prtDesc;

	aProtocol->Identify(&prtDesc);

	if(prtDesc.iAddrFamily!=KBTAddrFamily ||

	   prtDesc.iProtocol!=KBTLinkManager)

		{

		LEAVEL(KErrBtEskError);

		}

#endif

	aProtocol->BindL(this, 0);

	aProtocol->Open();

	iLowerProtocol = static_cast<CBluetoothProtocolBase*>(aProtocol);

	}

// Factory functions

CServProviderBase* CL2CAPProtocol::NewSAPL(TUint aSockType)

/** 

	Create a new SAP.

	The SAP returned is owned by the caller -- this protocol will not clean it up.

	The socket uses this function to create a new SAP, and the socket will delete when it

	is finished with it.

**/

	{

	LOG_FUNC

	CL2CAPConnectionSAP* lsap = NULL;

	switch(aSockType)

		{

	case KSockSeqPacket:  // packet interface

		lsap=CL2CAPConnectionSAP::NewL(*this);

		break;

	default:

		LEAVEL(KErrNotSupported);

		break;

		}

	return lsap;

	}

// Query functions

void CL2CAPProtocol::Identify(TServerProtocolDesc *aDesc)const

//

// Identify request from SOCKET server

//

	{

	LOG_FUNC

	CL2CAPProtocol::ProtocolIdentity(aDesc);

	}

void CL2CAPProtocol::ProtocolIdentity(TServerProtocolDesc* aDesc)

	{

	LOG_STATIC_FUNC

	_LIT(name,"L2CAP");

	aDesc->iProtocol=KL2CAP;

	aDesc->iName=name;

	aDesc->iAddrFamily=KBTAddrFamily;

	aDesc->iSockType=KSockSeqPacket;

	aDesc->iVersion=TVersion(KBTMajor,KBTMinor,KBTBuild);

	aDesc->iByteOrder=ELittleEndian;

	aDesc->iServiceInfo=KL2CAPSeqPacketServiceInfo;

	aDesc->iNamingServices=0;

	aDesc->iSecurity=KSocketNoSecurity;

	aDesc->iMessageSize=KSocketMessageSizeNoLimit; //This is the MAX packet size.

	aDesc->iServiceTypeInfo=ESocketSupport|ETransport|EPreferMBufChains|ENeedMBufs|EUseCanSend;

	aDesc->iNumSockets=KL2CAPSockets;

	}

void CL2CAPProtocol::CloseNow()

/**

	Close command from base class.

	Called when ref count reaches 0.

	We don't actually have to close now, but when we finally

	do, we must call CanClose (done within TryToClose). That will

	actually delete us. In the mean time, if a new client tries

	to connect to L2CAP, the socket will use this existing one and just

	call Open on it.

	What we do here, is queue an idle timer entry. It's expiry will

	call TryToClose, which will actually do the close.

**/

	{

	LOG_FUNC

	iClosePending = ETrue;

	QueIdleTimerEntry();

	}

void CL2CAPProtocol::Open()

/**

	Open L2CAP protocol.

	Called every time a new client (of L2CAP) wants to use it.

**/

	{

	LOG_FUNC

	iClosePending = EFalse;

	RemoveIdleTimerEntry();

	CProtocolBase::Open();

	}

void CL2CAPProtocol::Close()

	{

	LOG_FUNC

	CProtocolBase::Close();

	}

void CL2CAPProtocol::QueIdleTimerEntry()

/**

	Queue idle timer entry.

	When this timer expires, it'll call TryToClose, which actually

	causes the thing to finally close down.

**/

	{

	LOG_FUNC

	RemoveIdleTimerEntry();

	iIdleEntryQueued = ETrue;

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

	}

void CL2CAPProtocol::RemoveIdleTimerEntry()

/**

	Called whenever we're opened.

	Checks there are no idle timer entries queued.

**/

	{

	LOG_FUNC

	if (!iIdleEntryQueued)

		return;

	BTSocketTimer::Remove(iIdleTimerEntry);

	iIdleEntryQueued = EFalse;

	}

void CL2CAPProtocol::TryToClose()

	{

	LOG_FUNC

	if (!iIdleEntryQueued && iClosePending && MuxController().CanProtocolClose())

		{

		CanClose();

		}

	}

TInt CL2CAPProtocol::TryToClose(TAny* aProtocol)

/*

	Actually try to close the protocol.

	Called after the idle timeout period by the BTSocketTimer. If

	we're all set to close down, the thing is closed.

*/

	{

	LOG_STATIC_FUNC

	CL2CAPProtocol* p=static_cast<CL2CAPProtocol*>(aProtocol);

	p->iIdleEntryQueued = EFalse;

	p->TryToClose();

	return EFalse;

	}

CL2CAPSAPStateFactory& CL2CAPProtocol::StateFactory() const

	{

	LOG_FUNC

	return *iStateFactory;

	}

CL2CAPSignalStateFactory& CL2CAPProtocol::SigStateFactory() const

	{

	LOG_FUNC

	return *iSigStateFactory;

	}

TInt CL2CAPProtocol::BearerConnectComplete(const TBTDevAddr& aAddr, CServProviderBase* aSAP)

	{

	LOG_FUNC

	return iMuxController->BearerConnectComplete(aAddr, aSAP);

	}

const TBTDevAddr& CL2CAPProtocol::LocalBTAddr() const

	{

	LOG_FUNC

	return static_cast<CLinkMgrProtocol*>(iLowerProtocol)->LocalBTAddress();

	}

TInt CL2CAPProtocol::StartProtocolListening()

// forward L2CAPs listening requirements to listener

	{

	LOG_FUNC

	return CBluetoothProtocolBase::StartListening(EACLPortL2CAP,

												  KSockBluetoothTypeACL,

												  KL2CAPIncomingConnQueueSize,

												  KUidServiceL2CAP);

	}