// 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 "secman.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("secman");

#endif

#pragma warning (disable: 4355) //'this' in base init list - is OK for our usage

static const TInt KBTSecManAccessRequesterArrayGranularity = 4;

static const TInt KBTSecManNotifierRequesterArrayGranularity = 4;

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

//class CBTSecMan

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

void Panic(TBTSecPanic aPanic)

	{

	LOG_FUNC

	User::Panic(KBTSecPanic, aPanic);

	}

CBTSecMan* CBTSecMan::NewL()

	{

	LOG_FUNC

	CBTSecMan* self = CBTSecMan::NewLC();

	CleanupStack::Pop();	//self

	return self;

	}

CBTSecMan* CBTSecMan::NewLC()

	{

	LOG_FUNC

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CBTSecMan::CBTSecMan()

	: iAccessRequesters(KBTSecManAccessRequesterArrayGranularity),

	  iNotifierRequesters(KBTSecManNotifierRequesterArrayGranularity)

	{

	LOG_FUNC

	}

void CBTSecMan::ConstructL()

	{

	LOG_FUNC

	}

void CBTSecMan::SetPhysicalLinksMgr(const CPhysicalLinksManager& aConnectionsMgr)

	{

	LOG_FUNC

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

	}

CPhysicalLinksManager& CBTSecMan::ConnectionsManager() const

	{

	LOG_FUNC

	return *iPhysicalLinksManager;

	}

CBTSecMan::~CBTSecMan()

	{

	LOG_FUNC

	iAccessRequesters.ResetAndDestroy();

	iAccessRequesters.Close();

	iNotifierRequesters.ResetAndDestroy();

	iNotifierRequesters.Close();

	}

void CBTSecMan::AccessRequestL(const TBTServiceSecurity& aSecurity,

							   const TBTServiceSecurityPerDevice* const aOverride,

							   const TBTDevAddr& aBDAddr,

							   MAccessRequestResponseHandler& aRequester)

/**

Handle an access request...

Create a new CBTAccessRequester object to handle the request.

**/

	{

	LOG_FUNC

	// find the baseband this SAP is running on

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

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

													  aOverride,

													  aRequester,

													  *this);

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

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

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

	p->DoRequest();

	}

void CBTSecMan::CancelRequest(MAccessRequestResponseHandler& aRequester)

	{

	LOG_FUNC

	// search through access requesters to find correct one

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

	TInt count = iAccessRequesters.Count();

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

		{

		CBTAccessRequester* requester = iAccessRequesters[i];

		if(&requester->ServiceRequester() == &aRequester)

			{

			// should assert that aRequester is the same as in AccessRequester?

			LOG(_L("sec\tRemoving AccessRequester..."))

			iAccessRequesters.Remove(i);

			delete requester;

			break;

			}

		}

	}

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

				   	   					      TBool& aLocallyInitiatedAuthentication)

/**

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;

	TBool locallyInitiated = EFalse;

	TInt count = iAccessRequesters.Count();

	if (count == 0)

		{

		aLocallyInitiatedAuthentication = EFalse;

		return;

		}

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

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

		{

		CBTAccessRequester* requester = iAccessRequesters[i];

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

			{

			locallyInitiated = ETrue;

			if (aPasskeyMinLength < tmpPasskeyLength)

				{

				aPasskeyMinLength = tmpPasskeyLength;

				}

			}	

		}

	aLocallyInitiatedAuthentication = locallyInitiated;		

	}

void CBTSecMan::AuthenticationInProgress()

/**

When authorisation 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())

			{

			requester->SetAuthenticationInProgress();

			break;

			}		

		}

	}

void CBTSecMan::AccessRequestComplete(CBTAccessRequester* aAccessRequester, TInt aResult)

/**

The access request has been fully completed.

Delete the CBTAccessRequester that was handling the request.

**/

	{

	LOG_FUNC

	TInt count = iAccessRequesters.Count();

	ASSERT_DEBUG(count);

	// find the originating service *now*

	MAccessRequestResponseHandler& service = const_cast<MAccessRequestResponseHandler&>

											(aAccessRequester->ServiceRequester());

	// clean up the AccessRequester object

	TInt i;

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

		{

		//find aRequester in iAccessRequesters and delete it

		if(iAccessRequesters[i] == aAccessRequester)

			{

			iAccessRequesters.Remove(i);

			delete aAccessRequester;

			aAccessRequester = NULL;

			break;

			}

		}

	//compress the array if needs be

	if ((count!=0) && (i!=count))

		{

		iAccessRequesters.GranularCompress();

		}

	// now tell the service

	service.AccessRequestComplete(aResult);

	}

void CBTSecMan::AddNotifierRequestToQueL(CSecNotifierRequester& aRequest)

/**

Add notifier request to front of queue.  If there are no other requests already in the queue,

initiate this request.

**/

	{

	LOG_FUNC

	TInt count = iNotifierRequesters.Count();

	User::LeaveIfError(iNotifierRequesters.Insert(&aRequest,0));	//add to front of queue since requests are taken from the back

	if (count == 0)	//ok since count was calculated before we inserted the new element

		{

		iActiveNotifierRequester = &aRequest;

		aRequest.DoRequest();

		}

	else

		{

		LOG(_L("Secman: Request NOT initiated, should start later..."));

		}

	}

void CBTSecMan::RemoveNotifierRequestFromQue(CSecNotifierRequester& aRequest)

/**

Remove the request from the queue.  If aRequest is the currently active request then we can activate

the next one in the queue.  Otherwise, aRequest is being deleted prematurely and we must simply

remove it from the array.

**/

	{

	LOG_FUNC

	LOG(_L("sec\tCBTSecMan - removing notifier request from queue"));

	TInt count = iNotifierRequesters.Count();

	TInt found = 0;

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

		{

		if (iNotifierRequesters[i] == &aRequest)

			{

			found++;

			iNotifierRequesters.Remove(i);

			}

		}

	__ASSERT_DEBUG(found, User::Panic(KBTSecPanic, EBTSecBadNotifierArray));

	if (&aRequest == iActiveNotifierRequester)

		{

		//start the next request if there is one...

		count = iNotifierRequesters.Count();

		if (count > 0)

			{

			LOG(_L("sec\tCBTSecMan - auto-starting next notifier request from queue"));

			iActiveNotifierRequester = iNotifierRequesters[count-1];

			iActiveNotifierRequester->DoRequest();

			}

		}

	}

CSecNotifierRequester::CSecNotifierRequester(CBTSecMan& aSecMan)

: CActive(EPriorityStandard),

  iInquiryMgr(aSecMan.ConnectionsManager().LinkManagerProtocol().InquiryMgr()),

  iSecMgr(aSecMan)

	{

	LOG_FUNC

	}

void CSecNotifierRequester::ConstructL(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	User::LeaveIfError(iNotifier.Connect());

	// find the name at this stage for this device - may not be there yet

	iDeviceName = iInquiryMgr.DeviceNameFromCache(aAddr);

	if (!iDeviceName || iDeviceName->Length() ==0)

		{

		// cache didn't have name - so we'll ask for it as a HR action

		TRAP_IGNORE(iHR = iInquiryMgr.NewHostResolverL());

		iHRNameRecord = new TNameRecord;

		// ignore error - only an optimisation - don't want to leave if there's

		// a problem doing this optimisation

		if (iHR && iHRNameRecord)

			{

			iHR->SetNotify(this);

			TInquirySockAddr i;

			i.SetAction(KHostResName);

			i.SetBTAddr(aAddr);

			iHRNameRecord->iAddr = i;

			iHR->GetByAddress(*iHRNameRecord);

			}

		}

	iDevAddr = aAddr;

	iSecMgr.AddNotifierRequestToQueL(*this);

	iIsAddedToNotifierQue = ETrue;

	}

CSecNotifierRequester::~CSecNotifierRequester()

	{

	LOG_FUNC

	Cancel();

	//remove ourself from the notifier que if we're still on it.

	if (iIsAddedToNotifierQue)

		{

		iSecMgr.RemoveNotifierRequestFromQue(*this);

		iIsAddedToNotifierQue = EFalse;

		}

	delete iHR;

	delete iHRNameRecord;

	delete iUpdateNotifierAO; 

	iNotifier.Close();

	}

void CSecNotifierRequester::QueryComplete(TInt aErr)

	{

	LOG_FUNC

	if ( (aErr==KErrNone) && (iHRNameRecord!=NULL) )

		{

		// now have device name - update notifiers

		// we do have a copy of the name - but it is now wide :-|

		// and also we have iDeviceName that is still NULL, so best bet is

		// to just set our pointer and use the cache one (which we *know* is there!)

		TBTDevAddr a = TBTSockAddr::Cast(iHRNameRecord->iAddr).BTAddr();

		iDeviceName = iInquiryMgr.DeviceNameFromCache(a);

		DoUpdateNotifier();

		}

	delete iHRNameRecord;

	iHRNameRecord = NULL;

	}

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

//class CBTPinRequester

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

CBTPinRequester* CBTPinRequester::NewL(CPhysicalLink& aParent,

									   MPINCodeResponseHandler& aRequester,

									   CBTSecMan& aSecMan,

									   TUint aPasskeyMinLength,

									   TBool aInternallyInitiated)

	{

	LOG_FUNC

	CBTPinRequester* s = CBTPinRequester::NewLC(aParent, aRequester, aSecMan,

	                                            aPasskeyMinLength, aInternallyInitiated);

	CleanupStack::Pop();

	return s;

	}

CBTPinRequester* CBTPinRequester::NewLC(CPhysicalLink& aParent,

										MPINCodeResponseHandler& aRequester,

										CBTSecMan& aSecMan,

										TUint aPasskeyMinLength,

										TBool aInternallyInitiated)

	{

	LOG_FUNC

	CBTPinRequester* s = new(ELeave) CBTPinRequester(aParent, aRequester, aSecMan,

	                                                 aPasskeyMinLength, aInternallyInitiated);

	CleanupStack::PushL(s);

	s->ConstructL(aParent.BDAddr());

	return s;

	}

CBTPinRequester::CBTPinRequester(CPhysicalLink& aParent,

								 MPINCodeResponseHandler& aRequester,

								 CBTSecMan& aSecMan,

								 TUint aPasskeyMinLength,

								 TBool aInternallyInitiated) :

	CSecNotifierRequester(aSecMan),

	iParent(aParent),

	iRequester(aRequester),

	iSecMan(aSecMan),

	iPasskeyMinLength(aPasskeyMinLength),

	iInternallyInitiated(aInternallyInitiated)

	{

	LOG_FUNC

	// a lot of inlines

	CActiveScheduler::Add(this);

	}

CBTPinRequester::~CBTPinRequester()

	{

	LOG_FUNC

	Cancel();

	}

void CBTPinRequester::DoUpdateNotifier()

	{

	LOG_FUNC

 	if(IsActive())

 		{	

 		if(!iUpdateNotifierAO)

 			{

 			//Create a new CSecNotifierUpdateAO object

 			TRAP_IGNORE(iUpdateNotifierAO = CSecNotifierUpdateAO::NewL(iNotifier, KBTManPinNotifierUid));

 			}

 		if( (iUpdateNotifierAO) && (!iUpdateNotifierAO->IsActive()) )

 			{

 			TBTNotifierUpdateParamsPckg pckg;

 			if(iDeviceName)

 				{

 				TRAPD(err, pckg().iName = BTDeviceNameConverter::ToUnicodeL(*iDeviceName));

 				pckg().iResult = err; 	// Error code can be KErrNone 

 				if (err!=KErrNone)

	 				{

	 				pckg().iName = KNullDesC;

	 				}

 				}

 			else

 				{

 				pckg().iName = KNullDesC;

 				pckg().iResult = KErrNotFound;

 				}

 			iUpdateNotifierAO->DoUpdate(pckg);

 			}

   		}

	}

void CBTPinRequester::DoRequest()

/**

It's our turn...start the RNotifier plugin that deals with authorisation.

**/

	{

	LOG_FUNC

	ASSERT_DEBUG(iDevAddr == iParent.BDAddr());

	iPasskeyParamsPckg().iBDAddr = iDevAddr;

	if (iDeviceName)

		{

		TRAPD(err, iPasskeyParamsPckg().iName =	BTDeviceNameConverter::ToUnicodeL(*iDeviceName));

		if (err!=KErrNone)

			{

			iPasskeyParamsPckg().iName = KNullDesC;

			}

		}

	else

		{

		iPasskeyParamsPckg().iName = KNullDesC;	

		}			

	iPasskeyParamsPckg().iPasskeyMinLength = iPasskeyMinLength;	

	iPasskeyParamsPckg().iLocallyInitiated = iInternallyInitiated;	

	iNotifier.StartNotifierAndGetResponse(iStatus, KBTManPinNotifierUid, iPasskeyParamsPckg, iPassKey);

	SetActive();

	}

void CBTPinRequester::FriendlyNameRetrieved(const TDesC& /*aName*/, TInt /*aResult*/)

	{

	LOG_FUNC

	// do nothing for now 

	}

void CBTPinRequester::DoCancel()

	{

	LOG_FUNC

	iNotifier.CancelNotifier(KBTManPinNotifierUid);

	if (iUpdateNotifierAO)

		{

	 	iUpdateNotifierAO->Cancel();

		}

	}

void CBTPinRequester::RunL()

	{

	LOG_FUNC

	//got a PIN or error, so finish off: unload the plugin

	iNotifier.CancelNotifier(KBTManPinNotifierUid);

	//remove ourself from the notifier que, allowing the next notifier to be activated

	iSecMan.RemoveNotifierRequestFromQue(*this);

	iIsAddedToNotifierQue = EFalse;

	ASSERT_DEBUG(iPasskeyParamsPckg().iBDAddr == iParent.BDAddr());

	if (iStatus.Int())

		{

		// it failed - be unpairable

		iRequester.PINCodeRequestNegativeReply((iParent.BDAddr()));

		}