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

//

/**

 @file

 @internalComponent

*/

#include <e32base.h>

#include <bttypes.h>

#include <bluetooth/pairing.h>

#include <bluetooth/pairingservershared.h>

#include "pairingserversecuritypolicy.h"

#include "oobdata.h"

#include "pairingserver.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_PAIRING_SERVER);

#endif

#ifdef _DEBUG

PANICCATEGORY("pairingsrv");

#endif

// These come after the logging to ensure that debug.h knows we're using the

// bluetooth logger.

#include "physicallinksmanager.h"

#include "ProxySAP.h"

//

// CPairingServer

//

CPairingServer* CPairingServer::NewL(COobDataManager& aOobDataManager, CSimplePairingResultList& aSimplePairingResultList, CAuthenticationResultList& aAuthenticationResultList)

	{

	LOG_STATIC_FUNC

	CPairingServer* self = new(ELeave) CPairingServer(aOobDataManager, aSimplePairingResultList, aAuthenticationResultList);

	CleanupStack::PushL(self);

	// StartL is where the kernel checks that there isn't already an instance

	// of the same server running, so do it before ConstructL.

	self->StartL(KPairingServerName);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPairingServer::~CPairingServer()

	{

	LOG_FUNC

	delete iContainerIndex;

	}

CPairingServer::CPairingServer(COobDataManager& aOobDataManager, CSimplePairingResultList& aSimplePairingResultList, CAuthenticationResultList& aAuthenticationResultList)

	: CPolicyServer(CActive::EPriorityStandard, KPairingServerPolicy)

	, iOobDataManager(aOobDataManager)

	, iSimplePairingResultList(aSimplePairingResultList)

	, iAuthenticationResultList(aAuthenticationResultList)

	{

	LOG_FUNC

	}

void CPairingServer::ConstructL()

	{

	LOG_FUNC

	iContainerIndex = CObjectConIx::NewL();

	}

// Callback to LinksMgrProtocol to add a pairing session

void CPairingServer::AddSession()

	{

	LOG_FUNC

	if(iSessionCount++ == 0)

		{

		// While we have clients we need to make sure that the protocol remains alive.

		iLinkMgrProtocol->LocalOpen();

		}

	}

// Callback to LinksMgrProtocol to remove a pairing session

void CPairingServer::DropSession()

	{

	LOG_FUNC

	if(--iSessionCount == 0)

		{

		// There are no longer any clients

		iLinkMgrProtocol->LocalClose();

		}

	}

void CPairingServer::SetPhysicalLinksManager(CPhysicalLinksManager& aLinksMan)

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iLinksMan, PANIC(KPairingServerFaultCat, EPairingServerLinkManagerAlreadyProvided));

	iLinksMan = &aLinksMan;

	}

void CPairingServer::ClearPhysicalLinkMgr()

	{

	LOG_FUNC

	iLinksMan = NULL;

	}

// Save a reference to the LinksMgrProtocol

void CPairingServer::SetLinksMgrProtocol(CLinkMgrProtocol& aLinkMgrProtocol)

	{

	LOG_FUNC

	iLinkMgrProtocol = &aLinkMgrProtocol;

	}

// Clear the reference to the LinksMgrProtocol

void CPairingServer::ClearLinksMgrProtocol()

	{

	LOG_FUNC

	iLinkMgrProtocol = NULL;

	}

CSession2* CPairingServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

	{

	LOG_FUNC

	LOG3(_L("aVersion = (%d, %d, %d)"), aVersion.iMajor, aVersion.iMinor, aVersion.iBuild)

	// Version number check...

	TVersion v(KPairingServerMajorVersionNumber,

			   KPairingServerMinorVersionNumber,

			   KPairingServerBuildVersionNumber);

	if(!User::QueryVersionSupported(v, aVersion))

		{

		User::LeaveIfError(KErrNotSupported);

		}

	// Ensure that the reference to the LinksMgrProtocol has been receieved

	if(!iLinkMgrProtocol)

		{

		User::Leave(KErrNotReady);

		}

	// Cast 'this' to allow use in Constructor 

	CPairingServer* ncThis = const_cast<CPairingServer*>(this);

	CPairingSession* sess = CPairingSession::NewL(*ncThis);

	return sess;

	}

CObjectCon* CPairingServer::NewContainerL()

	{

	LOG_FUNC

	return iContainerIndex->CreateL();

	}

void CPairingServer::DeleteContainer(CObjectCon* aContainer)

	{

	LOG_FUNC

	iContainerIndex->Remove(aContainer);

	}

CPhysicalLinksManager& CPairingServer::LinksManL() const

	{

	LOG_FUNC

	if(!iLinksMan)

		{

		LEAVEL(KErrNotReady);

		}

	return *iLinksMan;

	}

COobDataManager& CPairingServer::OobDataManager() const

	{

	LOG_FUNC

	return iOobDataManager;

	}

CSimplePairingResultList& CPairingServer::SimplePairingResultList() const

	{

	LOG_FUNC

	return iSimplePairingResultList;

	}

CAuthenticationResultList& CPairingServer::AuthenticationResultList() const

	{

	LOG_FUNC

	return iAuthenticationResultList;

	}

//

// CPairingSession

//

CPairingSession* CPairingSession::NewL(CPairingServer& aPairingServer)

	{

	LOG_STATIC_FUNC

	CPairingSession* self = new(ELeave) CPairingSession(aPairingServer);

	aPairingServer.AddSession();

	return self;

	}

CPairingSession::CPairingSession(CPairingServer& aPairingServer)

	: iPairingServer(aPairingServer)

	{

	LOG_FUNC

	}

CPairingServer& CPairingSession::Server() const

	{

	LOG_FUNC

	return *static_cast<CPairingServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

CPairingSession::~CPairingSession()

	{

	LOG_FUNC

	iPairingServer.DropSession();

	delete iSubSessions; // Must be deleted before container to ensure ref counting is correct

	Server().DeleteContainer(iContainer);

	}

void CPairingSession::CreateL()

	{

	LOG_FUNC

	iSubSessions = CObjectIx::NewL();

	iContainer = Server().NewContainerL();

	__TEST_INVARIANT;

	}

#ifdef _DEBUG

void CPairingSession::__DbgTestInvariant() const

	{

	LOG_FUNC

	__ASSERT_DEBUG(iContainer->Count() == iSubSessions->ActiveCount(),

			PANIC(KPairingServerFaultCat, EPairingServerSessionContainerAndIndexMismatch));

	}

#endif // _DEBUG

void CPairingSession::ServiceL(const RMessage2& aMessage)

	{

	LOG_FUNC

	LOG1(_L("aMessage.Function() = &d"), aMessage.Function());

//	__TEST_INVARIANT; // Not needed as all major functional exits are checked

	TBool handled = DispatchSessMessageL(aMessage);

	if(!handled)

		{

		// if not handled, it must be a subsession request.

		DispatchSubSessMessageL(aMessage);

		}

	__TEST_INVARIANT;

	}

void CPairingSession::ServiceError(const RMessage2& aMessage, TInt aError)

	{

	LOG_FUNC

	LOG1(_L("aError = %d"), aError);

	if(aError == KErrBadDescriptor)

		{

		// If a KErrBadDescriptor is received then the request is bad so punish.

		aMessage.Panic(KPairingServerPanicCat, EPairingServerBadDescriptor);

		}

	else

		{

		aMessage.Complete(aError);

		}

	__TEST_INVARIANT;

	}

TBool CPairingSession::DispatchSessMessageL(const RMessage2& aMessage)

	{

	LOG_FUNC

	TBool handled = ETrue;

	switch(aMessage.Function())

		{

	case EPairingServerCreateOobDataSubSession:

		NewOobDataSubSessionL(aMessage);

		break;

	case EPairingServerCreateDedicatedBondingSubSession:

		NewDedicatedBondingSubSessionL(aMessage);

		break;

	case EPairingServerCreateSimplePairingResultSubSession:

		NewSimplePairingResultSubSessionL(aMessage);

		break;

	case EPairingServerCreateAuthenticationResultSubSession:

		NewAuthenticationResultSubSessionL(aMessage);

		break;

	case EPairingServerCloseSubSession:

		DeleteSubSession(aMessage);

		break;

	default:

		handled = EFalse;

		break;

		}

	return handled;

	}

void CPairingSession::DispatchSubSessMessageL(const RMessage2& aMessage)

	{

	LOG_FUNC

	CPairingSubSession* ss = SubSessionFromHandle(aMessage.Int3());

	if(!ss)

		{

		aMessage.Panic(KPairingServerPanicCat, EPairingServerBadSubSessionHandle);

		}

	else

		{

		ss->DispatchSubSessMessageL(aMessage);

		}

	}

CPairingSubSession* CPairingSession::SubSessionFromHandle(TInt aHandle)

	{

	LOG_FUNC

	LOG1(_L("aHandle = %d"), aHandle);

	return static_cast<CPairingSubSession*>(iSubSessions->At(aHandle));

	}

void CPairingSession::NewOobDataSubSessionL(const RMessage2& aMessage)

	{

	LOG_FUNC

	COobDataSession* oob = COobDataSession::NewLC(*this, Server().OobDataManager());

	SubSessionConstructL(aMessage, oob); // handles oob on CleanupStack

	}

void CPairingSession::NewDedicatedBondingSubSessionL(const RMessage2& aMessage)

	{

	LOG_FUNC

	CDedicatedBondingSession* ded = CDedicatedBondingSession::NewLC(*this, Server().LinksManL());

	SubSessionConstructL(aMessage, ded); // handles ded on CleanupStack

	}

void CPairingSession::NewSimplePairingResultSubSessionL(const RMessage2& aMessage)

	{

	LOG_FUNC

	CSimplePairingResultSession* sim = CSimplePairingResultSession::NewLC(*this, Server().SimplePairingResultList());

	SubSessionConstructL(aMessage, sim);

	}

void CPairingSession::NewAuthenticationResultSubSessionL(const RMessage2& aMessage)

	{

	LOG_FUNC

	CAuthenticationResultSession* aut = CAuthenticationResultSession::NewLC(*this, Server().AuthenticationResultList());

	SubSessionConstructL(aMessage, aut);

	}

/**

This function handles the subsession handle binding to the subsession that has been

created.

*/

void CPairingSession::SubSessionConstructL(const RMessage2& aMessage, CPairingSubSession* aSubSession)

	{

	LOG_FUNC

	// The subsession is on the cleanup stack when this function is called.

	TInt subSessionHandleLength = aMessage.GetDesMaxLengthL(3);

	if(subSessionHandleLength != sizeof(TInt))

		{

		aMessage.Panic(KPairingServerPanicCat, EPairingServerBadDescriptor);

		CleanupStack::PopAndDestroy(aSubSession);

		}

	else

		{

		iContainer->AddL(aSubSession);

		TInt handle = iSubSessions->AddL(aSubSession);

		CleanupStack::Pop(aSubSession); // Now lifetime is controlled by the binding CObjectIx

		TPckg<TInt> pckgHandle(handle);

		TRAPD(err, aMessage.WriteL(3, pckgHandle));

		if(err != KErrNone)

			{

			iSubSessions->Remove(handle);

			LEAVEL(err);

			}

		aMessage.Complete(KErrNone);

		}

	}

void CPairingSession::DeleteSubSession(const RMessage2& aMessage)

	{

	LOG_FUNC

	TInt handle = aMessage.Int3();

	CPairingSubSession* ss = SubSessionFromHandle(handle);

	if(!ss)

		{

		aMessage.Panic(KPairingServerPanicCat, EPairingServerBadSubSessionHandle);

		}

	else

		{

		iSubSessions->Remove(handle);

		aMessage.Complete(KErrNone);

		}

	}

//

// CPairingSubSession

//

CPairingSubSession::CPairingSubSession(CPairingSession& aSession)

	: iSession(aSession)

	{

	LOG_FUNC

	}

CPairingSubSession::~CPairingSubSession()

	{

	LOG_FUNC

	}

void CPairingSubSession::DispatchSubSessMessageL(const RMessage2& /*aMessage*/)

	{

	LOG_FUNC

	LEAVEL(KErrNotSupported);

	}

void CPairingSubSession::ConstructL()

	{

	LOG_FUNC

	}

CPairingSession& CPairingSubSession::Session() const

	{

	LOG_FUNC

	return iSession;

	}

//

// COobDataSession

//

COobDataSession* COobDataSession::NewLC(CPairingSession& aSession, COobDataManager& aOobDataManager)

	{

	LOG_STATIC_FUNC

	COobDataSession* self = new(ELeave) COobDataSession(aSession, aOobDataManager);

	//As its a CObject derived class so we should use CleanupClosePushL

	CleanupClosePushL(*self);

	self->ConstructL();

	return self;

	}

COobDataSession::COobDataSession(CPairingSession& aSession, COobDataManager& aOobDataManager)

	: CPairingSubSession(aSession)

	, iOobDataManager(aOobDataManager)

	{

	LOG_FUNC

	}

COobDataSession::~COobDataSession()

	{

	LOG_FUNC

	TryCancelReadLocalOobData();

	}

COobDataManager& COobDataSession::OobDataManager() const

	{

	LOG_FUNC

	return iOobDataManager;

	}

void COobDataSession::DispatchSubSessMessageL(const RMessage2& aMessage)

	{

	LOG_FUNC

	switch(aMessage.Function())

		{

	case EPairingServerOobDataRefreshLocal:

		iOobDataManager.RefreshLocalOobData();

		aMessage.Complete(KErrNone);

		break;

	case EPairingServerOobDataReadLocal:

		ReadLocalOobDataL(aMessage);

		break;

	case EPairingServerOobDataCancelReadLocal:

		CancelReadLocalOobData(aMessage);

		break;

	case EPairingServerOobDataProvideRemoteParsed:

		ProvideParsedRemoteOobDataL(aMessage);

		break;

	case EPairingServerOobDataProvideRemoteRaw:

		ProvideRawRemoteOobDataL(aMessage);

		break;

	case EPairingServerOobDataClearRemote:

		ClearRemoteOobDataL(aMessage);

		break;

	default:

		CPairingSubSession::DispatchSubSessMessageL(aMessage);

		break;

		}

	}

void COobDataSession::ProvideParsedRemoteOobDataL(const RMessage2& aMessage)

	{

	LOG_FUNC

	TPckgBuf<TBTDevAddr> addrBuf;

	if(aMessage.GetDesLengthL(0) != sizeof(TBTDevAddr))

		{

		LEAVEL(KErrBadDescriptor);

		}

	aMessage.ReadL(0, addrBuf);

	TBluetoothSimplePairingHash hash;

	if(aMessage.GetDesLengthL(1) != KBluetoothSimplePairingHashSize)

		{

		LEAVEL(KErrBadDescriptor);

		}

	aMessage.ReadL(1, hash);

	TBluetoothSimplePairingRandomizer randomizer;

	TInt len = aMessage.GetDesLength(2);

	if (len < KErrNone) // The randomizer wasn't available (which is fine...)

		{

		randomizer.FillZ(KBluetoothSimplePairingRandomizerSize);

		}

	else

		{

		if(len != KBluetoothSimplePairingRandomizerSize)