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

// 

//

#include <bluetooth/logger.h>

#include "physicallinksmanager.h"

#include "physicallinks.h"

#include "AclDataQController.h"

#include "ACLSAP.h"

#include "SCOSAP.h"

#include "ProxySAP.h"

#include "linkconsts.h"

#include "hcifacade.h"

#include "hostresolver.h"

#include "roleswitchhelper.h"

#include "pairingscache.h"

#include "oobdata.h"

#include "pairingserver.h"

#include "encryptionkeyrefreshhelper.h"

#include <bt_sock.h>

#include <bluetooth/hci/commandstatusevent.h>

#include <bluetooth/hci/sniffmodecommand.h>

#include <bluetooth/hci/exitsniffmodecommand.h>

#include <bluetooth/hci/holdmodecommand.h>

#include <bluetooth/hci/parkmodecommand.h>

#include <bluetooth/hci/exitparkmodecommand.h>

#include <bluetooth/hci/modechangeevent.h>

#include <bluetooth/hci/disconnectcommand.h>

#include <bluetooth/hci/disconnectioncompleteevent.h>

#include <bluetooth/hci/hciconsts.h>

#include <bluetooth/hci/linkkeyrequestreplycommand.h>

#include <bluetooth/hci/linkkeyrequestreplynegativecommand.h>

#include <btextnotifierspartner.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

#ifdef _DEBUG

PANICCATEGORY("plink");

#endif

static const THCIErrorCode KDefaultRejectReason = EHostSecurityRejection; // see spec Error Codes

#ifdef _DEBUG

#define __CHECK_CONNECTION_HANDLE(aHandle) __ASSERT_DEBUG(HasHandle(aHandle), Panic(EBTLinkMgrConnectionEventInWrongSAP));

#else

#define __CHECK_CONNECTION_HANDLE(aHandle) aHandle=aHandle; // to suppress warnings

#endif

CPhysicalLink* CPhysicalLink::NewLC(CPhysicalLinksManager& aConnectionMan, CRegistrySession& aRegSess, const TBTNamelessDevice& aDevice)

	{

	LOG_STATIC_FUNC

	CPhysicalLink* s = new(ELeave) CPhysicalLink(aConnectionMan, aRegSess, aDevice);

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CPhysicalLink* CPhysicalLink::NewL(CPhysicalLinksManager& aConnectionMan, CRegistrySession& aRegSess, const TBTNamelessDevice& aDevice)

	{

	LOG_STATIC_FUNC

	CPhysicalLink* s = NewLC(aConnectionMan, aRegSess, aDevice);

	CleanupStack::Pop(s);

	return s;

	}

CPhysicalLink::CPhysicalLink(CPhysicalLinksManager& aConnectionMan, CRegistrySession& aRegSess, const TBTNamelessDevice& aDevice)

	: iLinksMan(aConnectionMan)

	, iRegSess(aRegSess)

	, iDevice(aDevice)

	, iHandle(KHCIBroadcastHandle)

	, iRemoteFeatures(KInvalidRemoteFeatures)

	, iDeviceResult(KDeviceNotObtained)

	, iRegistryHelpers(_FOFF(CBTRegistryHelperBase,iLink))

	, iProxySAPs(_FOFF(CBTProxySAP, iQueueLink))

	, iOverrideParkRequests(EFalse)

	, iOverrideLPMRequests(EFalse)

	, iConnectionPacketTypeChanged(EFalse)

	, iLowPowModeCtrl(*this, iLinksMan.HCIFacade().CommandQController())

	, iDisconnectCtrl(*this, iLinksMan.HCIFacade().CommandQController())

	, iAuthenticationCtrl(*this, iLinksMan.HCIFacade().CommandQController())

	, iLSTO(0)

	, iAutoKeyRefreshQue(_FOFF(XAutoKeyRefreshToken, iQueLink))

	, iRemoteDeviceRecordedByStack(ENull)

	{

	LOG_FUNC

	// don't initialise physical link policy just yet - wait until connection completes

	// by then we'll have best information to go on

	LOG1(_L("New CPhysicalLink [0x%08x]"), this);

	}

CPhysicalLink::~CPhysicalLink()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iACLLogicalLinks.Count()==0, Panic(EBTACLLogicalLinkBadDebind));

	__ASSERT_DEBUG(iSyncLogicalLink == NULL, Panic(EBTSCOLogicalLinkBadDebind));

	LOG1(_L("CPhysicalLink Destructing this = 0x%08x"), this);

	// tell ConnectionsManager...

	iLinksMan.RemovePhysicalLink(*this);

	iACLLogicalLinks.Close();

	RemoveIdleTimer();

	LOG(_L("sec\tClosing subscribers..."))

	LOG(_L("sec\tClosing helpers..."))

	TSglQueIter<CBTRegistryHelperBase> iter(iRegistryHelpers);

	CBTRegistryHelperBase* helper;

	// Detach from any Registry Helpers for which this object

	// is the parent.

	while(iter)

		{

		helper = iter++;

		helper->DetachParent();

		}

	iLowPowModeCtrl.Abort();

	iDisconnectCtrl.Abort();

	iAuthenticationCtrl.Abort();

	delete iPhysicalLinkMetrics;

	delete iPinRequester;

	delete iNumericComparator;

	delete iUserConfirmer;

	delete iPasskeyEntry;

	delete iArbitrationDelay;

	delete iRoleSwitchCompleteCallBack;

	delete iKeyRefreshCompleteCallBack;

	delete iEncryptionEnforcer;

	DeleteRoleSwitcher();

	DeleteKeyRefresher();

	}

void CPhysicalLink::ConstructL()

	{

	LOG_FUNC

	LOG1(_L("CPhysicalLink::ConstructL() this = 0x%08x"), this);

	GetDeviceFromRegistryL();

	iArbitrationDelay = CArbitrationDelayTimer::NewL(this);

	TCallBack cb1(RoleSwitchCompleteCallBack, this);

	iRoleSwitchCompleteCallBack = new (ELeave)CAsyncCallBack(cb1, EActiveHighPriority);

	TCallBack cb2(KeyRefreshCompleteCallBack, this);

	iKeyRefreshCompleteCallBack = new (ELeave)CAsyncCallBack(cb2, EActiveHighPriority);

	iPhysicalLinkMetrics = CPhysicalLinkMetrics::NewL(*this, iLinksMan.HCIFacade().CommandQController());

	}

TBool CPhysicalLink::HasHandle(THCIConnHandle aHandle) const

	{

	LOG_FUNC

	if (iHandle == aHandle)

		return ETrue;	// Only one ACL handle is available.

	if (iSyncLogicalLink && iSyncLogicalLink->Handle() == aHandle)

		return ETrue;

	return EFalse;

	}

TBool CPhysicalLink::HasSyncLink() const

	{

	LOG_FUNC

	return (iSyncLogicalLink != NULL);

	}

void CPhysicalLink::SubscribeLinkObserver(MPhysicalLinkObserver& aObserver)

/**

The subscribed object will be notified whenever a link state change occurs.

**/

	{

	LOG_FUNC

#ifdef _DEBUG

	//ensure the subscriber isn't already subscribed...

	TInt found = 0;

	TDblQueIter<MPhysicalLinkObserver> iter(iBasebandSubscribers);

	while (iter)

		{

		if (iter++ == &aObserver)

			{

			found++;

			}

		}

	__ASSERT_DEBUG(found==0, Panic(ELinkMgrBadBasebandArray));

#endif	//_DEBUG

	iBasebandSubscribers.AddFirst(aObserver.ObserverQLink());

	}

void CPhysicalLink::UnsubscribeLinkObserver(MPhysicalLinkObserver& aObserver)

/**

aSubscriber will no longer be notified of state changes.

**/

	{

	LOG_FUNC

	aObserver.ObserverQLink().Deque();

	}

TInt CPhysicalLink::TryToAndThenPreventHostEncryptionKeyRefresh(TAny* aOutToken)

	{

	LOG_FUNC

	TInt err = KErrNone;

	// The handling of the TAny* parameter seems a bit wacky - but it makes sense as follows

	// this call handles a call from the bluetooth control plane (which passes

	// only a TAny* as a parameter).  We need to return a value back through as well, so we need

	// a pointer to a pointer (so after using the input it can be modified to point to the

	// output).  We need a Bluetooth device address so a pointer to a pointer to a TBTDevAddr 

	// is passed down. Then the pointer to a pointer is used to update the pointer to a control

	// plane token (which represents a handle preventing host encryption key refreshes).

	if (!IsEncryptionPauseResumeSupported())

		{

		err = KErrNotSupported;

		*reinterpret_cast<MBluetoothControlPlaneToken**>(aOutToken) = NULL;

		}

	else

		{

		// Only refresh the key if no-one is preventing it and we aren't still 

		// refreshing the key from a previous request.  Note that although

		// the previous key refresh may actually have finished if the key

		// refresher is waiting for async delete we have only just refreshed 

		// the key and there's no point doing it again.

		if (iAutoKeyRefreshQue.IsEmpty() && !iKeyRefresher)

			{

			TRAPD(err, iKeyRefresher = CEncryptionKeyRefresher::NewL(iLinksMan, *this));

			if(!err)

				{

				// Kick off the helper state machine

				iKeyRefresher->StartHelper();

				}

			// If we can't refresh the encryption key, there's not much we can do

			}

		XAutoKeyRefreshToken* token = new XAutoKeyRefreshToken();

		if (token)

			{

			iAutoKeyRefreshQue.AddLast(*token);

			}

		else

			{

			err = KErrNoMemory;

			}

		*reinterpret_cast<MBluetoothControlPlaneToken**>(aOutToken) = token;

		}

	return err;

	}

void CPhysicalLink::RegistryTaskComplete(CBTRegistryHelperBase* aHelper, TInt /*aResult*/)

/**

	A task has completed where we don't expect a response - just cleanup helper

**/

	{

	LOG_FUNC

	// remove from array

	iRegistryHelpers.Remove(*aHelper);

	// delete

	delete aHelper;

	}

/**

The completion function of a registry helper returning a remote device entry.

*/

void CPhysicalLink::RegistryTaskComplete(CBTRegistryHelperBase* aHelper,

										 const TBTNamelessDevice& aDevice,

										 TInt aResult)

/**

	A registry task has completed where we expect a device to be returned

**/

	{

	LOG_FUNC

	LOG1(_L("CPhysicalLink: Registry task complete; result %d"), aResult);

	// The TBTNamelessDevice assignment operator only performs an update on valid

	// entries, as we need a bitwise copy (since we want to mirror what is in the registry)

	// we need to go to these extras steps.

	TPckg<TBTNamelessDevice> cachedVersion(iRegistryDevice);

	cachedVersion.Copy(TPckg<TBTNamelessDevice>(aDevice));

	// We have to be careful about information flow from the registry to the actual representation (iDevice).

	// Although the values in the returned entry are useful if the stack has not yet got the information,

	// if the stack has already gathered values then they will be more up-to-date.  Therefore we need to

	// assign the current values first if they are valid to build up the latest representation.

	TBTNamelessDevice device = aDevice; // Take a local copy to work on.

	if(iDevice.IsValidDeviceClass())

		{

		device.SetDeviceClass(iDevice.DeviceClass());

		}

	if(iDevice.IsValidPageScanRepMode())

		{

		device.SetPageScanRepMode(iDevice.PageScanRepMode());

		}

	if(iDevice.IsValidPageScanPeriodMode())

		{

		device.SetPageScanPeriodMode(iDevice.PageScanPeriodMode());

		}

	if(iDevice.IsValidPageScanMode())

		{

		device.SetPageScanMode(iDevice.PageScanMode());

		}

	if(iDevice.IsValidClockOffset())

		{

		device.SetClockOffset(iDevice.ClockOffset());

		}

	if(iDevice.IsValidUsed())

		{

		device.SetUsed(iDevice.Used());

		}

	if(iDevice.IsValidSeen())

		{

		device.SetSeen(iDevice.Seen());

		}

	// With the link key (and friends) we need to be even more careful, as there is effectively

	// two-way flow of information:

	// 1) Link key storage from the stack.

	// 2) Unbonding from the clients of the registry.

	// Further to this, if the registry entry does not have a link key, it can mean one of several

	// things:

	// a) No link key has been generated with the remote device yet.

	// b) A client of the registry has unbonded the remote device.

	// c) The current link key is not to form a bond.

	// Taking this into account we make a suitable choice about what to do.

	if(!iDevice.IsValidLinkKey())

		{

		// If there isn't any link key in the system yet - and so it is safe to update the representation

		// to use the value from the registry.

		// <NOP> - see the global update below.

		}

	else

		{

		// We currently have a link key....

		if(device.IsValidLinkKey() || iRegistryDevBeingMod.InUse())

			{

			// Even if the linkkey in registry is valid, it must be older or same as the current

			// link key (as the stack is the only one who should be adding keys). Also, if we are in the

			// middle of updating the registry (for any purpose) then we can ignore the registry value as it

			// may not be up-to date. So, for both the cases just update with the latest.

			// There is an interesting case if client modifies the registry by unpairing/or deleting the device

			// and stack also tries to updates the link key in registry at the same time. We will give priority

			// to stack's updations by keeping the latest copy as it is.

			device.SetLinkKey(iDevice.LinkKey(), iDevice.LinkKeyType());

			if(iDevice.IsValidPassKey())

				{

				device.SetPassKey(iDevice.PassKey());

				}

			}

		else

			{

			// This is the interesting case where a client has unbonded, but we already have a link

			// key.  What we do here is interesting.

			if(IsAuthenticationPending() || LinkState().Authenticated() || SimplePairingMode() == EPhySimplePairingEnabled)

				{

				// If we're already authenticated / authenticating then we're already using our link

				// key.  As such we need to continue using it, but we don't want to update

				// Also if the link is SSP enabled then we can re-authenticate - this removes any chance of a

 				// race condition with the registry.

				iPreventLinkKeyUpdateReg = ETrue; // prevent locally cached link key being given back to the registry

				}

			else

				{

				// The link key hasn't been used yet - so we can update the representation to not

				// have a link key (as requested by the user).

				// Currently there is no chance of a race with the registry as combination link keys are

 				// always form a bond.

				iDevice.DeleteLinkKey(); // delete locally cached link key

				}

			}

		}

	// Finally update the representation - we should have manipulated it correctly.

	iDevice = device;

	// Store the result of the retrieval for usage later.

	iDeviceResult = aResult;

	if (iLinkKeyRequestOutstanding)

		{

		// the HW asked earlier for a link key - we can respond now

		__ASSERT_DEBUG(iDevice.IsValidAddress(), Panic(EBTPhysicalLinksInvalidAddress));

		LinkKeyRequestResponseAttempt(ETrue);

		}

	RegistryTaskComplete(aHelper, aResult);	 // cleans up our helper

	}

void CPhysicalLink::RegistryTaskComplete(CBTRegistryHelperBase* aHelper, TRegistryUpdateStatus aRegUpdateStatus, TInt aResult)

	{

/**

	This method allows the RegistryHelpers to indicate the registry action taking place

**/

	LOG_FUNC

	if(iRemoteDeviceRecordedByStack == EPending && aRegUpdateStatus != ENoChange)

		{

		if (aResult == KErrNone)

			{

			iRemoteDeviceRecordedByStack = EComplete;

			}

		else

			{

			iRemoteDeviceRecordedByStack = ENull;

			}

		}

	iRegistryDevBeingMod.RequestCompleted();

	RegistryTaskComplete(aHelper, aResult);	 // cleans up our helper

	}

void CPhysicalLink::CompletedPackets(THCIConnHandle aConnH, TUint16 aNumPackets)

/**

	In this domain we are happy that a valid event has come in telling us that

	the buffers in the local controller have been freed

	Since this reflects both local hardware features (buffers) and flow control

	we treat them separately

**/

	{

	LOG_FUNC

	// firstly report that local hardware buffers free (via inlines!)

	iLinksMan.LinkManagerProtocol().LinkMuxer().DataQController().CompletedPackets(aConnH, aNumPackets);

	// we forward this to the thing that sends the packets so that they can do Flow Control

	// could speed up - already done this handle test to get into *this* object

	if (iSyncLogicalLink && iSyncLogicalLink->Handle() == aConnH)

		{

		iSyncLogicalLink->PacketsSent(aConnH, aNumPackets);

		}

	else

		{

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

			{

			iACLLogicalLinks[i]->PacketsSent(aConnH, aNumPackets);

			}

		}

	}

void CPhysicalLink::TryToSend()

	{

	LOG_FUNC

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

		{

		iACLLogicalLinks[i]->TryToSend();

		}

	}

void CPhysicalLink::NewLinkKey(const TBTDevAddr& /*aAddr*/, const TBTLinkKey& aLinkKey, THCILinkKeyType aLinkKeyType)

	{

	LOG_FUNC

	if(iLinkKeyPending)

		//user has entered a PIN and a new link key has come in.

		{

		iLinkKeyPending = EFalse;

		iPreventLinkKeyUpdateReg = EFalse; //override previous unpair so that link key will be stored in the registry.

		}

	TBTLinkKeyType linkKeyType = ELinkKeyCombination;

	switch (aLinkKeyType)

		{

	case ECombinationKey:

		linkKeyType = ELinkKeyCombination;

		break;

	case EDebugCombinationKey:

		linkKeyType = ELinkKeyDebug;

		break;

	case EAuthenticatedCombinationKey:

		linkKeyType = ELinkKeyAuthenticated;

		break;

	case EUnauthenticatedCombinationKey:

		if (iLocalMITM || (iAuthenticationRequirement & KAuthenticationMitmReqMask) ||

			(iIOCapability == EIOCapsDisplayOnly) || (iIOCapability == EIOCapsNoInputNoOutput))

			{

			linkKeyType = ELinkKeyUnauthenticatedNonUpgradable;

			}

		else

			{

			linkKeyType = ELinkKeyUnauthenticatedUpgradable;

			}

		break;

	case EChangedCombinationKey:

		linkKeyType = iDevice.LinkKeyType(); // The link key type hasn't changed

		break;

	case ELocalUnitKey:

	case ERemoteUnitKey:

	default:

		LOG1(_L("CPhysicalLink: Unexpected link key type (%d)"), aLinkKeyType);

		__ASSERT_DEBUG(EFalse, Panic(EBTUnexpectedLinkKeyType));

		break;

		}

	if (linkKeyType == ELinkKeyCombination && iNewPinCodeValid)

		{

		// Only bind a PIN code to the device if we receive a link key based on it.

		iNewPinCodeValid = EFalse;

		iDevice.SetPassKey(iNewPinCode);

		}

	if (iLinksMan.SecMan().IsDedicatedBondingAttempted(iDevice.Address()))

		{

		iLinkKeyObtainedThroughDedicatedBonding = ETrue;

		}

	SetLinkKey(aLinkKey, linkKeyType);	// keeps a copy in our 'cache', updates paired list in PHYs mananger