diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/bookmarksupport/test/cenrepsrv/srvrepos.h --- /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 +#include +#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 + 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 + inline TInt Get(TUint32 aId, T& aVal) + { + const TServerSetting* s = GetSetting(aId); + if (!s || s->IsDeleted()) + { + return KErrNotFound; + } + return s->AssignValueTo(aVal); + } + + template + 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 + inline TInt MakeComparisonFindResultsCheckingReadPolicies(const RSettingPointerArray& aSettings, + const TClientRequest& aMessage, const char *aDiagnostic, const T& aVal, TComparison aEqual, RArray& 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 TInt CreateL(TUint32 aKey, const T& aVal, TUint32 aMeta); +private: + static RPointerArray iOpenRepositories; + CSharedRepository* iRepository; + }; + +template +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 +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 +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 + +