sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "srvreqs.h"
sl@0: #include "backup.h"
sl@0: #include "srvsubsess.h"
sl@0: #include "log.h"
sl@0: #include "centralrepositoryinternal.h"
sl@0: #include <e32def_private.h>
sl@0: 
sl@0: using namespace NCentralRepositoryConstants;
sl@0: 
sl@0: CServerSubSession::CServerSubSession(CServerSession* aSession)
sl@0:  : iSession(aSession), iInitialised(EFalse)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CServerSubSession::~CServerSubSession()
sl@0: 	{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE1("~CServerSubSession() UID: 0x%x\n",uid.iUid);
sl@0: #endif
sl@0: 
sl@0: 	iRepository.Close();
sl@0: 	iFindResult.Close();
sl@0: 	iInitialised = EFalse;
sl@0: 	}
sl@0: 
sl@0: // if session ServiceL Leaves, execution resumes in this method.
sl@0: // this allows us to panic clients using bad descriptors, to deal with OOM conditions
sl@0: // and to fail transactions with the correct reason: OOM etc.
sl@0: void CServerSubSession::ServiceError(TInt aError)
sl@0: 	{
sl@0: 	// ensure any transaction is failed for the reason aError
sl@0: 	iRepository.FailTransaction(aError, KUnspecifiedKey);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::ServiceL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	const TClientRequest msg(aMessage);
sl@0: 
sl@0: 	struct SAction
sl@0: 		{
sl@0: 		TServerRequest req;
sl@0: 		TInt (CServerSubSession::*groupFuncL)(const TClientRequest&, TServerFunc);
sl@0: 		TServerFunc funcL;
sl@0: 		};
sl@0: 
sl@0: 	static const SAction actionTable[] =
sl@0: 		{
sl@0: 			{EInitialise,				&CServerSubSession::GeneralOperationsL,	&CServerSubSession::InitialiseL},
sl@0: 			{ECreateInt,				&CServerSubSession::WriteOperationsL,	&CServerSubSession::CreateIntL},
sl@0: 			{ECreateReal,				&CServerSubSession::WriteOperationsL,	&CServerSubSession::CreateRealL},
sl@0: 			{ECreateString,				&CServerSubSession::WriteOperationsL,	&CServerSubSession::CreateStringL},
sl@0: 			{EDelete,					&CServerSubSession::WriteOperationsL,	&CServerSubSession::DeleteL},
sl@0: 			{EGetInt,					&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetIntL},
sl@0: 			{ESetInt,					&CServerSubSession::WriteOperationsL,	&CServerSubSession::SetIntL},
sl@0: 			{EGetReal,					&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetRealL},
sl@0: 			{ESetReal,					&CServerSubSession::WriteOperationsL,	&CServerSubSession::SetRealL},
sl@0: 			{EGetString,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetStringL},
sl@0: 			{ESetString,				&CServerSubSession::WriteOperationsL,	&CServerSubSession::SetStringL},
sl@0: 			{EFind,						&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindL},
sl@0: 			{EFindEqInt,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindEqIntL},
sl@0: 			{EFindEqReal,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindEqRealL},
sl@0: 			{EFindEqString,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindEqStringL},
sl@0: 			{EFindNeqInt,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindNeqIntL},
sl@0: 			{EFindNeqReal,				&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindNeqRealL},
sl@0: 			{EFindNeqString,			&CServerSubSession::ReadOperationsL,	&CServerSubSession::FindNeqStringL},
sl@0: 			{EGetFindResult,			&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetFindResultL},
sl@0: 			{ENotifyRequestCheck,		&CServerSubSession::GeneralOperationsL,	&CServerSubSession::NotifyRequestCheck},
sl@0: 			{ENotifyRequest,			&CServerSubSession::GeneralOperationsL,	&CServerSubSession::NotifyRequest},
sl@0: 			{ENotifyCancel,				&CServerSubSession::GeneralOperationsL,	&CServerSubSession::NotifyCancel},
sl@0: 			{ENotifyCancelAll,			&CServerSubSession::GeneralOperationsL,	&CServerSubSession::NotifyCancelAll},
sl@0: 			{EGroupNotifyRequest,		&CServerSubSession::GeneralOperationsL,	&CServerSubSession::GroupNotifyRequest},
sl@0: 			{EGroupNotifyCancel,		&CServerSubSession::GeneralOperationsL,	&CServerSubSession::GroupNotifyCancel},
sl@0: 			{EReset,					&CServerSubSession::ResetOperationsL,	&CServerSubSession::ResetL},
sl@0: 			{EResetAll,					&CServerSubSession::ResetOperationsL,	&CServerSubSession::ResetAllL},
sl@0: 			{ETransactionStart,			&CServerSubSession::GeneralOperationsL,	&CServerSubSession::TransactionStart},
sl@0:   			{ETransactionCommit,		&CServerSubSession::GeneralOperationsL,	&CServerSubSession::TransactionCommitL},
sl@0:   			{ETransactionCancel,		&CServerSubSession::GeneralOperationsL,	&CServerSubSession::TransactionCancel},
sl@0: 			{EMove,						&CServerSubSession::WriteOperationsL,	&CServerSubSession::MoveL},
sl@0: 			{ETransactionState,			&CServerSubSession::GeneralOperationsL,	&CServerSubSession::TransactionStateL},
sl@0: 			{ETransactionFail,			&CServerSubSession::GeneralOperationsL,	&CServerSubSession::TransactionFail},
sl@0: 			{EDeleteRange,				&CServerSubSession::WriteOperationsL,	&CServerSubSession::DeleteRangeL},
sl@0: 			{EGetMeta,					&CServerSubSession::ReadOperationsL,	&CServerSubSession::GetMeta}
sl@0: 		};
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	const TPtrC actionTableNames[] =
sl@0: 		{
sl@0: 			_L("EInitialize"),
sl@0: 			_L("ECreateInt"),
sl@0: 			_L("ECreateReal"),
sl@0: 			_L("ECreateString"),
sl@0: 			_L("EDelete"),
sl@0: 			_L("EGetInt"),
sl@0: 			_L("ESetInt"),
sl@0: 			_L("EGetReal"),
sl@0: 			_L("ESetReal"),
sl@0: 			_L("EGetString"),
sl@0: 			_L("ESetString"),
sl@0: 			_L("EFind"),
sl@0: 			_L("EFindEqInt"),
sl@0: 			_L("EFindEqReal"),
sl@0: 			_L("EFindEqString"),
sl@0: 			_L("EFindNeqInt"),
sl@0: 			_L("EFindNeqReal"),
sl@0: 			_L("EFindNeqString"),
sl@0: 			_L("EGetFindResult"),
sl@0: 			_L("ENotifyRequestCheck"),
sl@0: 			_L("ENotifyRequest"),
sl@0: 			_L("ENotifyCancel"),
sl@0: 			_L("ENotifyCancelAll"),
sl@0: 			_L("EGroupNotifyRequest"),
sl@0: 			_L("EGroupNotifyCancel"),
sl@0: 			_L("EReset"),
sl@0: 			_L("EResetAll"),
sl@0: 			_L("ETransactionStart"),
sl@0: 	  		_L("ETransactionCommit"),
sl@0: 	  		_L("ETransactionCancel"),
sl@0: 			_L("EMove"),
sl@0: 			_L("ETransactionState"),
sl@0: 			_L("ETransactionFail"),
sl@0: 			_L("EDeleteRange"),
sl@0: 			_L("EGetMeta")
sl@0: 		};
sl@0: #endif
sl@0: 
sl@0: 	TInt r;
sl@0: 	TServerRequest fn = static_cast<TServerRequest>(aMessage.Function());
sl@0: 
sl@0: 	__ASSERT_ALWAYS(iInitialised || fn==EInitialise, PanicClient(ESessionNotInitialised, msg));
sl@0: 	// In this assert we use (ELastInTable - 1) rather than ELastInTable because EClose is handled in the session
sl@0: 	// rather than the subsession, consiquently the actionTable array is one element shorter than ELastInTable
sl@0: 	__ASSERT_ALWAYS((fn < (ELastInTable)) && (fn >= EInitialise), PanicClient(EBadMessageNumber, msg));
sl@0: 
sl@0: 	if (EInitialise != fn)
sl@0: 		{
sl@0: 		iRepository.AccessRepositoryL();
sl@0: 		}
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 
sl@0: 	if (EInitialise != fn)
sl@0: 		{
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::ServiceL - UID: 0x%x %S\n",uid.iUid,&actionTableNames[fn]);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::ServiceL - UID: 0x?? %S\n",&actionTableNames[fn]);
sl@0: 		}
sl@0: 
sl@0: #endif
sl@0: 	// plus need to check we are initialised
sl@0: 	// this comment removes a false positive from the coverity output.  if fn >= ELastInTable then this code
sl@0: 	// will assert (see above).  but coverity doesn't consider this and therefore complains that there is a
sl@0: 	// posibility that actionTable could be indexed beyond it's length
sl@0: 	//coverity[overrun-local]
sl@0: 	r = (this->*actionTable[fn].groupFuncL)(aMessage, actionTable[fn].funcL);
sl@0: 
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: //method allows transactions and notify requests to get through during backup/restore
sl@0: //process to prevent them from being blocked.
sl@0: //Transactions being blocked would lead clients to be panicked
sl@0: //if they were trying to open a second transaction in the same session.
sl@0: // Notify cancels must be allowed through because they must always succeed.
sl@0: TInt CServerSubSession::GeneralOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)
sl@0: 	{
sl@0: 	ASSERT(aFuncL != NULL);
sl@0: 	return (this->*aFuncL)(aMessage);
sl@0: 	}
sl@0: 
sl@0: // method allows read operations to share transaction-related tasks.
sl@0: // Read operations are allowed only during backup process.
sl@0: // During restore it fails transactions with KErrLocked and returns KErrAbort
sl@0: // and if it is a standalone read oparation it rejects it with KErrServerBusy.
sl@0: TInt CServerSubSession::ReadOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)
sl@0: 	{
sl@0: 	TInt backupStatus = CRepositoryBackupClient::GetBackupStatus();
sl@0: 
sl@0: 	if (iRepository.IsInFailedTransaction())
sl@0: 		{
sl@0: 		return KErrAbort;
sl@0: 		}
sl@0: 	else if (iRepository.IsInTransaction() && (backupStatus == ERestoreInProgress) )
sl@0: 	    {
sl@0: 	    iRepository.FailTransaction(KErrLocked,KUnspecifiedKey);
sl@0: 	    return KErrAbort;
sl@0: 	    }
sl@0: 	else if (backupStatus == ERestoreInProgress)
sl@0: 	    {
sl@0: 	    return KErrServerBusy;
sl@0: 	    }
sl@0: 
sl@0: 	ASSERT(aFuncL != NULL);
sl@0: 	return (this->*aFuncL)(aMessage);
sl@0: 	}
sl@0: 
sl@0: // method allows write operations to share transaction-related tasks
sl@0: // All write operations are not allowed either during backup or restore process.
sl@0: // If backup or restore is in progress it fails transaction with KErrLocked,
sl@0: // returns KErrAbort or if it is a standalone operation it returns KErrServerBusy.
sl@0: TInt CServerSubSession::WriteOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)
sl@0: 	{
sl@0: 	TInt backupStatus = CRepositoryBackupClient::GetBackupStatus();
sl@0: 
sl@0: 	if (iRepository.IsInFailedTransaction())
sl@0: 		{
sl@0: 		return KErrAbort;
sl@0: 		}
sl@0: 	else if (iRepository.IsInTransaction() && (backupStatus != ENoBackupActivty) )
sl@0: 	    {
sl@0: 	    iRepository.FailTransaction(KErrLocked,KUnspecifiedKey);
sl@0: 	    return KErrAbort;
sl@0: 	    }
sl@0:     else if (backupStatus != ENoBackupActivty)
sl@0:         {
sl@0:         return KErrServerBusy;
sl@0:         }
sl@0: 
sl@0: 	// if not already in a transaction, create a temporary concurrent read/write transaction
sl@0: 	const TBool tempTransaction = !iRepository.IsInTransaction();
sl@0: 	if (tempTransaction)
sl@0: 		{
sl@0: 		// concurrent read/write transaction is guaranteed to start
sl@0: 		iRepository.StartTransaction(EConcurrentReadWriteTransaction);
sl@0: 		// to protect against Leaves:
sl@0: 		iRepository.CleanupCancelTransactionPushL();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (iRepository.IsInActiveReadTransaction())
sl@0: 			{
sl@0: 			// must be a read/write transaction to continue
sl@0: 			iRepository.AttemptPromoteTransactionToReadWrite();
sl@0: 			// Note we don't check the return value of the above and return it here.
sl@0: 			// Instead we call the next level write function and expect it to have the
sl@0: 			// following code:
sl@0: 			//	if (iRepository.IsInActiveReadTransaction())
sl@0: 			//		{
sl@0: 			//		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 			//		}
sl@0: 			// this ensures CommitTransaction reports the failing key.
sl@0: 			}
sl@0: 		// Note ServiceError will fail the transaction if write operation leaves
sl@0: 		}
sl@0: 
sl@0: 	// call the server function
sl@0: 	ASSERT(aFuncL != NULL);
sl@0: 	TInt result = (this->*aFuncL)(aMessage);
sl@0: 
sl@0: 	// commit the temporary transaction
sl@0: 	if (tempTransaction)
sl@0: 		{
sl@0: 		CleanupStack::Pop(); // remove cleanup item from earlier
sl@0: 		// absorb result and keyInfo from commit of temporary transaction
sl@0: 		TUint32 tempKeyInfo;
sl@0: 		User::LeaveIfError(iRepository.CommitTransaction(tempKeyInfo));
sl@0: 		}
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::ResetOperationsL(const TClientRequest& aMessage, TServerFunc aFuncL)
sl@0: 	{
sl@0: 	// reset operations are not currently supported in transactions
sl@0: 	if (iRepository.IsInTransaction())
sl@0: 		{
sl@0: 		// fail transaction otherwise client may be misled to believe operation worked
sl@0: 		return iRepository.FailTransaction(KErrNotSupported, KUnspecifiedKey);
sl@0: 		}
sl@0:    //can't reset when backup or restore is in progress
sl@0:    else if (CRepositoryBackupClient::GetBackupStatus() != ENoBackupActivty)
sl@0:         {
sl@0:         return KErrServerBusy;
sl@0:         }
sl@0: 	ASSERT(aFuncL != NULL);
sl@0: 	return (this->*aFuncL)(aMessage);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::InitialiseL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	__ASSERT_ALWAYS(!iInitialised,
sl@0: 		PanicClient(ESessionAlreadyInitialised, aMessage));
sl@0: 	// We let anyone to open a repository...
sl@0: 	// it's not considered a breach of security to let people know
sl@0: 	// that a repository is there...
sl@0: 	TUid uid = TUid::Uid(aMessage.Int0());
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE1("CServerSubSession::InitialiseL UID: 0x%x\n",uid.iUid);
sl@0: 
sl@0: 	// Calls iObserver->AccessL internally
sl@0: 	iRepository.OpenL(uid, iNotifier);
sl@0: 
sl@0: 	iInitialised = ETrue;
sl@0: 
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::CreateIntL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone !=  CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSubSession::CreateIntL - Attempt made to create a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TInt val = aMessage.Int1();
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::CreateIntL UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: #endif
sl@0: 
sl@0: 	TInt r = iRepository.TransactionCreateL(key, val, NULL);
sl@0: 
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::CreateRealL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::CreateRealL - Attempt made to create a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TReal val;
sl@0: 	TPckg<TReal> p(val);
sl@0: 	aMessage.ReadL(1, p);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::CreateRealL UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: #endif
sl@0: 	TInt r = iRepository.TransactionCreateL(key, val, NULL);
sl@0: 
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::CreateStringL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	// sometime: must ensure bad descriptor results in client being panic'd
sl@0: 
sl@0: 	// check for descriptor-too-long was previously on the client side,
sl@0: 	// hence test code expects KErrArgument response before KErrPermissionDenied
sl@0: 	TInt length = aMessage.GetDesLengthL(1);
sl@0: 	if (length > KMaxBinaryLength)
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrArgument, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::CreateStringL - Attempt made to create a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TBuf8<KMaxBinaryLength> val;
sl@0: 	aMessage.ReadL(1, val);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::CreateStringL UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: #endif
sl@0: 
sl@0: 	TInt error = iRepository.TransactionCreateL(key, val, NULL);
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::DeleteL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::DeleteL - Attempt made to delete a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::DeleteL UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: #endif
sl@0: 
sl@0: 	TInt r = iRepository.TransactionDeleteL(key);
sl@0: 
sl@0: 	return r;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GetIntL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetIntL - Attempt made to read a setting")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	TInt val;
sl@0: 	TInt error = iRepository.Get(key, val);
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		TPckg<TInt> p(val);
sl@0: 		aMessage.WriteL(1, p);
sl@0: 		}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GetIntL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::GetIntL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::SetIntL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::SetIntL - Attempt made to write a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TInt val = aMessage.Int1();
sl@0: 	TInt error = iRepository.TransactionSetL(key, val);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::SetIntL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::SetIntL **Failure** UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: #endif
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GetRealL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetRealL - Attempt made to read a setting")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	TReal val;
sl@0: 	TInt error = iRepository.Get(key, val);
sl@0: 
sl@0: 	if(error==KErrNone)
sl@0: 		{
sl@0: 		TPckg<TReal> p(val);
sl@0: 		aMessage.WriteL(1, p);
sl@0: 		}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GetRealL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::GetRealL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: #endif
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::SetRealL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::SetRealL - Attempt made to write a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TReal val;
sl@0: 	TPckg<TReal> p(val);
sl@0: 	aMessage.ReadL(1, p);
sl@0: 
sl@0: 	TInt error = iRepository.TransactionSetL(key, val);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::SetRealL UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::SetRealL **Failure** UID: 0x%x Key=0x%x Value=%d\n",uid.iUid,key,val);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GetStringL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetStringL - Attempt made to read a setting")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	TBuf8<KMaxBinaryLength> val;
sl@0: 
sl@0: 	TInt error = iRepository.Get(key, val);
sl@0: 
sl@0: 	if(error==KErrNone)
sl@0: 		{
sl@0: 		TInt clientMaxDescriptorLength;
sl@0: 		TPckg<TInt> pInt (clientMaxDescriptorLength);
sl@0: 		aMessage.Read(2, pInt);
sl@0: 
sl@0: 		TInt descriptorLength = val.Length();
sl@0: 
sl@0: 		// write the descriptor length to aMessage
sl@0: 		TPckg<TInt> p(descriptorLength);
sl@0: 		error = aMessage.Write(2, p);
sl@0: 
sl@0: 		if(error==KErrNone)
sl@0: 			{
sl@0: 			if(descriptorLength > clientMaxDescriptorLength)
sl@0: 				{
sl@0: 				// if it is, fill the descriptor up to its max length
sl@0: 				error = aMessage.Write(1, val.Left(clientMaxDescriptorLength));
sl@0: 
sl@0: 				// if client-side descriptor is too small to take the value, which it is, returns KErrOverflow
sl@0: 				if(error == KErrNone)
sl@0: 					{
sl@0: 					error = KErrOverflow;
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				error = aMessage.Write(1, val);
sl@0: 				}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 			TUid uid = RepositoryUid();
sl@0: 
sl@0: 			if (error == KErrNone)
sl@0: 				{
sl@0: 				__SRVSUBSESS_TRACE3("CServerSubSession::GetStringL UID: 0x%x Key=0x%x Value=%S\n",uid.iUid,key,&val);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				__SRVSUBSESS_TRACE2("CServerSubSession::GetStringL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 				}
sl@0: #endif
sl@0: 			}
sl@0: 
sl@0: 		// if error is KErrOverflow should not failing transaction
sl@0: 		if ((error != KErrNone) && (error != KErrOverflow))
sl@0: 			{
sl@0: 			// ServiceError will fail transaction
sl@0: 			User::Leave(error);
sl@0: 			}
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::SetStringL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	// cannot make changes in a read transaction - upgrade must have failed due to write lock being used
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrLocked, key);
sl@0: 		}
sl@0: 
sl@0: 	// check for descriptor-too-long was previously on the client side,
sl@0: 	// hence test code expects KErrArgument response before KErrPermissionDenied
sl@0: 	TInt length = aMessage.GetDesLengthL(1);
sl@0: 	if (length > KMaxBinaryLength)
sl@0: 		{
sl@0: 		return iRepository.FailTransaction(KErrArgument, key);
sl@0: 		}
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::SetStringL - Attempt made to write a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TBuf8<KMaxBinaryLength> val;
sl@0: 	aMessage.ReadL(1, val);  // no error if too long, truncated instead
sl@0: 
sl@0: 	TInt error = iRepository.TransactionSetL(key, val);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::SetStringL UID: 0x%x Key=0x%x Value=%S\n",uid.iUid,key,&val);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::SetStringL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GetMeta(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GetMeta - Attempt made to read a setting")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	TUint32 meta;
sl@0: 	TInt error = iRepository.GetMeta(key, meta);
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		TPckg<TUint32> p(meta);
sl@0: 		error = aMessage.Write(1, p);
sl@0: 		}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GetMeta UID: 0x%x Key=0x%x Meta=0x%x\n",uid.iUid,key,meta);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::GetMeta **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	// PLATSEC NOTE:
sl@0: 	// There are no read policy checks on FindL.
sl@0: 	// Client is returned the full list of keys whether they have read permission or not.
sl@0: 	// They were able to find this out by brute force using FindL on single setting ranges
sl@0: 	// anyway (because it would return KErrPermissionDenied if it existed, KErrNotFound otherwise).
sl@0: 	// Revealing the existence of settings is not considered a breach of security.
sl@0: 	TKeyFilter keyIdentifier;
sl@0: 	TPckg<TKeyFilter> p(keyIdentifier);
sl@0: 	aMessage.Read(0, p);
sl@0: 	// we reset results first since we do not police GetResult
sl@0: 	// and this way we can guarantee no results are available if access not granted
sl@0: 	iFindResult.Reset();
sl@0: 	
sl@0: 	RArray<TUint32> settingsToSend;
sl@0: 	CleanupClosePushL(settingsToSend);
sl@0: 
sl@0: 	TInt error=KErrNone;
sl@0: 	TRAP(error,iRepository.FindL(keyIdentifier.iPartialId, keyIdentifier.iIdMask,settingsToSend,KCentRepFindBufSize,iFindResult));	
sl@0: 	if (error==KErrNone)
sl@0: 		{
sl@0: 		//write back the total number of settingsFound;
sl@0: 		TInt numSettings=settingsToSend.Count()+iFindResult.Count();
sl@0: 		TPtrC8 count(reinterpret_cast<TUint8*>(&numSettings),sizeof(TUint32));
sl@0: 		error=aMessage.Write(2,count);
sl@0: 		if (error==KErrNone)
sl@0: 			{
sl@0: 			TPtrC8 p(reinterpret_cast<TUint8*>(&(settingsToSend[0])), (settingsToSend.Count())*sizeof(TUint32));
sl@0: 			error=aMessage.Write(2,p,4);
sl@0: 			}
sl@0: 	
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 		if (error == KErrNone)
sl@0: 			{
sl@0: 			__SRVSUBSESS_TRACE4("CServerSubSession::FindL UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId,
sl@0: 					keyIdentifier.iIdMask,&p);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			__SRVSUBSESS_TRACE4("CServerSubSession::FindL (failed write) UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId,
sl@0: 					keyIdentifier.iIdMask,&p);			
sl@0: 			}
sl@0: #endif
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(); //settingsToSend
sl@0: 	
sl@0: 	if (error != KErrNone)
sl@0: 		{
sl@0: 		iFindResult.Reset();
sl@0: 		if ((error != KErrNone) && (error != KErrNotFound))
sl@0: 			{
sl@0: 			// ServiceError will fail transaction
sl@0: 			User::Leave(error);
sl@0: 			}
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindEqIntL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TInt val = aMessage.Int1();
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindEqRealL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TReal val;
sl@0: 	TPckg<TReal> p(val);
sl@0: 	aMessage.Read(1, p);
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindEqStringL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TBuf8<KMaxBinaryLength> val;
sl@0: 	aMessage.ReadL(1, val);  // no error if too long, truncated instead
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindNeqIntL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TInt val = aMessage.Int1();
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val, ENotEqual);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindNeqRealL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TReal val;
sl@0: 	TPckg<TReal> p(val);
sl@0: 	aMessage.Read(1, p);
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val, ENotEqual);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::FindNeqStringL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TBuf8<KMaxBinaryLength> val;
sl@0: 	aMessage.ReadL(1, val);  // no error if too long, truncated instead
sl@0: 	// PlatSec check done in FindValueL
sl@0: 	return FindValueL(aMessage, val, ENotEqual);
sl@0: 	}
sl@0: 
sl@0: template <class T>
sl@0: TInt CServerSubSession::FindValueL(const TClientRequest& aMessage, const T& aVal,TComparison aComparison)
sl@0: 	{
sl@0: 	// IMPORTANT PLATSEC NOTE:
sl@0: 	// MUST return KErrPermissionDenied if read policy of ANY setting in the search range not passed.
sl@0: 	// MUST NOT merely check read policy of matching entries, otherwise it is possible to determine
sl@0: 	// secret values by brute force: Using single-value ranges, cycling through the possible values and
sl@0: 	// confirming a match when it returns KErrPermissionDenied rather than KErrNotFound.
sl@0: 	TKeyFilter keyIdentifier;
sl@0: 	TPckg<TKeyFilter> p(keyIdentifier);
sl@0: 	aMessage.Read(0, p);
sl@0: 	// we reset results first since we do not police GetResult
sl@0: 	// and this way we can guarantee no results are available if access not granted
sl@0: 	iFindResult.Reset();
sl@0: 	RSettingPointerArray settings;
sl@0: 	CleanupClosePushL(settings);
sl@0: 	TInt error = iRepository.FindSettings(keyIdentifier.iPartialId, keyIdentifier.iIdMask, settings);
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		//perform the read checking policies first
sl@0: 		TUint32 dummyErrId;
sl@0: 		error=iRepository.CheckPermissions(settings,aMessage,
sl@0: 		__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::FindValueL - Attempt made to search settings"),ETrue,dummyErrId);
sl@0: 		if (error==KErrPermissionDenied)
sl@0: 			iFindResult.Reset();
sl@0: 
sl@0: 		//now if everything passes, do perform the FindValue
sl@0: 		if (error==KErrNone)
sl@0: 			{
sl@0: 			TRAP(error,iRepository.FindCompareL(settings,aVal,aComparison,iFindResult));
sl@0: 			if (error==KErrNone)
sl@0: 				{
sl@0: 				const TInt numSettings = iFindResult.Count();
sl@0: 				const TInt numInitial = numSettings > KCentRepFindBufSize ? KCentRepFindBufSize : numSettings;
sl@0: 				RArray<TUint32> settingsToSend;
sl@0: 				CleanupClosePushL(settingsToSend);
sl@0: 				
sl@0: 				//reserve memory for everything that needs to be added to the array
sl@0: 				settingsToSend.ReserveL(numInitial + 1); // the plus one is for the numSettings value
sl@0: 				
sl@0: 				//first append the number of found settings
sl@0: 				settingsToSend.AppendL(numSettings);
sl@0: 
sl@0: 				//now append up to KCentRepFindBufSize settings
sl@0: 				for(TInt i = 0; i < numInitial; i++)
sl@0: 					{
sl@0: 					settingsToSend.AppendL(iFindResult[0]);
sl@0: 					iFindResult.Remove(0);
sl@0: 					}
sl@0: 					
sl@0: 				if(iFindResult.Count() == 0)
sl@0: 					{
sl@0: 					iFindResult.Reset();
sl@0: 					}
sl@0: 
sl@0: 				//send:
sl@0: 				//1 - the count of total settings found
sl@0: 				//2 - the settings that fit in the buffer allocated for the first IPC 
sl@0: 				TPtrC8 p(reinterpret_cast<TUint8*>(&(settingsToSend[0])), (numInitial+1)*sizeof(TUint32));
sl@0: 				error = aMessage.Write(2, p);
sl@0: 
sl@0: 	#ifdef SRVSUBSESS_TRACE
sl@0: 				TUid uid = RepositoryUid();
sl@0: 				
sl@0: 				__SRVSUBSESS_TRACE4("CServerSubSession::FindValueL UID: 0x%x Key=0x%x Mask=0x%x Value=%S\n",uid.iUid,keyIdentifier.iPartialId, 
sl@0: 						keyIdentifier.iIdMask,&p);
sl@0: 	#endif
sl@0: 				CleanupStack::PopAndDestroy(); //settingsToSend		
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	if ((error != KErrNone) && (error != KErrNotFound) && (error != KErrPermissionDenied))
sl@0: 		{
sl@0: 		iFindResult.Reset();
sl@0: 		CleanupStack::PopAndDestroy(); //settings
sl@0: 
sl@0: 		// ServiceError will fail transaction
sl@0: 		User::Leave(error);
sl@0: 		}
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	else
sl@0: 		{
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::FindValueL **Failure** UID: 0x%x Key=0x%x Mask=0x%x\n",uid.iUid,keyIdentifier.iPartialId,
sl@0: 				keyIdentifier.iIdMask);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(); //settings
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GetFindResultL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TInt n = iFindResult.Count();	
sl@0: 	if (n==0)
sl@0: 		{
sl@0: 		return KErrNotFound;
sl@0: 		}
sl@0: 
sl@0:   	TPtrC8 p(reinterpret_cast<TUint8*>(&(iFindResult[0])), n*sizeof(TUint32));
sl@0:   	TInt error = aMessage.Write(0, p);
sl@0:   	// Free up iFindResult - it's no longer needed
sl@0:   	iFindResult.Reset();
sl@0: 	// ServiceError will fail transaction
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0:   	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::GetFindResultL UID: 0x%x Value=%S\n",uid.iUid,&p);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::GetFindResultL **Failure** UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: #endif
sl@0: 	return User::LeaveIfError(error);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::NotifyRequestCheck(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::NotifyRequestCheck - Attempt made to check Notify request")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	TInt error = iRepository.GetPersistentSetting(key) ? KErrNone : KErrNotFound;
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::NotifyRequestCheck UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::NotifyRequestCheck **Failure** UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: #endif
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::NotifyRequest(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetReadAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::NotifyRequest - Attempt made to register for Notify")))
sl@0: 		return KErrPermissionDenied;
sl@0: 	TInt error = iNotifier.AddRequest(key, aMessage);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::NotifyRequest UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::NotifyRequest **Failure** UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return (error == KErrNone) ? KDontCompleteMessage : error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::NotifyCancel(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::NotifyCancel UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: #endif
sl@0: 
sl@0: 	return iNotifier.CancelRequest(key);
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::NotifyCancelAll(const TClientRequest& /*aMessage*/)
sl@0: 	{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE1("CServerSubSession::NotifyCancelAll UID: 0x%x\n",uid.iUid);
sl@0: #endif
sl@0: 	return iNotifier.CancelAllRequests();
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GroupNotifyRequest(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TUint32 partialId = aMessage.Int0();
sl@0: 	TUint32 idMask = aMessage.Int1();
sl@0: 	RSettingPointerArray settings;
sl@0: 	TInt error = iRepository.FindPersistentSettings(partialId, idMask, settings);
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		TUint32 dummyErrId;
sl@0: 		error = iRepository.CheckPermissions(settings, aMessage,
sl@0: 			__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::GroupNotifyRequest - Attempt made to register for group Notify"),ETrue,dummyErrId);
sl@0: 		}
sl@0: 	settings.Reset();
sl@0: 	if (error != KErrNone)
sl@0: 		{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest **Failure** UID: 0x%x\n PartialId=0x%x Mask=0x%x\n",
sl@0: 				uid.iUid,partialId,idMask);
sl@0: #endif
sl@0: 
sl@0: 		return KErrPermissionDenied;
sl@0: 		}
sl@0: 
sl@0: 	error = iNotifier.AddRequest(partialId, idMask, aMessage);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest UID: 0x%x PartialId=0x%x Mask=0x%x\n",
sl@0: 				uid.iUid,partialId,idMask);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyRequest **Failure** UID: 0x%x PartialId=0x%x Mask=0x%x\n",uid.iUid,
sl@0: 				partialId,idMask);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error==KErrNone ? KDontCompleteMessage : error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::GroupNotifyCancel(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TKeyFilter keyIdentifier;
sl@0: 	TPckg<TKeyFilter> p(keyIdentifier);
sl@0: 	aMessage.Read(0, p);
sl@0: 
sl@0: 	RSettingPointerArray settings;
sl@0: 	TInt error = iRepository.FindPersistentSettings(keyIdentifier.iPartialId, keyIdentifier.iIdMask, settings);
sl@0: 	settings.Reset();
sl@0: 	if (error != KErrNone)
sl@0: 		{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel **Failure** UID: 0x%x\n PartialId=0x%x Mask=0x%x\n",
sl@0: 				uid.iUid,keyIdentifier.iPartialId, keyIdentifier.iIdMask);
sl@0: #endif
sl@0: 		return error;
sl@0: 		}
sl@0: 
sl@0: 	error = iNotifier.CancelRequest(keyIdentifier.iPartialId, keyIdentifier.iIdMask);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel UID: 0x%x PartialId=0x%x Mask=0x%x\n",
sl@0: 				uid.iUid,keyIdentifier.iPartialId, keyIdentifier.iIdMask);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::GroupNotifyCancel **Failure** UID: 0x%x PartialId=0x%x Mask=0x%x\n",uid.iUid,
sl@0: 				keyIdentifier.iPartialId, keyIdentifier.iIdMask);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::ResetL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	// individual setting reset is not yet supported in transactions
sl@0: 	ASSERT(!iRepository.IsInTransaction());
sl@0: 	TUint32 key = aMessage.Int0();
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetWriteAccessPolicy(key),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::ResetL - Attempt made to reset a setting")))
sl@0: 		return iRepository.FailTransaction(KErrPermissionDenied, key);
sl@0: 
sl@0: 	TInt error = iRepository.ResetL(key);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::ResetL UID: 0x%x Key=0x%x\n",
sl@0: 				uid.iUid,key);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::ResetL **Failure** UID: 0x%x Key=0x%x\n",uid.iUid,key);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::ResetAllL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	// factory reset operation is not yet supported in transactions
sl@0: 	ASSERT(!iRepository.IsInTransaction());
sl@0: 	if(KErrNone != CheckPolicy(aMessage,iRepository.GetDefaultWriteAccessPolicy(),
sl@0: 				__PLATSEC_DIAGNOSTIC_STRING("CenRep: CServerSession::ResetAllL - Attempt made to reset repository")))
sl@0: 		return KErrPermissionDenied;
sl@0: 
sl@0: 	iNotifier.IdReportingOff();
sl@0: 	TInt error = iRepository.ResetAllL();
sl@0: 	iNotifier.IdReportingOn();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		iRepository.CommitChangesL();  // temporary measure
sl@0: 		}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::ResetAllL UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::ResetAllL **Failure** UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::MoveL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		TKeyFilter keyIdentifier;
sl@0: 		TPckg<TKeyFilter> p(keyIdentifier);
sl@0: 		aMessage.Read(0, p);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::MoveL **Failure** In Transaction UID: 0x%x PartialId=0x%x Mask=0x%x\n",
sl@0: 				uid.iUid,keyIdentifier.iPartialId,keyIdentifier.iIdMask);
sl@0: #endif
sl@0: 
sl@0: 		// could not promote to read/write: fail & give the source partialKey as the error key
sl@0: 		return iRepository.FailTransaction(KErrLocked, keyIdentifier.iPartialId);
sl@0: 		}
sl@0: 	
sl@0: 	TUint32 errorKey = KUnspecifiedKey;
sl@0: 	TInt result = iRepository.TransactionMoveL(aMessage, errorKey);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (result == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::MoveL UID: 0x%x\n",uid.iUid);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::MoveL **Failure** UID: 0x%x Error=%d\n",uid.iUid,errorKey);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	if (result != KErrNone && result!=KErrNotFound)
sl@0: 		{
sl@0: 		iRepository.FailTransaction(result, errorKey);
sl@0: 		TPckg<TUint32> p(errorKey);
sl@0: 		aMessage.WriteL(2, p);
sl@0: 		}
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::TransactionStart(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	// check if we are already in a transaction
sl@0: 	TBool inTransactionAlready = iRepository.IsInTransaction();
sl@0: 
sl@0: 	// panic client if attempting to start a transaction when already in one
sl@0: 	__ASSERT_ALWAYS(!inTransactionAlready, PanicClient(EStartAlreadyInTransaction, aMessage));
sl@0: 
sl@0: 	// if the client has been panicked then we don't want to continue.
sl@0: 	// client session will already have been taken down so don't want to complete the message
sl@0: 	if (inTransactionAlready)
sl@0: 		{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::TransactionStart **Failure** already in transaction UID=0x%x\n",uid.iUid);
sl@0: #endif
sl@0: 
sl@0: 		return KDontCompleteMessage;
sl@0: 		}
sl@0: 
sl@0: 	const TInt mode = aMessage.Int0();
sl@0: 
sl@0: 	TInt error = iRepository.StartTransaction(mode);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	// mode strings match transstate.h - if that is updated, this should be as well.
sl@0: 	const TPtrC modeStrings[] =
sl@0: 		{
sl@0: 			_L("ENoTransaction"),                              // 0
sl@0: 			_L("EReadTransaction"),                            // EReadBit     1
sl@0: 			_L("EConcurrentReadWriteTransaction"),             // EWriteBit    2
sl@0: 			_L("EReadWriteTransaction|EAllTransactionBits"),   //EReadBit | EWriteBit 3
sl@0: 			_L("EFailedBit")                                   // 4
sl@0: 		};
sl@0: 
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::TransactionStart UID: 0x%x Mode=%d (%S)\n",uid.iUid,mode,&modeStrings[mode]);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::TransactionStart **Failure** UID: 0x%x Mode=%d (%S)\n",uid.iUid,mode,&modeStrings[mode]);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: // serves as both rollback and async cancel
sl@0: TInt CServerSubSession::TransactionCancel(const TClientRequest& /*aMessage*/)
sl@0: 	{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE1("CServerSubSession::TransactionCancel UID: 0x%x",uid.iUid);
sl@0: #endif
sl@0: 	iRepository.CancelTransaction();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::TransactionCommitL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	// check if we are in a transaction
sl@0: 	TBool inTransaction = iRepository.IsInTransaction();
sl@0: 
sl@0: 	// panic client if attempting to commit a transaction when we are not in one
sl@0: 	__ASSERT_ALWAYS(inTransaction, PanicClient(ECommitNotInTransaction, aMessage));
sl@0: 
sl@0: 	// if the client has been panicked then we don't want to continue.
sl@0: 	// client session will already have been taken down so don't want to complete the message
sl@0: 	if (!inTransaction)
sl@0: 		{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 		TUid uid = RepositoryUid();
sl@0: 
sl@0: 		__SRVSUBSESS_TRACE1("CServerSubSession::TransactionCommitL **Failure** In Transaction UID: 0x%x TransactionKey=%d\n",uid.iUid);
sl@0: #endif
sl@0: 		return KDontCompleteMessage;
sl@0: 		}
sl@0: 
sl@0: 	TUint32 keyInfo = KUnspecifiedKey;
sl@0: 	TInt result = iRepository.CommitTransaction(keyInfo);
sl@0: 
sl@0: 	TPckg<TUint32> p(keyInfo);
sl@0: 	aMessage.WriteL(0, p);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	if (result == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::TransactionCommitL UID: 0x%x TransactionKey=%d\n",uid.iUid,keyInfo);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::TransactionCommitL **Failure** UID: 0x%x TransactionKey=%d\n",uid.iUid,keyInfo);
sl@0: 		}
sl@0: #endif
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::DeleteRangeL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	if (iRepository.IsInActiveReadTransaction())
sl@0: 		{
sl@0: 		// could not promote to read/write: fail & give the partialKey as the error key
sl@0: 		TUint32 partialKey = aMessage.Int0();
sl@0: 		return iRepository.FailTransaction(KErrLocked, partialKey);
sl@0: 		}
sl@0: 	TUint32 errorKey = KUnspecifiedKey;
sl@0: 	TInt result = iRepository.TransactionDeleteRangeL(aMessage, errorKey);
sl@0: 	if (result != KErrNone)
sl@0: 		{
sl@0: 		TPckg<TUint32> p(errorKey);
sl@0: 		aMessage.WriteL(2, p);
sl@0: 		}
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 	TUint32 partialKey = aMessage.Int0();
sl@0: 	TUint32 keyMask    = aMessage.Int1();
sl@0: 
sl@0: 	if (result == KErrNone)
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE3("CServerSubSession::DeleteRangeL UID: 0x%x Key=0x%x Mask=0x%x\n",uid.iUid,partialKey,keyMask);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SRVSUBSESS_TRACE2("CServerSubSession::DeleteRangeL **Failure** UID: 0x%x ErrorKey=%d\n",uid.iUid,errorKey);
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::TransactionStateL(const TClientRequest& aMessage)
sl@0: 	{
sl@0: 	TInt iState = iRepository.TransactionState();
sl@0: 
sl@0: 	TPckg<TInt> p(iState);
sl@0: 	aMessage.WriteL(0, p);
sl@0: 
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE2("CServerSubSession::TransactionStateL UID: 0x%x State=%d\n",uid.iUid,iState);
sl@0: #endif
sl@0: 
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: TInt CServerSubSession::TransactionFail(const TClientRequest& aMessage)
sl@0: 	{
sl@0: #ifdef SRVSUBSESS_TRACE
sl@0: 	TUid uid = RepositoryUid();
sl@0: 
sl@0: 	__SRVSUBSESS_TRACE1("CServerSubSession::TransactionFail UID: 0x%x",uid.iUid);
sl@0: #endif
sl@0: 
sl@0: 	iRepository.FailTransaction(aMessage.Int0(), KUnspecifiedKey);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: //Check the security policy against a RMessage.
sl@0: TInt CServerSubSession::CheckPolicy(const TClientRequest& msg,
sl@0: 								 const TSecurityPolicy& aPolicy,
sl@0: 								 const char *aDiagnostic)
sl@0: 	{
sl@0: 	return msg.CheckPolicy(aPolicy,aDiagnostic) ? KErrNone : KErrPermissionDenied;
sl@0: 	}