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

// Implementation of physical links manager

// 

//

#include <bluetooth/logger.h>

#include "physicallinksmanager.h"

#include "physicallinks.h"

#include "hcifacade.h"

#include "Basebandmodel.h"

#include "ProxySAP.h"

#include <bt_sock.h>

#include "hostresolver.h"

#include <bluetooth/hci/writepagetimeoutcommand.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

#ifdef _DEBUG

PANICCATEGORY("plinkmgr");

#endif

// macro to dump invalid commands from hardware

#define	RETURN_IF_NULL_CONNECTION(found) {if (!found) {LOG(_L("CPhysicalLinksManager: Bad event received - dropping")); return;}}

CPhysicalLinksManager* CPhysicalLinksManager::NewL(CLinkMgrProtocol& aLinkMgrProtocol,

												   CHCIFacade& aHCIFacade,

												   CRegistrySession& aRegSess,

												   CBTSecMan& aSecMan,

												   CBTCodServiceMan& aCodMan)

	{

	CPhysicalLinksManager* s = new(ELeave) CPhysicalLinksManager(aLinkMgrProtocol,

																 aHCIFacade,

																 aRegSess,

																 aSecMan,

																 aCodMan);

	CleanupStack::PushL(s);

	s->ConstructL();

	CleanupStack::Pop(s);

	return s;

	}

CPhysicalLinksManager::CPhysicalLinksManager(CLinkMgrProtocol& aLinkMgrProtocol,

											 CHCIFacade& aHCIFacade,

											 CRegistrySession& aRegSess,

											 CBTSecMan& aSecMan,

											 CBTCodServiceMan& aCodMan)

	: iPhysicalLinks(KBTBasebandConnectionArrayGranularity)

	, iHCIRequestHandler(aHCIFacade)

	, iRegSess(aRegSess)

	, iSecMan(aSecMan)

	, iCodMan(aCodMan)

	, iLinkManagerProtocol(aLinkMgrProtocol)

	, iTerminatingProxy(NULL)

	, iTerminatingConnection(NULL)

	, iRoleSwitchersQ(_FOFF(CRoleSwitcher, iQLink))

	, iPageTimeoutController(aHCIFacade.CommandQController())

	{

	}

void CPhysicalLinksManager::ConstructL()

	{

	iPairingsCache = CBTPairingsCache::NewL(*this, iRegSess.RegServ());

	iBaseband = CBTBasebandModel::NewL(iLinkManagerProtocol);

	iPrefetchMan = CBluetoothPrefetchManager::NewL();

	}

CPhysicalLinksManager::~CPhysicalLinksManager()

	{

	LOG(_L("sec\tCBTConnectionsManager destructing"));

	iPageTimeoutController.Abort();

	iPhysicalLinks.ResetAndDestroy();

	iPhysicalLinks.Close();

	__ASSERT_ALWAYS(iRoleSwitchersQ.IsEmpty(), Panic(ERoleSwitchersNotDeleted));

	iListeners.Close();

	delete iBaseband;

	delete iRoleSwitcherStateFactory;

	delete iPairingsCache;

	delete iPrefetchMan;

	}

void CPhysicalLinksManager::RequireSlotSpace()

/**

	At present we put all those connections that are holdable into hold

	To release baseband space for certain activities such

	as device discovery

	In future other operations may be performed here...

**/

	{

	if (LinkManagerProtocol().IsModeSupportedLocally(EHoldMode))

		{

		CPhysicalLink* con = NULL;

		// locally can support Hold mode - see if we can free up links that do

		TInt count = iPhysicalLinks.Count();

		for (TInt i=(count-1); i>=0; i--)

			{

			con = iPhysicalLinks[i];

			static_cast<void>(con->RequestHold()); //ignore error - best effort

			}

		}

	}

TBasebandTime CPhysicalLinksManager::TryToChangePageTimeout(TBasebandTime aPageTimeout)

	{

	// First check the page timeout is suitable wrt. link supervision timeouts.

	aPageTimeout = CheckPageTimeoutAgainstLSTO(aPageTimeout);

	iPageTimeoutController.WritePageTimeout(aPageTimeout);

	return aPageTimeout; // return the timeout that was tried (not necessarily set).

	}

CPhysicalLink& CPhysicalLinksManager::NewPhysicalLinkL(const TBTDevAddr& aAddr)

	{

	// create a PHY just knowing its address

	TBTNamelessDevice device;

	device.SetAddress(aAddr);

	return NewPhysicalLinkL(device);

	}

CPhysicalLink& CPhysicalLinksManager::NewPhysicalLinkL(const TBTNamelessDevice& aDevice)

	{

	// create a PHY with a full Device - make sure it isn't us!

	if (aDevice.Address() == iLinkManagerProtocol.LocalBTAddress())

		{

		// the app may be at fault - so don't panic

		User::Leave(KErrReflexiveBluetoothLink);

		}

	// create role switch SM

	// delete is in destructor of CPhysicalLinksManager

	if (!iRoleSwitcherStateFactory)

		{

		iRoleSwitcherStateFactory = CRoleSwitcherStateFactory::NewL();

		}

	CPhysicalLink* phy = CPhysicalLink::NewLC(*this, iRegSess, aDevice);

	User::LeaveIfError(iPhysicalLinks.Append(phy)); //transfers ownership

	CleanupStack::Pop(phy);

	LOG1(_L("CPhysicalLinksManager: Number of physical links %d"), iPhysicalLinks.Count());

	return *phy;

	}

CPhysicalLink* CPhysicalLinksManager::FindPhysicalLink(const TBTDevAddr& aBDAddr) const

	{

	CPhysicalLink* con = NULL;

	CPhysicalLink* found = NULL;

	TInt count = iPhysicalLinks.Count();

	for (TInt i=(count-1); i>=0; i--)

		{

		con = iPhysicalLinks[i];

		if (con->BDAddr() == aBDAddr)

			{

#ifndef _DEBUG

			found = con;

			break;

#else

			if (found) //make sure there's only one

				{

				__DEBUGGER()

				}

			else

				{

				found = con;

				continue; // just to show we do want to!

				}

#endif

			}

		}

	return found;

	}

void CPhysicalLinksManager::DumpPhysicalLinks()

	{

#ifdef __FLOG_ACTIVE

	TInt count = iPhysicalLinks.Count();

	CPhysicalLink* con = NULL;

	for (TInt i=(count-1); i>=0; i--)

		{

		con = iPhysicalLinks[i];

		LOG(_L(" - Link: "));

		LOGBTDEVADDR(con->BDAddr());

		}

#endif

	}

TBool CPhysicalLinksManager::IsAcceptPairedOnlyMode()

	{

	return iAcceptPairedOnlyMode;

	}

CPhysicalLink* CPhysicalLinksManager::FindPhysicalLink(THCIConnHandle aConnH) const

/**

	Handy for when a disconnection comes in - disconnections dont give either

	the address or (if SCO) the 'bound' handle.

	This method asks each CPhysicalLink if it knows of the handle (ACL or SCO)

**/

	{

	CPhysicalLink* con = NULL;

	CPhysicalLink* found = NULL;

	TInt count = iPhysicalLinks.Count();

	for (TInt i=(count-1); i>=0; i--)

		{

		con = iPhysicalLinks[i];

		if (con->HasHandle(aConnH))

			{

#ifndef _DEBUG

			found = con;

			break;

#else

			if (found) //make sure there's only one

				{

				__DEBUGGER()

				}

			else

				{

				found = con;

				continue; // just to show we do want to!

				}

#endif

			}

		}

	return found;

	}

CPhysicalLink* CPhysicalLinksManager::FindPhysicalLink() const

/**

	Handy for finding a random connected PHY

**/

	{

	CPhysicalLink* con = NULL;

	CPhysicalLink* found = NULL;

	TInt count = iPhysicalLinks.Count();

	if(!count)

		{

		return NULL;

		}

	for (TInt i=(count-1); i>=0; i--)

		{

		con = iPhysicalLinks[i];

		if (con->Handle()!=KHCIBroadcastHandle)

			{

			found = con;

			break;

			}

		}

	return found;

	}

TLogicalLinkListener* CPhysicalLinksManager::FindListener(TPhysicalLinkPort aPort)

	{

	// go through listeners until we find a listener on the required port

	TLogicalLinkListener* found = NULL;

	TLogicalLinkListener* l = NULL;

	TInt count = iListeners.Count();

	for (TInt i=(count-1); i>=0; i--)

		{

		l = &iListeners[i];

		if (l->iPort == aPort)

			{

			found = l;

			break;

			}

		}

	return found;

	}

void CPhysicalLinksManager::ClearTerminatingProxy(CBTProxySAP* aProxySAP)

	{

	if (aProxySAP==iTerminatingProxy)

		{

		iTerminatingProxy=NULL;

		}

	}

void CPhysicalLinksManager::UpdateTerminatingProxy(CBTProxySAP* aProxySAP)

	{

	// If there is an outstanding terminate request for a different Proxy SAP

	// complete it here and deal with the new request

	if (iTerminatingProxy && (iTerminatingProxy!=aProxySAP))

		{

		iTerminatingProxy->TerminatePhysicalLinksComplete();

		}

	iTerminatingProxy=aProxySAP;

	}

TInt CPhysicalLinksManager::TerminateAllPhysicalLinks(CBTProxySAP* aProxySAP, THCIErrorCode aErrorCode)

	{

	TInt count=iPhysicalLinks.Count();

	TInt retVal = (count==0) ? KErrNotFound : KErrNone;

	for (TInt i=0; i<count; i++)

		{

		// If any one of the physical links return an error then this 

		// function needs to return an error.

		TInt err = iPhysicalLinks[i]->Terminate(aErrorCode);

		if (err != KErrNone)

			{

			retVal=err;

			}

		}

	// aProxy==NULL	means that the calling Proxy SAP does not want to be told when the

	// physical link has terminated

	if ((retVal==KErrNone) || !aProxySAP)

		{

		UpdateTerminatingProxy(aProxySAP);

		}

	return retVal;

	}

TInt CPhysicalLinksManager::TerminatePhysicalLink(CPhysicalLink* aConnection, CBTProxySAP* aProxySAP)

	{

	TInt count = iPhysicalLinks.Count();

	TInt retVal=KErrNotFound;

	for (TInt i=(count-1); i>=0; i--)

		{

		if (iPhysicalLinks[i]==aConnection)

			{

			retVal=iPhysicalLinks[i]->Terminate(ERemoteUserEndedConnection);

			break;	

			}

		}

	// aProxy==NULL	means that the calling Proxy SAP does not want to be told when the

	// physical link has terminated

	if ((retVal==KErrNone) || !aProxySAP)

		{

		UpdateTerminatingProxy(aProxySAP);

		iTerminatingConnection=aConnection;

		}

	return retVal;

	}

void CPhysicalLinksManager::UpdateRemoteDevicesDetails()

	{

	//Update paired device list

	iPairingsCache->UpdateCache();

	//Update cached device info for existing PHYs

	TInt count=iPhysicalLinks.Count();

	for (TInt i=0; i<count; i++)

		{

		// try to get details of remote device

		TRAP_IGNORE(iPhysicalLinks[i]->GetDeviceFromRegistryL());

		// ignore error - as with other registry accessing routines

		}

	}

void CPhysicalLinksManager::SetAcceptPairedOnlyMode(TBool aOn)

	{

	iAcceptPairedOnlyMode = aOn;

	LinkManagerProtocol().SetAcceptPairedOnlyMode(aOn);

	}

void CPhysicalLinksManager::SetSimplePairingDebugMode(TBool aOn)

	{

	if(!SecMan().LocalSimplePairingMode())

		{

		LOG(_L("CPhysicalLinksManager: Simple pairing not supported by controller - ignoring request for debug mode"));

		return;

		}

	if(aOn)

		{

		iSecMan.SetDebugMode(aOn);

		}

	}

void CPhysicalLinksManager::SimplePairingDebugModeChanged(TBool aOn)

	{

	LinkManagerProtocol().SetSimplePairingDebugMode(aOn);

	}

void CPhysicalLinksManager::FatalError(TInt /*aErr*/)

	{

	// simulate a disconnection complete on all PHYs

	TInt count=iPhysicalLinks.Count();

	//The call to l.Disconnection removes an element from array iPhysicalLink, therefore invalidates 

	//count. So it's best iterating through the array backwards because count is only used for 

	//initialising i, and i is always valid. 

	for (TInt i=count-1; i>=0; i--)

		{

		// we say remote, as this is a passive-like disconnection

		CPhysicalLink& l = *iPhysicalLinks[i];

		l.Disconnection(EHardwareFail, l.Handle(), EHardwareFail);

		}

	// Don't error the Listeners

	}

void CPhysicalLinksManager::NewLinkKey(const TBTDevAddr& aBDAddr, const TBTLinkKey& aLinkKey, THCILinkKeyType aLinkKeyType)

	{

	CPhysicalLink* found = FindPhysicalLink(aBDAddr);

	RETURN_IF_NULL_CONNECTION(found);

	found->NewLinkKey(aBDAddr, aLinkKey, aLinkKeyType);

	}

void CPhysicalLinksManager::RemovePhysicalLink(const CPhysicalLink& aConnection)

/**

	A Physical Link wants us to remove our knowledge of it

**/

	{

	TInt count = iPhysicalLinks.Count();

	TInt i;

	for (i=(count-1); i>=0; i--)

		{

		if (iPhysicalLinks[i]==&aConnection)

			{

			iPhysicalLinks.Remove(i);

			count--;

			break;

			}

		}

	if (count!=0)

		{

		//compress the array if needs be

		if (i!=count)

			{

			iPhysicalLinks.GranularCompress();

			}

		// A physical link has been removed. Arbitrate for role switch allowed 

		// on the remainder of the links.

		ArbitrateAllPhysicalLinks();

		}

	// IF we have a Terminate request from a ProxySAP AND

	// either it was a request to terminate all connections and we have no connections left OR

	// it was a request for a specific connection that we have just removed THEN

	// tell the Proxy SAP that the request is complete

	if (iTerminatingProxy && 

		((!iTerminatingConnection && (count==0)) || 

		 ((iTerminatingConnection==&aConnection) && (i!=-1))))

		{

		iTerminatingProxy->TerminatePhysicalLinksComplete();

		iTerminatingProxy=NULL;

		iTerminatingConnection=NULL;

		}

	// good time to update that UI

	LinkManagerProtocol().SetUINumPhysicalLinks(count);

	LOG1(_L("CPhysicalLinksManager: Number of physical links %d"), count);

	}

void CPhysicalLinksManager::ArbitrateAllPhysicalLinks()

	{

	TInt i;

	for (i=(iPhysicalLinks.Count()-1); i>=0; i--)

		{

		iPhysicalLinks[i]->Arbitrate();

		}

	}

void CPhysicalLinksManager::SimplePairingComplete(const TBTDevAddr& aBDAddr, THCIErrorCode /*aErr*/)

	{

	//find the connection and pass on the request

	CPhysicalLink* found = FindPhysicalLink(aBDAddr);

	RETURN_IF_NULL_CONNECTION(found);

	found->AuthenticationComplete(ESimplePairingPending);

	}

void CPhysicalLinksManager::PinRequest(const TBTDevAddr& aBDAddr,

										MPINCodeResponseHandler& aRequester)

	{

	//find the connection and pass on the request

	CPhysicalLink* found = FindPhysicalLink(aBDAddr);

	RETURN_IF_NULL_CONNECTION(found);

	found->PinRequest(aBDAddr, aRequester);

	}

void CPhysicalLinksManager::LinkKeyRequest(const TBTDevAddr& aBDAddr, MLinkKeyResponseHandler& aRequester)

	{

	CPhysicalLink* found = FindPhysicalLink(aBDAddr);

	RETURN_IF_NULL_CONNECTION(found);

	found->LinkKeyRequest(aBDAddr, aRequester);

	}

void CPhysicalLinksManager::ReadRemoteSupportedFeaturesComplete(THCIErrorCode aErr, THCIConnHandle aConnH, const TBTFeatures& aBitMask)

	{

	CPhysicalLink* found = FindPhysicalLink(aConnH);

	RETURN_IF_NULL_CONNECTION(found);

	found->ReadRemoteSupportedFeaturesComplete(aErr, aConnH, aBitMask);

	}

void CPhysicalLinksManager::ReadRemoteExtendedFeaturesComplete(THCIErrorCode aErr, THCIConnHandle aConnH, TUint64 aBitMask, TUint8 aPageNumber, TUint8 aMaximumPageNumber)

	{

	CPhysicalLink* found = FindPhysicalLink(aConnH);

	RETURN_IF_NULL_CONNECTION(found);

	found->ReadRemoteExtendedFeaturesComplete(aErr, aConnH, aBitMask, aPageNumber, aMaximumPageNumber);

	}