/*

* 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 the License "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: 

* Implements CStsServer.

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include "stsserver.h"

#include "stsserversession.h"

#include <random.h>

#include <e32cmn.h>

#include <e32std.h>

#include <usif/sts/stsdefs.h>

#include "usiflog.h"

namespace Usif

{

CStsServerSession::CStsServerSession(CStsServer& aStsserver)

	: CScsSession(static_cast<CScsServer &>(aStsserver))

	{

	}

CStsServerSession::~CStsServerSession()

	{

	if (iTransactionPtr)

		TRAP_IGNORE(static_cast<CStsServer*>(&iServer)->ReleaseTransactionL(iTransactionPtr));

	}

CStsServerSession* CStsServerSession::NewL(CStsServer &aServer, const RMessage2& /*aMessage*/)

	{

	CStsServerSession* self = new (ELeave) CStsServerSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CStsServerSession::ConstructL()

	{

	CScsSession::ConstructL();

	}

_LIT(KStsPanicCategory, "StsServer");

static const TInt KInvalidMessagePanicCode = KErrArgument;

TBool CStsServerSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)

	{

	DEBUG_PRINTF2(_L("CStsServerSession::DoServiceL() - Function %d"), static_cast<TStsClientServerFunctionType>(aFunction));							

	TBool ret = ETrue; //used in CScsSession::ServiceL(); if set to ETRue >> aMessage.Complete(KErrNone); is executed

	TStsTransactionId transactionID;

	TPckg<TStsTransactionId> idPkg(transactionID);

	RBuf buf;

	CStsServer* server=static_cast<CStsServer*>(&iServer);

	switch(static_cast<TStsClientServerFunctionType>(aFunction))

		{

		case ECreateTransaction:

			{

			if(iTransactionPtr)

				{

				User::Leave(KErrInUse);

				}

			iTransactionPtr = server->CreateTransactionL();

			transactionID = iTransactionPtr->TransactionId();

			aMessage.WriteL(KIdIPCSlot, idPkg);

			break;

			}

		case EOpenTransaction:

			{

			if(iTransactionPtr)

				{

				User::Leave(KErrInUse);

				}

			aMessage.ReadL(KIdIPCSlot, idPkg, 0);

			iTransactionPtr = server->AttachTransactionL(transactionID);

			break;

			}

		case ERegisterNew:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

			buf.CreateL(KMaxFileName);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			iTransactionPtr->RegisterNewL(buf);

			CleanupStack::PopAndDestroy(&buf);

			break;

			}

		case ECreateNew:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

			// Taking the filename size from the IPC Arguments

			// No need to do any validation of filename as it is done by File Server

			TInt srcFileNameLen = aMessage.GetDesLengthL(KFilePathIPCSlot);

			buf.CreateL(srcFileNameLen);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			TPckgBuf<TFileMode> pkgFileMode;

			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

			RFile newFile;

			CleanupClosePushL(newFile);

			iTransactionPtr->CreateNewL(buf, newFile, pkgFileMode());

	        User::LeaveIfError(newFile.TransferToClient(aMessage, KFileHandleIPCSlot));

	        ASSERT(aMessage.IsNull());  // message should have been completed

	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

			CleanupStack::PopAndDestroy(2, &buf);

			break;

			}

		case ERemove:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

			buf.CreateL(KMaxFileName);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			iTransactionPtr->RemoveL(buf);

			CleanupStack::PopAndDestroy(&buf);

			break;

			}

		case ERegisterTemporary:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

			buf.CreateL(KMaxFileName);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			iTransactionPtr->RegisterTemporaryL(buf);

			CleanupStack::PopAndDestroy(&buf);

			break;

			}

		case ECreateTemporary:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

			// Taking the filename size from the IPC Arguments

			// No need to do any validation of filename as it is done by File Server

			TInt srcFileNameLen = aMessage.GetDesLengthL(KFilePathIPCSlot);

			buf.CreateL(srcFileNameLen);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			TPckgBuf<TFileMode> pkgFileMode;

			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

			RFile newTempFile;

			CleanupClosePushL(newTempFile);

			iTransactionPtr->CreateTemporaryL(buf, newTempFile, pkgFileMode());

	        User::LeaveIfError(newTempFile.TransferToClient(aMessage, KFileHandleIPCSlot));

	        ASSERT(aMessage.IsNull());  // message should have been completed

	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

			CleanupStack::PopAndDestroy(2, &buf);

			break;

			}

		case EOverwrite:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));			

			buf.CreateL(KMaxFileName);

			buf.CleanupClosePushL();

			aMessage.ReadL(KFilePathIPCSlot, buf, 0);

			TPckgBuf<TFileMode> pkgFileMode;

			aMessage.ReadL(KFileModeIPCSlot, pkgFileMode, 0);

			RFile newFile;

			CleanupClosePushL(newFile);

			iTransactionPtr->OverwriteL(buf, newFile, pkgFileMode());

	        User::LeaveIfError(newFile.TransferToClient(aMessage, KFileHandleIPCSlot));

	        ASSERT(aMessage.IsNull());  // message should have been completed

	        ret = EFalse; //message need not be completed in CScsSession::ServiceL()

			CleanupStack::PopAndDestroy(2, &buf);

			break;

			}

		case ECommit:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

			iTransactionPtr->CommitL(); 

			server->FinaliseTransactionL(iTransactionPtr); //releases transaction and erases pointer!

			break;

			}

		case ERollBack:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

			iTransactionPtr->RollBackL();

			server->FinaliseTransactionL(iTransactionPtr); //releases transaction and erases pointer!

			break;

			}

		case EGetId:

			{

			__ASSERT_ALWAYS(iTransactionPtr, aMessage.Panic(KStsPanicCategory, KInvalidMessagePanicCode));

			transactionID = iTransactionPtr->TransactionId();

			//return ID back to client

			aMessage.WriteL(KIdIPCSlot, idPkg);

			break;

			}

		case ERollBackAllPending:

			{

			server->RollBackAllPendingL();

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			break;

			}

		}

	return ret; 

	}

}//end of namespace Usif