--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/bookmarksupport/test/cenrepsrv/srvrepos.h	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,384 @@
+// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef SRVREPOS_H
+#define SRVREPOS_H
+
+#include <e32base.h>
+#include <s32file.h>
+#include "shrepos.h"
+#include "inifile.h"
+#include "setting.h"
+#include "clientrequest.h"
+#include "sessnotf.h"
+
+class MObserver;
+class CIniFileIn;
+
+class CServerRepository : public CRepositoryTransactor
+	{
+public:
+	~CServerRepository();
+	
+	void OpenL(TUid aUid, MObserver& aObserver, TBool aFailIfNotFound = ETrue);
+	void HandleOpenMergeL();
+	void Close(MObserver& aObserver);
+	void RestoreConsistencyL();
+	TInt ResetRepositoryL();
+	static void ResetRepositoriesL();
+
+	TInt ReadIniFileL(CSharedRepository*& aRepository,TCentRepLocation aLocation);
+
+	inline TInt StartTransaction(TInt aMode)
+		{
+		return iRepository->StartTransaction(*this, aMode);
+		}
+	inline TInt CommitTransaction(TUint32& aKeyInfo)
+		{
+		return iRepository->CommitTransaction(*this, aKeyInfo);
+		}
+	inline void CancelTransaction() // serves as both rollback and async cancel
+		{
+		iRepository->CancelTransaction(*this);
+		}
+	void CleanupCancelTransactionPushL();
+	inline TInt FailTransaction(TInt aError, TUint32 aErrorKey)
+		{
+		// returns aError to allow "return FailTransaction(error, errorKey);" - error written once
+		return iRepository->FailTransaction(*this, aError, aErrorKey);
+		}
+
+	inline void FailAllTransactions()
+		{
+		iRepository->FailAllTransactions(NULL);
+		}
+	/** must currently be in active Read transaction. Does not fail
+	transaction here if promotion to read/write failed.
+	@return KErrNone if promoted, KErrLocked if not
+	*/
+	inline TInt AttemptPromoteTransactionToReadWrite()
+		{
+		ASSERT(IsInActiveReadTransaction());
+		return iRepository->AttemptPromoteTransactionToReadWrite(*this);
+		}
+
+	inline TServerSetting* GetPersistentSetting(TUint32 aId)
+		{
+		return iRepository->iSettings.Find(aId);
+		}
+	inline TServerSetting* GetTransactionSetting(TUint32 aId)
+		{
+		return iTransactionSettings.Find(aId);
+		}
+	inline TServerSetting* GetSetting(TUint32 aId)
+		{
+		// try to be most efficient when no transaction changes
+		if ((iTransactionSettings.Count() > 0) && IsInActiveReadWriteTransaction())
+			{
+			TServerSetting* s = GetTransactionSetting(aId);
+			if (s)
+				{
+				return (s);
+				}
+			}
+		return GetPersistentSetting(aId);
+		}
+
+	template <class T> 
+	TInt TransactionCreateL(TUint32 aKey, const T& aVal, TUint32 aMeta);
+
+	inline TInt TransactionDeleteL(TUint32 aId)
+		{
+		// all write operations now done in a transaction
+		ASSERT(IsInActiveReadWriteTransaction());
+		TServerSetting* ts=GetTransactionSetting(aId);
+		if (ts)
+			{
+			//If already marked as Deleted just return KErrNotFound
+			if (ts->IsDeleted())
+				return KErrNotFound;
+			//otherwise reset and mark as delete
+			else
+				{
+				ts->Reset();
+				ts->SetDeleted();	
+				}
+			}
+		else
+			{
+			//cannot find transaction settings, go find persistent settings
+			TServerSetting* ps=GetPersistentSetting(aId);
+			//if also cannot find persistent settings just return KErrNotFound
+			if (!ps)
+				return KErrNotFound;
+			// Create a placeholder and set as deleted
+			TServerSetting newSetting(aId);
+			newSetting.SetDeleted();
+			iTransactionSettings.OrderedInsertL(newSetting);
+			}
+		return KErrNone;
+		}
+
+	// note this is non-const ONLY to use non-const helper function GetSetting
+	template <class T>
+	inline TInt Get(TUint32 aId, T& aVal)
+		{
+		const TServerSetting* s = GetSetting(aId);
+		if (!s || s->IsDeleted())
+			{
+			return KErrNotFound;
+			}
+		return s->AssignValueTo(aVal);
+		}
+
+	template <class T>
+	TInt TransactionSetL(TUint32 aKey, const T& aVal);
+	
+	TInt CheckReadPermissions(RSettingPointerArray& aSettings, const TClientRequest& aMessage, const char *aDiagnostic);
+
+	TInt TransactionDeleteRangeL(const TClientRequest& aMessage, TUint32& aErrId);
+	TInt TransactionMoveL(const TClientRequest& aMessage, TUint32& aErrorKey);
+
+	inline TInt FindPersistentSettings(TUint32 aPartialId, TUint32 aIdMask, RSettingPointerArray& aMatches) const
+		{
+		// guarantees to reset RSettingPointerArray in case of error
+		return iRepository->iSettings.Find(aPartialId, aIdMask, aMatches);
+		}
+	inline TInt FindTransactionSettings(TUint32 aPartialId, TUint32 aIdMask, RSettingPointerArray& aMatches) const
+		{
+		// guarantees to reset RSettingPointerArray in case of error
+		return iTransactionSettings.Find(aPartialId, aIdMask, aMatches);
+		}
+	TInt FindSettings(TUint32 aPartialId, TUint32 aIdMask, RSettingPointerArray& aMatches) const;
+
+	/** Fills aFindResult with the list of keys in aSettings matching or not matching the supplied
+	value, checking read policies as it goes. If any read policy is not satisfied, fails and returns
+	KErrPermissionDenied, otherwise KErrNone.
+	guarantees to reset aFindResult in case of error
+	IMPORTANT PLATSEC NOTE:
+	This method is called by the FindEqL and FindNeqL methods.
+	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.
+	*/
+	template <class T>
+	inline TInt MakeComparisonFindResultsCheckingReadPolicies(const RSettingPointerArray& aSettings,
+		const TClientRequest& aMessage, const char *aDiagnostic, const T& aVal, TComparison aEqual, RArray<TUint32>& aFindResult) const
+		{
+		aFindResult.Reset();
+		const TInt numSettings = aSettings.Count();
+		TInt error = KErrNone;
+		for (TInt i = 0; i < numSettings; i++)
+			{
+			ASSERT(aSettings[i]);
+			const TServerSetting& setting = *(aSettings[i]);
+			if (!aMessage.CheckPolicy(GetReadAccessPolicy(setting), aDiagnostic))
+				{
+				aFindResult.Reset();
+				return KErrPermissionDenied;
+				}
+			else
+				{
+				ASSERT(!setting.IsDeleted());
+				if(aEqual && setting==aVal || !aEqual && setting!=aVal)
+					{
+					error = aFindResult.Append(setting.Key());
+					if (error != KErrNone)
+						{
+						aFindResult.Reset();
+						return error;
+						}
+					}
+				}
+			}
+		return error;
+		}
+
+	inline void CommitChangesL() const
+		{
+		iRepository->CommitChangesL();
+		}
+
+	TInt ResetL(TUint32 aId);
+	TInt ResetAllL();
+
+	inline const TSecurityPolicy& GetFallbackReadAccessPolicy(TUint32 aId) const
+		{
+		return iRepository->GetFallbackReadAccessPolicy(aId);
+		}
+	inline const TSecurityPolicy& GetReadAccessPolicy(const TServerSetting& aSetting) const
+		{
+		return iRepository->GetReadAccessPolicy(aSetting);
+		}
+	inline const TSecurityPolicy& GetReadAccessPolicy(TUint32 aId) const
+		{
+		return iRepository->GetReadAccessPolicy(aId);
+		}
+	inline const TSecurityPolicy& GetDefaultReadAccessPolicy() const
+		{
+		return iRepository->GetDefaultReadAccessPolicy();
+		}
+
+	inline const TSecurityPolicy& GetFallbackWriteAccessPolicy(TUint32 aId) const
+		{
+		return iRepository->GetFallbackWriteAccessPolicy(aId);
+		}
+	inline TSettingsAccessPolicy* GetFallbackAccessPolicy(TUint32 aId) const
+		{
+		return iRepository->GetFallbackAccessPolicy(aId);
+		}
+	inline const TSecurityPolicy& GetWriteAccessPolicy(const TServerSetting& aSetting) const
+		{
+		return iRepository->GetWriteAccessPolicy(aSetting);
+		}
+	inline const TSecurityPolicy& GetWriteAccessPolicy(TUint32 aId) const
+		{
+		return iRepository->GetWriteAccessPolicy(aId);
+		}
+	inline const TSecurityPolicy& GetDefaultWriteAccessPolicy() const
+		{
+		return iRepository->GetDefaultWriteAccessPolicy();
+		}
+
+	void HandleSWIUpdateL(TUid aUid, TTime aModified, CSessionNotifier& aNotifier);
+	void HandleSWIDeleteL(TUid aUid, CSessionNotifier& aNotifier);
+
+	inline TUid Owner(){return iRepository->Owner();} ;
+
+	void StoreRepositoryContentsL(CStreamStore & aStore, TStreamId & aSettingStreamId, TStreamId & aDeletedSettingsStreamId) const;
+	void RestoreRepositoryContentsL(CStreamStore& aStore, TStreamId aSettingStreamId, TStreamId aDeletedSettingsStreamId = KNullStreamId);
+	void ResetFromIniFileL(TUint32 aId,TCentRepLocation aLocation,TBool& aKeyFound);
+	
+	static inline void RemoveRepository(CSharedRepository* aRepository)
+		{
+		TInt index = iOpenRepositories.Find(aRepository);
+		
+		if (index>=0)		
+			{
+			iOpenRepositories.Remove(index);
+			}
+		}
+
+#ifdef CACHE_OOM_TESTABILITY
+	static void CloseiOpenRepositories() 
+		{
+		iOpenRepositories.Close();
+		}
+	TInt SizeiRepository()
+		{
+		return iRepository->Size();
+		}
+	TBool iTrapOOMOnOpen;
+#endif	
+private:
+	void LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);
+	TInt CreateRepositoryL(CSharedRepository*& aRepository, TCentRepLocation aLocation);
+	TInt CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode);
+	TInt FindRepository(TUid aUid) const;
+	TInt ReadSettingsL(CIniFileIn* aIniFileIn, CSharedRepository* aRep);
+	template <class T> TInt CreateL(TUint32 aKey, const T& aVal, TUint32 aMeta);	
+private:
+	static RPointerArray<CSharedRepository> iOpenRepositories;
+	CSharedRepository* iRepository;
+	};
+
+template <class T>
+TInt CServerRepository::TransactionSetL(TUint32 aKey, const T& aVal)
+	{
+	// all write operations now done in a transaction
+	ASSERT(IsInActiveReadWriteTransaction());
+	TServerSetting* s = iTransactionSettings.Find(aKey);		
+	TServerSetting* orig_s = s ? NULL : iRepository->iSettings.Find(aKey);
+	if (!s && !orig_s)
+		{
+		return CreateL(aKey, aVal, 0);
+		}
+	TInt error = KErrNone;
+    if (s && s->IsDeleted())
+    	{
+ 		// replace the deleted entry with the new values
+		s->CopyValueL(aVal);
+		iRepository->SetMetaDataOnCreate(*s, 0);
+		s->SetAccessPolicy(GetFallbackAccessPolicy(aKey));
+		}		   
+	else if (s)
+		{
+		// replace value of setting already in transaction - fail if type is different
+		error = s->AssignValueFromL(aVal);
+		s->SetMeta(s->Meta() & (~KMetaDefaultValue));
+		}
+	else
+		{
+		ASSERT(orig_s);
+		// insert a setting with the new value (must be same type) into the transaction settings
+		if (!orig_s->IsType(aVal))
+			{
+			error = KErrArgument;
+			}
+		else
+			{
+			error = CreateL(aKey, aVal, orig_s->Meta() & (~KMetaDefaultValue));
+			}
+		}
+
+	if (error != KErrNone)
+		{
+		FailTransaction(error, aKey);
+		}
+	return error;
+	}
+
+template <class T>
+TInt CServerRepository::TransactionCreateL(TUint32 aKey, const T& aVal, TUint32 aMeta)
+	{
+	// all write operations now done in a transaction
+	ASSERT(IsInActiveReadWriteTransaction());
+	TServerSetting* s = GetSetting(aKey);
+	if (s && !s->IsDeleted())
+		{
+		return FailTransaction(KErrAlreadyExists, aKey);
+		}
+	if (s)
+		{
+		// replace the deleted entry with the new values
+		s->CopyValueL(aVal);
+		iRepository->SetMetaDataOnCreate(*s, aMeta);
+		s->SetAccessPolicy(GetFallbackAccessPolicy(aKey));
+		}
+	else
+		{
+		CreateL(aKey, aVal, aMeta);
+		}
+	return KErrNone;
+	}
+
+template <class T>
+TInt CServerRepository::CreateL(TUint32 aKey, const T& aVal, TUint32 aMeta)
+	{
+	TServerSetting newSetting(aKey);
+	newSetting.CopyValueL(aVal);
+	iRepository->SetMetaDataOnCreate(newSetting, aMeta);
+	newSetting.SetAccessPolicy(GetFallbackAccessPolicy(aKey));
+	newSetting.PushL(); // only needed for strings
+	iTransactionSettings.OrderedInsertL(newSetting);
+	newSetting.Pop();	// only needed for strings
+
+	return KErrNone;
+	}
+
+#endif // SRVREPOS_H
+
+