sl@0: // Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // sl@0: sl@0: #include "obsrvr_noc.h" sl@0: #include "panic.h" sl@0: #include "shrepos.h" sl@0: #include "srvrepos_noc.h" sl@0: #include "log.h" sl@0: #include "cachemgr.h" sl@0: sl@0: #define TRAP_UNIFIED(_unifiedLeave, _function) \ sl@0: { \ sl@0: TInt _returnValue = 0; \ sl@0: TRAP(_unifiedLeave, _returnValue = _function); \ sl@0: TInt& __rref = _unifiedLeave; \ sl@0: __rref = _unifiedLeave | _returnValue; \ sl@0: } sl@0: sl@0: CObservable::~CObservable() sl@0: { sl@0: iObservers.Close(); sl@0: // cleanup owned objects if there's any left sl@0: iOpenRepositories.ResetAndDestroy(); sl@0: iRepositoryInfo.ResetAndDestroy(); sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS sl@0: TInt multiRofsUidCount=iMultiRofsUidList.Count(); sl@0: for (TInt i=0;iConstructL(); sl@0: #endif sl@0: return self; sl@0: } sl@0: sl@0: void CObservable::AddObserverL(TUid aUid, CServerRepository* aRepositoryPointer) sl@0: { sl@0: TRepositoryObserverInfo info; sl@0: sl@0: info.iRepositoryUid = aUid; sl@0: info.iRepositoryPointer = aRepositoryPointer; sl@0: sl@0: TLinearOrder observerSortOrder(CObservable::ObserverSortOrder); sl@0: TInt err = iObservers.InsertInOrder(info, observerSortOrder); sl@0: if ((err != KErrNone)&&(err != KErrAlreadyExists)) sl@0: { sl@0: User::Leave(err); sl@0: } sl@0: } sl@0: sl@0: void CObservable::RemoveObserver(TUid aUid, CServerRepository* aRepositoryPointer, TInt aInMemoryIndex) sl@0: { sl@0: TRepositoryObserverInfo info; sl@0: sl@0: info.iRepositoryUid = aUid; sl@0: info.iRepositoryPointer = aRepositoryPointer; sl@0: sl@0: TLinearOrder observerSortOrder(CObservable::ObserverSortOrder); sl@0: sl@0: TInt i = iObservers.FindInOrder(info, observerSortOrder); sl@0: if (i!=KErrNotFound) sl@0: { sl@0: // we remove the observer we find listening on the repository sl@0: iObservers.Remove(i); sl@0: if (iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_Any)!=KErrNotFound) sl@0: { sl@0: //if there are more sl@0: __CENTREP_TRACE1("CENTREP: Observer Removed when closing repository %x", aUid); sl@0: } sl@0: else sl@0: { sl@0: // removed the last observer with the given uid sl@0: // if the repository is in memory, try evicting it sl@0: if (aInMemoryIndex>=0) sl@0: { sl@0: // Check cache size and carry out forced eviction if necessary sl@0: // Start Eviction if the repository fits in the cache sl@0: if (TServerResources::iCacheManager->Enabled()&& sl@0: TServerResources::iCacheManager->StartEviction(GetOpenRepository(aInMemoryIndex))) sl@0: { sl@0: // Repository added to the idle list in eviction order sl@0: __CENTREP_TRACE2("CENTREP: Repository Became Idle when closing repository %x size %d", aUid, GetOpenRepository(aInMemoryIndex)->Size()); sl@0: } sl@0: else sl@0: { sl@0: __CENTREP_TRACE1("CENTREP: Repository Delete when closing repository %x", aUid); sl@0: // Remove and Delete Open Repository sl@0: delete iOpenRepositories[aInMemoryIndex]; sl@0: iOpenRepositories.Remove(aInMemoryIndex); sl@0: } sl@0: } sl@0: // if no clients are connected on this repository, we no longer need the transaction information sl@0: RemoveSharedRepositoryInfo(aUid); sl@0: } sl@0: } sl@0: } sl@0: sl@0: void CObservable::Notify(TUid aUid, TUint32 aVal) const sl@0: { sl@0: TInt i = FindConnectedRepository(aUid); sl@0: if (i != KErrNotFound) sl@0: { sl@0: for(;(iNotifier()->Notify(aVal); sl@0: } sl@0: } sl@0: } sl@0: sl@0: TInt CObservable::FindConnectedRepository(TUid aUid) const sl@0: { sl@0: TRepositoryObserverInfo info; sl@0: info.iRepositoryUid = aUid; sl@0: sl@0: return iObservers.SpecificFindInSignedKeyOrder(info, EArrayFindMode_First); sl@0: } sl@0: sl@0: #ifdef CACHE_OOM_TESTABILITY sl@0: void CObservable::Reset() sl@0: { sl@0: iObservers.Reset(); sl@0: iOpenRepositories.Reset(); sl@0: iRepositoryInfo.Reset(); sl@0: } sl@0: sl@0: void CObservable::CloseiOpenRepositories() sl@0: { sl@0: for(TInt i=iOpenRepositories.Count()-1; i>=0; i--) sl@0: { sl@0: delete iOpenRepositories[i]; sl@0: iOpenRepositories.Remove(i); sl@0: } sl@0: ASSERT(iOpenRepositories.Count()==0); sl@0: iOpenRepositories.Close(); sl@0: } sl@0: sl@0: void CObservable::CloseiRepositoryInfo() sl@0: { sl@0: for(TInt i=iRepositoryInfo.Count()-1; i>=0; i--) sl@0: { sl@0: delete iRepositoryInfo[i]; sl@0: iRepositoryInfo.Remove(i); sl@0: } sl@0: ASSERT(iRepositoryInfo.Count()==0); sl@0: iRepositoryInfo.Close(); sl@0: } sl@0: sl@0: #endif sl@0: sl@0: /** sl@0: This function compares two UID's and indicates their sorting order. This sl@0: implementation avoids overflow problems inherent in 'return aUid1-aUid2' sl@0: implementations. sl@0: */ sl@0: TInt CObservable::CompareTUidValues(TInt aUid1, TInt aUid2) sl@0: { sl@0: if (aUid1 > aUid2) sl@0: return 1; sl@0: if (aUid1 < aUid2) sl@0: return -1; sl@0: return 0; sl@0: } sl@0: sl@0: sl@0: TInt CObservable::ObserverSortOrder(const TRepositoryObserverInfo &aRepository1, const TRepositoryObserverInfo &aRepository2) sl@0: { sl@0: TInt result; sl@0: sl@0: result = CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid); sl@0: if (result == 0) sl@0: { sl@0: if (aRepository1.iRepositoryPointer > aRepository2.iRepositoryPointer) sl@0: return 1; sl@0: if (aRepository1.iRepositoryPointer < aRepository2.iRepositoryPointer) sl@0: return -1; sl@0: } sl@0: sl@0: return result; sl@0: } sl@0: sl@0: void CObservable::RemoveOpenRepository(CSharedRepository* aRepository) sl@0: { sl@0: TInt index = iOpenRepositories.Find(aRepository); sl@0: sl@0: if (index>=0) sl@0: { sl@0: // we don't fail any transactions here anymore, because transactions can now survive NOC repository sl@0: // unloads. The shared information about transactions is kept in memory seperately as long as a sl@0: // client is connected. sl@0: iOpenRepositories.Remove(index); sl@0: delete aRepository; sl@0: } sl@0: } sl@0: sl@0: TInt CObservable::FindOpenRepository(TUid aUid) const sl@0: { sl@0: TInt i; sl@0: TInt count=iOpenRepositories.Count(); sl@0: for(i=count-1; i>=0; i--) sl@0: { sl@0: if(iOpenRepositories[i]->Uid()==aUid) sl@0: { sl@0: break; sl@0: } sl@0: } sl@0: return i; sl@0: } sl@0: sl@0: TInt CObservable::ReadIniFileL(CSharedRepository*& aRepository, TCentRepLocation aLocation) sl@0: { sl@0: TInt r=KErrNone; sl@0: CIniFileIn* inifile = 0; sl@0: sl@0: HBufC* fileName(NULL); sl@0: //allocates memory on the heap sl@0: TServerResources::CreateRepositoryFileNameLC(fileName, aRepository->Uid(), aLocation, EIni); sl@0: r = CIniFileIn::NewLC(TServerResources::iFs,inifile,*fileName); sl@0: if(r==KErrNone) sl@0: { sl@0: r=ReadSettingsL(inifile, aRepository); sl@0: if(r==KErrCorrupt) sl@0: { sl@0: // File is corrupt, if it's not the ROM file, delete it sl@0: if(fileName && aLocation != ERom) sl@0: User::LeaveIfError(TServerResources::iFs.Delete(*fileName)); sl@0: // Delete any repository settings that may have been read in sl@0: aRepository->GetSettings().Reset(); sl@0: } sl@0: } sl@0: sl@0: CleanupStack::PopAndDestroy(inifile); // inifile sl@0: CleanupStack::PopAndDestroy(fileName); // filename sl@0: return r; sl@0: } sl@0: sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS sl@0: sl@0: // Function to compare two TMultiRofsList's. sl@0: TInt CObservable::CompareUid(const TMultiRofsList& aUid1, const TMultiRofsList& aUid2) sl@0: { sl@0: if (aUid1.iRepUid.iUid < aUid2.iRepUid.iUid) sl@0: return -1 ; sl@0: if (aUid1.iRepUid.iUid > aUid2.iRepUid.iUid) sl@0: return 1 ; sl@0: return 0 ; sl@0: } sl@0: sl@0: void CObservable::ConstructL() sl@0: { sl@0: //now search for repositories uid that might be composed of multi rofs sl@0: #ifndef CENTREP_CONV_TOOL sl@0: if (TServerResources::iRomDirectory) sl@0: { sl@0: TFileName searchFileFormat; sl@0: searchFileFormat.Append(*(TServerResources::iRomDirectory)); sl@0: searchFileFormat.Append(_L("????????.???[*-00]")); sl@0: CDir* entryList=NULL; sl@0: User::LeaveIfError(TServerResources::iFs.GetDir(searchFileFormat,KEntryAttNormal,ESortByName,entryList)); sl@0: CleanupStack::PushL(entryList); sl@0: ProcessMultiRofsListL(*entryList); sl@0: CleanupStack::PopAndDestroy(entryList); sl@0: } sl@0: #endif sl@0: } sl@0: sl@0: void CObservable::ProcessMultiRofsListL(const CDir& aList) sl@0: { sl@0: TLex parser; sl@0: TUint32 uidNum; sl@0: TUint8 mountId; sl@0: TLinearOrder reposSortOrder(CompareUid); sl@0: TInt count=aList.Count(); sl@0: iMultiRofsUidList.ReserveL(count); sl@0: for (TInt i=0;i[id-00] sl@0: //Extract the Uid first sl@0: parser.Assign(aList[i].iName.Left(8)); sl@0: User::LeaveIfError(parser.Val(uidNum,EHex)); sl@0: sl@0: //Extract the Mount id now, see the file format above sl@0: parser.Assign(aList[i].iName.Mid(13,2)); sl@0: User::LeaveIfError(parser.Val(mountId,EHex)); sl@0: sl@0: //Now find whether this uid is already in the list sl@0: TMultiRofsList find(TUid::Uid(uidNum)); sl@0: //passing it the extension of the file sl@0: TRofsFlag newFlag(aList[i].iName.Mid(9,3),mountId); sl@0: sl@0: TInt err=iMultiRofsUidList.FindInOrder(find,reposSortOrder); sl@0: if (err==KErrNotFound) sl@0: { sl@0: //new entry sl@0: find.iMountFlagList.AppendL(newFlag); sl@0: iMultiRofsUidList.InsertInOrderL(find,reposSortOrder); sl@0: } sl@0: else sl@0: { sl@0: //entry exist, just need to update the array inside TMultiRofsList sl@0: err=iMultiRofsUidList[err].iMountFlagList.InsertInOrder(newFlag,TRofsFlag::CompareFlag); sl@0: //ignore KErrAlreadyExists which might be the case if a txt and cre found on the same sl@0: //rofs but the cre is preferred. sl@0: if (err!=KErrNone && err!=KErrAlreadyExists) sl@0: { sl@0: User::Leave(err); sl@0: } sl@0: } sl@0: } sl@0: } sl@0: sl@0: sl@0: void CObservable::OverrideSettingL(TServerSetting& aBaseSetting,const TServerSetting& aOvSetting,CSharedRepository* aCoreRepository,TBool aNewOv,TBool aNewOvIndivPolicy) sl@0: { sl@0: TUint32 ovId=aOvSetting.Key(); sl@0: sl@0: //---------------------CHECK AND SET THE META---------------------------- sl@0: TBool indivOvMeta=aOvSetting.IsIndividualMeta()!=0; sl@0: //if individually specified meta override this sl@0: if (indivOvMeta) sl@0: { sl@0: aBaseSetting.SetMeta(aOvSetting.Meta()); sl@0: } sl@0: //if not specified only when it is new we set it from the default meta sl@0: else sl@0: { sl@0: if (aNewOv) sl@0: aCoreRepository->SetMetaDataOnRead(aBaseSetting,EFalse); sl@0: } sl@0: sl@0: //----------------------CHECK AND SET THE PLATSEC---------------------------- sl@0: TLinearOrder order(&CHeapRepository::CompareKeyIds); sl@0: TSettingsAccessPolicy* ovTs=aOvSetting.AccessPolicy(); sl@0: TSettingsAccessPolicy* coreTs=aCoreRepository->GetFallbackAccessPolicy(ovId,ETrue); sl@0: //new setting defined sl@0: if (aNewOv) sl@0: { sl@0: //specify own settings sl@0: if (aNewOvIndivPolicy) sl@0: { sl@0: TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast sl@0: (aOvSetting.GetReadAccessPolicy())),*(const_cast(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask()); sl@0: CleanupStack::PushL(newPol); sl@0: //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback sl@0: if (ovTs->HighKey()==0) sl@0: { sl@0: newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy()); sl@0: } sl@0: //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback sl@0: if (ovTs->KeyMask()==0) sl@0: { sl@0: newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy()); sl@0: } sl@0: //insert the new one and set the setting policy to point to this sl@0: aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order); sl@0: aBaseSetting.SetAccessPolicy(newPol); sl@0: CleanupStack::Pop(newPol); sl@0: } sl@0: //no individual setting policy specified so revert to the default policy in the base sl@0: else sl@0: { sl@0: aBaseSetting.SetAccessPolicy(coreTs); sl@0: } sl@0: } sl@0: //old setting sl@0: else sl@0: { sl@0: //if no individual policy specified do nothing as this keeps what we have in the base setting sl@0: if (aNewOvIndivPolicy) sl@0: { sl@0: TInt baseIndividualPol=aCoreRepository->iSimRep->SinglePolicyArray().Find(aBaseSetting.AccessPolicy()); sl@0: if (baseIndividualPol==KErrNotFound) sl@0: { sl@0: //no base individual but overriding specify one so create one and insert into list sl@0: //point the old base setting to this newly defined invididual setting sl@0: TSettingsAccessPolicy* newPol=new (ELeave)TSettingsAccessPolicy(*(const_cast sl@0: (aOvSetting.GetReadAccessPolicy())),*(const_cast(aOvSetting.GetWriteAccessPolicy())),ovId,ovTs->HighKey(),ovTs->KeyMask()); sl@0: CleanupStack::PushL(newPol); sl@0: //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback sl@0: if (ovTs->HighKey()==0) sl@0: { sl@0: newPol->iReadAccessPolicy=*(coreTs->GetReadAccessPolicy()); sl@0: } sl@0: //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback sl@0: if (ovTs->KeyMask()==0) sl@0: { sl@0: newPol->iWriteAccessPolicy=*(coreTs->GetWriteAccessPolicy()); sl@0: } sl@0: //insert the new one and set the setting policy to point to this sl@0: aCoreRepository->iSimRep->SinglePolicyArray().InsertInOrderL(newPol,order); sl@0: aBaseSetting.SetAccessPolicy(newPol); sl@0: CleanupStack::Pop(newPol); sl@0: } sl@0: else sl@0: { sl@0: TSettingsAccessPolicy* oldPol=aBaseSetting.AccessPolicy(); sl@0: //existing individual already exist, just update them sl@0: //for single setting policy, the highkey is used to indicate whether the setting define its own read policy or it is just a fallback sl@0: if (ovTs->HighKey()!=0) sl@0: { sl@0: oldPol->iReadAccessPolicy=*(aOvSetting.GetReadAccessPolicy()); sl@0: } sl@0: //for single setting policy, the keymask is used to indicate whether the setting define its own write policy or it is just a fallback sl@0: if (ovTs->KeyMask()!=0) sl@0: { sl@0: oldPol->iWriteAccessPolicy=*(aOvSetting.GetWriteAccessPolicy()); sl@0: } sl@0: } sl@0: } sl@0: } sl@0: sl@0: //---------------------SET THE VALUE--------------------------------------- sl@0: //override the value only if it is a new setting or an old setting with value modified sl@0: if (aNewOv || (!aNewOv && aBaseSetting!=aOvSetting)) sl@0: User::LeaveIfError(aBaseSetting.CopyTypeValue(aOvSetting)); sl@0: sl@0: //need to set it clean as this is still ROM settings sl@0: aBaseSetting.SetClean(); sl@0: } sl@0: sl@0: //Function containing the rule of merging repositories to a core repository sl@0: //such as -ignoring of the global properties(non-overriden) sl@0: // -type cannot be overriden sl@0: void CObservable::MergeRepositoryL(CSharedRepository* aCoreRepository,CHeapRepository* aOverrideRepository) sl@0: { sl@0: /** sl@0: We may want to verify that the following global properties match sl@0: -OwnerUid sl@0: -Uid sl@0: We may want to give warning if they try to have global propertie section in the overriding layers sl@0: although this obviously now can be ignored now, just need to make sure that repository follows the format sl@0: and not corrupted sl@0: */ sl@0: TSettingsAccessPolicy defaultTs=aOverrideRepository->GetDefaultAccessPolicy(); sl@0: //here we panic immediately if there is any defined in the range meta/policy(we can check individually if sl@0: //they do override later on,we will assume any definiton of global policy is invalid here sl@0: if ( aOverrideRepository->Owner() != aCoreRepository->iSimRep->Owner() sl@0: || (aOverrideRepository->DefaultMeta()!=0 && aOverrideRepository->DefaultMeta()!= aCoreRepository->iSimRep->DefaultMeta()) sl@0: || (defaultTs.HighKey()!=0 && aOverrideRepository->GetDefaultReadAccessPolicy().Package() != aCoreRepository->iSimRep->GetDefaultReadAccessPolicy().Package()) sl@0: || (defaultTs.KeyMask()!=0 && aOverrideRepository->GetDefaultWriteAccessPolicy().Package()!= aCoreRepository->iSimRep->GetDefaultWriteAccessPolicy().Package()) sl@0: || (aOverrideRepository->RangeMetaArray().Count()!=0 && !(aCoreRepository->iSimRep->RangeMetaArray().IsEqual(aOverrideRepository->RangeMetaArray()))) sl@0: || (aOverrideRepository->RangePolicyArray().Count()!=0 && !(aCoreRepository->iSimRep->RangePolicyArray().IsEqual(aOverrideRepository->RangePolicyArray()) sl@0: ))) sl@0: { sl@0: #ifdef _DEBUG sl@0: RDebug::Printf("Illegal Global Properties Overriding"); sl@0: #endif sl@0: User::Leave(KErrMultiRofsGlobalOverride); sl@0: } sl@0: sl@0: TInt single_count=aOverrideRepository->SettingsArray().Count(); sl@0: for (TInt i=0;iSettingsArray()[i]; sl@0: TUint32 ovId=ovTs.Key(); sl@0: sl@0: //find whether it exist in the core sl@0: TServerSetting* coreTs=aCoreRepository->GetSettings().Find(ovId); sl@0: //check whether in the overriding repository,the policy is individually specified policy sl@0: TInt ovIndividualPol=aOverrideRepository->SinglePolicyArray().Find(ovTs.AccessPolicy()); sl@0: if (coreTs) sl@0: { sl@0: //found in core, need to check the type is the same else Panic sl@0: if (coreTs->Type()!=ovTs.Type()) sl@0: { sl@0: #ifdef _DEBUG sl@0: RDebug::Printf("Illegal Setting Type Overriding"); sl@0: #endif sl@0: User::Leave(KErrMultiRofsTypeOverride); sl@0: } sl@0: OverrideSettingL(*coreTs,ovTs,aCoreRepository,EFalse,ovIndividualPol!=KErrNotFound); sl@0: } sl@0: else sl@0: { sl@0: //this is a newly defined setting sl@0: TServerSetting newTs(ovTs.Key()); sl@0: OverrideSettingL(newTs,ovTs,aCoreRepository,ETrue,ovIndividualPol!=KErrNotFound); sl@0: //finally insert into the RSettingsArray for this new setting sl@0: aCoreRepository->iSimRep->SettingsArray().OrderedInsertL(newTs); sl@0: } sl@0: } sl@0: sl@0: } sl@0: sl@0: /**Function on initialising a repository of multi ROFS files sl@0: aCoreInitialized indicate whether there is already existing keyspace file in the core layer sl@0: otherwise the first one in the rofs layer will be the core repository sl@0: */ sl@0: void CObservable::MergeMultiRofsL(TBool aCoreInitialized,CSharedRepository* aCoreRepository,const RArray& aOverridingFileList) sl@0: { sl@0: //load all the files and construct an array of CHeapRepository to merge content into it sl@0: TInt sortedCount=aOverridingFileList.Count(); sl@0: TFileName repFileName; sl@0: for (TInt i=0;iUid().iUid,&extPointer,rofsFlag.iFlag & 0xFF); sl@0: //only when the core is not initialized, the first item in the list now becomes the core sl@0: if (!aCoreInitialized && i==0) sl@0: { sl@0: if (isTxt) sl@0: { sl@0: CIniFileIn* iniFile; sl@0: TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName); sl@0: User::LeaveIfError(err); sl@0: err=aCoreRepository->ReloadContentL(*iniFile,ETrue); sl@0: User::LeaveIfError(err); sl@0: CleanupStack::PopAndDestroy(iniFile);//iniFile sl@0: } sl@0: else sl@0: { sl@0: aCoreRepository->iSimRep->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName); sl@0: } sl@0: } sl@0: else sl@0: { sl@0: CHeapRepository* repos=CHeapRepository::NewL(aCoreRepository->Uid()); sl@0: CleanupStack::PushL(repos); sl@0: sl@0: if (isTxt) sl@0: { sl@0: CIniFileIn* iniFile; sl@0: TInt err=CIniFileIn::NewLC(TServerResources::iFs,iniFile,repFileName); sl@0: User::LeaveIfError(err); sl@0: repos->ReloadContentL(*iniFile); sl@0: CleanupStack::PopAndDestroy(iniFile);//iniFile sl@0: } sl@0: else sl@0: { sl@0: TUint8 creVersion; sl@0: repos->CreateRepositoryFromCreFileL(TServerResources::iFs,repFileName,creVersion); sl@0: //need to check the CRE version in the overloading layer sl@0: if (creVersionSettingsArray().SetIsDefault(ETrue); sl@0: MergeRepositoryL(aCoreRepository,repos); sl@0: sl@0: CleanupStack::PopAndDestroy(repos); //repos sl@0: } sl@0: } sl@0: } sl@0: #endif sl@0: sl@0: TInt CObservable::CreateRepositoryL(CSharedRepository* aRepository, TCentRepLocation aLocation) sl@0: { sl@0: aRepository->GetSettings().SetIsDefault(aLocation!=EPersists); sl@0: TInt err(KErrNotFound); sl@0: sl@0: err = aRepository->CreateRepositoryFromCreFileL(aLocation); sl@0: if(err==KErrNotFound) sl@0: { sl@0: if (aLocation!=EPersists) sl@0: err = ReadIniFileL(aRepository,aLocation); sl@0: } sl@0: //for ROM might want to consider the possibility of multi rofs file sl@0: #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS sl@0: if (aLocation==ERom && iMultiRofsUidList.Count()!=0) sl@0: { sl@0: //if there is error and not because of non-existant we should return error immediately sl@0: //and if it is fine but the uid does not match one of the multirofsuidlsit this means that sl@0: //repository is not composed of multi file. sl@0: if (err==KErrNone || err==KErrNotFound) sl@0: { sl@0: TMultiRofsList find(aRepository->Uid()); sl@0: TLinearOrder sort_order(CompareUid); sl@0: TInt index=iMultiRofsUidList.FindInOrder(find,sort_order); sl@0: if (index==KErrNotFound) sl@0: return err; sl@0: //if the first layer has already got the exattrib=U we should leave with KErrMultiRofsIllegalRofs sl@0: if (err==KErrNotFound && index!=KErrNotFound) sl@0: User::Leave(KErrMultiRofsIllegalRofs); sl@0: //the list exist in one of the mappings stored earlier, get the name and construct them sl@0: TRAP(err,MergeMultiRofsL(err==KErrNone,aRepository,iMultiRofsUidList[index].iMountFlagList)); sl@0: if (err==KErrNoMemory) sl@0: User::LeaveNoMemory(); sl@0: } sl@0: } sl@0: #endif sl@0: return( err); sl@0: } sl@0: sl@0: /** sl@0: In order to create a repository this routine looks for a .cre or .txt file. sl@0: Txt and cre files can co-exist in install and ROM but not in persists location. sl@0: If a persists txt file exists, the first write to the repository will cause a sl@0: cre file to be created and the txt file to be deleted. sl@0: If both files exist in the same location, the .cre is picked up first. sl@0: If the .cre file is not found,a .txt file from the same location is tried. sl@0: Otherwise if the .cre file is corrupted,it tries a .cre file from a next location. sl@0: sl@0: Note: sl@0: If a cre file exists at a particular location, even if the cre file is corrupt a txt sl@0: file will not be searched for in the same location. sl@0: */ sl@0: sl@0: TInt CObservable::CreateRepositoryL(CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode) sl@0: { sl@0: TInt err(KErrNotFound); sl@0: sl@0: switch (aIniFileOpenMode) sl@0: { sl@0: case CIniFileIn::EAuto: sl@0: { sl@0: // Look in persists dir sl@0: err=CreateRepositoryL(aRepository, EPersists); sl@0: sl@0: if(err==KErrNone) sl@0: { sl@0: return err; sl@0: } sl@0: sl@0: // No persists file - look in ROM dir sl@0: // Do this before looking in the install dir, because if there is sl@0: // a ROM file, an install file and no persists file then this sl@0: // repository is being opened after a SW install but before the sl@0: // merge. In this case the install file shouldn't be opened sl@0: // until after the merge. sl@0: err=CreateRepositoryL(aRepository, ERom); sl@0: sl@0: if(err==KErrNone) sl@0: { sl@0: break; sl@0: } sl@0: else if(err==KErrNotFound) sl@0: { sl@0: // Look in install directory only if there was no ROM or persists file sl@0: err=CreateRepositoryL(aRepository, EInstall); sl@0: if(err==KErrNone) sl@0: { sl@0: TTime installFileTimeStamp=TServerResources::CentrepFileTimeStampL(aRepository->Uid(), EInstall); sl@0: aRepository->SetInstallTime(installFileTimeStamp); sl@0: } sl@0: } sl@0: break; sl@0: } sl@0: sl@0: case CIniFileIn::EInstallOnly: sl@0: { sl@0: err=CreateRepositoryL(aRepository, EInstall); sl@0: break; sl@0: } sl@0: sl@0: case CIniFileIn::ERomOnly: sl@0: { sl@0: err=CreateRepositoryL(aRepository, ERom); sl@0: break; sl@0: } sl@0: } sl@0: sl@0: return err; sl@0: } sl@0: sl@0: TInt CObservable::ReadSettingsL(CIniFileIn *aIniFile, CSharedRepository* aRep) sl@0: { sl@0: return aRep->ReloadContentL(*aIniFile, ETrue); sl@0: } sl@0: sl@0: void CObservable::LoadRepositoryLC(TUid aUid, TBool aFailIfNotFound, CSharedRepository*& aRepository, CIniFileIn::TIniFileOpenMode aIniFileOpenMode) sl@0: { sl@0: // Calculate the amount of memory this repository will take in the heap sl@0: // by checking the heap size before and after the internalization sl@0: RHeap& myHeap = User::Heap(); sl@0: TInt firstSize = myHeap.Size(); sl@0: TInt biggestBlock; sl@0: TInt firstAvail = myHeap.Available(biggestBlock); sl@0: sl@0: TRAPD(err, aRepository = CSharedRepository::NewL(aUid)); sl@0: #ifdef CACHE_OOM_TESTABILITY sl@0: if ((err!=KErrNone)&&!iTrapOOMOnOpen) sl@0: { sl@0: User::Leave(err); sl@0: } sl@0: #endif sl@0: if ((err!=KErrNone)&&TServerResources::iCacheManager->Enabled()) sl@0: { sl@0: // If cache enabled, try recovery by releasing the cache sl@0: TServerResources::iCacheManager->FlushCache(EFalse); sl@0: // retry sl@0: aRepository = CSharedRepository::NewL(aUid); sl@0: err = KErrNone; sl@0: } sl@0: User::LeaveIfError(err); sl@0: sl@0: // Now that we have enough memory for the object and constructed it properly sl@0: // we try to load it. We trap all errors, either from leaving functions or error code sl@0: // returning functions and unify them (in all cases only one of these codes will sl@0: // contain a valid value and the other will be 0, and for our purposes we treat sl@0: // all errors the same no matter if they're thrown or returned) sl@0: sl@0: TInt unifiedErrorCode; sl@0: TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode)); sl@0: sl@0: if (unifiedErrorCode!=KErrNone) sl@0: { sl@0: switch(unifiedErrorCode) sl@0: { sl@0: case KErrNoMemory: sl@0: { sl@0: if (TServerResources::iCacheManager->Enabled()) // cache enabled sl@0: { sl@0: #ifdef CACHE_OOM_TESTABILITY sl@0: if (!iTrapOOMOnOpen) sl@0: { sl@0: delete aRepository; sl@0: aRepository = NULL; sl@0: User::Leave(KErrNoMemory); sl@0: } sl@0: #endif sl@0: // Flush cache sl@0: TServerResources::iCacheManager->FlushCache(ETrue); sl@0: sl@0: firstSize = myHeap.Size(); sl@0: firstAvail = myHeap.Available(biggestBlock); sl@0: sl@0: //retry sl@0: TRAP_UNIFIED(unifiedErrorCode, CreateRepositoryL(aRepository, aIniFileOpenMode)); sl@0: } sl@0: } sl@0: break; sl@0: case KErrNotFound: sl@0: case KErrPathNotFound: sl@0: { sl@0: if (!aFailIfNotFound) // backup open sl@0: { sl@0: // override error condition and continue normally sl@0: unifiedErrorCode = KErrNone; sl@0: } sl@0: } sl@0: break; sl@0: } sl@0: } sl@0: // If unhandled, leave sl@0: if(unifiedErrorCode != KErrNone) sl@0: { sl@0: delete aRepository; sl@0: aRepository = NULL; sl@0: } sl@0: User::LeaveIfError(unifiedErrorCode); sl@0: CleanupStack::PushL(aRepository); sl@0: sl@0: // Otherwise, finalize calulations sl@0: TInt lastSize = myHeap.Size(); sl@0: TInt lastAvail = myHeap.Available(biggestBlock); sl@0: sl@0: TInt calcSize = (lastSize - lastAvail) - (firstSize - firstAvail); sl@0: // record repository size for cache algorithm purposes sl@0: aRepository->SetSize(calcSize); sl@0: } sl@0: sl@0: CSharedRepository* CObservable::AccessL(TUid aUid, TBool aFailIfNotFound) sl@0: { sl@0: CSharedRepository* rep = NULL; sl@0: sl@0: TInt i = FindOpenRepository(aUid); sl@0: if(i!=KErrNotFound) sl@0: { sl@0: rep = GetOpenRepository(i); sl@0: // repository still open, can safely call RestoreConsistencyL sl@0: rep->RestoreConsistencyL(); sl@0: } sl@0: else sl@0: { sl@0: // For memory usage testing purposes sl@0: RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid); sl@0: // Various error conditions are handled in this function sl@0: LoadRepositoryLC(aUid, aFailIfNotFound, rep, CIniFileIn::EAuto); sl@0: __CENTREP_TRACE1("CENTREP: Repository Load when opening repository %x", aUid.iUid); sl@0: // For memory usage testing purposes sl@0: RECORD_HEAP_SIZE(EMemLcnRepositoryOpen, aUid.iUid); sl@0: sl@0: AddOpenRepositoryL(rep); sl@0: sl@0: // We pop the rep here because if later call of TServerResources::AddOwnerIdLookupMapping fails of OOM sl@0: // the call of RemoveOpenRepository() will delete the repository before leave. sl@0: CleanupStack::Pop(rep); sl@0: sl@0: // Add owner mapping to list - Will fail if an entry already exists sl@0: // with this Repository UID but this doesn't matter sl@0: TUid owner = rep->Owner() ; sl@0: TInt err = TServerResources::AddOwnerIdLookupMapping(aUid.iUid, owner.iUid); sl@0: if (err == KErrNoMemory) sl@0: { sl@0: RemoveOpenRepository(rep); sl@0: User::Leave(err); sl@0: } sl@0: sl@0: //Find the location of the current transaction for this repository sl@0: const TInt offset (FindRepositoryInfo(aUid)); sl@0: if (offset >=0) //If there are no outstanding transactions sl@0: { sl@0: RefreshTransactorAccessPolicies(rep,offset); sl@0: } sl@0: } sl@0: sl@0: // re-start the timer sl@0: if (TServerResources::iCacheManager->Enabled()) sl@0: { sl@0: TServerResources::iCacheManager->StartEviction(rep); sl@0: } sl@0: sl@0: return rep; sl@0: } sl@0: sl@0: TInt CObservable::FindRepositoryInfo(TUid aUid) sl@0: { sl@0: TSharedRepositoryInfo info(aUid); sl@0: TLinearOrder infoSortOrder(CObservable::InfoSortOrder); sl@0: sl@0: return iRepositoryInfo.FindInOrder(&info, infoSortOrder); sl@0: } sl@0: sl@0: CObservable::TSharedRepositoryInfo* CObservable::SharedRepositoryInfo(TUid aUid) sl@0: { sl@0: TInt pos = FindRepositoryInfo(aUid); sl@0: return (pos!=KErrNotFound) ? iRepositoryInfo[pos] : NULL; sl@0: } sl@0: sl@0: void CObservable::CancelTransaction(CRepositoryTransactor& aTransactor,TUid aRepositoryUid) sl@0: { sl@0: if (aTransactor.IsInTransaction()) sl@0: { sl@0: ReleaseTransactionLock(aTransactor,aRepositoryUid); sl@0: CObservable::TSharedRepositoryInfo* shrepinfo =SharedRepositoryInfo(aRepositoryUid); sl@0: ASSERT(shrepinfo); sl@0: shrepinfo->iTransactors.Remove(aTransactor); sl@0: //Remove the link to the next transaction sl@0: aTransactor.iLink.iNext = NULL; sl@0: aTransactor.Deque(); sl@0: } sl@0: } sl@0: sl@0: /** Private helper method which releases any read/write locks held in the shared repository sl@0: by this transactor. Caller must set transactor's state or remove from queue as appropriate. sl@0: @param aTransactor transactor whose read/write locks are to be released. sl@0: @post Any read/write locks held by transactor are released. sl@0: */ sl@0: void CObservable::ReleaseTransactionLock(CRepositoryTransactor& aTransactor,TUid aRepositoryUid) sl@0: { sl@0: CObservable::TSharedRepositoryInfo* shrepinfo = SharedRepositoryInfo(aRepositoryUid); sl@0: ASSERT(shrepinfo); sl@0: if (aTransactor.IsInActiveConcurrentReadWriteTransaction()) sl@0: { sl@0: shrepinfo->iNumActiveConcurrentReadWriteTransactions--; sl@0: ASSERT(shrepinfo->iNumActiveConcurrentReadWriteTransactions >= 0); // sanity check sl@0: } sl@0: else if (aTransactor.IsInActiveReadTransaction()) sl@0: { sl@0: shrepinfo->iPessimisticTransactionLockCount--; sl@0: ASSERT(shrepinfo->iPessimisticTransactionLockCount >= 0); // sanity check sl@0: } sl@0: else if (aTransactor.IsInActiveExclusiveReadWriteTransaction()) sl@0: { sl@0: // can only be one exclusive read/write transaction active (lock value -1) sl@0: ASSERT(shrepinfo->iPessimisticTransactionLockCount == -1); sl@0: shrepinfo->iPessimisticTransactionLockCount = 0; sl@0: } sl@0: } sl@0: CObservable::TSharedRepositoryInfo::TSharedRepositoryInfo(TUid aUid) : sl@0: iRepositoryUid(aUid), iTransactors(_FOFF(CRepositoryTransactor, iLink)), sl@0: iPessimisticTransactionLockCount(0), iNumActiveConcurrentReadWriteTransactions(0) sl@0: { sl@0: } sl@0: sl@0: TInt CObservable::InfoSortOrder(const TSharedRepositoryInfo &aRepository1, const TSharedRepositoryInfo &aRepository2) sl@0: { sl@0: return CompareTUidValues(aRepository1.iRepositoryUid.iUid, aRepository2.iRepositoryUid.iUid); sl@0: } sl@0: sl@0: void CObservable::AddSharedRepositoryInfoL(TUid aUid) sl@0: { sl@0: TSharedRepositoryInfo* shinfo = new(ELeave) TSharedRepositoryInfo(aUid); sl@0: sl@0: TLinearOrder infoSortOrder(CObservable::InfoSortOrder); sl@0: // Inserts if not already in the array, otherwise returns KErrAlreadyExists, which we handle gracefully sl@0: TInt err = iRepositoryInfo.InsertInOrder(shinfo, infoSortOrder); sl@0: if (err==KErrAlreadyExists) sl@0: { sl@0: delete shinfo; sl@0: } sl@0: else sl@0: { sl@0: if (err!=KErrNone) sl@0: delete shinfo; sl@0: User::LeaveIfError(err); sl@0: } sl@0: } sl@0: sl@0: void CObservable::RemoveSharedRepositoryInfo(TUid aUid) sl@0: { sl@0: TInt pos = FindRepositoryInfo(aUid); sl@0: if (pos!=KErrNotFound) sl@0: { sl@0: delete iRepositoryInfo[pos]; sl@0: iRepositoryInfo.Remove(pos); sl@0: } sl@0: } sl@0: sl@0: sl@0: void CObservable::RefreshTransactorAccessPolicies(CSharedRepository* aRepository,const TInt offset) sl@0: { sl@0: TSglQueIter iter(iRepositoryInfo[offset]->iTransactors); sl@0: CRepositoryTransactor* t (iter); sl@0: sl@0: while (iter++ != NULL) sl@0: { sl@0: const TInt count = t->iTransactionSettings.Count(); sl@0: for (TInt i=0; iiTransactionSettings[i]; sl@0: t->iTransactionSettings[i].SetAccessPolicy(aRepository->GetFallbackAccessPolicy(temp.Key())); sl@0: //Correct the access policy pointer so that its pointing to the new valid location sl@0: } sl@0: t = iter; sl@0: } sl@0: }