// 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 <s32mem.h>

#include <e32svr.h>

#include "BTManServer.h"

#include "BTSec.h"

#include "BtManServerSecurityPolicy.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_MANAGER_SERVER);

#endif

static const TInt KMessageArrayGranularity = 4; //< The granularity of the array used to hold TBTManMessage objects

static const TInt KBTManClientServerProtocolSlot = 2; // the slot that points to the struct buf used between client and server

inline CBTManServerShutdown::CBTManServerShutdown()

	:CTimer(-1)

	{

	LOG_FUNC

	CActiveScheduler::Add(this);

	}

inline void CBTManServerShutdown::ConstructL()

	{

	LOG_FUNC

	CTimer::ConstructL();

	}

inline void CBTManServerShutdown::Start()

	{

	LOG_FUNC

	After(KBTManServerShutdownDelay);

	}

//

void CBTManServerShutdown::RunL()

/**

Initiate server exit when the timer expires

**/

	{

	LOG_FUNC

	CActiveScheduler::Stop();

	}

//=====================================================================

// CBTManServer

//=====================================================================

inline CBTManServer::CBTManServer()

	:	CPolicyServer(EPriorityStandard,KBtmanServerPolicy,ESharableSessions)

	{

	LOG_FUNC

	}

CServer2* CBTManServer::NewLC()

	{

	LOG_STATIC_FUNC

	CBTManServer* self=new(ELeave) CBTManServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CBTManServer::ConstructL()

	{

	LOG_FUNC

	StartL(KBTManServerName);

	//Ensure that the server will exit even if the 1st client fails to connect

	iShutdown.ConstructL();

	iShutdown.Start();

	TInt err;

	err = iProperty.Define(KPropertyUidBluetoothCategory,

						   KPropertyKeyBluetoothGetRegistryTableChange,

						   RProperty::EInt,

						   KLOCAL_SERVICES,

						   KBTMAN_SID_PROT_SERV);

	FLOGIFERR(err,_L("CBTManServer::ConstructL() - iProperty.Define Failure"));

	err = iProperty.Define(KPropertyUidBluetoothCategory,

						   KPropertyKeyBluetoothCorruptRegistryReset,

						   RProperty::EInt,

						   KLOCAL_SERVICES,

						   KLOCAL_SERVICES_AND_NETWORK_CONTROL);

	FLOGIFERR(err,_L("CBTManServer::ConstructL() - iProperty.Define Failure"));

	//Create the service providers...

	iRegistry = CBTRegistry::NewL();

	iContainerIndex = CObjectConIx::NewL();

	// don't stop the server if we can't provide this service...				   

	//Start Backup/Restore Manager and obtain notification of backup/restore operations.

	iBURManager=CBTManServerBURMgr::NewL(*this, this);

	}

CObjectCon* CBTManServer::NewContainerL()

/**

Return a new object container

**/

	{

	LOG_FUNC

	return iContainerIndex->CreateL();

	}

void CBTManServer::DeleteContainer(CObjectCon* aCon)

	{

	LOG_FUNC

	iContainerIndex->Remove(aCon);

	}

CBTManServer::~CBTManServer()

	{

	LOG_FUNC

	// Delete defined properties

	TInt err;

	err = iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetRegistryTableChange);

	FLOGIFERR(err,_L("CBTManServer::~CBTManServer() - iProperty.Delete Failure"));

	err = iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothCorruptRegistryReset);

	FLOGIFERR(err,_L("CBTManServer::~CBTManServer() - iProperty.Delete Failure"));

	// Close the RProperty handle in case it is ever attached.

	iProperty.Close();

	delete iBURManager;

	delete iRegistry;

	delete iContainerIndex;

	}

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

	{

	LOG_FUNC

	TVersion v(KBTManServerMajorVersionNumber,KBTManServerMinorVersionNumber,KBTManServerBuildVersionNumber);

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

		{

		User::Leave(KErrNotSupported);

		}

	// make new session

	return new(ELeave) CBTManSession(*iRegistry, aMessage);

	}

void CBTManServer::BUROperationStarted()

/**

A backup or restore operation has started.

Cancel the shutdown timer if it was running

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(!iBUROperationStarted, PanicServer(EBTManBadState));

	iBUROperationStarted = ETrue;

	iShutdown.Cancel();

	}

void CBTManServer::BUROperationStopped()

/**

A backup or restore operation has finished.

Start the shutdown timer if there are no sessions running.

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iBUROperationStarted, PanicServer(EBTManBadState));

	iBUROperationStarted = EFalse;

	TryToStartShutdownTimer();

	}

void CBTManServer::AddSession()

/**

A new session is being created

Cancel the shutdown timer if it was running

**/

	{

	LOG_FUNC

	++iSessionCount;

	if (iSessionCount > iMaxSessionCount)

		{

		iMaxSessionCount = iSessionCount;

		}

	iShutdown.Cancel();

	}

void CBTManServer::DropSession()

/**

A session is being destroyed

Start the shutdown timer if it is the last session.

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iSessionCount > 0, PanicServer(EBTManBadState));

	--iSessionCount;

	TryToStartShutdownTimer();

	}

void CBTManServer::TryToStartShutdownTimer()

/**

Starts the shutdown timer if the server is able to shutdown

**/

	{

	LOG_FUNC

	if (iSessionCount == 0 && !iBUROperationStarted)

		{

		iShutdown.Start();

		}

	}

void CBTManServer::Publish(TUint aKey, TInt aValue)

	{

	LOG_FUNC

	TInt err;

	err = iProperty.Set(KPropertyUidBluetoothCategory,

					    aKey,

						aValue);

	FLOGIFERR(err,_L("CBTManServer::Publish() - iProperty.Set Failure"));

	}

void CBTManServer::NotifyViewChange(CBTManSubSession& aSubSessionViewOwner, const TDesC& aViewDescriptor)

	{

	LOG_FUNC

	// For views owned by subsessions.

	// Go through all sessions - they'll dispatch so all the subessions apart from the one calling here

	iSessionIter.SetToFirst();

	while (iSessionIter)

		{

		CBTManSession* s = static_cast<CBTManSession*>(iSessionIter++);

		s->SubSessionHasOverlappingView(aSubSessionViewOwner, aViewDescriptor);

		}

	}

void CBTManServer::NotifyViewChange(const TDesC& aViewDescriptor)

	{

	LOG_FUNC

	// For views not owned by subsessions (e.g. views owned by Backup/Restore classes)

	// Go through all sessions - they'll dispatch so all the subessions apart from the one calling here

	iSessionIter.SetToFirst();

	while (iSessionIter)

		{

		CBTManSession* s = static_cast<CBTManSession*>(iSessionIter++);

		s->SubSessionHasOverlappingView(aViewDescriptor);

		}

	}

void PanicClient(const RMessage2& aMessage,TInt aPanic, CBTManSession* aSession)

/**

RMessage2::Panic() also completes the message. This is:

(a) important for efficient cleanup within the kernel

(b) a problem if the message is completed a second time

**/

	{

	LOG_STATIC_FUNC

	LOG1(_L("PanicClient: Reason = %d"), aPanic);

	//remove the message from the message table so we don't complete it again

	//The message may not yet be in the table, so check for NULL before deleting it

	//This code could be more efficient, but hopefully it won't be called enough to make

	//it worthwhile improving it ;-)

	__DEBUGGER();

	/*** ORDER MATTERS! ***/

	//First find the message in the session's stored messages

	//This must be done BEFORE panicking the client because

	//panicking the client resets the RMessage2 handle value to

	//zero and so almost always renders the FindMessage method useless!

	CBTManMessage* m = aSession->FindMessage(aMessage);

	//Now panic the client - this is safer done before deleting 

	//the message from the message array, just in case the RMessage2

	//object is obtained from that array and not directly from the client

	aMessage.Panic(KBTManPanic,aPanic);

	//Now delete the message from the session's queue. This is vital

	//if we are not to attempt to complete on a dead message

	if (m)

		{

		//aMessage will not be usable after the next line if it is obtained from the message array

		//instead of the one directly supplied by the client

		aSession->DeleteMessage(m);

		}

	}

void PanicServer(TInt aPanic)

/**

Panic our own thread

**/

	{

	LOG_STATIC_FUNC

	LOG1(_L("PanicServer: Reason = %d"), aPanic);

	User::Panic(KBTManPanic, aPanic);

	}

static void RunServerL()

/**

Perform all server initialisation, in particular creation of the

scheduler and server and then run the scheduler

**/

	{

	LOG_STATIC_FUNC

	// create and install the active scheduler we need

	CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	//

	// create the server (leave it on the cleanup stack)

	CServer2* server = CBTManServer::NewLC();

	//

	#ifdef __BTMANSERVER_NO_PROCESSES__

	RThread::Rendezvous(KErrNone);

	#else

	// naming the server thread after the server helps to debug panics

	// ignore error - we tried the best we could

	User::RenameThread(KBTManServerName); 

	RProcess::Rendezvous(KErrNone);

	#endif

	//

	// Ready to run

	CActiveScheduler::Start();

	//

	// Cleanup the server and scheduler

	CleanupStack::PopAndDestroy(server);

	CleanupStack::PopAndDestroy(scheduler);

	}

TInt E32Main()

/**

Main entry-point for the server process

**/

	{

	CONNECT_LOGGER

	LOG_STATIC_FUNC

	LOG(_L("BTManServer RunServer"));

	__UHEAP_MARK;

#ifdef TEST_OOM //define TEST_OOM in preprocessor definitions in project settings

	__UHEAP_SETFAIL(RHeap::ERandom, 100);

#endif

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,RunServerL());

		delete cleanup;

		}

	//

	__UHEAP_MARKEND;

	CLOSE_LOGGER

	return r;

	}

//=====================================================================

//CBTManMessage

//=====================================================================

// This framework is retained as it allows instrinsically asynchronous actions to be

// looked after easily.  At present such actions are limited to change notifications

// pretty much everything else is handled synchronously once the Server has had

// its ServiceL called.

CBTManMessage* CBTManMessage::NewL(const RMessage2& aMessage)

	{

	LOG_STATIC_FUNC

	CBTManMessage* m = new (ELeave) CBTManMessage(aMessage);

	CleanupStack::PushL(m);

	m->ConstructL();

	CleanupStack::Pop(m);

	return m;

	}

CBTManMessage::CBTManMessage(const RMessage2& aMessage)

: iMessage(aMessage)

	{

	LOG_FUNC

	}

void CBTManMessage::ConstructL()

	{

	LOG_FUNC

	if (iMessage.Ptr2())

		{

		TPckgBuf<TBTManClientServerMessage> msgBuf;

		iMessage.ReadL(KBTManClientServerProtocolSlot, msgBuf);

		iCancelPtr = msgBuf().iClientStatusToCancel;

		}

	}

CBTManMessage::~CBTManMessage()

	{

	LOG_FUNC

	//ensure we delete the helper if there is one

	if (iHelper)

		{

		iHelper->Delete();

		}

	}

void CBTManMessage::SetHelper(MBTManHelper* aHelper)

/**

Assigns a helper to the message.

The helper will then be told to delete itself when the message is completed.

This is especially important when cancelling or under leave conditions.

**/

	{

	LOG_FUNC

	__ASSERT_DEBUG(iHelper==NULL, PanicServer(EBTManBadHelper));

	__ASSERT_DEBUG((aHelper->Message()).Ptr2() == iCancelPtr, PanicServer(EBTManBadHelper));

	iHelper = aHelper;

	}

void CBTManMessage::RemoveHelper()

/**

Disassociates a helper with a message.

**/

	{

	LOG_FUNC

	iHelper = NULL;

	}

void CBTManMessage::Complete(TInt aReason)

/**

Completes the RMessage2 and deletes any associated helper.

**/

	{

	LOG_FUNC

	//complete the message

	iMessage.Complete(aReason);

	//delete the helper if there is one

	if (iHelper)

		iHelper->Delete();

	}

const RMessage2& CBTManMessage::Message()

	{

	LOG_FUNC

	return iMessage;

	}

const TAny* CBTManMessage::CancelPtr()

/**

The CancelPtr is the address of the TRequestStatus of the client-side active object

dealing with the request.  When a request is cancelled, it is located server-side using

this address.

**/

	{

	LOG_FUNC

	return iCancelPtr;

	}

MBTManHelper* CBTManMessage::Helper()

	{

	LOG_FUNC

	return iHelper;

	}

TBool CBTManMessage::operator==(CBTManMessage& aMessage) const

	{

	LOG_FUNC

	if (iMessage == aMessage.Message())

		return ETrue;

	return EFalse;

	}

//=====================================================================

//CBTManSession

//=====================================================================

CBTManServer& CBTManSession::Server()

	{

	LOG_FUNC

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

	}

CBTManSession::CBTManSession(CBTRegistry& aRegistry, const RMessage2& aMessage)

: iRegistry(aRegistry), iCurrentMessage(aMessage)

	{

	LOG_FUNC

	}

void CBTManSession::CreateL()

/**

2nd phase construct for sessions - called by the CServer2 framework

**/

	{

	LOG_FUNC

	//CSession2::CreateL();	// private and does nowt so removed

	//Add session to server first. If anything leaves, it will be removed by the destructor

	Server().AddSession();

	ConstructL();

	}