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

//

#include "srvdefs.h"

#include "srvres.h"

#include "shrepos.h"

#include "srvrepos_noc.h"

#include "obsrvr_noc.h"

#include "srvparams.h"

CSharedRepository* CSharedRepository::NewL(TUid aUid)

	{

	CSharedRepository* self = new(ELeave) CSharedRepository();

	CleanupStack::PushL(self);

	self->ConstructL(aUid);

	CleanupStack::Pop(self);

	// debug check that CRepository::TTransactionMode modes match those used internally

	// from CRepositoryTransactor: internal state logic relies on this

	// there should be a better location for these checks...

	ASSERT(CRepository::EReadTransaction == static_cast<CRepository::TTransactionMode>(EReadTransaction));

	ASSERT(CRepository::EConcurrentReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EConcurrentReadWriteTransaction));

	ASSERT(CRepository::EReadWriteTransaction == static_cast<CRepository::TTransactionMode>(EReadWriteTransaction));

	return self;

	}

void CSharedRepository::ConstructL(TUid aUid)

	{

	iSimRep = CHeapRepository::NewL(aUid);

	}

CSharedRepository::CSharedRepository() : iNotificationState(ETrue)

	{

	}

CSharedRepository::~CSharedRepository()

	{

	if (iSimRep)

		{

		delete iSimRep;

		}

	}

TUid CSharedRepository::Uid() const

	{

	return iSimRep->Uid();

	}

/**

Stores the repository in-memory content to the related repository file on drive C.

If the operation fails, the in-memory content won't match the content of 

the repository file (which will be kept as it was before the CommitChangesL() call).

In order to keep the consistency, the in-memory repository content is deleted now

and restored later, on the next repository operation.

*/

TInt CSharedRepository::CommitChanges(TCentRepLocation aLocation)

	{

	iInconsistentData=ETrue;

	HBufC* filePath(NULL);	   

	TRAPD(err,TServerResources::CreateRepositoryFileNameL(filePath,iSimRep->Uid(),aLocation,ECre));	

	if (err!=KErrNone)

		{

		iSimRep->ResetContent();

		return err;		

		}

	// should not be committing while transactions are still active

	ASSERT(!IsTransactionActive());

	TInt ret=iSimRep->CommitChanges(TServerResources::iFs,TServerResources::iPersistsVersion,*filePath);

	if (ret==KErrNone)

		{

		iInconsistentData=EFalse;	

		}

	delete filePath;

	return ret;

	}

// merge transaction settings (which may include entries flagged as deleted), persist and notify

// private method relies on calling code to ensure it is permitted to make changes here.

// if this method is committing any changes, it cancels all other sessions' transactions

TInt CSharedRepository::DoCommitTransactionSettings(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo)

	{

	aKeyInfo = KUnspecifiedKey;

	if (0 == aTransactor.iTransactionSettings.Count())

		{

		aKeyInfo = 0; // == number of settings modified

		return KErrNone; // nothing to do

		}

	TInt error = iSimRep->SettingsArray().MergeArray(aTransactor.iTransactionSettings, iSimRep->DeletedSettingsArray(), ETransactionMerge);

	TInt numChanges = aTransactor.iTransactionSettings.Count();

	if (numChanges == 0)

		{

		if (error == KErrNone)

			{

			aKeyInfo = 0; // no changes

			}

		// no changes were made, so the internal cache is still valid.

		// This could be because there were no changes: empty list, only deletes on

		// non-existent items (a setting created and deleted in the transaction),

		// or because of error, such as failure of an initial realloc failure.

		return error;

		}

	if (error != KErrNone)

		{

		// the repository is corrupted. Dump it for lazy loading later

		ResetContent();

		// mark cache as inconsistent so it is reloaded.

		iInconsistentData = ETrue;	

		return error;	

		}

	if (error == KErrNone)

		{

		// changes have been made: fail all other sessions' transactions so we can commit

		FailAllTransactions(/*aExcludeTransactor=*/&aTransactor);

		error = CommitChanges(); // this already calls ResetContent() in case of failure

		}

	if (error == KErrNone)

		{

		// settings are now persistent on disk: we can now notify about the changes

		// following will notify about objects that are created and deleted in the transaction

		// this could be made faster by having a multiple Notify method.

		// That would also allow Notify messages to be more descriptive - ranges of Keys

		for (TInt i = 0; i < numChanges; i++)

			{

			Notify(aTransactor.iTransactionSettings[i].Key());

			}

		aKeyInfo = /*reinterpret_cast<TUint32>*/numChanges;

		}

	return error;

	}

void CSharedRepository::SetMetaDataOnRead(TServerSetting& aSetting, TBool aSingleMetaFound)

	{

	iSimRep->SetMetaDataOnRead(aSetting, aSingleMetaFound);

	}

void CSharedRepository::SetMetaDataOnCreate(TServerSetting& aNewSetting, TUint32* aMeta)

	{

	if(aMeta)

		{

		aNewSetting.SetMeta(*aMeta);

		}

	else

		{

		// No metadata specified. First check for a matching "range" default

		// metadata setting

		TSettingsDefaultMeta* defaultMeta = iSimRep->RangeMetaArray().Find(aNewSetting.Key());

		if (defaultMeta)

			{

			aNewSetting.SetMeta(defaultMeta->GetDefaultMetadata());

			}

		else

			{

			// Range value not found, try for a repository default

			aNewSetting.SetMeta(iSimRep->DefaultMeta());

			}

		}	

	}

void CSharedRepository::CreateL(TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool aFirstLoad, TBool aSingleMetaFound)

	{

	User::LeaveIfError(iSimRep->Create(aSetting, aPolicy, aSingleMetaFound));

	if (!aFirstLoad)

		{

		Notify(aSetting.Key());

		}

	}

// deletes an individual setting in the shared repository and makes it persistent

// if changes are made, all sessions' transactions are failed

TInt CSharedRepository::DeleteAndPersist(TUint32 aId)

	{

	TServerSetting* s = iSimRep->SettingsArray().Find(aId);

	if(!s)

		return KErrNotFound;

	iSimRep->SettingsArray().Remove(aId);

	// removed a setting, so must fail all sessions' transactions before commit possible

	FailAllTransactions(/*aExcludeTransactor=*/NULL);

	TInt error = CommitChanges();

	if (error == KErrNone)

		{

		Notify(aId);

		}

	return error;

	}

// deletes an individual setting without making it persistent

// must not be called while any sessions are in transactions

TInt CSharedRepository::DeleteNoPersist(TUint32 aId)

	{

	// should only be calling this if no transactions are active

	ASSERT(!IsTransactionActive());

	TServerSetting* s = iSimRep->SettingsArray().Find(aId);

	if(!s)

		return KErrNotFound;

	iSimRep->SettingsArray().Remove(aId);

	return KErrNone;	

	}

TInt CSharedRepository::ResetNoPersistL(TServerSetting& aSetting)

	{

	TServerSetting* s = iSimRep->SettingsArray().Find(aSetting.Key());

	if ((!s) || (*s != aSetting))

		{

		if (s)

			{

			// save access policy of setting

			TSettingsAccessPolicy* policy=s->AccessPolicy();

			s->Transfer(aSetting);

			// restore access policy of setting

			s->SetAccessPolicy(policy);

			}

		else

			{

			TServerSetting setting;

			setting.Transfer(aSetting);

			setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));

			setting.PushL();

			iSimRep->SettingsArray().OrderedInsertL(setting);

			TInt index = iSimRep->DeletedSettingsArray().FindInUnsignedKeyOrder(aSetting.Key());

			if (index != KErrNotFound)

				iSimRep->DeletedSettingsArray().Remove(index);

			setting.Pop();

			}

		}

	else

		{

		return KErrGeneral;

		}

	return KErrNone;

	}

// if changes are made, all sessions' transactions are failed

void CSharedRepository::ResetAndPersistL(TServerSetting& aSetting)

	{

	if (ResetNoPersistL(aSetting) == KErrNone)

		{

		// changed a setting, so must fail all sessions' transactions

		// before commit possible

		FailAllTransactions(/*aExcludeTransactor=*/NULL);

		CommitChangesL();

		Notify(aSetting.Key());

		}

	}

TInt CSharedRepository::ResetAllNoPersistL(CSharedRepository& aNewContent)

	{

	// mark cache as inconsistent in case Reset fails, so it is reloaded.

	iInconsistentData=ETrue;

	// should not change repository while transactions in progress: should fail them first

	ASSERT(!IsTransactionActive());

	TInt newCount = (aNewContent.iSimRep)->SettingsArray().Count();

	TInt count = iSimRep->SettingsArray().Count();

	TInt newIndex = 0;

	TInt index = 0;

	while(newIndex<newCount && index<count)

		{

		const TServerSetting& newSetting = (aNewContent.iSimRep)->SettingsArray()[newIndex];

		const TServerSetting& setting = iSimRep->SettingsArray()[index];

		TUint32 newKey = newSetting.Key();

		TUint32 key = setting.Key();

		if(newKey<key)

			{

			Notify(newKey);

			newIndex++;

			}

		else if(newKey==key)

			{

			if(newSetting!=setting)

				{

				Notify(key);

				}

			newIndex++;

			index++;

			}

		else if(newKey>key)

			{

			Notify(key);

			index++;

			}

		}

	while(newIndex<newCount)

		{

		Notify((aNewContent.iSimRep)->SettingsArray()[newIndex++].Key());

		}

	while(index<count)

		{

		Notify(iSimRep->SettingsArray()[index++].Key());

		}

	// Replace current settings with settings read from ROM, this 

	// will leave settings pointing to new single policies

	iSimRep->SettingsArray().AdoptL((aNewContent.iSimRep)->SettingsArray());

	// Reset policy pointers to point at this repositories policies

	newCount=iSimRep->SettingsArray().Count();

	for(TInt i=0; i<newCount;i++)

		{

		(iSimRep->SettingsArray())[i].SetAccessPolicy(NULL);

		TUint32 key = (iSimRep->SettingsArray())[i].Key();

		(iSimRep->SettingsArray())[i].SetAccessPolicy(GetFallbackAccessPolicy(key));

		}	

	iSimRep->DeletedSettingsArray().Reset();

	iInconsistentData=EFalse;

	return KErrNone;

	}

// returns the read security policy used if there is no per-setting policy at aId

const TSecurityPolicy& CSharedRepository::GetFallbackReadAccessPolicy(TUint32 aId)

	{

	return iSimRep->GetFallbackReadAccessPolicy(aId);

	}

// returns the write security policy used if there is no per-setting policy at aId

const TSecurityPolicy& CSharedRepository::GetFallbackWriteAccessPolicy(TUint32 aId)

	{

	return iSimRep->GetFallbackWriteAccessPolicy(aId);

	}

// Get pointer to security policy that applies to a given setting

TSettingsAccessPolicy* CSharedRepository::GetFallbackAccessPolicy(TUint32 aId

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TBool aSkipSingle

#endif	

	)

	{

	return iSimRep->GetFallbackAccessPolicy(aId

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,aSkipSingle

#endif	

	);

	}

TInt CSharedRepository::ReadSettingSavePolicyL(CIniFileIn& aFile,TServerSetting& aSetting, TSettingsAccessPolicy*& aPolicy, TBool& aSingleMetaFound)

	{

	return iSimRep->ReadSettingSavePolicyL(aFile, aSetting, aPolicy, aSingleMetaFound);

	}	

// Merge settings in this->iSettings with the iSettings of aMergeRep

// During an intsall/upgrade event aMergeRep will be created from the installed file

// During an upinstall event aMergeRep will be created from the ROM file

void CSharedRepository::MergeL(CSharedRepository& aMergeRep, TMergeType aMergeType)

	{

	// Process settings from main section - this updates values only

	User::LeaveIfError(GetSettings().MergeArray(aMergeRep.GetSettings(), iSimRep->DeletedSettingsArray(), aMergeType));

	//if the merging is due to a ROM Flash, we need to copy over both the NEW ROM keypsace global properties

	//(default access policies/metadata and range policies/metadata), individual policies, we then need to ensure

	//that the settings point at the correct individual policies and metadata.

	if (aMergeType==ERomFlash)

		{

		//copy the default/range/individual policy

		iSimRep->SetDefaultPolicy(aMergeRep.iSimRep->GetDefaultAccessPolicy());

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

		iSimRep->GetDefaultAccessPolicy().iHighKey=aMergeRep.iSimRep->GetDefaultAccessPolicy().iHighKey;

		iSimRep->GetDefaultAccessPolicy().iKeyMask=aMergeRep.iSimRep->GetDefaultAccessPolicy().iKeyMask;		

#endif		

		iSimRep->RangePolicyArray().Reset();

		TInt count=aMergeRep.iSimRep->RangePolicyArray().Count();

		iSimRep->RangePolicyArray().ReserveL(count);

		for (TInt i=0;i<count;i++)

			{

			iSimRep->RangePolicyArray().AppendL(aMergeRep.iSimRep->RangePolicyArray()[i]);

			}

		iSimRep->SinglePolicyArray().ResetAndDestroy();

		count=aMergeRep.iSimRep->SinglePolicyArray().Count();

		iSimRep->SinglePolicyArray().ReserveL(count);

		for (TInt i=0;i<count;i++)

			{

			iSimRep->SinglePolicyArray().AppendL(aMergeRep.iSimRep->SinglePolicyArray()[i]);

			}

		//now need to reset the aMergeRep single policies so it is not going to destroy the

		//individual policies as ownership has been transferred

		aMergeRep.iSimRep->SinglePolicyArray().Reset();

		//copy the default/range metadata

		iSimRep->SetDefaultMeta(aMergeRep.iSimRep->DefaultMeta());

		iSimRep->RangeMetaArray().Reset();

		count=aMergeRep.iSimRep->RangeMetaArray().Count();

		iSimRep->RangeMetaArray().ReserveL(count);		

		for (TInt i=0;i<count;i++)

			{

			iSimRep->RangeMetaArray().AppendL(aMergeRep.iSimRep->RangeMetaArray()[i]);

			}

		//set the timestamp,owner etc

		iSimRep->SetTimeStamp(aMergeRep.iSimRep->TimeStamp());

		iSimRep->SetOwner(aMergeRep.iSimRep->Owner());

		}

	// Update all access policies and meta

	for(TInt i=0; i<iSimRep->SettingsArray().Count();i++)

		{

		TServerSetting& setting= iSimRep->SettingsArray()[i];

		setting.SetAccessPolicy(GetFallbackAccessPolicy(setting.Key()));

		}	

	}

// Save timestamp of installed file 

void CSharedRepository::SetInstallTime(TTime aInstallTime)

	{

	iSimRep->SetTimeStamp(aInstallTime);

	}

// Handle creation or upgrade of file in install directory

void CSharedRepository::HandleUpdateMergeL(TTime aInstallFileTimeStamp, CSharedRepository& aInstallRep)

	{			

	MergeL(aInstallRep, ESWIUpgradeMerge);

	SetInstallTime(aInstallFileTimeStamp);	// Set merge timestamp		

	CommitChangesL();						// Commit changes to write system drive file

	// settings are now persistent on disk: we can now notify about the changes

	for (TInt i = 0; i < (aInstallRep.iSimRep)->SettingsArray().Count(); i++)

		{

		Notify((aInstallRep.iSimRep)->SettingsArray()[i].Key());

		}

	}

// Handle merge activity due to an uninstall

void CSharedRepository::HandleDeleteMergeL(CSharedRepository& aRomRep)

	{

	MergeL(aRomRep, ESWIDowngradeMerge);

	SetInstallTime(0);						// Reset timestamp			

	CommitChangesL();						// Commit changes to write system drive file

	// settings are now persistent on disk: we can now notify about the changes

	for (TInt i = 0; i < (aRomRep.iSimRep)->SettingsArray().Count(); i++)

		{

		Notify((aRomRep.iSimRep)->SettingsArray()[i].Key());

		}

	}

#ifdef CENTREP_CONV_TOOL

/**

Statement "iInconsistentData = ETrue;" must be the first statement in the method,

"iInconsistentData = EFalse;" must be the last. It is used for lasy-load implementation

for the repository and solves the problem that if CommitChangesL() fails the in-memory

repository data won't match the repository data, stored in the file.

This routine is being retained for testing purposes

*/

void CSharedRepository::DoCommitChangesToIniFileL(const TDesC& aOutFileName

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,TUint32 aCreVersion

#endif

	)

	{

	iInconsistentData=ETrue;

	// should not be committing while transactions are still active

	ASSERT(!IsTransactionActive());

	iSimRep->DoCommitChangesToIniFileL(TServerResources::iFs,aOutFileName

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	,aCreVersion

#endif	

	);

	iInconsistentData = EFalse;

	}

#endif //CENTREP_CONV_TOOL

/**

The method reloads the repository content from a repository file.

The current repository must be emptied (or must be empty already) before the call is made.

@param aIniFile A reference to CIniFileIn object, which will be used to load

				the repository content.

@param aFirstLoad is used to indicate whether the file is reloaded for first time, this is used to prevent

notification if not needed. For example file loading for merging purpose will not result in notification

@return KErrCorrupt Corrupted repository file.

		KErrNone	The repository content was seccessfully loaded into memory.

		KErrNotFound Setting not found in the file.

@leave System-wide error codes.

@leave KErrGeneral It's probably a programmer's error - current CSharedRepository 

				   object is partially initialised.

*/

TInt CSharedRepository::ReloadContentL(CIniFileIn& aIniFile, TBool aFirstLoad)

	{

	// Preconditions - CHeapRepository object should be an empty one.

	if(!iSimRep->IsEmpty())

		{

		User::Leave(KErrGeneral);

		}

	TInt err = iSimRep->ReloadContentExceptSettingsL(aIniFile);

	if(err == KErrCorrupt)

		{

		return err;

		}

	CleanupClosePushL(iSimRep->RangeMetaArray());

	CleanupClosePushL(iSimRep->RangePolicyArray());

	// Settings

	TServerSetting setting;

	TSettingsAccessPolicy* policy;

	TBool singleMetaFound;

	TCleanupItem tc(CHeapRepository::SinglePoliciesCleanup, &(iSimRep->SinglePolicyArray()));

	CleanupStack::PushL(tc);	

	CleanupClosePushL(iSimRep->SettingsArray());	

	while((err = ReadSettingSavePolicyL(aIniFile, setting, policy, singleMetaFound)) == KErrNone)

		{

		setting.PushL();

		if(iSimRep->SettingsArray().IsDefault())

			{

			setting.SetClean();			

			}

		CreateL(setting, policy, aFirstLoad, singleMetaFound);

		setting.Pop();

		}

	if(err == KErrNotFound)			

		{

		err = KErrNone;

		}

	if (err == KErrNone)

		{

		CleanupStack::Pop(4,&(iSimRep->RangeMetaArray()));		

		}

	else

		{

		CleanupStack::PopAndDestroy(4,&(iSimRep->RangeMetaArray()));		

		}

	return err;

	}

/**

Resets current repository data - actually all of them, which may be loaded from

the related ini file.

The iUid data member value is kept as it was at the moment of creation of 

CSharedRepository object.

*/

void CSharedRepository::ResetContent()

	{

	iSimRep->ResetContent();

	}

/**

This function is used to restore the notification, which was temporary disabled

when making RestoreConsistencyL() call.

@param aNotificationState It points to CObservable::iNotificationState data member, which 

						 controls the notification state - active or disabled.

@internalComponent

*/

static void RestoreNotification(void* aNotificationState)

	{

	TBool* notificationState = static_cast <TBool*> (aNotificationState);

	*notificationState = ETrue;

	}

/**

The method reloads the repository content from the related ini file if previous

CommitChangesL() has not completed successfully.

*/

void CSharedRepository::RestoreConsistencyL()

	{

	//Do nothing if previous CommitChangesL() completed successfully.

	if (!iInconsistentData)

		{

		return;

		}

	//Reset current repository data	

	ResetContent();

	//Disable notifications

	TCleanupItem restoreNotification(&RestoreNotification, &iNotificationState);

	CleanupStack::PushL(restoreNotification);

	iNotificationState = EFalse;

	//Reload the repository content from the related ini file

	DoRestoreConsistencyL();

	//Activate notifications

	CleanupStack::PopAndDestroy();//restoreNotification

	TCentRepLocation location = EPersists;

	HBufC* persistsTmpFilePath(NULL);

    //allocates memory on the heap

    TServerResources::CreateRepositoryFileNameLC(persistsTmpFilePath,iSimRep->Uid(),location,ETmp);

	// Remove any .tmp file

	// If a debug build - record error

	TInt fileDeleteErr=TServerResources::iFs.Delete(*persistsTmpFilePath);

	if ((fileDeleteErr != KErrNone) && (fileDeleteErr != KErrNotFound))

		{

		#ifdef _DEBUG

		RDebug::Print(_L("CHeapRepository::RestoreConsistencyL - Failed to delete file. Error = %d"), fileDeleteErr);

		#endif

		}

	CleanupStack::PopAndDestroy(persistsTmpFilePath);

	iInconsistentData=EFalse;

	}

/**

The method reloads the repository content from the related cre or ini file.

@leave System-wide error codes

*/	

void CSharedRepository::DoRestoreConsistencyL()

	{

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

	//note that the function below already handles the deletion of any corrupt file

	//in  non-rom location

	TInt ret=TServerResources::iObserver->CreateRepositoryL(this,EPersists);

	if (ret==KErrNotFound)

		{

		ret=TServerResources::iObserver->CreateRepositoryL(this,EInstall);

		if (ret==KErrNotFound)

			{	

			ret=TServerResources::iObserver->CreateRepositoryL(this,ERom);

			User::LeaveIfError(ret);

			}

		}

#else

	TCentRepLocation location;

	TInt err = FindLocationForFileL(location,iSimRep->Uid(),ECre);

	if (err != KErrNotFound)

		{

		User::LeaveIfError(CreateRepositoryFromCreFileL(location));

		return;

		}

	User::LeaveIfError(FindLocationForFileL(location,iSimRep->Uid(),EIni));

	HBufC* fileName(NULL);

    TServerResources::CreateRepositoryFileNameLC(fileName,iSimRep->Uid(),location,EIni);	

	CIniFileIn* iniFile = NULL;

	err = CIniFileIn::NewLC(TServerResources::iFs,iniFile,*fileName);

	if (err==KErrCorrupt && location!=ERom)

		{

		User::LeaveIfError(TServerResources::iFs.Delete(*fileName));

		}

	User::LeaveIfError(err);

	err = ReloadContentL(*iniFile);

	User::LeaveIfError(err);

	CleanupStack::PopAndDestroy(iniFile); //iniFile 

	CleanupStack::PopAndDestroy(fileName);	//fileName

#endif

	}

/**

This method looks for and sets a location for a given repository.

It is based on EAuto mode thus it goes through all locations in the

same order (EPersists - EInstall - ERom)  

@param aLocation - returns a location for a repository

@param aUid - id of a repository which location should be found

@param aType - repository file type (.txt or .cre) 

@return KErrNone if aLocation succesfully set for a given repository,

		KErrNotFound if a repository was not found in any locations.

@internalTechnology

*/

#ifndef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

TInt CSharedRepository::FindLocationForFileL(TCentRepLocation& aLocation,TUid aUid,const TCentRepFileType aType) const

    { 		

	if(TServerResources::CentrepFileExistsL(aUid, EPersists, aType))

	    {

	     aLocation = EPersists;

		 return KErrNone;

	    }

	if(TServerResources::CentrepFileExistsL(aUid, EInstall, aType))

		{

	     aLocation = EInstall;

		 return KErrNone;

	    }

	if(TServerResources::CentrepFileExistsL(aUid, ERom, aType))

		{

		aLocation = ERom;

		return KErrNone;

		}

	return KErrNotFound;

    }

#endif

TInt CSharedRepository::CreateRepositoryFromCreFileL( TCentRepLocation aLocation)

	{

	// Get file path name from location

    HBufC* filePath(NULL);

    TServerResources::CreateRepositoryFileNameLC(filePath,iSimRep->Uid(), aLocation,ECre);

    // Trap errors from repository creation so we can delete corrupt repositories

	TRAPD(error, iSimRep->CreateRepositoryFromCreFileL(TServerResources::iFs,*filePath));

	if(error!=KErrNone && error!=KErrNotFound && error!=KErrNoMemory)

		{

		error=KErrCorrupt;

		// store wasn't quite what we were expecting - can't return an error, can't leave

		// so all we can do is close the file, tidy up as best we can, and return corrupt 

		if (aLocation != ERom)

			{

			// If a debug build - record error

			TInt fileDeleteErr=TServerResources::iFs.Delete(*filePath);

			if (fileDeleteErr != KErrNone)

				{

				#ifdef _DEBUG

				RDebug::Print(_L("CSharedRepository::CreateRepositoryFromCreFileL - Failed to delete file. Error = %d"), fileDeleteErr);

				#endif

				}

			}

		}

	else if( error==KErrNoMemory)

		{

		User::Leave(KErrNoMemory);

		}

	CleanupStack::PopAndDestroy(filePath);

	return error;

	}

/** Attempts to start a transaction.

Guaranteed to succeed (return KErrNone) for EConcurrentReadWriteTransaction mode only.

@param aTransactor transactor attempting to start transaction

@param aMode type of transaction to be started

@pre transactor is not in a transaction

@return KErrNone if the transaction is started, KErrLocked if read/write locks prevented that

type of transaction from starting now, and KErrArgument for invalid aMode.

@post On returning KErrNone, transaction is started and read/write locks are obtained for it

in the shared repository. Any other return: transaction has not started.

*/

TInt CSharedRepository::StartTransaction(CRepositoryTransactor& aTransactor, TInt aMode)

	{

	// session can only be in one transaction

	ASSERT(!aTransactor.IsInTransaction());

  	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());

  	ASSERT(shrepinfo);

	switch (aMode)

		{

		case EConcurrentReadWriteTransaction:

			// can always start this type of transaction

			shrepinfo->iNumActiveConcurrentReadWriteTransactions++;

			break;

		case EReadTransaction:

			// negative lock means there is an active EReadWriteTransaction

			if (shrepinfo->iPessimisticTransactionLockCount < 0)

				{

				ASSERT(shrepinfo->iPessimisticTransactionLockCount == -1); // sanity check

				return KErrLocked;

				}

			// when non-negative lock equals number of active EReadTransactions.

			shrepinfo->iPessimisticTransactionLockCount++;

			break;

		case EReadWriteTransaction:

			// lock is zero if there are no active pessimistic transactions

			if (shrepinfo->iPessimisticTransactionLockCount != 0)

				{

				return KErrLocked;

				}

			// lock value of -1 means the exclusive EReadWriteTransaction is active

			shrepinfo->iPessimisticTransactionLockCount = -1;

			break;

		default:

			// not a valid transaction mode

			return KErrArgument;

		}

	aTransactor.AddToQueue(shrepinfo->iTransactors, aMode);

	return KErrNone;

	}

/**	Commit transaction

@return KErrNone on success, or error code.

@param aKeyInfo 

	on success (return KErrNone): aKeyInfo returns number of modified settings;

	on failure (other error code): KUnspecifiedKey

@pre transactor is in a transaction.

@post transactor is not in a transaction

*/

TInt CSharedRepository::CommitTransaction(CRepositoryTransactor& aTransactor, TUint32& aKeyInfo)

	{

	// calling code should have panicked the client if not in a transaction

	ASSERT(aTransactor.IsInTransaction());

	TInt result = aTransactor.iTransactionResult;

	if (aTransactor.IsInFailedTransaction())

		{

		ASSERT(result != KErrNone);

		aKeyInfo = aTransactor.iTransactionErrorKey;

		}

	else

		{

		ASSERT(result == KErrNone);

		ASSERT(aTransactor.iTransactionErrorKey == KUnspecifiedKey);

		aKeyInfo = 0;

		// must release locks otherwise shared repository will not commit changes

		// failed transactions have already released their locks

		TServerResources::iObserver->ReleaseTransactionLock(aTransactor,iSimRep->Uid());

		}

	// transactions that haven't made any changes can be closed at any time

	if (aTransactor.IsInActiveReadWriteTransaction() &&

		(aTransactor.iTransactionSettings.Count() > 0))

		{

		result = DoCommitTransactionSettings(aTransactor, aKeyInfo);

		}

	// transaction is complete - remove from queue

  	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());

  	ASSERT(shrepinfo);

	shrepinfo->iTransactors.Remove(aTransactor);

	//Remove the link to the next transaction

	aTransactor.iLink.iNext = NULL;

	aTransactor.Deque();

	return result;

	}

TInt CSharedRepository::FailTransaction(CRepositoryTransactor& aTransactor, TInt aError, TUint32 aErrorKey)

	{

	ASSERT(aError != KErrNone); // must fail for a reason

	if (aTransactor.IsInActiveTransaction())

		{

		// locks cannot be removed from a failed transaction, so release before failing

		TServerResources::iObserver->ReleaseTransactionLock(aTransactor,iSimRep->Uid());

		aTransactor.SetFailed(aError, aErrorKey);

		}

	return aError; // to allow "return FailTransaction(error, errorKey);" - error written once

	}

/** Fails all active transactions - except for the optional aExcludeTransactor, releasing locks.

All transactions are failed with reason "KErrLocked" meaning they are "locked out".

This should only be done to allow another agent to change values in the repository.

Beware that all concurrent read/write transactions that are failed with KErrLocked are

expected to retry the transactions straight afterwards - must be careful to allow their

retry strategy to be successful.

*/

void CSharedRepository::FailAllTransactions(const CRepositoryTransactor* aExcludeTransactor)

	{

  	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());

  	ASSERT(shrepinfo);

	TSglQueIter<CRepositoryTransactor> transIter(shrepinfo->iTransactors);  	

	CRepositoryTransactor* transactor;

	while ((transactor = transIter++) != NULL)

		{

		if (transactor != aExcludeTransactor)

			{

			FailTransaction(*transactor, KErrLocked, KUnspecifiedKey);

			}

		}

	}

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

*/

TInt CSharedRepository::AttemptPromoteTransactionToReadWrite(CRepositoryTransactor& aTransactor)

	{

	// transactor should currently be in an active read transaction

	ASSERT(aTransactor.IsInActiveReadTransaction());

  	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());

  	ASSERT(shrepinfo);

	// sanity check: must only be pessimistic reads active

	ASSERT(shrepinfo->iPessimisticTransactionLockCount > 0);

	// can promote only if there are no other active read transactions:

	if (1 == shrepinfo->iPessimisticTransactionLockCount)

		{

		// may only promote to exclusive read/write as it has the same commit semantics

		// as Read transaction: concurrent R/W must wait for reads to finish first.

		aTransactor.PromoteToExclusiveReadWrite();

		// lock value of -1 means the exclusive EReadWriteTransaction is active

		shrepinfo->iPessimisticTransactionLockCount = -1;

		return KErrNone;

		}

	return KErrLocked;

	}

void CSharedRepository::ExternalizeCre(RWriteStream& aStream) const

	{

	iSimRep->ExternalizeCre(TServerResources::iPersistsVersion,aStream);

	}

void CSharedRepository::InternalizeCreL(RReadStream& aStream)

	{

	iSimRep->InternalizeCreL(aStream);

	}

#ifdef	SYMBIAN_CENTREP_SUPPORT_MULTIROFS

void CSharedRepository::InternalizeCreL(RReadStream& aStream,TUint8& aCreVersion)

	{

	iSimRep->InternalizeCreL(aStream,aCreVersion);

	}

#endif	

void CSharedRepository::Notify(TUint32 aVal) const

	{

	if(iNotificationState)

		{

		TServerResources::iObserver->Notify(iSimRep->Uid(), aVal);

		}

	}

TBool CSharedRepository::IsTransactionActive()

	{

  	CObservable::TSharedRepositoryInfo* shrepinfo = TServerResources::iObserver->SharedRepositoryInfo(iSimRep->Uid());

  	if (shrepinfo)

  		{

		return (shrepinfo->iPessimisticTransactionLockCount != 0) ||

			(shrepinfo->iNumActiveConcurrentReadWriteTransactions > 0);

  		}

  	return EFalse;  		

	}

RSettingsArray& CSharedRepository::GetSettings()

	{

	return iSimRep->SettingsArray();

	}