// Copyright (c) 2008-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:

 // simrepos.cpp

 // 

 //

 #include "heaprepos.h"

 CHeapRepository* CHeapRepository::NewL(TUid aUid)

 	{

 	CHeapRepository* repos=new (ELeave) CHeapRepository(aUid);

 	return repos;

 	}

 CHeapRepository::CHeapRepository(TUid aUid)

 	:iSettings(),iUid(aUid),iSinglePolicies(KGranularity)

 	{

 	}

 CHeapRepository::~CHeapRepository()

 	{

 	iSinglePolicies.ResetAndDestroy();

 	iRangePolicies.Close();

 	iDeletedSettings.Close();

 	iSettings.Close();

 	iRangeMeta.Close();

 	}

 /**

 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 CHeapRepository::CommitChanges(RFs& aFs,TUint8 aPersistVersion,const TDesC& aTargetFilePath)

 	{

 	TRAPD(error, DoCommitChangesL(aFs,aPersistVersion,aTargetFilePath));

 	if (error != KErrNone)

 		{	

 		//If the commit fails reset the repository as it is in an inconsistent state

 		ResetContent();

 		}

 	return error;

 	}	

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

 	{

 	TInt isMetaFlagSet = aSetting.Meta() & KMetaDefaultValue;

 	if(!aSingleMetaFound)

 		// No single metadata set for this key

 		{

 		// First check for a matching "range" default metadata

 		// setting

 		TSettingsDefaultMeta* defaultMeta = iRangeMeta.Find(aSetting.Key());

 		if (defaultMeta)

 			{

 			if (isMetaFlagSet)

 				//sets a default meta data

 				//also sets the flag back to indicate that it is a default setting from ROM 

 				//or previous install so it can be replaced later with a new one. 

 				aSetting.SetMeta(defaultMeta->GetDefaultMetadata() | KMetaDefaultValue);

 			else

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

 			}

 		else

 			{

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

 			if (isMetaFlagSet)	

 				aSetting.SetMeta(iDefaultMeta | KMetaDefaultValue) ;

 			else

 				aSetting.SetMeta(iDefaultMeta) ;

 			}

 		}

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 #ifdef CENTREP_CONV_TOOL

 	if (aSingleMetaFound && aSetting.IsClean() && !aSetting.IsIndividualMeta())

 		aSingleMetaFound=EFalse;

 #endif	

 	aSetting.SetIndividualMeta(aSingleMetaFound);

 #endif			

 	}

 TInt CHeapRepository::Create(TServerSetting& aSetting, TSettingsAccessPolicy* &aPolicy, TBool aSingleMetaFound)

 	{

 	if(iSettings.Find(aSetting.Key()))

 		return KErrAlreadyExists;

 	SetMetaDataOnRead( aSetting, aSingleMetaFound);

 	aSetting.SetAccessPolicy(aPolicy);

 	return iSettings.OrderedInsert(aSetting);

 	}

 // Comparison relation to allow single policies to be inserted in order

 TInt CHeapRepository::CompareKeyIds(const TSettingsAccessPolicy& aSinglePolicy, const TSettingsAccessPolicy& aSinglePolicyIndexItem)

 	{

 	if(aSinglePolicy.iLowKey==aSinglePolicyIndexItem.iLowKey)

 		return 0;

 	return (aSinglePolicy.iLowKey < aSinglePolicyIndexItem.iLowKey)?-1:1;

 	}

 // Identity relation to allow single policy for a given key to be found

 TBool CHeapRepository::SinglePolicyMatchOnKey(const TSettingsAccessPolicy& aSinglePolicy, const TSettingsAccessPolicy& aSinglePolicyIndexItem)

 	{

 	return aSinglePolicy.iLowKey==aSinglePolicyIndexItem.iLowKey;

 	}

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

 const TSecurityPolicy& CHeapRepository::GetFallbackReadAccessPolicy(TUint32 aId)

 	{

 	return *(GetFallbackAccessPolicy(aId)->GetReadAccessPolicy());

 	}

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

 const TSecurityPolicy& CHeapRepository::GetFallbackWriteAccessPolicy(TUint32 aId)

 	{

 	return *(GetFallbackAccessPolicy(aId)->GetWriteAccessPolicy());

 	}

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

 TSettingsAccessPolicy* CHeapRepository::GetFallbackAccessPolicy(TUint32 aId

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 	,TBool aSkipSingle

 #endif

 	)

 	{

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	if (!aSkipSingle)

 		{

 #endif		

 		// Check for single policy

 		TSettingsAccessPolicy policy(aId);

 		TIdentityRelation<TSettingsAccessPolicy> identity(SinglePolicyMatchOnKey);

 		TInt index = iSinglePolicies.Find(&policy, identity);

 		if(KErrNotFound != index)

 			return iSinglePolicies[index];

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 		}

 #endif		

 	// check if the aId falls into any range specified in the ini file

 	TSettingsAccessPolicy* rangePolicy = iRangePolicies.Find(aId);

 	if(rangePolicy)

 		return rangePolicy;

 	// If no single policy or range policy, return default policy

 	return &iDefaultPolicy;

 	}

 // this function saves idividual meta as well

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

 	{

 	TBool singleReadPolicyFound;

 	TBool singleWritePolicyFound;

 	TSecurityPolicy singleReadPolicy;

 	TSecurityPolicy singleWritePolicy;

 	TInt err=aFile.ReadSettingL(aSetting,singleReadPolicy, singleWritePolicy, singleReadPolicyFound, singleWritePolicyFound, aSingleMetaFound);

 	if(err!=KErrNone)

 		return err;

 	// Set up single policies

 	if(!singleReadPolicyFound)

 		singleReadPolicy=GetDefaultReadAccessPolicy();

 	if(!singleWritePolicyFound)

 		singleWritePolicy=GetDefaultWriteAccessPolicy();

 	aSetting.PushL();

 	if(singleReadPolicyFound || singleWritePolicyFound)

 		{

 		aPolicy=new (ELeave) TSettingsAccessPolicy(singleReadPolicy,singleWritePolicy,aSetting.Key());

 		CleanupStack::PushL(aPolicy);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 		//reused single setting high key and mask to indicate whether read or write has been specified

 		//or they are just a default policy

 		if (singleReadPolicyFound)

 			aPolicy->iHighKey=1;

 		if (singleWritePolicyFound)

 			aPolicy->iKeyMask=1;

 #endif		

 		TLinearOrder<TSettingsAccessPolicy> order(&CHeapRepository::CompareKeyIds);

 		iSinglePolicies.InsertInOrderL(aPolicy,order);

 		CleanupStack::Pop(aPolicy);

 		}

 	else

 		{

 		// check if the aId falls into any range specified in the ini file

 		// otherwise set policy to default policy

 		TSettingsAccessPolicy* rangePolicy = iRangePolicies.Find(aSetting.Key());

 		if(rangePolicy)

 			aPolicy=rangePolicy;

 		else

 			aPolicy=&iDefaultPolicy;

 		}

 	aSetting.Pop();

 	return err;

 	}

 #ifdef CENTREP_CONV_TOOL

 void CHeapRepository::DoCommitChangesToIniFileL(RFs& aFs,const TDesC& aOutFileName

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 	,TUint32 aCreVersion

 #endif

 	)

 	{

 	CIniFileOut* out = CIniFileOut::NewLC(aFs,aOutFileName);

 	out->WriteHeaderL();

 	out->WriteOwnerSectionL(iOwner);

 	out->WriteTimeStampL(iTimeStamp);

 	out->WriteMetaDataL(iDefaultMeta, iRangeMeta);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	out->WritePlatSecL(GetDefaultAccessPolicy(), iRangePolicies,aCreVersion);

 #else

 	out->WritePlatSecL(GetDefaultReadAccessPolicy(), GetDefaultWriteAccessPolicy(), iRangePolicies);

 #endif	

 	out->WriteMainSectionHeaderL();

 	for(TInt i=0; i<iSettings.Count(); i++)

 		{

 		const TServerSetting& setting = iSettings[i];

 		if (setting.HasAccessPolicy() && (iSinglePolicies.Find(setting.AccessPolicy()) != KErrNotFound))

 			{

 			out->WriteSettingL(setting, *setting.AccessPolicy()

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS			

 			,aCreVersion

 #endif			

 			);

 			}

 		else

 			{

 			out->WriteSettingL(setting

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS			

 			,aCreVersion

 #endif			

 			);

 			}

 		}

 	out->CommitL();

 	CleanupStack::PopAndDestroy(out);//out

 	}

 #endif

 void CHeapRepository::DoCommitChangesL(RFs& aFs,TUint8 aPersistVersion,const TDesC& aTargetFilePath) 

 	{

 	CCreGenerator::CommitChangesToCreL(aFs,aPersistVersion,*this, aTargetFilePath);

 	}	

 /**

 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.

 @leave System-wide error codes.

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

 				   object is partially initialised.

 @leave KErrCorrupt Corrupted repository file.

 */

 void CHeapRepository::ReloadContentL(CIniFileIn& aIniFile)

 	{

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

 	if(!IsEmpty())

 		{

 		User::Leave(KErrGeneral);

 		}

 	TInt err = ReloadContentExceptSettingsL(aIniFile);

 	if(err == KErrCorrupt)

 		{

 		User::Leave(err);

 		}

 	CleanupClosePushL(iRangeMeta);

 	CleanupClosePushL(iRangePolicies);

 	// Settings

 	TServerSetting setting;

 	TSettingsAccessPolicy* policy;

 	TBool singleMetaFound;

 	TCleanupItem tc(SinglePoliciesCleanup, &iSinglePolicies);

 	CleanupStack::PushL(tc);	

 	CleanupClosePushL(iSettings);

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

 		{

 		setting.PushL();

 		if(iSettings.IsDefault())

 			{

 			setting.SetClean();			

 			}

 		User::LeaveIfError(Create(setting, policy, singleMetaFound));

 		setting.Pop();

 		}

 	if(err == KErrNotFound)			

 		{

 		err = KErrNone;

 		}

 	User::LeaveIfError(err);

 	CleanupStack::Pop(4,&iRangeMeta);

 	}

 /**

 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 

 CHeapRepository object.

 */

 void CHeapRepository::ResetContent()

 	{

 	iSettings.Reset();

 	iOwner = KNullUid;

 	iTimeStamp = TTime(0);

 	for (TInt i=0;i<iSinglePolicies.Count();i++)

 		{

 		delete iSinglePolicies[i];

 		}

 	iSinglePolicies.Reset();

 	iRangePolicies.Reset();

 	TSecurityPolicy emptyPolicy=TSecurityPolicy();

 	iDefaultPolicy = TSettingsAccessPolicy(emptyPolicy,emptyPolicy, KUnspecifiedKey);

 	iDefaultMeta = 0;

 	iRangeMeta.Reset();

 	}

 void CHeapRepository::CreateRepositoryFromCreFileL(RFs& aFs,const TDesC& aFilePath )

 	{

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	TUint8 dummyVersion;	

 	CCreGenerator::CreateReposFromCreL(aFs,*this, aFilePath,dummyVersion);

 #else

 	CCreGenerator::CreateReposFromCreL(aFs,*this, aFilePath);

 #endif	

 	}

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

 void CHeapRepository::CreateRepositoryFromCreFileL(RFs& aFs,const TDesC& aFilePath,TUint8& aCreVersion)

 	{	

 	CCreGenerator::CreateReposFromCreL(aFs,*this, aFilePath,aCreVersion);

 	}

 #endif

 void CHeapRepository::ExternalizeCre(TUint8 aPersistVersion,RWriteStream& aStream) const

 	{

 	CCreGenerator::ExternalizeCre(aPersistVersion,*this, aStream);

 	}

 void CHeapRepository::InternalizeCreL(RReadStream& aStream)

 	{

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	TUint8 dummyVersion;

 	CCreGenerator::InternalizeCreL(*this, aStream,dummyVersion);

 #else

 	CCreGenerator::InternalizeCreL(*this, aStream);

 #endif	

 	}

 void CHeapRepository::SinglePoliciesCleanup(TAny *aPtr)

 	{

 	static_cast<RPointerArray<TSettingsAccessPolicy>*>(aPtr)->ResetAndDestroy();

 	}

 TInt CHeapRepository::ReloadContentExceptSettingsL(CIniFileIn& aIniFile)

 	{

 	// Look for an "owner" section

 	TUint32 uidValue(KNullUid.iUid);

 	TInt err = aIniFile.ReadOwnerSectionL(uidValue);

 	if(err == KErrCorrupt)

 		{

 		return err;

 		}

 	iOwner.iUid = uidValue;

 	// Timestamp

 	TTime timeStamp (0);

 	err = aIniFile.ReadTimeStampSectionL(timeStamp);

 	if(err == KErrCorrupt)

 		{

 		return err;

 		}

 	iTimeStamp=timeStamp;

 	// Metadata

 	err = aIniFile.ReadDefaultMetaSecSectionL(iDefaultMeta, iRangeMeta);

 	// Even if err == KErrCorrupt, some items might have already been placed in the array

 	CleanupClosePushL(iRangeMeta);

 	if(err == KErrCorrupt)

 		{

 		CleanupStack::PopAndDestroy(&iRangeMeta);

 		return err;

 		}

 	// Default read/write policies

 	TBool gotDefaultReadPolicy;

 	TBool gotDefaultWritePolicy;

 	TSecurityPolicy defaultReadPolicy;

 	TSecurityPolicy defaultWritePolicy;

 	err = aIniFile.ReadPlatSecSectionL(defaultReadPolicy, gotDefaultReadPolicy,

 									   defaultWritePolicy, gotDefaultWritePolicy,

 									   iRangePolicies);

 	// Even if err == KErrCorrupt, some items might have already been placed in the array

 	CleanupClosePushL(iRangePolicies);	

 	if(err == KErrCorrupt)

 		{

 		CleanupStack::PopAndDestroy(2,&iRangeMeta);

 		return err;

 		}

 	iDefaultPolicy = TSettingsAccessPolicy(defaultReadPolicy,defaultWritePolicy, KUnspecifiedKey);

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	if (gotDefaultReadPolicy)

 		iDefaultPolicy.iHighKey=1;

 	if (gotDefaultWritePolicy)

 		iDefaultPolicy.iKeyMask=1;

 #endif	

 	CleanupStack::Pop(2,&iRangeMeta);

 	return KErrNone;

 	}

 TBool CHeapRepository::IsEmpty()

 	{

 	if(iSettings.Count() != 0 || iRangeMeta.Count() != 0 ||

 	   iSinglePolicies.Count() != 0 || iRangePolicies.Count() != 0)

 		{

 		return EFalse;

 		}

 	return ETrue;

 	}