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

// OOB Data Manager.

// 

//

/**

 @file

 @internalComponent

*/

#include <e32base.h>

#include <bttypes.h>

#include <bluetooth/pairingservershared.h>

#include <bluetooth/hcicommandqueue.h>

#include <bluetooth/hci/event.h>

#include <bluetooth/hci/readlocaloobdatacommand.h>

#include <bluetooth/hci/readlocaloobdatacompleteevent.h>

#include "oobdata.h"

#include "pairingserver.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAIRING_SERVER);

#endif

#include "secman.h"

//

// COobDataManager

//

COobDataManager* COobDataManager::NewL(CBTSecMan& aSecMan)

	{

	LOG_STATIC_FUNC

	COobDataManager* self = new(ELeave) COobDataManager(aSecMan);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COobDataManager::COobDataManager(CBTSecMan& aSecMan)

	: CBase()

	, iLocalOobState(ELocalOobInvalid)

	, iLocalOobObservers(_FOFF(XOobLocalDataObserver, iLink))

	, iSecMan(aSecMan)

	{

	LOG_FUNC

	}

void COobDataManager::SetHCICommandQueue(MHCICommandQueue& aCommandQueue)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iCommandQueue, PANIC(KOobDataPanicCat, EOobDataPanicCommandQueueAlreadyProvided));

	iCommandQueue = &aCommandQueue;

	}

void COobDataManager::ClearHCICommandQueue()

	{

	LOG_FUNC

	if(iCommandQueue)

		{

		iCommandQueue->MhcqRemoveAllCommands(*this);

		}

	iCommandQueue = NULL;

	}

MHCICommandQueue& COobDataManager::CommandQueueL() const

	{

	LOG_FUNC

	if(!iCommandQueue)

		{

		LEAVEL(KErrNotReady);

		}

	return *iCommandQueue;

	}

void COobDataManager::ConstructL()

	{

	LOG_FUNC

	}

COobDataManager::~COobDataManager()

	{

	LOG_FUNC

	}

void COobDataManager::ProvideRemoteOobDataL(const TOobData& aData)

	{

	LOG_FUNC

	TInt ix = iOobDataFromPeers.Find(aData.Addr(), TOobData::IsForAddress);

	if(ix == KErrNotFound)

		{

		iOobDataFromPeers.AppendL(aData);

		}

	else

		{

		__ASSERT_DEBUG(ix >= 0, PANIC(KOobDataPanicCat, EOobDataPanicErrorWhenFindingOobDataForProvision));

		iOobDataFromPeers[ix] = aData;

		}

	}

void COobDataManager::ClearRemoteOobData(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	TInt ix = iOobDataFromPeers.Find(aAddr, TOobData::IsForAddress);

	if(ix != KErrNotFound) // ignore if we cannot find an existing entry.

		{

		__ASSERT_DEBUG(ix >= 0, PANIC(KOobDataPanicCat, EOobDataPanicErrorWhenFindingOobDataForClear));

		iOobDataFromPeers.Remove(ix);

		iOobDataFromPeers.GranularCompress();

		}

#ifdef _DEBUG

	// When in debug builds, check that there is no entry for the referenced device

	// address once one has been removed (there should only be a single entry per

	// remote device).

	ix = iOobDataFromPeers.Find(aAddr, TOobData::IsForAddress);

	__ASSERT_DEBUG(ix == KErrNotFound, PANIC(KOobDataPanicCat, EOobDataPanicMultipleOobEntriesForDevice));

#endif // _DEBUG

	}

void COobDataManager::ReadLocalOobData(XOobLocalDataObserver& aObserver)

	{

	switch(iLocalOobState)

		{

		case ELocalOobValid:

			// synchronous complete.

			aObserver.XoldoLocalOobDataRetrieved(KErrNone, iOobHashC, iOobRandomizerR);

			break;

		case ELocalOobUpdating:

			// The update is outstanding and so the observer can be completed when the

			// result comes in.

			__ASSERT_DEBUG(!aObserver.iLink.IsQueued(), PANIC(KOobDataPanicCat, EOobDataPanicLocalOobObserverIsAlreadyQueuedDuringUpdate));

			iLocalOobObservers.AddLast(aObserver);

			break;

		case ELocalOobInvalid:

			// If invalid then we should issue a request to retrieve the data.

			__ASSERT_DEBUG(!aObserver.iLink.IsQueued(), PANIC(KOobDataPanicCat, EOobDataPanicLocalOobObserverIsAlreadyQueuedWhileInvalid));

			iLocalOobObservers.AddLast(aObserver);

			MakeLocalOobRequestToController();

			break;

		default:

			__ASSERT_DEBUG(EFalse, PANIC(KOobDataPanicCat, EOobDataPanicUnknownState));

			break;

		}

	}

void COobDataManager::CancelReadLocalOobData(XOobLocalDataObserver& aObserver)

	{

	LOG_FUNC

	// This requests doesn't actually cancel the retrieval of the local OOB data

	// from the controller.  Instead it merely removes the observer from being called.

	// back.

	aObserver.iLink.Deque();

	// Callback with to indicate the cancel. 

	aObserver.XoldoLocalOobDataRetrieved(KErrCancel, iOobHashC, iOobRandomizerR);

	}

void COobDataManager::RefreshLocalOobData()

	{

	LOG_FUNC

	// Don't do much, just set the state as invalid.  If there is an outstanding

	// new set of OOB data then don't do anything (as we are being refreshed.)

	if(iLocalOobState == ELocalOobValid)

		{

		iLocalOobState = ELocalOobInvalid;

		}

	}

void COobDataManager::MakeLocalOobRequestToController()

	{

	LOG_FUNC

	TRAPD(err, MakeLocalOobRequestToControllerL());

	if(err != KErrNone)

		{

		CompleteQueuedLocalOobObservers(err);

		}

	}

void COobDataManager::MakeLocalOobRequestToControllerL()

	{

	LOG_FUNC

	if (!iSecMan.LocalSimplePairingMode())

		{

		User::Leave(KErrNotSupported);

		}

	CReadLocalOOBDataCommand* cmd = CReadLocalOOBDataCommand::NewL();

	CleanupStack::PushL(cmd);

	MHCICommandQueue& commandQueue = CommandQueueL();

	CleanupStack::Pop(cmd);

	commandQueue.MhcqAddCommandL(cmd, *this);

	}

void COobDataManager::MhcqcCommandEventReceived(const THCIEventBase& aEvent, const CHCICommandBase* __DEBUG_ONLY(aRelatedCommand))

	{

	LOG_FUNC

	__ASSERT_DEBUG(aRelatedCommand && (aRelatedCommand->Opcode() == KReadLocalOOBDataOpcode),

			PANIC(KOobDataPanicCat, EOobDataPanicUnexpectedHciCommandAssociated));

	__ASSERT_DEBUG(aEvent.EventCode() == ECommandCompleteEvent,

			PANIC(KOobDataPanicCat, EOobDataPanicUnexpectedHciEventReceived));

	const THCICommandCompleteEvent& completeEvent = THCICommandCompleteEvent::Cast(aEvent);

	__ASSERT_DEBUG(completeEvent.CommandOpcode() == KReadLocalOOBDataOpcode,

			PANIC(KOobDataPanicCat, EOobDataPanicUnexpectedHciCommandCompleteEventReceived));

	const TReadLocalOOBDataCompleteEvent& event = TReadLocalOOBDataCompleteEvent::Cast(completeEvent);

	iOobHashC = event.OOBDataC();

	iOobRandomizerR = event.OOBDataR();

	iLocalOobState = ELocalOobValid;

	CompleteQueuedLocalOobObservers(KErrNone);

	}

void COobDataManager::MhcqcCommandErrored(TInt aErrorCode, const CHCICommandBase* __DEBUG_ONLY(aCommand))

	{

	LOG_FUNC

	__ASSERT_DEBUG(aCommand && (aCommand->Opcode() == KReadLocalOOBDataOpcode),

			PANIC(KOobDataPanicCat, EOobDataPanicUnexpectedHciCommandAssociatedWithError));

	iLocalOobState = ELocalOobInvalid;

	CompleteQueuedLocalOobObservers(aErrorCode);

	}

void COobDataManager::CompleteQueuedLocalOobObservers(TInt aResult)

	{

	LOG_FUNC

	TDblQueIter<XOobLocalDataObserver> iter(iLocalOobObservers);

	while(XOobLocalDataObserver* obs = iter++)

		{

		obs->iLink.Deque();

		obs->XoldoLocalOobDataRetrieved(aResult, iOobHashC, iOobRandomizerR);

		}

	}

TBool COobDataManager::GetRemoteOobData(const TBTDevAddr& aAddr, TBluetoothSimplePairingHash& aHashC, TBluetoothSimplePairingRandomizer& aRandomizerR)

	{

	LOG_FUNC

	TBool found = EFalse;

	TInt ix = iOobDataFromPeers.Find(aAddr, TOobData::IsForAddress);

	if(ix == KErrNotFound)

		{

		aHashC = KNullDesC8;

		aRandomizerR = KNullDesC8;

		}

	else

		{

		__ASSERT_DEBUG(ix >= 0, PANIC(KOobDataPanicCat, EOobDataPanicErrorWhenFindingOobDataForGet));

		found = ETrue;

		aHashC = iOobDataFromPeers[ix].HashC();

		aRandomizerR = iOobDataFromPeers[ix].RandomizerR();

		// Now invalidate (remove) this OOB data; only allow retrieval once

		iOobDataFromPeers.Remove(ix);

		iOobDataFromPeers.GranularCompress();

		}

	return found;

	}

TBool COobDataManager::HasRemoteOobData(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	TInt ix = iOobDataFromPeers.Find(aAddr, TOobData::IsForAddress);

	__ASSERT_DEBUG((ix >= 0 || ix == KErrNotFound), 

			PANIC(KOobDataPanicCat, EOobDataPanicErrorWhenFindingOobDataForHas));

	return ix != KErrNotFound;

	}

//

// TOobData

//

TOobData::TOobData(const TBTDevAddr& aAddr, const TBluetoothSimplePairingHash& aHashC, const TBluetoothSimplePairingRandomizer&  aRandomizerR)

	: iAddr(aAddr)

	, iHashC(aHashC)

	, iRandomizerR(aRandomizerR)

	{

	LOG_FUNC

	}

const TBTDevAddr& TOobData::Addr() const

	{

	LOG_FUNC

	return iAddr;

	}

const TBluetoothSimplePairingHash& TOobData::HashC() const

	{

	LOG_FUNC

	return iHashC;

	}

const TBluetoothSimplePairingRandomizer& TOobData::RandomizerR() const

	{

	LOG_FUNC

	return iRandomizerR;

	}

TBool TOobData::IsForAddress(const TBTDevAddr* aAddr, const TOobData& aOobData)

	{

	LOG_STATIC_FUNC

	return aAddr && *aAddr == aOobData.Addr();

	}