// 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 "panic.h"

#include "srvdefs.h"

#include "srvres.h"

#include "shrepos.h"

#include "srvrepos.h"

#include "srvparams.h"

#ifdef SYMBIAN_CENTRALREPOSITORY_PARANOID_CHECKING

/** Validates that the required invariants hold: (1) ordered by ascending key value (2) key uniqueness.

Panics upon violation.

*/

void RSettingsArray::ValidateInvariantProperties() const

	{

	if (Count() > 0)

		{

		const TServerSetting* prev = &( operator[](0) );

		const TServerSetting* curr = prev + 1;

		const TServerSetting* upperBound = prev + Count() - 1;

		while(curr <= upperBound)

			{

			// future: should replace with diagnostic panic code

			ASSERT(curr->Key() > prev->Key());

			prev = curr;

			++curr;

			}

		}

	}

/** Validates that the required invariants hold for the given setting pointer array: 

(1) ordered by ascending key value (2) key uniqueness. Panics upon violation.

*/

void RSettingsArray::ValidateInvariantProperties(const RSettingPointerArray& aPtrArray)

	{

	if (aPtrArray.Count() > 0)

		{

		const TServerSetting** prev = const_cast<const TServerSetting**>( &(aPtrArray[0]) );

		const TServerSetting** curr = prev + 1;

		const TServerSetting** upperBound = prev + aPtrArray.Count() - 1;

		while(curr <= upperBound)

			{

			// future: should replace with diagnostic panic code

			ASSERT((*curr)->Key() > (*prev)->Key());

			prev = curr;

			++curr;

			}

		}

	}

#endif

/** Returns pointers to all settings whose key matches all bits of the target id also included

in the bitwise mask.

@param	aTargetKey Bit pattern to match

@param	aMask Bitwise mask. Where bits are set the corresponding bit in aTargetKey is significant, ie

		AND behaviour conventional with masking

@param	aMatches Returns pointers to all settings with keys matching the mask, in ascending key order. The

		caller should ensure it is appropriately constructed for the likely growth pattern.

@return	Error code. aMatches may be modified even upon error return but the contents must not be relied upon.

*/

TInt RSettingsArray::Find(TUint32 aTargetKey, TUint32 aMask, RSettingPointerArray& aMatches) const

	{

#ifdef SYMBIAN_CENTRALREPOSITORY_PARANOID_CHECKING

	ValidateInvariantProperties();

#endif

	aMatches.Reset();

	// Find the first setting with key >= the lowest possible match

	const TInt upperIdx = Count() - 1;

	const TUint32 maskedTarget = aTargetKey & aMask;

	TInt lowerIdx;

	FindInUnsignedKeyOrder(TServerSetting(maskedTarget), lowerIdx);

	if(lowerIdx > upperIdx)

		{

		return KErrNone;

		}

	// this simply traverses the settings from the first possible match to the last. For masks with

	// only with higher bits this would be wasteful - in principle could jump to next possible match start

	// with another Find...() call. However logic more complex and counterproductive in some cases; would

	// need some heuristic such as probing N settings ahead of current point and only invoking the refind

	// if that still falls below the next range start, where N would allow for the cost of the binsearch

	// and other book-keeping (for real smartness construct a new RArray from the current point onwards,

	// so binsearch excludes the already known infertile preceding settings). Only worth pursuing after

	// profiling.

	const TUint32 upperMatchingKey = aTargetKey | ~aMask;

	const TServerSetting* setting = &( operator[](lowerIdx) );

	const TServerSetting* upperBound = setting + (upperIdx - lowerIdx);

	while(setting <= upperBound && setting->Key() <= upperMatchingKey)

		{

		if((setting->Key() & aMask) == maskedTarget)

			{

			TInt err = aMatches.Append(setting);

			// Small optimisation of not testing err in while() condition, presuming

			// that Append() far less common than key tests, ie repeatedly testing err

			// is wasteful. However (arguably) makes code more complex

			if(err != KErrNone)

				{

				aMatches.Reset();

				return err;

				}

			}

		++setting;

		}

	return KErrNone;

	}

/** Given source and destination arrays of settings, replaces the destination with the union of the

arrays. The properties of ascending key order and key uniqueness are preserved: where a key is common

to both arrays the source setting is kept, excepting where the source setting is flagged as deleted, which

simply deletes the destination

@param	aDst destination settings array

@param	aSrc source settings array

@return Error code. If not KErrNone then the contents of aDst are may have been modified and must be

		disregarded

@post	aDst contains the union and matches the setting array invariant

*/

TInt RSettingsArray::Merge(RSettingPointerArray& aDst, const RSettingPointerArray& aSrc)

	{

	const TServerSetting** srcBound;

	const TServerSetting** srcPtr;

	TInt count = aSrc.Count();

	if(count > 0)

		{

		srcPtr = const_cast<const TServerSetting**>( &(aSrc[0]) );

		srcBound = srcPtr + count;

		}

	else

		{

		srcPtr = NULL;

		srcBound = NULL;

		}

	TInt dstIdx = 0;

	const TServerSetting** dstPtr=NULL;

	const TServerSetting** dstBound=NULL;

	// The approach taken here of inserting entries one at a time is necessarily inefficient

	// given the RPointerArray interface, but may be adequate for the projected (small) use. For 

	// greater efficiency the ability to insert ranges is required, ie probably custom array code

	while(srcPtr < srcBound)

		{

		if (aDst.Count() > 0)

			{

			dstBound = const_cast<const TServerSetting**>( &(aDst[0]) ) + aDst.Count();

			dstPtr=const_cast<const TServerSetting**>( &(aDst[0]) )+ dstIdx;

			}

		const TUint32 srcKey = (*srcPtr)->Key();

		while(dstPtr < dstBound && srcKey > (*dstPtr)->Key())

			{

			++dstPtr;

			++dstIdx;

			}

		// Three possibilities: end of dst reached (append src), src and dst match (replace dst), 

		// and dst now greater than src (insert src)

		if((dstPtr == dstBound || (*dstPtr)->Key() > srcKey))

			{

			if(!(*srcPtr)->IsDeleted())	// drop deleted records

				{

				TInt ret = aDst.Insert(*srcPtr, dstIdx);	// presumes insert at end == append

				if(ret != KErrNone)

					{

					return ret;

					}

				++dstIdx;

				}

			}

		else

			{

			// Src key matches dst, replace or delete dst

			if(!(*srcPtr)->IsDeleted())

				{

				*dstPtr= *srcPtr;

				++dstIdx;

				}

			else

				{

				// may be more efficient ways of handling remove

				aDst.Remove(dstIdx);

				--dstBound;

				}

			}

		++srcPtr;

		}

#ifdef SYMBIAN_CENTRALREPOSITORY_PARANOID_CHECKING

	RSettingsArray::ValidateInvariantProperties(aDst);

#endif

	return KErrNone;

	}

CSharedRepository::CSharedRepository(TUid aUid) :

	iSettings(), iUid(aUid),

	iSinglePolicies(KGranularity),

	iTransactors(_FOFF(CRepositoryTransactor, iLink))

	{

	iPersistsIniFileExists = ETrue;

	// 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 == EReadTransaction);

	ASSERT(CRepository::EConcurrentReadWriteTransaction == EConcurrentReadWriteTransaction);

	ASSERT(CRepository::EReadWriteTransaction == EReadWriteTransaction);

	}

CSharedRepository::~CSharedRepository()

	{

	// sanity check that no transactions are active

	ASSERT(!IsTransactionActive());

	// check transactor queue is empty - note this includes failed transactions

	ASSERT(NULL == (CRepositoryTransactor*)TDblQueIter<CRepositoryTransactor>(iTransactors));

	iSinglePolicies.ResetAndDestroy();

	iDeletedSettings.Close();

	}

TUid CSharedRepository::Uid() const

	{

	return iUid;

	}

/**

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()

	{

	TRAPD(error, DoCommitChangesL());

	if (error != KErrNone)

		{

		ResetContent();

		}

	return error;

	}

/** Merges the aChanges settings into array. Is used for

	Transaction merges

	Restore merges

	SWI merges

	Works as follows:

(a) EDeleted settings in aChanges destroy the corresponding setting in this array (if any)

(b) Where matching settings exist in both arrays, data from aChanges replaces originals. 

    Matching depends on aKeyOnly parameter's value. If true, matching is only

    based on key. If false, settings values will be compared

    For SWI merges this replacement is also dependent on whether the setting has been modified

(c)	aMergeType is the merge type

Future: All descriptors are deeply copied; must change to use shallow copy for greater efficiency.

@post Following a requirement that notifications are only made if values have changed:

1. Settings flagged as deleted without a counterpart in the persistent array are removed from aChanges.

2. Where the new value and the existing value are the same, the setting is removed from aChanges.

*/

TInt RSettingsArray::MergeArray(RSettingsArray& aChanges, RArray<TUint32> & aDeletedSettings, TMergeType aMergeType, TBool aKeyOnly)

	{

	TInt error = KErrNone;

	TInt numChanges;

	TInt i;

	// For downgrade remove SWI only keys

	if(aMergeType==ESWIDowngradeMerge)

		{

		numChanges = Count();

		i = 0;

		while ((i < numChanges) && (KErrNone == error))

			{

			TServerSetting source = operator[](i);

			// find index of item in array matching the index of this change

			TInt targetIndex = aChanges.FindIndex(source);

			if (targetIndex == KErrNotFound)

				{

				// If key is default and wasn't in the ROM, it was an install key

				// so remove it

				if(source.IsClean())

					{

					DeleteElement(i);

					--numChanges;

					--i;

					}

				}

			++i;

			}

		}

	numChanges = aChanges.Count();

	i=0;

	while ((i < numChanges) && (KErrNone == error))

		{

		const TServerSetting& source = aChanges[i];

		// find index of item in array matching the index of this change

		TInt targetIndex = FindIndex(source);

		if (targetIndex == KErrNotFound)

			{

			if (source.IsDeleted())

				{

				// remove setting that is flagged as deleted to prevent notification

				aChanges.DeleteElement(i);

				i--;

				numChanges--;

				}

			else

				{

				// add the new setting

				TServerSetting newSetting(source.Key());

				error = newSetting.Replace(source);

				if (error == KErrNone)

					{

					error = OrderedInsert(newSetting);

					TInt deletedSetting = aDeletedSettings.FindInUnsignedKeyOrder(source.Key());

					if (KErrNotFound != deletedSetting)

						{

						aDeletedSettings.Remove(deletedSetting) ;

						}

					if (error != KErrNone)

						{

						newSetting.Reset();

						}

					}

				}

			}

		else

			{

			if (source.IsDeleted())

				{

				// Retain "deleted element" state for settings marked for backup so that

				// we can persist state correctly across a backup/restore cycle.

				if (operator[](targetIndex).Meta() & KMetaBackup)

					{

						aDeletedSettings.InsertInUnsignedKeyOrder(source.Key()) ;

					}

				DeleteElement(targetIndex);

				}

			else

				{

				TServerSetting& target = operator[](targetIndex);

				if ((target == source) && (aKeyOnly==EFalse))

					{

					// value not changing: remove setting to prevent notification

					// Note that for SWI merges, settings are not deleted from 

					// aChanges unless they are marked with EDeleted.

					aChanges.DeleteElement(i);

					i--;

					numChanges--;

					}

				else

					{						

					if( (aMergeType==ESWIUpgradeMerge) || (aMergeType==ESWIDowngradeMerge))

						{

						if(target.IsClean())

							{

							error = target.Replace(source);

							}

						else

							{

							// value not changing: remove setting to prevent notification

							aChanges.DeleteElement(i);

							i--;

							numChanges--;

							}

						}

					else

						{

						error = target.Replace(source);

						}

					}

				}

			}

		i++;

		}

	aDeletedSettings.Compress();

	return error;

	}

// 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 = iSettings.MergeArray(aTransactor.iTransactionSettings, iDeletedSettings, ETransactionMerge, EFalse);

	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();

		}

	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)

	{

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

			}

		}

	}

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

	{

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

		return KErrAlreadyExists;

	SetMetaDataOnRead( aSetting, aSingleMetaFound);

	TUint32 key = aSetting.Key();

	aSetting.SetAccessPolicy(aPolicy);

	iSettings.OrderedInsertL(aSetting);

	Notify(aSetting.Key());

	return KErrNone;

	}

// 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 = iSettings.Find(aId);

	if(!s)

		return KErrNotFound;

	iSettings.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 = iSettings.Find(aId);

	if(!s)

		return KErrNotFound;

	iSettings.Remove(aId);

	Notify(aId);

	return KErrNone;

	}

TInt CSharedRepository::ResetNoPersistL(TServerSetting& aSetting)

	{

	TServerSetting* s = iSettings.Find(aSetting.Key());