// server.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 "server.h"

#include "pipe.h"

#include "console.h"

#include "file.h"

#include "null.h"

#include "persistentconsole.h"

#include "readwrite.h"

#include "clientserver.h"

#include "session.h"

#ifndef EKA2

//

// TServerStart.

//

TServerStart::TServerStart()

	{

	}

void TServerStart::SignalL()

	{

	RThread starter;

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

	starter.RequestComplete(iStatus,KErrNone);

	starter.Close();

	}

#endif

//

// CShutdownTimer.

//

CShutdownTimer::CShutdownTimer()

	: CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

void CShutdownTimer::ConstructL()

	{

	CTimer::ConstructL();

	}

void CShutdownTimer::Start()

	{

	After(KShutdownDelay);

	}

void CShutdownTimer::RunL()

	{

	CActiveScheduler::Stop();

	}

//

// CIoServer.

//

CIoServer::CIoServer()

#ifdef EKA2

	: CServer2(0, ESharableSessions)

#else

	: CServer(0, ESharableSessions)

#endif

	{

	}

#ifdef EKA2

CServer2* CIoServer::NewLC()

#else

CServer* CIoServer::NewLC()

#endif

	{

	CIoServer* self=new(ELeave) CIoServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CIoServer::~CIoServer()

	{

	if (iIoObjectContainerIndex)

		{

		iIoObjectContainerIndex->Remove(iIoObjectContainer);

		}

	delete iIoObjectContainerIndex;

#ifdef IOSRV_LOGGING

	delete iLog;

#endif

	}

void CIoServer::ConstructL()

	{

#if defined (__WINS__) && !defined (EKA2)

	RThread().SetPriority(EPriorityAbsoluteHigh);

#else

	RProcess().SetPriority(::EPriorityHigh);

#endif

	User::LeaveIfError(iFs.Connect());

#ifdef IOSRV_LOGGING

	iLog = CIoLog::NewL(iFs);

#endif

	iConfig.Init(); // Ignore error (defaults will be used).

	StartL(KIoServerName);

	iIoObjectContainerIndex = CObjectConIx::NewL();

	iIoObjectContainer = iIoObjectContainerIndex->CreateL();

	iShutdownTimer.ConstructL();

	iShutdownTimer.Start();

	}

#ifdef EKA2

	CSession2* CIoServer::NewSessionL(const TVersion&, const RMessage2&) const

#else

	CSharableSession* CIoServer::NewSessionL(const TVersion&) const

#endif

	{

	CIoSession* session = new(ELeave) CIoSession();

	LOG(CIoLog::Printf(_L("CIoSession 0x%08x created\r\n"), session));

	return session;

	}

void CIoServer::AddSession()

	{

	++iSessionCount;

	iShutdownTimer.Cancel();

	}

void CIoServer::DropSession()

	{

	if (--iSessionCount == 0)

		{

		iShutdownTimer.Start();

		}

	}

CIoPipe& CIoServer::CreatePipeLC()

	{

	CIoPipe* pipe = CIoPipe::NewLC();

	iIoObjectContainer->AddL(pipe);

	return *pipe;

	}

CIoConsole& CIoServer::CreateConsoleLC(const TDesC& aImplementation, const TDesC& aTitle, TSize aSize, MIoWriteEndPoint* aUnderlyingConsole, TUint aOptions)

	{

	CIoConsole* underlying = NULL;

	while (aUnderlyingConsole && aUnderlyingConsole->IoepIsType(RIoHandle::EPersistentConsole))

		{

		aUnderlyingConsole = ((CIoPersistentConsole*)aUnderlyingConsole)->TransientWriter();

		}

	if (aUnderlyingConsole && aUnderlyingConsole->IoepIsConsole())

		{

		underlying = (CIoConsole*)aUnderlyingConsole;

		}

	CIoConsole* console = CIoConsole::NewLC(aImplementation, aTitle, aSize, iConfig, underlying, aOptions);

	iIoObjectContainer->AddL(console);

	return *console;

	}

CIoFile& CIoServer::CreateFileLC(const TDesC& aName, RIoFile::TMode aMode)

	{

	CIoFile* file = CIoFile::NewLC(iFs, aName, aMode);

	iIoObjectContainer->AddL(file);

	return *file;

	}

CIoNull& CIoServer::CreateNullLC()

	{

	CIoNull* null = CIoNull::NewLC();

	iIoObjectContainer->AddL(null);

	return *null;

	}

CIoPersistentConsole& CIoServer::CreatePersistentConsoleLC(const TDesC& aName, const TDesC& aTitle, const RMsg& aMessage)

	{

	CIoPersistentConsole* pcons = CIoPersistentConsole::NewLC(aName, aTitle, *this, aMessage);

	iIoObjectContainer->AddL(pcons);

	return *pcons;

	}

CIoReadObject& CIoServer::CreateReadObjLC()

	{

	CIoReadObject* obj = CIoReadObject::NewLC(iNextReadObjId++);

	iIoObjectContainer->AddL(obj);

	return *obj;

	}

CIoWriteObject& CIoServer::CreateWriteObjLC()

	{

	CIoWriteObject* obj = CIoWriteObject::NewLC(iNextWriteObjId++);

	iIoObjectContainer->AddL(obj);

	return *obj;

	}

CIoReadObject* CIoServer::NextReadObj(TThreadId aOwningThread) const

	{

	return (CIoReadObject*)DoFindObj(RIoHandle::EReadObject, aOwningThread, ETrue);

	}

CIoReadWriteObject* CIoServer::DoFindObj(RIoHandle::TType aType, TThreadId aOwningThread, TBool aNext) const

	{

	CIoReadWriteObject* lastMatchingObj = NULL;

	const TInt numObjs = iIoObjectContainer->Count();

	for (TInt i = 0; i < numObjs; ++i)

		{

		CIoObject* obj = (CIoObject*)(*iIoObjectContainer)[i];

		if (obj->IsType(aType))

			{

			CIoReadWriteObject* readWriteObj = (CIoReadWriteObject*)obj;

			if (aNext && readWriteObj->IsOwner(aOwningThread) && !readWriteObj->OpenedByOwner())

				{

				// aNext==ETrue means we return the first matching object that isn't already opened by its owner

				return readWriteObj;

				}

			else if (!aNext && readWriteObj->IsOwner(aOwningThread) && readWriteObj->OpenedByOwner())

				{

				// aNext==EFalse means we return the last matching object that *is* opened

				lastMatchingObj = readWriteObj;

				}

			}

		}

	return lastMatchingObj;

	}

CIoWriteObject* CIoServer::NextWriteObj(TThreadId aOwningThread) const

	{

	return (CIoWriteObject*)DoFindObj(RIoHandle::EWriteObject, aOwningThread, ETrue);

	}

CIoReadObject* CIoServer::LastOpenedReadObj(TThreadId aOwningThread) const

	{

	return (CIoReadObject*)DoFindObj(RIoHandle::EReadObject, aOwningThread, EFalse);

	}

CIoWriteObject* CIoServer::LastOpenedWriteObj(TThreadId aOwningThread) const

	{

	return (CIoWriteObject*)DoFindObj(RIoHandle::EWriteObject, aOwningThread, EFalse);

	}

CIoPersistentConsole& CIoServer::FindPersistentConsoleL(const TDesC& aName)

	{

	const TInt numObjs = iIoObjectContainer->Count();

	for (TInt i=0; i<numObjs; ++i)

		{

		CIoObject* obj = (CIoObject*)(*iIoObjectContainer)[i];

		if (obj->IsType(RIoHandle::EPersistentConsole))

			{

			CIoPersistentConsole& pcons = (CIoPersistentConsole&)*obj;

			if (pcons.Name().Compare(aName)==0)

				{

				return pcons;

				}

			}

		}

	User::Leave(KErrNotFound);

	return *(CIoPersistentConsole*)1; // To keep the compiler happy.

	}

CIoObject* CIoServer::FindObjectByName(RIoHandle::TType aType, TInt& aFindHandle, const TDesC& aMatch, TName& aName) const

	{

	FOREVER

		{

		TInt err = iIoObjectContainer->FindByName(aFindHandle, aMatch, aName);

		if (err == KErrNone)

			{

			CIoObject* obj = (CIoObject*)iIoObjectContainer->At(aFindHandle);

			if (obj->IsType(aType))

				{

				return obj;

				}

			}

		else

			{

			break;

			}

		}

	return NULL;

	}

CIoObject& CIoServer::OpenObjectLC(TInt aFindHandle)

	{

	CIoObject* obj = (CIoObject*)iIoObjectContainer->At(aFindHandle);

	if (obj)

		{

		User::LeaveIfError(obj->Open());

		CleanupClosePushL(*obj);

		return *obj;

		}

	User::Leave(KErrNotFound);

	return *(CIoObject*)1; // To keep the compiler happy.

	}

const TIoConfig& CIoServer::Config()

	{

	return iConfig;

	}

void CIoServer::PersistentConsoleAddL(const TDesC16& aName, const CIoPersistentConsole& aCons)

	{

	if (iPersistentConsoleNames.Find(aName)!=NULL)

		{

		User::Leave(KErrAlreadyExists);

		}

	iPersistentConsoleNames.InsertL(&aName, &aCons);

	}

void CIoServer::PersistentConsoleRemove(const TDesC16& aName, const CIoPersistentConsole& aCons)

	{

	if (iPersistentConsoleNames.Find(aName) == &aCons)

		{

		iPersistentConsoleNames.Remove(&aName);

		}

	}

TInt CIoServer::RunError(TInt aError)

	{

	if (aError == KErrBadDescriptor)

		{

		PanicClient(Message(), EPanicBadDescriptor);

		}

	else if (aError == KErrBadHandle)

		{

		PanicClient(Message(), EPanicBadHandle);

		}

	else

		{

		LOG(CIoLog::LogCompletion(Message(), aError));

		Complete(Message(), aError);

		}

	ReStart();

	return KErrNone;

	}

//

// Statics.

//

void PanicClient(const RMsg& aMessage, TIoPanicReason aReason)

	{

	aMessage.Panic(KIoServerName, aReason);

	}

#ifdef EKA2

static void RunServerL()

#else

static void RunServerL(TServerStart& aStart)

#endif

	{

	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CIoServer::NewLC();

#ifdef EKA2

	User::RenameThread(KIoServerName);

	RProcess::Rendezvous(KErrNone);

#else

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

	aStart.SignalL();

#endif

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2, scheduler);

	}

#ifdef EKA2

static TInt RunServer()

#else

static TInt RunServer(TServerStart& aStart)

#endif

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r = KErrNoMemory;

	if (cleanup)

		{

#ifdef EKA2

		TRAP(r, RunServerL());

#else

		TRAP(r, RunServerL(aStart));

#endif

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}

#if defined(__WINS__) && !defined(EKA2)

static TInt ThreadFunction(TAny* aParms)

	{

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

	}

IMPORT_C TInt WinsMain();

EXPORT_C TInt WinsMain()

	{

	return reinterpret_cast<TInt>(&ThreadFunction);

	}

TInt E32Dll(TDllReason)

	{

	return KErrNone;

	}

#else

#ifdef EKA2

TInt E32Main()

	{

	return RunServer();

	}

#else

TInt TServerStart::GetCommand()

	{

	RProcess p;

	if (p.CommandLineLength() != (sizeof(TServerStart) / sizeof(TText)))

		{

		return KErrGeneral;

		}

	TPtr ptr(reinterpret_cast<TText*>(this), 0, (sizeof(TServerStart) / sizeof(TText)));

	p.CommandLine(ptr);

	return KErrNone;

	}

TInt E32Main()

	{

	TServerStart start;

	TInt r = start.GetCommand();

	if (r == KErrNone)

		{

		r = RunServer(start);

		}

	return r;

	}

#endif

#endif

#ifndef EKA2

const TAny* MessagePtr(const RMsg& aMessage, TInt aParam)

	{

	const TAny* ptr;

	switch (aParam)

		{

		case 0:

			{

			ptr = aMessage.Ptr0();

			break;

			}

		case 1:

			{

			ptr = aMessage.Ptr1();

			break;

			}

		case 2:

			{

			ptr = aMessage.Ptr2();

			break;

			}

		case 3:

			{

			ptr = aMessage.Ptr3();

			break;

			}

		default:

			{

			ASSERT(EFalse);

			ptr = NULL;

			}

		}

	return ptr;

	}

#endif

TInt DesLengthL(const RMsg& aMessage, TInt aParam)	

	{

#ifdef EKA2

	return aMessage.GetDesLengthL(aParam);

#else

	return aMessage.Client().GetDesLength(MessagePtr(aMessage, aParam));

#endif

	}

TInt MaxDesLengthL(const RMsg& aMessage, TInt aParam)

	{

#ifdef EKA2

	return aMessage.GetDesMaxLengthL(aParam);

#else

	return aMessage.Client().GetDesMaxLength(MessagePtr(aMessage, aParam));

#endif

	}

void MessageReadL(const RMsg& aMessage, TInt aParam, TDes8& aDes)

	{

#ifdef EKA2

	aMessage.ReadL(aParam, aDes);

#else

	aMessage.ReadL(MessagePtr(aMessage, aParam), aDes);

#endif

	}

void MessageReadL(const RMsg& aMessage, TInt aParam, TDes8& aDes, TInt aOffset)

	{

#ifdef EKA2

	aMessage.ReadL(aParam, aDes, aOffset);