sl@0: // Copyright (c) 2004-2009 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 "srvdefs.h"
sl@0: #include "srvres.h"
sl@0: #include "shrepos.h"
sl@0: #include "srvrepos_noc.h"
sl@0: #include "obsrvr_noc.h"
sl@0: #include "srvparams.h"
sl@0: 
sl@0: CSharedRepository* CSharedRepository::NewL(TUid aUid)
sl@0: 	{
sl@0: 	CSharedRepository* self = new(ELeave) CSharedRepository();
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL(aUid);
sl@0: 	CleanupStack::Pop(self);
sl@0: 	
sl@0: 	// debug check that CRepository::TTransactionMode modes match those used internally
sl@0: 	// from CRepositoryTransactor: internal state logic relies on this
sl@0: 	// there should be a better location for these checks...
sl@0: 	ASSERT(CRepository::EReadTransaction == static_cast<CRepository::TTransactionMode>(EReadTransaction));
sl@0: 	ASSERT(CRepository::EConcurrentReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EConcurrentReadWriteTransaction));
sl@0: 	ASSERT(CRepository::EReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EReadWriteTransaction));
sl@0: 	
sl@0: 	return self;
sl@0: 	}
sl@0: 	
sl@0: void CSharedRepository::ConstructL(TUid aUid)
sl@0: 	{
sl@0: 	iSimRep = CHeapRepository::NewL(aUid);
sl@0: 	}
sl@0: 
sl@0: CSharedRepository::CSharedRepository() : iNotificationState(ETrue)
sl@0: 	{
sl@0: 	}
sl@0: 	
sl@0: CSharedRepository::~CSharedRepository()
sl@0: 	{
sl@0: 	if (iSimRep)
sl@0: 		{
sl@0: 		delete iSimRep;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TUid CSharedRepository::Uid() const
sl@0: 	{
sl@0: 	return iSimRep->Uid();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Stores the repository in-memory content to the related repository file on drive C.
sl@0: If the operation fails, the in-memory content won't match the content of 
sl@0: the repository file (which will be kept as it was before the CommitChangesL() call).
sl@0: In order to keep the consistency, the in-memory repository content is deleted now
sl@0: and restored later, on the next repository operation.
sl@0: */
sl@0: TInt CSharedRepository::CommitChanges(TCentRepLocation aLocation)
sl@0: 	{
sl@0: 	iInconsistentData=ETrue;
sl@0: 	
sl@0: 	HBufC* filePath(NULL);	   
sl@0: 	TRAPD(err,TServerResources::CreateRepositoryFileNameL(filePath,iSimRep->Uid(),aLocation,ECre));	
sl@0: 	if (err!=KErrNone)
sl@0: 		{
sl@0: 		iSimRep->ResetContent();
sl@0: 		return err;		
sl@0: 		}
sl@0: 	
sl@0: 	// should not be committing while transactions are still active
sl@0: 	ASSERT(!IsTransactionActive());
sl@0: 	TInt ret=iSimRep->CommitChanges(TServerResources::iFs,TServerResources::iPersistsVersion,*filePath);
sl@0: 	if (ret==KErrNone)
sl@0: 		{
sl@0: 		iInconsistentData=EFalse;	
sl@0: 		}
sl@0: 	delete filePath;
sl@0: 	return ret;
sl@0: 	}
sl@0: 
sl@0: // merge transaction settings (which may include entries flagged as deleted), persist and notify
sl@0: // private method relies on calling code to ensure it is permitted to make changes here.
sl@0: // if this method is committing any changes, it cancels all other sessions' transactions
sl@0: TInt CSharedRepository::DoCommitTransactionSettings(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo)
sl@0: 	{
sl@0: 	aKeyInfo = KUnspecifiedKey;
sl@0: 	if (0 == aTransactor.iTransactionSettings.Count())
sl@0: 		{
sl@0: 		aKeyInfo = 0; // == number of settings modified
sl@0: 		return KErrNone; // nothing to do
sl@0: 		}
sl@0: 	TInt error = iSimRep->SettingsArray().MergeArray(aTransactor.iTransactionSettings, iSimRep->DeletedSettingsArray(), ETransactionMerge);
sl@0: 	TInt numChanges = aTransactor.iTransactionSettings.Count();
sl@0: 	if (numChanges == 0)
sl@0: 		{
sl@0: 		if (error == KErrNone)
sl@0: 			{
sl@0: 			aKeyInfo = 0; // no changes
sl@0: 			}
sl@0: 		// no changes were made, so the internal cache is still valid.
sl@0: 		// This could be because there were no changes: empty list, only deletes on
sl@0: 		// non-existent items (a setting created and deleted in the transaction),
sl@0: 		// or because of error, such as failure of an initial realloc failure.
sl@0: 		return error;
sl@0: 		}
sl@0: 	if (error != KErrNone)
sl@0: 		{
sl@0: 		// the repository is corrupted. Dump it for lazy loading later
sl@0: 		ResetContent();
sl@0: 		
sl@0: 		// mark cache as inconsistent so it is reloaded.
sl@0: 		iInconsistentData = ETrue;	
sl@0: 		return error;	
sl@0: 		}
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		// changes have been made: fail all other sessions' transactions so we can commit
sl@0: 		FailAllTransactions(/*aExcludeTransactor=*/&aTransactor);
sl@0: 		error = CommitChanges(); // this already calls ResetContent() in case of failure
sl@0: 		}
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		// settings are now persistent on disk: we can now notify about the changes
sl@0: 		// following will notify about objects that are created and deleted in the transaction
sl@0: 		// this could be made faster by having a multiple Notify method.
sl@0: 		// That would also allow Notify messages to be more descriptive - ranges of Keys
sl@0: 		for (TInt i = 0; i < numChanges; i++)
sl@0: 			{
sl@0: 			Notify(aTransactor.iTransactionSettings[i].Key());
sl@0: 			}
sl@0: 		aKeyInfo = /*reinterpret_cast<TUint32>*/numChanges;
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: void CSharedRepository::SetMetaDataOnRead(TServerSetting& aSetting, TBool aSingleMetaFound)
sl@0: 	{
sl@0: 	iSimRep->SetMetaDataOnRead(aSetting, aSingleMetaFound);
sl@0: 	}
sl@0: 
sl@0: void CSharedRepository::SetMetaDataOnCreate(TServerSetting& aNewSetting, TUint32* aMeta)
sl@0: 	{
sl@0: 	if(aMeta)
sl@0: 		{
sl@0: 		aNewSetting.SetMeta(*aMeta);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// No metadata specified. First check for a matching "range" default
sl@0: 		// metadata setting
sl@0: 		TSettingsDefaultMeta* defaultMeta = iSimRep->RangeMetaArray().Find(aNewSetting.Key());
sl@0: 		if (defaultMeta)
sl@0: 			{
sl@0: 			aNewSetting.SetMeta(defaultMeta->GetDefaultMetadata());
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			// Range value not found, try for a repository default
sl@0: 			aNewSetting.SetMeta(iSimRep->DefaultMeta());
sl@0: 			}
sl@0: 		}	
sl@0: 	}
sl@0: 
sl@0: void CSharedRepository::CreateL(TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool aFirstLoad, TBool aSingleMetaFound)
sl@0: 	{
sl@0: 	User::LeaveIfError(iSimRep->Create(aSetting, aPolicy, aSingleMetaFound));
sl@0: 	if (!aFirstLoad)
sl@0: 		{
sl@0: 		Notify(aSetting.Key());
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // deletes an individual setting in the shared repository and makes it persistent
sl@0: // if changes are made, all sessions' transactions are failed
sl@0: TInt CSharedRepository::DeleteAndPersist(TUint32 aId)
sl@0: 	{
sl@0: 	TServerSetting* s = iSimRep->SettingsArray().Find(aId);
sl@0: 	if(!s)
sl@0: 		return KErrNotFound;
sl@0: 	iSimRep->SettingsArray().Remove(aId);
sl@0: 	
sl@0: 	// removed a setting, so must fail all sessions' transactions before commit possible
sl@0: 	FailAllTransactions(/*aExcludeTransactor=*/NULL);
sl@0: 	TInt error = CommitChanges();
sl@0: 	if (error == KErrNone)
sl@0: 		{
sl@0: 		Notify(aId);
sl@0: 		}
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: // deletes an individual setting without making it persistent
sl@0: // must not be called while any sessions are in transactions
sl@0: TInt CSharedRepository::DeleteNoPersist(TUint32 aId)
sl@0: 	{
sl@0: 	// should only be calling this if no transactions are active
sl@0: 	ASSERT(!IsTransactionActive());
sl@0: 	TServerSetting* s = iSimRep->SettingsArray().Find(aId);
sl@0: 	if(!s)
sl@0: 		return KErrNotFound;
sl@0: 
sl@0: 	iSimRep->SettingsArray().Remove(aId);
sl@0: 	return KErrNone;	
sl@0: 	}
sl@0: 
sl@0: TInt CSharedRepository::ResetNoPersistL(TServerSetting& aSetting)
sl@0: 	{
sl@0: 	TServerSetting* s = iSimRep->SettingsArray().Find(aSetting.Key());
sl@0: 	if ((!s) || (*s != aSetting))
sl@0: 		{
sl@0: 		if (s)
sl@0: 			{
sl@0: 			// save access policy of setting
sl@0: 			TSettingsAccessPolicy* policy=s->AccessPolicy();
sl@0: 			s->Transfer(aSetting);
sl@0: 			// restore access policy of setting
sl@0: 			s->SetAccessPolicy(policy);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TServerSetting setting;
sl@0: 			setting.Transfer(aSetting);
sl@0: 			setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));
sl@0: 			setting.PushL();
sl@0: 			iSimRep->SettingsArray().OrderedInsertL(setting);
sl@0: 			
sl@0: 			TInt index = iSimRep->DeletedSettingsArray().FindInUnsignedKeyOrder(aSetting.Key());
sl@0: 			if (index != KErrNotFound)
sl@0: 				iSimRep->DeletedSettingsArray().Remove(index);
sl@0: 	
sl@0: 			setting.Pop();
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		return KErrGeneral;
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: // if changes are made, all sessions' transactions are failed
sl@0: void CSharedRepository::ResetAndPersistL(TServerSetting& aSetting)
sl@0: 	{
sl@0: 	if (ResetNoPersistL(aSetting) == KErrNone)
sl@0: 		{
sl@0: 		// changed a setting, so must fail all sessions' transactions
sl@0: 		// before commit possible
sl@0: 		FailAllTransactions(/*aExcludeTransactor=*/NULL);
sl@0: 		CommitChangesL();
sl@0: 		Notify(aSetting.Key());
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CSharedRepository::ResetAllNoPersistL(CSharedRepository& aNewContent)
sl@0: 	{
sl@0: 	// mark cache as inconsistent in case Reset fails, so it is reloaded.
sl@0: 	iInconsistentData=ETrue;
sl@0: 
sl@0: 	// should not change repository while transactions in progress: should fail them first
sl@0: 	ASSERT(!IsTransactionActive());
sl@0: 	TInt newCount = (aNewContent.iSimRep)->SettingsArray().Count();
sl@0: 	TInt count = iSimRep->SettingsArray().Count();
sl@0: 
sl@0: 	TInt newIndex = 0;
sl@0: 	TInt index = 0;
sl@0: 
sl@0: 	while(newIndex<newCount && index<count)
sl@0: 		{
sl@0: 		const TServerSetting& newSetting = (aNewContent.iSimRep)->SettingsArray()[newIndex];
sl@0: 		const TServerSetting& setting = iSimRep->SettingsArray()[index];
sl@0: 
sl@0: 		TUint32 newKey = newSetting.Key();
sl@0: 		TUint32 key = setting.Key();
sl@0: 
sl@0: 		if(newKey<key)
sl@0: 			{
sl@0: 			Notify(newKey);
sl@0: 			newIndex++;
sl@0: 			}
sl@0: 		else if(newKey==key)
sl@0: 			{
sl@0: 			if(newSetting!=setting)
sl@0: 				{
sl@0: 				Notify(key);
sl@0: 				}
sl@0: 			newIndex++;
sl@0: 			index++;
sl@0: 			}
sl@0: 		else if(newKey>key)
sl@0: 			{
sl@0: 			Notify(key);
sl@0: 			index++;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	while(newIndex<newCount)
sl@0: 		{
sl@0: 		Notify((aNewContent.iSimRep)->SettingsArray()[newIndex++].Key());
sl@0: 		}
sl@0: 		
sl@0: 	while(index<count)
sl@0: 		{
sl@0: 		Notify(iSimRep->SettingsArray()[index++].Key());
sl@0: 		}
sl@0: 
sl@0: 	// Replace current settings with settings read from ROM, this 
sl@0: 	// will leave settings pointing to new single policies
sl@0: 	iSimRep->SettingsArray().AdoptL((aNewContent.iSimRep)->SettingsArray());
sl@0: 
sl@0: 	// Reset policy pointers to point at this repositories policies
sl@0: 	newCount=iSimRep->SettingsArray().Count();
sl@0: 	for(TInt i=0; i<newCount;i++)
sl@0: 		{
sl@0: 		(iSimRep->SettingsArray())[i].SetAccessPolicy(NULL);
sl@0: 		TUint32 key = (iSimRep->SettingsArray())[i].Key();
sl@0: 		(iSimRep->SettingsArray())[i].SetAccessPolicy(GetFallbackAccessPolicy(key));
sl@0: 		}	
sl@0: 	
sl@0: 	iSimRep->DeletedSettingsArray().Reset();
sl@0: 
sl@0: 	iInconsistentData=EFalse;
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: // returns the read security policy used if there is no per-setting policy at aId
sl@0: const TSecurityPolicy& CSharedRepository::GetFallbackReadAccessPolicy(TUint32 aId)
sl@0: 	{
sl@0: 	return iSimRep->GetFallbackReadAccessPolicy(aId);
sl@0: 	}
sl@0: 
sl@0: // returns the write security policy used if there is no per-setting policy at aId
sl@0: const TSecurityPolicy& CSharedRepository::GetFallbackWriteAccessPolicy(TUint32 aId)
sl@0: 	{
sl@0: 	return iSimRep->GetFallbackWriteAccessPolicy(aId);
sl@0: 	}
sl@0: 
sl@0: // Get pointer to security policy that applies to a given setting
sl@0: TSettingsAccessPolicy* CSharedRepository::GetFallbackAccessPolicy(TUint32 aId
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: 	,TBool aSkipSingle
sl@0: #endif	
sl@0: 	)
sl@0: 	{
sl@0: 	return iSimRep->GetFallbackAccessPolicy(aId
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: 	,aSkipSingle
sl@0: #endif	
sl@0: 	);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: TInt CSharedRepository::ReadSettingSavePolicyL(CIniFileIn& aFile,TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool& aSingleMetaFound)
sl@0: 	{
sl@0: 	return iSimRep->ReadSettingSavePolicyL(aFile, aSetting, aPolicy, aSingleMetaFound);
sl@0: 	}	
sl@0: 
sl@0: // Merge settings in this->iSettings with the iSettings of aMergeRep
sl@0: // During an intsall/upgrade event aMergeRep will be created from the installed file
sl@0: // During an upinstall event aMergeRep will be created from the ROM file
sl@0: void CSharedRepository::MergeL(CSharedRepository& aMergeRep, TMergeType aMergeType)
sl@0: 	{
sl@0: 	// Process settings from main section - this updates values only
sl@0: 	User::LeaveIfError(GetSettings().MergeArray(aMergeRep.GetSettings(), iSimRep->DeletedSettingsArray(), aMergeType));
sl@0: 
sl@0: 	//if the merging is due to a ROM Flash, we need to copy over both the NEW ROM keypsace global properties
sl@0: 	//(default access policies/metadata and range policies/metadata), individual policies, we then need to ensure
sl@0: 	//that the settings point at the correct individual policies and metadata.
sl@0: 	if (aMergeType==ERomFlash)
sl@0: 		{
sl@0: 		//copy the default/range/individual policy
sl@0: 		iSimRep->SetDefaultPolicy(aMergeRep.iSimRep->GetDefaultAccessPolicy());
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: 		iSimRep->GetDefaultAccessPolicy().iHighKey=aMergeRep.iSimRep->GetDefaultAccessPolicy().iHighKey;
sl@0: 		iSimRep->GetDefaultAccessPolicy().iKeyMask=aMergeRep.iSimRep->GetDefaultAccessPolicy().iKeyMask;		
sl@0: #endif		
sl@0: 		iSimRep->RangePolicyArray().Reset();
sl@0: 		TInt count=aMergeRep.iSimRep->RangePolicyArray().Count();
sl@0: 		iSimRep->RangePolicyArray().ReserveL(count);
sl@0: 		for (TInt i=0;i<count;i++)
sl@0: 			{
sl@0: 			iSimRep->RangePolicyArray().AppendL(aMergeRep.iSimRep->RangePolicyArray()[i]);
sl@0: 			}
sl@0: 		iSimRep->SinglePolicyArray().ResetAndDestroy();
sl@0: 		count=aMergeRep.iSimRep->SinglePolicyArray().Count();
sl@0: 		iSimRep->SinglePolicyArray().ReserveL(count);
sl@0: 		for (TInt i=0;i<count;i++)
sl@0: 			{
sl@0: 			iSimRep->SinglePolicyArray().AppendL(aMergeRep.iSimRep->SinglePolicyArray()[i]);
sl@0: 			}
sl@0: 		//now need to reset the aMergeRep single policies so it is not going to destroy the
sl@0: 		//individual policies as ownership has been transferred
sl@0: 		aMergeRep.iSimRep->SinglePolicyArray().Reset();
sl@0: 		
sl@0: 		//copy the default/range metadata
sl@0: 		iSimRep->SetDefaultMeta(aMergeRep.iSimRep->DefaultMeta());
sl@0: 		iSimRep->RangeMetaArray().Reset();
sl@0: 		count=aMergeRep.iSimRep->RangeMetaArray().Count();
sl@0: 		iSimRep->RangeMetaArray().ReserveL(count);		
sl@0: 		for (TInt i=0;i<count;i++)
sl@0: 			{
sl@0: 			iSimRep->RangeMetaArray().AppendL(aMergeRep.iSimRep->RangeMetaArray()[i]);
sl@0: 			}
sl@0: 		
sl@0: 		//set the timestamp,owner etc
sl@0: 		iSimRep->SetTimeStamp(aMergeRep.iSimRep->TimeStamp());
sl@0: 		iSimRep->SetOwner(aMergeRep.iSimRep->Owner());
sl@0: 		}
sl@0: 
sl@0: 	// Update all access policies and meta
sl@0: 	for(TInt i=0; i<iSimRep->SettingsArray().Count();i++)
sl@0: 		{
sl@0: 		TServerSetting& setting= iSimRep->SettingsArray()[i];
sl@0: 		setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));
sl@0: 		}	
sl@0: 	}
sl@0: 	
sl@0: // Save timestamp of installed file 
sl@0: void CSharedRepository::SetInstallTime(TTime aInstallTime)
sl@0: 	{
sl@0: 	iSimRep->SetTimeStamp(aInstallTime);
sl@0: 	}
sl@0: 	
sl@0: // Handle creation or upgrade of file in install directory
sl@0: void CSharedRepository::HandleUpdateMergeL(TTime aInstallFileTimeStamp, CSharedRepository& aInstallRep)
sl@0: 	{			
sl@0: 	MergeL(aInstallRep, ESWIUpgradeMerge);
sl@0: 	
sl@0: 	SetInstallTime(aInstallFileTimeStamp);	// Set merge timestamp		
sl@0: 	CommitChangesL();						// Commit changes to write system drive file
sl@0: 
sl@0: 	// settings are now persistent on disk: we can now notify about the changes
sl@0: 	for (TInt i = 0; i < (aInstallRep.iSimRep)->SettingsArray().Count(); i++)
sl@0: 		{
sl@0: 		Notify((aInstallRep.iSimRep)->SettingsArray()[i].Key());
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: // Handle merge activity due to an uninstall
sl@0: void CSharedRepository::HandleDeleteMergeL(CSharedRepository& aRomRep)
sl@0: 	{
sl@0: 	MergeL(aRomRep, ESWIDowngradeMerge);
sl@0: 	
sl@0: 	SetInstallTime(0);						// Reset timestamp			
sl@0: 	CommitChangesL();						// Commit changes to write system drive file
sl@0: 	
sl@0: 	// settings are now persistent on disk: we can now notify about the changes
sl@0: 	for (TInt i = 0; i < (aRomRep.iSimRep)->SettingsArray().Count(); i++)
sl@0: 		{
sl@0: 		Notify((aRomRep.iSimRep)->SettingsArray()[i].Key());
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: 
sl@0: #ifdef CENTREP_CONV_TOOL
sl@0: /**
sl@0: Statement "iInconsistentData = ETrue;" must be the first statement in the method,
sl@0: "iInconsistentData = EFalse;" must be the last. It is used for lasy-load implementation
sl@0: for the repository and solves the problem that if CommitChangesL() fails the in-memory
sl@0: repository data won't match the repository data, stored in the file.
sl@0: This routine is being retained for testing purposes
sl@0: */
sl@0: void CSharedRepository::DoCommitChangesToIniFileL(const TDesC& aOutFileName
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: 	,TUint32 aCreVersion
sl@0: #endif
sl@0: 	)
sl@0: 	{
sl@0: 	iInconsistentData=ETrue;
sl@0: 
sl@0: 	// should not be committing while transactions are still active
sl@0: 	ASSERT(!IsTransactionActive());
sl@0: 
sl@0: 	iSimRep->DoCommitChangesToIniFileL(TServerResources::iFs,aOutFileName
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: 	,aCreVersion
sl@0: #endif	
sl@0: 	);
sl@0: 	
sl@0: 	iInconsistentData = EFalse;
sl@0: 	}
sl@0: #endif //CENTREP_CONV_TOOL
sl@0: 	
sl@0: /**
sl@0: The method reloads the repository content from a repository file.
sl@0: The current repository must be emptied (or must be empty already) before the call is made.
sl@0: @param aIniFile A reference to CIniFileIn object, which will be used to load
sl@0: 				the repository content.
sl@0: @param aFirstLoad is used to indicate whether the file is reloaded for first time, this is used to prevent
sl@0: notification if not needed. For example file loading for merging purpose will not result in notification
sl@0: @return KErrCorrupt Corrupted repository file.
sl@0: 		KErrNone	The repository content was seccessfully loaded into memory.
sl@0: 		KErrNotFound Setting not found in the file.
sl@0: @leave System-wide error codes.
sl@0: @leave KErrGeneral It's probably a programmer's error - current CSharedRepository 
sl@0: 				   object is partially initialised.
sl@0: */
sl@0: TInt CSharedRepository::ReloadContentL(CIniFileIn& aIniFile, TBool aFirstLoad)
sl@0: 	{
sl@0: 	// Preconditions - CHeapRepository object should be an empty one.
sl@0: 	if(!iSimRep->IsEmpty())
sl@0: 		{
sl@0: 		User::Leave(KErrGeneral);
sl@0: 		}
sl@0: 	TInt err = iSimRep->ReloadContentExceptSettingsL(aIniFile);
sl@0: 	if(err == KErrCorrupt)
sl@0: 		{
sl@0: 		return err;
sl@0: 		}
sl@0: 	CleanupClosePushL(iSimRep->RangeMetaArray());
sl@0: 	CleanupClosePushL(iSimRep->RangePolicyArray());
sl@0: 	
sl@0: 	// Settings
sl@0: 	TServerSetting setting;
sl@0: 	TSettingsAccessPolicy* policy;
sl@0: 	TBool singleMetaFound;
sl@0: 	TCleanupItem tc(CHeapRepository::SinglePoliciesCleanup, &(iSimRep->SinglePolicyArray()));
sl@0: 	CleanupStack::PushL(tc);	
sl@0: 	CleanupClosePushL(iSimRep->SettingsArray());	
sl@0: 	while((err = ReadSettingSavePolicyL(aIniFile, setting, policy, singleMetaFound)) == KErrNone)
sl@0: 		{
sl@0: 		setting.PushL();
sl@0: 		if(iSimRep->SettingsArray().IsDefault())
sl@0: 			{
sl@0: 			setting.SetClean();			
sl@0: 			}
sl@0: 		CreateL(setting, policy, aFirstLoad, singleMetaFound);
sl@0: 		setting.Pop();
sl@0: 		}
sl@0: 	if(err == KErrNotFound)			
sl@0: 		{
sl@0: 		err = KErrNone;
sl@0: 		}
sl@0: 	if (err == KErrNone)
sl@0: 		{
sl@0: 		CleanupStack::Pop(4,&(iSimRep->RangeMetaArray()));		
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		CleanupStack::PopAndDestroy(4,&(iSimRep->RangeMetaArray()));		
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Resets current repository data - actually all of them, which may be loaded from
sl@0: the related ini file.
sl@0: The iUid data member value is kept as it was at the moment of creation of 
sl@0: CSharedRepository object.
sl@0: */
sl@0: void CSharedRepository::ResetContent()
sl@0: 	{
sl@0: 	iSimRep->ResetContent();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This function is used to restore the notification, which was temporary disabled
sl@0: when making RestoreConsistencyL() call.
sl@0: @param aNotificationState It points to CObservable::iNotificationState data member, which 
sl@0: 						 controls the notification state - active or disabled.
sl@0: @internalComponent
sl@0: */
sl@0: static void RestoreNotification(void* aNotificationState)
sl@0: 	{
sl@0: 	TBool* notificationState = static_cast <TBool*> (aNotificationState);
sl@0: 	*notificationState = ETrue;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method reloads the repository content from the related ini file if previous
sl@0: CommitChangesL() has not completed successfully.
sl@0: */
sl@0: void CSharedRepository::RestoreConsistencyL()
sl@0: 	{
sl@0: 	//Do nothing if previous CommitChangesL() completed successfully.
sl@0: 	if (!iInconsistentData)
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 	//Reset current repository data	
sl@0: 	ResetContent();
sl@0: 	//Disable notifications
sl@0: 	TCleanupItem restoreNotification(&RestoreNotification, &iNotificationState);
sl@0: 	CleanupStack::PushL(restoreNotification);
sl@0: 	iNotificationState = EFalse;
sl@0: 	//Reload the repository content from the related ini file
sl@0: 	DoRestoreConsistencyL();
sl@0: 	//Activate notifications
sl@0: 	CleanupStack::PopAndDestroy();//restoreNotification
sl@0: 	
sl@0: 	TCentRepLocation location = EPersists;
sl@0: 	HBufC* persistsTmpFilePath(NULL);
sl@0:     //allocates memory on the heap
sl@0:     TServerResources::CreateRepositoryFileNameLC(persistsTmpFilePath,iSimRep->Uid(),location,ETmp);
sl@0: 	// Remove any .tmp file
sl@0: 	// If a debug build - record error
sl@0: 	TInt fileDeleteErr=TServerResources::iFs.Delete(*persistsTmpFilePath);
sl@0: 	if ((fileDeleteErr != KErrNone) && (fileDeleteErr != KErrNotFound))
sl@0: 		{
sl@0: 		#ifdef _DEBUG
sl@0: 		RDebug::Print(_L("CHeapRepository::RestoreConsistencyL - Failed to delete file. Error = %d"), fileDeleteErr);
sl@0: 		#endif
sl@0: 		}
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(persistsTmpFilePath);
sl@0: 	
sl@0: 	iInconsistentData=EFalse;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method reloads the repository content from the related cre or ini file.
sl@0: @leave System-wide error codes
sl@0: */	
sl@0: void CSharedRepository::DoRestoreConsistencyL()
sl@0: 	{
sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	
sl@0: 	//note that the function below already handles the deletion of any corrupt file
sl@0: 	//in  non-rom location
sl@0: 	TInt ret=TServerResources::iObserver->CreateRepositoryL(this,EPersists);
sl@0: 	if (ret==KErrNotFound)
sl@0: 		{
sl@0: 		ret=TServerResources::iObserver->CreateRepositoryL(this,EInstall);
sl@0: 		if (ret==KErrNotFound)
sl@0: 			{	
sl@0: 			ret=TServerResources::iObserver->CreateRepositoryL(this,ERom);
sl@0: 			User::LeaveIfError(ret);
sl@0: 			}
sl@0: 		}
sl@0: #else
sl@0: 	TCentRepLocation location;
sl@0: 	
sl@0: 	TInt err = FindLocationForFileL(location,iSimRep->Uid(),ECre);
sl@0: 	if (err != KErrNotFound)
sl@0: 		{
sl@0: 		User::LeaveIfError(CreateRepositoryFromCreFileL(location));
sl@0: 		return;
sl@0: 		}
sl@0: 		
sl@0: 	User::LeaveIfError(FindLocationForFileL(location,iSimRep->Uid(),EIni));
sl@0: 	
sl@0: 	HBufC* fileName(NULL);
sl@0:     TServerResources::CreateRepositoryFileNameLC(fileName,iSimRep->Uid(),location,EIni);	
sl@0:  
sl@0: 	CIniFileIn* iniFile = NULL;
sl@0: 	err = CIniFileIn::NewLC(TServerResources::iFs,iniFile,*fileName);
sl@0: 	if (err==KErrCorrupt && location!=ERom)
sl@0: 		{
sl@0: 		User::LeaveIfError(TServerResources::iFs.Delete(*fileName));
sl@0: 		}
sl@0: 	User::LeaveIfError(err);
sl@0: 	
sl@0: 
sl@0: 	err = ReloadContentL(*iniFile);
sl@0: 	User::LeaveIfError(err);
sl@0: 	
sl@0: 	CleanupStack::PopAndDestroy(iniFile); //iniFile 
sl@0: 	CleanupStack::PopAndDestroy(fileName);	//fileName
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: This method looks for and sets a location for a given repository.
sl@0: It is based on EAuto mode thus it goes through all locations in the
sl@0: same order (EPersists - EInstall - ERom)  
sl@0: 
sl@0: @param aLocation - returns a location for a repository
sl@0: @param aUid - id of a repository which location should be found
sl@0: @param aType - repository file type (.txt or .cre) 
sl@0: @return KErrNone if aLocation succesfully set for a given repository,
sl@0: 		KErrNotFound if a repository was not found in any locations.
sl@0: 
sl@0: @internalTechnology
sl@0: */
sl@0: #ifndef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: TInt CSharedRepository::FindLocationForFileL(TCentRepLocation& aLocation,TUid aUid,const TCentRepFileType aType) const
sl@0:     { 		
sl@0: 	if(TServerResources::CentrepFileExistsL(aUid, EPersists, aType))
sl@0: 	    {
sl@0: 	     aLocation = EPersists;
sl@0: 		 return KErrNone;
sl@0: 	    }
sl@0: 	    
sl@0: 	if(TServerResources::CentrepFileExistsL(aUid, EInstall, aType))
sl@0: 		{
sl@0: 	     aLocation = EInstall;
sl@0: 		 return KErrNone;
sl@0: 	    }
sl@0: 	    
sl@0: 	if(TServerResources::CentrepFileExistsL(aUid, ERom, aType))
sl@0: 		{
sl@0: 		aLocation = ERom;
sl@0: 		return KErrNone;
sl@0: 		}
sl@0: 
sl@0: 	return KErrNotFound;
sl@0:     }
sl@0: #endif
sl@0: 
sl@0: TInt CSharedRepository::CreateRepositoryFromCreFileL( TCentRepLocation aLocation)
sl@0: 	{
sl@0: 	// Get file path name from location
sl@0:     HBufC* filePath(NULL);
sl@0:     TServerResources::CreateRepositoryFileNameLC(filePath,iSimRep->Uid(), aLocation,ECre);
sl@0:     // Trap errors from repository creation so we can delete corrupt repositories
sl@0: 	TRAPD(error, iSimRep->CreateRepositoryFromCreFileL(TServerResources::iFs,*filePath));
sl@0: 	if(error!=KErrNone && error!=KErrNotFound && error!=KErrNoMemory)
sl@0: 		{
sl@0: 		error=KErrCorrupt;
sl@0: 		// store wasn't quite what we were expecting - can't return an error, can't leave
sl@0: 		// so all we can do is close the file, tidy up as best we can, and return corrupt 
sl@0: 		if (aLocation != ERom)
sl@0: 			{
sl@0: 			// If a debug build - record error
sl@0: 			TInt fileDeleteErr=TServerResources::iFs.Delete(*filePath);
sl@0: 			if (fileDeleteErr != KErrNone)
sl@0: 				{
sl@0: 				#ifdef _DEBUG
sl@0: 				RDebug::Print(_L("CSharedRepository::CreateRepositoryFromCreFileL - Failed to delete file. Error = %d"), fileDeleteErr);
sl@0: 				#endif
sl@0: 				}
sl@0: 
sl@0: 			}
sl@0: 		}
sl@0: 	else if( error==KErrNoMemory)
sl@0: 		{
sl@0: 		User::Leave(KErrNoMemory);
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(filePath);
sl@0: 	return error;
sl@0: 	}
sl@0: 
sl@0: /** Attempts to start a transaction.
sl@0: Guaranteed to succeed (return KErrNone) for EConcurrentReadWriteTransaction mode only.
sl@0: @param aTransactor transactor attempting to start transaction
sl@0: @param aMode type of transaction to be started
sl@0: @pre transactor is not in a transaction
sl@0: @return KErrNone if the transaction is started, KErrLocked if read/write locks prevented that
sl@0: type of transaction from starting now, and KErrArgument for invalid aMode.
sl@0: @post On returning KErrNone, transaction is started and read/write locks are obtained for it
sl@0: in the shared repository. Any other return: transaction has not started.
sl@0: */
sl@0: TInt CSharedRepository::StartTransaction(CRepositoryTransactor& aTransactor, TInt aMode)
sl@0: 	{
sl@0: 	// session can only be in one transaction
sl@0: 	ASSERT(!aTransactor.IsInTransaction());
sl@0: 	
sl@0:   	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());
sl@0:   	ASSERT(shrepinfo);
sl@0: 	switch (aMode)
sl@0: 		{
sl@0: 		case EConcurrentReadWriteTransaction:
sl@0: 			// can always start this type of transaction
sl@0: 			shrepinfo->iNumActiveConcurrentReadWriteTransactions++;
sl@0: 			break;
sl@0: 		case EReadTransaction:
sl@0: 			// negative lock means there is an active EReadWriteTransaction
sl@0: 			if (shrepinfo->iPessimisticTransactionLockCount < 0)
sl@0: 				{
sl@0: 				ASSERT(shrepinfo->iPessimisticTransactionLockCount == -1); // sanity check
sl@0: 				return KErrLocked;
sl@0: 				}
sl@0: 			// when non-negative lock equals number of active EReadTransactions.
sl@0: 			shrepinfo->iPessimisticTransactionLockCount++;
sl@0: 			break;
sl@0: 		case EReadWriteTransaction:
sl@0: 			// lock is zero if there are no active pessimistic transactions
sl@0: 			if (shrepinfo->iPessimisticTransactionLockCount != 0)
sl@0: 				{
sl@0: 				return KErrLocked;
sl@0: 				}
sl@0: 			// lock value of -1 means the exclusive EReadWriteTransaction is active
sl@0: 			shrepinfo->iPessimisticTransactionLockCount = -1;
sl@0: 			break;
sl@0: 		default:
sl@0: 			// not a valid transaction mode
sl@0: 			return KErrArgument;
sl@0: 		}
sl@0: 	aTransactor.AddToQueue(shrepinfo->iTransactors, aMode);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /**	Commit transaction
sl@0: @return KErrNone on success, or error code.
sl@0: @param aKeyInfo 
sl@0: 	on success (return KErrNone): aKeyInfo returns number of modified settings;
sl@0: 	on failure (other error code): KUnspecifiedKey
sl@0: @pre transactor is in a transaction.
sl@0: @post transactor is not in a transaction
sl@0: */
sl@0: TInt CSharedRepository::CommitTransaction(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo)
sl@0: 	{
sl@0: 	// calling code should have panicked the client if not in a transaction
sl@0: 	ASSERT(aTransactor.IsInTransaction());
sl@0: 	TInt result = aTransactor.iTransactionResult;
sl@0: 	if (aTransactor.IsInFailedTransaction())
sl@0: 		{
sl@0: 		ASSERT(result != KErrNone);
sl@0: 		aKeyInfo = aTransactor.iTransactionErrorKey;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		ASSERT(result == KErrNone);
sl@0: 		ASSERT(aTransactor.iTransactionErrorKey == KUnspecifiedKey);
sl@0: 		aKeyInfo = 0;
sl@0: 		// must release locks otherwise shared repository will not commit changes
sl@0: 		// failed transactions have already released their locks
sl@0: 		TServerResources::iObserver->ReleaseTransactionLock(aTransactor,iSimRep->Uid());
sl@0: 		}
sl@0: 	
sl@0: 	// transactions that haven't made any changes can be closed at any time
sl@0: 	if (aTransactor.IsInActiveReadWriteTransaction() &&
sl@0: 		(aTransactor.iTransactionSettings.Count() > 0))
sl@0: 		{
sl@0: 		result = DoCommitTransactionSettings(aTransactor, aKeyInfo);
sl@0: 		}
sl@0: 
sl@0: 	// transaction is complete - remove from queue
sl@0:   	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());
sl@0:   	ASSERT(shrepinfo);
sl@0: 	shrepinfo->iTransactors.Remove(aTransactor);
sl@0: 	//Remove the link to the next transaction
sl@0: 	aTransactor.iLink.iNext = NULL;
sl@0: 	aTransactor.Deque();
sl@0: 
sl@0: 	return result;
sl@0: 	}
sl@0: 
sl@0: TInt CSharedRepository::FailTransaction(CRepositoryTransactor& aTransactor, TInt aError, TUint32 aErrorKey)
sl@0: 	{
sl@0: 	ASSERT(aError != KErrNone); // must fail for a reason
sl@0: 	if (aTransactor.IsInActiveTransaction())
sl@0: 		{
sl@0: 		// locks cannot be removed from a failed transaction, so release before failing
sl@0: 		TServerResources::iObserver->ReleaseTransactionLock(aTransactor,iSimRep->Uid());
sl@0: 		aTransactor.SetFailed(aError, aErrorKey);
sl@0: 		}
sl@0: 	return aError; // to allow "return FailTransaction(error, errorKey);" - error written once
sl@0: 	}
sl@0: 
sl@0: /** Fails all active transactions - except for the optional aExcludeTransactor, releasing locks.
sl@0: All transactions are failed with reason "KErrLocked" meaning they are "locked out".
sl@0: This should only be done to allow another agent to change values in the repository.
sl@0: Beware that all concurrent read/write transactions that are failed with KErrLocked are
sl@0: expected to retry the transactions straight afterwards - must be careful to allow their
sl@0: retry strategy to be successful.
sl@0: */
sl@0: void CSharedRepository::FailAllTransactions(const CRepositoryTransactor* aExcludeTransactor)
sl@0: 	{
sl@0:   	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());
sl@0:   	ASSERT(shrepinfo);
sl@0: 	TSglQueIter<CRepositoryTransactor> transIter(shrepinfo->iTransactors);  	
sl@0: 	CRepositoryTransactor* transactor;
sl@0: 	while ((transactor = transIter++) != NULL)
sl@0: 		{
sl@0: 		if (transactor != aExcludeTransactor)
sl@0: 			{
sl@0: 			FailTransaction(*transactor, KErrLocked, KUnspecifiedKey);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /** must currently be in active Read transaction. Does not fail
sl@0: transaction here if promotion to read/write failed.
sl@0: @return KErrNone if promoted, KErrLocked if not
sl@0: */
sl@0: TInt CSharedRepository::AttemptPromoteTransactionToReadWrite(CRepositoryTransactor& aTransactor)
sl@0: 	{
sl@0: 	// transactor should currently be in an active read transaction
sl@0: 	ASSERT(aTransactor.IsInActiveReadTransaction());
sl@0: 
sl@0:   	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());
sl@0:   	ASSERT(shrepinfo);
sl@0: 	// sanity check: must only be pessimistic reads active
sl@0: 	ASSERT(shrepinfo->iPessimisticTransactionLockCount > 0);
sl@0: 	// can promote only if there are no other active read transactions:
sl@0: 	if (1 == shrepinfo->iPessimisticTransactionLockCount)
sl@0: 		{
sl@0: 		// may only promote to exclusive read/write as it has the same commit semantics
sl@0: 		// as Read transaction: concurrent R/W must wait for reads to finish first.
sl@0: 		aTransactor.PromoteToExclusiveReadWrite();
sl@0: 		// lock value of -1 means the exclusive EReadWriteTransaction is active
sl@0: 		shrepinfo->iPessimisticTransactionLockCount = -1;
sl@0: 		return KErrNone;
sl@0: 		}
sl@0: 	return KErrLocked;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 	
sl@0: void CSharedRepository::ExternalizeCre(RWriteStream& aStream) const
sl@0: 	{
sl@0: 	iSimRep->ExternalizeCre(TServerResources::iPersistsVersion,aStream);
sl@0: 	}
sl@0: 
sl@0: void CSharedRepository::InternalizeCreL(RReadStream& aStream)
sl@0: 	{
sl@0: 	iSimRep->InternalizeCreL(aStream);
sl@0: 	}
sl@0: 	
sl@0: #ifdef	SYMBIAN_CENTREP_SUPPORT_MULTIROFS
sl@0: void CSharedRepository::InternalizeCreL(RReadStream& aStream,TUint8& aCreVersion)
sl@0: 	{
sl@0: 	iSimRep->InternalizeCreL(aStream,aCreVersion);
sl@0: 	}
sl@0: #endif	
sl@0: 
sl@0: void CSharedRepository::Notify(TUint32 aVal) const
sl@0: 	{
sl@0: 	if(iNotificationState)
sl@0: 		{
sl@0: 		TServerResources::iObserver->Notify(iSimRep->Uid(), aVal);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TBool CSharedRepository::IsTransactionActive()
sl@0: 	{
sl@0:   	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());
sl@0:   	if (shrepinfo)
sl@0:   		{
sl@0: 		return (shrepinfo->iPessimisticTransactionLockCount != 0) ||
sl@0: 			(shrepinfo->iNumActiveConcurrentReadWriteTransactions > 0);
sl@0:   		}
sl@0:   	return EFalse;  		
sl@0: 	}
sl@0: 
sl@0: RSettingsArray& CSharedRepository::GetSettings()
sl@0: 	{
sl@0: 	return iSimRep->SettingsArray();
sl@0: 	}