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

//

#include <bluetooth/logger.h>

#include <bluetooth/hci/hciutil.h>

#include "secman.h"

#include "secevent.h"

#include "hostresolver.h"

#include "pairingserver.h"

#include "oobdata.h"

#include "simplepairingresult.h"

#include "btaccessrequesterstatemachine.h"

#ifdef BT_LINKMGR_V2

#include "physicallinks.h"

#include "physicallinksmanager.h"

#else

#include "PhysicalLinks.h"

#include "PhysicalLinksManager.h"

#endif

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_SECMAN);

#endif

#ifdef _DEBUG

PANICCATEGORY("secman");

#endif

static const TInt KBTSecManAccessRequesterArrayGranularity = 4;

static const TInt KBTSecManNotifierRequesterArrayGranularity = 4;

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

//class CBTSecMan

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

CBTSecMan* CBTSecMan::NewL()

	{

	LOG_STATIC_FUNC

	CBTSecMan* self = CBTSecMan::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CBTSecMan* CBTSecMan::NewLC()

	{

	LOG_STATIC_FUNC

	CBTSecMan* self = new(ELeave) CBTSecMan();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CBTSecMan::CBTSecMan()

	: iAccessRequesters(KBTSecManAccessRequesterArrayGranularity)

	, iPendingAccessRequesters(KBTSecManAccessRequesterArrayGranularity)

	, iNotifierRequesters(KBTSecManNotifierRequesterArrayGranularity)

	, iLocalSimplePairingMode(EFalse)

	, iDebugMode (EFalse)

	{

	LOG_FUNC

	}

void CBTSecMan::ConstructL()

	{

	LOG_FUNC

	iStateMachine = CBTAccessRequesterStateFactory::NewL();

	iCommandController = CSecManCommandController::NewL(*this);

	iOobDataManager = COobDataManager::NewL(*this);

	iSimplePairingResultList = CSimplePairingResultList::NewL();

	iAuthenticationResultList = CAuthenticationResultList::NewL();

	iPairingServer = CPairingServer::NewL(*iOobDataManager, *iSimplePairingResultList, *iAuthenticationResultList);

	}

void CBTSecMan::SetLocalSimplePairingMode(TBool aEnabled)

	{

	LOG_FUNC

	iLocalSimplePairingMode=aEnabled;

	}

TBool CBTSecMan::LocalSimplePairingMode() const

	{

	LOG_FUNC

	return iLocalSimplePairingMode;

	}

void CBTSecMan::SimplePairingSupportDetermined(const TBTDevAddr& aBDAddr)

	{

	LOG_FUNC

	// Pending requesters must be notified first than the active requester. 

	// Otherwise it wouldn't work properly and pending requesters would not be notified at all.

	for (TInt i=0; i<iPendingAccessRequesters.Count(); i++)

		{

		CBTAccessRequester* requester = iPendingAccessRequesters[i];

		if (requester->DeviceAddress() == aBDAddr && requester->BasebandConnected())

			{

			TBTSecEvent event(TBTSecEvent::EPhysicalLinkUp);

			requester->SendEvent(event);

			}	

		}

	CBTAccessRequester* requester = this->FindActiveAccessRequester(aBDAddr);

	// There should only be one active access requester

	if (requester && requester->BasebandConnected())

		{

		TBTSecEvent event(TBTSecEvent::EPhysicalLinkUp);

		requester->SendEvent(event);

		}

	}

void CBTSecMan::SetPhysicalLinksMgr(const CPhysicalLinksManager& aConnectionsMgr)

	{

	LOG_FUNC

	iPhysicalLinksManager = &const_cast<CPhysicalLinksManager&>(aConnectionsMgr);

	iPairingServer->SetPhysicalLinksManager(*iPhysicalLinksManager);

	}

void CBTSecMan::ClearPhysicalLinksMgr()

	{

	LOG_FUNC

	iPhysicalLinksManager = NULL;

	iPairingServer->ClearPhysicalLinkMgr();

	}

// Passes a reference to the LinksMgrProtocol ultimately to the PairingServer 

void CBTSecMan::SetLinksMgrProtocol(CLinkMgrProtocol& aLinkMgrProtocol)

	{

	LOG_FUNC

	iPairingServer->SetLinksMgrProtocol(aLinkMgrProtocol);

	}

void CBTSecMan::ClearLinksMgrProtocol()

	{

	LOG_FUNC

	iPairingServer->ClearLinksMgrProtocol();

	}

void CBTSecMan::SetHCICommandQueue(MHCICommandQueue& aCommandQueue)

	{

	LOG_FUNC

	iCommandController->SetHCICommandQueue(aCommandQueue);

	iOobDataManager->SetHCICommandQueue(aCommandQueue);

	}

void CBTSecMan::ClearHCICommandQueue()

	{

	LOG_FUNC

	iCommandController->ClearHCICommandQueue();

	iOobDataManager->ClearHCICommandQueue();

	}

CPhysicalLinksManager& CBTSecMan::ConnectionsManager() const

	{

	LOG_FUNC

	__ASSERT_ALWAYS(iPhysicalLinksManager, PANIC(KBTSecPanic,EBTSecNullPhysicalLinksManager));

	return *iPhysicalLinksManager;

	}

COobDataManager& CBTSecMan::OobDataManager() const

	{

	LOG_FUNC

	return *iOobDataManager;

	}

TBool CBTSecMan::DebugMode() const

	{

	LOG_FUNC

	return iDebugMode;

	}

void CBTSecMan::SetDebugMode(TBool aOn)

	{

	LOG_FUNC

	// SecMan owns the policy about simple pairing debug mode - here we only allow it to be 

	// turned on.  So ignore any "off" requests.  (Stack must be unloaded for debug mode to be

	// turned off).

	if(aOn && !iDebugMode)

		{

		// First try to set debug mode. If we fail to send the command then we will just be

		// stuck in non-debug mode...

		static const TUint8 KSimplePairingDebugModeEnabled = 0x01;

		TRAP_IGNORE(iCommandController->WriteSimplePairingDebugModeL(KSimplePairingDebugModeEnabled));

		}

	}

void CBTSecMan::ClearDebugMode()

	{

	LOG_FUNC

	// Used to clear debug mode when the stack is reset

	iDebugMode = EFalse;

	ConnectionsManager().SimplePairingDebugModeChanged(EFalse);

	}

void CBTSecMan::DebugModeChanged(TBool aOn)

	{

	__ASSERT_DEBUG(aOn, PANIC(KBTSecPanic, EBTSecDebugModeTurnedOff));

	iDebugMode = aOn;

	ConnectionsManager().SimplePairingDebugModeChanged(aOn);

	}

CBTSecMan::~CBTSecMan()

	{

	LOG_FUNC

	iAccessRequesters.ResetAndDestroy();

	iAccessRequesters.Close();

	iPendingAccessRequesters.ResetAndDestroy();

	iPendingAccessRequesters.Close();

	iNotifierRequesters.ResetAndDestroy();

	iNotifierRequesters.Close();

	delete iStateMachine;

	delete iCommandController;

	delete iPairingServer;

	delete iOobDataManager;

	delete iSimplePairingResultList;

	delete iAuthenticationResultList;

	}

CBTAccessRequester* CBTSecMan::FindActiveAccessRequester(const TBTDevAddr& aAddr) const

	{

	LOG_FUNC

	CBTAccessRequester* ret = NULL;

	TInt ix = iAccessRequesters.Find(aAddr, CompareAccessRequesterByBDAddr);

	if(ix >= 0)

		{

		ret = iAccessRequesters[ix];

		}

	return ret;

	}

TBool CBTSecMan::CompareAccessRequesterByBDAddr(const TBTDevAddr* aKey, const CBTAccessRequester& aAccessRequester)

	{

	LOG_STATIC_FUNC

	return (!aKey || (*aKey) == aAccessRequester.DeviceAddress());

	}

TBool CBTSecMan::CompareAccessRequesterByRequester(const MAccessRequestResponseHandler* aKey, const CBTAccessRequester& aAccessRequester)

	{

	LOG_STATIC_FUNC

	return aKey == &aAccessRequester.ServiceRequester();

	}

void CBTSecMan::AccessRequestL(const TBTServiceSecurity& aSecurity,

							   const TBTServiceSecurityPerDevice* const aOverride,

							   const TBTDevAddr& aBDAddr,

							   TAccessType aAccessType,

							   MAccessRequestResponseHandler& aRequester)

/**

Handle an access request...

Create a new CBTAccessRequester object to handle the request.

**/

	{

	LOG_FUNC

#ifdef _DEBUG

	// Check that a service isn't queuing multiple access requesters.

	TInt ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecServiceTryingToQueueMultipleAccessRequesters));

	ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecServiceTryingToQueueMultipleAccessRequesters));

#endif // _DEBUG

	// find the baseband this SAP is running on

	CPhysicalLink& con = *iPhysicalLinksManager->FindPhysicalLink(aBDAddr);

	CBTAccessRequester* p = CBTAccessRequester::NewLC(con, aSecurity,

													  aOverride,

													  aRequester,

													  aAccessType,

													  *this);

	CBTAccessRequester* requester = FindActiveAccessRequester(aBDAddr);

	if(requester)

		{

		User::LeaveIfError(iPendingAccessRequesters.Append(p));

		CleanupStack::Pop(p); //clean up of p now handled by iPendingAccessRequesters

		}

	else

		{

		User::LeaveIfError(iAccessRequesters.Append(p));

		CleanupStack::Pop(p); //clean up of p now handled by iAccessRequesters

		// Try to start- it may not happen (depends on if device retrieved from registry)

		p->Start();

		}

	}

void CBTSecMan::CancelRequest(MAccessRequestResponseHandler& aRequester)

	{

	LOG_FUNC

	// search through access requesters to find correct one

	LOG1(_L8("\tCBTSecMan::CancelRequest from SAP 0x%08x"), &aRequester)

	CBTAccessRequester* request = NULL;

	TInt ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

	if(ix >= 0)

		{

		request = iAccessRequesters[ix];

		}

	else

		{

		ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

		if(ix >= 0)

			{

			request = iPendingAccessRequesters[ix];

			}

		}

	if(request)

		{

		static_cast<void>(FinishAccessRequest(request)); // don't need to call back to requester...

		}

#ifdef _DEBUG

	// Do a sanity test to check that there aren't multiple access requesters per service

	ix = iAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecMultipleActiveAccessRequestersForService));

	ix = iPendingAccessRequesters.Find(aRequester, CompareAccessRequesterByRequester);

	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KBTSecPanic, EBTSecMultiplePendingAccessRequestersForService));

#endif // _DEBUG

	}

void CBTSecMan::GetPassKeyLengthAndOriginator(const TBTDevAddr& aAddr, TUint& aPasskeyMinLength,

											  TBool& aLocallyInitiatedAuthentication,

											  TBool& aStrongKeyRequired)

/**

If authorisation request was initiated locally it will return true and will

return the passkey minimal length requred by user

**/

	{

	LOG_FUNC

	TUint tmpPasskeyLength = 0;

	TBluetoothMitmProtection mitmReqs = EMitmNotRequired;

	TBool locallyInitiated = EFalse;

	TInt count = iAccessRequesters.Count();

	aStrongKeyRequired = EFalse;

	// find all pending AccessRequesters for given BTAddr and find maximum of PasskeyMinLength

	if(count != 0)

		{

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

			{

			CBTAccessRequester* requester = iAccessRequesters[i];

			if (requester->IsAuthenticationReqPending(aAddr, tmpPasskeyLength, mitmReqs))

				{

				locallyInitiated = ETrue;

				if (aPasskeyMinLength < tmpPasskeyLength)

					{

					aPasskeyMinLength = tmpPasskeyLength;

					}

				if(mitmReqs == EMitmRequired)

					{

					aStrongKeyRequired = ETrue;

					}

				}

			}

		}

	aLocallyInitiatedAuthentication = locallyInitiated;

	}

TBool CBTSecMan::IsDedicatedBondingAttempted(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

	if(requester && (requester->AccessType() == EDedicatedBonding) )

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

TBool CBTSecMan::IsOutboundAccessRequest(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	// For now the only outbound access request is for dedicated bonding

	// attempts (so we share the code).

	return IsDedicatedBondingAttempted(aAddr);

	}

void CBTSecMan::AuthenticationInProgress()

/**

When authentication request was sent to HW, HCI will notify SecMan

**/

	{

	LOG_FUNC

	// find first pending AccessRequesters and set AuthenticationInProgress flag

	for (TInt i=0; i<iAccessRequesters.Count(); i++)

		{

		CBTAccessRequester* requester = iAccessRequesters[i];

		if (requester->AuthenticationRequired() && !requester->AuthenticationInProgress())

			{

			TBTSecEvent event(TBTSecEvent::EAuthenticationRequested);

			requester->SendEvent(event);

			break;

			}

		}

	}

void CBTSecMan::IOCapabilityRequestFromRemote(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

	if(requester)

		{

		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

		TBTSecEvent event(TBTSecEvent::EIOCapsRequested);

		requester->SendEvent(event);

		}

	else

		{

		LOG(_L8("\tCBTAccessRequester NOT FOUND!\n"));

		CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

		__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing)); // If we've got an IO Capability Response we should have a link

		if(link->IsPairable())

			{

			link->SetAuthenticationPending(ESimplePairingPending);

			THCIOobDataPresence oobPresence = EOOBDataNotPresent;

			if (link->HasRemoteOobData())

				{

				oobPresence = EOOBDataPresent;

				}

			THCIAuthenticationRequirement authReq = link->AuthenticationRequirement();

			switch(authReq)

				{

				case EMitmNotReqNoBonding:

				case EMitmNotReqDedicatedBonding:

				case EMitmNotReqGeneralBonding:

					link->SetLocalMITM(EFalse);

					break;

				case EMitmReqNoBonding:

				case EMitmReqDedicatedBonding:

				case EMitmReqGeneralBonding:

					link->SetLocalMITM(ETrue);

					break;

				default:

					PANIC(KBTSecPanic, EBTSecUnexpectedIoCapability);

					break;    

				}

			TRAP_IGNORE(iCommandController->IOCapabilityRequestReplyL(aAddr, EIOCapsDisplayYesNo, oobPresence, authReq));

			}

		else

			{

			TRAP_IGNORE(iCommandController->IOCapabilityRequestNegativeReplyL(aAddr, EPairingNotAllowed));

			}

		}

	}

void CBTSecMan::IOCapabilityAskForResponse(const TBTDevAddr& aAddr,

										THCIIoCapability aIOCapability,

										THCIOobDataPresence aOOBDataPresent,

										THCIAuthenticationRequirement aAuthenticationRequirements)

	{

	LOG_FUNC

	CPhysicalLink* link = iPhysicalLinksManager->FindPhysicalLink(aAddr);

	__ASSERT_ALWAYS(link, PANIC(KBTSecPanic, EBTSecPhysicalLinkMissing)); // If we've got an IO Capability Response we should have a link

	link->IOCapabilityAskForResponse(aIOCapability, aOOBDataPresent, aAuthenticationRequirements);

	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

	if(requester)

		{

		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

		TBTSecEventIoCapabilityResponse event(aIOCapability, aOOBDataPresent, aAuthenticationRequirements);

		requester->SendEvent(event);

		}

	}

void CBTSecMan::RemoteOOBDataRequest(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	CBTAccessRequester* requester = FindActiveAccessRequester(aAddr);

	if(requester)

		{

		LOG(_L8("\tCBTAccessRequester FOUND!\n"));

		TBTSecEvent event(TBTSecEvent::ERemoteOOBDataRequested);

		requester->SendEvent(event);

		}

	TBluetoothSimplePairingHash hashC;

	TBluetoothSimplePairingRandomizer randomizerR;

	if(OobDataManager().GetRemoteOobData(aAddr, hashC, randomizerR))

		{

		TRAP_IGNORE(iCommandController->RemoteOOBDataRequestReplyL(aAddr, hashC, randomizerR));

		}

	else

		{

		TRAP_IGNORE(iCommandController->RemoteOOBDataRequestNegativeReplyL(aAddr));

		}

	}

void CBTSecMan::RemoteOOBDataRequestComplete(const TBTDevAddr& aAddr)

	{

	LOG_FUNC