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

// ACL.cpp

// Implementation of ACL Logical links

// 

//

#include <bluetooth/logger.h>

#include <bt_sock.h>

#include <bluetooth/hci/aclpacketconsts.h>

#include "ACLSAP.h"

#include "physicallinks.h"

#include "physicallinksmanager.h"

#include "Basebandmodel.h"

#include "linkmgr.h"

#include "AclDataQController.h"

#include "linkconsts.h"

#include "linkutil.h"

#include "hcifacade.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

#pragma warning (disable: 4100) //unreference formal param

CACLLinkStateFactory* CACLLinkStateFactory::NewL()

	{

	LOG_STATIC_FUNC

	CACLLinkStateFactory* ret=new (ELeave) CACLLinkStateFactory();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

void CACLLinkStateFactory::ConstructL()

	{

	LOG_FUNC

	iStates[EClosed]				=new (ELeave) TACLLinkStateClosed(*this);

	iStates[EListening]				=new (ELeave) TACLLinkStateListening(*this);

	iStates[EAccepting]				=new (ELeave) TACLLinkStateAccepting(*this);

	iStates[EWaitForLink]			=new (ELeave) TACLLinkStateWaitForLink(*this);

	iStates[EWaitForStart]			=new (ELeave) TACLLinkStateWaitForStart(*this);

	iStates[EWaitForStartError]		=new (ELeave) TACLLinkStateWaitForStartError(*this);

	iStates[EWaitForStartParked]	=new (ELeave) TACLLinkStateWaitForStartParked(*this);

	iStates[EOpen]					=new (ELeave) TACLLinkStateOpen(*this);

	iStates[EOpenParked]			=new (ELeave) TACLLinkStateOpenParked(*this);

	iStates[EClosing]				=new (ELeave) TACLLinkStateClosing(*this);

	iStates[EAcceptingClosing]		=new (ELeave) TACLLinkStateAcceptingClosing(*this);

	}

CACLLinkStateFactory::~CACLLinkStateFactory()

	{

	LOG_FUNC

	iStates.DeleteAll();

	}

TACLLinkState& CACLLinkStateFactory::GetState(CACLLinkStateFactory::TACLLinkStates aState)

	{

	LOG_FUNC

	__ASSERT_DEBUG(aState != EACLLinkMaxState, Panic(EACLLinkStateOutOfBounds));

	return *iStates[aState];

	}

TInt CACLLinkStateFactory::StateIndex(const TACLLinkState* aState) const

	{

	LOG_FUNC

	TInt state;

	for (state = 0; state < EACLLinkMaxState; state++)

		{

		if (iStates[state] == aState)

			{

			return state;

			}

		}

	return KUnknownState;

	}

TACLLinkState::TACLLinkState(CACLLinkStateFactory& aFactory)

: iFactory(aFactory)

	{

	LOG_FUNC

	}

void TACLLinkState::PanicInState(TLinkPanic aPanic) const

	{

	LOG_FUNC

	Panic(aPanic, iFactory.StateIndex(this));

	}

void TACLLinkState::ChangeState(CACLLink& aContext, CACLLinkStateFactory::TACLLinkStates aState) const

	{

	LOG_FUNC

	aContext.iState->Exit(aContext);

#ifdef __FLOG_ACTIVE

	TACLLinkState* state=&iFactory.GetState(aState);

	LOG2(_L("ACLLink: State %S -> %S"), &aContext.iState->iName, &state->iName);

#endif //__FLOG_ACTIVE

	aContext.iState=&iFactory.GetState(aState);

	aContext.iState->Enter(aContext);

	}

void TACLLinkState::Enter(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	// do nothing

	}

void TACLLinkState::Exit(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	// do nothing

	}

void TACLLinkState::Deletion(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

void TACLLinkState::ActiveOpen(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

void TACLLinkState::DataReceived(CACLLink& /*aContext*/, TUint8 /*aFlag*/, const TDesC8& /*aData*/) const

	{

	LOG_FUNC

	__DEBUGGER(); // drop, but see why went wrong

	}

void TACLLinkState::Start(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent); //Panics since ESOCK and our state machine might be out of sync

	}

void TACLLinkState::ConnectComplete(CACLLink& /*aContext*/, const TBTConnect& /*aConnect*/) const

	{

	LOG_FUNC

	//Drop the event silently in UREL

 	#ifdef _DEBUG

	PanicInState(EBTACLSAPUnexpectedEvent);

	#endif

	}

TBool TACLLinkState::ConnectRequest(CACLLink& /*aContext*/,

									  const TBTConnect& /*aConnectDetails*/,

									  const CPhysicalLink& /*aPhysicalLink*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	return EFalse;

	}

void TACLLinkState::Disconnection(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

void TACLLinkState::Error(CACLLink& /*aContext*/, TInt /*aError*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

void TACLLinkState::Timeout(CACLLink& /*aContext*/, TBasebandTimeout /*aTimeout*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

void TACLLinkState::Shutdown(CACLLink& /*aContext*/, CServProviderBase::TCloseType /*aCloseType*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	}

TInt TACLLinkState::PassiveOpen(CACLLink& /*aContext*/, TUint /*aQueSize*/) const

	{

	LOG_FUNC

	PanicInState(EBTACLSAPUnexpectedEvent);

	return KErrGeneral;

	}

TUint TACLLinkState::Write(CACLLink& /*aContext*/, const TDesC8& /*aData*/, TUint /*aOptions*/, TSockAddr* /*aAddr*/) const

	{

	LOG_FUNC

	LOG(_L("CACLLink: Write in base state - Dropping data..."));

	return 0;

	}

TBool TACLLinkState::IsIdle() const

	{

	LOG_FUNC

	return EFalse;

	}

void TACLLinkState::Park(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	// ignore

	}

void TACLLinkState::Unpark(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	// ignore

	}

//----------------------------------------------------------------------------------

TACLLinkStateListening::TACLLinkStateListening(CACLLinkStateFactory& aFactory)

: TACLLinkState(aFactory)

	{

	LOG_FUNC

	STATENAME("Listening");

	}

void TACLLinkStateListening::Enter(CACLLink& aContext) const

	{

	LOG_FUNC

	TInt err = aContext.iLinksMan.AddListener(aContext, EACLLink);

	if (err)

		{

		__ASSERT_DEBUG(err!=KErrInUse, PanicInState(EBTACLAlreadyBoundToPhysicalLink));

		aContext.iSocket->Error(err, MSocketNotify::EErrorFatal);

		ChangeState(aContext, CACLLinkStateFactory::EClosed);

		}

	}

TBool TACLLinkStateListening::ConnectRequest(CACLLink& aContext,

											 const TBTConnect& /*aConnectDetails*/,

											 const CPhysicalLink& aPhysicalLink) const

	{

	LOG_FUNC										

	// ah! we have a connection

	/*	super - now BT1.1/1.2 says we don't need to do anything - 

	ACL is here for free: with same handle as PhysicalLink.

	We do however need to introduce ourselves to ACL Q

	*/

	LOG(_L("CACLLink: Physical Channel Up - Spawning..."));

	// clone the sap - we only support *one* child at present since

	// we dont expose ACL sockets to ESOCK - only to L2CAP who will 

	// only attempt to Start one child at a time

	TRAPD(err, SpawnL(aContext, const_cast<CPhysicalLink&>(aPhysicalLink)));

	return (err==KErrNone);

	}

void TACLLinkStateListening::SpawnL(CACLLink& aContext, CPhysicalLink& aPhysicalLink) const

/**

	Called when a PassiveSAP wants to create a (connected) child of itself

**/

	{

	LOG_FUNC

	//Listening SAP only keeps one pointer to accepting SAP so we 

	//can't have more than one outstanding accepting SAP

	if(aContext.iChild)

		{

		LOG(_L("TACLLinkStateListening::SpawnL: there is already an outstanding accepting SAP, can't spawn now"));

		User::Leave(KErrInUse);

		}

	CACLLink* child = CACLLink::NewLC(aContext.iLinksMan,

									  &aPhysicalLink,

									  aContext.iProtocol);

	User::LeaveIfError(child->BindLink(EACLLink, aPhysicalLink));

	CleanupStack::Pop(child);

	// tell child about parent

	child->ListeningSAP() = &aContext;

	// and parent about child

	aContext.iChild = child;

	// configure the SAP

	child->iRemoteDev = aPhysicalLink.BDAddr();

	child->iLocalPort = aContext.iLocalPort;

	// transition for child is Closed->WaitForStart

	ChangeState(*child, CACLLinkStateFactory::EAccepting);

	}

void TACLLinkStateListening::Shutdown(CACLLink& aContext, CServProviderBase::TCloseType aCloseType) const

	{

	LOG_FUNC

	ChangeState(aContext, CACLLinkStateFactory::EClosed);

	if(aContext.iChild)

		{

		//As soon as this method returns, this SAP could be deleted.

		//Notify the child.

		aContext.iChild->Shutdown(CServProviderBase::EImmediate);

		//If the child was in EAccepting state, the shutdown will move it to EClosing. It

		//will still be bound to PHY, and when the ConnectComplete arrives the PHY will

		//still route it to the child. If the parent has been deleted by then, the child

		//will cause a panic. The best thing to do is delete the child now.

		//N.B. It is important to Shutdown the child before deleting it, because if it

		//was in EAccepting state calling Shutdown stops its watchdog.

		aContext.DeleteChild(aContext.iChild);

		aContext.iChild=NULL; //Not sure if this is needed, but it'll do no harm.

		}

	if (aCloseType == CServProviderBase::ENormal)

		{

		aContext.Socket()->CanClose();

		}

	}

void TACLLinkStateListening::Deletion(CACLLink& aContext) const

	{

	LOG_FUNC

	delete aContext.iChild;

	}

void TACLLinkStateListening::Exit(CACLLink& aContext) const

	{

	LOG_FUNC

	aContext.iLinksMan.RemoveListener(aContext);

	}

void TACLLinkStateListening::Error(CACLLink& /*aContext*/, TInt __DEBUG_ONLY(aError)) const

	{

	LOG_FUNC

	// Don't propagate the error as listeners don't care if the hardware has gone down

	__ASSERT_DEBUG(aError==KErrHardwareNotAvailable, PanicInState(EBTACLSAPUnexpectedEvent));

	}

//----------------------------------------------------------------------------------

TACLLinkStateAccepting::TACLLinkStateAccepting(CACLLinkStateFactory& aFactory)

: TACLLinkState(aFactory)

	{

	LOG_FUNC

	STATENAME("Accepting");

	}

void TACLLinkStateAccepting::Enter(CACLLink& aContext) const

	{

	LOG_FUNC

	// start watchdog

	aContext.iAcceptWatchdog.Start();

	// If the link is accepting then it must be being remotely initiated.

	aContext.SetInitiationState(CACLLink::ERemotelyInitiated);

	if(aContext.iLinksMan.IsAcceptPairedOnlyMode())

		{

		// Start an access request for appropriate security - this will start as

		// the physical link is established.

		aContext.StartAccessRequest(*(aContext.ListeningSAP()));

		}

	}

void TACLLinkStateAccepting::Exit(CACLLink& aContext) const

 	{

	LOG_FUNC

 	//Ensure watchdog has been cancelled (safe to call Cancel multiple times)

 	aContext.iAcceptWatchdog.Cancel();

 	}

void TACLLinkStateAccepting::ConnectComplete(CACLLink& aContext, const TBTConnect& /*aConnect*/) const

	{

	LOG_FUNC

	// cancel watchdog

	aContext.iAcceptWatchdog.Cancel();

	// must wait until started

	ChangeState(aContext, CACLLinkStateFactory::EWaitForStart);

	// let the listening Socket know...

	__ASSERT_DEBUG(aContext.ListeningSAP()->Socket(), PanicInState(EBTACLSAPNullSocket));

	aContext.ListeningSAP()->Socket()->ConnectComplete(aContext);	// tell listening socket about its new SAP

	}

void TACLLinkStateAccepting::Timeout(CACLLink& aContext, TBasebandTimeout aTimeout) const

	{

	LOG_FUNC

	if (aTimeout == EAccept)

		{

		// the accept never worked - give up

		Error(aContext, KErrTimedOut);

		}

	}

void TACLLinkStateAccepting::Deletion(CACLLink& aContext) const

	{

	LOG_FUNC

	aContext.ListeningSAP()->RemoveChild(&aContext);

	}

void TACLLinkStateAccepting::Disconnection(CACLLink& aContext) const

	{

	LOG_FUNC

	// This will be called if there is a hardware error - give up

	Error(aContext, KErrDisconnected);

	}

void TACLLinkStateAccepting::Error(CACLLink& aContext, TInt /*aError*/) const

	{

	LOG_FUNC

	// unbind from physical link

	aContext.UnbindLink(EACLLink);

	// cancel watchdog

	aContext.iAcceptWatchdog.Cancel();

	aContext.ListeningSAP()->DeleteChild(&aContext);

	}

void TACLLinkStateAccepting::Shutdown(CACLLink& aContext, CServProviderBase::TCloseType /*aCloseType*/) const

	{

	LOG_FUNC

	// we're not wanted - close

	ChangeState(aContext, CACLLinkStateFactory::EAcceptingClosing);

	}

//----------------------------------------------------------------------------------

TACLLinkStateWaitForStart::TACLLinkStateWaitForStart(CACLLinkStateFactory& aFactory)

: TACLLinkState(aFactory)

	{

	LOG_FUNC

	STATENAME("WaitForStart");

	}

void TACLLinkStateWaitForStart::Enter(CACLLink& __DEBUG_ONLY(aContext)) const

	{

	LOG_FUNC

	__ASSERT_DEBUG(aContext.ListeningSAP(), PanicInState(EBTACLSAPParentlessChild));

	}

void TACLLinkStateWaitForStart::Start(CACLLink& aContext) const

	{

	LOG_FUNC

	// transfer ownership to higher entity

	aContext.ListeningSAP()->RemoveChild(&aContext);

	aContext.ListeningSAP() = NULL;

	TInt err = aContext.OpenLogicalLink();

	if (err == KErrNone)

		{

		ChangeState(aContext, CACLLinkStateFactory::EOpen);

		}

	else

		{

		Error(aContext, err);

		}

	}

void TACLLinkStateWaitForStart::Deletion(CACLLink& aContext) const

	{

	LOG_FUNC

	aContext.ListeningSAP()->RemoveChild(&aContext);

	}

void TACLLinkStateWaitForStart::Error(CACLLink& aContext, TInt /*aError*/) const

	{

	LOG_FUNC

	ChangeState(aContext, CACLLinkStateFactory::EWaitForStartError);

	}

void TACLLinkStateWaitForStart::Park(CACLLink& aContext) const

	{

	LOG_FUNC

	// blimey! already gone into park - dont tell socket anything

	ChangeState(aContext, CACLLinkStateFactory::EWaitForStartParked);	

	}

void TACLLinkStateWaitForStart::Disconnection(CACLLink& aContext) const

	{

	LOG_FUNC

	aContext.ListeningSAP()->DeleteChild(&aContext);

	}

void TACLLinkStateWaitForStart::Shutdown(CACLLink& aContext, CServProviderBase::TCloseType /*aCloseType*/) const

	{

	LOG_FUNC

	// just go

	ChangeState(aContext, CACLLinkStateFactory::EAcceptingClosing);

	}

//----------------------------------------------------------------------------------

TACLLinkStateWaitForStartError::TACLLinkStateWaitForStartError(CACLLinkStateFactory& aFactory)

: TACLLinkState(aFactory)

	{

	LOG_FUNC

	STATENAME("Error");

	}

void TACLLinkStateWaitForStartError::Start(CACLLink& aContext) const

	{

	LOG_FUNC

	// summat went wrong - close and remove this acceptor

	ChangeState(aContext, CACLLinkStateFactory::EClosed);

	aContext.Socket()->Disconnect();

	aContext.ListeningSAP()->RemoveChild(&aContext);

	}

void TACLLinkStateWaitForStartError::Disconnection(CACLLink& /*aContext*/) const

	{

	LOG_FUNC

	//Release build should silently ignore the event

	__ASSERT_DEBUG(EFalse,PanicInState(EBTACLSAPUnexpectedEvent));