// Copyright (c) 2004-2010 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 "obsrvr_noc.h"

#include "panic.h"

#include "shrepos.h"

#include "srvrepos_noc.h"

#include "log.h"

#include "cachemgr.h"

#define TRAP_UNIFIED(_unifiedLeave, _function)	\

	{ \

	TInt _returnValue = 0; \

	TRAP(_unifiedLeave, _returnValue = _function);	\

	TInt& __rref = _unifiedLeave; \

	__rref = _unifiedLeave | _returnValue; \

	}

CObservable::~CObservable()

	{

	iObservers.Close();

	// cleanup owned objects if there's any left

	iOpenRepositories.ResetAndDestroy();

	iRepositoryInfo.ResetAndDestroy();

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

	TInt multiRofsUidCount=iMultiRofsUidList.Count();

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

		{

		iMultiRofsUidList[i].iMountFlagList.Close();

		}

	iMultiRofsUidList.Close();

#endif	

	}

CObservable* CObservable::NewLC()

	{

	CObservable* self = new(ELeave) CObservable;

	CleanupStack::PushL(self);

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

	self->ConstructL();

#endif	

	return self;

	}

void CObservable::AddObserverL(TUid aUid, CServerRepository* aRepositoryPointer)

	{

	TRepositoryObserverInfo info;

	info.iRepositoryUid = aUid;

	info.iRepositoryPointer = aRepositoryPointer;	

	TLinearOrder<TRepositoryObserverInfo> observerSortOrder(CObservable::ObserverSortOrder);

	TInt err = iObservers.InsertInOrder(info, observerSortOrder);

	if ((err != KErrNone)&&(err != KErrAlreadyExists))

		{

		User::Leave(err);

		}

	}

void CObservable::RemoveObserver(TUid aUid, CServerRepository* aRepositoryPointer, TInt aInMemoryIndex)

	{

	TRepositoryObserverInfo info;

	info.iRepositoryUid = aUid;

	info.iRepositoryPointer = aRepositoryPointer;

	TLinearOrder<TRepositoryObserverInfo> observerSortOrder(CObservable::ObserverSortOrder);

	TInt i = iObservers.FindInOrder(info, observerSortOrder);

	if (i!=KErrNotFound)

		{

		// we remove the observer we find listening on the repository

		iObservers.Remove(i);

		if (iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_Any)!=KErrNotFound)

			{

			//if there are more 

			__CENTREP_TRACE1("CENTREP: Observer Removed when closing repository %x", aUid);

			}

		else

			{

			// removed the last observer with the given uid 

			// if the repository is in memory, try evicting it

			if (aInMemoryIndex>=0)

				{

				// Check cache size and carry out forced eviction if necessary			

				// Start Eviction if the repository fits in the cache	

				if (TServerResources::iCacheManager->Enabled()&&

					TServerResources::iCacheManager->StartEviction(GetOpenRepository(aInMemoryIndex)))

					{

					// Repository added to the idle list in eviction order

					__CENTREP_TRACE2("CENTREP: Repository Became Idle when closing repository %x size %d", aUid, GetOpenRepository(aInMemoryIndex)->Size());

					}

				else

					{

					__CENTREP_TRACE1("CENTREP: Repository Delete when closing repository %x", aUid);

					// Remove and Delete Open Repository

					delete iOpenRepositories[aInMemoryIndex];

					iOpenRepositories.Remove(aInMemoryIndex);

					}

				}

			// if no clients are connected on this repository, we no longer need the transaction information

			RemoveSharedRepositoryInfo(aUid);

			}

		}

	}

void CObservable::Notify(TUid aUid, TUint32 aVal) const

	{

	TInt i = FindConnectedRepository(aUid);

	if (i != KErrNotFound)

		{

		for(;(i<iObservers.Count())&&(iObservers[i].iRepositoryUid == aUid);i++)

			{

			iObservers[i].iRepositoryPointer->Notifier()->Notify(aVal);				

			}

		}

	}

TInt CObservable::FindConnectedRepository(TUid aUid) const

	{

	TRepositoryObserverInfo info;

	info.iRepositoryUid = aUid;

	return iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_First);

	}

#ifdef CACHE_OOM_TESTABILITY

void CObservable::Reset()

	{

	iObservers.Reset();

	iOpenRepositories.Reset();

	iRepositoryInfo.Reset();	

	}

void CObservable::CloseiOpenRepositories() 

	{

	for(TInt i=iOpenRepositories.Count()-1; i>=0; i--)

		{

		delete iOpenRepositories[i];			

		iOpenRepositories.Remove(i);

		}

	ASSERT(iOpenRepositories.Count()==0);

	iOpenRepositories.Close();

	}

void CObservable::CloseiRepositoryInfo() 

	{

	for(TInt i=iRepositoryInfo.Count()-1; i>=0; i--)

		{

		delete iRepositoryInfo[i];			

		iRepositoryInfo.Remove(i);

		}

	ASSERT(iRepositoryInfo.Count()==0);

	iRepositoryInfo.Close();

	}

#endif	

/**

This function compares two UID's and indicates their sorting order.  This

implementation avoids overflow problems inherent in 'return aUid1-aUid2' 

implementations.

*/

TInt CObservable::CompareTUidValues(TInt aUid1, TInt aUid2)

	{

	if (aUid1 > aUid2)

		return 1;

	if (aUid1 < aUid2)

		return -1;

	return 0;

	}

TInt CObservable::ObserverSortOrder(const TRepositoryObserverInfo &aRepository1, const TRepositoryObserverInfo &aRepository2)

	{

	TInt result;

	result = CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid);

	if (result == 0)	

		{

		if (aRepository1.iRepositoryPointer > aRepository2.iRepositoryPointer)

			return 1;

		if (aRepository1.iRepositoryPointer < aRepository2.iRepositoryPointer)

			return -1;		

		}

	return result;

	}

void CObservable::RemoveOpenRepository(CSharedRepository* aRepository)

	{

	TInt index = iOpenRepositories.Find(aRepository);

	if (index>=0)		

		{

		// we don't fail any transactions here anymore, because transactions can now survive NOC repository

		// unloads. The shared information about transactions is kept in memory seperately as long as a 

		// client is connected. 

		iOpenRepositories.Remove(index);

		delete aRepository;

		}

	}

TInt CObservable::FindOpenRepository(TUid aUid) const

	{

	TInt i;

	TInt count=iOpenRepositories.Count();

	for(i=count-1; i>=0; i--)

		{

		if(iOpenRepositories[i]->Uid()==aUid)

			{

			break;

			}

		}

	return i;

	}

TInt CObservable::ReadIniFileL(CSharedRepository*& aRepository, TCentRepLocation aLocation)

	{

	TInt r=KErrNone;

	CIniFileIn* inifile = 0;

	HBufC* fileName(NULL);

    //allocates memory on the heap

    TServerResources::CreateRepositoryFileNameLC(fileName, aRepository->Uid(), aLocation, EIni);		

	r = CIniFileIn::NewLC(TServerResources::iFs,inifile,*fileName);

	if(r==KErrNone)

		{			

		r=ReadSettingsL(inifile, aRepository);		

			{

			// File is corrupt, if it's not the ROM file, delete it

			if(fileName && aLocation != ERom)

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

			// Delete any repository settings that may have been read in

			aRepository->GetSettings().Reset();

			}

		}

	CleanupStack::PopAndDestroy(inifile); // inifile	 

	CleanupStack::PopAndDestroy(fileName);	// filename

	return r;

	}

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

// Function to compare two TMultiRofsList's.

TInt CObservable::CompareUid(const TMultiRofsList& aUid1, const TMultiRofsList& aUid2)

	{

    if (aUid1.iRepUid.iUid < aUid2.iRepUid.iUid)

        return -1 ;

    if (aUid1.iRepUid.iUid > aUid2.iRepUid.iUid)

		return 1 ;

   	return 0 ;

	}

void CObservable::ConstructL()

	{

	//now search for repositories uid that might be composed of multi rofs

#ifndef CENTREP_CONV_TOOL

	if (TServerResources::iRomDirectory)

		{

		TFileName searchFileFormat;

		searchFileFormat.Append(*(TServerResources::iRomDirectory));

		searchFileFormat.Append(_L("????????.???[*-00]"));

	    CDir* entryList=NULL;		

		User::LeaveIfError(TServerResources::iFs.GetDir(searchFileFormat,KEntryAttNormal,ESortByName,entryList));

		CleanupStack::PushL(entryList);

		ProcessMultiRofsListL(*entryList);

		CleanupStack::PopAndDestroy(entryList);

		}

#endif	

	}

void CObservable::ProcessMultiRofsListL(const CDir& aList)

	{

	TLex parser;

	TUint32 uidNum;

	TUint8 mountId;

	TLinearOrder<TMultiRofsList> reposSortOrder(CompareUid);

	TInt count=aList.Count();

	iMultiRofsUidList.ReserveL(count);

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

		{

		//file format as following XXXXYYYY.<cre/txt>[id-00]

		//Extract the Uid first

		parser.Assign(aList[i].iName.Left(8));		

		User::LeaveIfError(parser.Val(uidNum,EHex));		

		//Extract the Mount id now, see the file format above

		parser.Assign(aList[i].iName.Mid(13,2));

		User::LeaveIfError(parser.Val(mountId,EHex));

		//Now find whether this uid is already in the list

		TMultiRofsList find(TUid::Uid(uidNum));

		//passing it the extension of the file

		TRofsFlag newFlag(aList[i].iName.Mid(9,3),mountId);

		TInt err=iMultiRofsUidList.FindInOrder(find,reposSortOrder);

		if (err==KErrNotFound)

			{

			//new entry

			find.iMountFlagList.AppendL(newFlag);

			iMultiRofsUidList.InsertInOrderL(find,reposSortOrder);

			}

		else

			{

			//entry exist, just need to update the array inside TMultiRofsList

			err=iMultiRofsUidList[err].iMountFlagList.InsertInOrder(newFlag,TRofsFlag::CompareFlag);

			//ignore KErrAlreadyExists which might be the case if a txt and cre found on the same

			//rofs but the cre is preferred.

			if (err!=KErrNone && err!=KErrAlreadyExists)

				{

				User::Leave(err);

				}

			}

		}		

	}

void CObservable::OverrideSettingL(TServerSetting& aBaseSetting,const TServerSetting& aOvSetting,CSharedRepository* aCoreRepository,TBool aNewOv,TBool aNewOvIndivPolicy)

	{

	TUint32 ovId=aOvSetting.Key();

	//---------------------CHECK AND SET THE META----------------------------

	TBool indivOvMeta=aOvSetting.IsIndividualMeta()!=0;

	//if individually specified meta override this

	if (indivOvMeta)

		{

		aBaseSetting.SetMeta(aOvSetting.Meta());

		}

	//if not specified only when it is new we set it from the default meta

	else

		{

		if (aNewOv)	

			aCoreRepository->SetMetaDataOnRead(aBaseSetting,EFalse);		

		}

	//----------------------CHECK AND SET THE PLATSEC----------------------------	

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

	TSettingsAccessPolicy* ovTs=aOvSetting.AccessPolicy();

	TSettingsAccessPolicy* coreTs=aCoreRepository->GetFallbackAccessPolicy(ovId,ETrue);

	//new setting defined

	if (aNewOv)

		{

		//specify own settings

		if (aNewOvIndivPolicy)	

			{

			TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast<TSecurityPolicy*>

			(aOvSetting.GetReadAccessPolicy())),*(const_cast<TSecurityPolicy*>(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask());

			CleanupStack::PushL(newPol);

			//for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback

			if (ovTs->HighKey()==0)

				{

				newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy());

				}

			//for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback

			if (ovTs->KeyMask()==0)

				{

				newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy());

				}

			//insert the new one and set the setting policy to point to this

			aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order);

			aBaseSetting.SetAccessPolicy(newPol);				

			CleanupStack::Pop(newPol);			

			}

		//no individual setting policy specified so revert to the default policy in the base	

		else

			{

			aBaseSetting.SetAccessPolicy(coreTs);	

			}

		}

	//old setting

	else

		{

		//if no individual policy specified do nothing as this keeps what we have in the base setting

		if (aNewOvIndivPolicy)

			{

			TInt baseIndividualPol=aCoreRepository->iSimRep->SinglePolicyArray().Find(aBaseSetting.AccessPolicy());	

			if (baseIndividualPol==KErrNotFound)

				{

				//no base individual but overriding specify one so create one and insert into list

				//point the old base setting to this newly defined invididual setting

				TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast<TSecurityPolicy*>

				(aOvSetting.GetReadAccessPolicy())),*(const_cast<TSecurityPolicy*>(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask());

				CleanupStack::PushL(newPol);

				//for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback								

				if (ovTs->HighKey()==0)

					{

					newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy());

					}

				//for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback				

				if (ovTs->KeyMask()==0)

					{

					newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy());

					}

				//insert the new one and set the setting policy to point to this

				aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order);

				aBaseSetting.SetAccessPolicy(newPol);				

				CleanupStack::Pop(newPol);			

				}

			else

				{

				TSettingsAccessPolicy* oldPol=aBaseSetting.AccessPolicy();				

				//existing individual already exist, just update them

				//for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback

				if (ovTs->HighKey()!=0)

					{

					oldPol->iReadAccessPolicy=*(aOvSetting.GetReadAccessPolicy());

					}

				//for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback		

				if (ovTs->KeyMask()!=0)

					{

					oldPol->iWriteAccessPolicy=*(aOvSetting.GetWriteAccessPolicy());

					}

				}

			}

		}

	//---------------------SET THE VALUE---------------------------------------

	//override the value only if it is a new setting or an old setting with value modified

	if (aNewOv || (!aNewOv && aBaseSetting!=aOvSetting))

		User::LeaveIfError(aBaseSetting.CopyTypeValue(aOvSetting));

	//need to set it clean as this is still ROM settings

	aBaseSetting.SetClean();			

	}

//Function containing the rule of merging repositories to a core repository

//such as -ignoring of the global properties(non-overriden)

//        -type cannot be overriden

void CObservable::MergeRepositoryL(CSharedRepository* aCoreRepository,CHeapRepository* aOverrideRepository)

	{

	/**

	We may want to verify that the following global properties match

	-OwnerUid

	-Uid

	We may want to give warning if they try to have global propertie section in the overriding layers

	although this obviously now can be ignored now, just need to make sure that repository follows the format

	and not corrupted

	*/

	TSettingsAccessPolicy defaultTs=aOverrideRepository->GetDefaultAccessPolicy();

	//here we panic immediately if there is any defined in the range meta/policy(we can check individually if

	//they do override later on,we will assume any definiton of global policy is invalid here

	if (   aOverrideRepository->Owner() != aCoreRepository->iSimRep->Owner()

		|| (aOverrideRepository->DefaultMeta()!=0 && aOverrideRepository->DefaultMeta()!= aCoreRepository->iSimRep->DefaultMeta())

		|| (defaultTs.HighKey()!=0 && aOverrideRepository->GetDefaultReadAccessPolicy().Package() !=	aCoreRepository->iSimRep->GetDefaultReadAccessPolicy().Package())

		|| (defaultTs.KeyMask()!=0 && aOverrideRepository->GetDefaultWriteAccessPolicy().Package()!= aCoreRepository->iSimRep->GetDefaultWriteAccessPolicy().Package())

		|| (aOverrideRepository->RangeMetaArray().Count()!=0 && !(aCoreRepository->iSimRep->RangeMetaArray().IsEqual(aOverrideRepository->RangeMetaArray())))

		|| (aOverrideRepository->RangePolicyArray().Count()!=0 && !(aCoreRepository->iSimRep->RangePolicyArray().IsEqual(aOverrideRepository->RangePolicyArray())		

		)))

		{

		#ifdef _DEBUG		

			RDebug::Printf("Illegal Global Properties Overriding");

		#endif		

		User::Leave(KErrMultiRofsGlobalOverride);

		}

	TInt single_count=aOverrideRepository->SettingsArray().Count();

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

		{

		//get the overriding setting

		TServerSetting& ovTs=aOverrideRepository->SettingsArray()[i];

		TUint32 ovId=ovTs.Key();

		//find whether it exist in the core

		TServerSetting* coreTs=aCoreRepository->GetSettings().Find(ovId);

		//check whether in the overriding repository,the policy is individually specified policy

		TInt ovIndividualPol=aOverrideRepository->SinglePolicyArray().Find(ovTs.AccessPolicy());

		if (coreTs)

			{

			//found in core, need to check the type is the same else Panic

			if (coreTs->Type()!=ovTs.Type())

				{

				#ifdef _DEBUG			

					RDebug::Printf("Illegal Setting Type Overriding");

				#endif	

				User::Leave(KErrMultiRofsTypeOverride);				

				}

			OverrideSettingL(*coreTs,ovTs,aCoreRepository,EFalse,ovIndividualPol!=KErrNotFound);					

			}

		else

			{

			//this is a newly defined setting

			TServerSetting newTs(ovTs.Key());

			OverrideSettingL(newTs,ovTs,aCoreRepository,ETrue,ovIndividualPol!=KErrNotFound);

			//finally insert into the RSettingsArray for this new setting

			aCoreRepository->iSimRep->SettingsArray().OrderedInsertL(newTs);	

			}

		}

	}	

/**Function on initialising a repository of multi ROFS files

aCoreInitialized indicate whether there is already existing keyspace file in the core layer

otherwise the first one in the rofs layer will be the core repository

*/ 

void CObservable::MergeMultiRofsL(TBool aCoreInitialized,CSharedRepository* aCoreRepository,const RArray<TRofsFlag>& aOverridingFileList)

	{

	//load all the files and construct an array of CHeapRepository to merge content into it