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

//

#include "panic.h"

#include "sessnotf.h"

#include "srvreqs.h"

#include "srvsess.h"

#include "cachemgr.h"

#include <centralrepository.h>

#include "backup.h"

using namespace NCentralRepositoryConstants;

#ifdef __CENTREP_SERVER_PERFTEST__

// Function EncodeEventAndData

// Put event Id in upper 8 bit and data in lower 24 bit.

inline

TUint32 EncodeEventAndData(TUint aEventId, TUint32 aData)

	{

	return ((aEventId & KEventIdMask) << KEventIdShiftBits) |

		   (aData & KDataMask);

	}

#endif //__CENTREP_SERVER_PERFTEST__

inline CSessionManager& CServerSession::Server()

	{return *static_cast<CSessionManager*>(const_cast<CServer2*>(CSession2::Server()));}

CServerSession::~CServerSession()

	{

	iFindResult.Close();

#ifdef __CENTREP_SERVER_PERFTEST__

	DoEventStart();

#endif

	iRepository.Close(iNotifier);

#ifdef __CENTREP_SERVER_PERFTEST__

	if (iInitialised)

		{

		DoEventEnd(ESessionClose);

		}

#endif

	}

// if ServiceL Leaves, execution resumes in this method.

// this allows us to panic clients using bad descriptors, to deal with OOM conditions

// and to fail transactions with the correct reason: OOM etc.

void CServerSession::ServiceError(const RMessage2 &aMessage, TInt aError)

	{

	// ensure any transaction is failed for the reason aError

	iRepository.FailTransaction(aError, KUnspecifiedKey);

	CSession2::ServiceError(aMessage, aError);

	}

void CServerSession::ServiceL(const RMessage2& aMessage)

	{

	const TClientRequest msg(aMessage);

	struct SAction

		{

		TServerRequest req;

		TInt (CServerSession::*groupFuncL)(const TClientRequest&, TServerFunc);

		TServerFunc funcL;

		};

	static const SAction actionTable[] =

		{

			{EInitialise,				&CServerSession::GeneralOperationsL,	&CServerSession::InitialiseL},

			{ECreateInt,				&CServerSession::WriteOperationsL,		&CServerSession::CreateIntL},

			{ECreateReal,				&CServerSession::WriteOperationsL,		&CServerSession::CreateRealL},

			{ECreateString,				&CServerSession::WriteOperationsL,		&CServerSession::CreateStringL},

			{EDelete,					&CServerSession::WriteOperationsL,		&CServerSession::DeleteL},

			{EGetInt,					&CServerSession::ReadOperationsL,		&CServerSession::GetIntL},

			{ESetInt,					&CServerSession::WriteOperationsL,		&CServerSession::SetIntL},

			{EGetReal,					&CServerSession::ReadOperationsL,		&CServerSession::GetRealL},

			{ESetReal,					&CServerSession::WriteOperationsL,		&CServerSession::SetRealL},

			{EGetString,				&CServerSession::ReadOperationsL,		&CServerSession::GetStringL},

			{ESetString,				&CServerSession::WriteOperationsL,		&CServerSession::SetStringL},

			{EFind,						&CServerSession::ReadOperationsL,		&CServerSession::FindL},

			{EFindEqInt,				&CServerSession::ReadOperationsL,		&CServerSession::FindEqIntL},

			{EFindEqReal,				&CServerSession::ReadOperationsL,		&CServerSession::FindEqRealL},

			{EFindEqString,				&CServerSession::ReadOperationsL,		&CServerSession::FindEqStringL},

			{EFindNeqInt,				&CServerSession::ReadOperationsL,		&CServerSession::FindNeqIntL},

			{EFindNeqReal,				&CServerSession::ReadOperationsL,		&CServerSession::FindNeqRealL},

			{EFindNeqString,			&CServerSession::ReadOperationsL,		&CServerSession::FindNeqStringL},

			{EGetFindResult,			&CServerSession::ReadOperationsL,		&CServerSession::GetFindResultL},

			{ENotifyRequestCheck,		&CServerSession::GeneralOperationsL,	&CServerSession::NotifyRequestCheck},

			{ENotifyRequest,			&CServerSession::GeneralOperationsL,	&CServerSession::NotifyRequest},

			{ENotifyCancel,				&CServerSession::GeneralOperationsL,	&CServerSession::NotifyCancel},

			{ENotifyCancelAll,			&CServerSession::GeneralOperationsL,	&CServerSession::NotifyCancelAll},

			{EGroupNotifyRequest,		&CServerSession::GeneralOperationsL,	&CServerSession::GroupNotifyRequest},

			{EGroupNotifyCancel,		&CServerSession::GeneralOperationsL,	&CServerSession::GroupNotifyCancel},

			{EReset,					&CServerSession::ResetOperationsL,		&CServerSession::ResetL},

			{EResetAll,					&CServerSession::ResetOperationsL,		&CServerSession::ResetAllL},

			{ETransactionStart,			&CServerSession::GeneralOperationsL,	&CServerSession::TransactionStart},

  			{ETransactionCommit,		&CServerSession::GeneralOperationsL,	&CServerSession::TransactionCommitL},

  			{ETransactionCancel,		&CServerSession::GeneralOperationsL,	&CServerSession::TransactionCancel},

			{EMove,						&CServerSession::WriteOperationsL,		&CServerSession::MoveL},

			{ETransactionState,			&CServerSession::GeneralOperationsL,	&CServerSession::TransactionStateL},

			{ETransactionFail,			&CServerSession::GeneralOperationsL,	&CServerSession::TransactionFail},

			{EDeleteRange,				&CServerSession::WriteOperationsL,		&CServerSession::DeleteRangeL}

		};

	TInt r;

	TServerRequest fn = static_cast<TServerRequest>(aMessage.Function());

#if defined(__CENTREP_SERVER_PERFTEST__) || defined(__CENTREP_SERVER_MEMTEST__) || defined(__CENTREP_SERVER_CACHETEST__)

	if (fn == EGetSetParameters)

		{

		r = GetSetParameters(msg);

		aMessage.Complete(r);

		return;

		}

#endif

#ifdef __CENTREP_SERVER_PERFTEST__

    DoEventStart();

	if (EInitialise == fn)

		{

		iRepositoryUid = aMessage.Int0();

		}

#endif

	__ASSERT_ALWAYS(iInitialised || fn==EInitialise,

		PanicClient(ESessionNotInitialised, msg));

	if(fn>ELastInTable)

		{

		r = KErrNotSupported; // or panic client??

		}

	else

		{

		iRepository.RestoreConsistencyL();

		// plus need to check we are initialised

		r = (this->*actionTable[fn].groupFuncL)(aMessage, actionTable[fn].funcL);

		}

#ifdef __CENTREP_SERVER_PERFTEST__

	DoEventEnd(fn);

#endif

	if (r != KDontComplete)

		{

		aMessage.Complete(r);

		}

	}

//method allows transactions and notify requests to get through during backup/restore

//process to prevent them from being blocked.

//Transactions being blocked would lead clients to be panicked

//if they were trying to open a second transaction in the same session. 

// Notify cancels must be allowed through because they must always succeed.

TInt CServerSession::GeneralOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)

	{

	ASSERT(aFuncL != NULL);

	return (this->*aFuncL)(aMessage);

	}

// method allows read operations to share transaction-related tasks.

// Read operations are allowed only during backup process. 

// During restore it fails transactions with KErrLocked and returns KErrAbort

// and if it is a standalone read oparation it rejects it with KErrServerBusy.

TInt CServerSession::ReadOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)

	{

	TInt backupStatus = CRepositoryBackupClient::GetBackupStatus();

	if (iRepository.IsInFailedTransaction())

		{

		return KErrAbort;

		}

	else if (iRepository.IsInTransaction() && (backupStatus == ERestoreInProgress) )

	    {

	    iRepository.FailTransaction(KErrLocked,KUnspecifiedKey);

	    return KErrAbort;

	    }

	else if (backupStatus == ERestoreInProgress)

	    {

	    return KErrServerBusy;

	    }

	ASSERT(aFuncL != NULL);

	return (this->*aFuncL)(aMessage);

	}

// method allows write operations to share transaction-related tasks

// All write operations are not allowed either during backup or restore process.

// If backup or restore is in progress it fails transaction with KErrLocked, 

// returns KErrAbort or if it is a standalone operation it returns KErrServerBusy. 

TInt CServerSession::WriteOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)

	{

	TInt backupStatus = CRepositoryBackupClient::GetBackupStatus();

	if (iRepository.IsInFailedTransaction())

		{

		return KErrAbort;

		}

	else if (iRepository.IsInTransaction() && (backupStatus != ENoBackupActivty) )

	    {

	    iRepository.FailTransaction(KErrLocked,KUnspecifiedKey);

	    return KErrAbort;

	    }

    else if (CRepositoryBackupClient::GetBackupStatus() != ENoBackupActivty)

        {

        return KErrServerBusy;

        }

	// if not already in a transaction, create a temporary concurrent read/write transaction

	const TBool tempTransaction = !iRepository.IsInTransaction();

	if (tempTransaction)

		{

		// concurrent read/write transaction is guaranteed to start

		iRepository.StartTransaction(EConcurrentReadWriteTransaction);

		// to protect against Leaves:

		iRepository.CleanupCancelTransactionPushL();

		}

	else

		{

		if (iRepository.IsInActiveReadTransaction())

			{

			// must be a read/write transaction to continue

			iRepository.AttemptPromoteTransactionToReadWrite();

			// Note we don't check the return value of the above and return it here.

			// Instead we call the next level write function and expect it to have the

			// following code:

			//	if (iRepository.IsInActiveReadTransaction())

			//		{

			//		return iRepository.FailTransaction(KErrLocked, key);

			//		}

			// this ensures CommitTransaction reports the failing key. 

			}

		// Note ServiceError will fail the transaction if write operation leaves

		}

	// call the server function

	ASSERT(aFuncL != NULL);

	TInt result = (this->*aFuncL)(aMessage);

	// commit the temporary transaction

	if (tempTransaction)

		{

		CleanupStack::Pop(); // remove cleanup item from earlier

		// absorb result and keyInfo from commit of temporary transaction

		TUint32 tempKeyInfo;

		User::LeaveIfError(iRepository.CommitTransaction(tempKeyInfo));

		}

	return result;

	}

TInt CServerSession::ResetOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)

	{

	// reset operations are not currently supported in transactions

	if (iRepository.IsInTransaction())

		{

		// fail transaction otherwise client may be misled to believe operation worked

		return iRepository.FailTransaction(KErrNotSupported, KUnspecifiedKey);

		}

   //can't reset when backup or restore is in progress

   else if (CRepositoryBackupClient::GetBackupStatus() != ENoBackupActivty)

        {

        return KErrServerBusy;

        }		

	ASSERT(aFuncL != NULL);

	return (this->*aFuncL)(aMessage);

	}

TInt CServerSession::InitialiseL(const TClientRequest& aMessage)

	{

	__ASSERT_ALWAYS(!iInitialised,

		PanicClient(ESessionAlreadyInitialised, aMessage));

	// We let anyone to open a repository... 

	// it's not considered a breach of security to let people know

	// that a repository is there... 

	TUid repositoryUid = TUid::Uid(aMessage.Int0());

	iRepository.OpenL(repositoryUid, iNotifier);

	iInitialised = ETrue;

	return KErrNone;

	}

TInt CServerSession::CreateIntL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	if(KErrNone !=  CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::CreateIntL - Attempt made to create a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TInt val = aMessage.Int1();

	TInt r = iRepository.TransactionCreateL(key, val, 0);

	return r;

	}

TInt CServerSession::CreateRealL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::CreateRealL - Attempt made to create a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TReal val;

	TPckg<TReal> p(val);

	aMessage.ReadL(1, p);

	TInt r = iRepository.TransactionCreateL(key, val, 0);

	return r;

	}

TInt CServerSession::CreateStringL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	// sometime: must ensure bad descriptor results in client being panic'd

	// check for descriptor-too-long was previously on the client side,

	// hence test code expects KErrArgument response before KErrPermissionDenied

	TInt length = aMessage.GetDesLengthL(1);

	if (length > KMaxBinaryLength)

		{

		return iRepository.FailTransaction(KErrArgument, key);

		}

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::CreateStringL - Attempt made to create a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TBuf8<KMaxBinaryLength> val;

	aMessage.ReadL(1, val);

	TInt error = iRepository.TransactionCreateL(key, val, 0);

	return error;

	}

TInt CServerSession::DeleteL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::DeleteL - Attempt made to delete a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TInt r = iRepository.TransactionDeleteL(key);

	return r;

	}

TInt CServerSession::GetIntL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),

				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetIntL - Attempt made to read a setting")))

		return KErrPermissionDenied;

	TInt val;

	TInt error = iRepository.Get(key, val);

	if (error == KErrNone)

		{

		TPckg<TInt> p(val);

		aMessage.WriteL(1, p);

		}

	return error;

	}

TInt CServerSession::SetIntL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::SetIntL - Attempt made to write a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TInt val = aMessage.Int1();

	TInt error = iRepository.TransactionSetL(key, val);

	return error;

	}

TInt CServerSession::GetRealL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),

				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetRealL - Attempt made to read a setting")))

		return KErrPermissionDenied;

	TReal val;

	TInt error = iRepository.Get(key, val);

	if(error==KErrNone)

		{

		TPckg<TReal> p(val);

		aMessage.WriteL(1, p);

		}

	return error;

	}

TInt CServerSession::SetRealL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used

	if (iRepository.IsInActiveReadTransaction())

		{

		return iRepository.FailTransaction(KErrLocked, key);

		}

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),

				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::SetRealL - Attempt made to write a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TReal val;

	TPckg<TReal> p(val);

	aMessage.ReadL(1, p);

	TInt error = iRepository.TransactionSetL(key, val);

	return error;

	}

TInt CServerSession::GetStringL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();

	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),

				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetStringL - Attempt made to read a setting")))

		return KErrPermissionDenied;

	TBuf8<KMaxBinaryLength> val;

	TInt error = iRepository.Get(key, val);

	if(error==KErrNone)

		{

		TInt clientMaxDescriptorLength;

		TPckg<TInt> pInt (clientMaxDescriptorLength);

		aMessage.Read(2, pInt);

		TInt descriptorLength = val.Length();

		// write the descriptor length to aMessage			

		TPckg<TInt> p(descriptorLength);

		error = aMessage.Write(2, p);

		if(error==KErrNone)

			{

			if(descriptorLength > clientMaxDescriptorLength)

				{

				// if it is, fill the descriptor up to its max length

				error = aMessage.Write(1, val.Left(clientMaxDescriptorLength));

				// if client-side descriptor is too small to take the value, which it is, returns KErrOverflow

				if(error == KErrNone)

					{

					error = KErrOverflow;

					}

				}

			else

				{

				error = aMessage.Write(1, val);

				}

			}

		// if error is KErrOverflow should not failing transaction

		if ((error != KErrNone) && (error != KErrOverflow))

			{

			// ServiceError will fail transaction

			User::Leave(error);

			}

		}

	return error;

	}

TInt CServerSession::SetStringL(const TClientRequest& aMessage)

	{

	TUint32 key = aMessage.Int0();