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

//

#include <bluetooth/logger.h>

#include "secman.h"

#include "secevent.h"

#include "hostresolver.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("btaccreq");

#endif

/**

	class CBTAccessRequester

	The access requester handles the state machine involved in allowing accesses:

	setting authentication, entering PINs, asking for authorisation and encrypting

	This class deals only with security procedures we initiate (which could be for

	inbound or outbound connections)

*/

CBTAccessRequester* CBTAccessRequester::NewLC(CPhysicalLink& aConnection,

											  const TBTServiceSecurity& aSecurityRequired,

											  const TBTServiceSecurityPerDevice* const aOverride,

											  MAccessRequestResponseHandler& aRequester,

											  TAccessType aAccessType,

											  CBTSecMan& aParent)

	{

	LOG_STATIC_FUNC

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CBTAccessRequester::CBTAccessRequester(CPhysicalLink& aConnection,

									   const TBTServiceSecurity& aServiceSecurity,

									   const TBTServiceSecurityPerDevice* const aOverride,

									   MAccessRequestResponseHandler& aRequester,

									   TAccessType aAccessType,

									   CBTSecMan& aParent)

	: iRequester(aRequester)

	, iSecMan(aParent)

	, iBaseband(&aConnection)

	, iDevAddr(aConnection.BDAddr())

	, iServiceRequirements(aServiceSecurity)

	, iOverride(aOverride)

	, iIsSubscribedToConnection(EFalse)

	, iDeviceRetrievedFromRegistry(EFalse)

	, iQueLink(this)

	, iPrefetchQueueLink(this)

	, iAuthenticationInProgress(EFalse)

	, iAccessType(aAccessType)

	, iRemoteIndicatedNoBonding(EFalse)

	, iCurrentState(EBTUninitialised)

	{

	LOG_FUNC

	// try to get name for UI dialogs

	SetDeviceName();

	}

CBTAccessRequester::~CBTAccessRequester()

	{

	LOG_FUNC

	if (iBaseband && iIsSubscribedToConnection)

		{

		iBaseband->UnsubscribeLinkObserver(*this);

		}

	iPrefetchQueueLink.Deque();

	delete iAuthorisor;

	delete iTimer;

	}

void CBTAccessRequester::ConstructL()

	{

	LOG_FUNC

	iTimer = CAuthenticationTimer::NewL(*this);

	SubscribeToLinkObserver();

	}

void CBTAccessRequester::SubscribeToLinkObserver()

	{

	LOG_FUNC

	iBaseband->SubscribeLinkObserver(*this);

	iIsSubscribedToConnection = ETrue;

	if (BasebandConnected() && iBaseband->SimplePairingMode() != EPhySimplePairingUndefined)

		{

		TBTSecEvent event(TBTSecEvent::EPhysicalLinkUp);

		SendEvent(event);

		}

	}

//

// Events

//

template<class XDerivedSecEventType, TBTSecEvent::TEventType XEventType>

XDerivedSecEventType* DynamicEventCast(TBTSecEvent* aEvent)

	{

	if(aEvent && aEvent->Event() == XEventType)

		{

		return static_cast<XDerivedSecEventType*>(aEvent);

		}

	return NULL;

	}

TBTSecEventStart* TBTSecEventStart::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventStart, EStart>(aEvent);

	}

TBTSecEventAuthorisationComplete* TBTSecEventAuthorisationComplete::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventAuthorisationComplete, EAuthorisationComplete>(aEvent);

	}

TBTSecEventIoCapabilityResponse* TBTSecEventIoCapabilityResponse::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventIoCapabilityResponse, EIOCapsResponse>(aEvent);

	}

TBTSecEventIoCapabilityRequested* TBTSecEventIoCapabilityRequested::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventIoCapabilityRequested, EIOCapsRequested>(aEvent);

	}

TBTSecEventKeypressEntry* TBTSecEventKeypressEntry::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventKeypressEntry, EKeypressEntry>(aEvent);

	}

TBTSecEventUserConfirmationRequest* TBTSecEventUserConfirmationRequest::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventUserConfirmationRequest, EUserConfirmationRequested>(aEvent);

	}

TBTSecEventRemoteOOBDataRequest* TBTSecEventRemoteOOBDataRequest::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventRemoteOOBDataRequest, ERemoteOOBDataRequested>(aEvent);

	}

TBTSecEventPhysicalLinkUp* TBTSecEventPhysicalLinkUp::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventPhysicalLinkUp, EPhysicalLinkUp>(aEvent);

	}

TBTSecEventAuthenticationComplete* TBTSecEventAuthenticationComplete::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventAuthenticationComplete, EAuthenticationComplete>(aEvent);

	}

TBTSecEventEncryptionChangeComplete* TBTSecEventEncryptionChangeComplete::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventEncryptionChangeComplete, EEncryptionChangeComplete>(aEvent);

	}

TBTSecEventAuthenticationRequested* TBTSecEventAuthenticationRequested::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventAuthenticationRequested, EAuthenticationRequested>(aEvent);

	}

TBTSecEventRequestAuthentication* TBTSecEventRequestAuthentication::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventRequestAuthentication, ERequestAuthentication>(aEvent);

	}

TBTSecEventAuthorisationRequested* TBTSecEventAuthorisationRequested::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventAuthorisationRequested, EAuthorisationRequested>(aEvent);

	}

TBTSecEventRequestAuthorisation* TBTSecEventRequestAuthorisation::Cast(TBTSecEvent* aEvent)

	{

	return DynamicEventCast<TBTSecEventRequestAuthorisation, ERequestAuthorisation>(aEvent);

	}

// This function is expected to be re-entrant

TBool CBTAccessRequester::SendEvent(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	LOG2(_L8("iCurrentState = %d, aEvent.Event() = %d"), iCurrentState, aEvent.Event());

	TInt err = KErrNotFound; // Let the caller know if the event has been accepted and therefore is being handled ok.

	err = iSecMan.StateMachine()->ProcessRequesterState(iCurrentState, *this, aEvent);

	if(err != KErrNone)

		{

		__ASSERT_DEBUG(err != KErrNotFound, PANIC(KBTSecPanic, EBTSecCouldNotFindStateTransition));

		CompleteRequest(err);

		return EFalse;

		}

	return ETrue;

	}

void CBTAccessRequester::Ready(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEvent* event = TBTSecEventPhysicalLinkUp::Cast(&aEvent);

	event = event ? event : TBTSecEventStart::Cast(&aEvent);

	__ASSERT_DEBUG(event, PANIC(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	iRequirements = OverallRequirements(iServiceRequirements, iBaseband->RemoteDevice());

	if (AuthenticationRecommended())

		{

		LOG(_L8("\tAuthentication recommended"))

		/* For dedicated bonding we always want to request authentication (even if we are already authenticated)

		 * so that we can upgrade the linkkey if the new linkkey is stronger.

		 */

		if(iBaseband->Authenticated() && LinkKeyGoodEnough() && (iAccessType != EDedicatedBonding))

			{

			TBTSecEvent newevent(TBTSecEvent::EAuthenticationComplete);

			SendEvent(newevent);

			}

		else

			{

			LOG(_L8("\tPhysical link needs to be authenticated"))

			TBTSecEvent newevent(TBTSecEvent::ERequestAuthentication);

			SendEvent(newevent);

			}

		}

	else

		{

		LOG(_L8("\tAuthentication is not required or recommended"))

		TBTSecEvent newevent(TBTSecEvent::EAuthenticationComplete);

		SendEvent(newevent);

		}

	}

void CBTAccessRequester::RequestAuthentication(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventRequestAuthentication* event = TBTSecEventRequestAuthentication::Cast(&aEvent);

	__ASSERT_DEBUG(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	// Here we issue the request if authentication is "recommended" - not neccessarily required.

	if	(

		AuthenticationRecommended()

		&&

			(

			!iBaseband->Authenticated()

			||

			!LinkKeyGoodEnough()

			||

			iAccessType == EDedicatedBonding

			)

		)

		{

		LOG(_L8("\tAuthentication required..."));

		LOG(_L8("\tStarting Authentication..."));

		if(iBaseband->Authenticate(iRequirements.MitmProtection() != EMitmNotRequired) !=KErrNone)

			{

			// the remote device is authenticated, but longer passkey is required

			CompleteRequest(EBTSecManAccessDenied);

			}

		else

			{

			SetAuthenticationInProgress();

			// Pending authentication...

			}

		}

	else

		{

		LOG(_L8("\tAuthentication not required go to next state"))

		TBTSecEvent event(TBTSecEvent::EAuthenticationComplete);

		SendEvent(event);

		}

	}

void CBTAccessRequester::AuthenticationRequested(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventAuthenticationRequested* event = TBTSecEventAuthenticationRequested::Cast(&aEvent);

	__ASSERT_DEBUG(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	if(aEvent.Error() == KErrNone)

		{

		// Start guard timer?

		iTimer->Start();

		SetAuthenticationInProgress();

		// Pending authentication...

		}

	else

		{

		CompleteRequest(EBTSecManAccessDenied);

		}

	}

void CBTAccessRequester::AuthenticationComplete(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventAuthenticationComplete* event = TBTSecEventAuthenticationComplete::Cast(&aEvent);

	__ASSERT_DEBUG(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	iTimer->Cancel();

	// Here we check that we have successfully authenticated the link before progressing to the

	// next stage (encryption).  Here success is considered as when ...

	if (

		!AuthenticationRequired() // either authentication is not required...

		|| // or authentication is required...

			( 

			iBaseband->Authenticated() // and the phys is already authenticated, ...

			&&

			LinkKeyGoodEnough() // and the link key is of a sufficient strength.

			)

		)

			{

			// Initiate encryption

			TBTSecEvent newevent(TBTSecEvent::ERequestEncryptionChange);

			SendEvent(newevent);

			}

		else if (

				aEvent.Error() == ELMPErrorTransactionCollision

				||

				aEvent.Error() == EDifferentTransactionCollision

				)

			{

			// Re-attempt authentication request

			TBTSecEvent newevent(TBTSecEvent::ERequestAuthentication);

			SendEvent(newevent);

			}

		else if(aEvent.Error() == ERemoteUserEndedConnection)

			{

			// If end user brough the connection down then we'll see a disconnection in

			// a minute - and that will handle prefetch cases.

			}

		else

			{

			// Failed to set-up authentication conditions required by the access requester.

			CompleteRequest(EBTSecManAccessDenied);

			}

	} 

void CBTAccessRequester::EncryptionChangePending(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	switch(aEvent.Event())

		{

		case TBTSecEvent::ERequestEncryptionChange:

			{

			if(EncryptionRequired() && !iBaseband->Encrypted())

				{

				LOG(_L8("\tEncryption required..."))

				if (!iBaseband->IsEncryptionDisabledForRoleSwitch())

					{

					TInt err = iBaseband->ChangeEncryption(EPointToPointEncryption);

					if(err!=KErrNone)

						{

						CompleteRequest(EBTSecManAccessDenied);

						}

						// Pending encryption...

					}

					// Pending encryption...

				}

			else

				{

				TBTSecEvent event(TBTSecEvent::EEncryptionChangeComplete);

				SendEvent(event);

				}

			}

		break;

		case TBTSecEvent::EEncryptionChangeRequested:

			// start guard timer

			iTimer->Start();

		break;

		default:

			User::Panic(KBTSecPanic,EBTSecUnexpectedStateMachineEventId);

		break;

		}

	}

void CBTAccessRequester::EncryptionChangeComplete(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventEncryptionChangeComplete* event = TBTSecEventEncryptionChangeComplete::Cast(&aEvent);

	__ASSERT_DEBUG(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	// cancel guard timer

	iTimer->Cancel();

	// We can try again if there was a race with some other PHY modification

	// Curiously, the firmware always return ELMPErrorTransactionCollision (0x23) for both

	// kinds of transaction collisions (0x23,0x2a), we guard against both situations here

	// anyway just to be safe.

	if((aEvent.Error() == ELMPErrorTransactionCollision) || (aEvent.Error() == EDifferentTransactionCollision))

		{	

		// This will force the state machine logic to try sending the command again

		TBTSecEvent newevent(TBTSecEvent::ERequestEncryptionChange);

		SendEvent(newevent);

		}

	else if((aEvent.Error() == KErrNone) && 

				(!EncryptionRequired() || // The extra checks may not be needed...

				(EncryptionRequired() && iBaseband->Encrypted())))

		{

		TBTSecEvent newevent(TBTSecEvent::ERequestAuthorisation);

		SendEvent(newevent);

		}

	else

		{

		CompleteRequest(EBTSecManAccessDenied);

		}

	}

void CBTAccessRequester::RequestAuthorisation(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventRequestAuthorisation* event = TBTSecEventRequestAuthorisation::Cast(&aEvent);

	__ASSERT_ALWAYS(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	if (iRequirements.AuthorisationRequired())

		{

		LOG(_L8("\tAuthorisation required..."))

		LOG(_L8("\tStarting Authorisation..."))

		__ASSERT_ALWAYS(!iAuthorisor, User::Panic(KBTSecPanic,EBTSecAuthorisationRequestAlreadyExists));

		TRAPD(err,iAuthorisor = CBTAuthorisor::NewL(*this, iSecMan, iServiceRequirements.Uid()));

		if(err != KErrNone)

			{

			// the remote device is authenticated, but longer passkey is required

			CompleteRequest(EBTSecManAccessDenied);

			}

			// Pending authorisation...

		}

	else

		{

		TBTSecEventAuthorisationComplete event(ETrue);

		SendEvent(event);

		}

	}

void CBTAccessRequester::AuthorisationRequested(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventAuthorisationRequested* event = TBTSecEventAuthorisationRequested::Cast(&aEvent);

	__ASSERT_ALWAYS(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	iTimer->Start();

	}

void CBTAccessRequester::AuthorisationComplete(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventAuthorisationComplete* event = TBTSecEventAuthorisationComplete::Cast(&aEvent);

	__ASSERT_DEBUG(event, User::Panic(KBTSecPanic, EBTSecUnexpectedStateMachineEventId));

	// cancel guard timer

	iTimer->Cancel();

	if(event->Error() != KErrNone && iRequirements.AuthorisationRequired())

		{

		CompleteRequest(EBTSecManAccessDenied);

		}

	else

		{

		if(event->AccessAllowed())

			{

			CompleteRequest(EBTSecManAccessGranted);

			}

		else

			{

			CompleteRequest(EBTSecManAccessDenied);

			}

		}

	}

void CBTAccessRequester::IOCapsResponse(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventIoCapabilityResponse* event = TBTSecEventIoCapabilityResponse::Cast(&aEvent);

	__ASSERT_ALWAYS(event, User::Panic(KBTSecPanic,EBTSecBadStateMachineEvent));

	// store/do something with the remote device's IO caps

	iRemoteIOCapability = event->IoCapability();

	iRemoteOOBDataPresence = event->OobDataPresent();

	// If remote device says "no bonding" when asked for dedicated

	// bonding, remember this for sending a negative reply later

	THCIAuthenticationRequirement authReq = event->AuthenticationRequirements();

	if (iAccessType == EDedicatedBonding && (authReq == EMitmReqNoBonding || authReq == EMitmNotReqNoBonding))

		{

		iRemoteIndicatedNoBonding = ETrue;

		}

	}

void CBTAccessRequester::IOCapsRequested(TBTSecEvent& aEvent)

	{

	LOG_FUNC

	TBTSecEventIoCapabilityRequested* event = TBTSecEventIoCapabilityRequested::Cast(&aEvent);

	__ASSERT_ALWAYS(event, User::Panic(KBTSecPanic,EBTSecBadStateMachineEvent));

	// Send local IO caps to remote device

	// Host and Controller supports SSP.