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

	}