// SensibleServer.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "SensibleServer.h"

#include "SensibleServer_server_specific.h"

#define DebugPanic() User::Panic(KDebugPanic, __LINE__)

#define ClientPanic(aMsg) PanicClient(aMsg, - __LINE__)

inline CShutdown::CShutdown()

	:CTimer(-1)

	{CActiveScheduler::Add(this);}

inline void CShutdown::ConstructL()

	{CTimer::ConstructL();}

inline void CShutdown::Start(TInt aDelay)

	{

	if (aDelay)

		{

		After(aDelay);

		}

	}

CSensibleServer::CSensibleServer()

	:CServerBase(0,ESharableSessions)

	{}

CSensibleSession::CSensibleSession()

	: iCallbackQ(_FOFF(CCallbackContext, iLink))

	{}

inline CSensibleServer& CSensibleSession::Server()

	{return *static_cast<CSensibleServer*>(const_cast<CServerBase*>(CSessionBase::Server()));}

inline CFilteringScheduler* CSensibleServer::Scheduler()

	{return iScheduler;}

#ifdef RUN_SERVER_WITH_EIKONENV

#include <eikenv.h>

#include <eikappui.h>

class CSensibleAppUi : public CEikAppUi

	{

public:

	void ConstructL();

	~CSensibleAppUi();

private:

	CSensibleServer* iServer;

	};

void CSensibleAppUi::ConstructL()

	{

	BaseConstructL(ENoAppResourceFile /*|ENoScreenFurniture*/);

	//

	// create the server

	iServer = new(ELeave) CServer_Class_Name();

	iServer->ConstructL();

	}

CSensibleAppUi::~CSensibleAppUi()

	{

	delete iServer;

	}

// Have to derive from CONE scheduler otherwise ccoeenv complains mightily

#define SCHEDULER_SUPER CCoeScheduler

#define SCHEDULER_CONSTRUCTOR CCoeScheduler(CCoeEnv::Static())

inline void ExitScheduler() { CBaActiveScheduler::Exit(); }

#else

#define SCHEDULER_SUPER CActiveScheduler

#define SCHEDULER_CONSTRUCTOR CActiveScheduler()

inline void ExitScheduler() { CActiveScheduler::Stop(); }

#endif

class CFilteringScheduler : public SCHEDULER_SUPER

	{

public:

	CFilteringScheduler();

	void WaitForAnyRequest();

	//void OnlyRunThisObject(CActive* aActive); // This doesn't work atm!

	void RunEverythingExcept(CActive* aActive, CActive* aActive2);

	void StopFiltering();

private:

	struct SObj {

		CActive* iObject;

		TInt iCachedStatus;

		};

	static const TInt KNumFilteredObjects = 2;

	SObj iFilteredObjects[KNumFilteredObjects];

	};

inline TServerStart::TServerStart()

	{}

void TServerStart::SignalL()

//

// Signal the owning thread that the server has started successfully

// This may itself fail

//

	{

#ifdef EKA2

	RProcess::Rendezvous(KErrNone);

#else

	RThread starter;

	User::LeaveIfError(starter.Open(iId));

	starter.RequestComplete(iStatus,KErrNone);

	starter.Close();

#endif

	}

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

#ifndef __HIDE_IPC_V1__

void CSensibleSession::CreateL(const CServer& aServer)

//

// 2nd phase construct for sessions - called by the CServer framework

//

	{

	CSharableSession::CreateL(aServer);	// does not leave

	CreateL();

	}

#endif

void CSensibleSession::CreateL()

	{

	Server().AddSession();

	}

CSensibleSession::~CSensibleSession()

	{

	Server().DropSession();

	}

static void JustPanic(TAny*)

	{

	User::Panic(_L("Crash!"), 0);

	}

extern void CleanupPanicPushL()

	{

	CleanupStack::PushL(TCleanupItem(&JustPanic, 0));

	}

void CSensibleSession::ServiceL(const RMessage& aMessage)

//

// Handle a client request.

// Leaving is handled by CSensibleServer::RunError() which reports the error code

// to the client

//

	{

	switch (aMessage.Function())

		{

	case ERegisterCallbackNotifier:

		__ASSERT_ALWAYS(!iCallbackPending, ClientPanic(aMessage)); // Can't call Register is there's something already registered

		iCallbackNotifier = aMessage;

		iCallbackPending = ETrue;

		CompleteNextCallback();

		break;

	case EGetCallbackContext:

		{

		__ASSERT_ALWAYS(!iCallbackQ.IsEmpty(), ClientPanic(aMessage));

		CCallbackContext* c = iCallbackQ.First();

		__ASSERT_ALWAYS(c->Flag(EActive), ClientPanic(aMessage));

		__ASSERT_ALWAYS(c->CallbackHasContext(), ClientPanic(aMessage));

		aMessage.WriteL(SLOT(aMessage, 0), *c->Context());

		aMessage.Complete(KErrNone);

		if (!c->CallbackRequiresResult())

			{

			iCallbackQ.Remove(*c);

			delete c;

			}

		break;

		}

	case EWriteCallbackResultAndReregister:

		{

		__ASSERT_ALWAYS(!iCallbackPending, ClientPanic(aMessage)); // Can't call Register is there's something already registered

		__ASSERT_ALWAYS(!iCallbackQ.IsEmpty(), ClientPanic(aMessage));

		CCallbackContext* c = iCallbackQ.First();

		__ASSERT_ALWAYS(c->Flag(EActive), ClientPanic(aMessage));

		__ASSERT_ALWAYS(c->CallbackRequiresResult(), ClientPanic(aMessage));

		// Get the reregistering out of the way

		iCallbackNotifier = aMessage;

		iCallbackPending = ETrue;

		if (aMessage.Int2() < 0)

			{

			// Leave code

			c->SetFlags(EResultIsLeaveCode);

			c->Result().integer = aMessage.Int2();

			}

		else if (c->Flag(EResultHBufC16))

			{

			HBufC16* result = HBufC16::New(aMessage.Int2());

			if (!result) 

				{

				c->SetFlags(EResultIsLeaveCode);

				c->Result().integer = KErrNoMemory;

				}

			else

				{

				*c->Result().l = result;

				TPtr16 ptr(result->Des());

				aMessage.ReadL(SLOT(aMessage, 1), ptr);

				}

			}

		else if (c->Flag(EResultHBufC8))

			{

			HBufC8* result = HBufC8::New(aMessage.Int2());

			if (!result) 

				{

				c->SetFlags(EResultIsLeaveCode);

				c->Result().integer = KErrNoMemory;

				}

			else

				{

				*c->Result().s = result;

				TPtr8 ptr(result->Des());

				aMessage.ReadL(SLOT(aMessage, 1), ptr);

				}

			}

		else

			{

			// It's a TPkg

			aMessage.ReadL(SLOT(aMessage, 1), *c->Result().pkg);

			}

		CActiveScheduler::Stop();

		break;

		}

	case ECancelCallbackNotifier:

		{

		if (iCallbackPending)

			{

			iCallbackNotifier.Complete(KErrCancel);

			iCallbackPending = EFalse;

			}

		aMessage.Complete(KErrNone);

		break;

		}

	case EDummy:

		aMessage.Complete(KErrNone);

		break;

	default:

		if (!DoServiceL(aMessage))

			{

			PanicClient(aMessage, EPanicIllegalFunction);

			}

		break;

		}

	}

TBool CSensibleSession::DoServiceL(const RMessage& aMessage)

	{

	// Subclasses override this!

	aMessage.Complete(KErrNone);

	return ETrue;

	}

void CShutdown::RunL()

//

// Initiate server exit when the timer expires

//

	{

	ExitScheduler();

	}

void CSensibleServer::ConstructL()

//

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

//

	{

	StartL(KMyServerName);

	iShutdown.ConstructL();

	// ensure that the server still exits even if the 1st client fails to connect

	iShutdown.Start(TransientServerShutdownTime());

	// Now set up our special scheduler. This is tricky because of good old eikonenv doing stuff differently

	// Basically without eikonenv, RunServer owns the old scheduler so we can't delete it

	// However eikonenv will delete the new one as part of its shutdown!

	iScheduler = new(ELeave) CFilteringScheduler();

	iOldScheduler = CActiveScheduler::Replace(iScheduler);

#ifdef RUN_SERVER_WITH_EIKONENV

	DISOWN(iOldScheduler);

#endif

	}

CSensibleServer::~CSensibleServer()

	{

#ifndef RUN_SERVER_WITH_EIKONENV

	DISOWN(iScheduler); // To mimic what CCoeEnv does

#endif

	}

#ifdef __HIDE_IPC_V1__

CSessionBase* CSensibleServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage& /*aMessage*/) const

#else

CSessionBase* CSensibleServer::NewSessionL(const TVersion& /*aVersion*/) const

#endif

//

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

//

	{

	return new(ELeave) CSensibleSession();

	}

void CSensibleServer::AddSession()

//

// A new session is being created

// Cancel the shutdown timer if it was running

//

	{

	++iSessionCount;

	iShutdown.Cancel();

	}

void CSensibleServer::DropSession()

//

// A session is being destroyed

// Start the shutdown timer if it is the last session.

//

	{

	if (--iSessionCount==0 && CActiveScheduler::Current()) // Check we have a scheduler, because if the server is being shut down there won't be one (and there'll be no point starting a shutdown timer

		iShutdown.Start(TransientServerShutdownTime());

	}

TInt CSensibleServer::RunError(TInt aError)

//

// Handle an error from CSensibleSession::ServiceL()

// A bad descriptor error implies a badly programmed client, so panic it;

// otherwise report the error to the client

//

	{

	if (aError==KErrBadDescriptor)

		PanicClient(Message(),EPanicBadDescriptor);

	else

		Message().Complete(aError);

	//

	// The leave will result in an early return from CServer::RunL(), skipping

	// the call to request another message. So do that now in order to keep the

	// server running.

	ReStart();

	return KErrNone;	// handled the error fully

	}

/*void CSensibleServer::BlockAllAOsExceptServerRequests()

	{

	Scheduler()->OnlyRunThisObject(this);

	}*/

void CSensibleServer::BlockRequestsFrom(CActive* aActive1, CActive* aActive2)

	{

	Scheduler()->RunEverythingExcept(aActive1, aActive2);

	}

void CSensibleServer::StopBlocking()

	{

	Scheduler()->StopFiltering();

	}

TInt CSensibleServer::TransientServerShutdownTime() const

	{

	return 2000000; // Default to 2 seconds

	}

void PanicClient(const RMessage& aMessage, TInt aPanic)

//

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

//

	{

	__DEBUGGER();

	aMessage.Panic(KDebugPanic, aPanic);

	}

static void RunServerL(TServerStart& aStart)

//

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

// scheduler and server and then run the scheduler

//

	{

#ifndef RUN_SERVER_WITH_EIKONENV

	// create and install the active scheduler we need

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(s);

	CActiveScheduler::Install(s);

#endif

	//

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

#ifdef __SECURE_API__

	User::LeaveIfError(User::RenameThread(KMyServerName));

#else

	User::LeaveIfError(RThread().Rename(KMyServerName));

#endif

#ifdef RUN_SERVER_WITH_EIKONENV

	// In this case, the server creation/destruction is pushed into CSensibleAppUi

	// Give ourselves a eikonenv

	CEikonEnv* env = new CEikonEnv;

	CEikAppUi* appui = NULL;

	TInt err = KErrNone;

	if (env != NULL)

		{

		TRAP(err,

			env->ConstructL(EFalse);

			appui = new (ELeave)CSensibleAppUi();

			appui->ConstructL();

			env->SetAppUi(appui);

			);

		}

	if (err == KErrNone)

		{

		//

		// Initialisation complete, now signal the client

		aStart.SignalL();

		env->ExecuteD();

		}

	else

		{

		if (env != NULL)

			{

			env->DestroyEnvironment();

			}

		User::Leave(err); // This will tell the client that something's gone wrong

		}

#else	

	//

	// create the server

	CSensibleServer* server = new(ELeave) CServer_Class_Name();

	CleanupStack::PushL(server);

	server->ConstructL();

	//

	// Initialisation complete, now signal the client

	aStart.SignalL();

	//

	// Ready to run

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2, s); // server, scheduler

#endif

	}

static TInt RunServer(TServerStart& aStart)

//

// Main entry-point for the server thread

//

	{

	__UHEAP_MARK;

	//

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

//#ifdef _DEBUG

//		TRAP(r, CleanupPanicPushL(); RunServerL(aStart); CleanupStack::Pop());

//#else

		TRAP(r,RunServerL(aStart));

//#endif

		delete cleanup;

		}

	//

	__UHEAP_MARKEND;

	return r;

	}

#ifndef EKA2

// The server binary is an "EPOCEXE" target type

// Thus the server parameter passing and startup code for WINS and EPOC are

// significantly different.

#ifdef __WINS__

// In WINS, the EPOCEXE target is a DLL with an entry point called WinsMain,

// taking no parameters and returning TInt. This is not really valid as a thread

// function which takes a TAny* parameter which we need.

//

// So the DLL entry-point WinsMain() is used to return a TInt representing the

// real thread function within the DLL. This is good as long as

// sizeof(TInt)>=sizeof(TThreadFunction).

//

static TInt ThreadFunction(TAny* aParms)

//

// WINS thread entry-point function.

// The TServerStart objects is passed as the thread parameter

//

	{

	return RunServer(*static_cast<TServerStart*>(aParms));

	}

IMPORT_C TInt WinsMain();

EXPORT_C TInt WinsMain()

//

// WINS DLL entry-point. Just return the real thread function 

// cast to TInt

//

	{

	return reinterpret_cast<TInt>(&ThreadFunction);

	}

TInt E32Dll(TDllReason)