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

 		if(r==KErrCorrupt)

 			{

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

 	TInt sortedCount=aOverridingFileList.Count();

 	TFileName repFileName;

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

 		{

 		repFileName.Zero();

 		TRofsFlag rofsFlag=aOverridingFileList[i];

 		TPtrC extPointer(*(TServerResources::iCreExt));

 		TBool isTxt=rofsFlag.iFlag & 0x80000000;

 		if (isTxt)

 			{

 			extPointer.Set(*(TServerResources::iIniExt));

 			}

 		repFileName.Format(_L("z:\\private\\10202be9\\%08x%S[%02x-00]"),aCoreRepository->Uid().iUid,&extPointer,rofsFlag.iFlag & 0xFF);

 		//only when the core is not initialized, the first item in the list now becomes the core

 		if (!aCoreInitialized && i==0)

 			{

 			if (isTxt)

 				{

 				CIniFileIn* iniFile;

 				TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName);

 				User::LeaveIfError(err);

 				err=aCoreRepository->ReloadContentL(*iniFile,ETrue);

 				User::LeaveIfError(err);

 				CleanupStack::PopAndDestroy(iniFile);//iniFile

 				}

 			else

 				{

 				aCoreRepository->iSimRep->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName);

 				}

 			}

 		else

 			{

 			CHeapRepository* repos=CHeapRepository::NewL(aCoreRepository->Uid());

 			CleanupStack::PushL(repos);

 			if (isTxt)

 				{

 				CIniFileIn* iniFile;

 				TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName);

 				User::LeaveIfError(err);

 				repos->ReloadContentL(*iniFile);

 				CleanupStack::PopAndDestroy(iniFile);//iniFile

 				}

 			else

 				{

 				TUint8 creVersion;

 				repos->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName,creVersion);

 				//need to check the CRE version in the overloading layer

 				if (creVersion<KPersistFormatSupportsIndMetaIndicator)

 					{

 					#ifdef _DEBUG		

 						RDebug::Printf("Use of Cre version less than 2 in the overriding layer");

 					#endif	

 					//this macro is used for testing existing regression test with multi-rofs

 					//so we allow older cre to be used in higher rofs

 					#ifndef PDS_TEST_MULTIROFS											

 						User::Leave(KErrMultiRofsOldCreUsed);

 					#endif								

 					}

 				}

 			//Now that the repository is initialized and at this stage the repository file has been

 			//checked whether they are corrupt	

 			repos->SettingsArray().SetIsDefault(ETrue);

 			MergeRepositoryL(aCoreRepository,repos);

 			CleanupStack::PopAndDestroy(repos);	//repos

 			}

 		}

 	}

 #endif	

 TInt CObservable::CreateRepositoryL(CSharedRepository* aRepository, TCentRepLocation aLocation)

 	{

 	aRepository->GetSettings().SetIsDefault(aLocation!=EPersists);

     TInt err(KErrNotFound);

 	err = aRepository->CreateRepositoryFromCreFileL(aLocation);

 	if(err==KErrNotFound)

 		{

 		if (aLocation!=EPersists)

 			err = ReadIniFileL(aRepository,aLocation);

 		}

 	//for ROM might want to consider the possibility of multi rofs file

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS		

 	if (aLocation==ERom && iMultiRofsUidList.Count()!=0)

 		{

 		//if there is error and not because of non-existant we should return error immediately

 		//and if it is fine but the uid does not match one of the multirofsuidlsit this means that

 		//repository is not composed of multi file.

 		if (err==KErrNone || err==KErrNotFound)

 			{

 			TMultiRofsList find(aRepository->Uid());

 			TLinearOrder<TMultiRofsList> sort_order(CompareUid);			

 			TInt index=iMultiRofsUidList.FindInOrder(find,sort_order);		

 			if (index==KErrNotFound)	

 				return err;

 			//if the first layer has already got the exattrib=U we should leave with KErrMultiRofsIllegalRofs

 			if (err==KErrNotFound && index!=KErrNotFound)	

 				User::Leave(KErrMultiRofsIllegalRofs);

 			//the list exist in one of the mappings stored earlier, get the name and construct them

 			TRAP(err,MergeMultiRofsL(err==KErrNone,aRepository,iMultiRofsUidList[index].iMountFlagList));

 			if (err==KErrNoMemory)	

 				User::LeaveNoMemory();

 			}

 		}

 #endif		

 	return( err);

 	}

 /**

 In order to create a repository this routine looks for a .cre or .txt file. 

 Txt and cre files can co-exist in install and ROM but not in persists location.

 If a persists txt file exists, the first write to the repository will cause a

 cre file to be created and the txt file to be deleted.

 If both files exist in the same location, the .cre is picked up first. 

 If the .cre file is not found,a .txt file from the same location is tried.

 Otherwise if the .cre file is corrupted,it tries a .cre file from a next location. 

 Note:

 If a cre file exists at a particular location, even if the cre file is corrupt a txt 

 file will not be searched for in the same location. 

 */

 TInt CObservable::CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode)

     {

     TInt err(KErrNotFound);

     switch (aIniFileOpenMode)

 	    {

 	    case CIniFileIn::EAuto:

 	        {

 	        // Look in persists dir	 

 	        err=CreateRepositoryL(aRepository, EPersists);		

 			if(err==KErrNone)

 				{

 				return err;

 				}

 	        // No persists file - look in ROM dir	 

 	        // Do this before looking in the install dir, because if there is

 	        // a ROM file, an install file and no persists file then this

 	        // repository is being opened after a SW install but before the 

 	        // merge. In this case the install file shouldn't be opened

 	        // until after the merge.

 	        err=CreateRepositoryL(aRepository, ERom);		

 			if(err==KErrNone)

 				{

 				break;

 				}

 			else if(err==KErrNotFound)

 				{				

 			     // Look in install directory only if there was no ROM or persists file	            

 				err=CreateRepositoryL(aRepository, EInstall);

 				if(err==KErrNone)

 					{

 					TTime installFileTimeStamp=TServerResources::CentrepFileTimeStampL(aRepository->Uid(), EInstall);

 					aRepository->SetInstallTime(installFileTimeStamp);

 					}

 				}

 	        break;

 	        }

 	    case CIniFileIn::EInstallOnly:

 	        {

 	    	err=CreateRepositoryL(aRepository, EInstall);		

 	        break;

 	        }

 	    case CIniFileIn::ERomOnly:

 	        {

 	    	err=CreateRepositoryL(aRepository, ERom);		

 	        break;

 	        }

 	    }

 	return err;

 	}

 TInt CObservable::ReadSettingsL(CIniFileIn *aIniFile, CSharedRepository* aRep)

 	{	

 	return aRep->ReloadContentL(*aIniFile, ETrue);

 	}

 void CObservable::LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode)

 	{

 	// Calculate the amount of memory this repository will take in the heap

 	// by checking the heap size before and after the internalization

 	RHeap& myHeap = User::Heap();

 	TInt firstSize = myHeap.Size();

 	TInt biggestBlock;

 	TInt firstAvail = myHeap.Available(biggestBlock);

 	TRAPD(err, aRepository = CSharedRepository::NewL(aUid));

 #ifdef CACHE_OOM_TESTABILITY

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

 		{

 		User::Leave(err);

 		}

 #endif	

 	if ((err!=KErrNone)&&TServerResources::iCacheManager->Enabled())

 		{

 		// If cache enabled, try recovery by releasing the cache

 		TServerResources::iCacheManager->FlushCache(EFalse);

 		// retry

 		aRepository = CSharedRepository::NewL(aUid);

 		err = KErrNone;

 		}

 	User::LeaveIfError(err);

 	// Now that we have enough memory for the object and constructed it properly

 	// we try to load it. We trap all errors, either from leaving functions or error code

 	// returning functions and unify them (in all cases only one of these codes will

 	// contain a valid value and the other will be 0, and for our purposes we treat

 	// all errors the same no matter if they're thrown or returned)

 	TInt unifiedErrorCode;

 	TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode));

 	if (unifiedErrorCode!=KErrNone)

 	{

 	switch(unifiedErrorCode)

 		{

 		case KErrNoMemory:

 			{

 			if (TServerResources::iCacheManager->Enabled()) // cache enabled

 				{

 #ifdef CACHE_OOM_TESTABILITY

 				if (!iTrapOOMOnOpen)	

 					{

 					delete aRepository;

 					aRepository = NULL;

 					User::Leave(KErrNoMemory);

 					}

 #endif	

 				// Flush cache

 				TServerResources::iCacheManager->FlushCache(ETrue);

 				firstSize = myHeap.Size();

 				firstAvail = myHeap.Available(biggestBlock);

 				//retry

 				TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode));

 				}

 			}

 			break;

 		case KErrNotFound:

 		case KErrPathNotFound:		

 			{

 			if (!aFailIfNotFound) // backup open

 				{

 				// override error condition and continue normally

 				unifiedErrorCode = KErrNone;

 				}

 			}

 			break;

 		}

 	}

 	// If unhandled, leave

 	if(unifiedErrorCode != KErrNone)

 		{

 		delete aRepository;

 		aRepository = NULL;

 		}

 	User::LeaveIfError(unifiedErrorCode);

 	CleanupStack::PushL(aRepository);

 	// Otherwise, finalize calulations

 	TInt lastSize = myHeap.Size();

 	TInt lastAvail = myHeap.Available(biggestBlock);

 	TInt calcSize = (lastSize - lastAvail) - (firstSize - firstAvail);

 	// record repository size for cache algorithm purposes

 	aRepository->SetSize(calcSize);

 	}

 CSharedRepository* CObservable::AccessL(TUid aUid, TBool aFailIfNotFound)

 	{

 	CSharedRepository* rep = NULL;

 	TInt i = FindOpenRepository(aUid);

 	if(i!=KErrNotFound)

 		{

 		rep = GetOpenRepository(i);

 		// repository still open, can safely call RestoreConsistencyL

 		rep->RestoreConsistencyL();

 		}

 	else

 		{

 		// For memory usage testing purposes

 		RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid);

 		// Various error conditions are handled in this function 

 		LoadRepositoryLC(aUid, aFailIfNotFound, rep, CIniFileIn::EAuto);

 		__CENTREP_TRACE1("CENTREP: Repository Load when opening repository %x", aUid.iUid);

 		// For memory usage testing purposes

 		RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid);

 		AddOpenRepositoryL(rep);

 		// We pop the rep here because if later call of TServerResources::AddOwnerIdLookupMapping fails of OOM

 		// the call of RemoveOpenRepository() will delete the repository before leave.

 		CleanupStack::Pop(rep);

 		// Add owner mapping to list - Will fail if an entry already exists

 		// with this Repository UID but this doesn't matter

 		TUid owner = rep->Owner() ;

 		TInt err = TServerResources::AddOwnerIdLookupMapping(aUid.iUid, owner.iUid);	

 		if (err == KErrNoMemory)

 			{

 			RemoveOpenRepository(rep);

 			User::Leave(err);

 			}

 		//Find the location of the current transaction for this repository

 		const TInt offset (FindRepositoryInfo(aUid));

 		if (offset >=0) //If there are no outstanding transactions

 			{

 			RefreshTransactorAccessPolicies(rep,offset);

 			}

 		}

 	// re-start the timer

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

 		{

 		TServerResources::iCacheManager->StartEviction(rep);

 		}	

 	return rep;

 	}

 TInt CObservable::FindRepositoryInfo(TUid aUid)

 	{

 	TSharedRepositoryInfo info(aUid);

 	TLinearOrder<TSharedRepositoryInfo> infoSortOrder(CObservable::InfoSortOrder);

 	return iRepositoryInfo.FindInOrder(&info, infoSortOrder);

 	}

 CObservable::TSharedRepositoryInfo* CObservable::SharedRepositoryInfo(TUid aUid)

 	{

 	TInt pos = FindRepositoryInfo(aUid);

 	return (pos!=KErrNotFound) ? iRepositoryInfo[pos] : NULL;

 	}

 void CObservable::CancelTransaction(CRepositoryTransactor& aTransactor,TUid aRepositoryUid)

     {

     if (aTransactor.IsInTransaction())

         {

         ReleaseTransactionLock(aTransactor,aRepositoryUid);

         CObservable::TSharedRepositoryInfo* shrepinfo =SharedRepositoryInfo(aRepositoryUid);

         ASSERT(shrepinfo);

         shrepinfo->iTransactors.Remove(aTransactor);

         //Remove the link to the next transaction

         aTransactor.iLink.iNext = NULL;

         aTransactor.Deque();

         }

     }

 /** Private helper method which releases any read/write locks held in the shared repository

 by this transactor. Caller must set transactor's state or remove from queue as appropriate.

 @param aTransactor transactor whose read/write locks are to be released.

 @post Any read/write locks held by transactor are released.

 */

 void CObservable::ReleaseTransactionLock(CRepositoryTransactor& aTransactor,TUid aRepositoryUid)

     {

     CObservable::TSharedRepositoryInfo* shrepinfo = SharedRepositoryInfo(aRepositoryUid);

     ASSERT(shrepinfo);

     if (aTransactor.IsInActiveConcurrentReadWriteTransaction())

         {

         shrepinfo->iNumActiveConcurrentReadWriteTransactions--;

         ASSERT(shrepinfo->iNumActiveConcurrentReadWriteTransactions >= 0); // sanity check

         }

     else if (aTransactor.IsInActiveReadTransaction())

         {

         shrepinfo->iPessimisticTransactionLockCount--;

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

         }

     else if (aTransactor.IsInActiveExclusiveReadWriteTransaction())

         {

         // can only be one exclusive read/write transaction active (lock value -1)

         ASSERT(shrepinfo->iPessimisticTransactionLockCount == -1);

         shrepinfo->iPessimisticTransactionLockCount = 0;

         }

     }

 CObservable::TSharedRepositoryInfo::TSharedRepositoryInfo(TUid aUid) : 

 	iRepositoryUid(aUid), iTransactors(_FOFF(CRepositoryTransactor, iLink)), 

 	iPessimisticTransactionLockCount(0), iNumActiveConcurrentReadWriteTransactions(0) 

 	{

 	}

 TInt CObservable::InfoSortOrder(const TSharedRepositoryInfo &aRepository1, const TSharedRepositoryInfo &aRepository2)

 	{

 	return CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid);

 	}

 void CObservable::AddSharedRepositoryInfoL(TUid aUid)

 	{

 	TSharedRepositoryInfo* shinfo = new(ELeave) TSharedRepositoryInfo(aUid);

 	TLinearOrder<TSharedRepositoryInfo> infoSortOrder(CObservable::InfoSortOrder);

 	// Inserts if not already in the array, otherwise returns KErrAlreadyExists, which we handle gracefully

 	TInt err = iRepositoryInfo.InsertInOrder(shinfo, infoSortOrder);	

 	if (err==KErrAlreadyExists)

 		{

 		delete shinfo;

 		}

 	else

 		{

 		if (err!=KErrNone)

 			delete shinfo;

 		User::LeaveIfError(err);

 		}

 	}

 void CObservable::RemoveSharedRepositoryInfo(TUid aUid)

 	{

 	TInt pos = FindRepositoryInfo(aUid);

 	if (pos!=KErrNotFound)

 		{

 		delete iRepositoryInfo[pos];

 		iRepositoryInfo.Remove(pos);

 		}

 	}

 void CObservable::RefreshTransactorAccessPolicies(CSharedRepository* aRepository,const TInt offset)

 	{

 	TSglQueIter<CRepositoryTransactor> iter(iRepositoryInfo[offset]->iTransactors);

 	CRepositoryTransactor* t (iter);

 	while (iter++ != NULL)

 		{

 		const TInt count = t->iTransactionSettings.Count();

 		for (TInt i=0; i<count;i++) //for the no. of changed settings in the transaction

 			{

 			TServerSetting temp = t->iTransactionSettings[i];

 			t->iTransactionSettings[i].SetAccessPolicy(aRepository->GetFallbackAccessPolicy(temp.Key()));		

 			//Correct the access policy pointer so that its pointing to the new valid location

 			}

 		t = iter;

 		}

 	}