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

 // DBMS server implementation

 // 

 //

 #include "SD_STD.H"

 #include "Sd_PlatDep.h"

 using namespace DBSC;

 //CDbmsActiveScheduler class just exposes the access to 

 //CActiveScheduler::Level() method, which is needed to 

 //make a decision when to call CDbmsActiveScheduler::Stop().

 class CDbmsActiveScheduler : public CActiveScheduler

 	{

 public:

 	inline TInt Level() const

 		{

 		return CActiveScheduler::Level();

 		}

 	};

 ///////////////////////

 // Class CDbsServer

 inline CDbsServer::CDbsServer() :

 	CServer2(0, ESharableSessions), 

 	iSources(iCache),

 	iDbPropsFactory(iFs),

 	iDriveSpaceCol(iFs)

 	{

 	DbgPrint1(_L("###CDbsServer::CDbsServer(), Server ProcID=%d\n"), RDbProcess().Id());

 	}

 //"iCache.Hold(this,KDbsExitDelay)" statement will put CDbsServer instance in the cache, 

 //which ensures that CDbsServer instance will be automatically destroyed if nobody

 //uses it next KDbsExitDelay microseconds.

 CDbsServer* CDbsServer::NewL()

 	{

 	DbgPrint1(_L("###CDbsServer::NewL(), Server ProcId=%d\n"), RDbProcess().Id());

 	CDbsServer* self= new (ELeave) CDbsServer;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	self->iCache.Hold(self, KDbsExitDelay);		// the last thing we do here

 	//Intentional behaviour, resources freed after timeout only

 	//coverity[use_after_free]

 	return self;

 	}

 //

 // 2nd phase construction - ensure the timer and server objects are running

 //

 void CDbsServer::ConstructL()

 	{

 	DbgPrint1(_L("###CDbsServer::ConstructL(), Server ProcId=%d\n"), RDbProcess().Id());

 	__LEAVE_IF_ERROR(Dll::SetTls(this));

 	StartL(KDbsServerName);

 	__LEAVE_IF_ERROR(iFs.Connect());

 	iDbPropsFactory.OpenL();

 	//EDriveZ - Symbian OS ROM drive !?!?

 	iDbPropsFactory.GetPrivatePathL(EDriveZ, iFileName);

 	iPolicyProxy = CPolicyProxy::NewL(iFs,iFileName);

 	User::LeaveIfError(iCache.Open(ECacheSize, ETrue));	// create a timed cache

 	}

 //

 // Invoked via cache entry expiry (or cleanup)

 //

 CDbsServer::~CDbsServer()

 	{

 	DbgPrint1(_L("###CDbsServer::~CDbsServer(), Server ProcId=%d\n"), RDbProcess().Id());

 	iDriveSpaceCol.Close();

 	delete iPolicyProxy;

 	iDbPropsFactory.Close();

 	iCache.Close();

 	iSources.Close();

 	iFs.Close();

 	//Stop the scheduler if the nesting level > 0.

 	//Sometime it happens that more than one thread tries to run the server and you will have

 	//CDbmsActiveScheduler::Install() called multiple times. But you have to stop the 

 	//scheduler only once!

 	CDbmsActiveScheduler* scheduler = static_cast <CDbmsActiveScheduler*> (CActiveScheduler::Current());

 	if(scheduler->Level() > 0)

 		{

 		DbgPrint2(_L("###CDbsServer::~CDbsServer(), stop the scheduler, Server ProcId=%d, scheduler=%x\n"), RDbProcess().Id(), (TInt)scheduler);

 		CDbmsActiveScheduler::Stop();

 		}

 	}

 //

 // Creates a new client session. This should really check the version number.

 //

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

 	{

 	if(!User::QueryVersionSupported(RDbs::Version(), aVersion))

 		{

 		__LEAVE(KErrNotSupported);

 		}

 	CSession2* session = new (ELeave) CDbsSession;

 	iCache.Release(*this);

 	return session;

 	}

 //

 // Returns the instance of the server

 //

 CDbsServer* CDbsServer::Instance()

 	{

 	return (CDbsServer*)Dll::Tls();

 	}

 //

 // initiates exit if the last client is closing

 //

 void CDbsServer::RemoveSession()

 	{

 	iSessionIter.SetToFirst();

 	iSessionIter++;

 	if(iSessionIter++ == 0)

 		{

 		iCache.Hold(this, KDbsExitDelay);

 		}

 	}

 //

 // Performs all server initialisation, in particular creation of the

 // scheduler and server.

 // Noting has to be leaved in the cleanup stack!

 // Both: DBMS server and the active scheduler will be destroyed

 // later. The active scheduler - in CDbsServer destructor.

 // CDbsServer instance - by iCache instance (RDbCache).

 static void CreateServerL()

 	{

 	DbgPrint1(_L("###DBMS-CreateServerL(), Server ProcId=%d\n"), RDbProcess().Id());

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

 	User::LeaveIfError(User::RenameThread(KDbsServerName));

 	// ensure the server thread has a handle on EDBMS.DLL

 	LoadDbmsLibraryL();

 	// create and install the active scheduler we need

 	CDbmsActiveScheduler* scheduler = new (ELeave) CDbmsActiveScheduler;

 	CleanupStack::PushL(scheduler);

 	CDbmsActiveScheduler::Install(scheduler);

 	// create the server

 	(void)CDbsServer::NewL();

 	CleanupStack::Pop(scheduler);

 	// Initialisation complete, now signal the client

 	RDbProcess::Rendezvous(KErrNone);

 	}

 //

 // Performs all server initialisation, in particular creation of the

 // scheduler and server and then run the scheduler

 //

 static void RunServerL()

 	{

 	DbgPrint1(_L("###DBMS-RunServerL(), Server ProcId=%d\n"), RDbProcess().Id());

 	::CreateServerL();

 	//After successfull creation CreateServerL() call leaves the active scheduler instance

 	//and the DBMS server instance in the heap - they will be destroyed later.

 	__UHEAP_MARK;

 	//Start the scheduler. The execution control is transferred to the curent

 	//active scheduler. The statement after "CDbmsActiveScheduler::Start();" will

 	//be reached after the stop of active scheduler.

 	CDbmsActiveScheduler::Start();

 	__UHEAP_MARKEND;

 	}

 //

 // Server process entry-point

 //

 EXPORT_C TInt Dbs::Run()

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	TInt err = KErrNoMemory;

 	if(cleanup)

 		{

 		TRAP(err, ::RunServerL());

 		delete cleanup;

 		}

 	DbgPrint2(_L("###Dbs::Run(), end, Server ProcId=%d, err=%d\n"), RDbProcess().Id(), err);

 	return err;

 	}

 ///////////////////////

 // Client called code

 //

 // Starts the DBMS server

 //

 TInt Dbs::Start()

 	{

 	DbgPrint1(_L("#-#Dbs::Start(), Client ProcId=%d\n"), RDbProcess().Id());

 	RDbProcess server;

 	TInt err = ::CreateDbmsProcess(server);

 	if(err != KErrNone)

 		{

 		DbgPrint2(_L("#-#Dbs::Start(), CreateDbmsProcess, Client ProcId=%d, err=%d\n"), RDbProcess().Id(), err);

 		return err;

 		}

 	TRequestStatus stat;

 	server.Rendezvous(stat);

 	if(stat != KRequestPending)

 		{

 		server.Kill(0);		// abort startup

 		}

 	else

 		{

 		server.Resume();	// logon OK - start the server

 		}

 	User::WaitForRequest(stat);		// wait for start or death

 	// we can't use the 'exit reason' if the server panicked as this

 	// is the panic 'reason' and may be '0' which cannot be distinguished

 	// from KErrNone

 	err = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

 	server.Close();

 	DbgPrint2(_L("#-#Dbs::Start(), end, Client ProcId=%d, err=%d\n"), RDbProcess().Id(), err);

 	return err;

 	}