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

#include "backup.h"

#include "srvsubsess.h"

#include "log.h"

#include "centralrepositoryinternal.h"

#include <e32def_private.h>

using namespace NCentralRepositoryConstants;

CServerSubSession::CServerSubSession(CServerSession* aSession)

 : iSession(aSession), iInitialised(EFalse)

	{

	}

CServerSubSession::~CServerSubSession()

	{

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	__SRVSUBSESS_TRACE1("~CServerSubSession() UID: 0x%x\n",uid.iUid);

#endif

	iRepository.Close();

	iFindResult.Close();

	iInitialised = EFalse;

	}

// if session 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 CServerSubSession::ServiceError(TInt aError)

	{

	// ensure any transaction is failed for the reason aError

	iRepository.FailTransaction(aError, KUnspecifiedKey);

	}

TInt CServerSubSession::ServiceL(const RMessage2& aMessage)

	{

	const TClientRequest msg(aMessage);

	struct SAction

		{

		TServerRequest req;

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

		TServerFunc funcL;

		};

	static const SAction actionTable[] =

		{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			{EGetMeta,					&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetMeta}

		};

#ifdef SRVSUBSESS_TRACE

	const TPtrC actionTableNames[] =

		{

			_L("EInitialize"),

			_L("ECreateInt"),

			_L("ECreateReal"),

			_L("ECreateString"),

			_L("EDelete"),

			_L("EGetInt"),

			_L("ESetInt"),

			_L("EGetReal"),

			_L("ESetReal"),

			_L("EGetString"),

			_L("ESetString"),

			_L("EFind"),

			_L("EFindEqInt"),

			_L("EFindEqReal"),

			_L("EFindEqString"),

			_L("EFindNeqInt"),

			_L("EFindNeqReal"),

			_L("EFindNeqString"),

			_L("EGetFindResult"),

			_L("ENotifyRequestCheck"),

			_L("ENotifyRequest"),

			_L("ENotifyCancel"),

			_L("ENotifyCancelAll"),

			_L("EGroupNotifyRequest"),

			_L("EGroupNotifyCancel"),

			_L("EReset"),

			_L("EResetAll"),

			_L("ETransactionStart"),

	  		_L("ETransactionCommit"),

	  		_L("ETransactionCancel"),

			_L("EMove"),

			_L("ETransactionState"),

			_L("ETransactionFail"),

			_L("EDeleteRange"),

			_L("EGetMeta")

		};

#endif

	TInt r;

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

	__ASSERT_ALWAYS(iInitialised || fn==EInitialise, PanicClient(ESessionNotInitialised, msg));

	// In this assert we use (ELastInTable - 1) rather than ELastInTable because EClose is handled in the session

	// rather than the subsession, consiquently the actionTable array is one element shorter than ELastInTable

	__ASSERT_ALWAYS((fn < (ELastInTable)) && (fn >= EInitialise), PanicClient(EBadMessageNumber, msg));

	if (EInitialise != fn)

		{

		iRepository.AccessRepositoryL();

		}

#ifdef SRVSUBSESS_TRACE

	if (EInitialise != fn)

		{

		TUid uid = RepositoryUid();

		__SRVSUBSESS_TRACE2("CServerSubSession::ServiceL - UID: 0x%x %S\n",uid.iUid,&actionTableNames[fn]);

		}

	else

		{

		__SRVSUBSESS_TRACE1("CServerSubSession::ServiceL - UID: 0x?? %S\n",&actionTableNames[fn]);

		}

#endif

	// plus need to check we are initialised

	// this comment removes a false positive from the coverity output.  if fn >= ELastInTable then this code

	// will assert (see above).  but coverity doesn't consider this and therefore complains that there is a

	// posibility that actionTable could be indexed beyond it's length

	//coverity[overrun-local]

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

	return 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 CServerSubSession::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 CServerSubSession::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 CServerSubSession::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 (backupStatus != 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 CServerSubSession::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 CServerSubSession::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 uid = TUid::Uid(aMessage.Int0());

	__SRVSUBSESS_TRACE1("CServerSubSession::InitialiseL UID: 0x%x\n",uid.iUid);

	// Calls iObserver->AccessL internally

	iRepository.OpenL(uid, iNotifier);

	iInitialised = ETrue;

	return KErrNone;

	}

TInt CServerSubSession::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: CServerSubSession::CreateIntL - Attempt made to create a setting")))

		return iRepository.FailTransaction(KErrPermissionDenied, key);

	TInt val = aMessage.Int1();

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	__SRVSUBSESS_TRACE2("CServerSubSession::CreateIntL UID: 0x%x Key=0x%x\n",uid.iUid,key);

#endif

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

	return r;

	}

TInt CServerSubSession::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);

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	__SRVSUBSESS_TRACE2("CServerSubSession::CreateRealL UID: 0x%x Key=0x%x\n",uid.iUid,key);

#endif

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

	return r;

	}

TInt CServerSubSession::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);

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	__SRVSUBSESS_TRACE2("CServerSubSession::CreateStringL UID: 0x%x Key=0x%x\n",uid.iUid,key);

#endif

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

	return error;

	}

TInt CServerSubSession::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);

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	__SRVSUBSESS_TRACE2("CServerSubSession::DeleteL UID: 0x%x Key=0x%x\n",uid.iUid,key);

#endif

	TInt r = iRepository.TransactionDeleteL(key);

	return r;

	}

TInt CServerSubSession::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);

		}

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	if (error == KErrNone)

		{

		__SRVSUBSESS_TRACE3("CServerSubSession::GetIntL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);

		}

	else

		{

		__SRVSUBSESS_TRACE2("CServerSubSession::GetIntL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);

		}

#endif

	return error;

	}

TInt CServerSubSession::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);

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	if (error == KErrNone)

		{

		__SRVSUBSESS_TRACE3("CServerSubSession::SetIntL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);

		}

	else

		{

		__SRVSUBSESS_TRACE3("CServerSubSession::SetIntL **Failure** UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);

		}

#endif

	return error;

	}

TInt CServerSubSession::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);

		}

#ifdef SRVSUBSESS_TRACE

	TUid uid = RepositoryUid();

	if (error == KErrNone)

		{

		__SRVSUBSESS_TRACE3("CServerSubSession::GetRealL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);

		}

	else

		{

		__SRVSUBSESS_TRACE2("CServerSubSession::GetRealL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);

		}

#endif

	return error;