// 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