--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/centralrepository/cenrepsrv/srvsubsess.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1374 @@
+// Copyright (c) 2006-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 "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;
+	}
+
+TInt CServerSubSession::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);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::SetRealL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::SetRealL **Failure** UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
+		}
+#endif
+
+	return error;
+	}
+
+TInt CServerSubSession::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);
+				}
+
+#ifdef SRVSUBSESS_TRACE
+			TUid uid = RepositoryUid();
+
+			if (error == KErrNone)
+				{
+				__SRVSUBSESS_TRACE3("CServerSubSession::GetStringL UID: 0x%x Key=0x%x Value=%S\n",uid.iUid,key,&val);
+				}
+			else
+				{
+				__SRVSUBSESS_TRACE2("CServerSubSession::GetStringL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
+				}
+#endif
+			}
+
+		// if error is KErrOverflow should not failing transaction
+		if ((error != KErrNone) && (error != KErrOverflow))
+			{
+			// ServiceError will fail transaction
+			User::Leave(error);
+			}
+		}
+	return error;
+	}
+
+TInt CServerSubSession::SetStringL(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);
+		}
+
+	// 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::SetStringL - Attempt made to write a setting")))
+		return iRepository.FailTransaction(KErrPermissionDenied, key);
+
+	TBuf8<KMaxBinaryLength> val;
+	aMessage.ReadL(1, val);  // no error if too long, truncated instead
+
+	TInt error = iRepository.TransactionSetL(key, val);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::SetStringL UID: 0x%x Key=0x%x Value=%S\n",uid.iUid,key,&val);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::SetStringL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
+		}
+#endif
+
+	return error;
+	}
+
+TInt CServerSubSession::GetMeta(const TClientRequest& aMessage)
+	{
+	TUint32 key = aMessage.Int0();
+
+	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
+				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetMeta - Attempt made to read a setting")))
+		return KErrPermissionDenied;
+
+	TUint32 meta;
+	TInt error = iRepository.GetMeta(key, meta);
+
+	if (error == KErrNone)
+		{
+		TPckg<TUint32> p(meta);
+		error = aMessage.Write(1, p);
+		}
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::GetMeta UID: 0x%x Key=0x%x Meta=0x%x\n",uid.iUid,key,meta);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::GetMeta **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
+		}
+#endif
+
+	return error;
+	}
+
+TInt CServerSubSession::FindL(const TClientRequest& aMessage)
+	{
+	// PLATSEC NOTE:
+	// There are no read policy checks on FindL.
+	// Client is returned the full list of keys whether they have read permission or not.
+	// They were able to find this out by brute force using FindL on single setting ranges
+	// anyway (because it would return KErrPermissionDenied if it existed, KErrNotFound otherwise).
+	// Revealing the existence of settings is not considered a breach of security.
+	TKeyFilter keyIdentifier;
+	TPckg<TKeyFilter> p(keyIdentifier);
+	aMessage.Read(0, p);
+	// we reset results first since we do not police GetResult
+	// and this way we can guarantee no results are available if access not granted
+	iFindResult.Reset();
+	
+	RArray<TUint32> settingsToSend;
+	CleanupClosePushL(settingsToSend);
+
+	TInt error=KErrNone;
+	TRAP(error,iRepository.FindL(keyIdentifier.iPartialId, keyIdentifier.iIdMask,settingsToSend,KCentRepFindBufSize,iFindResult));	
+	if (error==KErrNone)
+		{
+		//write back the total number of settingsFound;
+		TInt numSettings=settingsToSend.Count()+iFindResult.Count();
+		TPtrC8 count(reinterpret_cast<TUint8*>(&numSettings),sizeof(TUint32));
+		error=aMessage.Write(2,count);
+		if (error==KErrNone)
+			{
+			TPtrC8 p(reinterpret_cast<TUint8*>(&(settingsToSend[0])), (settingsToSend.Count())*sizeof(TUint32));
+			error=aMessage.Write(2,p,4);
+			}
+	
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+		if (error == KErrNone)
+			{
+			__SRVSUBSESS_TRACE4("CServerSubSession::FindL UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId,
+					keyIdentifier.iIdMask,&p);
+			}
+		else
+			{
+			__SRVSUBSESS_TRACE4("CServerSubSession::FindL (failed write) UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId,
+					keyIdentifier.iIdMask,&p);			
+			}
+#endif
+		}
+	CleanupStack::PopAndDestroy(); //settingsToSend
+	
+	if (error != KErrNone)
+		{
+		iFindResult.Reset();
+		if ((error != KErrNone) && (error != KErrNotFound))
+			{
+			// ServiceError will fail transaction
+			User::Leave(error);
+			}
+		}
+	return error;
+	}
+
+TInt CServerSubSession::FindEqIntL(const TClientRequest& aMessage)
+	{
+	TInt val = aMessage.Int1();
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val);
+	}
+
+TInt CServerSubSession::FindEqRealL(const TClientRequest& aMessage)
+	{
+	TReal val;
+	TPckg<TReal> p(val);
+	aMessage.Read(1, p);
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val);
+	}
+
+TInt CServerSubSession::FindEqStringL(const TClientRequest& aMessage)
+	{
+	TBuf8<KMaxBinaryLength> val;
+	aMessage.ReadL(1, val);  // no error if too long, truncated instead
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val);
+	}
+
+TInt CServerSubSession::FindNeqIntL(const TClientRequest& aMessage)
+	{
+	TInt val = aMessage.Int1();
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val, ENotEqual);
+	}
+
+TInt CServerSubSession::FindNeqRealL(const TClientRequest& aMessage)
+	{
+	TReal val;
+	TPckg<TReal> p(val);
+	aMessage.Read(1, p);
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val, ENotEqual);
+	}
+
+TInt CServerSubSession::FindNeqStringL(const TClientRequest& aMessage)
+	{
+	TBuf8<KMaxBinaryLength> val;
+	aMessage.ReadL(1, val);  // no error if too long, truncated instead
+	// PlatSec check done in FindValueL
+	return FindValueL(aMessage, val, ENotEqual);
+	}
+
+template <class T>
+TInt CServerSubSession::FindValueL(const TClientRequest& aMessage, const T& aVal,TComparison aComparison)
+	{
+	// IMPORTANT PLATSEC NOTE:
+	// MUST return KErrPermissionDenied if read policy of ANY setting in the search range not passed.
+	// MUST NOT merely check read policy of matching entries, otherwise it is possible to determine
+	// secret values by brute force: Using single-value ranges, cycling through the possible values and
+	// confirming a match when it returns KErrPermissionDenied rather than KErrNotFound.
+	TKeyFilter keyIdentifier;
+	TPckg<TKeyFilter> p(keyIdentifier);
+	aMessage.Read(0, p);
+	// we reset results first since we do not police GetResult
+	// and this way we can guarantee no results are available if access not granted
+	iFindResult.Reset();
+	RSettingPointerArray settings;
+	CleanupClosePushL(settings);
+	TInt error = iRepository.FindSettings(keyIdentifier.iPartialId, keyIdentifier.iIdMask, settings);
+	if (error == KErrNone)
+		{
+		//perform the read checking policies first
+		TUint32 dummyErrId;
+		error=iRepository.CheckPermissions(settings,aMessage,
+		__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::FindValueL - Attempt made to search settings"),ETrue,dummyErrId);
+		if (error==KErrPermissionDenied)
+			iFindResult.Reset();
+
+		//now if everything passes, do perform the FindValue
+		if (error==KErrNone)
+			{
+			TRAP(error,iRepository.FindCompareL(settings,aVal,aComparison,iFindResult));
+			if (error==KErrNone)
+				{
+				const TInt numSettings = iFindResult.Count();
+				const TInt numInitial = numSettings > KCentRepFindBufSize ? KCentRepFindBufSize : numSettings;
+				RArray<TUint32> settingsToSend;
+				CleanupClosePushL(settingsToSend);
+				
+				//reserve memory for everything that needs to be added to the array
+				settingsToSend.Reserve(numInitial);
+				
+				//first append the number of found settings
+				settingsToSend.AppendL(numSettings);
+
+				//now append up to KCentRepFindBufSize settings
+				for(TInt i = 0; i < numInitial; i++)
+					{
+					settingsToSend.AppendL(iFindResult[0]);
+					iFindResult.Remove(0);
+					}
+					
+				if(iFindResult.Count() == 0)
+					{
+					iFindResult.Reset();
+					}
+
+				//send:
+				//1 - the count of total settings found
+				//2 - the settings that fit in the buffer allocated for the first IPC 
+				TPtrC8 p(reinterpret_cast<TUint8*>(&(settingsToSend[0])), (numInitial+1)*sizeof(TUint32));
+				error = aMessage.Write(2, p);
+
+	#ifdef SRVSUBSESS_TRACE
+				TUid uid = RepositoryUid();
+				
+				__SRVSUBSESS_TRACE4("CServerSubSession::FindValueL UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId, 
+						keyIdentifier.iIdMask,&p);
+	#endif
+				CleanupStack::PopAndDestroy(); //settingsToSend		
+				}
+			}
+		}
+	if ((error != KErrNone) && (error != KErrNotFound) && (error != KErrPermissionDenied))
+		{
+		iFindResult.Reset();
+		CleanupStack::PopAndDestroy(); //settings
+
+		// ServiceError will fail transaction
+		User::Leave(error);
+		}
+#ifdef SRVSUBSESS_TRACE
+	else
+		{
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE3("CServerSubSession::FindValueL **Failure** UID: 0x%x Key=0x%x Mask=0x%x\n",uid.iUid,keyIdentifier.iPartialId,
+				keyIdentifier.iIdMask);
+		}
+#endif
+
+	CleanupStack::PopAndDestroy(); //settings
+	return error;
+	}
+
+TInt CServerSubSession::GetFindResultL(const TClientRequest& aMessage)
+	{
+	TInt n = iFindResult.Count();	
+	if (n==0)
+		{
+		return KErrNotFound;
+		}
+
+  	TPtrC8 p(reinterpret_cast<TUint8*>(&(iFindResult[0])), n*sizeof(TUint32));
+  	TInt error = aMessage.Write(0, p);
+  	// Free up iFindResult - it's no longer needed
+  	iFindResult.Reset();
+	// ServiceError will fail transaction
+
+#ifdef SRVSUBSESS_TRACE
+  	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::GetFindResultL UID: 0x%x Value=%S\n",uid.iUid,&p);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::GetFindResultL **Failure** UID: 0x%x\n",uid.iUid);
+		}
+#endif
+	return User::LeaveIfError(error);
+	}
+
+TInt CServerSubSession::NotifyRequestCheck(const TClientRequest& aMessage)
+	{
+	TUint32 key = aMessage.Int0();
+	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
+				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::NotifyRequestCheck - Attempt made to check Notify request")))
+		return KErrPermissionDenied;
+
+	TInt error = iRepository.GetPersistentSetting(key) ? KErrNone : KErrNotFound;
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::NotifyRequestCheck UID: 0x%x Key=0x%x\n",uid.iUid,key);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::NotifyRequestCheck **Failure** UID: 0x%x\n",uid.iUid);
+		}
+#endif
+	return error;
+	}
+
+TInt CServerSubSession::NotifyRequest(const TClientRequest& aMessage)
+	{
+	TUint32 key = aMessage.Int0();
+	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
+				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::NotifyRequest - Attempt made to register for Notify")))
+		return KErrPermissionDenied;
+	TInt error = iNotifier.AddRequest(key, aMessage);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::NotifyRequest UID: 0x%x Key=0x%x\n",uid.iUid,key);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::NotifyRequest **Failure** UID: 0x%x\n",uid.iUid);
+		}
+#endif
+
+	return (error == KErrNone) ? KDontCompleteMessage : error;
+	}
+
+TInt CServerSubSession::NotifyCancel(const TClientRequest& aMessage)
+	{
+	TUint32 key = aMessage.Int0();
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	__SRVSUBSESS_TRACE2("CServerSubSession::NotifyCancel UID: 0x%x Key=0x%x\n",uid.iUid,key);
+#endif
+
+	return iNotifier.CancelRequest(key);
+	}
+
+TInt CServerSubSession::NotifyCancelAll(const TClientRequest& /*aMessage*/)
+	{
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	__SRVSUBSESS_TRACE1("CServerSubSession::NotifyCancelAll UID: 0x%x\n",uid.iUid);
+#endif
+	return iNotifier.CancelAllRequests();
+	}
+
+TInt CServerSubSession::GroupNotifyRequest(const TClientRequest& aMessage)
+	{
+	TUint32 partialId = aMessage.Int0();
+	TUint32 idMask = aMessage.Int1();
+	RSettingPointerArray settings;
+	TInt error = iRepository.FindPersistentSettings(partialId, idMask, settings);
+	if (error == KErrNone)
+		{
+		TUint32 dummyErrId;
+		error = iRepository.CheckPermissions(settings, aMessage,
+			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GroupNotifyRequest - Attempt made to register for group Notify"),ETrue,dummyErrId);
+		}
+	settings.Reset();
+	if (error != KErrNone)
+		{
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest **Failure** UID: 0x%x\n PartialId=0x%x Mask=0x%x\n",
+				uid.iUid,partialId,idMask);
+#endif
+
+		return KErrPermissionDenied;
+		}
+
+	error = iNotifier.AddRequest(partialId, idMask, aMessage);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest UID: 0x%x PartialId=0x%x Mask=0x%x\n",
+				uid.iUid,partialId,idMask);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest **Failure** UID: 0x%x PartialId=0x%x Mask=0x%x\n",uid.iUid,
+				partialId,idMask);
+		}
+#endif
+
+	return error==KErrNone ? KDontCompleteMessage : error;
+	}
+
+TInt CServerSubSession::GroupNotifyCancel(const TClientRequest& aMessage)
+	{
+	TKeyFilter keyIdentifier;
+	TPckg<TKeyFilter> p(keyIdentifier);
+	aMessage.Read(0, p);
+
+	RSettingPointerArray settings;
+	TInt error = iRepository.FindPersistentSettings(keyIdentifier.iPartialId, keyIdentifier.iIdMask, settings);
+	settings.Reset();
+	if (error != KErrNone)
+		{
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel **Failure** UID: 0x%x\n PartialId=0x%x Mask=0x%x\n",
+				uid.iUid,keyIdentifier.iPartialId, keyIdentifier.iIdMask);
+#endif
+		return error;
+		}
+
+	error = iNotifier.CancelRequest(keyIdentifier.iPartialId, keyIdentifier.iIdMask);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel UID: 0x%x PartialId=0x%x Mask=0x%x\n",
+				uid.iUid,keyIdentifier.iPartialId, keyIdentifier.iIdMask);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel **Failure** UID: 0x%x PartialId=0x%x Mask=0x%x\n",uid.iUid,
+				keyIdentifier.iPartialId, keyIdentifier.iIdMask);
+		}
+#endif
+
+
+	return error;
+	}
+
+TInt CServerSubSession::ResetL(const TClientRequest& aMessage)
+	{
+	// individual setting reset is not yet supported in transactions
+	ASSERT(!iRepository.IsInTransaction());
+	TUint32 key = aMessage.Int0();
+	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
+				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::ResetL - Attempt made to reset a setting")))
+		return iRepository.FailTransaction(KErrPermissionDenied, key);
+
+	TInt error = iRepository.ResetL(key);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::ResetL UID: 0x%x Key=0x%x\n",
+				uid.iUid,key);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::ResetL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
+		}
+#endif
+
+	return error;
+	}
+
+TInt CServerSubSession::ResetAllL(const TClientRequest& aMessage)
+	{
+	// factory reset operation is not yet supported in transactions
+	ASSERT(!iRepository.IsInTransaction());
+	if(KErrNone != CheckPolicy(aMessage,iRepository.GetDefaultWriteAccessPolicy(),
+				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::ResetAllL - Attempt made to reset repository")))
+		return KErrPermissionDenied;
+
+	iNotifier.IdReportingOff();
+	TInt error = iRepository.ResetAllL();
+	iNotifier.IdReportingOn();
+
+	if (error == KErrNone)
+		{
+		iRepository.CommitChangesL();  // temporary measure
+		}
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::ResetAllL UID: 0x%x\n",uid.iUid);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::ResetAllL **Failure** UID: 0x%x\n",uid.iUid);
+		}
+#endif
+
+	return error;
+	}
+
+TInt CServerSubSession::MoveL(const TClientRequest& aMessage)
+	{
+	if (iRepository.IsInActiveReadTransaction())
+		{
+		TKeyFilter keyIdentifier;
+		TPckg<TKeyFilter> p(keyIdentifier);
+		aMessage.Read(0, p);
+
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE3("CServerSubSession::MoveL **Failure** In Transaction UID: 0x%x PartialId=0x%x Mask=0x%x\n",
+				uid.iUid,keyIdentifier.iPartialId,keyIdentifier.iIdMask);
+#endif
+
+		// could not promote to read/write: fail & give the source partialKey as the error key
+		return iRepository.FailTransaction(KErrLocked, keyIdentifier.iPartialId);
+		}
+	
+	TUint32 errorKey = KUnspecifiedKey;
+	TInt result = iRepository.TransactionMoveL(aMessage, errorKey);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (result == KErrNone)
+		{
+		__SRVSUBSESS_TRACE1("CServerSubSession::MoveL UID: 0x%x\n",uid.iUid);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::MoveL **Failure** UID: 0x%x Error=%d\n",uid.iUid,errorKey);
+		}
+#endif
+
+	if (result != KErrNone && result!=KErrNotFound)
+		{
+		iRepository.FailTransaction(result, errorKey);
+		TPckg<TUint32> p(errorKey);
+		aMessage.WriteL(2, p);
+		}
+	return result;
+	}
+
+TInt CServerSubSession::TransactionStart(const TClientRequest& aMessage)
+	{
+	// check if we are already in a transaction
+	TBool inTransactionAlready = iRepository.IsInTransaction();
+
+	// panic client if attempting to start a transaction when already in one
+	__ASSERT_ALWAYS(!inTransactionAlready, PanicClient(EStartAlreadyInTransaction, aMessage));
+
+	// if the client has been panicked then we don't want to continue.
+	// client session will already have been taken down so don't want to complete the message
+	if (inTransactionAlready)
+		{
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE1("CServerSubSession::TransactionStart **Failure** already in transaction UID=0x%x\n",uid.iUid);
+#endif
+
+		return KDontCompleteMessage;
+		}
+
+	const TInt mode = aMessage.Int0();
+
+	TInt error = iRepository.StartTransaction(mode);
+
+#ifdef SRVSUBSESS_TRACE
+
+	TUid uid = RepositoryUid();
+
+	// mode strings match transstate.h - if that is updated, this should be as well.
+	const TPtrC modeStrings[] =
+		{
+			_L("ENoTransaction"),                              // 0
+			_L("EReadTransaction"),                            // EReadBit     1
+			_L("EConcurrentReadWriteTransaction"),             // EWriteBit    2
+			_L("EReadWriteTransaction|EAllTransactionBits"),   //EReadBit | EWriteBit 3
+			_L("EFailedBit")                                   // 4
+		};
+
+	if (error == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::TransactionStart UID: 0x%x Mode=%d (%S)\n",uid.iUid,mode,&modeStrings[mode]);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::TransactionStart **Failure** UID: 0x%x Mode=%d (%S)\n",uid.iUid,mode,&modeStrings[mode]);
+		}
+#endif
+
+	return error;
+	}
+
+// serves as both rollback and async cancel
+TInt CServerSubSession::TransactionCancel(const TClientRequest& /*aMessage*/)
+	{
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	__SRVSUBSESS_TRACE1("CServerSubSession::TransactionCancel UID: 0x%x",uid.iUid);
+#endif
+	iRepository.CancelTransaction();
+	return KErrNone;
+	}
+
+TInt CServerSubSession::TransactionCommitL(const TClientRequest& aMessage)
+	{
+	// check if we are in a transaction
+	TBool inTransaction = iRepository.IsInTransaction();
+
+	// panic client if attempting to commit a transaction when we are not in one
+	__ASSERT_ALWAYS(inTransaction, PanicClient(ECommitNotInTransaction, aMessage));
+
+	// if the client has been panicked then we don't want to continue.
+	// client session will already have been taken down so don't want to complete the message
+	if (!inTransaction)
+		{
+#ifdef SRVSUBSESS_TRACE
+		TUid uid = RepositoryUid();
+
+		__SRVSUBSESS_TRACE1("CServerSubSession::TransactionCommitL **Failure** In Transaction UID: 0x%x TransactionKey=%d\n",uid.iUid);
+#endif
+		return KDontCompleteMessage;
+		}
+
+	TUint32 keyInfo = KUnspecifiedKey;
+	TInt result = iRepository.CommitTransaction(keyInfo);
+
+	TPckg<TUint32> p(keyInfo);
+	aMessage.WriteL(0, p);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	if (result == KErrNone)
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::TransactionCommitL UID: 0x%x TransactionKey=%d\n",uid.iUid,keyInfo);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::TransactionCommitL **Failure** UID: 0x%x TransactionKey=%d\n",uid.iUid,keyInfo);
+		}
+#endif
+	return result;
+	}
+
+TInt CServerSubSession::DeleteRangeL(const TClientRequest& aMessage)
+	{
+	if (iRepository.IsInActiveReadTransaction())
+		{
+		// could not promote to read/write: fail & give the partialKey as the error key
+		TUint32 partialKey = aMessage.Int0();
+		return iRepository.FailTransaction(KErrLocked, partialKey);
+		}
+	TUint32 errorKey = KUnspecifiedKey;
+	TInt result = iRepository.TransactionDeleteRangeL(aMessage, errorKey);
+	if (result != KErrNone)
+		{
+		TPckg<TUint32> p(errorKey);
+		aMessage.WriteL(2, p);
+		}
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+	TUint32 partialKey = aMessage.Int0();
+	TUint32 keyMask    = aMessage.Int1();
+
+	if (result == KErrNone)
+		{
+		__SRVSUBSESS_TRACE3("CServerSubSession::DeleteRangeL UID: 0x%x Key=0x%x Mask=0x%x\n",uid.iUid,partialKey,keyMask);
+		}
+	else
+		{
+		__SRVSUBSESS_TRACE2("CServerSubSession::DeleteRangeL **Failure** UID: 0x%x ErrorKey=%d\n",uid.iUid,errorKey);
+		}
+#endif
+
+	return result;
+	}
+
+TInt CServerSubSession::TransactionStateL(const TClientRequest& aMessage)
+	{
+	TInt iState = iRepository.TransactionState();
+
+	TPckg<TInt> p(iState);
+	aMessage.WriteL(0, p);
+
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	__SRVSUBSESS_TRACE2("CServerSubSession::TransactionStateL UID: 0x%x State=%d\n",uid.iUid,iState);
+#endif
+
+	return KErrNone;
+	}
+
+TInt CServerSubSession::TransactionFail(const TClientRequest& aMessage)
+	{
+#ifdef SRVSUBSESS_TRACE
+	TUid uid = RepositoryUid();
+
+	__SRVSUBSESS_TRACE1("CServerSubSession::TransactionFail UID: 0x%x",uid.iUid);
+#endif
+
+	iRepository.FailTransaction(aMessage.Int0(), KUnspecifiedKey);
+	return KErrNone;
+	}
+
+//Check the security policy against a RMessage.
+TInt CServerSubSession::CheckPolicy(const TClientRequest& msg,
+								 const TSecurityPolicy& aPolicy,
+								 const char *aDiagnostic)
+	{
+	return msg.CheckPolicy(aPolicy,aDiagnostic) ? KErrNone : KErrPermissionDenied;
+	}